From 18500e9dd136988669ae3919b7d48c1959a3a24e Mon Sep 17 00:00:00 2001 From: postables Date: Wed, 2 Sep 2020 23:21:28 -0700 Subject: [PATCH 1/3] add wip gopherjs compilation --- README.md | 9 + go.mod | 7 +- go.sum | 21 + ticket/js/doc.go | 2 + ticket/js/js.js | 44918 ++++++++++++++++++++++++++++++++++++++++++ ticket/js/js.js.map | 1 + ticket/js/main.go | 12 + 7 files changed, 44969 insertions(+), 1 deletion(-) create mode 100644 ticket/js/doc.go create mode 100644 ticket/js/js.js create mode 100644 ticket/js/js.js.map create mode 100644 ticket/js/main.go diff --git a/README.md b/README.md index 0abffda..09598cf 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,15 @@ After the VDF is solved the proof is then stored inside the ticket, and sent bac To see a usage example implementing vcaptcha in a HTTP server see the `examples` directory. +# javascript + +there is experimental support for building javascript bindings to vcaptcha, however it requires Go 1.12.x, if you don't have this you can run the following instructions: +``` +go get golang.org/dl/go1.12.16 +go1.12.16 download +export GOPHERJS_GOROOT="$(go1.12.16 env GOROOT)" # Also add this line to your .profile or equivalent. +``` + # future improvements * each captcha can be used by at most one session diff --git a/go.mod b/go.mod index 26332ed..d3970ab 100644 --- a/go.mod +++ b/go.mod @@ -3,9 +3,14 @@ module github.com/bonedaddy/vcaptcha go 1.14 require ( + github.com/davecgh/go-spew v1.1.1 // indirect github.com/dgrijalva/jwt-go v3.2.0+incompatible - github.com/go-chi/chi v4.1.2+incompatible // indirect + github.com/go-chi/chi v4.1.2+incompatible github.com/go-chi/jwtauth v4.0.4+incompatible + github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 + github.com/kr/pretty v0.1.0 // indirect github.com/segmentio/ksuid v1.0.3 github.com/stretchr/testify v1.6.1 + golang.org/x/net v0.0.0-20200822124328-c89045814202 // indirect + gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect ) diff --git a/go.sum b/go.sum index 5728449..c3ffcf4 100644 --- a/go.sum +++ b/go.sum @@ -1,11 +1,20 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM= github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= github.com/go-chi/chi v4.1.2+incompatible h1:fGFk2Gmi/YKXk0OmGfBh0WgmN3XB8lVnEyNz34tQRec= github.com/go-chi/chi v4.1.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ= github.com/go-chi/jwtauth v4.0.4+incompatible h1:LGIxg6YfvSBzxU2BljXbrzVc1fMlgqSKBQgKOGAVtPY= github.com/go-chi/jwtauth v4.0.4+incompatible/go.mod h1:Q5EIArY/QnD6BdS+IyDw7B2m6iNbnPxtfd6/BcmtWbs= +github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 h1:l5lAOZEym3oK3SQ2HBHWsJUfbNBiTXJDeW2QDxw9AQ0= +github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/segmentio/ksuid v1.0.3 h1:FoResxvleQwYiPAVKe1tMUlEirodZqlqglIuFsdDntY= @@ -13,7 +22,19 @@ github.com/segmentio/ksuid v1.0.3/go.mod h1:/XUiZBD3kVx5SmUOl55voK5yeAbBNNIed+2O github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up98WAHf3f/ulnJ62IyA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/ticket/js/doc.go b/ticket/js/doc.go new file mode 100644 index 0000000..3fae2f1 --- /dev/null +++ b/ticket/js/doc.go @@ -0,0 +1,2 @@ +// Package main provides javascript bindigns for vcaptcha using gopherjs +package main diff --git a/ticket/js/js.js b/ticket/js/js.js new file mode 100644 index 0000000..a1b46ed --- /dev/null +++ b/ticket/js/js.js @@ -0,0 +1,44918 @@ +"use strict"; +(function() { + +Error.stackTraceLimit = Infinity; + +var $global, $module; +if (typeof window !== "undefined") { /* web page */ + $global = window; +} else if (typeof self !== "undefined") { /* web worker */ + $global = self; +} else if (typeof global !== "undefined") { /* Node.js */ + $global = global; + $global.require = require; +} else { /* others (e.g. Nashorn) */ + $global = this; +} + +if ($global === undefined || $global.Array === undefined) { + throw new Error("no global object found"); +} +if (typeof module !== "undefined") { + $module = module; +} + +var $packages = {}, $idCounter = 0; +var $keys = function(m) { return m ? Object.keys(m) : []; }; +var $flushConsole = function() {}; +var $throwRuntimeError; /* set by package "runtime" */ +var $throwNilPointerError = function() { $throwRuntimeError("invalid memory address or nil pointer dereference"); }; +var $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); }; +var $makeFunc = function(fn) { return function() { return $externalize(fn(this, new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))), $emptyInterface); }; }; +var $unused = function(v) {}; + +var $mapArray = function(array, f) { + var newArray = new array.constructor(array.length); + for (var i = 0; i < array.length; i++) { + newArray[i] = f(array[i]); + } + return newArray; +}; + +var $methodVal = function(recv, name) { + var vals = recv.$methodVals || {}; + recv.$methodVals = vals; /* noop for primitives */ + var f = vals[name]; + if (f !== undefined) { + return f; + } + var method = recv[name]; + f = function() { + $stackDepthOffset--; + try { + return method.apply(recv, arguments); + } finally { + $stackDepthOffset++; + } + }; + vals[name] = f; + return f; +}; + +var $methodExpr = function(typ, name) { + var method = typ.prototype[name]; + if (method.$expr === undefined) { + method.$expr = function() { + $stackDepthOffset--; + try { + if (typ.wrapped) { + arguments[0] = new typ(arguments[0]); + } + return Function.call.apply(method, arguments); + } finally { + $stackDepthOffset++; + } + }; + } + return method.$expr; +}; + +var $ifaceMethodExprs = {}; +var $ifaceMethodExpr = function(name) { + var expr = $ifaceMethodExprs["$" + name]; + if (expr === undefined) { + expr = $ifaceMethodExprs["$" + name] = function() { + $stackDepthOffset--; + try { + return Function.call.apply(arguments[0][name], arguments); + } finally { + $stackDepthOffset++; + } + }; + } + return expr; +}; + +var $subslice = function(slice, low, high, max) { + if (high === undefined) { + high = slice.$length; + } + if (max === undefined) { + max = slice.$capacity; + } + if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) { + $throwRuntimeError("slice bounds out of range"); + } + if (slice === slice.constructor.nil) { + return slice; + } + var s = new slice.constructor(slice.$array); + s.$offset = slice.$offset + low; + s.$length = high - low; + s.$capacity = max - low; + return s; +}; + +var $substring = function(str, low, high) { + if (low < 0 || high < low || high > str.length) { + $throwRuntimeError("slice bounds out of range"); + } + return str.substring(low, high); +}; + +var $sliceToArray = function(slice) { + if (slice.$array.constructor !== Array) { + return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length); + } + return slice.$array.slice(slice.$offset, slice.$offset + slice.$length); +}; + +var $decodeRune = function(str, pos) { + var c0 = str.charCodeAt(pos); + + if (c0 < 0x80) { + return [c0, 1]; + } + + if (c0 !== c0 || c0 < 0xC0) { + return [0xFFFD, 1]; + } + + var c1 = str.charCodeAt(pos + 1); + if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) { + return [0xFFFD, 1]; + } + + if (c0 < 0xE0) { + var r = (c0 & 0x1F) << 6 | (c1 & 0x3F); + if (r <= 0x7F) { + return [0xFFFD, 1]; + } + return [r, 2]; + } + + var c2 = str.charCodeAt(pos + 2); + if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) { + return [0xFFFD, 1]; + } + + if (c0 < 0xF0) { + var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F); + if (r <= 0x7FF) { + return [0xFFFD, 1]; + } + if (0xD800 <= r && r <= 0xDFFF) { + return [0xFFFD, 1]; + } + return [r, 3]; + } + + var c3 = str.charCodeAt(pos + 3); + if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) { + return [0xFFFD, 1]; + } + + if (c0 < 0xF8) { + var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F); + if (r <= 0xFFFF || 0x10FFFF < r) { + return [0xFFFD, 1]; + } + return [r, 4]; + } + + return [0xFFFD, 1]; +}; + +var $encodeRune = function(r) { + if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) { + r = 0xFFFD; + } + if (r <= 0x7F) { + return String.fromCharCode(r); + } + if (r <= 0x7FF) { + return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F)); + } + if (r <= 0xFFFF) { + return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); + } + return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); +}; + +var $stringToBytes = function(str) { + var array = new Uint8Array(str.length); + for (var i = 0; i < str.length; i++) { + array[i] = str.charCodeAt(i); + } + return array; +}; + +var $bytesToString = function(slice) { + if (slice.$length === 0) { + return ""; + } + var str = ""; + for (var i = 0; i < slice.$length; i += 10000) { + str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000))); + } + return str; +}; + +var $stringToRunes = function(str) { + var array = new Int32Array(str.length); + var rune, j = 0; + for (var i = 0; i < str.length; i += rune[1], j++) { + rune = $decodeRune(str, i); + array[j] = rune[0]; + } + return array.subarray(0, j); +}; + +var $runesToString = function(slice) { + if (slice.$length === 0) { + return ""; + } + var str = ""; + for (var i = 0; i < slice.$length; i++) { + str += $encodeRune(slice.$array[slice.$offset + i]); + } + return str; +}; + +var $copyString = function(dst, src) { + var n = Math.min(src.length, dst.$length); + for (var i = 0; i < n; i++) { + dst.$array[dst.$offset + i] = src.charCodeAt(i); + } + return n; +}; + +var $copySlice = function(dst, src) { + var n = Math.min(src.$length, dst.$length); + $copyArray(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem); + return n; +}; + +var $copyArray = function(dst, src, dstOffset, srcOffset, n, elem) { + if (n === 0 || (dst === src && dstOffset === srcOffset)) { + return; + } + + if (src.subarray) { + dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset); + return; + } + + switch (elem.kind) { + case $kindArray: + case $kindStruct: + if (dst === src && dstOffset > srcOffset) { + for (var i = n - 1; i >= 0; i--) { + elem.copy(dst[dstOffset + i], src[srcOffset + i]); + } + return; + } + for (var i = 0; i < n; i++) { + elem.copy(dst[dstOffset + i], src[srcOffset + i]); + } + return; + } + + if (dst === src && dstOffset > srcOffset) { + for (var i = n - 1; i >= 0; i--) { + dst[dstOffset + i] = src[srcOffset + i]; + } + return; + } + for (var i = 0; i < n; i++) { + dst[dstOffset + i] = src[srcOffset + i]; + } +}; + +var $clone = function(src, type) { + var clone = type.zero(); + type.copy(clone, src); + return clone; +}; + +var $pointerOfStructConversion = function(obj, type) { + if(obj.$proxies === undefined) { + obj.$proxies = {}; + obj.$proxies[obj.constructor.string] = obj; + } + var proxy = obj.$proxies[type.string]; + if (proxy === undefined) { + var properties = {}; + for (var i = 0; i < type.elem.fields.length; i++) { + (function(fieldProp) { + properties[fieldProp] = { + get: function() { return obj[fieldProp]; }, + set: function(value) { obj[fieldProp] = value; } + }; + })(type.elem.fields[i].prop); + } + proxy = Object.create(type.prototype, properties); + proxy.$val = proxy; + obj.$proxies[type.string] = proxy; + proxy.$proxies = obj.$proxies; + } + return proxy; +}; + +var $append = function(slice) { + return $internalAppend(slice, arguments, 1, arguments.length - 1); +}; + +var $appendSlice = function(slice, toAppend) { + if (toAppend.constructor === String) { + var bytes = $stringToBytes(toAppend); + return $internalAppend(slice, bytes, 0, bytes.length); + } + return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length); +}; + +var $internalAppend = function(slice, array, offset, length) { + if (length === 0) { + return slice; + } + + var newArray = slice.$array; + var newOffset = slice.$offset; + var newLength = slice.$length + length; + var newCapacity = slice.$capacity; + + if (newLength > newCapacity) { + newOffset = 0; + newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4)); + + if (slice.$array.constructor === Array) { + newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length); + newArray.length = newCapacity; + var zero = slice.constructor.elem.zero; + for (var i = slice.$length; i < newCapacity; i++) { + newArray[i] = zero(); + } + } else { + newArray = new slice.$array.constructor(newCapacity); + newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length)); + } + } + + $copyArray(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem); + + var newSlice = new slice.constructor(newArray); + newSlice.$offset = newOffset; + newSlice.$length = newLength; + newSlice.$capacity = newCapacity; + return newSlice; +}; + +var $equal = function(a, b, type) { + if (type === $jsObjectPtr) { + return a === b; + } + switch (type.kind) { + case $kindComplex64: + case $kindComplex128: + return a.$real === b.$real && a.$imag === b.$imag; + case $kindInt64: + case $kindUint64: + return a.$high === b.$high && a.$low === b.$low; + case $kindArray: + if (a.length !== b.length) { + return false; + } + for (var i = 0; i < a.length; i++) { + if (!$equal(a[i], b[i], type.elem)) { + return false; + } + } + return true; + case $kindStruct: + for (var i = 0; i < type.fields.length; i++) { + var f = type.fields[i]; + if (!$equal(a[f.prop], b[f.prop], f.typ)) { + return false; + } + } + return true; + case $kindInterface: + return $interfaceIsEqual(a, b); + default: + return a === b; + } +}; + +var $interfaceIsEqual = function(a, b) { + if (a === $ifaceNil || b === $ifaceNil) { + return a === b; + } + if (a.constructor !== b.constructor) { + return false; + } + if (a.constructor === $jsObjectPtr) { + return a.object === b.object; + } + if (!a.constructor.comparable) { + $throwRuntimeError("comparing uncomparable type " + a.constructor.string); + } + return $equal(a.$val, b.$val, a.constructor); +}; + +var $min = Math.min; +var $mod = function(x, y) { return x % y; }; +var $parseInt = parseInt; +var $parseFloat = function(f) { + if (f !== undefined && f !== null && f.constructor === Number) { + return f; + } + return parseFloat(f); +}; + +var $froundBuf = new Float32Array(1); +var $fround = Math.fround || function(f) { + $froundBuf[0] = f; + return $froundBuf[0]; +}; + +var $imul = Math.imul || function(a, b) { + var ah = (a >>> 16) & 0xffff; + var al = a & 0xffff; + var bh = (b >>> 16) & 0xffff; + var bl = b & 0xffff; + return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) >> 0); +}; + +var $floatKey = function(f) { + if (f !== f) { + $idCounter++; + return "NaN$" + $idCounter; + } + return String(f); +}; + +var $flatten64 = function(x) { + return x.$high * 4294967296 + x.$low; +}; + +var $shiftLeft64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0); + } + if (y < 64) { + return new x.constructor(x.$low << (y - 32), 0); + } + return new x.constructor(0, 0); +}; + +var $shiftRightInt64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); + } + if (y < 64) { + return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0); + } + if (x.$high < 0) { + return new x.constructor(-1, 4294967295); + } + return new x.constructor(0, 0); +}; + +var $shiftRightUint64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); + } + if (y < 64) { + return new x.constructor(0, x.$high >>> (y - 32)); + } + return new x.constructor(0, 0); +}; + +var $mul64 = function(x, y) { + var high = 0, low = 0; + if ((y.$low & 1) !== 0) { + high = x.$high; + low = x.$low; + } + for (var i = 1; i < 32; i++) { + if ((y.$low & 1<>> (32 - i); + low += (x.$low << i) >>> 0; + } + } + for (var i = 0; i < 32; i++) { + if ((y.$high & 1< yHigh) || (xHigh === yHigh && xLow > yLow))) { + yHigh = (yHigh << 1 | yLow >>> 31) >>> 0; + yLow = (yLow << 1) >>> 0; + n++; + } + for (var i = 0; i <= n; i++) { + high = high << 1 | low >>> 31; + low = (low << 1) >>> 0; + if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) { + xHigh = xHigh - yHigh; + xLow = xLow - yLow; + if (xLow < 0) { + xHigh--; + xLow += 4294967296; + } + low++; + if (low === 4294967296) { + high++; + low = 0; + } + } + yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0; + yHigh = yHigh >>> 1; + } + + if (returnRemainder) { + return new x.constructor(xHigh * rs, xLow * rs); + } + return new x.constructor(high * s, low * s); +}; + +var $divComplex = function(n, d) { + var ninf = n.$real === Infinity || n.$real === -Infinity || n.$imag === Infinity || n.$imag === -Infinity; + var dinf = d.$real === Infinity || d.$real === -Infinity || d.$imag === Infinity || d.$imag === -Infinity; + var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag); + var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag); + if(nnan || dnan) { + return new n.constructor(NaN, NaN); + } + if (ninf && !dinf) { + return new n.constructor(Infinity, Infinity); + } + if (!ninf && dinf) { + return new n.constructor(0, 0); + } + if (d.$real === 0 && d.$imag === 0) { + if (n.$real === 0 && n.$imag === 0) { + return new n.constructor(NaN, NaN); + } + return new n.constructor(Infinity, Infinity); + } + var a = Math.abs(d.$real); + var b = Math.abs(d.$imag); + if (a <= b) { + var ratio = d.$real / d.$imag; + var denom = d.$real * ratio + d.$imag; + return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom); + } + var ratio = d.$imag / d.$real; + var denom = d.$imag * ratio + d.$real; + return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom); +}; + +var $kindBool = 1; +var $kindInt = 2; +var $kindInt8 = 3; +var $kindInt16 = 4; +var $kindInt32 = 5; +var $kindInt64 = 6; +var $kindUint = 7; +var $kindUint8 = 8; +var $kindUint16 = 9; +var $kindUint32 = 10; +var $kindUint64 = 11; +var $kindUintptr = 12; +var $kindFloat32 = 13; +var $kindFloat64 = 14; +var $kindComplex64 = 15; +var $kindComplex128 = 16; +var $kindArray = 17; +var $kindChan = 18; +var $kindFunc = 19; +var $kindInterface = 20; +var $kindMap = 21; +var $kindPtr = 22; +var $kindSlice = 23; +var $kindString = 24; +var $kindStruct = 25; +var $kindUnsafePointer = 26; + +var $methodSynthesizers = []; +var $addMethodSynthesizer = function(f) { + if ($methodSynthesizers === null) { + f(); + return; + } + $methodSynthesizers.push(f); +}; +var $synthesizeMethods = function() { + $methodSynthesizers.forEach(function(f) { f(); }); + $methodSynthesizers = null; +}; + +var $ifaceKeyFor = function(x) { + if (x === $ifaceNil) { + return 'nil'; + } + var c = x.constructor; + return c.string + '$' + c.keyFor(x.$val); +}; + +var $identity = function(x) { return x; }; + +var $typeIDCounter = 0; + +var $idKey = function(x) { + if (x.$id === undefined) { + $idCounter++; + x.$id = $idCounter; + } + return String(x.$id); +}; + +var $newType = function(size, kind, string, named, pkg, exported, constructor) { + var typ; + switch(kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindUnsafePointer: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = $identity; + break; + + case $kindString: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = function(x) { return "$" + x; }; + break; + + case $kindFloat32: + case $kindFloat64: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = function(x) { return $floatKey(x); }; + break; + + case $kindInt64: + typ = function(high, low) { + this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >> 0; + this.$low = low >>> 0; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; + break; + + case $kindUint64: + typ = function(high, low) { + this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >>> 0; + this.$low = low >>> 0; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; + break; + + case $kindComplex64: + typ = function(real, imag) { + this.$real = $fround(real); + this.$imag = $fround(imag); + this.$val = this; + }; + typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; + break; + + case $kindComplex128: + typ = function(real, imag) { + this.$real = real; + this.$imag = imag; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; + break; + + case $kindArray: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.ptr = $newType(4, $kindPtr, "*" + string, false, "", false, function(array) { + this.$get = function() { return array; }; + this.$set = function(v) { typ.copy(this, v); }; + this.$val = array; + }); + typ.init = function(elem, len) { + typ.elem = elem; + typ.len = len; + typ.comparable = elem.comparable; + typ.keyFor = function(x) { + return Array.prototype.join.call($mapArray(x, function(e) { + return String(elem.keyFor(e)).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); + }), "$"); + }; + typ.copy = function(dst, src) { + $copyArray(dst, src, 0, 0, src.length, elem); + }; + typ.ptr.init(typ); + Object.defineProperty(typ.ptr.nil, "nilCheck", { get: $throwNilPointerError }); + }; + break; + + case $kindChan: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = $idKey; + typ.init = function(elem, sendOnly, recvOnly) { + typ.elem = elem; + typ.sendOnly = sendOnly; + typ.recvOnly = recvOnly; + }; + break; + + case $kindFunc: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.init = function(params, results, variadic) { + typ.params = params; + typ.results = results; + typ.variadic = variadic; + typ.comparable = false; + }; + break; + + case $kindInterface: + typ = { implementedBy: {}, missingMethodFor: {} }; + typ.keyFor = $ifaceKeyFor; + typ.init = function(methods) { + typ.methods = methods; + methods.forEach(function(m) { + $ifaceNil[m.prop] = $throwNilPointerError; + }); + }; + break; + + case $kindMap: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.init = function(key, elem) { + typ.key = key; + typ.elem = elem; + typ.comparable = false; + }; + break; + + case $kindPtr: + typ = constructor || function(getter, setter, target) { + this.$get = getter; + this.$set = setter; + this.$target = target; + this.$val = this; + }; + typ.keyFor = $idKey; + typ.init = function(elem) { + typ.elem = elem; + typ.wrapped = (elem.kind === $kindArray); + typ.nil = new typ($throwNilPointerError, $throwNilPointerError); + }; + break; + + case $kindSlice: + typ = function(array) { + if (array.constructor !== typ.nativeArray) { + array = new typ.nativeArray(array); + } + this.$array = array; + this.$offset = 0; + this.$length = array.length; + this.$capacity = array.length; + this.$val = this; + }; + typ.init = function(elem) { + typ.elem = elem; + typ.comparable = false; + typ.nativeArray = $nativeArray(elem.kind); + typ.nil = new typ([]); + }; + break; + + case $kindStruct: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.ptr = $newType(4, $kindPtr, "*" + string, false, pkg, exported, constructor); + typ.ptr.elem = typ; + typ.ptr.prototype.$get = function() { return this; }; + typ.ptr.prototype.$set = function(v) { typ.copy(this, v); }; + typ.init = function(pkgPath, fields) { + typ.pkgPath = pkgPath; + typ.fields = fields; + fields.forEach(function(f) { + if (!f.typ.comparable) { + typ.comparable = false; + } + }); + typ.keyFor = function(x) { + var val = x.$val; + return $mapArray(fields, function(f) { + return String(f.typ.keyFor(val[f.prop])).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); + }).join("$"); + }; + typ.copy = function(dst, src) { + for (var i = 0; i < fields.length; i++) { + var f = fields[i]; + switch (f.typ.kind) { + case $kindArray: + case $kindStruct: + f.typ.copy(dst[f.prop], src[f.prop]); + continue; + default: + dst[f.prop] = src[f.prop]; + continue; + } + } + }; + /* nil value */ + var properties = {}; + fields.forEach(function(f) { + properties[f.prop] = { get: $throwNilPointerError, set: $throwNilPointerError }; + }); + typ.ptr.nil = Object.create(constructor.prototype, properties); + typ.ptr.nil.$val = typ.ptr.nil; + /* methods for embedded fields */ + $addMethodSynthesizer(function() { + var synthesizeMethod = function(target, m, f) { + if (target.prototype[m.prop] !== undefined) { return; } + target.prototype[m.prop] = function() { + var v = this.$val[f.prop]; + if (f.typ === $jsObjectPtr) { + v = new $jsObjectPtr(v); + } + if (v.$val === undefined) { + v = new f.typ(v); + } + return v[m.prop].apply(v, arguments); + }; + }; + fields.forEach(function(f) { + if (f.embedded) { + $methodSet(f.typ).forEach(function(m) { + synthesizeMethod(typ, m, f); + synthesizeMethod(typ.ptr, m, f); + }); + $methodSet($ptrType(f.typ)).forEach(function(m) { + synthesizeMethod(typ.ptr, m, f); + }); + } + }); + }); + }; + break; + + default: + $panic(new $String("invalid kind: " + kind)); + } + + switch (kind) { + case $kindBool: + case $kindMap: + typ.zero = function() { return false; }; + break; + + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8 : + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindUnsafePointer: + case $kindFloat32: + case $kindFloat64: + typ.zero = function() { return 0; }; + break; + + case $kindString: + typ.zero = function() { return ""; }; + break; + + case $kindInt64: + case $kindUint64: + case $kindComplex64: + case $kindComplex128: + var zero = new typ(0, 0); + typ.zero = function() { return zero; }; + break; + + case $kindPtr: + case $kindSlice: + typ.zero = function() { return typ.nil; }; + break; + + case $kindChan: + typ.zero = function() { return $chanNil; }; + break; + + case $kindFunc: + typ.zero = function() { return $throwNilPointerError; }; + break; + + case $kindInterface: + typ.zero = function() { return $ifaceNil; }; + break; + + case $kindArray: + typ.zero = function() { + var arrayClass = $nativeArray(typ.elem.kind); + if (arrayClass !== Array) { + return new arrayClass(typ.len); + } + var array = new Array(typ.len); + for (var i = 0; i < typ.len; i++) { + array[i] = typ.elem.zero(); + } + return array; + }; + break; + + case $kindStruct: + typ.zero = function() { return new typ.ptr(); }; + break; + + default: + $panic(new $String("invalid kind: " + kind)); + } + + typ.id = $typeIDCounter; + $typeIDCounter++; + typ.size = size; + typ.kind = kind; + typ.string = string; + typ.named = named; + typ.pkg = pkg; + typ.exported = exported; + typ.methods = []; + typ.methodSetCache = null; + typ.comparable = true; + return typ; +}; + +var $methodSet = function(typ) { + if (typ.methodSetCache !== null) { + return typ.methodSetCache; + } + var base = {}; + + var isPtr = (typ.kind === $kindPtr); + if (isPtr && typ.elem.kind === $kindInterface) { + typ.methodSetCache = []; + return []; + } + + var current = [{typ: isPtr ? typ.elem : typ, indirect: isPtr}]; + + var seen = {}; + + while (current.length > 0) { + var next = []; + var mset = []; + + current.forEach(function(e) { + if (seen[e.typ.string]) { + return; + } + seen[e.typ.string] = true; + + if (e.typ.named) { + mset = mset.concat(e.typ.methods); + if (e.indirect) { + mset = mset.concat($ptrType(e.typ).methods); + } + } + + switch (e.typ.kind) { + case $kindStruct: + e.typ.fields.forEach(function(f) { + if (f.embedded) { + var fTyp = f.typ; + var fIsPtr = (fTyp.kind === $kindPtr); + next.push({typ: fIsPtr ? fTyp.elem : fTyp, indirect: e.indirect || fIsPtr}); + } + }); + break; + + case $kindInterface: + mset = mset.concat(e.typ.methods); + break; + } + }); + + mset.forEach(function(m) { + if (base[m.name] === undefined) { + base[m.name] = m; + } + }); + + current = next; + } + + typ.methodSetCache = []; + Object.keys(base).sort().forEach(function(name) { + typ.methodSetCache.push(base[name]); + }); + return typ.methodSetCache; +}; + +var $Bool = $newType( 1, $kindBool, "bool", true, "", false, null); +var $Int = $newType( 4, $kindInt, "int", true, "", false, null); +var $Int8 = $newType( 1, $kindInt8, "int8", true, "", false, null); +var $Int16 = $newType( 2, $kindInt16, "int16", true, "", false, null); +var $Int32 = $newType( 4, $kindInt32, "int32", true, "", false, null); +var $Int64 = $newType( 8, $kindInt64, "int64", true, "", false, null); +var $Uint = $newType( 4, $kindUint, "uint", true, "", false, null); +var $Uint8 = $newType( 1, $kindUint8, "uint8", true, "", false, null); +var $Uint16 = $newType( 2, $kindUint16, "uint16", true, "", false, null); +var $Uint32 = $newType( 4, $kindUint32, "uint32", true, "", false, null); +var $Uint64 = $newType( 8, $kindUint64, "uint64", true, "", false, null); +var $Uintptr = $newType( 4, $kindUintptr, "uintptr", true, "", false, null); +var $Float32 = $newType( 4, $kindFloat32, "float32", true, "", false, null); +var $Float64 = $newType( 8, $kindFloat64, "float64", true, "", false, null); +var $Complex64 = $newType( 8, $kindComplex64, "complex64", true, "", false, null); +var $Complex128 = $newType(16, $kindComplex128, "complex128", true, "", false, null); +var $String = $newType( 8, $kindString, "string", true, "", false, null); +var $UnsafePointer = $newType( 4, $kindUnsafePointer, "unsafe.Pointer", true, "", false, null); + +var $nativeArray = function(elemKind) { + switch (elemKind) { + case $kindInt: + return Int32Array; + case $kindInt8: + return Int8Array; + case $kindInt16: + return Int16Array; + case $kindInt32: + return Int32Array; + case $kindUint: + return Uint32Array; + case $kindUint8: + return Uint8Array; + case $kindUint16: + return Uint16Array; + case $kindUint32: + return Uint32Array; + case $kindUintptr: + return Uint32Array; + case $kindFloat32: + return Float32Array; + case $kindFloat64: + return Float64Array; + default: + return Array; + } +}; +var $toNativeArray = function(elemKind, array) { + var nativeArray = $nativeArray(elemKind); + if (nativeArray === Array) { + return array; + } + return new nativeArray(array); +}; +var $arrayTypes = {}; +var $arrayType = function(elem, len) { + var typeKey = elem.id + "$" + len; + var typ = $arrayTypes[typeKey]; + if (typ === undefined) { + typ = $newType(12, $kindArray, "[" + len + "]" + elem.string, false, "", false, null); + $arrayTypes[typeKey] = typ; + typ.init(elem, len); + } + return typ; +}; + +var $chanType = function(elem, sendOnly, recvOnly) { + var string = (recvOnly ? "<-" : "") + "chan" + (sendOnly ? "<- " : " ") + elem.string; + var field = sendOnly ? "SendChan" : (recvOnly ? "RecvChan" : "Chan"); + var typ = elem[field]; + if (typ === undefined) { + typ = $newType(4, $kindChan, string, false, "", false, null); + elem[field] = typ; + typ.init(elem, sendOnly, recvOnly); + } + return typ; +}; +var $Chan = function(elem, capacity) { + if (capacity < 0 || capacity > 2147483647) { + $throwRuntimeError("makechan: size out of range"); + } + this.$elem = elem; + this.$capacity = capacity; + this.$buffer = []; + this.$sendQueue = []; + this.$recvQueue = []; + this.$closed = false; +}; +var $chanNil = new $Chan(null, 0); +$chanNil.$sendQueue = $chanNil.$recvQueue = { length: 0, push: function() {}, shift: function() { return undefined; }, indexOf: function() { return -1; } }; + +var $funcTypes = {}; +var $funcType = function(params, results, variadic) { + var typeKey = $mapArray(params, function(p) { return p.id; }).join(",") + "$" + $mapArray(results, function(r) { return r.id; }).join(",") + "$" + variadic; + var typ = $funcTypes[typeKey]; + if (typ === undefined) { + var paramTypes = $mapArray(params, function(p) { return p.string; }); + if (variadic) { + paramTypes[paramTypes.length - 1] = "..." + paramTypes[paramTypes.length - 1].substr(2); + } + var string = "func(" + paramTypes.join(", ") + ")"; + if (results.length === 1) { + string += " " + results[0].string; + } else if (results.length > 1) { + string += " (" + $mapArray(results, function(r) { return r.string; }).join(", ") + ")"; + } + typ = $newType(4, $kindFunc, string, false, "", false, null); + $funcTypes[typeKey] = typ; + typ.init(params, results, variadic); + } + return typ; +}; + +var $interfaceTypes = {}; +var $interfaceType = function(methods) { + var typeKey = $mapArray(methods, function(m) { return m.pkg + "," + m.name + "," + m.typ.id; }).join("$"); + var typ = $interfaceTypes[typeKey]; + if (typ === undefined) { + var string = "interface {}"; + if (methods.length !== 0) { + string = "interface { " + $mapArray(methods, function(m) { + return (m.pkg !== "" ? m.pkg + "." : "") + m.name + m.typ.string.substr(4); + }).join("; ") + " }"; + } + typ = $newType(8, $kindInterface, string, false, "", false, null); + $interfaceTypes[typeKey] = typ; + typ.init(methods); + } + return typ; +}; +var $emptyInterface = $interfaceType([]); +var $ifaceNil = {}; +var $error = $newType(8, $kindInterface, "error", true, "", false, null); +$error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]); + +var $mapTypes = {}; +var $mapType = function(key, elem) { + var typeKey = key.id + "$" + elem.id; + var typ = $mapTypes[typeKey]; + if (typ === undefined) { + typ = $newType(4, $kindMap, "map[" + key.string + "]" + elem.string, false, "", false, null); + $mapTypes[typeKey] = typ; + typ.init(key, elem); + } + return typ; +}; +var $makeMap = function(keyForFunc, entries) { + var m = {}; + for (var i = 0; i < entries.length; i++) { + var e = entries[i]; + m[keyForFunc(e.k)] = e; + } + return m; +}; + +var $ptrType = function(elem) { + var typ = elem.ptr; + if (typ === undefined) { + typ = $newType(4, $kindPtr, "*" + elem.string, false, "", elem.exported, null); + elem.ptr = typ; + typ.init(elem); + } + return typ; +}; + +var $newDataPointer = function(data, constructor) { + if (constructor.elem.kind === $kindStruct) { + return data; + } + return new constructor(function() { return data; }, function(v) { data = v; }); +}; + +var $indexPtr = function(array, index, constructor) { + array.$ptr = array.$ptr || {}; + return array.$ptr[index] || (array.$ptr[index] = new constructor(function() { return array[index]; }, function(v) { array[index] = v; })); +}; + +var $sliceType = function(elem) { + var typ = elem.slice; + if (typ === undefined) { + typ = $newType(12, $kindSlice, "[]" + elem.string, false, "", false, null); + elem.slice = typ; + typ.init(elem); + } + return typ; +}; +var $makeSlice = function(typ, length, capacity) { + capacity = capacity || length; + if (length < 0 || length > 2147483647) { + $throwRuntimeError("makeslice: len out of range"); + } + if (capacity < 0 || capacity < length || capacity > 2147483647) { + $throwRuntimeError("makeslice: cap out of range"); + } + var array = new typ.nativeArray(capacity); + if (typ.nativeArray === Array) { + for (var i = 0; i < capacity; i++) { + array[i] = typ.elem.zero(); + } + } + var slice = new typ(array); + slice.$length = length; + return slice; +}; + +var $structTypes = {}; +var $structType = function(pkgPath, fields) { + var typeKey = $mapArray(fields, function(f) { return f.name + "," + f.typ.id + "," + f.tag; }).join("$"); + var typ = $structTypes[typeKey]; + if (typ === undefined) { + var string = "struct { " + $mapArray(fields, function(f) { + return f.name + " " + f.typ.string + (f.tag !== "" ? (" \"" + f.tag.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"") : ""); + }).join("; ") + " }"; + if (fields.length === 0) { + string = "struct {}"; + } + typ = $newType(0, $kindStruct, string, false, "", false, function() { + this.$val = this; + for (var i = 0; i < fields.length; i++) { + var f = fields[i]; + var arg = arguments[i]; + this[f.prop] = arg !== undefined ? arg : f.typ.zero(); + } + }); + $structTypes[typeKey] = typ; + typ.init(pkgPath, fields); + } + return typ; +}; + +var $assertType = function(value, type, returnTuple) { + var isInterface = (type.kind === $kindInterface), ok, missingMethod = ""; + if (value === $ifaceNil) { + ok = false; + } else if (!isInterface) { + ok = value.constructor === type; + } else { + var valueTypeString = value.constructor.string; + ok = type.implementedBy[valueTypeString]; + if (ok === undefined) { + ok = true; + var valueMethodSet = $methodSet(value.constructor); + var interfaceMethods = type.methods; + for (var i = 0; i < interfaceMethods.length; i++) { + var tm = interfaceMethods[i]; + var found = false; + for (var j = 0; j < valueMethodSet.length; j++) { + var vm = valueMethodSet[j]; + if (vm.name === tm.name && vm.pkg === tm.pkg && vm.typ === tm.typ) { + found = true; + break; + } + } + if (!found) { + ok = false; + type.missingMethodFor[valueTypeString] = tm.name; + break; + } + } + type.implementedBy[valueTypeString] = ok; + } + if (!ok) { + missingMethod = type.missingMethodFor[valueTypeString]; + } + } + + if (!ok) { + if (returnTuple) { + return [type.zero(), false]; + } + $panic(new $packages["runtime"].TypeAssertionError.ptr( + $packages["runtime"]._type.ptr.nil, + (value === $ifaceNil ? $packages["runtime"]._type.ptr.nil : new $packages["runtime"]._type.ptr(value.constructor.string)), + new $packages["runtime"]._type.ptr(type.string), + missingMethod)); + } + + if (!isInterface) { + value = value.$val; + } + if (type === $jsObjectPtr) { + value = value.object; + } + return returnTuple ? [value, true] : value; +}; + +var $stackDepthOffset = 0; +var $getStackDepth = function() { + var err = new Error(); + if (err.stack === undefined) { + return undefined; + } + return $stackDepthOffset + err.stack.split("\n").length; +}; + +var $panicStackDepth = null, $panicValue; +var $callDeferred = function(deferred, jsErr, fromPanic) { + if (!fromPanic && deferred !== null && deferred.index >= $curGoroutine.deferStack.length) { + throw jsErr; + } + if (jsErr !== null) { + var newErr = null; + try { + $curGoroutine.deferStack.push(deferred); + $panic(new $jsErrorPtr(jsErr)); + } catch (err) { + newErr = err; + } + $curGoroutine.deferStack.pop(); + $callDeferred(deferred, newErr); + return; + } + if ($curGoroutine.asleep) { + return; + } + + $stackDepthOffset--; + var outerPanicStackDepth = $panicStackDepth; + var outerPanicValue = $panicValue; + + var localPanicValue = $curGoroutine.panicStack.pop(); + if (localPanicValue !== undefined) { + $panicStackDepth = $getStackDepth(); + $panicValue = localPanicValue; + } + + try { + while (true) { + if (deferred === null) { + deferred = $curGoroutine.deferStack[$curGoroutine.deferStack.length - 1]; + if (deferred === undefined) { + /* The panic reached the top of the stack. Clear it and throw it as a JavaScript error. */ + $panicStackDepth = null; + if (localPanicValue.Object instanceof Error) { + throw localPanicValue.Object; + } + var msg; + if (localPanicValue.constructor === $String) { + msg = localPanicValue.$val; + } else if (localPanicValue.Error !== undefined) { + msg = localPanicValue.Error(); + } else if (localPanicValue.String !== undefined) { + msg = localPanicValue.String(); + } else { + msg = localPanicValue; + } + throw new Error(msg); + } + } + var call = deferred.pop(); + if (call === undefined) { + $curGoroutine.deferStack.pop(); + if (localPanicValue !== undefined) { + deferred = null; + continue; + } + return; + } + var r = call[0].apply(call[2], call[1]); + if (r && r.$blk !== undefined) { + deferred.push([r.$blk, [], r]); + if (fromPanic) { + throw null; + } + return; + } + + if (localPanicValue !== undefined && $panicStackDepth === null) { + throw null; /* error was recovered */ + } + } + } finally { + if (localPanicValue !== undefined) { + if ($panicStackDepth !== null) { + $curGoroutine.panicStack.push(localPanicValue); + } + $panicStackDepth = outerPanicStackDepth; + $panicValue = outerPanicValue; + } + $stackDepthOffset++; + } +}; + +var $panic = function(value) { + $curGoroutine.panicStack.push(value); + $callDeferred(null, null, true); +}; +var $recover = function() { + if ($panicStackDepth === null || ($panicStackDepth !== undefined && $panicStackDepth !== $getStackDepth() - 2)) { + return $ifaceNil; + } + $panicStackDepth = null; + return $panicValue; +}; +var $throw = function(err) { throw err; }; + +var $noGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [] }; +var $curGoroutine = $noGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true; +var $mainFinished = false; +var $go = function(fun, args) { + $totalGoroutines++; + $awakeGoroutines++; + var $goroutine = function() { + try { + $curGoroutine = $goroutine; + var r = fun.apply(undefined, args); + if (r && r.$blk !== undefined) { + fun = function() { return r.$blk(); }; + args = []; + return; + } + $goroutine.exit = true; + } catch (err) { + if (!$goroutine.exit) { + throw err; + } + } finally { + $curGoroutine = $noGoroutine; + if ($goroutine.exit) { /* also set by runtime.Goexit() */ + $totalGoroutines--; + $goroutine.asleep = true; + } + if ($goroutine.asleep) { + $awakeGoroutines--; + if (!$mainFinished && $awakeGoroutines === 0 && $checkForDeadlock) { + console.error("fatal error: all goroutines are asleep - deadlock!"); + if ($global.process !== undefined) { + $global.process.exit(2); + } + } + } + } + }; + $goroutine.asleep = false; + $goroutine.exit = false; + $goroutine.deferStack = []; + $goroutine.panicStack = []; + $schedule($goroutine); +}; + +var $scheduled = []; +var $runScheduled = function() { + try { + var r; + while ((r = $scheduled.shift()) !== undefined) { + r(); + } + } finally { + if ($scheduled.length > 0) { + setTimeout($runScheduled, 0); + } + } +}; + +var $schedule = function(goroutine) { + if (goroutine.asleep) { + goroutine.asleep = false; + $awakeGoroutines++; + } + $scheduled.push(goroutine); + if ($curGoroutine === $noGoroutine) { + $runScheduled(); + } +}; + +var $setTimeout = function(f, t) { + $awakeGoroutines++; + return setTimeout(function() { + $awakeGoroutines--; + f(); + }, t); +}; + +var $block = function() { + if ($curGoroutine === $noGoroutine) { + $throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine"); + } + $curGoroutine.asleep = true; +}; + +var $send = function(chan, value) { + if (chan.$closed) { + $throwRuntimeError("send on closed channel"); + } + var queuedRecv = chan.$recvQueue.shift(); + if (queuedRecv !== undefined) { + queuedRecv([value, true]); + return; + } + if (chan.$buffer.length < chan.$capacity) { + chan.$buffer.push(value); + return; + } + + var thisGoroutine = $curGoroutine; + var closedDuringSend; + chan.$sendQueue.push(function(closed) { + closedDuringSend = closed; + $schedule(thisGoroutine); + return value; + }); + $block(); + return { + $blk: function() { + if (closedDuringSend) { + $throwRuntimeError("send on closed channel"); + } + } + }; +}; +var $recv = function(chan) { + var queuedSend = chan.$sendQueue.shift(); + if (queuedSend !== undefined) { + chan.$buffer.push(queuedSend(false)); + } + var bufferedValue = chan.$buffer.shift(); + if (bufferedValue !== undefined) { + return [bufferedValue, true]; + } + if (chan.$closed) { + return [chan.$elem.zero(), false]; + } + + var thisGoroutine = $curGoroutine; + var f = { $blk: function() { return this.value; } }; + var queueEntry = function(v) { + f.value = v; + $schedule(thisGoroutine); + }; + chan.$recvQueue.push(queueEntry); + $block(); + return f; +}; +var $close = function(chan) { + if (chan.$closed) { + $throwRuntimeError("close of closed channel"); + } + chan.$closed = true; + while (true) { + var queuedSend = chan.$sendQueue.shift(); + if (queuedSend === undefined) { + break; + } + queuedSend(true); /* will panic */ + } + while (true) { + var queuedRecv = chan.$recvQueue.shift(); + if (queuedRecv === undefined) { + break; + } + queuedRecv([chan.$elem.zero(), false]); + } +}; +var $select = function(comms) { + var ready = []; + var selection = -1; + for (var i = 0; i < comms.length; i++) { + var comm = comms[i]; + var chan = comm[0]; + switch (comm.length) { + case 0: /* default */ + selection = i; + break; + case 1: /* recv */ + if (chan.$sendQueue.length !== 0 || chan.$buffer.length !== 0 || chan.$closed) { + ready.push(i); + } + break; + case 2: /* send */ + if (chan.$closed) { + $throwRuntimeError("send on closed channel"); + } + if (chan.$recvQueue.length !== 0 || chan.$buffer.length < chan.$capacity) { + ready.push(i); + } + break; + } + } + + if (ready.length !== 0) { + selection = ready[Math.floor(Math.random() * ready.length)]; + } + if (selection !== -1) { + var comm = comms[selection]; + switch (comm.length) { + case 0: /* default */ + return [selection]; + case 1: /* recv */ + return [selection, $recv(comm[0])]; + case 2: /* send */ + $send(comm[0], comm[1]); + return [selection]; + } + } + + var entries = []; + var thisGoroutine = $curGoroutine; + var f = { $blk: function() { return this.selection; } }; + var removeFromQueues = function() { + for (var i = 0; i < entries.length; i++) { + var entry = entries[i]; + var queue = entry[0]; + var index = queue.indexOf(entry[1]); + if (index !== -1) { + queue.splice(index, 1); + } + } + }; + for (var i = 0; i < comms.length; i++) { + (function(i) { + var comm = comms[i]; + switch (comm.length) { + case 1: /* recv */ + var queueEntry = function(value) { + f.selection = [i, value]; + removeFromQueues(); + $schedule(thisGoroutine); + }; + entries.push([comm[0].$recvQueue, queueEntry]); + comm[0].$recvQueue.push(queueEntry); + break; + case 2: /* send */ + var queueEntry = function() { + if (comm[0].$closed) { + $throwRuntimeError("send on closed channel"); + } + f.selection = [i]; + removeFromQueues(); + $schedule(thisGoroutine); + return comm[1]; + }; + entries.push([comm[0].$sendQueue, queueEntry]); + comm[0].$sendQueue.push(queueEntry); + break; + } + })(i); + } + $block(); + return f; +}; + +var $jsObjectPtr, $jsErrorPtr; + +var $needsExternalization = function(t) { + switch (t.kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindFloat32: + case $kindFloat64: + return false; + default: + return t !== $jsObjectPtr; + } +}; + +var $externalize = function(v, t) { + if (t === $jsObjectPtr) { + return v; + } + switch (t.kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindFloat32: + case $kindFloat64: + return v; + case $kindInt64: + case $kindUint64: + return $flatten64(v); + case $kindArray: + if ($needsExternalization(t.elem)) { + return $mapArray(v, function(e) { return $externalize(e, t.elem); }); + } + return v; + case $kindFunc: + return $externalizeFunction(v, t, false); + case $kindInterface: + if (v === $ifaceNil) { + return null; + } + if (v.constructor === $jsObjectPtr) { + return v.$val.object; + } + return $externalize(v.$val, v.constructor); + case $kindMap: + var m = {}; + var keys = $keys(v); + for (var i = 0; i < keys.length; i++) { + var entry = v[keys[i]]; + m[$externalize(entry.k, t.key)] = $externalize(entry.v, t.elem); + } + return m; + case $kindPtr: + if (v === t.nil) { + return null; + } + return $externalize(v.$get(), t.elem); + case $kindSlice: + if ($needsExternalization(t.elem)) { + return $mapArray($sliceToArray(v), function(e) { return $externalize(e, t.elem); }); + } + return $sliceToArray(v); + case $kindString: + if ($isASCII(v)) { + return v; + } + var s = "", r; + for (var i = 0; i < v.length; i += r[1]) { + r = $decodeRune(v, i); + var c = r[0]; + if (c > 0xFFFF) { + var h = Math.floor((c - 0x10000) / 0x400) + 0xD800; + var l = (c - 0x10000) % 0x400 + 0xDC00; + s += String.fromCharCode(h, l); + continue; + } + s += String.fromCharCode(c); + } + return s; + case $kindStruct: + var timePkg = $packages["time"]; + if (timePkg !== undefined && v.constructor === timePkg.Time.ptr) { + var milli = $div64(v.UnixNano(), new $Int64(0, 1000000)); + return new Date($flatten64(milli)); + } + + var noJsObject = {}; + var searchJsObject = function(v, t) { + if (t === $jsObjectPtr) { + return v; + } + switch (t.kind) { + case $kindPtr: + if (v === t.nil) { + return noJsObject; + } + return searchJsObject(v.$get(), t.elem); + case $kindStruct: + var f = t.fields[0]; + return searchJsObject(v[f.prop], f.typ); + case $kindInterface: + return searchJsObject(v.$val, v.constructor); + default: + return noJsObject; + } + }; + var o = searchJsObject(v, t); + if (o !== noJsObject) { + return o; + } + + o = {}; + for (var i = 0; i < t.fields.length; i++) { + var f = t.fields[i]; + if (!f.exported) { + continue; + } + o[f.name] = $externalize(v[f.prop], f.typ); + } + return o; + } + $throwRuntimeError("cannot externalize " + t.string); +}; + +var $externalizeFunction = function(v, t, passThis) { + if (v === $throwNilPointerError) { + return null; + } + if (v.$externalizeWrapper === undefined) { + $checkForDeadlock = false; + v.$externalizeWrapper = function() { + var args = []; + for (var i = 0; i < t.params.length; i++) { + if (t.variadic && i === t.params.length - 1) { + var vt = t.params[i].elem, varargs = []; + for (var j = i; j < arguments.length; j++) { + varargs.push($internalize(arguments[j], vt)); + } + args.push(new (t.params[i])(varargs)); + break; + } + args.push($internalize(arguments[i], t.params[i])); + } + var result = v.apply(passThis ? this : undefined, args); + switch (t.results.length) { + case 0: + return; + case 1: + return $externalize(result, t.results[0]); + default: + for (var i = 0; i < t.results.length; i++) { + result[i] = $externalize(result[i], t.results[i]); + } + return result; + } + }; + } + return v.$externalizeWrapper; +}; + +var $internalize = function(v, t, recv) { + if (t === $jsObjectPtr) { + return v; + } + if (t === $jsObjectPtr.elem) { + $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); + } + if (v && v.__internal_object__ !== undefined) { + return $assertType(v.__internal_object__, t, false); + } + var timePkg = $packages["time"]; + if (timePkg !== undefined && t === timePkg.Time) { + if (!(v !== null && v !== undefined && v.constructor === Date)) { + $throwRuntimeError("cannot internalize time.Time from " + typeof v + ", must be Date"); + } + return timePkg.Unix(new $Int64(0, 0), new $Int64(0, v.getTime() * 1000000)); + } + switch (t.kind) { + case $kindBool: + return !!v; + case $kindInt: + return parseInt(v); + case $kindInt8: + return parseInt(v) << 24 >> 24; + case $kindInt16: + return parseInt(v) << 16 >> 16; + case $kindInt32: + return parseInt(v) >> 0; + case $kindUint: + return parseInt(v); + case $kindUint8: + return parseInt(v) << 24 >>> 24; + case $kindUint16: + return parseInt(v) << 16 >>> 16; + case $kindUint32: + case $kindUintptr: + return parseInt(v) >>> 0; + case $kindInt64: + case $kindUint64: + return new t(0, v); + case $kindFloat32: + case $kindFloat64: + return parseFloat(v); + case $kindArray: + if (v.length !== t.len) { + $throwRuntimeError("got array with wrong size from JavaScript native"); + } + return $mapArray(v, function(e) { return $internalize(e, t.elem); }); + case $kindFunc: + return function() { + var args = []; + for (var i = 0; i < t.params.length; i++) { + if (t.variadic && i === t.params.length - 1) { + var vt = t.params[i].elem, varargs = arguments[i]; + for (var j = 0; j < varargs.$length; j++) { + args.push($externalize(varargs.$array[varargs.$offset + j], vt)); + } + break; + } + args.push($externalize(arguments[i], t.params[i])); + } + var result = v.apply(recv, args); + switch (t.results.length) { + case 0: + return; + case 1: + return $internalize(result, t.results[0]); + default: + for (var i = 0; i < t.results.length; i++) { + result[i] = $internalize(result[i], t.results[i]); + } + return result; + } + }; + case $kindInterface: + if (t.methods.length !== 0) { + $throwRuntimeError("cannot internalize " + t.string); + } + if (v === null) { + return $ifaceNil; + } + if (v === undefined) { + return new $jsObjectPtr(undefined); + } + switch (v.constructor) { + case Int8Array: + return new ($sliceType($Int8))(v); + case Int16Array: + return new ($sliceType($Int16))(v); + case Int32Array: + return new ($sliceType($Int))(v); + case Uint8Array: + return new ($sliceType($Uint8))(v); + case Uint16Array: + return new ($sliceType($Uint16))(v); + case Uint32Array: + return new ($sliceType($Uint))(v); + case Float32Array: + return new ($sliceType($Float32))(v); + case Float64Array: + return new ($sliceType($Float64))(v); + case Array: + return $internalize(v, $sliceType($emptyInterface)); + case Boolean: + return new $Bool(!!v); + case Date: + if (timePkg === undefined) { + /* time package is not present, internalize as &js.Object{Date} so it can be externalized into original Date. */ + return new $jsObjectPtr(v); + } + return new timePkg.Time($internalize(v, timePkg.Time)); + case Function: + var funcType = $funcType([$sliceType($emptyInterface)], [$jsObjectPtr], true); + return new funcType($internalize(v, funcType)); + case Number: + return new $Float64(parseFloat(v)); + case String: + return new $String($internalize(v, $String)); + default: + if ($global.Node && v instanceof $global.Node) { + return new $jsObjectPtr(v); + } + var mapType = $mapType($String, $emptyInterface); + return new mapType($internalize(v, mapType)); + } + case $kindMap: + var m = {}; + var keys = $keys(v); + for (var i = 0; i < keys.length; i++) { + var k = $internalize(keys[i], t.key); + m[t.key.keyFor(k)] = { k: k, v: $internalize(v[keys[i]], t.elem) }; + } + return m; + case $kindPtr: + if (t.elem.kind === $kindStruct) { + return $internalize(v, t.elem); + } + case $kindSlice: + return new t($mapArray(v, function(e) { return $internalize(e, t.elem); })); + case $kindString: + v = String(v); + if ($isASCII(v)) { + return v; + } + var s = ""; + var i = 0; + while (i < v.length) { + var h = v.charCodeAt(i); + if (0xD800 <= h && h <= 0xDBFF) { + var l = v.charCodeAt(i + 1); + var c = (h - 0xD800) * 0x400 + l - 0xDC00 + 0x10000; + s += $encodeRune(c); + i += 2; + continue; + } + s += $encodeRune(h); + i++; + } + return s; + case $kindStruct: + var noJsObject = {}; + var searchJsObject = function(t) { + if (t === $jsObjectPtr) { + return v; + } + if (t === $jsObjectPtr.elem) { + $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); + } + switch (t.kind) { + case $kindPtr: + return searchJsObject(t.elem); + case $kindStruct: + var f = t.fields[0]; + var o = searchJsObject(f.typ); + if (o !== noJsObject) { + var n = new t.ptr(); + n[f.prop] = o; + return n; + } + return noJsObject; + default: + return noJsObject; + } + }; + var o = searchJsObject(t); + if (o !== noJsObject) { + return o; + } + } + $throwRuntimeError("cannot internalize " + t.string); +}; + +/* $isASCII reports whether string s contains only ASCII characters. */ +var $isASCII = function(s) { + for (var i = 0; i < s.length; i++) { + if (s.charCodeAt(i) >= 128) { + return false; + } + } + return true; +}; + +$packages["github.com/gopherjs/gopherjs/js"] = (function() { + var $pkg = {}, $init, Object, Error, sliceType, ptrType, ptrType$1, MakeFunc, init; + Object = $pkg.Object = $newType(0, $kindStruct, "js.Object", true, "github.com/gopherjs/gopherjs/js", true, function(object_) { + this.$val = this; + if (arguments.length === 0) { + this.object = null; + return; + } + this.object = object_; + }); + Error = $pkg.Error = $newType(0, $kindStruct, "js.Error", true, "github.com/gopherjs/gopherjs/js", true, function(Object_) { + this.$val = this; + if (arguments.length === 0) { + this.Object = null; + return; + } + this.Object = Object_; + }); + sliceType = $sliceType($emptyInterface); + ptrType = $ptrType(Object); + ptrType$1 = $ptrType(Error); + Object.ptr.prototype.Get = function(key) { + var key, o; + o = this; + return o.object[$externalize(key, $String)]; + }; + Object.prototype.Get = function(key) { return this.$val.Get(key); }; + Object.ptr.prototype.Set = function(key, value) { + var key, o, value; + o = this; + o.object[$externalize(key, $String)] = $externalize(value, $emptyInterface); + }; + Object.prototype.Set = function(key, value) { return this.$val.Set(key, value); }; + Object.ptr.prototype.Delete = function(key) { + var key, o; + o = this; + delete o.object[$externalize(key, $String)]; + }; + Object.prototype.Delete = function(key) { return this.$val.Delete(key); }; + Object.ptr.prototype.Length = function() { + var o; + o = this; + return $parseInt(o.object.length); + }; + Object.prototype.Length = function() { return this.$val.Length(); }; + Object.ptr.prototype.Index = function(i) { + var i, o; + o = this; + return o.object[i]; + }; + Object.prototype.Index = function(i) { return this.$val.Index(i); }; + Object.ptr.prototype.SetIndex = function(i, value) { + var i, o, value; + o = this; + o.object[i] = $externalize(value, $emptyInterface); + }; + Object.prototype.SetIndex = function(i, value) { return this.$val.SetIndex(i, value); }; + Object.ptr.prototype.Call = function(name, args) { + var args, name, o, obj; + o = this; + return (obj = o.object, obj[$externalize(name, $String)].apply(obj, $externalize(args, sliceType))); + }; + Object.prototype.Call = function(name, args) { return this.$val.Call(name, args); }; + Object.ptr.prototype.Invoke = function(args) { + var args, o; + o = this; + return o.object.apply(undefined, $externalize(args, sliceType)); + }; + Object.prototype.Invoke = function(args) { return this.$val.Invoke(args); }; + Object.ptr.prototype.New = function(args) { + var args, o; + o = this; + return new ($global.Function.prototype.bind.apply(o.object, [undefined].concat($externalize(args, sliceType)))); + }; + Object.prototype.New = function(args) { return this.$val.New(args); }; + Object.ptr.prototype.Bool = function() { + var o; + o = this; + return !!(o.object); + }; + Object.prototype.Bool = function() { return this.$val.Bool(); }; + Object.ptr.prototype.String = function() { + var o; + o = this; + return $internalize(o.object, $String); + }; + Object.prototype.String = function() { return this.$val.String(); }; + Object.ptr.prototype.Int = function() { + var o; + o = this; + return $parseInt(o.object) >> 0; + }; + Object.prototype.Int = function() { return this.$val.Int(); }; + Object.ptr.prototype.Int64 = function() { + var o; + o = this; + return $internalize(o.object, $Int64); + }; + Object.prototype.Int64 = function() { return this.$val.Int64(); }; + Object.ptr.prototype.Uint64 = function() { + var o; + o = this; + return $internalize(o.object, $Uint64); + }; + Object.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Object.ptr.prototype.Float = function() { + var o; + o = this; + return $parseFloat(o.object); + }; + Object.prototype.Float = function() { return this.$val.Float(); }; + Object.ptr.prototype.Interface = function() { + var o; + o = this; + return $internalize(o.object, $emptyInterface); + }; + Object.prototype.Interface = function() { return this.$val.Interface(); }; + Object.ptr.prototype.Unsafe = function() { + var o; + o = this; + return o.object; + }; + Object.prototype.Unsafe = function() { return this.$val.Unsafe(); }; + Error.ptr.prototype.Error = function() { + var err; + err = this; + return "JavaScript error: " + $internalize(err.Object.message, $String); + }; + Error.prototype.Error = function() { return this.$val.Error(); }; + Error.ptr.prototype.Stack = function() { + var err; + err = this; + return $internalize(err.Object.stack, $String); + }; + Error.prototype.Stack = function() { return this.$val.Stack(); }; + MakeFunc = function(fn) { + var fn; + return $makeFunc(fn); + }; + $pkg.MakeFunc = MakeFunc; + init = function() { + var e; + e = new Error.ptr(null); + $unused(e); + }; + ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $emptyInterface], [], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [ptrType], false)}, {prop: "SetIndex", name: "SetIndex", pkg: "", typ: $funcType([$Int, $emptyInterface], [], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([$String, sliceType], [ptrType], true)}, {prop: "Invoke", name: "Invoke", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "New", name: "New", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Unsafe", name: "Unsafe", pkg: "", typ: $funcType([], [$Uintptr], false)}]; + ptrType$1.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Stack", name: "Stack", pkg: "", typ: $funcType([], [$String], false)}]; + Object.init("github.com/gopherjs/gopherjs/js", [{prop: "object", name: "object", embedded: false, exported: false, typ: ptrType, tag: ""}]); + Error.init("", [{prop: "Object", name: "Object", embedded: true, exported: true, typ: ptrType, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/cpu"] = (function() { + var $pkg = {}, $init; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/bytealg"] = (function() { + var $pkg = {}, $init, cpu, Index, Cutover, IndexByteString; + cpu = $packages["internal/cpu"]; + Index = function(a, b) { + var a, b; + $panic(new $String("unimplemented")); + }; + $pkg.Index = Index; + Cutover = function(n) { + var n; + $panic(new $String("unimplemented")); + }; + $pkg.Cutover = Cutover; + IndexByteString = function(s, c) { + var c, i, s; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (s.charCodeAt(i) === c) { + return i; + } + i = i + (1) >> 0; + } + return -1; + }; + $pkg.IndexByteString = IndexByteString; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = cpu.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.MaxLen = 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["runtime/internal/sys"] = (function() { + var $pkg = {}, $init; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["runtime"] = (function() { + var $pkg = {}, $init, js, bytealg, sys, _type, Func, TypeAssertionError, errorString, ptrType, ptrType$1, structType, ptrType$4, init, GOROOT, Caller, Goexit, SetFinalizer, FuncForPC, KeepAlive, throw$1; + js = $packages["github.com/gopherjs/gopherjs/js"]; + bytealg = $packages["internal/bytealg"]; + sys = $packages["runtime/internal/sys"]; + _type = $pkg._type = $newType(0, $kindStruct, "runtime._type", true, "runtime", false, function(str_) { + this.$val = this; + if (arguments.length === 0) { + this.str = ""; + return; + } + this.str = str_; + }); + Func = $pkg.Func = $newType(0, $kindStruct, "runtime.Func", true, "runtime", true, function(opaque_) { + this.$val = this; + if (arguments.length === 0) { + this.opaque = new structType.ptr(); + return; + } + this.opaque = opaque_; + }); + TypeAssertionError = $pkg.TypeAssertionError = $newType(0, $kindStruct, "runtime.TypeAssertionError", true, "runtime", true, function(_interface_, concrete_, asserted_, missingMethod_) { + this.$val = this; + if (arguments.length === 0) { + this._interface = ptrType.nil; + this.concrete = ptrType.nil; + this.asserted = ptrType.nil; + this.missingMethod = ""; + return; + } + this._interface = _interface_; + this.concrete = concrete_; + this.asserted = asserted_; + this.missingMethod = missingMethod_; + }); + errorString = $pkg.errorString = $newType(8, $kindString, "runtime.errorString", true, "runtime", false, null); + ptrType = $ptrType(_type); + ptrType$1 = $ptrType(Func); + structType = $structType("", []); + ptrType$4 = $ptrType(TypeAssertionError); + _type.ptr.prototype.string = function() { + var t; + t = this; + return t.str; + }; + _type.prototype.string = function() { return this.$val.string(); }; + _type.ptr.prototype.pkgpath = function() { + var t; + t = this; + return ""; + }; + _type.prototype.pkgpath = function() { return this.$val.pkgpath(); }; + init = function() { + var e, jsPkg; + jsPkg = $packages[$externalize("github.com/gopherjs/gopherjs/js", $String)]; + $jsObjectPtr = jsPkg.Object.ptr; + $jsErrorPtr = jsPkg.Error.ptr; + $throwRuntimeError = throw$1; + e = $ifaceNil; + e = new TypeAssertionError.ptr(ptrType.nil, ptrType.nil, ptrType.nil, ""); + $unused(e); + }; + GOROOT = function() { + var process, v, v$1; + process = $global.process; + if (process === undefined) { + return "/"; + } + v = process.env.GOPHERJS_GOROOT; + if (!(v === undefined)) { + return $internalize(v, $String); + } else { + v$1 = process.env.GOROOT; + if (!(v$1 === undefined)) { + return $internalize(v$1, $String); + } + } + return "/usr/local/go"; + }; + $pkg.GOROOT = GOROOT; + Caller = function(skip) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, file, info, line, ok, parts, pc, skip; + pc = 0; + file = ""; + line = 0; + ok = false; + info = new ($global.Error)().stack.split($externalize("\n", $String))[(skip + 2 >> 0)]; + if (info === undefined) { + _tmp = 0; + _tmp$1 = ""; + _tmp$2 = 0; + _tmp$3 = false; + pc = _tmp; + file = _tmp$1; + line = _tmp$2; + ok = _tmp$3; + return [pc, file, line, ok]; + } + parts = info.substring(($parseInt(info.indexOf($externalize("(", $String))) >> 0) + 1 >> 0, $parseInt(info.indexOf($externalize(")", $String))) >> 0).split($externalize(":", $String)); + _tmp$4 = 0; + _tmp$5 = $internalize(parts[0], $String); + _tmp$6 = $parseInt(parts[1]) >> 0; + _tmp$7 = true; + pc = _tmp$4; + file = _tmp$5; + line = _tmp$6; + ok = _tmp$7; + return [pc, file, line, ok]; + }; + $pkg.Caller = Caller; + Goexit = function() { + $curGoroutine.exit = $externalize(true, $Bool); + $throw(null); + }; + $pkg.Goexit = Goexit; + SetFinalizer = function(x, f) { + var f, x; + }; + $pkg.SetFinalizer = SetFinalizer; + Func.ptr.prototype.Entry = function() { + return 0; + }; + Func.prototype.Entry = function() { return this.$val.Entry(); }; + Func.ptr.prototype.FileLine = function(pc) { + var _tmp, _tmp$1, file, line, pc; + file = ""; + line = 0; + _tmp = ""; + _tmp$1 = 0; + file = _tmp; + line = _tmp$1; + return [file, line]; + }; + Func.prototype.FileLine = function(pc) { return this.$val.FileLine(pc); }; + Func.ptr.prototype.Name = function() { + return ""; + }; + Func.prototype.Name = function() { return this.$val.Name(); }; + FuncForPC = function(pc) { + var pc; + return ptrType$1.nil; + }; + $pkg.FuncForPC = FuncForPC; + KeepAlive = function(param) { + var param; + }; + $pkg.KeepAlive = KeepAlive; + throw$1 = function(s) { + var s; + $panic(new errorString((s))); + }; + TypeAssertionError.ptr.prototype.RuntimeError = function() { + }; + TypeAssertionError.prototype.RuntimeError = function() { return this.$val.RuntimeError(); }; + TypeAssertionError.ptr.prototype.Error = function() { + var as, cs, e, inter, msg; + e = this; + inter = "interface"; + if (!(e._interface === ptrType.nil)) { + inter = e._interface.string(); + } + as = e.asserted.string(); + if (e.concrete === ptrType.nil) { + return "interface conversion: " + inter + " is nil, not " + as; + } + cs = e.concrete.string(); + if (e.missingMethod === "") { + msg = "interface conversion: " + inter + " is " + cs + ", not " + as; + if (cs === as) { + if (!(e.concrete.pkgpath() === e.asserted.pkgpath())) { + msg = msg + (" (types from different packages)"); + } else { + msg = msg + (" (types from different scopes)"); + } + } + return msg; + } + return "interface conversion: " + cs + " is not " + as + ": missing method " + e.missingMethod; + }; + TypeAssertionError.prototype.Error = function() { return this.$val.Error(); }; + errorString.prototype.RuntimeError = function() { + var e; + e = this.$val; + }; + $ptrType(errorString).prototype.RuntimeError = function() { return new errorString(this.$get()).RuntimeError(); }; + errorString.prototype.Error = function() { + var e; + e = this.$val; + return "runtime error: " + (e); + }; + $ptrType(errorString).prototype.Error = function() { return new errorString(this.$get()).Error(); }; + ptrType.methods = [{prop: "string", name: "string", pkg: "runtime", typ: $funcType([], [$String], false)}, {prop: "pkgpath", name: "pkgpath", pkg: "runtime", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "Entry", name: "Entry", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "FileLine", name: "FileLine", pkg: "", typ: $funcType([$Uintptr], [$String, $Int], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$4.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + errorString.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + _type.init("runtime", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); + Func.init("runtime", [{prop: "opaque", name: "opaque", embedded: false, exported: false, typ: structType, tag: ""}]); + TypeAssertionError.init("runtime", [{prop: "_interface", name: "_interface", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "concrete", name: "concrete", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "asserted", name: "asserted", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "missingMethod", name: "missingMethod", embedded: false, exported: false, typ: $String, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sys.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["errors"] = (function() { + var $pkg = {}, $init, errorString, ptrType, New; + errorString = $pkg.errorString = $newType(0, $kindStruct, "errors.errorString", true, "errors", false, function(s_) { + this.$val = this; + if (arguments.length === 0) { + this.s = ""; + return; + } + this.s = s_; + }); + ptrType = $ptrType(errorString); + New = function(text) { + var text; + return new errorString.ptr(text); + }; + $pkg.New = New; + errorString.ptr.prototype.Error = function() { + var e; + e = this; + return e.s; + }; + errorString.prototype.Error = function() { return this.$val.Error(); }; + ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + errorString.init("errors", [{prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/race"] = (function() { + var $pkg = {}, $init, Acquire, Release, ReleaseMerge, Disable, Enable, ReadRange, WriteRange; + Acquire = function(addr) { + var addr; + }; + $pkg.Acquire = Acquire; + Release = function(addr) { + var addr; + }; + $pkg.Release = Release; + ReleaseMerge = function(addr) { + var addr; + }; + $pkg.ReleaseMerge = ReleaseMerge; + Disable = function() { + }; + $pkg.Disable = Disable; + Enable = function() { + }; + $pkg.Enable = Enable; + ReadRange = function(addr, len) { + var addr, len; + }; + $pkg.ReadRange = ReadRange; + WriteRange = function(addr, len) { + var addr, len; + }; + $pkg.WriteRange = WriteRange; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["sync/atomic"] = (function() { + var $pkg = {}, $init, js, Value, ptrType, CompareAndSwapInt32, CompareAndSwapUint64, AddInt32, LoadInt32, LoadUint64, StoreInt32, StoreUint32; + js = $packages["github.com/gopherjs/gopherjs/js"]; + Value = $pkg.Value = $newType(0, $kindStruct, "atomic.Value", true, "sync/atomic", true, function(v_) { + this.$val = this; + if (arguments.length === 0) { + this.v = $ifaceNil; + return; + } + this.v = v_; + }); + ptrType = $ptrType(Value); + CompareAndSwapInt32 = function(addr, old, new$1) { + var addr, new$1, old; + if (addr.$get() === old) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapInt32 = CompareAndSwapInt32; + CompareAndSwapUint64 = function(addr, old, new$1) { + var addr, new$1, old, x; + if ((x = addr.$get(), (x.$high === old.$high && x.$low === old.$low))) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapUint64 = CompareAndSwapUint64; + AddInt32 = function(addr, delta) { + var addr, delta, new$1; + new$1 = addr.$get() + delta >> 0; + addr.$set(new$1); + return new$1; + }; + $pkg.AddInt32 = AddInt32; + LoadInt32 = function(addr) { + var addr; + return addr.$get(); + }; + $pkg.LoadInt32 = LoadInt32; + LoadUint64 = function(addr) { + var addr; + return addr.$get(); + }; + $pkg.LoadUint64 = LoadUint64; + StoreInt32 = function(addr, val) { + var addr, val; + addr.$set(val); + }; + $pkg.StoreInt32 = StoreInt32; + StoreUint32 = function(addr, val) { + var addr, val; + addr.$set(val); + }; + $pkg.StoreUint32 = StoreUint32; + Value.ptr.prototype.Load = function() { + var v, x; + x = $ifaceNil; + v = this; + x = v.v; + return x; + }; + Value.prototype.Load = function() { return this.$val.Load(); }; + Value.ptr.prototype.Store = function(x) { + var v, x; + v = this; + if ($interfaceIsEqual(x, $ifaceNil)) { + $panic(new $String("sync/atomic: store of nil value into Value")); + } + if (!($interfaceIsEqual(v.v, $ifaceNil)) && !(x.constructor === v.v.constructor)) { + $panic(new $String("sync/atomic: store of inconsistently typed value into Value")); + } + v.v = x; + }; + Value.prototype.Store = function(x) { return this.$val.Store(x); }; + ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface], [], false)}]; + Value.init("sync/atomic", [{prop: "v", name: "v", embedded: false, exported: false, typ: $emptyInterface, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["sync"] = (function() { + var $pkg = {}, $init, js, race, runtime, atomic, Pool, Mutex, Locker, poolLocalInternal, poolLocal, notifyList, RWMutex, rlocker, ptrType, sliceType, ptrType$1, chanType, sliceType$1, ptrType$6, ptrType$7, sliceType$4, ptrType$8, ptrType$9, funcType, ptrType$16, arrayType$2, semWaiters, semAwoken, expunged, allPools, runtime_registerPoolCleanup, runtime_SemacquireMutex, runtime_Semrelease, runtime_notifyListCheck, runtime_canSpin, runtime_nanotime, throw$1, poolCleanup, init, indexLocal, init$1, runtime_doSpin; + js = $packages["github.com/gopherjs/gopherjs/js"]; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + atomic = $packages["sync/atomic"]; + Pool = $pkg.Pool = $newType(0, $kindStruct, "sync.Pool", true, "sync", true, function(local_, localSize_, store_, New_) { + this.$val = this; + if (arguments.length === 0) { + this.local = 0; + this.localSize = 0; + this.store = sliceType$4.nil; + this.New = $throwNilPointerError; + return; + } + this.local = local_; + this.localSize = localSize_; + this.store = store_; + this.New = New_; + }); + Mutex = $pkg.Mutex = $newType(0, $kindStruct, "sync.Mutex", true, "sync", true, function(state_, sema_) { + this.$val = this; + if (arguments.length === 0) { + this.state = 0; + this.sema = 0; + return; + } + this.state = state_; + this.sema = sema_; + }); + Locker = $pkg.Locker = $newType(8, $kindInterface, "sync.Locker", true, "sync", true, null); + poolLocalInternal = $pkg.poolLocalInternal = $newType(0, $kindStruct, "sync.poolLocalInternal", true, "sync", false, function(private$0_, shared_, Mutex_) { + this.$val = this; + if (arguments.length === 0) { + this.private$0 = $ifaceNil; + this.shared = sliceType$4.nil; + this.Mutex = new Mutex.ptr(0, 0); + return; + } + this.private$0 = private$0_; + this.shared = shared_; + this.Mutex = Mutex_; + }); + poolLocal = $pkg.poolLocal = $newType(0, $kindStruct, "sync.poolLocal", true, "sync", false, function(poolLocalInternal_, pad_) { + this.$val = this; + if (arguments.length === 0) { + this.poolLocalInternal = new poolLocalInternal.ptr($ifaceNil, sliceType$4.nil, new Mutex.ptr(0, 0)); + this.pad = arrayType$2.zero(); + return; + } + this.poolLocalInternal = poolLocalInternal_; + this.pad = pad_; + }); + notifyList = $pkg.notifyList = $newType(0, $kindStruct, "sync.notifyList", true, "sync", false, function(wait_, notify_, lock_, head_, tail_) { + this.$val = this; + if (arguments.length === 0) { + this.wait = 0; + this.notify = 0; + this.lock = 0; + this.head = 0; + this.tail = 0; + return; + } + this.wait = wait_; + this.notify = notify_; + this.lock = lock_; + this.head = head_; + this.tail = tail_; + }); + RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "sync.RWMutex", true, "sync", true, function(w_, writerSem_, readerSem_, readerCount_, readerWait_) { + this.$val = this; + if (arguments.length === 0) { + this.w = new Mutex.ptr(0, 0); + this.writerSem = 0; + this.readerSem = 0; + this.readerCount = 0; + this.readerWait = 0; + return; + } + this.w = w_; + this.writerSem = writerSem_; + this.readerSem = readerSem_; + this.readerCount = readerCount_; + this.readerWait = readerWait_; + }); + rlocker = $pkg.rlocker = $newType(0, $kindStruct, "sync.rlocker", true, "sync", false, function(w_, writerSem_, readerSem_, readerCount_, readerWait_) { + this.$val = this; + if (arguments.length === 0) { + this.w = new Mutex.ptr(0, 0); + this.writerSem = 0; + this.readerSem = 0; + this.readerCount = 0; + this.readerWait = 0; + return; + } + this.w = w_; + this.writerSem = writerSem_; + this.readerSem = readerSem_; + this.readerCount = readerCount_; + this.readerWait = readerWait_; + }); + ptrType = $ptrType(Pool); + sliceType = $sliceType(ptrType); + ptrType$1 = $ptrType($Uint32); + chanType = $chanType($Bool, false, false); + sliceType$1 = $sliceType(chanType); + ptrType$6 = $ptrType($Int32); + ptrType$7 = $ptrType(poolLocal); + sliceType$4 = $sliceType($emptyInterface); + ptrType$8 = $ptrType(rlocker); + ptrType$9 = $ptrType(RWMutex); + funcType = $funcType([], [$emptyInterface], false); + ptrType$16 = $ptrType(Mutex); + arrayType$2 = $arrayType($Uint8, 100); + Pool.ptr.prototype.Get = function() { + var _r, p, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (p.store.$length === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (p.store.$length === 0) { */ case 1: + /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(p.New === $throwNilPointerError)) { */ case 3: + _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 2: + x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); + $s = -1; return x$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Pool.prototype.Get = function() { return this.$val.Get(); }; + Pool.ptr.prototype.Put = function(x) { + var p, x; + p = this; + if ($interfaceIsEqual(x, $ifaceNil)) { + return; + } + p.store = $append(p.store, x); + }; + Pool.prototype.Put = function(x) { return this.$val.Put(x); }; + runtime_registerPoolCleanup = function(cleanup) { + var cleanup; + }; + runtime_SemacquireMutex = function(s, lifo) { + var _entry, _entry$1, _entry$2, _entry$3, _entry$4, _key, _key$1, _key$2, _r, ch, lifo, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _r = $f._r; ch = $f.ch; lifo = $f.lifo; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { */ case 1: + ch = new $Chan($Bool, 0); + if (lifo) { + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: $appendSlice(new sliceType$1([ch]), (_entry$1 = semWaiters[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : sliceType$1.nil)) }; + } else { + _key$1 = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: $append((_entry$2 = semWaiters[ptrType$1.keyFor(s)], _entry$2 !== undefined ? _entry$2.v : sliceType$1.nil), ch) }; + } + _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r[0]; + _key$2 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$2)] = { k: _key$2, v: (_entry$3 = semAwoken[ptrType$1.keyFor(s)], _entry$3 !== undefined ? _entry$3.v : 0) - (1) >>> 0 }; + if ((_entry$4 = semAwoken[ptrType$1.keyFor(s)], _entry$4 !== undefined ? _entry$4.v : 0) === 0) { + delete semAwoken[ptrType$1.keyFor(s)]; + } + /* } */ case 2: + s.$set(s.$get() - (1) >>> 0); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_SemacquireMutex }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._r = _r; $f.ch = ch; $f.lifo = lifo; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_Semrelease = function(s, handoff) { + var _entry, _entry$1, _key, _key$1, ch, handoff, s, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _key = $f._key; _key$1 = $f._key$1; ch = $f.ch; handoff = $f.handoff; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s.$set(s.$get() + (1) >>> 0); + w = (_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil); + if (w.$length === 0) { + $s = -1; return; + } + ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); + w = $subslice(w, 1); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: w }; + if (w.$length === 0) { + delete semWaiters[ptrType$1.keyFor(s)]; + } + _key$1 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: (_entry$1 = semAwoken[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : 0) + (1) >>> 0 }; + $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._key = _key; $f._key$1 = _key$1; $f.ch = ch; $f.handoff = handoff; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_notifyListCheck = function(size) { + var size; + }; + runtime_canSpin = function(i) { + var i; + return false; + }; + runtime_nanotime = function() { + return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); + }; + throw$1 = function(s) { + var s; + $throwRuntimeError($externalize(s, $String)); + }; + Mutex.ptr.prototype.Lock = function() { + var awoke, delta, iter, m, new$1, old, queueLifo, starving, waitStartTime, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; awoke = $f.awoke; delta = $f.delta; iter = $f.iter; m = $f.m; new$1 = $f.new$1; old = $f.old; queueLifo = $f.queueLifo; starving = $f.starving; waitStartTime = $f.waitStartTime; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), 0, 1)) { + if (false) { + race.Acquire((m)); + } + $s = -1; return; + } + waitStartTime = new $Int64(0, 0); + starving = false; + awoke = false; + iter = 0; + old = m.state; + /* while (true) { */ case 1: + /* */ if (((old & 5) === 1) && runtime_canSpin(iter)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (((old & 5) === 1) && runtime_canSpin(iter)) { */ case 3: + if (!awoke && ((old & 2) === 0) && !(((old >> 3 >> 0) === 0)) && atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, old | 2)) { + awoke = true; + } + runtime_doSpin(); + iter = iter + (1) >> 0; + old = m.state; + /* continue; */ $s = 1; continue; + /* } */ case 4: + new$1 = old; + if ((old & 4) === 0) { + new$1 = new$1 | (1); + } + if (!(((old & 5) === 0))) { + new$1 = new$1 + (8) >> 0; + } + if (starving && !(((old & 1) === 0))) { + new$1 = new$1 | (4); + } + if (awoke) { + if ((new$1 & 2) === 0) { + throw$1("sync: inconsistent mutex state"); + } + new$1 = (new$1 & ~(2)) >> 0; + } + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 5: + if ((old & 5) === 0) { + /* break; */ $s = 2; continue; + } + queueLifo = !((waitStartTime.$high === 0 && waitStartTime.$low === 0)); + if ((waitStartTime.$high === 0 && waitStartTime.$low === 0)) { + waitStartTime = runtime_nanotime(); + } + $r = runtime_SemacquireMutex((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), queueLifo); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + starving = starving || (x = (x$1 = runtime_nanotime(), new $Int64(x$1.$high - waitStartTime.$high, x$1.$low - waitStartTime.$low)), (x.$high > 0 || (x.$high === 0 && x.$low > 1000000))); + old = m.state; + if (!(((old & 4) === 0))) { + if (!(((old & 3) === 0)) || ((old >> 3 >> 0) === 0)) { + throw$1("sync: inconsistent mutex state"); + } + delta = -7; + if (!starving || ((old >> 3 >> 0) === 1)) { + delta = delta - (4) >> 0; + } + atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), delta); + /* break; */ $s = 2; continue; + } + awoke = true; + iter = 0; + $s = 7; continue; + /* } else { */ case 6: + old = m.state; + /* } */ case 7: + /* } */ $s = 1; continue; case 2: + if (false) { + race.Acquire((m)); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Lock }; } $f.awoke = awoke; $f.delta = delta; $f.iter = iter; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.queueLifo = queueLifo; $f.starving = starving; $f.waitStartTime = waitStartTime; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Mutex.prototype.Lock = function() { return this.$val.Lock(); }; + Mutex.ptr.prototype.Unlock = function() { + var m, new$1, old, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; m = $f.m; new$1 = $f.new$1; old = $f.old; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + if (false) { + $unused(m.state); + race.Release((m)); + } + new$1 = atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), -1); + if ((((new$1 + 1 >> 0)) & 1) === 0) { + throw$1("sync: unlock of unlocked mutex"); + } + /* */ if ((new$1 & 4) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((new$1 & 4) === 0) { */ case 1: + old = new$1; + /* while (true) { */ case 4: + if (((old >> 3 >> 0) === 0) || !(((old & 7) === 0))) { + $s = -1; return; + } + new$1 = ((old - 8 >> 0)) | 2; + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 6: + $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), false); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 7: + old = m.state; + /* } */ $s = 4; continue; case 5: + $s = 3; continue; + /* } else { */ case 2: + $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), true); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Unlock }; } $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f; + }; + Mutex.prototype.Unlock = function() { return this.$val.Unlock(); }; + poolCleanup = function() { + var _i, _i$1, _ref, _ref$1, i, i$1, j, l, p, x; + _ref = allPools; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + p = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= allPools.$length) ? ($throwRuntimeError("index out of range"), undefined) : allPools.$array[allPools.$offset + i] = ptrType.nil); + i$1 = 0; + while (true) { + if (!(i$1 < ((p.localSize >> 0)))) { break; } + l = indexLocal(p.local, i$1); + l.poolLocalInternal.private$0 = $ifaceNil; + _ref$1 = l.poolLocalInternal.shared; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + j = _i$1; + (x = l.poolLocalInternal.shared, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j] = $ifaceNil)); + _i$1++; + } + l.poolLocalInternal.shared = sliceType$4.nil; + i$1 = i$1 + (1) >> 0; + } + p.local = 0; + p.localSize = 0; + _i++; + } + allPools = new sliceType([]); + }; + init = function() { + runtime_registerPoolCleanup(poolCleanup); + }; + indexLocal = function(l, i) { + var i, l, lp; + lp = (((l) + ($imul(((i >>> 0)), 128) >>> 0) >>> 0)); + return ($pointerOfStructConversion(lp, ptrType$7)); + }; + init$1 = function() { + var n; + n = new notifyList.ptr(0, 0, 0, 0, 0); + runtime_notifyListCheck(20); + }; + runtime_doSpin = function() { + $throwRuntimeError("native function not implemented: sync.runtime_doSpin"); + }; + RWMutex.ptr.prototype.RLock = function() { + var rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + $unused(rw.w.state); + race.Disable(); + } + /* */ if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { */ case 1: + $r = runtime_SemacquireMutex((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))), false); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (false) { + race.Enable(); + race.Acquire(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RLock }; } $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; + }; + RWMutex.prototype.RLock = function() { return this.$val.RLock(); }; + RWMutex.ptr.prototype.RUnlock = function() { + var r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + $unused(rw.w.state); + race.ReleaseMerge(((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))))); + race.Disable(); + } + r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1); + /* */ if (r < 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (r < 0) { */ case 1: + if (((r + 1 >> 0) === 0) || ((r + 1 >> 0) === -1073741824)) { + race.Enable(); + throw$1("sync: RUnlock of unlocked RWMutex"); + } + /* */ if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { */ case 3: + $r = runtime_Semrelease((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))), false); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + /* } */ case 2: + if (false) { + race.Enable(); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RUnlock }; } $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; + }; + RWMutex.prototype.RUnlock = function() { return this.$val.RUnlock(); }; + RWMutex.ptr.prototype.Lock = function() { + var r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + $unused(rw.w.state); + race.Disable(); + } + $r = rw.w.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1073741824) + 1073741824 >> 0; + /* */ if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { */ case 2: + $r = runtime_SemacquireMutex((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))), false); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + if (false) { + race.Enable(); + race.Acquire(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); + race.Acquire(((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))))); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Lock }; } $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; + }; + RWMutex.prototype.Lock = function() { return this.$val.Lock(); }; + RWMutex.ptr.prototype.Unlock = function() { + var i, r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; i = $f.i; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + $unused(rw.w.state); + race.Release(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); + race.Disable(); + } + r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1073741824); + if (r >= 1073741824) { + race.Enable(); + throw$1("sync: Unlock of unlocked RWMutex"); + } + i = 0; + /* while (true) { */ case 1: + /* if (!(i < ((r >> 0)))) { break; } */ if(!(i < ((r >> 0)))) { $s = 2; continue; } + $r = runtime_Semrelease((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))), false); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $r = rw.w.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (false) { + race.Enable(); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Unlock }; } $f.i = i; $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; + }; + RWMutex.prototype.Unlock = function() { return this.$val.Unlock(); }; + RWMutex.ptr.prototype.RLocker = function() { + var rw; + rw = this; + return ($pointerOfStructConversion(rw, ptrType$8)); + }; + RWMutex.prototype.RLocker = function() { return this.$val.RLocker(); }; + rlocker.ptr.prototype.Lock = function() { + var r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + $r = ($pointerOfStructConversion(r, ptrType$9)).RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Lock }; } $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + rlocker.prototype.Lock = function() { return this.$val.Lock(); }; + rlocker.ptr.prototype.Unlock = function() { + var r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + $r = ($pointerOfStructConversion(r, ptrType$9)).RUnlock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Unlock }; } $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + rlocker.prototype.Unlock = function() { return this.$val.Unlock(); }; + ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "getSlow", name: "getSlow", pkg: "sync", typ: $funcType([], [$emptyInterface], false)}, {prop: "pin", name: "pin", pkg: "sync", typ: $funcType([], [ptrType$7], false)}, {prop: "pinSlow", name: "pinSlow", pkg: "sync", typ: $funcType([], [ptrType$7], false)}]; + ptrType$16.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + ptrType$9.methods = [{prop: "RLock", name: "RLock", pkg: "", typ: $funcType([], [], false)}, {prop: "RUnlock", name: "RUnlock", pkg: "", typ: $funcType([], [], false)}, {prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}, {prop: "RLocker", name: "RLocker", pkg: "", typ: $funcType([], [Locker], false)}]; + ptrType$8.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + Pool.init("sync", [{prop: "local", name: "local", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "localSize", name: "localSize", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "store", name: "store", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: funcType, tag: ""}]); + Mutex.init("sync", [{prop: "state", name: "state", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "sema", name: "sema", embedded: false, exported: false, typ: $Uint32, tag: ""}]); + Locker.init([{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]); + poolLocalInternal.init("sync", [{prop: "private$0", name: "private", embedded: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "shared", name: "shared", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: Mutex, tag: ""}]); + poolLocal.init("sync", [{prop: "poolLocalInternal", name: "poolLocalInternal", embedded: true, exported: false, typ: poolLocalInternal, tag: ""}, {prop: "pad", name: "pad", embedded: false, exported: false, typ: arrayType$2, tag: ""}]); + notifyList.init("sync", [{prop: "wait", name: "wait", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "notify", name: "notify", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "lock", name: "lock", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "head", name: "head", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "tail", name: "tail", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}]); + RWMutex.init("sync", [{prop: "w", name: "w", embedded: false, exported: false, typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", embedded: false, exported: false, typ: $Int32, tag: ""}]); + rlocker.init("sync", [{prop: "w", name: "w", embedded: false, exported: false, typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", embedded: false, exported: false, typ: $Int32, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + allPools = sliceType.nil; + semWaiters = {}; + semAwoken = {}; + expunged = (new Uint8Array(8)); + init(); + init$1(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["io"] = (function() { + var $pkg = {}, $init, errors, sync, atomic, Reader, Writer, ByteScanner, RuneReader, RuneScanner, StringWriter, sliceType, errWhence, errOffset, WriteString, ReadAtLeast, ReadFull; + errors = $packages["errors"]; + sync = $packages["sync"]; + atomic = $packages["sync/atomic"]; + Reader = $pkg.Reader = $newType(8, $kindInterface, "io.Reader", true, "io", true, null); + Writer = $pkg.Writer = $newType(8, $kindInterface, "io.Writer", true, "io", true, null); + ByteScanner = $pkg.ByteScanner = $newType(8, $kindInterface, "io.ByteScanner", true, "io", true, null); + RuneReader = $pkg.RuneReader = $newType(8, $kindInterface, "io.RuneReader", true, "io", true, null); + RuneScanner = $pkg.RuneScanner = $newType(8, $kindInterface, "io.RuneScanner", true, "io", true, null); + StringWriter = $pkg.StringWriter = $newType(8, $kindInterface, "io.StringWriter", true, "io", true, null); + sliceType = $sliceType($Uint8); + WriteString = function(w, s) { + var _r, _r$1, _tuple, _tuple$1, _tuple$2, err, n, ok, s, sw, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; n = $f.n; ok = $f.ok; s = $f.s; sw = $f.sw; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _tuple = $assertType(w, StringWriter, true); + sw = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + _r = sw.WriteString(s); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + n = _tuple$1[0]; + err = _tuple$1[1]; + $s = -1; return [n, err]; + /* } */ case 2: + _r$1 = w.Write((new sliceType($stringToBytes(s)))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$2 = _r$1; + n = _tuple$2[0]; + err = _tuple$2[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: WriteString }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.n = n; $f.ok = ok; $f.s = s; $f.sw = sw; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.WriteString = WriteString; + ReadAtLeast = function(r, buf, min) { + var _r, _tmp, _tmp$1, _tuple, buf, err, min, n, nn, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; buf = $f.buf; err = $f.err; min = $f.min; n = $f.n; nn = $f.nn; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + if (buf.$length < min) { + _tmp = 0; + _tmp$1 = $pkg.ErrShortBuffer; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + /* while (true) { */ case 1: + /* if (!(n < min && $interfaceIsEqual(err, $ifaceNil))) { break; } */ if(!(n < min && $interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } + nn = 0; + _r = r.Read($subslice(buf, n)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + nn = _tuple[0]; + err = _tuple[1]; + n = n + (nn) >> 0; + /* } */ $s = 1; continue; case 2: + if (n >= min) { + err = $ifaceNil; + } else if (n > 0 && $interfaceIsEqual(err, $pkg.EOF)) { + err = $pkg.ErrUnexpectedEOF; + } + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: ReadAtLeast }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.min = min; $f.n = n; $f.nn = nn; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.ReadAtLeast = ReadAtLeast; + ReadFull = function(r, buf) { + var _r, _tuple, buf, err, n, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; err = $f.err; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = ReadAtLeast(r, buf, buf.$length); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: ReadFull }; } $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.ReadFull = ReadFull; + Reader.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); + Writer.init([{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); + ByteScanner.init([{prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}]); + RuneReader.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}]); + RuneScanner.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]); + StringWriter.init([{prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrShortWrite = errors.New("short write"); + $pkg.ErrShortBuffer = errors.New("short buffer"); + $pkg.EOF = errors.New("EOF"); + $pkg.ErrUnexpectedEOF = errors.New("unexpected EOF"); + $pkg.ErrNoProgress = errors.New("multiple Read calls return no data or error"); + errWhence = errors.New("Seek: invalid whence"); + errOffset = errors.New("Seek: invalid offset"); + $pkg.ErrClosedPipe = errors.New("io: read/write on closed pipe"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["hash"] = (function() { + var $pkg = {}, $init, io, Hash, sliceType; + io = $packages["io"]; + Hash = $pkg.Hash = $newType(8, $kindInterface, "hash.Hash", true, "hash", true, null); + sliceType = $sliceType($Uint8); + Hash.init([{prop: "BlockSize", name: "BlockSize", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Sum", name: "Sum", pkg: "", typ: $funcType([sliceType], [sliceType], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = io.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["math/bits"] = (function() { + var $pkg = {}, $init, deBruijn32tab, deBruijn64tab, len8tab, LeadingZeros, LeadingZeros64, TrailingZeros, TrailingZeros32, TrailingZeros64, Len, Len32, Len64; + LeadingZeros = function(x) { + var x; + return 32 - Len(x) >> 0; + }; + $pkg.LeadingZeros = LeadingZeros; + LeadingZeros64 = function(x) { + var x; + return 64 - Len64(x) >> 0; + }; + $pkg.LeadingZeros64 = LeadingZeros64; + TrailingZeros = function(x) { + var x; + if (true) { + return TrailingZeros32(((x >>> 0))); + } + return TrailingZeros64((new $Uint64(0, x))); + }; + $pkg.TrailingZeros = TrailingZeros; + TrailingZeros32 = function(x) { + var x, x$1; + if (x === 0) { + return 32; + } + return (((x$1 = ($imul((((x & (-x >>> 0)) >>> 0)), 125613361) >>> 0) >>> 27 >>> 0, ((x$1 < 0 || x$1 >= deBruijn32tab.length) ? ($throwRuntimeError("index out of range"), undefined) : deBruijn32tab[x$1])) >> 0)); + }; + $pkg.TrailingZeros32 = TrailingZeros32; + TrailingZeros64 = function(x) { + var x, x$1, x$2; + if ((x.$high === 0 && x.$low === 0)) { + return 64; + } + return (((x$1 = $shiftRightUint64($mul64(((x$2 = new $Uint64(-x.$high, -x.$low), new $Uint64(x.$high & x$2.$high, (x.$low & x$2.$low) >>> 0))), new $Uint64(66559345, 3033172745)), 58), (($flatten64(x$1) < 0 || $flatten64(x$1) >= deBruijn64tab.length) ? ($throwRuntimeError("index out of range"), undefined) : deBruijn64tab[$flatten64(x$1)])) >> 0)); + }; + $pkg.TrailingZeros64 = TrailingZeros64; + Len = function(x) { + var x; + if (true) { + return Len32(((x >>> 0))); + } + return Len64((new $Uint64(0, x))); + }; + $pkg.Len = Len; + Len32 = function(x) { + var n, x, y, y$1; + n = 0; + if (x >= 65536) { + x = (y = (16), y < 32 ? (x >>> y) : 0) >>> 0; + n = 16; + } + if (x >= 256) { + x = (y$1 = (8), y$1 < 32 ? (x >>> y$1) : 0) >>> 0; + n = n + (8) >> 0; + } + n = n + ((((x < 0 || x >= len8tab.length) ? ($throwRuntimeError("index out of range"), undefined) : len8tab[x]) >> 0)) >> 0; + return n; + }; + $pkg.Len32 = Len32; + Len64 = function(x) { + var n, x; + n = 0; + if ((x.$high > 1 || (x.$high === 1 && x.$low >= 0))) { + x = $shiftRightUint64(x, (32)); + n = 32; + } + if ((x.$high > 0 || (x.$high === 0 && x.$low >= 65536))) { + x = $shiftRightUint64(x, (16)); + n = n + (16) >> 0; + } + if ((x.$high > 0 || (x.$high === 0 && x.$low >= 256))) { + x = $shiftRightUint64(x, (8)); + n = n + (8) >> 0; + } + n = n + (((($flatten64(x) < 0 || $flatten64(x) >= len8tab.length) ? ($throwRuntimeError("index out of range"), undefined) : len8tab[$flatten64(x)]) >> 0)) >> 0; + return n; + }; + $pkg.Len64 = Len64; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + deBruijn32tab = $toNativeArray($kindUint8, [0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9]); + deBruijn64tab = $toNativeArray($kindUint8, [0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6]); + len8tab = $toNativeArray($kindUint8, [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["math"] = (function() { + var $pkg = {}, $init, js, bits, arrayType, arrayType$1, arrayType$2, structType, math, zero, posInf, negInf, nan, buf, Ceil, Copysign, Exp, Floor, Frexp, Inf, IsInf, IsNaN, Ldexp, Log, Log2, Max, NaN, Pow, Signbit, Sqrt, init, Float32bits, Float32frombits, Float64bits, Float64frombits, Abs, normalize, max, Round, frexp, ldexp, log2; + js = $packages["github.com/gopherjs/gopherjs/js"]; + bits = $packages["math/bits"]; + arrayType = $arrayType($Uint32, 2); + arrayType$1 = $arrayType($Float32, 2); + arrayType$2 = $arrayType($Float64, 1); + structType = $structType("math", [{prop: "uint32array", name: "uint32array", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "float32array", name: "float32array", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "float64array", name: "float64array", embedded: false, exported: false, typ: arrayType$2, tag: ""}]); + Ceil = function(x) { + var x; + return $parseFloat(math.ceil(x)); + }; + $pkg.Ceil = Ceil; + Copysign = function(x, y) { + var x, y; + if (!((x < 0 || (1 / x === negInf)) === (y < 0 || (1 / y === negInf)))) { + return -x; + } + return x; + }; + $pkg.Copysign = Copysign; + Exp = function(x) { + var x; + return $parseFloat(math.exp(x)); + }; + $pkg.Exp = Exp; + Floor = function(x) { + var x; + return $parseFloat(math.floor(x)); + }; + $pkg.Floor = Floor; + Frexp = function(f) { + var _tuple, exp$1, f, frac; + frac = 0; + exp$1 = 0; + _tuple = frexp(f); + frac = _tuple[0]; + exp$1 = _tuple[1]; + return [frac, exp$1]; + }; + $pkg.Frexp = Frexp; + Inf = function(sign) { + var sign; + if (sign >= 0) { + return posInf; + } else { + return negInf; + } + }; + $pkg.Inf = Inf; + IsInf = function(f, sign) { + var f, sign; + if (f === posInf) { + return sign >= 0; + } + if (f === negInf) { + return sign <= 0; + } + return false; + }; + $pkg.IsInf = IsInf; + IsNaN = function(f) { + var f, is; + is = false; + is = !((f === f)); + return is; + }; + $pkg.IsNaN = IsNaN; + Ldexp = function(frac, exp$1) { + var exp$1, frac; + if (-1024 < exp$1 && exp$1 < 1024) { + if (frac === 0) { + return frac; + } + return frac * $parseFloat(math.pow(2, exp$1)); + } + return ldexp(frac, exp$1); + }; + $pkg.Ldexp = Ldexp; + Log = function(x) { + var x; + if (!((x === x))) { + return nan; + } + return $parseFloat(math.log(x)); + }; + $pkg.Log = Log; + Log2 = function(x) { + var x; + return log2(x); + }; + $pkg.Log2 = Log2; + Max = function(x, y) { + var x, y; + return max(x, y); + }; + $pkg.Max = Max; + NaN = function() { + return nan; + }; + $pkg.NaN = NaN; + Pow = function(x, y) { + var x, y; + if ((x === 1) || ((x === -1) && ((y === posInf) || (y === negInf)))) { + return 1; + } + return $parseFloat(math.pow(x, y)); + }; + $pkg.Pow = Pow; + Signbit = function(x) { + var x; + return x < 0 || (1 / x === negInf); + }; + $pkg.Signbit = Signbit; + Sqrt = function(x) { + var x; + return $parseFloat(math.sqrt(x)); + }; + $pkg.Sqrt = Sqrt; + init = function() { + var ab; + ab = new ($global.ArrayBuffer)(8); + buf.uint32array = new ($global.Uint32Array)(ab); + buf.float32array = new ($global.Float32Array)(ab); + buf.float64array = new ($global.Float64Array)(ab); + }; + Float32bits = function(f) { + var f; + buf.float32array[0] = f; + return buf.uint32array[0]; + }; + $pkg.Float32bits = Float32bits; + Float32frombits = function(b) { + var b; + buf.uint32array[0] = b; + return buf.float32array[0]; + }; + $pkg.Float32frombits = Float32frombits; + Float64bits = function(f) { + var f, x, x$1; + buf.float64array[0] = f; + return (x = $shiftLeft64((new $Uint64(0, buf.uint32array[1])), 32), x$1 = (new $Uint64(0, buf.uint32array[0])), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + }; + $pkg.Float64bits = Float64bits; + Float64frombits = function(b) { + var b; + buf.uint32array[0] = ((b.$low >>> 0)); + buf.uint32array[1] = (($shiftRightUint64(b, 32).$low >>> 0)); + return buf.float64array[0]; + }; + $pkg.Float64frombits = Float64frombits; + Abs = function(x) { + var x, x$1; + return Float64frombits((x$1 = Float64bits(x), new $Uint64(x$1.$high & ~2147483648, (x$1.$low & ~0) >>> 0))); + }; + $pkg.Abs = Abs; + normalize = function(x) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, exp$1, x, y; + y = 0; + exp$1 = 0; + if (Abs(x) < 2.2250738585072014e-308) { + _tmp = x * 4.503599627370496e+15; + _tmp$1 = -52; + y = _tmp; + exp$1 = _tmp$1; + return [y, exp$1]; + } + _tmp$2 = x; + _tmp$3 = 0; + y = _tmp$2; + exp$1 = _tmp$3; + return [y, exp$1]; + }; + max = function(x, y) { + var x, y; + if (IsInf(x, 1) || IsInf(y, 1)) { + return Inf(1); + } else if (IsNaN(x) || IsNaN(y)) { + return NaN(); + } else if ((x === 0) && (x === y)) { + if (Signbit(x)) { + return y; + } + return x; + } + if (x > y) { + return x; + } + return y; + }; + Round = function(x) { + var bits$1, e, x, x$1, x$2, x$3, x$4; + bits$1 = Float64bits(x); + e = ((($shiftRightUint64(bits$1, 52).$low >>> 0)) & 2047) >>> 0; + if (e < 1023) { + bits$1 = (x$1 = new $Uint64(2147483648, 0), new $Uint64(bits$1.$high & x$1.$high, (bits$1.$low & x$1.$low) >>> 0)); + if (e === 1022) { + bits$1 = (x$2 = new $Uint64(1072693248, 0), new $Uint64(bits$1.$high | x$2.$high, (bits$1.$low | x$2.$low) >>> 0)); + } + } else if (e < 1075) { + e = e - (1023) >>> 0; + bits$1 = (x$3 = $shiftRightUint64(new $Uint64(524288, 0), e), new $Uint64(bits$1.$high + x$3.$high, bits$1.$low + x$3.$low)); + bits$1 = (x$4 = $shiftRightUint64(new $Uint64(1048575, 4294967295), e), new $Uint64(bits$1.$high & ~x$4.$high, (bits$1.$low & ~x$4.$low) >>> 0)); + } + return Float64frombits(bits$1); + }; + $pkg.Round = Round; + frexp = function(f) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, exp$1, f, frac, x, x$1, x$2, x$3; + frac = 0; + exp$1 = 0; + if ((f === 0)) { + _tmp = f; + _tmp$1 = 0; + frac = _tmp; + exp$1 = _tmp$1; + return [frac, exp$1]; + } else if (IsInf(f, 0) || IsNaN(f)) { + _tmp$2 = f; + _tmp$3 = 0; + frac = _tmp$2; + exp$1 = _tmp$3; + return [frac, exp$1]; + } + _tuple = normalize(f); + f = _tuple[0]; + exp$1 = _tuple[1]; + x = Float64bits(f); + exp$1 = exp$1 + ((((((x$1 = $shiftRightUint64(x, 52), new $Uint64(x$1.$high & 0, (x$1.$low & 2047) >>> 0)).$low >> 0)) - 1023 >> 0) + 1 >> 0)) >> 0; + x = (x$2 = new $Uint64(2146435072, 0), new $Uint64(x.$high & ~x$2.$high, (x.$low & ~x$2.$low) >>> 0)); + x = (x$3 = new $Uint64(1071644672, 0), new $Uint64(x.$high | x$3.$high, (x.$low | x$3.$low) >>> 0)); + frac = Float64frombits(x); + return [frac, exp$1]; + }; + ldexp = function(frac, exp$1) { + var _tuple, e, exp$1, frac, m, x, x$1, x$2; + if ((frac === 0)) { + return frac; + } else if (IsInf(frac, 0) || IsNaN(frac)) { + return frac; + } + _tuple = normalize(frac); + frac = _tuple[0]; + e = _tuple[1]; + exp$1 = exp$1 + (e) >> 0; + x = Float64bits(frac); + exp$1 = exp$1 + ((((($shiftRightUint64(x, 52).$low >> 0)) & 2047) - 1023 >> 0)) >> 0; + if (exp$1 < -1075) { + return Copysign(0, frac); + } + if (exp$1 > 1023) { + if (frac < 0) { + return Inf(-1); + } + return Inf(1); + } + m = 1; + if (exp$1 < -1022) { + exp$1 = exp$1 + (53) >> 0; + m = 1.1102230246251565e-16; + } + x = (x$1 = new $Uint64(2146435072, 0), new $Uint64(x.$high & ~x$1.$high, (x.$low & ~x$1.$low) >>> 0)); + x = (x$2 = $shiftLeft64((new $Uint64(0, (exp$1 + 1023 >> 0))), 52), new $Uint64(x.$high | x$2.$high, (x.$low | x$2.$low) >>> 0)); + return m * Float64frombits(x); + }; + log2 = function(x) { + var _tuple, exp$1, frac, x; + _tuple = Frexp(x); + frac = _tuple[0]; + exp$1 = _tuple[1]; + if (frac === 0.5) { + return ((exp$1 - 1 >> 0)); + } + return Log(frac) * 1.4426950408889634 + (exp$1); + }; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bits.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + buf = new structType.ptr(arrayType.zero(), arrayType$1.zero(), arrayType$2.zero()); + math = $global.Math; + zero = 0; + posInf = 1 / zero; + negInf = -1 / zero; + nan = 0 / zero; + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["unicode/utf8"] = (function() { + var $pkg = {}, $init, acceptRange, first, acceptRanges, DecodeRune, DecodeRuneInString, DecodeLastRune, DecodeLastRuneInString, RuneLen, EncodeRune, RuneCount, RuneCountInString, RuneStart, ValidString, ValidRune; + acceptRange = $pkg.acceptRange = $newType(0, $kindStruct, "utf8.acceptRange", true, "unicode/utf8", false, function(lo_, hi_) { + this.$val = this; + if (arguments.length === 0) { + this.lo = 0; + this.hi = 0; + return; + } + this.lo = lo_; + this.hi = hi_; + }); + DecodeRune = function(p) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, accept, b1, b2, b3, mask, n, p, p0, r, size, sz, x, x$1; + r = 0; + size = 0; + n = p.$length; + if (n < 1) { + _tmp = 65533; + _tmp$1 = 0; + r = _tmp; + size = _tmp$1; + return [r, size]; + } + p0 = (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0]); + x = ((p0 < 0 || p0 >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[p0]); + if (x >= 240) { + mask = (((x >> 0)) << 31 >> 0) >> 31 >> 0; + _tmp$2 = (((((0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0]) >> 0)) & ~mask) >> 0) | (65533 & mask); + _tmp$3 = 1; + r = _tmp$2; + size = _tmp$3; + return [r, size]; + } + sz = (x & 7) >>> 0; + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + if (n < ((sz >> 0))) { + _tmp$4 = 65533; + _tmp$5 = 1; + r = _tmp$4; + size = _tmp$5; + return [r, size]; + } + b1 = (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1]); + if (b1 < accept.lo || accept.hi < b1) { + _tmp$6 = 65533; + _tmp$7 = 1; + r = _tmp$6; + size = _tmp$7; + return [r, size]; + } + if (sz === 2) { + _tmp$8 = (((((p0 & 31) >>> 0) >> 0)) << 6 >> 0) | ((((b1 & 63) >>> 0) >> 0)); + _tmp$9 = 2; + r = _tmp$8; + size = _tmp$9; + return [r, size]; + } + b2 = (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2]); + if (b2 < 128 || 191 < b2) { + _tmp$10 = 65533; + _tmp$11 = 1; + r = _tmp$10; + size = _tmp$11; + return [r, size]; + } + if (sz === 3) { + _tmp$12 = ((((((p0 & 15) >>> 0) >> 0)) << 12 >> 0) | (((((b1 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((b2 & 63) >>> 0) >> 0)); + _tmp$13 = 3; + r = _tmp$12; + size = _tmp$13; + return [r, size]; + } + b3 = (3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3]); + if (b3 < 128 || 191 < b3) { + _tmp$14 = 65533; + _tmp$15 = 1; + r = _tmp$14; + size = _tmp$15; + return [r, size]; + } + _tmp$16 = (((((((p0 & 7) >>> 0) >> 0)) << 18 >> 0) | (((((b1 & 63) >>> 0) >> 0)) << 12 >> 0)) | (((((b2 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((b3 & 63) >>> 0) >> 0)); + _tmp$17 = 4; + r = _tmp$16; + size = _tmp$17; + return [r, size]; + }; + $pkg.DecodeRune = DecodeRune; + DecodeRuneInString = function(s) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, accept, mask, n, r, s, s0, s1, s2, s3, size, sz, x, x$1; + r = 0; + size = 0; + n = s.length; + if (n < 1) { + _tmp = 65533; + _tmp$1 = 0; + r = _tmp; + size = _tmp$1; + return [r, size]; + } + s0 = s.charCodeAt(0); + x = ((s0 < 0 || s0 >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[s0]); + if (x >= 240) { + mask = (((x >> 0)) << 31 >> 0) >> 31 >> 0; + _tmp$2 = ((((s.charCodeAt(0) >> 0)) & ~mask) >> 0) | (65533 & mask); + _tmp$3 = 1; + r = _tmp$2; + size = _tmp$3; + return [r, size]; + } + sz = (x & 7) >>> 0; + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + if (n < ((sz >> 0))) { + _tmp$4 = 65533; + _tmp$5 = 1; + r = _tmp$4; + size = _tmp$5; + return [r, size]; + } + s1 = s.charCodeAt(1); + if (s1 < accept.lo || accept.hi < s1) { + _tmp$6 = 65533; + _tmp$7 = 1; + r = _tmp$6; + size = _tmp$7; + return [r, size]; + } + if (sz === 2) { + _tmp$8 = (((((s0 & 31) >>> 0) >> 0)) << 6 >> 0) | ((((s1 & 63) >>> 0) >> 0)); + _tmp$9 = 2; + r = _tmp$8; + size = _tmp$9; + return [r, size]; + } + s2 = s.charCodeAt(2); + if (s2 < 128 || 191 < s2) { + _tmp$10 = 65533; + _tmp$11 = 1; + r = _tmp$10; + size = _tmp$11; + return [r, size]; + } + if (sz === 3) { + _tmp$12 = ((((((s0 & 15) >>> 0) >> 0)) << 12 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s2 & 63) >>> 0) >> 0)); + _tmp$13 = 3; + r = _tmp$12; + size = _tmp$13; + return [r, size]; + } + s3 = s.charCodeAt(3); + if (s3 < 128 || 191 < s3) { + _tmp$14 = 65533; + _tmp$15 = 1; + r = _tmp$14; + size = _tmp$15; + return [r, size]; + } + _tmp$16 = (((((((s0 & 7) >>> 0) >> 0)) << 18 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 12 >> 0)) | (((((s2 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s3 & 63) >>> 0) >> 0)); + _tmp$17 = 4; + r = _tmp$16; + size = _tmp$17; + return [r, size]; + }; + $pkg.DecodeRuneInString = DecodeRuneInString; + DecodeLastRune = function(p) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, p, r, size, start; + r = 0; + size = 0; + end = p.$length; + if (end === 0) { + _tmp = 65533; + _tmp$1 = 0; + r = _tmp; + size = _tmp$1; + return [r, size]; + } + start = end - 1 >> 0; + r = ((((start < 0 || start >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + start]) >> 0)); + if (r < 128) { + _tmp$2 = r; + _tmp$3 = 1; + r = _tmp$2; + size = _tmp$3; + return [r, size]; + } + lim = end - 4 >> 0; + if (lim < 0) { + lim = 0; + } + start = start - (1) >> 0; + while (true) { + if (!(start >= lim)) { break; } + if (RuneStart(((start < 0 || start >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + start]))) { + break; + } + start = start - (1) >> 0; + } + if (start < 0) { + start = 0; + } + _tuple = DecodeRune($subslice(p, start, end)); + r = _tuple[0]; + size = _tuple[1]; + if (!(((start + size >> 0) === end))) { + _tmp$4 = 65533; + _tmp$5 = 1; + r = _tmp$4; + size = _tmp$5; + return [r, size]; + } + _tmp$6 = r; + _tmp$7 = size; + r = _tmp$6; + size = _tmp$7; + return [r, size]; + }; + $pkg.DecodeLastRune = DecodeLastRune; + DecodeLastRuneInString = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, r, s, size, start; + r = 0; + size = 0; + end = s.length; + if (end === 0) { + _tmp = 65533; + _tmp$1 = 0; + r = _tmp; + size = _tmp$1; + return [r, size]; + } + start = end - 1 >> 0; + r = ((s.charCodeAt(start) >> 0)); + if (r < 128) { + _tmp$2 = r; + _tmp$3 = 1; + r = _tmp$2; + size = _tmp$3; + return [r, size]; + } + lim = end - 4 >> 0; + if (lim < 0) { + lim = 0; + } + start = start - (1) >> 0; + while (true) { + if (!(start >= lim)) { break; } + if (RuneStart(s.charCodeAt(start))) { + break; + } + start = start - (1) >> 0; + } + if (start < 0) { + start = 0; + } + _tuple = DecodeRuneInString($substring(s, start, end)); + r = _tuple[0]; + size = _tuple[1]; + if (!(((start + size >> 0) === end))) { + _tmp$4 = 65533; + _tmp$5 = 1; + r = _tmp$4; + size = _tmp$5; + return [r, size]; + } + _tmp$6 = r; + _tmp$7 = size; + r = _tmp$6; + size = _tmp$7; + return [r, size]; + }; + $pkg.DecodeLastRuneInString = DecodeLastRuneInString; + RuneLen = function(r) { + var r; + if (r < 0) { + return -1; + } else if (r <= 127) { + return 1; + } else if (r <= 2047) { + return 2; + } else if (55296 <= r && r <= 57343) { + return -1; + } else if (r <= 65535) { + return 3; + } else if (r <= 1114111) { + return 4; + } + return -1; + }; + $pkg.RuneLen = RuneLen; + EncodeRune = function(p, r) { + var i, p, r; + i = ((r >>> 0)); + if (i <= 127) { + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((r << 24 >>> 24))); + return 1; + } else if (i <= 2047) { + $unused((1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((192 | (((r >> 6 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 2; + } else if ((i > 1114111) || (55296 <= i && i <= 57343)) { + r = 65533; + $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 3; + } else if (i <= 65535) { + $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 3; + } else { + $unused((3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((240 | (((r >> 18 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 12 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 4; + } + }; + $pkg.EncodeRune = EncodeRune; + RuneCount = function(p) { + var accept, c, c$1, c$2, c$3, i, n, np, p, size, x, x$1, x$2, x$3, x$4; + np = p.$length; + n = 0; + i = 0; + while (true) { + if (!(i < np)) { break; } + n = n + (1) >> 0; + c = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); + if (c < 128) { + i = i + (1) >> 0; + continue; + } + x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); + if (x === 241) { + i = i + (1) >> 0; + continue; + } + size = ((((x & 7) >>> 0) >> 0)); + if ((i + size >> 0) > np) { + i = i + (1) >> 0; + continue; + } + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + c$1 = (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2])); + if (c$1 < accept.lo || accept.hi < c$1) { + size = 1; + } else if (size === 2) { + } else { + c$2 = (x$3 = i + 2 >> 0, ((x$3 < 0 || x$3 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$3])); + if (c$2 < 128 || 191 < c$2) { + size = 1; + } else if (size === 3) { + } else { + c$3 = (x$4 = i + 3 >> 0, ((x$4 < 0 || x$4 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$4])); + if (c$3 < 128 || 191 < c$3) { + size = 1; + } + } + } + i = i + (size) >> 0; + } + return n; + }; + $pkg.RuneCount = RuneCount; + RuneCountInString = function(s) { + var accept, c, c$1, c$2, c$3, i, n, ns, s, size, x, x$1; + n = 0; + ns = s.length; + i = 0; + while (true) { + if (!(i < ns)) { break; } + c = s.charCodeAt(i); + if (c < 128) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); + if (x === 241) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + size = ((((x & 7) >>> 0) >> 0)); + if ((i + size >> 0) > ns) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + c$1 = s.charCodeAt((i + 1 >> 0)); + if (c$1 < accept.lo || accept.hi < c$1) { + size = 1; + } else if (size === 2) { + } else { + c$2 = s.charCodeAt((i + 2 >> 0)); + if (c$2 < 128 || 191 < c$2) { + size = 1; + } else if (size === 3) { + } else { + c$3 = s.charCodeAt((i + 3 >> 0)); + if (c$3 < 128 || 191 < c$3) { + size = 1; + } + } + } + i = i + (size) >> 0; + n = n + (1) >> 0; + } + n = n; + return n; + }; + $pkg.RuneCountInString = RuneCountInString; + RuneStart = function(b) { + var b; + return !((((b & 192) >>> 0) === 128)); + }; + $pkg.RuneStart = RuneStart; + ValidString = function(s) { + var accept, c, c$1, c$2, i, n, s, si, size, x, x$1; + n = s.length; + i = 0; + while (true) { + if (!(i < n)) { break; } + si = s.charCodeAt(i); + if (si < 128) { + i = i + (1) >> 0; + continue; + } + x = ((si < 0 || si >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[si]); + if (x === 241) { + return false; + } + size = ((((x & 7) >>> 0) >> 0)); + if ((i + size >> 0) > n) { + return false; + } + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + c = s.charCodeAt((i + 1 >> 0)); + if (c < accept.lo || accept.hi < c) { + return false; + } else if (size === 2) { + } else { + c$1 = s.charCodeAt((i + 2 >> 0)); + if (c$1 < 128 || 191 < c$1) { + return false; + } else if (size === 3) { + } else { + c$2 = s.charCodeAt((i + 3 >> 0)); + if (c$2 < 128 || 191 < c$2) { + return false; + } + } + } + i = i + (size) >> 0; + } + return true; + }; + $pkg.ValidString = ValidString; + ValidRune = function(r) { + var r; + if (0 <= r && r < 55296) { + return true; + } else if (57343 < r && r <= 1114111) { + return true; + } + return false; + }; + $pkg.ValidRune = ValidRune; + acceptRange.init("unicode/utf8", [{prop: "lo", name: "lo", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "hi", name: "hi", embedded: false, exported: false, typ: $Uint8, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + first = $toNativeArray($kindUint8, [240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 19, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 35, 3, 3, 52, 4, 4, 4, 68, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241]); + acceptRanges = $toNativeArray($kindStruct, [new acceptRange.ptr(128, 191), new acceptRange.ptr(160, 191), new acceptRange.ptr(128, 159), new acceptRange.ptr(144, 191), new acceptRange.ptr(128, 143)]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["strconv"] = (function() { + var $pkg = {}, $init, errors, bytealg, math, bits, utf8, NumError, decimal, leftCheat, extFloat, floatInfo, decimalSlice, sliceType, sliceType$1, sliceType$2, sliceType$3, sliceType$4, sliceType$5, arrayType, sliceType$6, ptrType, arrayType$1, arrayType$2, ptrType$1, arrayType$3, arrayType$4, ptrType$2, ptrType$3, ptrType$4, optimize, powtab, float64pow10, float32pow10, leftcheats, smallPowersOfTen, powersOfTen, uint64pow10, float32info, float32info$24ptr, float64info, float64info$24ptr, isPrint16, isNotPrint16, isPrint32, isNotPrint32, isGraphic, equalIgnoreCase, special, readFloat, atof64exact, atof32exact, atof32, atof64, ParseFloat, syntaxError, rangeError, baseError, bitSizeError, ParseUint, ParseInt, digitZero, trim, rightShift, prefixIsLessThan, leftShift, shouldRoundUp, frexp10Many, adjustLastDigitFixed, adjustLastDigit, FormatFloat, AppendFloat, genericFtoa, bigFtoa, formatDigits, roundShortest, fmtE, fmtF, fmtB, min, max, FormatUint, FormatInt, Itoa, AppendInt, AppendUint, small, formatBits, isPowerOfTwo, quoteWith, appendQuotedWith, appendQuotedRuneWith, appendEscapedRune, Quote, AppendQuote, QuoteToASCII, AppendQuoteToASCII, AppendQuoteRune, AppendQuoteRuneToASCII, CanBackquote, unhex, UnquoteChar, Unquote, contains, bsearch16, bsearch32, IsPrint, isInGraphicList; + errors = $packages["errors"]; + bytealg = $packages["internal/bytealg"]; + math = $packages["math"]; + bits = $packages["math/bits"]; + utf8 = $packages["unicode/utf8"]; + NumError = $pkg.NumError = $newType(0, $kindStruct, "strconv.NumError", true, "strconv", true, function(Func_, Num_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Func = ""; + this.Num = ""; + this.Err = $ifaceNil; + return; + } + this.Func = Func_; + this.Num = Num_; + this.Err = Err_; + }); + decimal = $pkg.decimal = $newType(0, $kindStruct, "strconv.decimal", true, "strconv", false, function(d_, nd_, dp_, neg_, trunc_) { + this.$val = this; + if (arguments.length === 0) { + this.d = arrayType.zero(); + this.nd = 0; + this.dp = 0; + this.neg = false; + this.trunc = false; + return; + } + this.d = d_; + this.nd = nd_; + this.dp = dp_; + this.neg = neg_; + this.trunc = trunc_; + }); + leftCheat = $pkg.leftCheat = $newType(0, $kindStruct, "strconv.leftCheat", true, "strconv", false, function(delta_, cutoff_) { + this.$val = this; + if (arguments.length === 0) { + this.delta = 0; + this.cutoff = ""; + return; + } + this.delta = delta_; + this.cutoff = cutoff_; + }); + extFloat = $pkg.extFloat = $newType(0, $kindStruct, "strconv.extFloat", true, "strconv", false, function(mant_, exp_, neg_) { + this.$val = this; + if (arguments.length === 0) { + this.mant = new $Uint64(0, 0); + this.exp = 0; + this.neg = false; + return; + } + this.mant = mant_; + this.exp = exp_; + this.neg = neg_; + }); + floatInfo = $pkg.floatInfo = $newType(0, $kindStruct, "strconv.floatInfo", true, "strconv", false, function(mantbits_, expbits_, bias_) { + this.$val = this; + if (arguments.length === 0) { + this.mantbits = 0; + this.expbits = 0; + this.bias = 0; + return; + } + this.mantbits = mantbits_; + this.expbits = expbits_; + this.bias = bias_; + }); + decimalSlice = $pkg.decimalSlice = $newType(0, $kindStruct, "strconv.decimalSlice", true, "strconv", false, function(d_, nd_, dp_, neg_) { + this.$val = this; + if (arguments.length === 0) { + this.d = sliceType$6.nil; + this.nd = 0; + this.dp = 0; + this.neg = false; + return; + } + this.d = d_; + this.nd = nd_; + this.dp = dp_; + this.neg = neg_; + }); + sliceType = $sliceType($Int); + sliceType$1 = $sliceType($Float64); + sliceType$2 = $sliceType($Float32); + sliceType$3 = $sliceType(leftCheat); + sliceType$4 = $sliceType($Uint16); + sliceType$5 = $sliceType($Uint32); + arrayType = $arrayType($Uint8, 800); + sliceType$6 = $sliceType($Uint8); + ptrType = $ptrType(NumError); + arrayType$1 = $arrayType($Uint8, 24); + arrayType$2 = $arrayType($Uint8, 32); + ptrType$1 = $ptrType(floatInfo); + arrayType$3 = $arrayType($Uint8, 65); + arrayType$4 = $arrayType($Uint8, 4); + ptrType$2 = $ptrType(decimal); + ptrType$3 = $ptrType(decimalSlice); + ptrType$4 = $ptrType(extFloat); + equalIgnoreCase = function(s1, s2) { + var c1, c2, i, s1, s2; + if (!((s1.length === s2.length))) { + return false; + } + i = 0; + while (true) { + if (!(i < s1.length)) { break; } + c1 = s1.charCodeAt(i); + if (65 <= c1 && c1 <= 90) { + c1 = c1 + (32) << 24 >>> 24; + } + c2 = s2.charCodeAt(i); + if (65 <= c2 && c2 <= 90) { + c2 = c2 + (32) << 24 >>> 24; + } + if (!((c1 === c2))) { + return false; + } + i = i + (1) >> 0; + } + return true; + }; + special = function(s) { + var _1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, f, ok, s; + f = 0; + ok = false; + if (s.length === 0) { + return [f, ok]; + } + _1 = s.charCodeAt(0); + if (_1 === (43)) { + if (equalIgnoreCase(s, "+inf") || equalIgnoreCase(s, "+infinity")) { + _tmp = math.Inf(1); + _tmp$1 = true; + f = _tmp; + ok = _tmp$1; + return [f, ok]; + } + } else if (_1 === (45)) { + if (equalIgnoreCase(s, "-inf") || equalIgnoreCase(s, "-infinity")) { + _tmp$2 = math.Inf(-1); + _tmp$3 = true; + f = _tmp$2; + ok = _tmp$3; + return [f, ok]; + } + } else if ((_1 === (110)) || (_1 === (78))) { + if (equalIgnoreCase(s, "nan")) { + _tmp$4 = math.NaN(); + _tmp$5 = true; + f = _tmp$4; + ok = _tmp$5; + return [f, ok]; + } + } else if ((_1 === (105)) || (_1 === (73))) { + if (equalIgnoreCase(s, "inf") || equalIgnoreCase(s, "infinity")) { + _tmp$6 = math.Inf(1); + _tmp$7 = true; + f = _tmp$6; + ok = _tmp$7; + return [f, ok]; + } + } else { + return [f, ok]; + } + return [f, ok]; + }; + decimal.ptr.prototype.set = function(s) { + var b, e, esign, i, ok, s, sawdigits, sawdot, x, x$1; + ok = false; + b = this; + i = 0; + b.neg = false; + b.trunc = false; + if (i >= s.length) { + return ok; + } + if ((s.charCodeAt(i) === 43)) { + i = i + (1) >> 0; + } else if ((s.charCodeAt(i) === 45)) { + b.neg = true; + i = i + (1) >> 0; + } + sawdot = false; + sawdigits = false; + while (true) { + if (!(i < s.length)) { break; } + if ((s.charCodeAt(i) === 46)) { + if (sawdot) { + return ok; + } + sawdot = true; + b.dp = b.nd; + i = i + (1) >> 0; + continue; + } else if (48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57) { + sawdigits = true; + if ((s.charCodeAt(i) === 48) && (b.nd === 0)) { + b.dp = b.dp - (1) >> 0; + i = i + (1) >> 0; + continue; + } + if (b.nd < 800) { + (x = b.d, x$1 = b.nd, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1] = s.charCodeAt(i))); + b.nd = b.nd + (1) >> 0; + } else if (!((s.charCodeAt(i) === 48))) { + b.trunc = true; + } + i = i + (1) >> 0; + continue; + } + break; + } + if (!sawdigits) { + return ok; + } + if (!sawdot) { + b.dp = b.nd; + } + if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) { + i = i + (1) >> 0; + if (i >= s.length) { + return ok; + } + esign = 1; + if (s.charCodeAt(i) === 43) { + i = i + (1) >> 0; + } else if (s.charCodeAt(i) === 45) { + i = i + (1) >> 0; + esign = -1; + } + if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) { + return ok; + } + e = 0; + while (true) { + if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; } + if (e < 10000) { + e = (($imul(e, 10)) + ((s.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; + } + i = i + (1) >> 0; + } + b.dp = b.dp + (($imul(e, esign))) >> 0; + } + if (!((i === s.length))) { + return ok; + } + ok = true; + return ok; + }; + decimal.prototype.set = function(s) { return this.$val.set(s); }; + readFloat = function(s) { + var _1, c, dp, e, esign, exp, i, mantissa, nd, ndMant, neg, ok, s, sawdigits, sawdot, trunc, x; + mantissa = new $Uint64(0, 0); + exp = 0; + neg = false; + trunc = false; + ok = false; + i = 0; + if (i >= s.length) { + return [mantissa, exp, neg, trunc, ok]; + } + if ((s.charCodeAt(i) === 43)) { + i = i + (1) >> 0; + } else if ((s.charCodeAt(i) === 45)) { + neg = true; + i = i + (1) >> 0; + } + sawdot = false; + sawdigits = false; + nd = 0; + ndMant = 0; + dp = 0; + while (true) { + if (!(i < s.length)) { break; } + c = s.charCodeAt(i); + _1 = true; + if (_1 === ((c === 46))) { + if (sawdot) { + return [mantissa, exp, neg, trunc, ok]; + } + sawdot = true; + dp = nd; + i = i + (1) >> 0; + continue; + } else if (_1 === (48 <= c && c <= 57)) { + sawdigits = true; + if ((c === 48) && (nd === 0)) { + dp = dp - (1) >> 0; + i = i + (1) >> 0; + continue; + } + nd = nd + (1) >> 0; + if (ndMant < 19) { + mantissa = $mul64(mantissa, (new $Uint64(0, 10))); + mantissa = (x = (new $Uint64(0, (c - 48 << 24 >>> 24))), new $Uint64(mantissa.$high + x.$high, mantissa.$low + x.$low)); + ndMant = ndMant + (1) >> 0; + } else if (!((s.charCodeAt(i) === 48))) { + trunc = true; + } + i = i + (1) >> 0; + continue; + } + break; + } + if (!sawdigits) { + return [mantissa, exp, neg, trunc, ok]; + } + if (!sawdot) { + dp = nd; + } + if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) { + i = i + (1) >> 0; + if (i >= s.length) { + return [mantissa, exp, neg, trunc, ok]; + } + esign = 1; + if (s.charCodeAt(i) === 43) { + i = i + (1) >> 0; + } else if (s.charCodeAt(i) === 45) { + i = i + (1) >> 0; + esign = -1; + } + if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) { + return [mantissa, exp, neg, trunc, ok]; + } + e = 0; + while (true) { + if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; } + if (e < 10000) { + e = (($imul(e, 10)) + ((s.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; + } + i = i + (1) >> 0; + } + dp = dp + (($imul(e, esign))) >> 0; + } + if (!((i === s.length))) { + return [mantissa, exp, neg, trunc, ok]; + } + if (!((mantissa.$high === 0 && mantissa.$low === 0))) { + exp = dp - ndMant >> 0; + } + ok = true; + return [mantissa, exp, neg, trunc, ok]; + }; + decimal.ptr.prototype.floatBits = function(flt) { + var _tmp, _tmp$1, b, bits$1, d, exp, flt, mant, n, n$1, n$2, overflow, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, y$1, y$2, y$3, $s; + /* */ $s = 0; s: while (true) { switch ($s) { case 0: + b = new $Uint64(0, 0); + overflow = false; + d = this; + exp = 0; + mant = new $Uint64(0, 0); + /* */ if (d.nd === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (d.nd === 0) { */ case 1: + mant = new $Uint64(0, 0); + exp = flt.bias; + /* goto out */ $s = 3; continue; + /* } */ case 2: + /* */ if (d.dp > 310) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (d.dp > 310) { */ case 4: + /* goto overflow */ $s = 6; continue; + /* } */ case 5: + /* */ if (d.dp < -330) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (d.dp < -330) { */ case 7: + mant = new $Uint64(0, 0); + exp = flt.bias; + /* goto out */ $s = 3; continue; + /* } */ case 8: + exp = 0; + while (true) { + if (!(d.dp > 0)) { break; } + n = 0; + if (d.dp >= powtab.$length) { + n = 27; + } else { + n = (x = d.dp, ((x < 0 || x >= powtab.$length) ? ($throwRuntimeError("index out of range"), undefined) : powtab.$array[powtab.$offset + x])); + } + d.Shift(-n); + exp = exp + (n) >> 0; + } + while (true) { + if (!(d.dp < 0 || (d.dp === 0) && d.d[0] < 53)) { break; } + n$1 = 0; + if (-d.dp >= powtab.$length) { + n$1 = 27; + } else { + n$1 = (x$1 = -d.dp, ((x$1 < 0 || x$1 >= powtab.$length) ? ($throwRuntimeError("index out of range"), undefined) : powtab.$array[powtab.$offset + x$1])); + } + d.Shift(n$1); + exp = exp - (n$1) >> 0; + } + exp = exp - (1) >> 0; + if (exp < (flt.bias + 1 >> 0)) { + n$2 = (flt.bias + 1 >> 0) - exp >> 0; + d.Shift(-n$2); + exp = exp + (n$2) >> 0; + } + /* */ if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { */ case 9: + /* goto overflow */ $s = 6; continue; + /* } */ case 10: + d.Shift((((1 + flt.mantbits >>> 0) >> 0))); + mant = d.RoundedInteger(); + /* */ if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { */ case 11: + mant = $shiftRightUint64(mant, (1)); + exp = exp + (1) >> 0; + /* */ if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { */ case 13: + /* goto overflow */ $s = 6; continue; + /* } */ case 14: + /* } */ case 12: + if ((x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$4.$high, (mant.$low & x$4.$low) >>> 0)), (x$3.$high === 0 && x$3.$low === 0))) { + exp = flt.bias; + } + /* goto out */ $s = 3; continue; + /* overflow: */ case 6: + mant = new $Uint64(0, 0); + exp = (((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0) + flt.bias >> 0; + overflow = true; + /* out: */ case 3: + bits$1 = (x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$6.$high - 0, x$6.$low - 1)), new $Uint64(mant.$high & x$5.$high, (mant.$low & x$5.$low) >>> 0)); + bits$1 = (x$7 = $shiftLeft64((new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$3 = flt.expbits, y$3 < 32 ? (1 << y$3) : 0) >> 0) - 1 >> 0))))), flt.mantbits), new $Uint64(bits$1.$high | x$7.$high, (bits$1.$low | x$7.$low) >>> 0)); + if (d.neg) { + bits$1 = (x$8 = $shiftLeft64($shiftLeft64(new $Uint64(0, 1), flt.mantbits), flt.expbits), new $Uint64(bits$1.$high | x$8.$high, (bits$1.$low | x$8.$low) >>> 0)); + } + _tmp = bits$1; + _tmp$1 = overflow; + b = _tmp; + overflow = _tmp$1; + $s = -1; return [b, overflow]; + /* */ } return; } + }; + decimal.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; + atof64exact = function(mantissa, exp, neg) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2; + f = 0; + ok = false; + if (!((x = $shiftRightUint64(mantissa, float64info.mantbits), (x.$high === 0 && x.$low === 0)))) { + return [f, ok]; + } + f = ($flatten64(mantissa)); + if (neg) { + f = -f; + } + if ((exp === 0)) { + _tmp = f; + _tmp$1 = true; + f = _tmp; + ok = _tmp$1; + return [f, ok]; + } else if (exp > 0 && exp <= 37) { + if (exp > 22) { + f = f * ((x$1 = exp - 22 >> 0, ((x$1 < 0 || x$1 >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + x$1]))); + exp = 22; + } + if (f > 1e+15 || f < -1e+15) { + return [f, ok]; + } + _tmp$2 = f * ((exp < 0 || exp >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + exp]); + _tmp$3 = true; + f = _tmp$2; + ok = _tmp$3; + return [f, ok]; + } else if (exp < 0 && exp >= -22) { + _tmp$4 = f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + x$2])); + _tmp$5 = true; + f = _tmp$4; + ok = _tmp$5; + return [f, ok]; + } + return [f, ok]; + }; + atof32exact = function(mantissa, exp, neg) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2; + f = 0; + ok = false; + if (!((x = $shiftRightUint64(mantissa, float32info.mantbits), (x.$high === 0 && x.$low === 0)))) { + return [f, ok]; + } + f = ($flatten64(mantissa)); + if (neg) { + f = -f; + } + if ((exp === 0)) { + _tmp = f; + _tmp$1 = true; + f = _tmp; + ok = _tmp$1; + return [f, ok]; + } else if (exp > 0 && exp <= 17) { + if (exp > 10) { + f = $fround(f * ((x$1 = exp - 10 >> 0, ((x$1 < 0 || x$1 >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + x$1])))); + exp = 10; + } + if (f > 1e+07 || f < -1e+07) { + return [f, ok]; + } + _tmp$2 = $fround(f * ((exp < 0 || exp >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + exp])); + _tmp$3 = true; + f = _tmp$2; + ok = _tmp$3; + return [f, ok]; + } else if (exp < 0 && exp >= -10) { + _tmp$4 = $fround(f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + x$2]))); + _tmp$5 = true; + f = _tmp$4; + ok = _tmp$5; + return [f, ok]; + } + return [f, ok]; + }; + atof32 = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val; + f = 0; + err = $ifaceNil; + _tuple = special(s); + val = _tuple[0]; + ok = _tuple[1]; + if (ok) { + _tmp = ($fround(val)); + _tmp$1 = $ifaceNil; + f = _tmp; + err = _tmp$1; + return [f, err]; + } + if (optimize) { + _tuple$1 = readFloat(s); + mantissa = _tuple$1[0]; + exp = _tuple$1[1]; + neg = _tuple$1[2]; + trunc = _tuple$1[3]; + ok$1 = _tuple$1[4]; + if (ok$1) { + if (!trunc) { + _tuple$2 = atof32exact(mantissa, exp, neg); + f$1 = _tuple$2[0]; + ok$2 = _tuple$2[1]; + if (ok$2) { + _tmp$2 = f$1; + _tmp$3 = $ifaceNil; + f = _tmp$2; + err = _tmp$3; + return [f, err]; + } + } + ext = new extFloat.ptr(new $Uint64(0, 0), 0, false); + ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float32info); + if (ok$3) { + _tuple$3 = ext.floatBits(float32info); + b = _tuple$3[0]; + ovf = _tuple$3[1]; + f = math.Float32frombits(((b.$low >>> 0))); + if (ovf) { + err = rangeError("ParseFloat", s); + } + _tmp$4 = f; + _tmp$5 = err; + f = _tmp$4; + err = _tmp$5; + return [f, err]; + } + } + } + d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + if (!d.set(s)) { + _tmp$6 = 0; + _tmp$7 = syntaxError("ParseFloat", s); + f = _tmp$6; + err = _tmp$7; + return [f, err]; + } + _tuple$4 = d.floatBits(float32info); + b$1 = _tuple$4[0]; + ovf$1 = _tuple$4[1]; + f = math.Float32frombits(((b$1.$low >>> 0))); + if (ovf$1) { + err = rangeError("ParseFloat", s); + } + _tmp$8 = f; + _tmp$9 = err; + f = _tmp$8; + err = _tmp$9; + return [f, err]; + }; + atof64 = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val; + f = 0; + err = $ifaceNil; + _tuple = special(s); + val = _tuple[0]; + ok = _tuple[1]; + if (ok) { + _tmp = val; + _tmp$1 = $ifaceNil; + f = _tmp; + err = _tmp$1; + return [f, err]; + } + if (optimize) { + _tuple$1 = readFloat(s); + mantissa = _tuple$1[0]; + exp = _tuple$1[1]; + neg = _tuple$1[2]; + trunc = _tuple$1[3]; + ok$1 = _tuple$1[4]; + if (ok$1) { + if (!trunc) { + _tuple$2 = atof64exact(mantissa, exp, neg); + f$1 = _tuple$2[0]; + ok$2 = _tuple$2[1]; + if (ok$2) { + _tmp$2 = f$1; + _tmp$3 = $ifaceNil; + f = _tmp$2; + err = _tmp$3; + return [f, err]; + } + } + ext = new extFloat.ptr(new $Uint64(0, 0), 0, false); + ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float64info); + if (ok$3) { + _tuple$3 = ext.floatBits(float64info); + b = _tuple$3[0]; + ovf = _tuple$3[1]; + f = math.Float64frombits(b); + if (ovf) { + err = rangeError("ParseFloat", s); + } + _tmp$4 = f; + _tmp$5 = err; + f = _tmp$4; + err = _tmp$5; + return [f, err]; + } + } + } + d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + if (!d.set(s)) { + _tmp$6 = 0; + _tmp$7 = syntaxError("ParseFloat", s); + f = _tmp$6; + err = _tmp$7; + return [f, err]; + } + _tuple$4 = d.floatBits(float64info); + b$1 = _tuple$4[0]; + ovf$1 = _tuple$4[1]; + f = math.Float64frombits(b$1); + if (ovf$1) { + err = rangeError("ParseFloat", s); + } + _tmp$8 = f; + _tmp$9 = err; + f = _tmp$8; + err = _tmp$9; + return [f, err]; + }; + ParseFloat = function(s, bitSize) { + var _tuple, bitSize, err, f, s; + if (bitSize === 32) { + _tuple = atof32(s); + f = _tuple[0]; + err = _tuple[1]; + return [(f), err]; + } + return atof64(s); + }; + $pkg.ParseFloat = ParseFloat; + NumError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return "strconv." + e.Func + ": " + "parsing " + Quote(e.Num) + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: NumError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + NumError.prototype.Error = function() { return this.$val.Error(); }; + syntaxError = function(fn, str) { + var fn, str; + return new NumError.ptr(fn, str, $pkg.ErrSyntax); + }; + rangeError = function(fn, str) { + var fn, str; + return new NumError.ptr(fn, str, $pkg.ErrRange); + }; + baseError = function(fn, str, base) { + var base, fn, str; + return new NumError.ptr(fn, str, errors.New("invalid base " + Itoa(base))); + }; + bitSizeError = function(fn, str, bitSize) { + var bitSize, fn, str; + return new NumError.ptr(fn, str, errors.New("invalid bit size " + Itoa(bitSize))); + }; + ParseUint = function(s, base, bitSize) { + var _1, _i, _ref, base, bitSize, c, cutoff, d, maxVal, n, n1, s, s0, x, x$1, x$2; + if (s.length === 0) { + return [new $Uint64(0, 0), syntaxError("ParseUint", s)]; + } + s0 = s; + if (2 <= base && base <= 36) { + } else if ((base === 0)) { + if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { + if (s.length < 3) { + return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; + } + base = 16; + s = $substring(s, 2); + } else if ((s.charCodeAt(0) === 48)) { + base = 8; + s = $substring(s, 1); + } else { + base = 10; + } + } else { + return [new $Uint64(0, 0), baseError("ParseUint", s0, base)]; + } + if (bitSize === 0) { + bitSize = 32; + } else if (bitSize < 0 || bitSize > 64) { + return [new $Uint64(0, 0), bitSizeError("ParseUint", s0, bitSize)]; + } + cutoff = new $Uint64(0, 0); + _1 = base; + if (_1 === (10)) { + cutoff = new $Uint64(429496729, 2576980378); + } else if (_1 === (16)) { + cutoff = new $Uint64(268435456, 0); + } else { + cutoff = (x = $div64(new $Uint64(4294967295, 4294967295), (new $Uint64(0, base)), false), new $Uint64(x.$high + 0, x.$low + 1)); + } + maxVal = (x$1 = $shiftLeft64(new $Uint64(0, 1), ((bitSize >>> 0))), new $Uint64(x$1.$high - 0, x$1.$low - 1)); + n = new $Uint64(0, 0); + _ref = (new sliceType$6($stringToBytes(s))); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + d = 0; + if (48 <= c && c <= 57) { + d = c - 48 << 24 >>> 24; + } else if (97 <= c && c <= 122) { + d = (c - 97 << 24 >>> 24) + 10 << 24 >>> 24; + } else if (65 <= c && c <= 90) { + d = (c - 65 << 24 >>> 24) + 10 << 24 >>> 24; + } else { + return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; + } + if (d >= ((base << 24 >>> 24))) { + return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; + } + if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { + return [maxVal, rangeError("ParseUint", s0)]; + } + n = $mul64(n, ((new $Uint64(0, base)))); + n1 = (x$2 = (new $Uint64(0, d)), new $Uint64(n.$high + x$2.$high, n.$low + x$2.$low)); + if ((n1.$high < n.$high || (n1.$high === n.$high && n1.$low < n.$low)) || (n1.$high > maxVal.$high || (n1.$high === maxVal.$high && n1.$low > maxVal.$low))) { + return [maxVal, rangeError("ParseUint", s0)]; + } + n = n1; + _i++; + } + return [n, $ifaceNil]; + }; + $pkg.ParseUint = ParseUint; + ParseInt = function(s, base, bitSize) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, base, bitSize, cutoff, err, i, n, neg, s, s0, un, x, x$1; + i = new $Int64(0, 0); + err = $ifaceNil; + if (s.length === 0) { + _tmp = new $Int64(0, 0); + _tmp$1 = syntaxError("ParseInt", s); + i = _tmp; + err = _tmp$1; + return [i, err]; + } + s0 = s; + neg = false; + if (s.charCodeAt(0) === 43) { + s = $substring(s, 1); + } else if (s.charCodeAt(0) === 45) { + neg = true; + s = $substring(s, 1); + } + un = new $Uint64(0, 0); + _tuple = ParseUint(s, base, bitSize); + un = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil)) && !($interfaceIsEqual($assertType(err, ptrType).Err, $pkg.ErrRange))) { + $assertType(err, ptrType).Func = "ParseInt"; + $assertType(err, ptrType).Num = s0; + _tmp$2 = new $Int64(0, 0); + _tmp$3 = err; + i = _tmp$2; + err = _tmp$3; + return [i, err]; + } + if (bitSize === 0) { + bitSize = 32; + } + cutoff = ($shiftLeft64(new $Uint64(0, 1), (((bitSize - 1 >> 0) >>> 0)))); + if (!neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low >= cutoff.$low))) { + _tmp$4 = ((x = new $Uint64(cutoff.$high - 0, cutoff.$low - 1), new $Int64(x.$high, x.$low))); + _tmp$5 = rangeError("ParseInt", s0); + i = _tmp$4; + err = _tmp$5; + return [i, err]; + } + if (neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low > cutoff.$low))) { + _tmp$6 = (x$1 = (new $Int64(cutoff.$high, cutoff.$low)), new $Int64(-x$1.$high, -x$1.$low)); + _tmp$7 = rangeError("ParseInt", s0); + i = _tmp$6; + err = _tmp$7; + return [i, err]; + } + n = (new $Int64(un.$high, un.$low)); + if (neg) { + n = new $Int64(-n.$high, -n.$low); + } + _tmp$8 = n; + _tmp$9 = $ifaceNil; + i = _tmp$8; + err = _tmp$9; + return [i, err]; + }; + $pkg.ParseInt = ParseInt; + decimal.ptr.prototype.String = function() { + var a, buf, n, w; + a = this; + n = 10 + a.nd >> 0; + if (a.dp > 0) { + n = n + (a.dp) >> 0; + } + if (a.dp < 0) { + n = n + (-a.dp) >> 0; + } + buf = $makeSlice(sliceType$6, n); + w = 0; + if ((a.nd === 0)) { + return "0"; + } else if (a.dp <= 0) { + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); + w = w + (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + w = w + (1) >> 0; + w = w + (digitZero($subslice(buf, w, (w + -a.dp >> 0)))) >> 0; + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; + } else if (a.dp < a.nd) { + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.dp))) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + w = w + (1) >> 0; + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), a.dp, a.nd))) >> 0; + } else { + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; + w = w + (digitZero($subslice(buf, w, ((w + a.dp >> 0) - a.nd >> 0)))) >> 0; + } + return ($bytesToString($subslice(buf, 0, w))); + }; + decimal.prototype.String = function() { return this.$val.String(); }; + digitZero = function(dst) { + var _i, _ref, dst, i; + _ref = dst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + i] = 48); + _i++; + } + return dst.$length; + }; + trim = function(a) { + var a, x, x$1; + while (true) { + if (!(a.nd > 0 && ((x = a.d, x$1 = a.nd - 1 >> 0, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])) === 48))) { break; } + a.nd = a.nd - (1) >> 0; + } + if (a.nd === 0) { + a.dp = 0; + } + }; + decimal.ptr.prototype.Assign = function(v) { + var a, buf, n, v, v1, x, x$1, x$2; + a = this; + buf = arrayType$1.zero(); + n = 0; + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + v1 = $div64(v, new $Uint64(0, 10), false); + v = (x = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x.$high, v.$low - x.$low)); + ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); + n = n + (1) >> 0; + v = v1; + } + a.nd = 0; + n = n - (1) >> 0; + while (true) { + if (!(n >= 0)) { break; } + (x$1 = a.d, x$2 = a.nd, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2] = ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n]))); + a.nd = a.nd + (1) >> 0; + n = n - (1) >> 0; + } + a.dp = a.nd; + trim(a); + }; + decimal.prototype.Assign = function(v) { return this.$val.Assign(v); }; + rightShift = function(a, k) { + var a, c, c$1, dig, dig$1, k, mask, n, r, w, x, x$1, x$2, x$3, y, y$1, y$2, y$3, y$4; + r = 0; + w = 0; + n = 0; + while (true) { + if (!(((y = k, y < 32 ? (n >>> y) : 0) >>> 0) === 0)) { break; } + if (r >= a.nd) { + if (n === 0) { + a.nd = 0; + return; + } + while (true) { + if (!(((y$1 = k, y$1 < 32 ? (n >>> y$1) : 0) >>> 0) === 0)) { break; } + n = n * 10 >>> 0; + r = r + (1) >> 0; + } + break; + } + c = (((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)); + n = ((n * 10 >>> 0) + c >>> 0) - 48 >>> 0; + r = r + (1) >> 0; + } + a.dp = a.dp - ((r - 1 >> 0)) >> 0; + mask = (((y$2 = k, y$2 < 32 ? (1 << y$2) : 0) >>> 0)) - 1 >>> 0; + while (true) { + if (!(r < a.nd)) { break; } + c$1 = (((x$1 = a.d, ((r < 0 || r >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[r])) >>> 0)); + dig = (y$3 = k, y$3 < 32 ? (n >>> y$3) : 0) >>> 0; + n = (n & (mask)) >>> 0; + (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((dig + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + n = ((n * 10 >>> 0) + c$1 >>> 0) - 48 >>> 0; + r = r + (1) >> 0; + } + while (true) { + if (!(n > 0)) { break; } + dig$1 = (y$4 = k, y$4 < 32 ? (n >>> y$4) : 0) >>> 0; + n = (n & (mask)) >>> 0; + if (w < 800) { + (x$3 = a.d, ((w < 0 || w >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[w] = (((dig$1 + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + } else if (dig$1 > 0) { + a.trunc = true; + } + n = n * 10 >>> 0; + } + a.nd = w; + trim(a); + }; + prefixIsLessThan = function(b, s) { + var b, i, s; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (i >= b.$length) { + return true; + } + if (!((((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) === s.charCodeAt(i)))) { + return ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) < s.charCodeAt(i); + } + i = i + (1) >> 0; + } + return false; + }; + leftShift = function(a, k) { + var _q, _q$1, a, delta, k, n, quo, quo$1, r, rem, rem$1, w, x, x$1, x$2, y; + delta = ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).delta; + if (prefixIsLessThan($subslice(new sliceType$6(a.d), 0, a.nd), ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).cutoff)) { + delta = delta - (1) >> 0; + } + r = a.nd; + w = a.nd + delta >> 0; + n = 0; + r = r - (1) >> 0; + while (true) { + if (!(r >= 0)) { break; } + n = n + (((y = k, y < 32 ? ((((((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)) - 48 >>> 0)) << y) : 0) >>> 0)) >>> 0; + quo = (_q = n / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + rem = n - (10 * quo >>> 0) >>> 0; + w = w - (1) >> 0; + if (w < 800) { + (x$1 = a.d, ((w < 0 || w >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[w] = (((rem + 48 >>> 0) << 24 >>> 24)))); + } else if (!((rem === 0))) { + a.trunc = true; + } + n = quo; + r = r - (1) >> 0; + } + while (true) { + if (!(n > 0)) { break; } + quo$1 = (_q$1 = n / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + rem$1 = n - (10 * quo$1 >>> 0) >>> 0; + w = w - (1) >> 0; + if (w < 800) { + (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((rem$1 + 48 >>> 0) << 24 >>> 24)))); + } else if (!((rem$1 === 0))) { + a.trunc = true; + } + n = quo$1; + } + a.nd = a.nd + (delta) >> 0; + if (a.nd >= 800) { + a.nd = 800; + } + a.dp = a.dp + (delta) >> 0; + trim(a); + }; + decimal.ptr.prototype.Shift = function(k) { + var a, k; + a = this; + if ((a.nd === 0)) { + } else if (k > 0) { + while (true) { + if (!(k > 28)) { break; } + leftShift(a, 28); + k = k - (28) >> 0; + } + leftShift(a, ((k >>> 0))); + } else if (k < 0) { + while (true) { + if (!(k < -28)) { break; } + rightShift(a, 28); + k = k + (28) >> 0; + } + rightShift(a, ((-k >>> 0))); + } + }; + decimal.prototype.Shift = function(k) { return this.$val.Shift(k); }; + shouldRoundUp = function(a, nd) { + var _r, a, nd, x, x$1, x$2, x$3; + if (nd < 0 || nd >= a.nd) { + return false; + } + if (((x = a.d, ((nd < 0 || nd >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[nd])) === 53) && ((nd + 1 >> 0) === a.nd)) { + if (a.trunc) { + return true; + } + return nd > 0 && !(((_r = (((x$1 = a.d, x$2 = nd - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2])) - 48 << 24 >>> 24)) % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0)); + } + return (x$3 = a.d, ((nd < 0 || nd >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[nd])) >= 53; + }; + decimal.ptr.prototype.Round = function(nd) { + var a, nd; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + if (shouldRoundUp(a, nd)) { + a.RoundUp(nd); + } else { + a.RoundDown(nd); + } + }; + decimal.prototype.Round = function(nd) { return this.$val.Round(nd); }; + decimal.ptr.prototype.RoundDown = function(nd) { + var a, nd; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + a.nd = nd; + trim(a); + }; + decimal.prototype.RoundDown = function(nd) { return this.$val.RoundDown(nd); }; + decimal.ptr.prototype.RoundUp = function(nd) { + var a, c, i, nd, x, x$1, x$2; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + i = nd - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + c = (x = a.d, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])); + if (c < 57) { + (x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = ((x$1 = a.d, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])) + (1) << 24 >>> 24))); + a.nd = i + 1 >> 0; + return; + } + i = i - (1) >> 0; + } + a.d[0] = 49; + a.nd = 1; + a.dp = a.dp + (1) >> 0; + }; + decimal.prototype.RoundUp = function(nd) { return this.$val.RoundUp(nd); }; + decimal.ptr.prototype.RoundedInteger = function() { + var a, i, n, x, x$1, x$2, x$3; + a = this; + if (a.dp > 20) { + return new $Uint64(4294967295, 4294967295); + } + i = 0; + n = new $Uint64(0, 0); + i = 0; + while (true) { + if (!(i < a.dp && i < a.nd)) { break; } + n = (x = $mul64(n, new $Uint64(0, 10)), x$1 = (new $Uint64(0, ((x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i])) - 48 << 24 >>> 24))), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + i = i + (1) >> 0; + } + while (true) { + if (!(i < a.dp)) { break; } + n = $mul64(n, (new $Uint64(0, 10))); + i = i + (1) >> 0; + } + if (shouldRoundUp(a, a.dp)) { + n = (x$3 = new $Uint64(0, 1), new $Uint64(n.$high + x$3.$high, n.$low + x$3.$low)); + } + return n; + }; + decimal.prototype.RoundedInteger = function() { return this.$val.RoundedInteger(); }; + extFloat.ptr.prototype.floatBits = function(flt) { + var bits$1, exp, f, flt, mant, n, overflow, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2; + bits$1 = new $Uint64(0, 0); + overflow = false; + f = this; + f.Normalize(); + exp = f.exp + 63 >> 0; + if (exp < (flt.bias + 1 >> 0)) { + n = (flt.bias + 1 >> 0) - exp >> 0; + f.mant = $shiftRightUint64(f.mant, (((n >>> 0)))); + exp = exp + (n) >> 0; + } + mant = $shiftRightUint64(f.mant, ((63 - flt.mantbits >>> 0))); + if (!((x = (x$1 = f.mant, x$2 = $shiftLeft64(new $Uint64(0, 1), ((62 - flt.mantbits >>> 0))), new $Uint64(x$1.$high & x$2.$high, (x$1.$low & x$2.$low) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + mant = (x$3 = new $Uint64(0, 1), new $Uint64(mant.$high + x$3.$high, mant.$low + x$3.$low)); + } + if ((x$4 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$4.$high && mant.$low === x$4.$low))) { + mant = $shiftRightUint64(mant, (1)); + exp = exp + (1) >> 0; + } + if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { + mant = new $Uint64(0, 0); + exp = (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0) + flt.bias >> 0; + overflow = true; + } else if ((x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$6.$high, (mant.$low & x$6.$low) >>> 0)), (x$5.$high === 0 && x$5.$low === 0))) { + exp = flt.bias; + } + bits$1 = (x$7 = (x$8 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$8.$high - 0, x$8.$low - 1)), new $Uint64(mant.$high & x$7.$high, (mant.$low & x$7.$low) >>> 0)); + bits$1 = (x$9 = $shiftLeft64((new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0))))), flt.mantbits), new $Uint64(bits$1.$high | x$9.$high, (bits$1.$low | x$9.$low) >>> 0)); + if (f.neg) { + bits$1 = (x$10 = $shiftLeft64(new $Uint64(0, 1), ((flt.mantbits + flt.expbits >>> 0))), new $Uint64(bits$1.$high | x$10.$high, (bits$1.$low | x$10.$low) >>> 0)); + } + return [bits$1, overflow]; + }; + extFloat.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; + extFloat.ptr.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { + var _tmp, _tmp$1, exp, expBiased, f, flt, lower, mant, neg, upper, x, x$1, x$2, x$3, x$4; + lower = new extFloat.ptr(new $Uint64(0, 0), 0, false); + upper = new extFloat.ptr(new $Uint64(0, 0), 0, false); + f = this; + f.mant = mant; + f.exp = exp - ((flt.mantbits >> 0)) >> 0; + f.neg = neg; + if (f.exp <= 0 && (x = $shiftLeft64(($shiftRightUint64(mant, ((-f.exp >>> 0)))), ((-f.exp >>> 0))), (mant.$high === x.$high && mant.$low === x.$low))) { + f.mant = $shiftRightUint64(f.mant, (((-f.exp >>> 0)))); + f.exp = 0; + _tmp = $clone(f, extFloat); + _tmp$1 = $clone(f, extFloat); + extFloat.copy(lower, _tmp); + extFloat.copy(upper, _tmp$1); + return [lower, upper]; + } + expBiased = exp - flt.bias >> 0; + extFloat.copy(upper, new extFloat.ptr((x$1 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$1.$high + 0, x$1.$low + 1)), f.exp - 1 >> 0, f.neg)); + if (!((x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) || (expBiased === 1)) { + extFloat.copy(lower, new extFloat.ptr((x$3 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$3.$high - 0, x$3.$low - 1)), f.exp - 1 >> 0, f.neg)); + } else { + extFloat.copy(lower, new extFloat.ptr((x$4 = $mul64(new $Uint64(0, 4), f.mant), new $Uint64(x$4.$high - 0, x$4.$low - 1)), f.exp - 2 >> 0, f.neg)); + } + return [lower, upper]; + }; + extFloat.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { return this.$val.AssignComputeBounds(mant, exp, neg, flt); }; + extFloat.ptr.prototype.Normalize = function() { + var f, shift, x; + f = this; + if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { + return 0; + } + shift = bits.LeadingZeros64(f.mant); + f.mant = $shiftLeft64(f.mant, (((shift >>> 0)))); + f.exp = f.exp - (shift) >> 0; + return ((shift >>> 0)); + }; + extFloat.prototype.Normalize = function() { return this.$val.Normalize(); }; + extFloat.ptr.prototype.Multiply = function(g) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, cross1, cross2, f, fhi, flo, g, ghi, glo, rem, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + _tmp = $shiftRightUint64(f.mant, 32); + _tmp$1 = (new $Uint64(0, ((f.mant.$low >>> 0)))); + fhi = _tmp; + flo = _tmp$1; + _tmp$2 = $shiftRightUint64(g.mant, 32); + _tmp$3 = (new $Uint64(0, ((g.mant.$low >>> 0)))); + ghi = _tmp$2; + glo = _tmp$3; + cross1 = $mul64(fhi, glo); + cross2 = $mul64(flo, ghi); + f.mant = (x = (x$1 = $mul64(fhi, ghi), x$2 = $shiftRightUint64(cross1, 32), new $Uint64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)), x$3 = $shiftRightUint64(cross2, 32), new $Uint64(x.$high + x$3.$high, x.$low + x$3.$low)); + rem = (x$4 = (x$5 = (new $Uint64(0, ((cross1.$low >>> 0)))), x$6 = (new $Uint64(0, ((cross2.$low >>> 0)))), new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), x$7 = $shiftRightUint64(($mul64(flo, glo)), 32), new $Uint64(x$4.$high + x$7.$high, x$4.$low + x$7.$low)); + rem = (x$8 = new $Uint64(0, 2147483648), new $Uint64(rem.$high + x$8.$high, rem.$low + x$8.$low)); + f.mant = (x$9 = f.mant, x$10 = ($shiftRightUint64(rem, 32)), new $Uint64(x$9.$high + x$10.$high, x$9.$low + x$10.$low)); + f.exp = (f.exp + g.exp >> 0) + 64 >> 0; + }; + extFloat.prototype.Multiply = function(g) { return this.$val.Multiply(g); }; + extFloat.ptr.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { + var _q, _r, adjExp, denormalExp, errors$1, exp10, extrabits, f, flt, halfway, i, mant_extra, mantissa, neg, ok, shift, trunc, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y; + ok = false; + f = this; + errors$1 = 0; + if (trunc) { + errors$1 = errors$1 + (4) >> 0; + } + f.mant = mantissa; + f.exp = 0; + f.neg = neg; + i = (_q = ((exp10 - -348 >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + if (exp10 < -348 || i >= 87) { + ok = false; + return ok; + } + adjExp = (_r = ((exp10 - -348 >> 0)) % 8, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); + if (adjExp < 19 && (x = (x$1 = 19 - adjExp >> 0, ((x$1 < 0 || x$1 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$1])), (mantissa.$high < x.$high || (mantissa.$high === x.$high && mantissa.$low < x.$low)))) { + f.mant = $mul64(f.mant, (((adjExp < 0 || adjExp >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[adjExp]))); + f.Normalize(); + } else { + f.Normalize(); + f.Multiply($clone(((adjExp < 0 || adjExp >= smallPowersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : smallPowersOfTen[adjExp]), extFloat)); + errors$1 = errors$1 + (4) >> 0; + } + f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + if (errors$1 > 0) { + errors$1 = errors$1 + (1) >> 0; + } + errors$1 = errors$1 + (4) >> 0; + shift = f.Normalize(); + errors$1 = (y = (shift), y < 32 ? (errors$1 << y) : 0) >> 0; + denormalExp = flt.bias - 63 >> 0; + extrabits = 0; + if (f.exp <= denormalExp) { + extrabits = ((63 - flt.mantbits >>> 0) + 1 >>> 0) + (((denormalExp - f.exp >> 0) >>> 0)) >>> 0; + } else { + extrabits = 63 - flt.mantbits >>> 0; + } + halfway = $shiftLeft64(new $Uint64(0, 1), ((extrabits - 1 >>> 0))); + mant_extra = (x$2 = f.mant, x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), extrabits), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); + if ((x$5 = (x$6 = (new $Int64(halfway.$high, halfway.$low)), x$7 = (new $Int64(0, errors$1)), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), x$8 = (new $Int64(mant_extra.$high, mant_extra.$low)), (x$5.$high < x$8.$high || (x$5.$high === x$8.$high && x$5.$low < x$8.$low))) && (x$9 = (new $Int64(mant_extra.$high, mant_extra.$low)), x$10 = (x$11 = (new $Int64(halfway.$high, halfway.$low)), x$12 = (new $Int64(0, errors$1)), new $Int64(x$11.$high + x$12.$high, x$11.$low + x$12.$low)), (x$9.$high < x$10.$high || (x$9.$high === x$10.$high && x$9.$low < x$10.$low)))) { + ok = false; + return ok; + } + ok = true; + return ok; + }; + extFloat.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { return this.$val.AssignDecimal(mantissa, exp10, neg, trunc, flt); }; + extFloat.ptr.prototype.frexp10 = function() { + var _q, _q$1, _tmp, _tmp$1, approxExp10, exp, exp10, f, i, index; + exp10 = 0; + index = 0; + f = this; + approxExp10 = (_q = ($imul(((-46 - f.exp >> 0)), 28)) / 93, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + i = (_q$1 = ((approxExp10 - -348 >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + Loop: + while (true) { + exp = (f.exp + ((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]).exp >> 0) + 64 >> 0; + if (exp < -60) { + i = i + (1) >> 0; + } else if (exp > -32) { + i = i - (1) >> 0; + } else { + break Loop; + } + } + f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + _tmp = -((-348 + ($imul(i, 8)) >> 0)); + _tmp$1 = i; + exp10 = _tmp; + index = _tmp$1; + return [exp10, index]; + }; + extFloat.prototype.frexp10 = function() { return this.$val.frexp10(); }; + frexp10Many = function(a, b, c) { + var _tuple, a, b, c, exp10, i; + exp10 = 0; + _tuple = c.frexp10(); + exp10 = _tuple[0]; + i = _tuple[1]; + a.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + b.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + return exp10; + }; + extFloat.ptr.prototype.FixedDecimal = function(d, n) { + var $CE$B5, _q, _q$1, _tmp, _tmp$1, _tuple, buf, d, digit, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, n, nd, needed, ok, pos, pow, pow10, rest, shift, v, v1, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { + d.nd = 0; + d.dp = 0; + d.neg = f.neg; + return true; + } + if (n === 0) { + $panic(new $String("strconv: internal error: extFloat.FixedDecimal called with n == 0")); + } + f.Normalize(); + _tuple = f.frexp10(); + exp10 = _tuple[0]; + shift = ((-f.exp >>> 0)); + integer = (($shiftRightUint64(f.mant, shift).$low >>> 0)); + fraction = (x$1 = f.mant, x$2 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + $CE$B5 = new $Uint64(0, 1); + needed = n; + integerDigits = 0; + pow10 = new $Uint64(0, 1); + _tmp = 0; + _tmp$1 = new $Uint64(0, 1); + i = _tmp; + pow = _tmp$1; + while (true) { + if (!(i < 20)) { break; } + if ((x$3 = (new $Uint64(0, integer)), (pow.$high > x$3.$high || (pow.$high === x$3.$high && pow.$low > x$3.$low)))) { + integerDigits = i; + break; + } + pow = $mul64(pow, (new $Uint64(0, 10))); + i = i + (1) >> 0; + } + rest = integer; + if (integerDigits > needed) { + pow10 = (x$4 = integerDigits - needed >> 0, ((x$4 < 0 || x$4 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$4])); + integer = (_q = integer / (((pow10.$low >>> 0))), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + rest = rest - (($imul(integer, ((pow10.$low >>> 0))) >>> 0)) >>> 0; + } else { + rest = 0; + } + buf = arrayType$2.zero(); + pos = 32; + v = integer; + while (true) { + if (!(v > 0)) { break; } + v1 = (_q$1 = v / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + v = v - (($imul(10, v1) >>> 0)) >>> 0; + pos = pos - (1) >> 0; + ((pos < 0 || pos >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[pos] = (((v + 48 >>> 0) << 24 >>> 24))); + v = v1; + } + i$1 = pos; + while (true) { + if (!(i$1 < 32)) { break; } + (x$5 = d.d, x$6 = i$1 - pos >> 0, ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6] = ((i$1 < 0 || i$1 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i$1]))); + i$1 = i$1 + (1) >> 0; + } + nd = 32 - pos >> 0; + d.nd = nd; + d.dp = integerDigits + exp10 >> 0; + needed = needed - (nd) >> 0; + if (needed > 0) { + if (!((rest === 0)) || !((pow10.$high === 0 && pow10.$low === 1))) { + $panic(new $String("strconv: internal error, rest != 0 but needed > 0")); + } + while (true) { + if (!(needed > 0)) { break; } + fraction = $mul64(fraction, (new $Uint64(0, 10))); + $CE$B5 = $mul64($CE$B5, (new $Uint64(0, 10))); + if ((x$7 = $mul64(new $Uint64(0, 2), $CE$B5), x$8 = $shiftLeft64(new $Uint64(0, 1), shift), (x$7.$high > x$8.$high || (x$7.$high === x$8.$high && x$7.$low > x$8.$low)))) { + return false; + } + digit = $shiftRightUint64(fraction, shift); + (x$9 = d.d, ((nd < 0 || nd >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + nd] = ((new $Uint64(digit.$high + 0, digit.$low + 48).$low << 24 >>> 24)))); + fraction = (x$10 = $shiftLeft64(digit, shift), new $Uint64(fraction.$high - x$10.$high, fraction.$low - x$10.$low)); + nd = nd + (1) >> 0; + needed = needed - (1) >> 0; + } + d.nd = nd; + } + ok = adjustLastDigitFixed(d, (x$11 = $shiftLeft64((new $Uint64(0, rest)), shift), new $Uint64(x$11.$high | fraction.$high, (x$11.$low | fraction.$low) >>> 0)), pow10, shift, $CE$B5); + if (!ok) { + return false; + } + i$2 = d.nd - 1 >> 0; + while (true) { + if (!(i$2 >= 0)) { break; } + if (!(((x$12 = d.d, ((i$2 < 0 || i$2 >= x$12.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + i$2])) === 48))) { + d.nd = i$2 + 1 >> 0; + break; + } + i$2 = i$2 - (1) >> 0; + } + return true; + }; + extFloat.prototype.FixedDecimal = function(d, n) { return this.$val.FixedDecimal(d, n); }; + adjustLastDigitFixed = function(d, num, den, shift, $CE$B5) { + var $CE$B5, d, den, i, num, shift, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + if ((x = $shiftLeft64(den, shift), (num.$high > x.$high || (num.$high === x.$high && num.$low > x.$low)))) { + $panic(new $String("strconv: num > den< x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { + $panic(new $String("strconv: \xCE\xB5 > (den< x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low)))) { + i = d.nd - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + if ((x$7 = d.d, ((i < 0 || i >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + i])) === 57) { + d.nd = d.nd - (1) >> 0; + } else { + break; + } + i = i - (1) >> 0; + } + if (i < 0) { + (x$8 = d.d, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0] = 49)); + d.nd = 1; + d.dp = d.dp + (1) >> 0; + } else { + (x$10 = d.d, ((i < 0 || i >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + i] = ((x$9 = d.d, ((i < 0 || i >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + i])) + (1) << 24 >>> 24))); + } + return true; + } + return false; + }; + extFloat.ptr.prototype.ShortestDecimal = function(d, lower, upper) { + var _q, _tmp, _tmp$1, _tmp$2, _tmp$3, allowance, buf, currentDiff, d, digit, digit$1, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, lower, multiplier, n, nd, pow, pow$1, shift, targetDiff, upper, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { + d.nd = 0; + d.dp = 0; + d.neg = f.neg; + return true; + } + if ((f.exp === 0) && $equal(lower, f, extFloat) && $equal(lower, upper, extFloat)) { + buf = arrayType$1.zero(); + n = 23; + v = f.mant; + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + v1 = $div64(v, new $Uint64(0, 10), false); + v = (x$1 = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x$1.$high, v.$low - x$1.$low)); + ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); + n = n - (1) >> 0; + v = v1; + } + nd = (24 - n >> 0) - 1 >> 0; + i = 0; + while (true) { + if (!(i < nd)) { break; } + (x$3 = d.d, ((i < 0 || i >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i] = (x$2 = (n + 1 >> 0) + i >> 0, ((x$2 < 0 || x$2 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x$2])))); + i = i + (1) >> 0; + } + _tmp = nd; + _tmp$1 = nd; + d.nd = _tmp; + d.dp = _tmp$1; + while (true) { + if (!(d.nd > 0 && ((x$4 = d.d, x$5 = d.nd - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) === 48))) { break; } + d.nd = d.nd - (1) >> 0; + } + if (d.nd === 0) { + d.dp = 0; + } + d.neg = f.neg; + return true; + } + upper.Normalize(); + if (f.exp > upper.exp) { + f.mant = $shiftLeft64(f.mant, ((((f.exp - upper.exp >> 0) >>> 0)))); + f.exp = upper.exp; + } + if (lower.exp > upper.exp) { + lower.mant = $shiftLeft64(lower.mant, ((((lower.exp - upper.exp >> 0) >>> 0)))); + lower.exp = upper.exp; + } + exp10 = frexp10Many(lower, f, upper); + upper.mant = (x$6 = upper.mant, x$7 = new $Uint64(0, 1), new $Uint64(x$6.$high + x$7.$high, x$6.$low + x$7.$low)); + lower.mant = (x$8 = lower.mant, x$9 = new $Uint64(0, 1), new $Uint64(x$8.$high - x$9.$high, x$8.$low - x$9.$low)); + shift = ((-upper.exp >>> 0)); + integer = (($shiftRightUint64(upper.mant, shift).$low >>> 0)); + fraction = (x$10 = upper.mant, x$11 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$10.$high - x$11.$high, x$10.$low - x$11.$low)); + allowance = (x$12 = upper.mant, x$13 = lower.mant, new $Uint64(x$12.$high - x$13.$high, x$12.$low - x$13.$low)); + targetDiff = (x$14 = upper.mant, x$15 = f.mant, new $Uint64(x$14.$high - x$15.$high, x$14.$low - x$15.$low)); + integerDigits = 0; + _tmp$2 = 0; + _tmp$3 = new $Uint64(0, 1); + i$1 = _tmp$2; + pow = _tmp$3; + while (true) { + if (!(i$1 < 20)) { break; } + if ((x$16 = (new $Uint64(0, integer)), (pow.$high > x$16.$high || (pow.$high === x$16.$high && pow.$low > x$16.$low)))) { + integerDigits = i$1; + break; + } + pow = $mul64(pow, (new $Uint64(0, 10))); + i$1 = i$1 + (1) >> 0; + } + i$2 = 0; + while (true) { + if (!(i$2 < integerDigits)) { break; } + pow$1 = (x$17 = (integerDigits - i$2 >> 0) - 1 >> 0, ((x$17 < 0 || x$17 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$17])); + digit = (_q = integer / ((pow$1.$low >>> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + (x$18 = d.d, ((i$2 < 0 || i$2 >= x$18.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$18.$array[x$18.$offset + i$2] = (((digit + 48 >>> 0) << 24 >>> 24)))); + integer = integer - (($imul(digit, ((pow$1.$low >>> 0))) >>> 0)) >>> 0; + currentDiff = (x$19 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$19.$high + fraction.$high, x$19.$low + fraction.$low)); + if ((currentDiff.$high < allowance.$high || (currentDiff.$high === allowance.$high && currentDiff.$low < allowance.$low))) { + d.nd = i$2 + 1 >> 0; + d.dp = integerDigits + exp10 >> 0; + d.neg = f.neg; + return adjustLastDigit(d, currentDiff, targetDiff, allowance, $shiftLeft64(pow$1, shift), new $Uint64(0, 2)); + } + i$2 = i$2 + (1) >> 0; + } + d.nd = integerDigits; + d.dp = d.nd + exp10 >> 0; + d.neg = f.neg; + digit$1 = 0; + multiplier = new $Uint64(0, 1); + while (true) { + fraction = $mul64(fraction, (new $Uint64(0, 10))); + multiplier = $mul64(multiplier, (new $Uint64(0, 10))); + digit$1 = (($shiftRightUint64(fraction, shift).$low >> 0)); + (x$20 = d.d, x$21 = d.nd, ((x$21 < 0 || x$21 >= x$20.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$20.$array[x$20.$offset + x$21] = (((digit$1 + 48 >> 0) << 24 >>> 24)))); + d.nd = d.nd + (1) >> 0; + fraction = (x$22 = $shiftLeft64((new $Uint64(0, digit$1)), shift), new $Uint64(fraction.$high - x$22.$high, fraction.$low - x$22.$low)); + if ((x$23 = $mul64(allowance, multiplier), (fraction.$high < x$23.$high || (fraction.$high === x$23.$high && fraction.$low < x$23.$low)))) { + return adjustLastDigit(d, fraction, $mul64(targetDiff, multiplier), $mul64(allowance, multiplier), $shiftLeft64(new $Uint64(0, 1), shift), $mul64(multiplier, new $Uint64(0, 2))); + } + } + }; + extFloat.prototype.ShortestDecimal = function(d, lower, upper) { return this.$val.ShortestDecimal(d, lower, upper); }; + adjustLastDigit = function(d, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary) { + var _index, currentDiff, d, maxDiff, targetDiff, ulpBinary, ulpDecimal, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + if ((x = $mul64(new $Uint64(0, 2), ulpBinary), (ulpDecimal.$high < x.$high || (ulpDecimal.$high === x.$high && ulpDecimal.$low < x.$low)))) { + return false; + } + while (true) { + if (!((x$1 = (x$2 = (x$3 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(currentDiff.$high + x$3.$high, currentDiff.$low + x$3.$low)), new $Uint64(x$2.$high + ulpBinary.$high, x$2.$low + ulpBinary.$low)), (x$1.$high < targetDiff.$high || (x$1.$high === targetDiff.$high && x$1.$low < targetDiff.$low))))) { break; } + _index = d.nd - 1 >> 0; + (x$5 = d.d, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index] = ((x$4 = d.d, ((_index < 0 || _index >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + _index])) - (1) << 24 >>> 24))); + currentDiff = (x$6 = ulpDecimal, new $Uint64(currentDiff.$high + x$6.$high, currentDiff.$low + x$6.$low)); + } + if ((x$7 = new $Uint64(currentDiff.$high + ulpDecimal.$high, currentDiff.$low + ulpDecimal.$low), x$8 = (x$9 = (x$10 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(targetDiff.$high + x$10.$high, targetDiff.$low + x$10.$low)), new $Uint64(x$9.$high + ulpBinary.$high, x$9.$low + ulpBinary.$low)), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low <= x$8.$low)))) { + return false; + } + if ((currentDiff.$high < ulpBinary.$high || (currentDiff.$high === ulpBinary.$high && currentDiff.$low < ulpBinary.$low)) || (x$11 = new $Uint64(maxDiff.$high - ulpBinary.$high, maxDiff.$low - ulpBinary.$low), (currentDiff.$high > x$11.$high || (currentDiff.$high === x$11.$high && currentDiff.$low > x$11.$low)))) { + return false; + } + if ((d.nd === 1) && ((x$12 = d.d, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0])) === 48)) { + d.nd = 0; + d.dp = 0; + } + return true; + }; + FormatFloat = function(f, fmt, prec, bitSize) { + var bitSize, f, fmt, prec; + return ($bytesToString(genericFtoa($makeSlice(sliceType$6, 0, max(prec + 4 >> 0, 24)), f, fmt, prec, bitSize))); + }; + $pkg.FormatFloat = FormatFloat; + AppendFloat = function(dst, f, fmt, prec, bitSize) { + var bitSize, dst, f, fmt, prec; + return genericFtoa(dst, f, fmt, prec, bitSize); + }; + $pkg.AppendFloat = AppendFloat; + genericFtoa = function(dst, val, fmt, prec, bitSize) { + var _1, _2, _3, _4, _tuple, bitSize, bits$1, buf, buf$1, digits, digs, dst, exp, f, f$1, flt, fmt, lower, mant, neg, ok, prec, s, shortest, upper, val, x, x$1, x$2, x$3, y, y$1; + bits$1 = new $Uint64(0, 0); + flt = ptrType$1.nil; + _1 = bitSize; + if (_1 === (32)) { + bits$1 = (new $Uint64(0, math.Float32bits(($fround(val))))); + flt = float32info; + } else if (_1 === (64)) { + bits$1 = math.Float64bits(val); + flt = float64info; + } else { + $panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize")); + } + neg = !((x = $shiftRightUint64(bits$1, ((flt.expbits + flt.mantbits >>> 0))), (x.$high === 0 && x.$low === 0))); + exp = (($shiftRightUint64(bits$1, flt.mantbits).$low >> 0)) & ((((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)); + mant = (x$1 = (x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$2.$high - 0, x$2.$low - 1)), new $Uint64(bits$1.$high & x$1.$high, (bits$1.$low & x$1.$low) >>> 0)); + _2 = exp; + if (_2 === ((((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0))) { + s = ""; + if (!((mant.$high === 0 && mant.$low === 0))) { + s = "NaN"; + } else if (neg) { + s = "-Inf"; + } else { + s = "+Inf"; + } + return $appendSlice(dst, s); + } else if (_2 === (0)) { + exp = exp + (1) >> 0; + } else { + mant = (x$3 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high | x$3.$high, (mant.$low | x$3.$low) >>> 0)); + } + exp = exp + (flt.bias) >> 0; + if (fmt === 98) { + return fmtB(dst, neg, mant, exp, flt); + } + if (!optimize) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); + ok = false; + shortest = prec < 0; + if (shortest) { + f = new extFloat.ptr(new $Uint64(0, 0), 0, false); + _tuple = f.AssignComputeBounds(mant, exp, neg, flt); + lower = $clone(_tuple[0], extFloat); + upper = $clone(_tuple[1], extFloat); + buf = arrayType$2.zero(); + digs.d = new sliceType$6(buf); + ok = f.ShortestDecimal(digs, lower, upper); + if (!ok) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + _3 = fmt; + if ((_3 === (101)) || (_3 === (69))) { + prec = max(digs.nd - 1 >> 0, 0); + } else if (_3 === (102)) { + prec = max(digs.nd - digs.dp >> 0, 0); + } else if ((_3 === (103)) || (_3 === (71))) { + prec = digs.nd; + } + } else if (!((fmt === 102))) { + digits = prec; + _4 = fmt; + if ((_4 === (101)) || (_4 === (69))) { + digits = digits + (1) >> 0; + } else if ((_4 === (103)) || (_4 === (71))) { + if (prec === 0) { + prec = 1; + } + digits = prec; + } + if (digits <= 15) { + buf$1 = arrayType$1.zero(); + digs.d = new sliceType$6(buf$1); + f$1 = new extFloat.ptr(mant, exp - ((flt.mantbits >> 0)) >> 0, neg); + ok = f$1.FixedDecimal(digs, digits); + } + } + if (!ok) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); + }; + bigFtoa = function(dst, prec, fmt, neg, mant, exp, flt) { + var _1, _2, d, digs, dst, exp, flt, fmt, mant, neg, prec, shortest; + d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + d.Assign(mant); + d.Shift(exp - ((flt.mantbits >> 0)) >> 0); + digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); + shortest = prec < 0; + if (shortest) { + roundShortest(d, mant, exp, flt); + decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); + _1 = fmt; + if ((_1 === (101)) || (_1 === (69))) { + prec = digs.nd - 1 >> 0; + } else if (_1 === (102)) { + prec = max(digs.nd - digs.dp >> 0, 0); + } else if ((_1 === (103)) || (_1 === (71))) { + prec = digs.nd; + } + } else { + _2 = fmt; + if ((_2 === (101)) || (_2 === (69))) { + d.Round(prec + 1 >> 0); + } else if (_2 === (102)) { + d.Round(d.dp + prec >> 0); + } else if ((_2 === (103)) || (_2 === (71))) { + if (prec === 0) { + prec = 1; + } + d.Round(prec); + } + decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); + } + return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); + }; + formatDigits = function(dst, shortest, neg, digs, prec, fmt) { + var _1, digs, dst, eprec, exp, fmt, neg, prec, shortest; + _1 = fmt; + if ((_1 === (101)) || (_1 === (69))) { + return fmtE(dst, neg, $clone(digs, decimalSlice), prec, fmt); + } else if (_1 === (102)) { + return fmtF(dst, neg, $clone(digs, decimalSlice), prec); + } else if ((_1 === (103)) || (_1 === (71))) { + eprec = prec; + if (eprec > digs.nd && digs.nd >= digs.dp) { + eprec = digs.nd; + } + if (shortest) { + eprec = 6; + } + exp = digs.dp - 1 >> 0; + if (exp < -4 || exp >= eprec) { + if (prec > digs.nd) { + prec = digs.nd; + } + return fmtE(dst, neg, $clone(digs, decimalSlice), prec - 1 >> 0, (fmt + 101 << 24 >>> 24) - 103 << 24 >>> 24); + } + if (prec > digs.dp) { + prec = digs.nd; + } + return fmtF(dst, neg, $clone(digs, decimalSlice), max(prec - digs.dp >> 0, 0)); + } + return $append(dst, 37, fmt); + }; + roundShortest = function(d, mant, exp, flt) { + var d, exp, explo, flt, i, inclusive, l, lower, m, mant, mantlo, minexp, okdown, okup, u, upper, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + if ((mant.$high === 0 && mant.$low === 0)) { + d.nd = 0; + return; + } + minexp = flt.bias + 1 >> 0; + if (exp > minexp && ($imul(332, ((d.dp - d.nd >> 0)))) >= ($imul(100, ((exp - ((flt.mantbits >> 0)) >> 0))))) { + return; + } + upper = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + upper.Assign((x = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x.$high + 0, x.$low + 1))); + upper.Shift((exp - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); + mantlo = new $Uint64(0, 0); + explo = 0; + if ((x$1 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high > x$1.$high || (mant.$high === x$1.$high && mant.$low > x$1.$low))) || (exp === minexp)) { + mantlo = new $Uint64(mant.$high - 0, mant.$low - 1); + explo = exp; + } else { + mantlo = (x$2 = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x$2.$high - 0, x$2.$low - 1)); + explo = exp - 1 >> 0; + } + lower = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + lower.Assign((x$3 = $mul64(mantlo, new $Uint64(0, 2)), new $Uint64(x$3.$high + 0, x$3.$low + 1))); + lower.Shift((explo - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); + inclusive = (x$4 = $div64(mant, new $Uint64(0, 2), true), (x$4.$high === 0 && x$4.$low === 0)); + i = 0; + while (true) { + if (!(i < d.nd)) { break; } + l = 48; + if (i < lower.nd) { + l = (x$5 = lower.d, ((i < 0 || i >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i])); + } + m = (x$6 = d.d, ((i < 0 || i >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i])); + u = 48; + if (i < upper.nd) { + u = (x$7 = upper.d, ((i < 0 || i >= x$7.length) ? ($throwRuntimeError("index out of range"), undefined) : x$7[i])); + } + okdown = !((l === m)) || inclusive && ((i + 1 >> 0) === lower.nd); + okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.nd); + if (okdown && okup) { + d.Round(i + 1 >> 0); + return; + } else if (okdown) { + d.RoundDown(i + 1 >> 0); + return; + } else if (okup) { + d.RoundUp(i + 1 >> 0); + return; + } + i = i + (1) >> 0; + } + }; + fmtE = function(dst, neg, d, prec, fmt) { + var _q, _q$1, _q$2, _r, _r$1, _r$2, ch, d, dst, exp, fmt, i, m, neg, prec, x; + if (neg) { + dst = $append(dst, 45); + } + ch = 48; + if (!((d.nd === 0))) { + ch = (x = d.d, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + } + dst = $append(dst, ch); + if (prec > 0) { + dst = $append(dst, 46); + i = 1; + m = min(d.nd, prec + 1 >> 0); + if (i < m) { + dst = $appendSlice(dst, $subslice(d.d, i, m)); + i = m; + } + while (true) { + if (!(i <= prec)) { break; } + dst = $append(dst, 48); + i = i + (1) >> 0; + } + } + dst = $append(dst, fmt); + exp = d.dp - 1 >> 0; + if (d.nd === 0) { + exp = 0; + } + if (exp < 0) { + ch = 45; + exp = -exp; + } else { + ch = 43; + } + dst = $append(dst, ch); + if (exp < 10) { + dst = $append(dst, 48, ((exp << 24 >>> 24)) + 48 << 24 >>> 24); + } else if (exp < 100) { + dst = $append(dst, (((_q = exp / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (((_r = exp % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); + } else { + dst = $append(dst, (((_q$1 = exp / 100, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (_r$1 = (((_q$2 = exp / 10, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) % 10, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) + 48 << 24 >>> 24, (((_r$2 = exp % 10, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); + } + return dst; + }; + fmtF = function(dst, neg, d, prec) { + var ch, d, dst, i, j, m, neg, prec, x; + if (neg) { + dst = $append(dst, 45); + } + if (d.dp > 0) { + m = min(d.nd, d.dp); + dst = $appendSlice(dst, $subslice(d.d, 0, m)); + while (true) { + if (!(m < d.dp)) { break; } + dst = $append(dst, 48); + m = m + (1) >> 0; + } + } else { + dst = $append(dst, 48); + } + if (prec > 0) { + dst = $append(dst, 46); + i = 0; + while (true) { + if (!(i < prec)) { break; } + ch = 48; + j = d.dp + i >> 0; + if (0 <= j && j < d.nd) { + ch = (x = d.d, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); + } + dst = $append(dst, ch); + i = i + (1) >> 0; + } + } + return dst; + }; + fmtB = function(dst, neg, mant, exp, flt) { + var _tuple, _tuple$1, dst, exp, flt, mant, neg; + if (neg) { + dst = $append(dst, 45); + } + _tuple = formatBits(dst, mant, 10, false, true); + dst = _tuple[0]; + dst = $append(dst, 112); + exp = exp - (((flt.mantbits >> 0))) >> 0; + if (exp >= 0) { + dst = $append(dst, 43); + } + _tuple$1 = formatBits(dst, (new $Uint64(0, exp)), 10, exp < 0, true); + dst = _tuple$1[0]; + return dst; + }; + min = function(a, b) { + var a, b; + if (a < b) { + return a; + } + return b; + }; + max = function(a, b) { + var a, b; + if (a > b) { + return a; + } + return b; + }; + FormatUint = function(i, base) { + var _tuple, base, i, s; + if (true && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { + return small(((i.$low >> 0))); + } + _tuple = formatBits(sliceType$6.nil, i, base, false, false); + s = _tuple[1]; + return s; + }; + $pkg.FormatUint = FormatUint; + FormatInt = function(i, base) { + var _tuple, base, i, s; + if (true && (0 < i.$high || (0 === i.$high && 0 <= i.$low)) && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { + return small((((i.$low + ((i.$high >> 31) * 4294967296)) >> 0))); + } + _tuple = formatBits(sliceType$6.nil, (new $Uint64(i.$high, i.$low)), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), false); + s = _tuple[1]; + return s; + }; + $pkg.FormatInt = FormatInt; + Itoa = function(i) { + var i; + return FormatInt((new $Int64(0, i)), 10); + }; + $pkg.Itoa = Itoa; + AppendInt = function(dst, i, base) { + var _tuple, base, dst, i; + if (true && (0 < i.$high || (0 === i.$high && 0 <= i.$low)) && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { + return $appendSlice(dst, small((((i.$low + ((i.$high >> 31) * 4294967296)) >> 0)))); + } + _tuple = formatBits(dst, (new $Uint64(i.$high, i.$low)), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), true); + dst = _tuple[0]; + return dst; + }; + $pkg.AppendInt = AppendInt; + AppendUint = function(dst, i, base) { + var _tuple, base, dst, i; + if (true && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { + return $appendSlice(dst, small(((i.$low >> 0)))); + } + _tuple = formatBits(dst, i, base, false, true); + dst = _tuple[0]; + return dst; + }; + $pkg.AppendUint = AppendUint; + small = function(i) { + var i; + if (i < 10) { + return $substring("0123456789abcdefghijklmnopqrstuvwxyz", i, (i + 1 >> 0)); + } + return $substring("00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899", ($imul(i, 2)), (($imul(i, 2)) + 2 >> 0)); + }; + formatBits = function(dst, u, base, neg, append_) { + var _q, _q$1, _r, _r$1, a, append_, b, b$1, base, d, dst, i, is, is$1, is$2, j, m, neg, q, q$1, s, shift, u, us, us$1, x, x$1, x$2, x$3, x$4, x$5; + d = sliceType$6.nil; + s = ""; + if (base < 2 || base > 36) { + $panic(new $String("strconv: illegal AppendInt/FormatInt base")); + } + a = arrayType$3.zero(); + i = 65; + if (neg) { + u = new $Uint64(-u.$high, -u.$low); + } + if (base === 10) { + if (true) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 1000000000)))) { break; } + q = $div64(u, new $Uint64(0, 1000000000), false); + us = (((x = $mul64(q, new $Uint64(0, 1000000000)), new $Uint64(u.$high - x.$high, u.$low - x.$low)).$low >>> 0)); + j = 4; + while (true) { + if (!(j > 0)) { break; } + is = (_r = us % 100, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; + us = (_q = us / (100), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + i = i - (2) >> 0; + (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$1] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 1 >>> 0)))); + (x$2 = i + 0 >> 0, ((x$2 < 0 || x$2 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$2] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 0 >>> 0)))); + j = j - (1) >> 0; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(((us * 2 >>> 0) + 1 >>> 0))); + u = q; + } + } + us$1 = ((u.$low >>> 0)); + while (true) { + if (!(us$1 >= 100)) { break; } + is$1 = (_r$1 = us$1 % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; + us$1 = (_q$1 = us$1 / (100), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + i = i - (2) >> 0; + (x$3 = i + 1 >> 0, ((x$3 < 0 || x$3 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$3] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 1 >>> 0)))); + (x$4 = i + 0 >> 0, ((x$4 < 0 || x$4 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$4] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 0 >>> 0)))); + } + is$2 = us$1 * 2 >>> 0; + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$2 + 1 >>> 0))); + if (us$1 >= 10) { + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(is$2)); + } + } else if (isPowerOfTwo(base)) { + shift = (((bits.TrailingZeros(((base >>> 0))) >>> 0)) & 7) >>> 0; + b = (new $Uint64(0, base)); + m = ((base >>> 0)) - 1 >>> 0; + while (true) { + if (!((u.$high > b.$high || (u.$high === b.$high && u.$low >= b.$low)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((((u.$low >>> 0)) & m) >>> 0))); + u = $shiftRightUint64(u, (shift)); + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); + } else { + b$1 = (new $Uint64(0, base)); + while (true) { + if (!((u.$high > b$1.$high || (u.$high === b$1.$high && u.$low >= b$1.$low)))) { break; } + i = i - (1) >> 0; + q$1 = $div64(u, b$1, false); + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((x$5 = $mul64(q$1, b$1), new $Uint64(u.$high - x$5.$high, u.$low - x$5.$low)).$low >>> 0)))); + u = q$1; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); + } + if (neg) { + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = 45); + } + if (append_) { + d = $appendSlice(dst, $subslice(new sliceType$6(a), i)); + return [d, s]; + } + s = ($bytesToString($subslice(new sliceType$6(a), i))); + return [d, s]; + }; + isPowerOfTwo = function(x) { + var x; + return (x & ((x - 1 >> 0))) === 0; + }; + quoteWith = function(s, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, _q, graphicOnly, quote, s; + return ($bytesToString(appendQuotedWith($makeSlice(sliceType$6, 0, (_q = ($imul(3, s.length)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))), s, quote, ASCIIonly, graphicOnly))); + }; + appendQuotedWith = function(buf, s, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, _tuple, buf, graphicOnly, quote, r, s, width; + buf = $append(buf, quote); + width = 0; + while (true) { + if (!(s.length > 0)) { break; } + r = ((s.charCodeAt(0) >> 0)); + width = 1; + if (r >= 128) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + width = _tuple[1]; + } + if ((width === 1) && (r === 65533)) { + buf = $appendSlice(buf, "\\x"); + buf = $append(buf, "0123456789abcdef".charCodeAt((s.charCodeAt(0) >>> 4 << 24 >>> 24))); + buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0))); + s = $substring(s, width); + continue; + } + buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); + s = $substring(s, width); + } + buf = $append(buf, quote); + return buf; + }; + appendQuotedRuneWith = function(buf, r, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, buf, graphicOnly, quote, r; + buf = $append(buf, quote); + if (!utf8.ValidRune(r)) { + r = 65533; + } + buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); + buf = $append(buf, quote); + return buf; + }; + appendEscapedRune = function(buf, r, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, _1, buf, graphicOnly, n, quote, r, runeTmp, s, s$1; + runeTmp = arrayType$4.zero(); + if ((r === ((quote >> 0))) || (r === 92)) { + buf = $append(buf, 92); + buf = $append(buf, ((r << 24 >>> 24))); + return buf; + } + if (ASCIIonly) { + if (r < 128 && IsPrint(r)) { + buf = $append(buf, ((r << 24 >>> 24))); + return buf; + } + } else if (IsPrint(r) || graphicOnly && isInGraphicList(r)) { + n = utf8.EncodeRune(new sliceType$6(runeTmp), r); + buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n)); + return buf; + } + _1 = r; + if (_1 === (7)) { + buf = $appendSlice(buf, "\\a"); + } else if (_1 === (8)) { + buf = $appendSlice(buf, "\\b"); + } else if (_1 === (12)) { + buf = $appendSlice(buf, "\\f"); + } else if (_1 === (10)) { + buf = $appendSlice(buf, "\\n"); + } else if (_1 === (13)) { + buf = $appendSlice(buf, "\\r"); + } else if (_1 === (9)) { + buf = $appendSlice(buf, "\\t"); + } else if (_1 === (11)) { + buf = $appendSlice(buf, "\\v"); + } else { + if (r < 32) { + buf = $appendSlice(buf, "\\x"); + buf = $append(buf, "0123456789abcdef".charCodeAt((((r << 24 >>> 24)) >>> 4 << 24 >>> 24))); + buf = $append(buf, "0123456789abcdef".charCodeAt(((((r << 24 >>> 24)) & 15) >>> 0))); + } else if (r > 1114111) { + r = 65533; + buf = $appendSlice(buf, "\\u"); + s = 12; + while (true) { + if (!(s >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); + s = s - (4) >> 0; + } + } else if (r < 65536) { + buf = $appendSlice(buf, "\\u"); + s = 12; + while (true) { + if (!(s >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); + s = s - (4) >> 0; + } + } else { + buf = $appendSlice(buf, "\\U"); + s$1 = 28; + while (true) { + if (!(s$1 >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s$1 >>> 0)), 31)) >> 0) & 15))); + s$1 = s$1 - (4) >> 0; + } + } + } + return buf; + }; + Quote = function(s) { + var s; + return quoteWith(s, 34, false, false); + }; + $pkg.Quote = Quote; + AppendQuote = function(dst, s) { + var dst, s; + return appendQuotedWith(dst, s, 34, false, false); + }; + $pkg.AppendQuote = AppendQuote; + QuoteToASCII = function(s) { + var s; + return quoteWith(s, 34, true, false); + }; + $pkg.QuoteToASCII = QuoteToASCII; + AppendQuoteToASCII = function(dst, s) { + var dst, s; + return appendQuotedWith(dst, s, 34, true, false); + }; + $pkg.AppendQuoteToASCII = AppendQuoteToASCII; + AppendQuoteRune = function(dst, r) { + var dst, r; + return appendQuotedRuneWith(dst, r, 39, false, false); + }; + $pkg.AppendQuoteRune = AppendQuoteRune; + AppendQuoteRuneToASCII = function(dst, r) { + var dst, r; + return appendQuotedRuneWith(dst, r, 39, true, false); + }; + $pkg.AppendQuoteRuneToASCII = AppendQuoteRuneToASCII; + CanBackquote = function(s) { + var _tuple, r, s, wid; + while (true) { + if (!(s.length > 0)) { break; } + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + wid = _tuple[1]; + s = $substring(s, wid); + if (wid > 1) { + if (r === 65279) { + return false; + } + continue; + } + if (r === 65533) { + return false; + } + if ((r < 32 && !((r === 9))) || (r === 96) || (r === 127)) { + return false; + } + } + return true; + }; + $pkg.CanBackquote = CanBackquote; + unhex = function(b) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, c, ok, v; + v = 0; + ok = false; + c = ((b >> 0)); + if (48 <= c && c <= 57) { + _tmp = c - 48 >> 0; + _tmp$1 = true; + v = _tmp; + ok = _tmp$1; + return [v, ok]; + } else if (97 <= c && c <= 102) { + _tmp$2 = (c - 97 >> 0) + 10 >> 0; + _tmp$3 = true; + v = _tmp$2; + ok = _tmp$3; + return [v, ok]; + } else if (65 <= c && c <= 70) { + _tmp$4 = (c - 65 >> 0) + 10 >> 0; + _tmp$5 = true; + v = _tmp$4; + ok = _tmp$5; + return [v, ok]; + } + return [v, ok]; + }; + UnquoteChar = function(s, quote) { + var _1, _2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, c, c$1, err, j, j$1, multibyte, n, ok, quote, r, s, size, tail, v, v$1, value, x, x$1; + value = 0; + multibyte = false; + tail = ""; + err = $ifaceNil; + if (s.length === 0) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + c = s.charCodeAt(0); + if ((c === quote) && ((quote === 39) || (quote === 34))) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } else if (c >= 128) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + size = _tuple[1]; + _tmp = r; + _tmp$1 = true; + _tmp$2 = $substring(s, size); + _tmp$3 = $ifaceNil; + value = _tmp; + multibyte = _tmp$1; + tail = _tmp$2; + err = _tmp$3; + return [value, multibyte, tail, err]; + } else if (!((c === 92))) { + _tmp$4 = ((s.charCodeAt(0) >> 0)); + _tmp$5 = false; + _tmp$6 = $substring(s, 1); + _tmp$7 = $ifaceNil; + value = _tmp$4; + multibyte = _tmp$5; + tail = _tmp$6; + err = _tmp$7; + return [value, multibyte, tail, err]; + } + if (s.length <= 1) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + c$1 = s.charCodeAt(1); + s = $substring(s, 2); + switch (0) { default: + _1 = c$1; + if (_1 === (97)) { + value = 7; + } else if (_1 === (98)) { + value = 8; + } else if (_1 === (102)) { + value = 12; + } else if (_1 === (110)) { + value = 10; + } else if (_1 === (114)) { + value = 13; + } else if (_1 === (116)) { + value = 9; + } else if (_1 === (118)) { + value = 11; + } else if ((_1 === (120)) || (_1 === (117)) || (_1 === (85))) { + n = 0; + _2 = c$1; + if (_2 === (120)) { + n = 2; + } else if (_2 === (117)) { + n = 4; + } else if (_2 === (85)) { + n = 8; + } + v = 0; + if (s.length < n) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + j = 0; + while (true) { + if (!(j < n)) { break; } + _tuple$1 = unhex(s.charCodeAt(j)); + x = _tuple$1[0]; + ok = _tuple$1[1]; + if (!ok) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + v = (v << 4 >> 0) | x; + j = j + (1) >> 0; + } + s = $substring(s, n); + if (c$1 === 120) { + value = v; + break; + } + if (v > 1114111) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = v; + multibyte = true; + } else if ((_1 === (48)) || (_1 === (49)) || (_1 === (50)) || (_1 === (51)) || (_1 === (52)) || (_1 === (53)) || (_1 === (54)) || (_1 === (55))) { + v$1 = ((c$1 >> 0)) - 48 >> 0; + if (s.length < 2) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + j$1 = 0; + while (true) { + if (!(j$1 < 2)) { break; } + x$1 = ((s.charCodeAt(j$1) >> 0)) - 48 >> 0; + if (x$1 < 0 || x$1 > 7) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + v$1 = ((v$1 << 3 >> 0)) | x$1; + j$1 = j$1 + (1) >> 0; + } + s = $substring(s, 2); + if (v$1 > 255) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = v$1; + } else if (_1 === (92)) { + value = 92; + } else if ((_1 === (39)) || (_1 === (34))) { + if (!((c$1 === quote))) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = ((c$1 >> 0)); + } else { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + } + tail = s; + return [value, multibyte, tail, err]; + }; + $pkg.UnquoteChar = UnquoteChar; + Unquote = function(s) { + var _1, _q, _tuple, _tuple$1, buf, buf$1, c, err, i, multibyte, n, n$1, quote, r, runeTmp, s, size, ss; + n = s.length; + if (n < 2) { + return ["", $pkg.ErrSyntax]; + } + quote = s.charCodeAt(0); + if (!((quote === s.charCodeAt((n - 1 >> 0))))) { + return ["", $pkg.ErrSyntax]; + } + s = $substring(s, 1, (n - 1 >> 0)); + if (quote === 96) { + if (contains(s, 96)) { + return ["", $pkg.ErrSyntax]; + } + if (contains(s, 13)) { + buf = $makeSlice(sliceType$6, 0, (s.length - 1 >> 0)); + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (!((s.charCodeAt(i) === 13))) { + buf = $append(buf, s.charCodeAt(i)); + } + i = i + (1) >> 0; + } + return [($bytesToString(buf)), $ifaceNil]; + } + return [s, $ifaceNil]; + } + if (!((quote === 34)) && !((quote === 39))) { + return ["", $pkg.ErrSyntax]; + } + if (contains(s, 10)) { + return ["", $pkg.ErrSyntax]; + } + if (!contains(s, 92) && !contains(s, quote)) { + _1 = quote; + if (_1 === (34)) { + if (utf8.ValidString(s)) { + return [s, $ifaceNil]; + } + } else if (_1 === (39)) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + size = _tuple[1]; + if ((size === s.length) && (!((r === 65533)) || !((size === 1)))) { + return [s, $ifaceNil]; + } + } + } + runeTmp = arrayType$4.zero(); + buf$1 = $makeSlice(sliceType$6, 0, (_q = ($imul(3, s.length)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); + while (true) { + if (!(s.length > 0)) { break; } + _tuple$1 = UnquoteChar(s, quote); + c = _tuple$1[0]; + multibyte = _tuple$1[1]; + ss = _tuple$1[2]; + err = _tuple$1[3]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return ["", err]; + } + s = ss; + if (c < 128 || !multibyte) { + buf$1 = $append(buf$1, ((c << 24 >>> 24))); + } else { + n$1 = utf8.EncodeRune(new sliceType$6(runeTmp), c); + buf$1 = $appendSlice(buf$1, $subslice(new sliceType$6(runeTmp), 0, n$1)); + } + if ((quote === 39) && !((s.length === 0))) { + return ["", $pkg.ErrSyntax]; + } + } + return [($bytesToString(buf$1)), $ifaceNil]; + }; + $pkg.Unquote = Unquote; + contains = function(s, c) { + var c, s; + return !((bytealg.IndexByteString(s, c) === -1)); + }; + bsearch16 = function(a, x) { + var _q, _tmp, _tmp$1, a, h, i, j, x; + _tmp = 0; + _tmp$1 = a.$length; + i = _tmp; + j = _tmp$1; + while (true) { + if (!(i < j)) { break; } + h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + bsearch32 = function(a, x) { + var _q, _tmp, _tmp$1, a, h, i, j, x; + _tmp = 0; + _tmp$1 = a.$length; + i = _tmp; + j = _tmp$1; + while (true) { + if (!(i < j)) { break; } + h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + IsPrint = function(r) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, i, i$1, isNotPrint, isNotPrint$1, isPrint, isPrint$1, j, j$1, r, rr, rr$1, x, x$1, x$2, x$3; + if (r <= 255) { + if (32 <= r && r <= 126) { + return true; + } + if (161 <= r && r <= 255) { + return !((r === 173)); + } + return false; + } + if (0 <= r && r < 65536) { + _tmp = ((r << 16 >>> 16)); + _tmp$1 = isPrint16; + _tmp$2 = isNotPrint16; + rr = _tmp; + isPrint = _tmp$1; + isNotPrint = _tmp$2; + i = bsearch16(isPrint, rr); + if (i >= isPrint.$length || rr < (x = (i & ~1) >> 0, ((x < 0 || x >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x])) || (x$1 = i | 1, ((x$1 < 0 || x$1 >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x$1])) < rr) { + return false; + } + j = bsearch16(isNotPrint, rr); + return j >= isNotPrint.$length || !((((j < 0 || j >= isNotPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint.$array[isNotPrint.$offset + j]) === rr)); + } + _tmp$3 = ((r >>> 0)); + _tmp$4 = isPrint32; + _tmp$5 = isNotPrint32; + rr$1 = _tmp$3; + isPrint$1 = _tmp$4; + isNotPrint$1 = _tmp$5; + i$1 = bsearch32(isPrint$1, rr$1); + if (i$1 >= isPrint$1.$length || rr$1 < (x$2 = (i$1 & ~1) >> 0, ((x$2 < 0 || x$2 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$2])) || (x$3 = i$1 | 1, ((x$3 < 0 || x$3 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$3])) < rr$1) { + return false; + } + if (r >= 131072) { + return true; + } + r = r - (65536) >> 0; + j$1 = bsearch16(isNotPrint$1, ((r << 16 >>> 16))); + return j$1 >= isNotPrint$1.$length || !((((j$1 < 0 || j$1 >= isNotPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint$1.$array[isNotPrint$1.$offset + j$1]) === ((r << 16 >>> 16)))); + }; + $pkg.IsPrint = IsPrint; + isInGraphicList = function(r) { + var i, r, rr; + if (r > 65535) { + return false; + } + rr = ((r << 16 >>> 16)); + i = bsearch16(isGraphic, rr); + return i < isGraphic.$length && (rr === ((i < 0 || i >= isGraphic.$length) ? ($throwRuntimeError("index out of range"), undefined) : isGraphic.$array[isGraphic.$offset + i])); + }; + ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$2.methods = [{prop: "set", name: "set", pkg: "strconv", typ: $funcType([$String], [$Bool], false)}, {prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Assign", name: "Assign", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "Shift", name: "Shift", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundDown", name: "RoundDown", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundUp", name: "RoundUp", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundedInteger", name: "RoundedInteger", pkg: "", typ: $funcType([], [$Uint64], false)}]; + ptrType$4.methods = [{prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "AssignComputeBounds", name: "AssignComputeBounds", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, ptrType$1], [extFloat, extFloat], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([extFloat], [], false)}, {prop: "AssignDecimal", name: "AssignDecimal", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, $Bool, ptrType$1], [$Bool], false)}, {prop: "frexp10", name: "frexp10", pkg: "strconv", typ: $funcType([], [$Int, $Int], false)}, {prop: "FixedDecimal", name: "FixedDecimal", pkg: "", typ: $funcType([ptrType$3, $Int], [$Bool], false)}, {prop: "ShortestDecimal", name: "ShortestDecimal", pkg: "", typ: $funcType([ptrType$3, ptrType$4, ptrType$4], [$Bool], false)}]; + NumError.init("", [{prop: "Func", name: "Func", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Num", name: "Num", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); + decimal.init("strconv", [{prop: "d", name: "d", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "nd", name: "nd", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "trunc", name: "trunc", embedded: false, exported: false, typ: $Bool, tag: ""}]); + leftCheat.init("strconv", [{prop: "delta", name: "delta", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cutoff", name: "cutoff", embedded: false, exported: false, typ: $String, tag: ""}]); + extFloat.init("strconv", [{prop: "mant", name: "mant", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}]); + floatInfo.init("strconv", [{prop: "mantbits", name: "mantbits", embedded: false, exported: false, typ: $Uint, tag: ""}, {prop: "expbits", name: "expbits", embedded: false, exported: false, typ: $Uint, tag: ""}, {prop: "bias", name: "bias", embedded: false, exported: false, typ: $Int, tag: ""}]); + decimalSlice.init("strconv", [{prop: "d", name: "d", embedded: false, exported: false, typ: sliceType$6, tag: ""}, {prop: "nd", name: "nd", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bits.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + optimize = true; + powtab = new sliceType([1, 3, 6, 9, 13, 16, 19, 23, 26]); + float64pow10 = new sliceType$1([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 1e+21, 1e+22]); + float32pow10 = new sliceType$2([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10]); + $pkg.ErrRange = errors.New("value out of range"); + $pkg.ErrSyntax = errors.New("invalid syntax"); + leftcheats = new sliceType$3([new leftCheat.ptr(0, ""), new leftCheat.ptr(1, "5"), new leftCheat.ptr(1, "25"), new leftCheat.ptr(1, "125"), new leftCheat.ptr(2, "625"), new leftCheat.ptr(2, "3125"), new leftCheat.ptr(2, "15625"), new leftCheat.ptr(3, "78125"), new leftCheat.ptr(3, "390625"), new leftCheat.ptr(3, "1953125"), new leftCheat.ptr(4, "9765625"), new leftCheat.ptr(4, "48828125"), new leftCheat.ptr(4, "244140625"), new leftCheat.ptr(4, "1220703125"), new leftCheat.ptr(5, "6103515625"), new leftCheat.ptr(5, "30517578125"), new leftCheat.ptr(5, "152587890625"), new leftCheat.ptr(6, "762939453125"), new leftCheat.ptr(6, "3814697265625"), new leftCheat.ptr(6, "19073486328125"), new leftCheat.ptr(7, "95367431640625"), new leftCheat.ptr(7, "476837158203125"), new leftCheat.ptr(7, "2384185791015625"), new leftCheat.ptr(7, "11920928955078125"), new leftCheat.ptr(8, "59604644775390625"), new leftCheat.ptr(8, "298023223876953125"), new leftCheat.ptr(8, "1490116119384765625"), new leftCheat.ptr(9, "7450580596923828125"), new leftCheat.ptr(9, "37252902984619140625"), new leftCheat.ptr(9, "186264514923095703125"), new leftCheat.ptr(10, "931322574615478515625"), new leftCheat.ptr(10, "4656612873077392578125"), new leftCheat.ptr(10, "23283064365386962890625"), new leftCheat.ptr(10, "116415321826934814453125"), new leftCheat.ptr(11, "582076609134674072265625"), new leftCheat.ptr(11, "2910383045673370361328125"), new leftCheat.ptr(11, "14551915228366851806640625"), new leftCheat.ptr(12, "72759576141834259033203125"), new leftCheat.ptr(12, "363797880709171295166015625"), new leftCheat.ptr(12, "1818989403545856475830078125"), new leftCheat.ptr(13, "9094947017729282379150390625"), new leftCheat.ptr(13, "45474735088646411895751953125"), new leftCheat.ptr(13, "227373675443232059478759765625"), new leftCheat.ptr(13, "1136868377216160297393798828125"), new leftCheat.ptr(14, "5684341886080801486968994140625"), new leftCheat.ptr(14, "28421709430404007434844970703125"), new leftCheat.ptr(14, "142108547152020037174224853515625"), new leftCheat.ptr(15, "710542735760100185871124267578125"), new leftCheat.ptr(15, "3552713678800500929355621337890625"), new leftCheat.ptr(15, "17763568394002504646778106689453125"), new leftCheat.ptr(16, "88817841970012523233890533447265625"), new leftCheat.ptr(16, "444089209850062616169452667236328125"), new leftCheat.ptr(16, "2220446049250313080847263336181640625"), new leftCheat.ptr(16, "11102230246251565404236316680908203125"), new leftCheat.ptr(17, "55511151231257827021181583404541015625"), new leftCheat.ptr(17, "277555756156289135105907917022705078125"), new leftCheat.ptr(17, "1387778780781445675529539585113525390625"), new leftCheat.ptr(18, "6938893903907228377647697925567626953125"), new leftCheat.ptr(18, "34694469519536141888238489627838134765625"), new leftCheat.ptr(18, "173472347597680709441192448139190673828125"), new leftCheat.ptr(19, "867361737988403547205962240695953369140625")]); + smallPowersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(2147483648, 0), -63, false), new extFloat.ptr(new $Uint64(2684354560, 0), -60, false), new extFloat.ptr(new $Uint64(3355443200, 0), -57, false), new extFloat.ptr(new $Uint64(4194304000, 0), -54, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3276800000, 0), -47, false), new extFloat.ptr(new $Uint64(4096000000, 0), -44, false), new extFloat.ptr(new $Uint64(2560000000, 0), -40, false)]); + powersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(4203730336, 136053384), -1220, false), new extFloat.ptr(new $Uint64(3132023167, 2722021238), -1193, false), new extFloat.ptr(new $Uint64(2333539104, 810921078), -1166, false), new extFloat.ptr(new $Uint64(3477244234, 1573795306), -1140, false), new extFloat.ptr(new $Uint64(2590748842, 1432697645), -1113, false), new extFloat.ptr(new $Uint64(3860516611, 1025131999), -1087, false), new extFloat.ptr(new $Uint64(2876309015, 3348809418), -1060, false), new extFloat.ptr(new $Uint64(4286034428, 3200048207), -1034, false), new extFloat.ptr(new $Uint64(3193344495, 1097586188), -1007, false), new extFloat.ptr(new $Uint64(2379227053, 2424306748), -980, false), new extFloat.ptr(new $Uint64(3545324584, 827693699), -954, false), new extFloat.ptr(new $Uint64(2641472655, 2913388981), -927, false), new extFloat.ptr(new $Uint64(3936100983, 602835915), -901, false), new extFloat.ptr(new $Uint64(2932623761, 1081627501), -874, false), new extFloat.ptr(new $Uint64(2184974969, 1572261463), -847, false), new extFloat.ptr(new $Uint64(3255866422, 1308317239), -821, false), new extFloat.ptr(new $Uint64(2425809519, 944281679), -794, false), new extFloat.ptr(new $Uint64(3614737867, 629291719), -768, false), new extFloat.ptr(new $Uint64(2693189581, 2545915892), -741, false), new extFloat.ptr(new $Uint64(4013165208, 388672741), -715, false), new extFloat.ptr(new $Uint64(2990041083, 708162190), -688, false), new extFloat.ptr(new $Uint64(2227754207, 3536207675), -661, false), new extFloat.ptr(new $Uint64(3319612455, 450088378), -635, false), new extFloat.ptr(new $Uint64(2473304014, 3139815830), -608, false), new extFloat.ptr(new $Uint64(3685510180, 2103616900), -582, false), new extFloat.ptr(new $Uint64(2745919064, 224385782), -555, false), new extFloat.ptr(new $Uint64(4091738259, 3737383206), -529, false), new extFloat.ptr(new $Uint64(3048582568, 2868871352), -502, false), new extFloat.ptr(new $Uint64(2271371013, 1820084875), -475, false), new extFloat.ptr(new $Uint64(3384606560, 885076051), -449, false), new extFloat.ptr(new $Uint64(2521728396, 2444895829), -422, false), new extFloat.ptr(new $Uint64(3757668132, 1881767613), -396, false), new extFloat.ptr(new $Uint64(2799680927, 3102062735), -369, false), new extFloat.ptr(new $Uint64(4171849679, 2289335700), -343, false), new extFloat.ptr(new $Uint64(3108270227, 2410191823), -316, false), new extFloat.ptr(new $Uint64(2315841784, 3205436779), -289, false), new extFloat.ptr(new $Uint64(3450873173, 1697722806), -263, false), new extFloat.ptr(new $Uint64(2571100870, 3497754540), -236, false), new extFloat.ptr(new $Uint64(3831238852, 707476230), -210, false), new extFloat.ptr(new $Uint64(2854495385, 1769181907), -183, false), new extFloat.ptr(new $Uint64(4253529586, 2197867022), -157, false), new extFloat.ptr(new $Uint64(3169126500, 2450594539), -130, false), new extFloat.ptr(new $Uint64(2361183241, 1867548876), -103, false), new extFloat.ptr(new $Uint64(3518437208, 3793315116), -77, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3906250000, 0), -24, false), new extFloat.ptr(new $Uint64(2910383045, 2892103680), 3, false), new extFloat.ptr(new $Uint64(2168404344, 4170451332), 30, false), new extFloat.ptr(new $Uint64(3231174267, 3372684723), 56, false), new extFloat.ptr(new $Uint64(2407412430, 2078956656), 83, false), new extFloat.ptr(new $Uint64(3587324068, 2884206696), 109, false), new extFloat.ptr(new $Uint64(2672764710, 395977285), 136, false), new extFloat.ptr(new $Uint64(3982729777, 3569679143), 162, false), new extFloat.ptr(new $Uint64(2967364920, 2361961896), 189, false), new extFloat.ptr(new $Uint64(2210859150, 447440347), 216, false), new extFloat.ptr(new $Uint64(3294436857, 1114709402), 242, false), new extFloat.ptr(new $Uint64(2454546732, 2786846552), 269, false), new extFloat.ptr(new $Uint64(3657559652, 443583978), 295, false), new extFloat.ptr(new $Uint64(2725094297, 2599384906), 322, false), new extFloat.ptr(new $Uint64(4060706939, 3028118405), 348, false), new extFloat.ptr(new $Uint64(3025462433, 2044532855), 375, false), new extFloat.ptr(new $Uint64(2254145170, 1536935362), 402, false), new extFloat.ptr(new $Uint64(3358938053, 3365297469), 428, false), new extFloat.ptr(new $Uint64(2502603868, 4204241075), 455, false), new extFloat.ptr(new $Uint64(3729170365, 2577424355), 481, false), new extFloat.ptr(new $Uint64(2778448436, 3677981733), 508, false), new extFloat.ptr(new $Uint64(4140210802, 2744688476), 534, false), new extFloat.ptr(new $Uint64(3084697427, 1424604878), 561, false), new extFloat.ptr(new $Uint64(2298278679, 4062331362), 588, false), new extFloat.ptr(new $Uint64(3424702107, 3546052773), 614, false), new extFloat.ptr(new $Uint64(2551601907, 2065781727), 641, false), new extFloat.ptr(new $Uint64(3802183132, 2535403578), 667, false), new extFloat.ptr(new $Uint64(2832847187, 1558426518), 694, false), new extFloat.ptr(new $Uint64(4221271257, 2762425404), 720, false), new extFloat.ptr(new $Uint64(3145092172, 2812560400), 747, false), new extFloat.ptr(new $Uint64(2343276271, 3057687578), 774, false), new extFloat.ptr(new $Uint64(3491753744, 2790753324), 800, false), new extFloat.ptr(new $Uint64(2601559269, 3918606633), 827, false), new extFloat.ptr(new $Uint64(3876625403, 2711358621), 853, false), new extFloat.ptr(new $Uint64(2888311001, 1648096297), 880, false), new extFloat.ptr(new $Uint64(2151959390, 2057817989), 907, false), new extFloat.ptr(new $Uint64(3206669376, 61660461), 933, false), new extFloat.ptr(new $Uint64(2389154863, 1581580175), 960, false), new extFloat.ptr(new $Uint64(3560118173, 2626467905), 986, false), new extFloat.ptr(new $Uint64(2652494738, 3034782633), 1013, false), new extFloat.ptr(new $Uint64(3952525166, 3135207385), 1039, false), new extFloat.ptr(new $Uint64(2944860731, 2616258155), 1066, false)]); + uint64pow10 = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 10), new $Uint64(0, 100), new $Uint64(0, 1000), new $Uint64(0, 10000), new $Uint64(0, 100000), new $Uint64(0, 1000000), new $Uint64(0, 10000000), new $Uint64(0, 100000000), new $Uint64(0, 1000000000), new $Uint64(2, 1410065408), new $Uint64(23, 1215752192), new $Uint64(232, 3567587328), new $Uint64(2328, 1316134912), new $Uint64(23283, 276447232), new $Uint64(232830, 2764472320), new $Uint64(2328306, 1874919424), new $Uint64(23283064, 1569325056), new $Uint64(232830643, 2808348672), new $Uint64(2328306436, 2313682944)]); + float32info = new floatInfo.ptr(23, 8, -127); + float64info = new floatInfo.ptr(52, 11, -1023); + isPrint16 = new sliceType$4([32, 126, 161, 887, 890, 895, 900, 1366, 1369, 1418, 1421, 1479, 1488, 1514, 1520, 1524, 1542, 1563, 1566, 1805, 1808, 1866, 1869, 1969, 1984, 2042, 2048, 2093, 2096, 2139, 2142, 2154, 2208, 2237, 2260, 2444, 2447, 2448, 2451, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2531, 2534, 2557, 2561, 2570, 2575, 2576, 2579, 2617, 2620, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2654, 2662, 2677, 2689, 2745, 2748, 2765, 2768, 2768, 2784, 2787, 2790, 2801, 2809, 2828, 2831, 2832, 2835, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2915, 2918, 2935, 2946, 2954, 2958, 2965, 2969, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3021, 3024, 3024, 3031, 3031, 3046, 3066, 3072, 3129, 3133, 3149, 3157, 3162, 3168, 3171, 3174, 3183, 3192, 3257, 3260, 3277, 3285, 3286, 3294, 3299, 3302, 3314, 3328, 3407, 3412, 3427, 3430, 3455, 3458, 3478, 3482, 3517, 3520, 3526, 3530, 3530, 3535, 3551, 3558, 3567, 3570, 3572, 3585, 3642, 3647, 3675, 3713, 3716, 3719, 3722, 3725, 3725, 3732, 3751, 3754, 3773, 3776, 3789, 3792, 3801, 3804, 3807, 3840, 3948, 3953, 4058, 4096, 4295, 4301, 4301, 4304, 4685, 4688, 4701, 4704, 4749, 4752, 4789, 4792, 4805, 4808, 4885, 4888, 4954, 4957, 4988, 4992, 5017, 5024, 5109, 5112, 5117, 5120, 5788, 5792, 5880, 5888, 5908, 5920, 5942, 5952, 5971, 5984, 6003, 6016, 6109, 6112, 6121, 6128, 6137, 6144, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6443, 6448, 6459, 6464, 6464, 6468, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6622, 6683, 6686, 6780, 6783, 6793, 6800, 6809, 6816, 6829, 6832, 6846, 6912, 6987, 6992, 7036, 7040, 7155, 7164, 7223, 7227, 7241, 7245, 7304, 7360, 7367, 7376, 7417, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8061, 8064, 8147, 8150, 8175, 8178, 8190, 8208, 8231, 8240, 8286, 8304, 8305, 8308, 8348, 8352, 8383, 8400, 8432, 8448, 8587, 8592, 9254, 9280, 9290, 9312, 11123, 11126, 11157, 11160, 11193, 11197, 11218, 11244, 11247, 11264, 11507, 11513, 11559, 11565, 11565, 11568, 11623, 11631, 11632, 11647, 11670, 11680, 11849, 11904, 12019, 12032, 12245, 12272, 12283, 12289, 12438, 12441, 12543, 12549, 12590, 12593, 12730, 12736, 12771, 12784, 19893, 19904, 40938, 40960, 42124, 42128, 42182, 42192, 42539, 42560, 42743, 42752, 42935, 42999, 43051, 43056, 43065, 43072, 43127, 43136, 43205, 43214, 43225, 43232, 43261, 43264, 43347, 43359, 43388, 43392, 43481, 43486, 43574, 43584, 43597, 43600, 43609, 43612, 43714, 43739, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43877, 43888, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64449, 64467, 64831, 64848, 64911, 64914, 64967, 65008, 65021, 65024, 65049, 65056, 65131, 65136, 65276, 65281, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65504, 65518, 65532, 65533]); + isNotPrint16 = new sliceType$4([173, 907, 909, 930, 1328, 1376, 1416, 1424, 1757, 2111, 2143, 2229, 2274, 2436, 2473, 2481, 2526, 2564, 2601, 2609, 2612, 2615, 2621, 2653, 2692, 2702, 2706, 2729, 2737, 2740, 2758, 2762, 2816, 2820, 2857, 2865, 2868, 2910, 2948, 2961, 2971, 2973, 3017, 3076, 3085, 3089, 3113, 3141, 3145, 3159, 3204, 3213, 3217, 3241, 3252, 3269, 3273, 3295, 3312, 3332, 3341, 3345, 3397, 3401, 3460, 3506, 3516, 3541, 3543, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3770, 3781, 3783, 3912, 3992, 4029, 4045, 4294, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823, 4881, 5760, 5901, 5997, 6001, 6431, 6751, 7674, 8024, 8026, 8028, 8030, 8117, 8133, 8156, 8181, 8335, 11209, 11311, 11359, 11558, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 11743, 11930, 12352, 12687, 12831, 13055, 42927, 43470, 43519, 43815, 43823, 64311, 64317, 64319, 64322, 64325, 65107, 65127, 65141, 65511]); + isPrint32 = new sliceType$5([65536, 65613, 65616, 65629, 65664, 65786, 65792, 65794, 65799, 65843, 65847, 65947, 65952, 65952, 66000, 66045, 66176, 66204, 66208, 66256, 66272, 66299, 66304, 66339, 66349, 66378, 66384, 66426, 66432, 66499, 66504, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66927, 66927, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67640, 67644, 67644, 67647, 67742, 67751, 67759, 67808, 67829, 67835, 67867, 67871, 67897, 67903, 67903, 67968, 68023, 68028, 68047, 68050, 68102, 68108, 68147, 68152, 68154, 68159, 68167, 68176, 68184, 68192, 68255, 68288, 68326, 68331, 68342, 68352, 68405, 68409, 68437, 68440, 68466, 68472, 68497, 68505, 68508, 68521, 68527, 68608, 68680, 68736, 68786, 68800, 68850, 68858, 68863, 69216, 69246, 69632, 69709, 69714, 69743, 69759, 69825, 69840, 69864, 69872, 69881, 69888, 69955, 69968, 70006, 70016, 70093, 70096, 70132, 70144, 70206, 70272, 70313, 70320, 70378, 70384, 70393, 70400, 70412, 70415, 70416, 70419, 70457, 70460, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70749, 70784, 70855, 70864, 70873, 71040, 71093, 71096, 71133, 71168, 71236, 71248, 71257, 71264, 71276, 71296, 71351, 71360, 71369, 71424, 71449, 71453, 71467, 71472, 71487, 71840, 71922, 71935, 71935, 72192, 72263, 72272, 72323, 72326, 72354, 72384, 72440, 72704, 72773, 72784, 72812, 72816, 72847, 72850, 72886, 72960, 73014, 73018, 73031, 73040, 73049, 73728, 74649, 74752, 74868, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92777, 92782, 92783, 92880, 92909, 92912, 92917, 92928, 92997, 93008, 93047, 93053, 93071, 93952, 94020, 94032, 94078, 94095, 94111, 94176, 94177, 94208, 100332, 100352, 101106, 110592, 110878, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113820, 113823, 118784, 119029, 119040, 119078, 119081, 119154, 119163, 119272, 119296, 119365, 119552, 119638, 119648, 119665, 119808, 119967, 119970, 119970, 119973, 119974, 119977, 120074, 120077, 120134, 120138, 120485, 120488, 120779, 120782, 121483, 121499, 121519, 122880, 122904, 122907, 122922, 124928, 125124, 125127, 125142, 125184, 125258, 125264, 125273, 125278, 125279, 126464, 126500, 126503, 126523, 126530, 126530, 126535, 126548, 126551, 126564, 126567, 126619, 126625, 126651, 126704, 126705, 126976, 127019, 127024, 127123, 127136, 127150, 127153, 127221, 127232, 127244, 127248, 127339, 127344, 127404, 127462, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 128724, 128736, 128748, 128752, 128760, 128768, 128883, 128896, 128980, 129024, 129035, 129040, 129095, 129104, 129113, 129120, 129159, 129168, 129197, 129280, 129291, 129296, 129356, 129360, 129387, 129408, 129431, 129472, 129472, 129488, 129510, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]); + isNotPrint32 = new sliceType$4([12, 39, 59, 62, 399, 926, 2057, 2102, 2134, 2291, 2564, 2580, 2584, 4285, 4405, 4576, 4626, 4743, 4745, 4750, 4766, 4868, 4905, 4913, 4916, 5210, 5212, 6813, 7177, 7223, 7336, 7431, 7434, 7483, 7486, 9327, 27231, 27482, 27490, 54357, 54429, 54445, 54458, 54460, 54468, 54534, 54549, 54557, 54586, 54591, 54597, 54609, 55968, 57351, 57378, 57381, 60932, 60960, 60963, 60968, 60979, 60984, 60986, 61000, 61002, 61004, 61008, 61011, 61016, 61018, 61020, 61022, 61024, 61027, 61035, 61043, 61048, 61053, 61055, 61066, 61092, 61098, 61632, 61648, 61743, 63807]); + isGraphic = new sliceType$4([160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["crypto"] = (function() { + var $pkg = {}, $init, hash, io, strconv, funcType, sliceType$1, hashes, RegisterHash; + hash = $packages["hash"]; + io = $packages["io"]; + strconv = $packages["strconv"]; + funcType = $funcType([], [hash.Hash], false); + sliceType$1 = $sliceType(funcType); + RegisterHash = function(h, f) { + var f, h; + if (h >= 20) { + $panic(new $String("crypto: RegisterHash of unknown hash function")); + } + ((h < 0 || h >= hashes.$length) ? ($throwRuntimeError("index out of range"), undefined) : hashes.$array[hashes.$offset + h] = f); + }; + $pkg.RegisterHash = RegisterHash; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = hash.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + hashes = $makeSlice(sliceType$1, 20); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["crypto/sha256"] = (function() { + var $pkg = {}, $init, crypto, errors, hash, digest, sliceType, sliceType$1, arrayType, arrayType$1, arrayType$2, arrayType$3, arrayType$4, arrayType$6, ptrType, _K, block, init, putUint32, putUint64, appendUint64, appendUint32, consumeUint64, consumeUint32, New, New224, Sum256, blockGeneric; + crypto = $packages["crypto"]; + errors = $packages["errors"]; + hash = $packages["hash"]; + digest = $pkg.digest = $newType(0, $kindStruct, "sha256.digest", true, "crypto/sha256", false, function(h_, x_, nx_, len_, is224_) { + this.$val = this; + if (arguments.length === 0) { + this.h = arrayType$2.zero(); + this.x = arrayType$3.zero(); + this.nx = 0; + this.len = new $Uint64(0, 0); + this.is224 = false; + return; + } + this.h = h_; + this.x = x_; + this.nx = nx_; + this.len = len_; + this.is224 = is224_; + }); + sliceType = $sliceType($Uint32); + sliceType$1 = $sliceType($Uint8); + arrayType = $arrayType($Uint8, 8); + arrayType$1 = $arrayType($Uint8, 4); + arrayType$2 = $arrayType($Uint32, 8); + arrayType$3 = $arrayType($Uint8, 64); + arrayType$4 = $arrayType($Uint8, 32); + arrayType$6 = $arrayType($Uint32, 64); + ptrType = $ptrType(digest); + init = function() { + crypto.RegisterHash(4, New224); + crypto.RegisterHash(5, New); + }; + digest.ptr.prototype.MarshalBinary = function() { + var b, d; + d = this; + b = $makeSlice(sliceType$1, 0, 108); + if (d.is224) { + b = $appendSlice(b, "sha\x02"); + } else { + b = $appendSlice(b, "sha\x03"); + } + b = appendUint32(b, d.h[0]); + b = appendUint32(b, d.h[1]); + b = appendUint32(b, d.h[2]); + b = appendUint32(b, d.h[3]); + b = appendUint32(b, d.h[4]); + b = appendUint32(b, d.h[5]); + b = appendUint32(b, d.h[6]); + b = appendUint32(b, d.h[7]); + b = $appendSlice(b, $subslice(new sliceType$1(d.x), 0, d.nx)); + b = $subslice(b, 0, ((b.$length + 64 >> 0) - (d.nx) >> 0)); + b = appendUint64(b, d.len); + return [b, $ifaceNil]; + }; + digest.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); }; + digest.ptr.prototype.UnmarshalBinary = function(b) { + var _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, b, d; + d = this; + if (b.$length < 4 || (d.is224 && !(($bytesToString($subslice(b, 0, 4))) === "sha\x02")) || (!d.is224 && !(($bytesToString($subslice(b, 0, 4))) === "sha\x03"))) { + return errors.New("crypto/sha256: invalid hash state identifier"); + } + if (!((b.$length === 108))) { + return errors.New("crypto/sha256: invalid hash state size"); + } + b = $subslice(b, 4); + _tuple = consumeUint32(b); + b = _tuple[0]; + d.h[0] = _tuple[1]; + _tuple$1 = consumeUint32(b); + b = _tuple$1[0]; + d.h[1] = _tuple$1[1]; + _tuple$2 = consumeUint32(b); + b = _tuple$2[0]; + d.h[2] = _tuple$2[1]; + _tuple$3 = consumeUint32(b); + b = _tuple$3[0]; + d.h[3] = _tuple$3[1]; + _tuple$4 = consumeUint32(b); + b = _tuple$4[0]; + d.h[4] = _tuple$4[1]; + _tuple$5 = consumeUint32(b); + b = _tuple$5[0]; + d.h[5] = _tuple$5[1]; + _tuple$6 = consumeUint32(b); + b = _tuple$6[0]; + d.h[6] = _tuple$6[1]; + _tuple$7 = consumeUint32(b); + b = _tuple$7[0]; + d.h[7] = _tuple$7[1]; + b = $subslice(b, $copySlice(new sliceType$1(d.x), b)); + _tuple$8 = consumeUint64(b); + b = _tuple$8[0]; + d.len = _tuple$8[1]; + d.nx = (($div64(d.len, new $Uint64(0, 64), true).$low >> 0)); + return $ifaceNil; + }; + digest.prototype.UnmarshalBinary = function(b) { return this.$val.UnmarshalBinary(b); }; + putUint32 = function(x, s) { + var s, x; + $unused((3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3])); + (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = (((s >>> 24 >>> 0) << 24 >>> 24))); + (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1] = (((s >>> 16 >>> 0) << 24 >>> 24))); + (2 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 2] = (((s >>> 8 >>> 0) << 24 >>> 24))); + (3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3] = ((s << 24 >>> 24))); + }; + putUint64 = function(x, s) { + var s, x; + $unused((7 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 7])); + (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = (($shiftRightUint64(s, 56).$low << 24 >>> 24))); + (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1] = (($shiftRightUint64(s, 48).$low << 24 >>> 24))); + (2 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 2] = (($shiftRightUint64(s, 40).$low << 24 >>> 24))); + (3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3] = (($shiftRightUint64(s, 32).$low << 24 >>> 24))); + (4 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 4] = (($shiftRightUint64(s, 24).$low << 24 >>> 24))); + (5 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 5] = (($shiftRightUint64(s, 16).$low << 24 >>> 24))); + (6 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 6] = (($shiftRightUint64(s, 8).$low << 24 >>> 24))); + (7 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 7] = ((s.$low << 24 >>> 24))); + }; + appendUint64 = function(b, x) { + var a, b, x; + a = arrayType.zero(); + putUint64(new sliceType$1(a), x); + return $appendSlice(b, new sliceType$1(a)); + }; + appendUint32 = function(b, x) { + var a, b, x; + a = arrayType$1.zero(); + putUint32(new sliceType$1(a), x); + return $appendSlice(b, new sliceType$1(a)); + }; + consumeUint64 = function(b) { + var b, x, x$1, x$10, x$11, x$12, x$13, x$14, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + x$14 = (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$7 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); + return [$subslice(b, 8), x$14]; + }; + consumeUint32 = function(b) { + var b, x; + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + x = ((((((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) << 24 >>> 0)) >>> 0; + return [$subslice(b, 4), x]; + }; + digest.ptr.prototype.Reset = function() { + var d; + d = this; + if (!d.is224) { + d.h[0] = 1779033703; + d.h[1] = 3144134277; + d.h[2] = 1013904242; + d.h[3] = 2773480762; + d.h[4] = 1359893119; + d.h[5] = 2600822924; + d.h[6] = 528734635; + d.h[7] = 1541459225; + } else { + d.h[0] = 3238371032; + d.h[1] = 914150663; + d.h[2] = 812702999; + d.h[3] = 4144912697; + d.h[4] = 4290775857; + d.h[5] = 1750603025; + d.h[6] = 1694076839; + d.h[7] = 3204075428; + } + d.nx = 0; + d.len = new $Uint64(0, 0); + }; + digest.prototype.Reset = function() { return this.$val.Reset(); }; + New = function() { + var d; + d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); + d.Reset(); + return d; + }; + $pkg.New = New; + New224 = function() { + var d; + d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); + d.is224 = true; + d.Reset(); + return d; + }; + $pkg.New224 = New224; + digest.ptr.prototype.Size = function() { + var d; + d = this; + if (!d.is224) { + return 32; + } + return 28; + }; + digest.prototype.Size = function() { return this.$val.Size(); }; + digest.ptr.prototype.BlockSize = function() { + var d; + d = this; + return 64; + }; + digest.prototype.BlockSize = function() { return this.$val.BlockSize(); }; + digest.ptr.prototype.Write = function(p) { + var d, err, n, n$1, nn, p, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; d = $f.d; err = $f.err; n = $f.n; n$1 = $f.n$1; nn = $f.nn; p = $f.p; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + nn = 0; + err = $ifaceNil; + d = this; + nn = p.$length; + d.len = (x = d.len, x$1 = (new $Uint64(0, nn)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + /* */ if (d.nx > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (d.nx > 0) { */ case 1: + n = $copySlice($subslice(new sliceType$1(d.x), d.nx), p); + d.nx = d.nx + (n) >> 0; + /* */ if (d.nx === 64) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (d.nx === 64) { */ case 3: + $r = block(d, new sliceType$1(d.x)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + d.nx = 0; + /* } */ case 4: + p = $subslice(p, n); + /* } */ case 2: + /* */ if (p.$length >= 64) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (p.$length >= 64) { */ case 6: + n$1 = (p.$length & ~63) >> 0; + $r = block(d, $subslice(p, 0, n$1)); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + p = $subslice(p, n$1); + /* } */ case 7: + if (p.$length > 0) { + d.nx = $copySlice(new sliceType$1(d.x), p); + } + $s = -1; return [nn, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.Write }; } $f.d = d; $f.err = err; $f.n = n; $f.n$1 = n$1; $f.nn = nn; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + digest.prototype.Write = function(p) { return this.$val.Write(p); }; + digest.ptr.prototype.Sum = function(in$1) { + var _r, d, d0, hash$1, in$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; d = $f.d; d0 = $f.d0; hash$1 = $f.hash$1; in$1 = $f.in$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + d = this; + d0 = $clone(d, digest); + _r = d0.checkSum(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + hash$1 = $clone(_r, arrayType$4); + if (d0.is224) { + $s = -1; return $appendSlice(in$1, $subslice(new sliceType$1(hash$1), 0, 28)); + } + $s = -1; return $appendSlice(in$1, new sliceType$1(hash$1)); + /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.Sum }; } $f._r = _r; $f.d = d; $f.d0 = d0; $f.hash$1 = hash$1; $f.in$1 = in$1; $f.$s = $s; $f.$r = $r; return $f; + }; + digest.prototype.Sum = function(in$1) { return this.$val.Sum(in$1); }; + digest.ptr.prototype.checkSum = function() { + var _r, _r$1, _r$2, d, digest$1, len, tmp, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; d = $f.d; digest$1 = $f.digest$1; len = $f.len; tmp = $f.tmp; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + d = this; + len = d.len; + tmp = arrayType$3.zero(); + tmp[0] = 128; + /* */ if ((x = $div64(len, new $Uint64(0, 64), true), (x.$high < 0 || (x.$high === 0 && x.$low < 56)))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((x = $div64(len, new $Uint64(0, 64), true), (x.$high < 0 || (x.$high === 0 && x.$low < 56)))) { */ case 1: + _r = d.Write($subslice(new sliceType$1(tmp), 0, $flatten64((x$1 = $div64(len, new $Uint64(0, 64), true), new $Uint64(0 - x$1.$high, 56 - x$1.$low))))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + $s = 3; continue; + /* } else { */ case 2: + _r$1 = d.Write($subslice(new sliceType$1(tmp), 0, $flatten64((x$2 = $div64(len, new $Uint64(0, 64), true), new $Uint64(0 - x$2.$high, 120 - x$2.$low))))); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 3: + len = $shiftLeft64(len, (3)); + putUint64(new sliceType$1(tmp), len); + _r$2 = d.Write($subslice(new sliceType$1(tmp), 0, 8)); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + if (!((d.nx === 0))) { + $panic(new $String("d.nx != 0")); + } + digest$1 = arrayType$4.zero(); + putUint32($subslice(new sliceType$1(digest$1), 0), d.h[0]); + putUint32($subslice(new sliceType$1(digest$1), 4), d.h[1]); + putUint32($subslice(new sliceType$1(digest$1), 8), d.h[2]); + putUint32($subslice(new sliceType$1(digest$1), 12), d.h[3]); + putUint32($subslice(new sliceType$1(digest$1), 16), d.h[4]); + putUint32($subslice(new sliceType$1(digest$1), 20), d.h[5]); + putUint32($subslice(new sliceType$1(digest$1), 24), d.h[6]); + if (!d.is224) { + putUint32($subslice(new sliceType$1(digest$1), 28), d.h[7]); + } + $s = -1; return digest$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.checkSum }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.d = d; $f.digest$1 = digest$1; $f.len = len; $f.tmp = tmp; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + digest.prototype.checkSum = function() { return this.$val.checkSum(); }; + Sum256 = function(data) { + var _r, _r$1, d, data, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; d = $f.d; data = $f.data; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); + d.Reset(); + _r = d.Write(data); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + _r$1 = d.checkSum(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sum256 }; } $f._r = _r; $f._r$1 = _r$1; $f.d = d; $f.data = data; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sum256 = Sum256; + blockGeneric = function(dig, p) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, a, b, c, d, dig, e, f, g, h, h0, h1, h2, h3, h4, h5, h6, h7, i, i$1, i$2, j, p, t1, t1$1, t2, t2$1, v1, v2, w, x, x$1, x$2, x$3, x$4, x$5, x$6; + w = arrayType$6.zero(); + _tmp = dig.h[0]; + _tmp$1 = dig.h[1]; + _tmp$2 = dig.h[2]; + _tmp$3 = dig.h[3]; + _tmp$4 = dig.h[4]; + _tmp$5 = dig.h[5]; + _tmp$6 = dig.h[6]; + _tmp$7 = dig.h[7]; + h0 = _tmp; + h1 = _tmp$1; + h2 = _tmp$2; + h3 = _tmp$3; + h4 = _tmp$4; + h5 = _tmp$5; + h6 = _tmp$6; + h7 = _tmp$7; + while (true) { + if (!(p.$length >= 64)) { break; } + i = 0; + while (true) { + if (!(i < 16)) { break; } + j = $imul(i, 4); + ((i < 0 || i >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i] = (((((((((((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]) >>> 0)) << 24 >>> 0) | ((((x = j + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])) >>> 0)) << 16 >>> 0)) >>> 0) | ((((x$1 = j + 2 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])) >>> 0)) << 8 >>> 0)) >>> 0) | (((x$2 = j + 3 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2])) >>> 0))) >>> 0)); + i = i + (1) >> 0; + } + i$1 = 16; + while (true) { + if (!(i$1 < 64)) { break; } + v1 = (x$3 = i$1 - 2 >> 0, ((x$3 < 0 || x$3 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$3])); + t1 = (((((((v1 >>> 17 >>> 0) | (v1 << 15 >>> 0)) >>> 0)) ^ ((((v1 >>> 19 >>> 0) | (v1 << 13 >>> 0)) >>> 0))) >>> 0) ^ ((v1 >>> 10 >>> 0))) >>> 0; + v2 = (x$4 = i$1 - 15 >> 0, ((x$4 < 0 || x$4 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$4])); + t2 = (((((((v2 >>> 7 >>> 0) | (v2 << 25 >>> 0)) >>> 0)) ^ ((((v2 >>> 18 >>> 0) | (v2 << 14 >>> 0)) >>> 0))) >>> 0) ^ ((v2 >>> 3 >>> 0))) >>> 0; + ((i$1 < 0 || i$1 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i$1] = (((t1 + (x$5 = i$1 - 7 >> 0, ((x$5 < 0 || x$5 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$5])) >>> 0) + t2 >>> 0) + (x$6 = i$1 - 16 >> 0, ((x$6 < 0 || x$6 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$6])) >>> 0)); + i$1 = i$1 + (1) >> 0; + } + _tmp$8 = h0; + _tmp$9 = h1; + _tmp$10 = h2; + _tmp$11 = h3; + _tmp$12 = h4; + _tmp$13 = h5; + _tmp$14 = h6; + _tmp$15 = h7; + a = _tmp$8; + b = _tmp$9; + c = _tmp$10; + d = _tmp$11; + e = _tmp$12; + f = _tmp$13; + g = _tmp$14; + h = _tmp$15; + i$2 = 0; + while (true) { + if (!(i$2 < 64)) { break; } + t1$1 = (((h + (((((((((e >>> 6 >>> 0) | (e << 26 >>> 0)) >>> 0)) ^ ((((e >>> 11 >>> 0) | (e << 21 >>> 0)) >>> 0))) >>> 0) ^ ((((e >>> 25 >>> 0) | (e << 7 >>> 0)) >>> 0))) >>> 0)) >>> 0) + ((((((e & f) >>> 0)) ^ ((((~e >>> 0) & g) >>> 0))) >>> 0)) >>> 0) + ((i$2 < 0 || i$2 >= _K.$length) ? ($throwRuntimeError("index out of range"), undefined) : _K.$array[_K.$offset + i$2]) >>> 0) + ((i$2 < 0 || i$2 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i$2]) >>> 0; + t2$1 = (((((((((a >>> 2 >>> 0) | (a << 30 >>> 0)) >>> 0)) ^ ((((a >>> 13 >>> 0) | (a << 19 >>> 0)) >>> 0))) >>> 0) ^ ((((a >>> 22 >>> 0) | (a << 10 >>> 0)) >>> 0))) >>> 0)) + ((((((((a & b) >>> 0)) ^ (((a & c) >>> 0))) >>> 0) ^ (((b & c) >>> 0))) >>> 0)) >>> 0; + h = g; + g = f; + f = e; + e = d + t1$1 >>> 0; + d = c; + c = b; + b = a; + a = t1$1 + t2$1 >>> 0; + i$2 = i$2 + (1) >> 0; + } + h0 = h0 + (a) >>> 0; + h1 = h1 + (b) >>> 0; + h2 = h2 + (c) >>> 0; + h3 = h3 + (d) >>> 0; + h4 = h4 + (e) >>> 0; + h5 = h5 + (f) >>> 0; + h6 = h6 + (g) >>> 0; + h7 = h7 + (h) >>> 0; + p = $subslice(p, 64); + } + _tmp$16 = h0; + _tmp$17 = h1; + _tmp$18 = h2; + _tmp$19 = h3; + _tmp$20 = h4; + _tmp$21 = h5; + _tmp$22 = h6; + _tmp$23 = h7; + dig.h[0] = _tmp$16; + dig.h[1] = _tmp$17; + dig.h[2] = _tmp$18; + dig.h[3] = _tmp$19; + dig.h[4] = _tmp$20; + dig.h[5] = _tmp$21; + dig.h[6] = _tmp$22; + dig.h[7] = _tmp$23; + }; + ptrType.methods = [{prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "BlockSize", name: "BlockSize", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "Sum", name: "Sum", pkg: "", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "checkSum", name: "checkSum", pkg: "crypto/sha256", typ: $funcType([], [arrayType$4], false)}]; + digest.init("crypto/sha256", [{prop: "h", name: "h", embedded: false, exported: false, typ: arrayType$2, tag: ""}, {prop: "x", name: "x", embedded: false, exported: false, typ: arrayType$3, tag: ""}, {prop: "nx", name: "nx", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "is224", name: "is224", embedded: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = crypto.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = hash.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _K = new sliceType([1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298]); + block = blockGeneric; + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["unicode"] = (function() { + var $pkg = {}, $init, RangeTable, Range16, Range32, CaseRange, d, foldPair, arrayType, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, sliceType$4, _C, _Cc, _Cf, _Co, _Cs, _L, _Ll, _Lm, _Lo, _Lt, _Lu, _M, _Mc, _Me, _Mn, _N, _Nd, _Nl, _No, _P, _Pc, _Pd, _Pe, _Pf, _Pi, _Po, _Ps, _S, _Sc, _Sk, _Sm, _So, _Z, _Zl, _Zp, _Zs, _Adlam, _Ahom, _Anatolian_Hieroglyphs, _Arabic, _Armenian, _Avestan, _Balinese, _Bamum, _Bassa_Vah, _Batak, _Bengali, _Bhaiksuki, _Bopomofo, _Brahmi, _Braille, _Buginese, _Buhid, _Canadian_Aboriginal, _Carian, _Caucasian_Albanian, _Chakma, _Cham, _Cherokee, _Common, _Coptic, _Cuneiform, _Cypriot, _Cyrillic, _Deseret, _Devanagari, _Duployan, _Egyptian_Hieroglyphs, _Elbasan, _Ethiopic, _Georgian, _Glagolitic, _Gothic, _Grantha, _Greek, _Gujarati, _Gurmukhi, _Han, _Hangul, _Hanunoo, _Hatran, _Hebrew, _Hiragana, _Imperial_Aramaic, _Inherited, _Inscriptional_Pahlavi, _Inscriptional_Parthian, _Javanese, _Kaithi, _Kannada, _Katakana, _Kayah_Li, _Kharoshthi, _Khmer, _Khojki, _Khudawadi, _Lao, _Latin, _Lepcha, _Limbu, _Linear_A, _Linear_B, _Lisu, _Lycian, _Lydian, _Mahajani, _Malayalam, _Mandaic, _Manichaean, _Marchen, _Masaram_Gondi, _Meetei_Mayek, _Mende_Kikakui, _Meroitic_Cursive, _Meroitic_Hieroglyphs, _Miao, _Modi, _Mongolian, _Mro, _Multani, _Myanmar, _Nabataean, _New_Tai_Lue, _Newa, _Nko, _Nushu, _Ogham, _Ol_Chiki, _Old_Hungarian, _Old_Italic, _Old_North_Arabian, _Old_Permic, _Old_Persian, _Old_South_Arabian, _Old_Turkic, _Oriya, _Osage, _Osmanya, _Pahawh_Hmong, _Palmyrene, _Pau_Cin_Hau, _Phags_Pa, _Phoenician, _Psalter_Pahlavi, _Rejang, _Runic, _Samaritan, _Saurashtra, _Sharada, _Shavian, _Siddham, _SignWriting, _Sinhala, _Sora_Sompeng, _Soyombo, _Sundanese, _Syloti_Nagri, _Syriac, _Tagalog, _Tagbanwa, _Tai_Le, _Tai_Tham, _Tai_Viet, _Takri, _Tamil, _Tangut, _Telugu, _Thaana, _Thai, _Tibetan, _Tifinagh, _Tirhuta, _Ugaritic, _Vai, _Warang_Citi, _Yi, _Zanabazar_Square, _CaseRanges, properties, asciiFold, caseOrbit, foldL, foldLl, foldLt, foldLu, foldM, foldMn, foldCommon, foldGreek, foldInherited, to, IsDigit, IsPrint, In, IsLetter, is16, is32, Is, isExcludingLatin, To, ToUpper, ToLower, SimpleFold; + RangeTable = $pkg.RangeTable = $newType(0, $kindStruct, "unicode.RangeTable", true, "unicode", true, function(R16_, R32_, LatinOffset_) { + this.$val = this; + if (arguments.length === 0) { + this.R16 = sliceType.nil; + this.R32 = sliceType$1.nil; + this.LatinOffset = 0; + return; + } + this.R16 = R16_; + this.R32 = R32_; + this.LatinOffset = LatinOffset_; + }); + Range16 = $pkg.Range16 = $newType(0, $kindStruct, "unicode.Range16", true, "unicode", true, function(Lo_, Hi_, Stride_) { + this.$val = this; + if (arguments.length === 0) { + this.Lo = 0; + this.Hi = 0; + this.Stride = 0; + return; + } + this.Lo = Lo_; + this.Hi = Hi_; + this.Stride = Stride_; + }); + Range32 = $pkg.Range32 = $newType(0, $kindStruct, "unicode.Range32", true, "unicode", true, function(Lo_, Hi_, Stride_) { + this.$val = this; + if (arguments.length === 0) { + this.Lo = 0; + this.Hi = 0; + this.Stride = 0; + return; + } + this.Lo = Lo_; + this.Hi = Hi_; + this.Stride = Stride_; + }); + CaseRange = $pkg.CaseRange = $newType(0, $kindStruct, "unicode.CaseRange", true, "unicode", true, function(Lo_, Hi_, Delta_) { + this.$val = this; + if (arguments.length === 0) { + this.Lo = 0; + this.Hi = 0; + this.Delta = arrayType.zero(); + return; + } + this.Lo = Lo_; + this.Hi = Hi_; + this.Delta = Delta_; + }); + d = $pkg.d = $newType(12, $kindArray, "unicode.d", true, "unicode", false, null); + foldPair = $pkg.foldPair = $newType(0, $kindStruct, "unicode.foldPair", true, "unicode", false, function(From_, To_) { + this.$val = this; + if (arguments.length === 0) { + this.From = 0; + this.To = 0; + return; + } + this.From = From_; + this.To = To_; + }); + arrayType = $arrayType($Int32, 3); + sliceType = $sliceType(Range16); + sliceType$1 = $sliceType(Range32); + ptrType = $ptrType(RangeTable); + sliceType$2 = $sliceType(ptrType); + sliceType$3 = $sliceType(CaseRange); + sliceType$4 = $sliceType(foldPair); + to = function(_case, r, caseRange) { + var _case, _q, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, caseRange, cr, delta, foundMapping, hi, lo, m, mappedRune, r, x; + mappedRune = 0; + foundMapping = false; + if (_case < 0 || 3 <= _case) { + _tmp = 65533; + _tmp$1 = false; + mappedRune = _tmp; + foundMapping = _tmp$1; + return [mappedRune, foundMapping]; + } + lo = 0; + hi = caseRange.$length; + while (true) { + if (!(lo < hi)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + cr = ((m < 0 || m >= caseRange.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseRange.$array[caseRange.$offset + m]); + if (((cr.Lo >> 0)) <= r && r <= ((cr.Hi >> 0))) { + delta = ((x = cr.Delta, ((_case < 0 || _case >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[_case]))); + if (delta > 1114111) { + _tmp$2 = ((cr.Lo >> 0)) + ((((((r - ((cr.Lo >> 0)) >> 0)) & ~1) >> 0) | (((_case & 1) >> 0)))) >> 0; + _tmp$3 = true; + mappedRune = _tmp$2; + foundMapping = _tmp$3; + return [mappedRune, foundMapping]; + } + _tmp$4 = r + delta >> 0; + _tmp$5 = true; + mappedRune = _tmp$4; + foundMapping = _tmp$5; + return [mappedRune, foundMapping]; + } + if (r < ((cr.Lo >> 0))) { + hi = m; + } else { + lo = m + 1 >> 0; + } + } + _tmp$6 = r; + _tmp$7 = false; + mappedRune = _tmp$6; + foundMapping = _tmp$7; + return [mappedRune, foundMapping]; + }; + IsDigit = function(r) { + var r; + if (r <= 255) { + return 48 <= r && r <= 57; + } + return isExcludingLatin($pkg.Digit, r); + }; + $pkg.IsDigit = IsDigit; + IsPrint = function(r) { + var r, x; + if (((r >>> 0)) <= 255) { + return !(((((x = ((r << 24 >>> 24)), ((x < 0 || x >= properties.length) ? ($throwRuntimeError("index out of range"), undefined) : properties[x])) & 128) >>> 0) === 0)); + } + return In(r, $pkg.PrintRanges); + }; + $pkg.IsPrint = IsPrint; + In = function(r, ranges) { + var _i, _ref, inside, r, ranges; + _ref = ranges; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + inside = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (Is(inside, r)) { + return true; + } + _i++; + } + return false; + }; + $pkg.In = In; + IsLetter = function(r) { + var r, x; + if (((r >>> 0)) <= 255) { + return !(((((x = ((r << 24 >>> 24)), ((x < 0 || x >= properties.length) ? ($throwRuntimeError("index out of range"), undefined) : properties[x])) & 96) >>> 0) === 0)); + } + return isExcludingLatin($pkg.Letter, r); + }; + $pkg.IsLetter = IsLetter; + is16 = function(ranges, r) { + var _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges; + if (ranges.$length <= 18 || r <= 255) { + _ref = ranges; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + range_ = ((i < 0 || i >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + i]); + if (r < range_.Lo) { + return false; + } + if (r <= range_.Hi) { + return (range_.Stride === 1) || ((_r = ((r - range_.Lo << 16 >>> 16)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0); + } + _i++; + } + return false; + } + lo = 0; + hi = ranges.$length; + while (true) { + if (!(lo < hi)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + range_$1 = ((m < 0 || m >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + m]); + if (range_$1.Lo <= r && r <= range_$1.Hi) { + return (range_$1.Stride === 1) || ((_r$1 = ((r - range_$1.Lo << 16 >>> 16)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0); + } + if (r < range_$1.Lo) { + hi = m; + } else { + lo = m + 1 >> 0; + } + } + return false; + }; + is32 = function(ranges, r) { + var _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges; + if (ranges.$length <= 18) { + _ref = ranges; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + range_ = ((i < 0 || i >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + i]); + if (r < range_.Lo) { + return false; + } + if (r <= range_.Hi) { + return (range_.Stride === 1) || ((_r = ((r - range_.Lo >>> 0)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0); + } + _i++; + } + return false; + } + lo = 0; + hi = ranges.$length; + while (true) { + if (!(lo < hi)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + range_$1 = $clone(((m < 0 || m >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + m]), Range32); + if (range_$1.Lo <= r && r <= range_$1.Hi) { + return (range_$1.Stride === 1) || ((_r$1 = ((r - range_$1.Lo >>> 0)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0); + } + if (r < range_$1.Lo) { + hi = m; + } else { + lo = m + 1 >> 0; + } + } + return false; + }; + Is = function(rangeTab, r) { + var r, r16, r32, rangeTab, x; + r16 = rangeTab.R16; + if (r16.$length > 0 && r <= (((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? ($throwRuntimeError("index out of range"), undefined) : r16.$array[r16.$offset + x])).Hi >> 0))) { + return is16(r16, ((r << 16 >>> 16))); + } + r32 = rangeTab.R32; + if (r32.$length > 0 && r >= (((0 >= r32.$length ? ($throwRuntimeError("index out of range"), undefined) : r32.$array[r32.$offset + 0]).Lo >> 0))) { + return is32(r32, ((r >>> 0))); + } + return false; + }; + $pkg.Is = Is; + isExcludingLatin = function(rangeTab, r) { + var off, r, r16, r32, rangeTab, x; + r16 = rangeTab.R16; + off = rangeTab.LatinOffset; + if (r16.$length > off && r <= (((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? ($throwRuntimeError("index out of range"), undefined) : r16.$array[r16.$offset + x])).Hi >> 0))) { + return is16($subslice(r16, off), ((r << 16 >>> 16))); + } + r32 = rangeTab.R32; + if (r32.$length > 0 && r >= (((0 >= r32.$length ? ($throwRuntimeError("index out of range"), undefined) : r32.$array[r32.$offset + 0]).Lo >> 0))) { + return is32(r32, ((r >>> 0))); + } + return false; + }; + To = function(_case, r) { + var _case, _tuple, r; + _tuple = to(_case, r, $pkg.CaseRanges); + r = _tuple[0]; + return r; + }; + $pkg.To = To; + ToUpper = function(r) { + var r; + if (r <= 127) { + if (97 <= r && r <= 122) { + r = r - (32) >> 0; + } + return r; + } + return To(0, r); + }; + $pkg.ToUpper = ToUpper; + ToLower = function(r) { + var r; + if (r <= 127) { + if (65 <= r && r <= 90) { + r = r + (32) >> 0; + } + return r; + } + return To(1, r); + }; + $pkg.ToLower = ToLower; + SimpleFold = function(r) { + var _q, hi, l, lo, m, r; + if (r < 0 || r > 1114111) { + return r; + } + if (((r >> 0)) < 128) { + return ((((r < 0 || r >= asciiFold.length) ? ($throwRuntimeError("index out of range"), undefined) : asciiFold[r]) >> 0)); + } + lo = 0; + hi = caseOrbit.$length; + while (true) { + if (!(lo < hi)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + if (((((m < 0 || m >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + m]).From >> 0)) < r) { + lo = m + 1 >> 0; + } else { + hi = m; + } + } + if (lo < caseOrbit.$length && (((((lo < 0 || lo >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + lo]).From >> 0)) === r)) { + return ((((lo < 0 || lo >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + lo]).To >> 0)); + } + l = ToLower(r); + if (!((l === r))) { + return l; + } + return ToUpper(r); + }; + $pkg.SimpleFold = SimpleFold; + RangeTable.init("", [{prop: "R16", name: "R16", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "R32", name: "R32", embedded: false, exported: true, typ: sliceType$1, tag: ""}, {prop: "LatinOffset", name: "LatinOffset", embedded: false, exported: true, typ: $Int, tag: ""}]); + Range16.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Stride", name: "Stride", embedded: false, exported: true, typ: $Uint16, tag: ""}]); + Range32.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Stride", name: "Stride", embedded: false, exported: true, typ: $Uint32, tag: ""}]); + CaseRange.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Delta", name: "Delta", embedded: false, exported: true, typ: d, tag: ""}]); + d.init($Int32, 3); + foldPair.init("", [{prop: "From", name: "From", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "To", name: "To", embedded: false, exported: true, typ: $Uint16, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _C = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 31, 1), new Range16.ptr(127, 159, 1), new Range16.ptr(173, 1536, 1363), new Range16.ptr(1537, 1541, 1), new Range16.ptr(1564, 1757, 193), new Range16.ptr(1807, 2274, 467), new Range16.ptr(6158, 8203, 2045), new Range16.ptr(8204, 8207, 1), new Range16.ptr(8234, 8238, 1), new Range16.ptr(8288, 8292, 1), new Range16.ptr(8294, 8303, 1), new Range16.ptr(55296, 63743, 1), new Range16.ptr(65279, 65529, 250), new Range16.ptr(65530, 65531, 1)]), new sliceType$1([new Range32.ptr(69821, 113824, 44003), new Range32.ptr(113825, 113827, 1), new Range32.ptr(119155, 119162, 1), new Range32.ptr(917505, 917536, 31), new Range32.ptr(917537, 917631, 1), new Range32.ptr(983040, 1048573, 1), new Range32.ptr(1048576, 1114109, 1)]), 2); + _Cc = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 31, 1), new Range16.ptr(127, 159, 1)]), sliceType$1.nil, 2); + _Cf = new RangeTable.ptr(new sliceType([new Range16.ptr(173, 1536, 1363), new Range16.ptr(1537, 1541, 1), new Range16.ptr(1564, 1757, 193), new Range16.ptr(1807, 2274, 467), new Range16.ptr(6158, 8203, 2045), new Range16.ptr(8204, 8207, 1), new Range16.ptr(8234, 8238, 1), new Range16.ptr(8288, 8292, 1), new Range16.ptr(8294, 8303, 1), new Range16.ptr(65279, 65529, 250), new Range16.ptr(65530, 65531, 1)]), new sliceType$1([new Range32.ptr(69821, 113824, 44003), new Range32.ptr(113825, 113827, 1), new Range32.ptr(119155, 119162, 1), new Range32.ptr(917505, 917536, 31), new Range32.ptr(917537, 917631, 1)]), 0); + _Co = new RangeTable.ptr(new sliceType([new Range16.ptr(57344, 63743, 1)]), new sliceType$1([new Range32.ptr(983040, 1048573, 1), new Range32.ptr(1048576, 1114109, 1)]), 0); + _Cs = new RangeTable.ptr(new sliceType([new Range16.ptr(55296, 57343, 1)]), sliceType$1.nil, 0); + _L = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(97, 122, 1), new Range16.ptr(170, 181, 11), new Range16.ptr(186, 192, 6), new Range16.ptr(193, 214, 1), new Range16.ptr(216, 246, 1), new Range16.ptr(248, 705, 1), new Range16.ptr(710, 721, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(748, 750, 2), new Range16.ptr(880, 884, 1), new Range16.ptr(886, 887, 1), new Range16.ptr(890, 893, 1), new Range16.ptr(895, 902, 7), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 929, 1), new Range16.ptr(931, 1013, 1), new Range16.ptr(1015, 1153, 1), new Range16.ptr(1162, 1327, 1), new Range16.ptr(1329, 1366, 1), new Range16.ptr(1369, 1377, 8), new Range16.ptr(1378, 1415, 1), new Range16.ptr(1488, 1514, 1), new Range16.ptr(1520, 1522, 1), new Range16.ptr(1568, 1610, 1), new Range16.ptr(1646, 1647, 1), new Range16.ptr(1649, 1747, 1), new Range16.ptr(1749, 1765, 16), new Range16.ptr(1766, 1774, 8), new Range16.ptr(1775, 1786, 11), new Range16.ptr(1787, 1788, 1), new Range16.ptr(1791, 1808, 17), new Range16.ptr(1810, 1839, 1), new Range16.ptr(1869, 1957, 1), new Range16.ptr(1969, 1994, 25), new Range16.ptr(1995, 2026, 1), new Range16.ptr(2036, 2037, 1), new Range16.ptr(2042, 2048, 6), new Range16.ptr(2049, 2069, 1), new Range16.ptr(2074, 2084, 10), new Range16.ptr(2088, 2112, 24), new Range16.ptr(2113, 2136, 1), new Range16.ptr(2144, 2154, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2308, 2361, 1), new Range16.ptr(2365, 2384, 19), new Range16.ptr(2392, 2401, 1), new Range16.ptr(2417, 2432, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2486, 4), new Range16.ptr(2487, 2489, 1), new Range16.ptr(2493, 2510, 17), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2529, 1), new Range16.ptr(2544, 2545, 1), new Range16.ptr(2556, 2565, 9), new Range16.ptr(2566, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2674, 20), new Range16.ptr(2675, 2676, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2749, 2768, 19), new Range16.ptr(2784, 2785, 1), new Range16.ptr(2809, 2821, 12), new Range16.ptr(2822, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2877, 2908, 31), new Range16.ptr(2909, 2911, 2), new Range16.ptr(2912, 2913, 1), new Range16.ptr(2929, 2947, 18), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2974, 2), new Range16.ptr(2975, 2979, 4), new Range16.ptr(2980, 2984, 4), new Range16.ptr(2985, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3024, 3077, 53), new Range16.ptr(3078, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3160, 27), new Range16.ptr(3161, 3162, 1), new Range16.ptr(3168, 3169, 1), new Range16.ptr(3200, 3205, 5), new Range16.ptr(3206, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3261, 3294, 33), new Range16.ptr(3296, 3297, 1), new Range16.ptr(3313, 3314, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3386, 1), new Range16.ptr(3389, 3406, 17), new Range16.ptr(3412, 3414, 1), new Range16.ptr(3423, 3425, 1), new Range16.ptr(3450, 3455, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3520, 3), new Range16.ptr(3521, 3526, 1), new Range16.ptr(3585, 3632, 1), new Range16.ptr(3634, 3635, 1), new Range16.ptr(3648, 3654, 1), new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3719, 3), new Range16.ptr(3720, 3722, 2), new Range16.ptr(3725, 3732, 7), new Range16.ptr(3733, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3751, 2), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3760, 1), new Range16.ptr(3762, 3763, 1), new Range16.ptr(3773, 3776, 3), new Range16.ptr(3777, 3780, 1), new Range16.ptr(3782, 3804, 22), new Range16.ptr(3805, 3807, 1), new Range16.ptr(3840, 3904, 64), new Range16.ptr(3905, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3976, 3980, 1), new Range16.ptr(4096, 4138, 1), new Range16.ptr(4159, 4176, 17), new Range16.ptr(4177, 4181, 1), new Range16.ptr(4186, 4189, 1), new Range16.ptr(4193, 4197, 4), new Range16.ptr(4198, 4206, 8), new Range16.ptr(4207, 4208, 1), new Range16.ptr(4213, 4225, 1), new Range16.ptr(4238, 4256, 18), new Range16.ptr(4257, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(4304, 4346, 1), new Range16.ptr(4348, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4698, 2), new Range16.ptr(4699, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4802, 2), new Range16.ptr(4803, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4992, 5007, 1), new Range16.ptr(5024, 5109, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(5121, 5740, 1), new Range16.ptr(5743, 5759, 1), new Range16.ptr(5761, 5786, 1), new Range16.ptr(5792, 5866, 1), new Range16.ptr(5873, 5880, 1), new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5905, 1), new Range16.ptr(5920, 5937, 1), new Range16.ptr(5952, 5969, 1), new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6016, 6067, 1), new Range16.ptr(6103, 6108, 5), new Range16.ptr(6176, 6263, 1), new Range16.ptr(6272, 6276, 1), new Range16.ptr(6279, 6312, 1), new Range16.ptr(6314, 6320, 6), new Range16.ptr(6321, 6389, 1), new Range16.ptr(6400, 6430, 1), new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1), new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6656, 6678, 1), new Range16.ptr(6688, 6740, 1), new Range16.ptr(6823, 6917, 94), new Range16.ptr(6918, 6963, 1), new Range16.ptr(6981, 6987, 1), new Range16.ptr(7043, 7072, 1), new Range16.ptr(7086, 7087, 1), new Range16.ptr(7098, 7141, 1), new Range16.ptr(7168, 7203, 1), new Range16.ptr(7245, 7247, 1), new Range16.ptr(7258, 7293, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7409, 1), new Range16.ptr(7413, 7414, 1), new Range16.ptr(7424, 7615, 1), new Range16.ptr(7680, 7957, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7968, 8005, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8032, 8061, 1), new Range16.ptr(8064, 8116, 1), new Range16.ptr(8118, 8124, 1), new Range16.ptr(8126, 8130, 4), new Range16.ptr(8131, 8132, 1), new Range16.ptr(8134, 8140, 1), new Range16.ptr(8144, 8147, 1), new Range16.ptr(8150, 8155, 1), new Range16.ptr(8160, 8172, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8188, 1), new Range16.ptr(8305, 8319, 14), new Range16.ptr(8336, 8348, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8458, 8467, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8495, 8505, 1), new Range16.ptr(8508, 8511, 1), new Range16.ptr(8517, 8521, 1), new Range16.ptr(8526, 8579, 53), new Range16.ptr(8580, 11264, 2684), new Range16.ptr(11265, 11310, 1), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11360, 11492, 1), new Range16.ptr(11499, 11502, 1), new Range16.ptr(11506, 11507, 1), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(11568, 11623, 1), new Range16.ptr(11631, 11648, 17), new Range16.ptr(11649, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(11823, 12293, 470), new Range16.ptr(12294, 12337, 43), new Range16.ptr(12338, 12341, 1), new Range16.ptr(12347, 12348, 1), new Range16.ptr(12353, 12438, 1), new Range16.ptr(12445, 12447, 1), new Range16.ptr(12449, 12538, 1), new Range16.ptr(12540, 12543, 1), new Range16.ptr(12549, 12590, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12704, 12730, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(40960, 42124, 1), new Range16.ptr(42192, 42237, 1), new Range16.ptr(42240, 42508, 1), new Range16.ptr(42512, 42527, 1), new Range16.ptr(42538, 42539, 1), new Range16.ptr(42560, 42606, 1), new Range16.ptr(42623, 42653, 1), new Range16.ptr(42656, 42725, 1), new Range16.ptr(42775, 42783, 1), new Range16.ptr(42786, 42888, 1), new Range16.ptr(42891, 42926, 1), new Range16.ptr(42928, 42935, 1), new Range16.ptr(42999, 43009, 1), new Range16.ptr(43011, 43013, 1), new Range16.ptr(43015, 43018, 1), new Range16.ptr(43020, 43042, 1), new Range16.ptr(43072, 43123, 1), new Range16.ptr(43138, 43187, 1), new Range16.ptr(43250, 43255, 1), new Range16.ptr(43259, 43261, 2), new Range16.ptr(43274, 43301, 1), new Range16.ptr(43312, 43334, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(43396, 43442, 1), new Range16.ptr(43471, 43488, 17), new Range16.ptr(43489, 43492, 1), new Range16.ptr(43494, 43503, 1), new Range16.ptr(43514, 43518, 1), new Range16.ptr(43520, 43560, 1), new Range16.ptr(43584, 43586, 1), new Range16.ptr(43588, 43595, 1), new Range16.ptr(43616, 43638, 1), new Range16.ptr(43642, 43646, 4), new Range16.ptr(43647, 43695, 1), new Range16.ptr(43697, 43701, 4), new Range16.ptr(43702, 43705, 3), new Range16.ptr(43706, 43709, 1), new Range16.ptr(43712, 43714, 2), new Range16.ptr(43739, 43741, 1), new Range16.ptr(43744, 43754, 1), new Range16.ptr(43762, 43764, 1), new Range16.ptr(43777, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1), new Range16.ptr(43824, 43866, 1), new Range16.ptr(43868, 43877, 1), new Range16.ptr(43888, 44002, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(64275, 64279, 1), new Range16.ptr(64285, 64287, 2), new Range16.ptr(64288, 64296, 1), new Range16.ptr(64298, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64320, 2), new Range16.ptr(64321, 64323, 2), new Range16.ptr(64324, 64326, 2), new Range16.ptr(64327, 64433, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65019, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1), new Range16.ptr(65313, 65338, 1), new Range16.ptr(65345, 65370, 1), new Range16.ptr(65382, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1), new Range32.ptr(66176, 66204, 1), new Range32.ptr(66208, 66256, 1), new Range32.ptr(66304, 66335, 1), new Range32.ptr(66349, 66368, 1), new Range32.ptr(66370, 66377, 1), new Range32.ptr(66384, 66421, 1), new Range32.ptr(66432, 66461, 1), new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66511, 1), new Range32.ptr(66560, 66717, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(66816, 66855, 1), new Range32.ptr(66864, 66915, 1), new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1), new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67594, 2), new Range32.ptr(67595, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67647, 3), new Range32.ptr(67648, 67669, 1), new Range32.ptr(67680, 67702, 1), new Range32.ptr(67712, 67742, 1), new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67840, 67861, 1), new Range32.ptr(67872, 67897, 1), new Range32.ptr(67968, 68023, 1), new Range32.ptr(68030, 68031, 1), new Range32.ptr(68096, 68112, 16), new Range32.ptr(68113, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68192, 68220, 1), new Range32.ptr(68224, 68252, 1), new Range32.ptr(68288, 68295, 1), new Range32.ptr(68297, 68324, 1), new Range32.ptr(68352, 68405, 1), new Range32.ptr(68416, 68437, 1), new Range32.ptr(68448, 68466, 1), new Range32.ptr(68480, 68497, 1), new Range32.ptr(68608, 68680, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(69635, 69687, 1), new Range32.ptr(69763, 69807, 1), new Range32.ptr(69840, 69864, 1), new Range32.ptr(69891, 69926, 1), new Range32.ptr(69968, 70002, 1), new Range32.ptr(70006, 70019, 13), new Range32.ptr(70020, 70066, 1), new Range32.ptr(70081, 70084, 1), new Range32.ptr(70106, 70108, 2), new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70187, 1), new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70282, 2), new Range32.ptr(70283, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70312, 1), new Range32.ptr(70320, 70366, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70461, 70480, 19), new Range32.ptr(70493, 70497, 1), new Range32.ptr(70656, 70708, 1), new Range32.ptr(70727, 70730, 1), new Range32.ptr(70784, 70831, 1), new Range32.ptr(70852, 70853, 1), new Range32.ptr(70855, 71040, 185), new Range32.ptr(71041, 71086, 1), new Range32.ptr(71128, 71131, 1), new Range32.ptr(71168, 71215, 1), new Range32.ptr(71236, 71296, 60), new Range32.ptr(71297, 71338, 1), new Range32.ptr(71424, 71449, 1), new Range32.ptr(71840, 71903, 1), new Range32.ptr(71935, 72192, 257), new Range32.ptr(72203, 72242, 1), new Range32.ptr(72250, 72272, 22), new Range32.ptr(72284, 72323, 1), new Range32.ptr(72326, 72329, 1), new Range32.ptr(72384, 72440, 1), new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72750, 1), new Range32.ptr(72768, 72818, 50), new Range32.ptr(72819, 72847, 1), new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73008, 1), new Range32.ptr(73030, 73728, 698), new Range32.ptr(73729, 74649, 1), new Range32.ptr(74880, 75075, 1), new Range32.ptr(77824, 78894, 1), new Range32.ptr(82944, 83526, 1), new Range32.ptr(92160, 92728, 1), new Range32.ptr(92736, 92766, 1), new Range32.ptr(92880, 92909, 1), new Range32.ptr(92928, 92975, 1), new Range32.ptr(92992, 92995, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1), new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94099, 67), new Range32.ptr(94100, 94111, 1), new Range32.ptr(94176, 94177, 1), new Range32.ptr(94208, 100332, 1), new Range32.ptr(100352, 101106, 1), new Range32.ptr(110592, 110878, 1), new Range32.ptr(110960, 111355, 1), new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(119808, 119892, 1), new Range32.ptr(119894, 119964, 1), new Range32.ptr(119966, 119967, 1), new Range32.ptr(119970, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119993, 1), new Range32.ptr(119995, 119997, 2), new Range32.ptr(119998, 120003, 1), new Range32.ptr(120005, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120094, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120146, 120485, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120514, 120538, 1), new Range32.ptr(120540, 120570, 1), new Range32.ptr(120572, 120596, 1), new Range32.ptr(120598, 120628, 1), new Range32.ptr(120630, 120654, 1), new Range32.ptr(120656, 120686, 1), new Range32.ptr(120688, 120712, 1), new Range32.ptr(120714, 120744, 1), new Range32.ptr(120746, 120770, 1), new Range32.ptr(120772, 120779, 1), new Range32.ptr(124928, 125124, 1), new Range32.ptr(125184, 125251, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126503, 3), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126523, 2), new Range32.ptr(126530, 126535, 5), new Range32.ptr(126537, 126541, 2), new Range32.ptr(126542, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126551, 3), new Range32.ptr(126553, 126561, 2), new Range32.ptr(126562, 126564, 2), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126592, 2), new Range32.ptr(126593, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 6); + _Ll = new RangeTable.ptr(new sliceType([new Range16.ptr(97, 122, 1), new Range16.ptr(181, 223, 42), new Range16.ptr(224, 246, 1), new Range16.ptr(248, 255, 1), new Range16.ptr(257, 311, 2), new Range16.ptr(312, 328, 2), new Range16.ptr(329, 375, 2), new Range16.ptr(378, 382, 2), new Range16.ptr(383, 384, 1), new Range16.ptr(387, 389, 2), new Range16.ptr(392, 396, 4), new Range16.ptr(397, 402, 5), new Range16.ptr(405, 409, 4), new Range16.ptr(410, 411, 1), new Range16.ptr(414, 417, 3), new Range16.ptr(419, 421, 2), new Range16.ptr(424, 426, 2), new Range16.ptr(427, 429, 2), new Range16.ptr(432, 436, 4), new Range16.ptr(438, 441, 3), new Range16.ptr(442, 445, 3), new Range16.ptr(446, 447, 1), new Range16.ptr(454, 460, 3), new Range16.ptr(462, 476, 2), new Range16.ptr(477, 495, 2), new Range16.ptr(496, 499, 3), new Range16.ptr(501, 505, 4), new Range16.ptr(507, 563, 2), new Range16.ptr(564, 569, 1), new Range16.ptr(572, 575, 3), new Range16.ptr(576, 578, 2), new Range16.ptr(583, 591, 2), new Range16.ptr(592, 659, 1), new Range16.ptr(661, 687, 1), new Range16.ptr(881, 883, 2), new Range16.ptr(887, 891, 4), new Range16.ptr(892, 893, 1), new Range16.ptr(912, 940, 28), new Range16.ptr(941, 974, 1), new Range16.ptr(976, 977, 1), new Range16.ptr(981, 983, 1), new Range16.ptr(985, 1007, 2), new Range16.ptr(1008, 1011, 1), new Range16.ptr(1013, 1019, 3), new Range16.ptr(1020, 1072, 52), new Range16.ptr(1073, 1119, 1), new Range16.ptr(1121, 1153, 2), new Range16.ptr(1163, 1215, 2), new Range16.ptr(1218, 1230, 2), new Range16.ptr(1231, 1327, 2), new Range16.ptr(1377, 1415, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7424, 7467, 1), new Range16.ptr(7531, 7543, 1), new Range16.ptr(7545, 7578, 1), new Range16.ptr(7681, 7829, 2), new Range16.ptr(7830, 7837, 1), new Range16.ptr(7839, 7935, 2), new Range16.ptr(7936, 7943, 1), new Range16.ptr(7952, 7957, 1), new Range16.ptr(7968, 7975, 1), new Range16.ptr(7984, 7991, 1), new Range16.ptr(8000, 8005, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8032, 8039, 1), new Range16.ptr(8048, 8061, 1), new Range16.ptr(8064, 8071, 1), new Range16.ptr(8080, 8087, 1), new Range16.ptr(8096, 8103, 1), new Range16.ptr(8112, 8116, 1), new Range16.ptr(8118, 8119, 1), new Range16.ptr(8126, 8130, 4), new Range16.ptr(8131, 8132, 1), new Range16.ptr(8134, 8135, 1), new Range16.ptr(8144, 8147, 1), new Range16.ptr(8150, 8151, 1), new Range16.ptr(8160, 8167, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8183, 1), new Range16.ptr(8458, 8462, 4), new Range16.ptr(8463, 8467, 4), new Range16.ptr(8495, 8505, 5), new Range16.ptr(8508, 8509, 1), new Range16.ptr(8518, 8521, 1), new Range16.ptr(8526, 8580, 54), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11361, 11365, 4), new Range16.ptr(11366, 11372, 2), new Range16.ptr(11377, 11379, 2), new Range16.ptr(11380, 11382, 2), new Range16.ptr(11383, 11387, 1), new Range16.ptr(11393, 11491, 2), new Range16.ptr(11492, 11500, 8), new Range16.ptr(11502, 11507, 5), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(42561, 42605, 2), new Range16.ptr(42625, 42651, 2), new Range16.ptr(42787, 42799, 2), new Range16.ptr(42800, 42801, 1), new Range16.ptr(42803, 42865, 2), new Range16.ptr(42866, 42872, 1), new Range16.ptr(42874, 42876, 2), new Range16.ptr(42879, 42887, 2), new Range16.ptr(42892, 42894, 2), new Range16.ptr(42897, 42899, 2), new Range16.ptr(42900, 42901, 1), new Range16.ptr(42903, 42921, 2), new Range16.ptr(42933, 42935, 2), new Range16.ptr(43002, 43824, 822), new Range16.ptr(43825, 43866, 1), new Range16.ptr(43872, 43877, 1), new Range16.ptr(43888, 43967, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(64275, 64279, 1), new Range16.ptr(65345, 65370, 1)]), new sliceType$1([new Range32.ptr(66600, 66639, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(71872, 71903, 1), new Range32.ptr(119834, 119859, 1), new Range32.ptr(119886, 119892, 1), new Range32.ptr(119894, 119911, 1), new Range32.ptr(119938, 119963, 1), new Range32.ptr(119990, 119993, 1), new Range32.ptr(119995, 119997, 2), new Range32.ptr(119998, 120003, 1), new Range32.ptr(120005, 120015, 1), new Range32.ptr(120042, 120067, 1), new Range32.ptr(120094, 120119, 1), new Range32.ptr(120146, 120171, 1), new Range32.ptr(120198, 120223, 1), new Range32.ptr(120250, 120275, 1), new Range32.ptr(120302, 120327, 1), new Range32.ptr(120354, 120379, 1), new Range32.ptr(120406, 120431, 1), new Range32.ptr(120458, 120485, 1), new Range32.ptr(120514, 120538, 1), new Range32.ptr(120540, 120545, 1), new Range32.ptr(120572, 120596, 1), new Range32.ptr(120598, 120603, 1), new Range32.ptr(120630, 120654, 1), new Range32.ptr(120656, 120661, 1), new Range32.ptr(120688, 120712, 1), new Range32.ptr(120714, 120719, 1), new Range32.ptr(120746, 120770, 1), new Range32.ptr(120772, 120777, 1), new Range32.ptr(120779, 125218, 4439), new Range32.ptr(125219, 125251, 1)]), 4); + _Lm = new RangeTable.ptr(new sliceType([new Range16.ptr(688, 705, 1), new Range16.ptr(710, 721, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(748, 750, 2), new Range16.ptr(884, 890, 6), new Range16.ptr(1369, 1600, 231), new Range16.ptr(1765, 1766, 1), new Range16.ptr(2036, 2037, 1), new Range16.ptr(2042, 2074, 32), new Range16.ptr(2084, 2088, 4), new Range16.ptr(2417, 3654, 1237), new Range16.ptr(3782, 4348, 566), new Range16.ptr(6103, 6211, 108), new Range16.ptr(6823, 7288, 465), new Range16.ptr(7289, 7293, 1), new Range16.ptr(7468, 7530, 1), new Range16.ptr(7544, 7579, 35), new Range16.ptr(7580, 7615, 1), new Range16.ptr(8305, 8319, 14), new Range16.ptr(8336, 8348, 1), new Range16.ptr(11388, 11389, 1), new Range16.ptr(11631, 11823, 192), new Range16.ptr(12293, 12337, 44), new Range16.ptr(12338, 12341, 1), new Range16.ptr(12347, 12445, 98), new Range16.ptr(12446, 12540, 94), new Range16.ptr(12541, 12542, 1), new Range16.ptr(40981, 42232, 1251), new Range16.ptr(42233, 42237, 1), new Range16.ptr(42508, 42623, 115), new Range16.ptr(42652, 42653, 1), new Range16.ptr(42775, 42783, 1), new Range16.ptr(42864, 42888, 24), new Range16.ptr(43000, 43001, 1), new Range16.ptr(43471, 43494, 23), new Range16.ptr(43632, 43741, 109), new Range16.ptr(43763, 43764, 1), new Range16.ptr(43868, 43871, 1), new Range16.ptr(65392, 65438, 46), new Range16.ptr(65439, 65439, 1)]), new sliceType$1([new Range32.ptr(92992, 92992, 1), new Range32.ptr(92993, 92995, 1), new Range32.ptr(94099, 94111, 1), new Range32.ptr(94176, 94177, 1)]), 0); + _Lo = new RangeTable.ptr(new sliceType([new Range16.ptr(170, 186, 16), new Range16.ptr(443, 448, 5), new Range16.ptr(449, 451, 1), new Range16.ptr(660, 1488, 828), new Range16.ptr(1489, 1514, 1), new Range16.ptr(1520, 1522, 1), new Range16.ptr(1568, 1599, 1), new Range16.ptr(1601, 1610, 1), new Range16.ptr(1646, 1647, 1), new Range16.ptr(1649, 1747, 1), new Range16.ptr(1749, 1774, 25), new Range16.ptr(1775, 1786, 11), new Range16.ptr(1787, 1788, 1), new Range16.ptr(1791, 1808, 17), new Range16.ptr(1810, 1839, 1), new Range16.ptr(1869, 1957, 1), new Range16.ptr(1969, 1994, 25), new Range16.ptr(1995, 2026, 1), new Range16.ptr(2048, 2069, 1), new Range16.ptr(2112, 2136, 1), new Range16.ptr(2144, 2154, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2308, 2361, 1), new Range16.ptr(2365, 2384, 19), new Range16.ptr(2392, 2401, 1), new Range16.ptr(2418, 2432, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2486, 4), new Range16.ptr(2487, 2489, 1), new Range16.ptr(2493, 2510, 17), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2529, 1), new Range16.ptr(2544, 2545, 1), new Range16.ptr(2556, 2565, 9), new Range16.ptr(2566, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2674, 20), new Range16.ptr(2675, 2676, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2749, 2768, 19), new Range16.ptr(2784, 2785, 1), new Range16.ptr(2809, 2821, 12), new Range16.ptr(2822, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2877, 2908, 31), new Range16.ptr(2909, 2911, 2), new Range16.ptr(2912, 2913, 1), new Range16.ptr(2929, 2947, 18), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2974, 2), new Range16.ptr(2975, 2979, 4), new Range16.ptr(2980, 2984, 4), new Range16.ptr(2985, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3024, 3077, 53), new Range16.ptr(3078, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3160, 27), new Range16.ptr(3161, 3162, 1), new Range16.ptr(3168, 3169, 1), new Range16.ptr(3200, 3205, 5), new Range16.ptr(3206, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3261, 3294, 33), new Range16.ptr(3296, 3297, 1), new Range16.ptr(3313, 3314, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3386, 1), new Range16.ptr(3389, 3406, 17), new Range16.ptr(3412, 3414, 1), new Range16.ptr(3423, 3425, 1), new Range16.ptr(3450, 3455, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3520, 3), new Range16.ptr(3521, 3526, 1), new Range16.ptr(3585, 3632, 1), new Range16.ptr(3634, 3635, 1), new Range16.ptr(3648, 3653, 1), new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3719, 3), new Range16.ptr(3720, 3722, 2), new Range16.ptr(3725, 3732, 7), new Range16.ptr(3733, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3751, 2), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3760, 1), new Range16.ptr(3762, 3763, 1), new Range16.ptr(3773, 3776, 3), new Range16.ptr(3777, 3780, 1), new Range16.ptr(3804, 3807, 1), new Range16.ptr(3840, 3904, 64), new Range16.ptr(3905, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3976, 3980, 1), new Range16.ptr(4096, 4138, 1), new Range16.ptr(4159, 4176, 17), new Range16.ptr(4177, 4181, 1), new Range16.ptr(4186, 4189, 1), new Range16.ptr(4193, 4197, 4), new Range16.ptr(4198, 4206, 8), new Range16.ptr(4207, 4208, 1), new Range16.ptr(4213, 4225, 1), new Range16.ptr(4238, 4304, 66), new Range16.ptr(4305, 4346, 1), new Range16.ptr(4349, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4698, 2), new Range16.ptr(4699, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4802, 2), new Range16.ptr(4803, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4992, 5007, 1), new Range16.ptr(5121, 5740, 1), new Range16.ptr(5743, 5759, 1), new Range16.ptr(5761, 5786, 1), new Range16.ptr(5792, 5866, 1), new Range16.ptr(5873, 5880, 1), new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5905, 1), new Range16.ptr(5920, 5937, 1), new Range16.ptr(5952, 5969, 1), new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6016, 6067, 1), new Range16.ptr(6108, 6176, 68), new Range16.ptr(6177, 6210, 1), new Range16.ptr(6212, 6263, 1), new Range16.ptr(6272, 6276, 1), new Range16.ptr(6279, 6312, 1), new Range16.ptr(6314, 6320, 6), new Range16.ptr(6321, 6389, 1), new Range16.ptr(6400, 6430, 1), new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1), new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6656, 6678, 1), new Range16.ptr(6688, 6740, 1), new Range16.ptr(6917, 6963, 1), new Range16.ptr(6981, 6987, 1), new Range16.ptr(7043, 7072, 1), new Range16.ptr(7086, 7087, 1), new Range16.ptr(7098, 7141, 1), new Range16.ptr(7168, 7203, 1), new Range16.ptr(7245, 7247, 1), new Range16.ptr(7258, 7287, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7409, 1), new Range16.ptr(7413, 7414, 1), new Range16.ptr(8501, 8504, 1), new Range16.ptr(11568, 11623, 1), new Range16.ptr(11648, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(12294, 12348, 54), new Range16.ptr(12353, 12438, 1), new Range16.ptr(12447, 12449, 2), new Range16.ptr(12450, 12538, 1), new Range16.ptr(12543, 12549, 6), new Range16.ptr(12550, 12590, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12704, 12730, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(40960, 40980, 1), new Range16.ptr(40982, 42124, 1), new Range16.ptr(42192, 42231, 1), new Range16.ptr(42240, 42507, 1), new Range16.ptr(42512, 42527, 1), new Range16.ptr(42538, 42539, 1), new Range16.ptr(42606, 42656, 50), new Range16.ptr(42657, 42725, 1), new Range16.ptr(42895, 42999, 104), new Range16.ptr(43003, 43009, 1), new Range16.ptr(43011, 43013, 1), new Range16.ptr(43015, 43018, 1), new Range16.ptr(43020, 43042, 1), new Range16.ptr(43072, 43123, 1), new Range16.ptr(43138, 43187, 1), new Range16.ptr(43250, 43255, 1), new Range16.ptr(43259, 43261, 2), new Range16.ptr(43274, 43301, 1), new Range16.ptr(43312, 43334, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(43396, 43442, 1), new Range16.ptr(43488, 43492, 1), new Range16.ptr(43495, 43503, 1), new Range16.ptr(43514, 43518, 1), new Range16.ptr(43520, 43560, 1), new Range16.ptr(43584, 43586, 1), new Range16.ptr(43588, 43595, 1), new Range16.ptr(43616, 43631, 1), new Range16.ptr(43633, 43638, 1), new Range16.ptr(43642, 43646, 4), new Range16.ptr(43647, 43695, 1), new Range16.ptr(43697, 43701, 4), new Range16.ptr(43702, 43705, 3), new Range16.ptr(43706, 43709, 1), new Range16.ptr(43712, 43714, 2), new Range16.ptr(43739, 43740, 1), new Range16.ptr(43744, 43754, 1), new Range16.ptr(43762, 43777, 15), new Range16.ptr(43778, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1), new Range16.ptr(43968, 44002, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1), new Range16.ptr(64285, 64287, 2), new Range16.ptr(64288, 64296, 1), new Range16.ptr(64298, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64320, 2), new Range16.ptr(64321, 64323, 2), new Range16.ptr(64324, 64326, 2), new Range16.ptr(64327, 64433, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65019, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1), new Range16.ptr(65382, 65391, 1), new Range16.ptr(65393, 65437, 1), new Range16.ptr(65440, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1), new Range32.ptr(66176, 66204, 1), new Range32.ptr(66208, 66256, 1), new Range32.ptr(66304, 66335, 1), new Range32.ptr(66349, 66368, 1), new Range32.ptr(66370, 66377, 1), new Range32.ptr(66384, 66421, 1), new Range32.ptr(66432, 66461, 1), new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66511, 1), new Range32.ptr(66640, 66717, 1), new Range32.ptr(66816, 66855, 1), new Range32.ptr(66864, 66915, 1), new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1), new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67594, 2), new Range32.ptr(67595, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67647, 3), new Range32.ptr(67648, 67669, 1), new Range32.ptr(67680, 67702, 1), new Range32.ptr(67712, 67742, 1), new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67840, 67861, 1), new Range32.ptr(67872, 67897, 1), new Range32.ptr(67968, 68023, 1), new Range32.ptr(68030, 68031, 1), new Range32.ptr(68096, 68112, 16), new Range32.ptr(68113, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68192, 68220, 1), new Range32.ptr(68224, 68252, 1), new Range32.ptr(68288, 68295, 1), new Range32.ptr(68297, 68324, 1), new Range32.ptr(68352, 68405, 1), new Range32.ptr(68416, 68437, 1), new Range32.ptr(68448, 68466, 1), new Range32.ptr(68480, 68497, 1), new Range32.ptr(68608, 68680, 1), new Range32.ptr(69635, 69687, 1), new Range32.ptr(69763, 69807, 1), new Range32.ptr(69840, 69864, 1), new Range32.ptr(69891, 69926, 1), new Range32.ptr(69968, 70002, 1), new Range32.ptr(70006, 70019, 13), new Range32.ptr(70020, 70066, 1), new Range32.ptr(70081, 70084, 1), new Range32.ptr(70106, 70108, 2), new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70187, 1), new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70282, 2), new Range32.ptr(70283, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70312, 1), new Range32.ptr(70320, 70366, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70461, 70480, 19), new Range32.ptr(70493, 70497, 1), new Range32.ptr(70656, 70708, 1), new Range32.ptr(70727, 70730, 1), new Range32.ptr(70784, 70831, 1), new Range32.ptr(70852, 70853, 1), new Range32.ptr(70855, 71040, 185), new Range32.ptr(71041, 71086, 1), new Range32.ptr(71128, 71131, 1), new Range32.ptr(71168, 71215, 1), new Range32.ptr(71236, 71296, 60), new Range32.ptr(71297, 71338, 1), new Range32.ptr(71424, 71449, 1), new Range32.ptr(71935, 72192, 257), new Range32.ptr(72203, 72242, 1), new Range32.ptr(72250, 72272, 22), new Range32.ptr(72284, 72323, 1), new Range32.ptr(72326, 72329, 1), new Range32.ptr(72384, 72440, 1), new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72750, 1), new Range32.ptr(72768, 72818, 50), new Range32.ptr(72819, 72847, 1), new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73008, 1), new Range32.ptr(73030, 73728, 698), new Range32.ptr(73729, 74649, 1), new Range32.ptr(74880, 75075, 1), new Range32.ptr(77824, 78894, 1), new Range32.ptr(82944, 83526, 1), new Range32.ptr(92160, 92728, 1), new Range32.ptr(92736, 92766, 1), new Range32.ptr(92880, 92909, 1), new Range32.ptr(92928, 92975, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1), new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94208, 176), new Range32.ptr(94209, 100332, 1), new Range32.ptr(100352, 101106, 1), new Range32.ptr(110592, 110878, 1), new Range32.ptr(110960, 111355, 1), new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(124928, 125124, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126503, 3), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126523, 2), new Range32.ptr(126530, 126535, 5), new Range32.ptr(126537, 126541, 2), new Range32.ptr(126542, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126551, 3), new Range32.ptr(126553, 126561, 2), new Range32.ptr(126562, 126564, 2), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126592, 2), new Range32.ptr(126593, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 1); + _Lt = new RangeTable.ptr(new sliceType([new Range16.ptr(453, 459, 3), new Range16.ptr(498, 8072, 7574), new Range16.ptr(8073, 8079, 1), new Range16.ptr(8088, 8095, 1), new Range16.ptr(8104, 8111, 1), new Range16.ptr(8124, 8140, 16), new Range16.ptr(8188, 8188, 1)]), sliceType$1.nil, 0); + _Lu = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 222, 1), new Range16.ptr(256, 310, 2), new Range16.ptr(313, 327, 2), new Range16.ptr(330, 376, 2), new Range16.ptr(377, 381, 2), new Range16.ptr(385, 386, 1), new Range16.ptr(388, 390, 2), new Range16.ptr(391, 393, 2), new Range16.ptr(394, 395, 1), new Range16.ptr(398, 401, 1), new Range16.ptr(403, 404, 1), new Range16.ptr(406, 408, 1), new Range16.ptr(412, 413, 1), new Range16.ptr(415, 416, 1), new Range16.ptr(418, 422, 2), new Range16.ptr(423, 425, 2), new Range16.ptr(428, 430, 2), new Range16.ptr(431, 433, 2), new Range16.ptr(434, 435, 1), new Range16.ptr(437, 439, 2), new Range16.ptr(440, 444, 4), new Range16.ptr(452, 461, 3), new Range16.ptr(463, 475, 2), new Range16.ptr(478, 494, 2), new Range16.ptr(497, 500, 3), new Range16.ptr(502, 504, 1), new Range16.ptr(506, 562, 2), new Range16.ptr(570, 571, 1), new Range16.ptr(573, 574, 1), new Range16.ptr(577, 579, 2), new Range16.ptr(580, 582, 1), new Range16.ptr(584, 590, 2), new Range16.ptr(880, 882, 2), new Range16.ptr(886, 895, 9), new Range16.ptr(902, 904, 2), new Range16.ptr(905, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 913, 2), new Range16.ptr(914, 929, 1), new Range16.ptr(931, 939, 1), new Range16.ptr(975, 978, 3), new Range16.ptr(979, 980, 1), new Range16.ptr(984, 1006, 2), new Range16.ptr(1012, 1015, 3), new Range16.ptr(1017, 1018, 1), new Range16.ptr(1021, 1071, 1), new Range16.ptr(1120, 1152, 2), new Range16.ptr(1162, 1216, 2), new Range16.ptr(1217, 1229, 2), new Range16.ptr(1232, 1326, 2), new Range16.ptr(1329, 1366, 1), new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(5024, 5109, 1), new Range16.ptr(7680, 7828, 2), new Range16.ptr(7838, 7934, 2), new Range16.ptr(7944, 7951, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7976, 7983, 1), new Range16.ptr(7992, 7999, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8040, 8047, 1), new Range16.ptr(8120, 8123, 1), new Range16.ptr(8136, 8139, 1), new Range16.ptr(8152, 8155, 1), new Range16.ptr(8168, 8172, 1), new Range16.ptr(8184, 8187, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8459, 8461, 1), new Range16.ptr(8464, 8466, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8496, 8499, 1), new Range16.ptr(8510, 8511, 1), new Range16.ptr(8517, 8579, 62), new Range16.ptr(11264, 11310, 1), new Range16.ptr(11360, 11362, 2), new Range16.ptr(11363, 11364, 1), new Range16.ptr(11367, 11373, 2), new Range16.ptr(11374, 11376, 1), new Range16.ptr(11378, 11381, 3), new Range16.ptr(11390, 11392, 1), new Range16.ptr(11394, 11490, 2), new Range16.ptr(11499, 11501, 2), new Range16.ptr(11506, 42560, 31054), new Range16.ptr(42562, 42604, 2), new Range16.ptr(42624, 42650, 2), new Range16.ptr(42786, 42798, 2), new Range16.ptr(42802, 42862, 2), new Range16.ptr(42873, 42877, 2), new Range16.ptr(42878, 42886, 2), new Range16.ptr(42891, 42893, 2), new Range16.ptr(42896, 42898, 2), new Range16.ptr(42902, 42922, 2), new Range16.ptr(42923, 42926, 1), new Range16.ptr(42928, 42932, 1), new Range16.ptr(42934, 65313, 22379), new Range16.ptr(65314, 65338, 1)]), new sliceType$1([new Range32.ptr(66560, 66599, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(71840, 71871, 1), new Range32.ptr(119808, 119833, 1), new Range32.ptr(119860, 119885, 1), new Range32.ptr(119912, 119937, 1), new Range32.ptr(119964, 119966, 2), new Range32.ptr(119967, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119989, 1), new Range32.ptr(120016, 120041, 1), new Range32.ptr(120068, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120120, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120172, 120197, 1), new Range32.ptr(120224, 120249, 1), new Range32.ptr(120276, 120301, 1), new Range32.ptr(120328, 120353, 1), new Range32.ptr(120380, 120405, 1), new Range32.ptr(120432, 120457, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120546, 120570, 1), new Range32.ptr(120604, 120628, 1), new Range32.ptr(120662, 120686, 1), new Range32.ptr(120720, 120744, 1), new Range32.ptr(120778, 125184, 4406), new Range32.ptr(125185, 125217, 1)]), 3); + _M = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1155, 1161, 1), new Range16.ptr(1425, 1469, 1), new Range16.ptr(1471, 1473, 2), new Range16.ptr(1474, 1476, 2), new Range16.ptr(1477, 1479, 2), new Range16.ptr(1552, 1562, 1), new Range16.ptr(1611, 1631, 1), new Range16.ptr(1648, 1750, 102), new Range16.ptr(1751, 1756, 1), new Range16.ptr(1759, 1764, 1), new Range16.ptr(1767, 1768, 1), new Range16.ptr(1770, 1773, 1), new Range16.ptr(1809, 1840, 31), new Range16.ptr(1841, 1866, 1), new Range16.ptr(1958, 1968, 1), new Range16.ptr(2027, 2035, 1), new Range16.ptr(2070, 2073, 1), new Range16.ptr(2075, 2083, 1), new Range16.ptr(2085, 2087, 1), new Range16.ptr(2089, 2093, 1), new Range16.ptr(2137, 2139, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2307, 1), new Range16.ptr(2362, 2364, 1), new Range16.ptr(2366, 2383, 1), new Range16.ptr(2385, 2391, 1), new Range16.ptr(2402, 2403, 1), new Range16.ptr(2433, 2435, 1), new Range16.ptr(2492, 2494, 2), new Range16.ptr(2495, 2500, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2509, 1), new Range16.ptr(2519, 2530, 11), new Range16.ptr(2531, 2561, 30), new Range16.ptr(2562, 2563, 1), new Range16.ptr(2620, 2622, 2), new Range16.ptr(2623, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2672, 31), new Range16.ptr(2673, 2677, 4), new Range16.ptr(2689, 2691, 1), new Range16.ptr(2748, 2750, 2), new Range16.ptr(2751, 2757, 1), new Range16.ptr(2759, 2761, 1), new Range16.ptr(2763, 2765, 1), new Range16.ptr(2786, 2787, 1), new Range16.ptr(2810, 2815, 1), new Range16.ptr(2817, 2819, 1), new Range16.ptr(2876, 2878, 2), new Range16.ptr(2879, 2884, 1), new Range16.ptr(2887, 2888, 1), new Range16.ptr(2891, 2893, 1), new Range16.ptr(2902, 2903, 1), new Range16.ptr(2914, 2915, 1), new Range16.ptr(2946, 3006, 60), new Range16.ptr(3007, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3021, 1), new Range16.ptr(3031, 3072, 41), new Range16.ptr(3073, 3075, 1), new Range16.ptr(3134, 3140, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3170, 3171, 1), new Range16.ptr(3201, 3203, 1), new Range16.ptr(3260, 3262, 2), new Range16.ptr(3263, 3268, 1), new Range16.ptr(3270, 3272, 1), new Range16.ptr(3274, 3277, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3298, 3299, 1), new Range16.ptr(3328, 3331, 1), new Range16.ptr(3387, 3388, 1), new Range16.ptr(3390, 3396, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3405, 1), new Range16.ptr(3415, 3426, 11), new Range16.ptr(3427, 3458, 31), new Range16.ptr(3459, 3530, 71), new Range16.ptr(3535, 3540, 1), new Range16.ptr(3542, 3544, 2), new Range16.ptr(3545, 3551, 1), new Range16.ptr(3570, 3571, 1), new Range16.ptr(3633, 3636, 3), new Range16.ptr(3637, 3642, 1), new Range16.ptr(3655, 3662, 1), new Range16.ptr(3761, 3764, 3), new Range16.ptr(3765, 3769, 1), new Range16.ptr(3771, 3772, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3864, 3865, 1), new Range16.ptr(3893, 3897, 2), new Range16.ptr(3902, 3903, 1), new Range16.ptr(3953, 3972, 1), new Range16.ptr(3974, 3975, 1), new Range16.ptr(3981, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4038, 4139, 101), new Range16.ptr(4140, 4158, 1), new Range16.ptr(4182, 4185, 1), new Range16.ptr(4190, 4192, 1), new Range16.ptr(4194, 4196, 1), new Range16.ptr(4199, 4205, 1), new Range16.ptr(4209, 4212, 1), new Range16.ptr(4226, 4237, 1), new Range16.ptr(4239, 4250, 11), new Range16.ptr(4251, 4253, 1), new Range16.ptr(4957, 4959, 1), new Range16.ptr(5906, 5908, 1), new Range16.ptr(5938, 5940, 1), new Range16.ptr(5970, 5971, 1), new Range16.ptr(6002, 6003, 1), new Range16.ptr(6068, 6099, 1), new Range16.ptr(6109, 6155, 46), new Range16.ptr(6156, 6157, 1), new Range16.ptr(6277, 6278, 1), new Range16.ptr(6313, 6432, 119), new Range16.ptr(6433, 6443, 1), new Range16.ptr(6448, 6459, 1), new Range16.ptr(6679, 6683, 1), new Range16.ptr(6741, 6750, 1), new Range16.ptr(6752, 6780, 1), new Range16.ptr(6783, 6832, 49), new Range16.ptr(6833, 6846, 1), new Range16.ptr(6912, 6916, 1), new Range16.ptr(6964, 6980, 1), new Range16.ptr(7019, 7027, 1), new Range16.ptr(7040, 7042, 1), new Range16.ptr(7073, 7085, 1), new Range16.ptr(7142, 7155, 1), new Range16.ptr(7204, 7223, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7400, 1), new Range16.ptr(7405, 7410, 5), new Range16.ptr(7411, 7412, 1), new Range16.ptr(7415, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8400, 8432, 1), new Range16.ptr(11503, 11505, 1), new Range16.ptr(11647, 11744, 97), new Range16.ptr(11745, 11775, 1), new Range16.ptr(12330, 12335, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(42607, 42610, 1), new Range16.ptr(42612, 42621, 1), new Range16.ptr(42654, 42655, 1), new Range16.ptr(42736, 42737, 1), new Range16.ptr(43010, 43014, 4), new Range16.ptr(43019, 43043, 24), new Range16.ptr(43044, 43047, 1), new Range16.ptr(43136, 43137, 1), new Range16.ptr(43188, 43205, 1), new Range16.ptr(43232, 43249, 1), new Range16.ptr(43302, 43309, 1), new Range16.ptr(43335, 43347, 1), new Range16.ptr(43392, 43395, 1), new Range16.ptr(43443, 43456, 1), new Range16.ptr(43493, 43561, 68), new Range16.ptr(43562, 43574, 1), new Range16.ptr(43587, 43596, 9), new Range16.ptr(43597, 43643, 46), new Range16.ptr(43644, 43645, 1), new Range16.ptr(43696, 43698, 2), new Range16.ptr(43699, 43700, 1), new Range16.ptr(43703, 43704, 1), new Range16.ptr(43710, 43711, 1), new Range16.ptr(43713, 43755, 42), new Range16.ptr(43756, 43759, 1), new Range16.ptr(43765, 43766, 1), new Range16.ptr(44003, 44010, 1), new Range16.ptr(44012, 44013, 1), new Range16.ptr(64286, 65024, 738), new Range16.ptr(65025, 65039, 1), new Range16.ptr(65056, 65071, 1)]), new sliceType$1([new Range32.ptr(66045, 66272, 227), new Range32.ptr(66422, 66426, 1), new Range32.ptr(68097, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68111, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68325, 166), new Range32.ptr(68326, 69632, 1306), new Range32.ptr(69633, 69634, 1), new Range32.ptr(69688, 69702, 1), new Range32.ptr(69759, 69762, 1), new Range32.ptr(69808, 69818, 1), new Range32.ptr(69888, 69890, 1), new Range32.ptr(69927, 69940, 1), new Range32.ptr(70003, 70016, 13), new Range32.ptr(70017, 70018, 1), new Range32.ptr(70067, 70080, 1), new Range32.ptr(70090, 70092, 1), new Range32.ptr(70188, 70199, 1), new Range32.ptr(70206, 70367, 161), new Range32.ptr(70368, 70378, 1), new Range32.ptr(70400, 70403, 1), new Range32.ptr(70460, 70462, 2), new Range32.ptr(70463, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70487, 70498, 11), new Range32.ptr(70499, 70502, 3), new Range32.ptr(70503, 70508, 1), new Range32.ptr(70512, 70516, 1), new Range32.ptr(70709, 70726, 1), new Range32.ptr(70832, 70851, 1), new Range32.ptr(71087, 71093, 1), new Range32.ptr(71096, 71104, 1), new Range32.ptr(71132, 71133, 1), new Range32.ptr(71216, 71232, 1), new Range32.ptr(71339, 71351, 1), new Range32.ptr(71453, 71467, 1), new Range32.ptr(72193, 72202, 1), new Range32.ptr(72243, 72249, 1), new Range32.ptr(72251, 72254, 1), new Range32.ptr(72263, 72273, 10), new Range32.ptr(72274, 72283, 1), new Range32.ptr(72330, 72345, 1), new Range32.ptr(72751, 72758, 1), new Range32.ptr(72760, 72767, 1), new Range32.ptr(72850, 72871, 1), new Range32.ptr(72873, 72886, 1), new Range32.ptr(73009, 73014, 1), new Range32.ptr(73018, 73020, 2), new Range32.ptr(73021, 73023, 2), new Range32.ptr(73024, 73029, 1), new Range32.ptr(73031, 92912, 19881), new Range32.ptr(92913, 92916, 1), new Range32.ptr(92976, 92982, 1), new Range32.ptr(94033, 94078, 1), new Range32.ptr(94095, 94098, 1), new Range32.ptr(113821, 113822, 1), new Range32.ptr(119141, 119145, 1), new Range32.ptr(119149, 119154, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(119362, 119364, 1), new Range32.ptr(121344, 121398, 1), new Range32.ptr(121403, 121452, 1), new Range32.ptr(121461, 121476, 15), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1), new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1), new Range32.ptr(125136, 125142, 1), new Range32.ptr(125252, 125258, 1), new Range32.ptr(917760, 917999, 1)]), 0); + _Mc = new RangeTable.ptr(new sliceType([new Range16.ptr(2307, 2363, 56), new Range16.ptr(2366, 2368, 1), new Range16.ptr(2377, 2380, 1), new Range16.ptr(2382, 2383, 1), new Range16.ptr(2434, 2435, 1), new Range16.ptr(2494, 2496, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2508, 1), new Range16.ptr(2519, 2563, 44), new Range16.ptr(2622, 2624, 1), new Range16.ptr(2691, 2750, 59), new Range16.ptr(2751, 2752, 1), new Range16.ptr(2761, 2763, 2), new Range16.ptr(2764, 2818, 54), new Range16.ptr(2819, 2878, 59), new Range16.ptr(2880, 2887, 7), new Range16.ptr(2888, 2891, 3), new Range16.ptr(2892, 2903, 11), new Range16.ptr(3006, 3007, 1), new Range16.ptr(3009, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3020, 1), new Range16.ptr(3031, 3073, 42), new Range16.ptr(3074, 3075, 1), new Range16.ptr(3137, 3140, 1), new Range16.ptr(3202, 3203, 1), new Range16.ptr(3262, 3264, 2), new Range16.ptr(3265, 3268, 1), new Range16.ptr(3271, 3272, 1), new Range16.ptr(3274, 3275, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3330, 3331, 1), new Range16.ptr(3390, 3392, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3404, 1), new Range16.ptr(3415, 3458, 43), new Range16.ptr(3459, 3535, 76), new Range16.ptr(3536, 3537, 1), new Range16.ptr(3544, 3551, 1), new Range16.ptr(3570, 3571, 1), new Range16.ptr(3902, 3903, 1), new Range16.ptr(3967, 4139, 172), new Range16.ptr(4140, 4145, 5), new Range16.ptr(4152, 4155, 3), new Range16.ptr(4156, 4182, 26), new Range16.ptr(4183, 4194, 11), new Range16.ptr(4195, 4196, 1), new Range16.ptr(4199, 4205, 1), new Range16.ptr(4227, 4228, 1), new Range16.ptr(4231, 4236, 1), new Range16.ptr(4239, 4250, 11), new Range16.ptr(4251, 4252, 1), new Range16.ptr(6070, 6078, 8), new Range16.ptr(6079, 6085, 1), new Range16.ptr(6087, 6088, 1), new Range16.ptr(6435, 6438, 1), new Range16.ptr(6441, 6443, 1), new Range16.ptr(6448, 6449, 1), new Range16.ptr(6451, 6456, 1), new Range16.ptr(6681, 6682, 1), new Range16.ptr(6741, 6743, 2), new Range16.ptr(6753, 6755, 2), new Range16.ptr(6756, 6765, 9), new Range16.ptr(6766, 6770, 1), new Range16.ptr(6916, 6965, 49), new Range16.ptr(6971, 6973, 2), new Range16.ptr(6974, 6977, 1), new Range16.ptr(6979, 6980, 1), new Range16.ptr(7042, 7073, 31), new Range16.ptr(7078, 7079, 1), new Range16.ptr(7082, 7143, 61), new Range16.ptr(7146, 7148, 1), new Range16.ptr(7150, 7154, 4), new Range16.ptr(7155, 7204, 49), new Range16.ptr(7205, 7211, 1), new Range16.ptr(7220, 7221, 1), new Range16.ptr(7393, 7410, 17), new Range16.ptr(7411, 7415, 4), new Range16.ptr(12334, 12335, 1), new Range16.ptr(43043, 43044, 1), new Range16.ptr(43047, 43136, 89), new Range16.ptr(43137, 43188, 51), new Range16.ptr(43189, 43203, 1), new Range16.ptr(43346, 43347, 1), new Range16.ptr(43395, 43444, 49), new Range16.ptr(43445, 43450, 5), new Range16.ptr(43451, 43453, 2), new Range16.ptr(43454, 43456, 1), new Range16.ptr(43567, 43568, 1), new Range16.ptr(43571, 43572, 1), new Range16.ptr(43597, 43643, 46), new Range16.ptr(43645, 43755, 110), new Range16.ptr(43758, 43759, 1), new Range16.ptr(43765, 44003, 238), new Range16.ptr(44004, 44006, 2), new Range16.ptr(44007, 44009, 2), new Range16.ptr(44010, 44012, 2)]), new sliceType$1([new Range32.ptr(69632, 69634, 2), new Range32.ptr(69762, 69808, 46), new Range32.ptr(69809, 69810, 1), new Range32.ptr(69815, 69816, 1), new Range32.ptr(69932, 70018, 86), new Range32.ptr(70067, 70069, 1), new Range32.ptr(70079, 70080, 1), new Range32.ptr(70188, 70190, 1), new Range32.ptr(70194, 70195, 1), new Range32.ptr(70197, 70368, 171), new Range32.ptr(70369, 70370, 1), new Range32.ptr(70402, 70403, 1), new Range32.ptr(70462, 70463, 1), new Range32.ptr(70465, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70487, 70498, 11), new Range32.ptr(70499, 70709, 210), new Range32.ptr(70710, 70711, 1), new Range32.ptr(70720, 70721, 1), new Range32.ptr(70725, 70832, 107), new Range32.ptr(70833, 70834, 1), new Range32.ptr(70841, 70843, 2), new Range32.ptr(70844, 70846, 1), new Range32.ptr(70849, 71087, 238), new Range32.ptr(71088, 71089, 1), new Range32.ptr(71096, 71099, 1), new Range32.ptr(71102, 71216, 114), new Range32.ptr(71217, 71218, 1), new Range32.ptr(71227, 71228, 1), new Range32.ptr(71230, 71340, 110), new Range32.ptr(71342, 71343, 1), new Range32.ptr(71350, 71456, 106), new Range32.ptr(71457, 71462, 5), new Range32.ptr(72199, 72200, 1), new Range32.ptr(72249, 72279, 30), new Range32.ptr(72280, 72343, 63), new Range32.ptr(72751, 72766, 15), new Range32.ptr(72873, 72881, 8), new Range32.ptr(72884, 94033, 21149), new Range32.ptr(94034, 94078, 1), new Range32.ptr(119141, 119142, 1), new Range32.ptr(119149, 119154, 1)]), 0); + _Me = new RangeTable.ptr(new sliceType([new Range16.ptr(1160, 1161, 1), new Range16.ptr(6846, 8413, 1567), new Range16.ptr(8414, 8416, 1), new Range16.ptr(8418, 8420, 1), new Range16.ptr(42608, 42610, 1)]), sliceType$1.nil, 0); + _Mn = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1155, 1159, 1), new Range16.ptr(1425, 1469, 1), new Range16.ptr(1471, 1473, 2), new Range16.ptr(1474, 1476, 2), new Range16.ptr(1477, 1479, 2), new Range16.ptr(1552, 1562, 1), new Range16.ptr(1611, 1631, 1), new Range16.ptr(1648, 1750, 102), new Range16.ptr(1751, 1756, 1), new Range16.ptr(1759, 1764, 1), new Range16.ptr(1767, 1768, 1), new Range16.ptr(1770, 1773, 1), new Range16.ptr(1809, 1840, 31), new Range16.ptr(1841, 1866, 1), new Range16.ptr(1958, 1968, 1), new Range16.ptr(2027, 2035, 1), new Range16.ptr(2070, 2073, 1), new Range16.ptr(2075, 2083, 1), new Range16.ptr(2085, 2087, 1), new Range16.ptr(2089, 2093, 1), new Range16.ptr(2137, 2139, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2306, 1), new Range16.ptr(2362, 2364, 2), new Range16.ptr(2369, 2376, 1), new Range16.ptr(2381, 2385, 4), new Range16.ptr(2386, 2391, 1), new Range16.ptr(2402, 2403, 1), new Range16.ptr(2433, 2492, 59), new Range16.ptr(2497, 2500, 1), new Range16.ptr(2509, 2530, 21), new Range16.ptr(2531, 2561, 30), new Range16.ptr(2562, 2620, 58), new Range16.ptr(2625, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2672, 31), new Range16.ptr(2673, 2677, 4), new Range16.ptr(2689, 2690, 1), new Range16.ptr(2748, 2753, 5), new Range16.ptr(2754, 2757, 1), new Range16.ptr(2759, 2760, 1), new Range16.ptr(2765, 2786, 21), new Range16.ptr(2787, 2810, 23), new Range16.ptr(2811, 2815, 1), new Range16.ptr(2817, 2876, 59), new Range16.ptr(2879, 2881, 2), new Range16.ptr(2882, 2884, 1), new Range16.ptr(2893, 2902, 9), new Range16.ptr(2914, 2915, 1), new Range16.ptr(2946, 3008, 62), new Range16.ptr(3021, 3072, 51), new Range16.ptr(3134, 3136, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3170, 3171, 1), new Range16.ptr(3201, 3260, 59), new Range16.ptr(3263, 3270, 7), new Range16.ptr(3276, 3277, 1), new Range16.ptr(3298, 3299, 1), new Range16.ptr(3328, 3329, 1), new Range16.ptr(3387, 3388, 1), new Range16.ptr(3393, 3396, 1), new Range16.ptr(3405, 3426, 21), new Range16.ptr(3427, 3530, 103), new Range16.ptr(3538, 3540, 1), new Range16.ptr(3542, 3633, 91), new Range16.ptr(3636, 3642, 1), new Range16.ptr(3655, 3662, 1), new Range16.ptr(3761, 3764, 3), new Range16.ptr(3765, 3769, 1), new Range16.ptr(3771, 3772, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3864, 3865, 1), new Range16.ptr(3893, 3897, 2), new Range16.ptr(3953, 3966, 1), new Range16.ptr(3968, 3972, 1), new Range16.ptr(3974, 3975, 1), new Range16.ptr(3981, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4038, 4141, 103), new Range16.ptr(4142, 4144, 1), new Range16.ptr(4146, 4151, 1), new Range16.ptr(4153, 4154, 1), new Range16.ptr(4157, 4158, 1), new Range16.ptr(4184, 4185, 1), new Range16.ptr(4190, 4192, 1), new Range16.ptr(4209, 4212, 1), new Range16.ptr(4226, 4229, 3), new Range16.ptr(4230, 4237, 7), new Range16.ptr(4253, 4957, 704), new Range16.ptr(4958, 4959, 1), new Range16.ptr(5906, 5908, 1), new Range16.ptr(5938, 5940, 1), new Range16.ptr(5970, 5971, 1), new Range16.ptr(6002, 6003, 1), new Range16.ptr(6068, 6069, 1), new Range16.ptr(6071, 6077, 1), new Range16.ptr(6086, 6089, 3), new Range16.ptr(6090, 6099, 1), new Range16.ptr(6109, 6155, 46), new Range16.ptr(6156, 6157, 1), new Range16.ptr(6277, 6278, 1), new Range16.ptr(6313, 6432, 119), new Range16.ptr(6433, 6434, 1), new Range16.ptr(6439, 6440, 1), new Range16.ptr(6450, 6457, 7), new Range16.ptr(6458, 6459, 1), new Range16.ptr(6679, 6680, 1), new Range16.ptr(6683, 6742, 59), new Range16.ptr(6744, 6750, 1), new Range16.ptr(6752, 6754, 2), new Range16.ptr(6757, 6764, 1), new Range16.ptr(6771, 6780, 1), new Range16.ptr(6783, 6832, 49), new Range16.ptr(6833, 6845, 1), new Range16.ptr(6912, 6915, 1), new Range16.ptr(6964, 6966, 2), new Range16.ptr(6967, 6970, 1), new Range16.ptr(6972, 6978, 6), new Range16.ptr(7019, 7027, 1), new Range16.ptr(7040, 7041, 1), new Range16.ptr(7074, 7077, 1), new Range16.ptr(7080, 7081, 1), new Range16.ptr(7083, 7085, 1), new Range16.ptr(7142, 7144, 2), new Range16.ptr(7145, 7149, 4), new Range16.ptr(7151, 7153, 1), new Range16.ptr(7212, 7219, 1), new Range16.ptr(7222, 7223, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7392, 1), new Range16.ptr(7394, 7400, 1), new Range16.ptr(7405, 7412, 7), new Range16.ptr(7416, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8400, 8412, 1), new Range16.ptr(8417, 8421, 4), new Range16.ptr(8422, 8432, 1), new Range16.ptr(11503, 11505, 1), new Range16.ptr(11647, 11744, 97), new Range16.ptr(11745, 11775, 1), new Range16.ptr(12330, 12333, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(42607, 42612, 5), new Range16.ptr(42613, 42621, 1), new Range16.ptr(42654, 42655, 1), new Range16.ptr(42736, 42737, 1), new Range16.ptr(43010, 43014, 4), new Range16.ptr(43019, 43045, 26), new Range16.ptr(43046, 43204, 158), new Range16.ptr(43205, 43232, 27), new Range16.ptr(43233, 43249, 1), new Range16.ptr(43302, 43309, 1), new Range16.ptr(43335, 43345, 1), new Range16.ptr(43392, 43394, 1), new Range16.ptr(43443, 43446, 3), new Range16.ptr(43447, 43449, 1), new Range16.ptr(43452, 43493, 41), new Range16.ptr(43561, 43566, 1), new Range16.ptr(43569, 43570, 1), new Range16.ptr(43573, 43574, 1), new Range16.ptr(43587, 43596, 9), new Range16.ptr(43644, 43696, 52), new Range16.ptr(43698, 43700, 1), new Range16.ptr(43703, 43704, 1), new Range16.ptr(43710, 43711, 1), new Range16.ptr(43713, 43756, 43), new Range16.ptr(43757, 43766, 9), new Range16.ptr(44005, 44008, 3), new Range16.ptr(44013, 64286, 20273), new Range16.ptr(65024, 65039, 1), new Range16.ptr(65056, 65071, 1)]), new sliceType$1([new Range32.ptr(66045, 66272, 227), new Range32.ptr(66422, 66426, 1), new Range32.ptr(68097, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68111, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68325, 166), new Range32.ptr(68326, 69633, 1307), new Range32.ptr(69688, 69702, 1), new Range32.ptr(69759, 69761, 1), new Range32.ptr(69811, 69814, 1), new Range32.ptr(69817, 69818, 1), new Range32.ptr(69888, 69890, 1), new Range32.ptr(69927, 69931, 1), new Range32.ptr(69933, 69940, 1), new Range32.ptr(70003, 70016, 13), new Range32.ptr(70017, 70070, 53), new Range32.ptr(70071, 70078, 1), new Range32.ptr(70090, 70092, 1), new Range32.ptr(70191, 70193, 1), new Range32.ptr(70196, 70198, 2), new Range32.ptr(70199, 70206, 7), new Range32.ptr(70367, 70371, 4), new Range32.ptr(70372, 70378, 1), new Range32.ptr(70400, 70401, 1), new Range32.ptr(70460, 70464, 4), new Range32.ptr(70502, 70508, 1), new Range32.ptr(70512, 70516, 1), new Range32.ptr(70712, 70719, 1), new Range32.ptr(70722, 70724, 1), new Range32.ptr(70726, 70835, 109), new Range32.ptr(70836, 70840, 1), new Range32.ptr(70842, 70847, 5), new Range32.ptr(70848, 70850, 2), new Range32.ptr(70851, 71090, 239), new Range32.ptr(71091, 71093, 1), new Range32.ptr(71100, 71101, 1), new Range32.ptr(71103, 71104, 1), new Range32.ptr(71132, 71133, 1), new Range32.ptr(71219, 71226, 1), new Range32.ptr(71229, 71231, 2), new Range32.ptr(71232, 71339, 107), new Range32.ptr(71341, 71344, 3), new Range32.ptr(71345, 71349, 1), new Range32.ptr(71351, 71453, 102), new Range32.ptr(71454, 71455, 1), new Range32.ptr(71458, 71461, 1), new Range32.ptr(71463, 71467, 1), new Range32.ptr(72193, 72198, 1), new Range32.ptr(72201, 72202, 1), new Range32.ptr(72243, 72248, 1), new Range32.ptr(72251, 72254, 1), new Range32.ptr(72263, 72273, 10), new Range32.ptr(72274, 72278, 1), new Range32.ptr(72281, 72283, 1), new Range32.ptr(72330, 72342, 1), new Range32.ptr(72344, 72345, 1), new Range32.ptr(72752, 72758, 1), new Range32.ptr(72760, 72765, 1), new Range32.ptr(72767, 72850, 83), new Range32.ptr(72851, 72871, 1), new Range32.ptr(72874, 72880, 1), new Range32.ptr(72882, 72883, 1), new Range32.ptr(72885, 72886, 1), new Range32.ptr(73009, 73014, 1), new Range32.ptr(73018, 73020, 2), new Range32.ptr(73021, 73023, 2), new Range32.ptr(73024, 73029, 1), new Range32.ptr(73031, 92912, 19881), new Range32.ptr(92913, 92916, 1), new Range32.ptr(92976, 92982, 1), new Range32.ptr(94095, 94098, 1), new Range32.ptr(113821, 113822, 1), new Range32.ptr(119143, 119145, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(119362, 119364, 1), new Range32.ptr(121344, 121398, 1), new Range32.ptr(121403, 121452, 1), new Range32.ptr(121461, 121476, 15), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1), new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1), new Range32.ptr(125136, 125142, 1), new Range32.ptr(125252, 125258, 1), new Range32.ptr(917760, 917999, 1)]), 0); + _N = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(178, 179, 1), new Range16.ptr(185, 188, 3), new Range16.ptr(189, 190, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2548, 2553, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(2930, 2935, 1), new Range16.ptr(3046, 3058, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3192, 3198, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3416, 3422, 1), new Range16.ptr(3430, 3448, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3891, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(4969, 4988, 1), new Range16.ptr(5870, 5872, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6618, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(8304, 8308, 4), new Range16.ptr(8309, 8313, 1), new Range16.ptr(8320, 8329, 1), new Range16.ptr(8528, 8578, 1), new Range16.ptr(8581, 8585, 1), new Range16.ptr(9312, 9371, 1), new Range16.ptr(9450, 9471, 1), new Range16.ptr(10102, 10131, 1), new Range16.ptr(11517, 12295, 778), new Range16.ptr(12321, 12329, 1), new Range16.ptr(12344, 12346, 1), new Range16.ptr(12690, 12693, 1), new Range16.ptr(12832, 12841, 1), new Range16.ptr(12872, 12879, 1), new Range16.ptr(12881, 12895, 1), new Range16.ptr(12928, 12937, 1), new Range16.ptr(12977, 12991, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(42726, 42735, 1), new Range16.ptr(43056, 43061, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(65799, 65843, 1), new Range32.ptr(65856, 65912, 1), new Range32.ptr(65930, 65931, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(66336, 66339, 1), new Range32.ptr(66369, 66378, 9), new Range32.ptr(66513, 66517, 1), new Range32.ptr(66720, 66729, 1), new Range32.ptr(67672, 67679, 1), new Range32.ptr(67705, 67711, 1), new Range32.ptr(67751, 67759, 1), new Range32.ptr(67835, 67839, 1), new Range32.ptr(67862, 67867, 1), new Range32.ptr(68028, 68029, 1), new Range32.ptr(68032, 68047, 1), new Range32.ptr(68050, 68095, 1), new Range32.ptr(68160, 68167, 1), new Range32.ptr(68221, 68222, 1), new Range32.ptr(68253, 68255, 1), new Range32.ptr(68331, 68335, 1), new Range32.ptr(68440, 68447, 1), new Range32.ptr(68472, 68479, 1), new Range32.ptr(68521, 68527, 1), new Range32.ptr(68858, 68863, 1), new Range32.ptr(69216, 69246, 1), new Range32.ptr(69714, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70113, 70132, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70736, 70745, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71472, 71483, 1), new Range32.ptr(71904, 71922, 1), new Range32.ptr(72784, 72812, 1), new Range32.ptr(73040, 73049, 1), new Range32.ptr(74752, 74862, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(125127, 125135, 1), new Range32.ptr(125264, 125273, 1), new Range32.ptr(127232, 127244, 1)]), 4); + _Nd = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(3046, 3055, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3430, 3439, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3881, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6617, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(66720, 66729, 1), new Range32.ptr(69734, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70736, 70745, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71472, 71481, 1), new Range32.ptr(71904, 71913, 1), new Range32.ptr(72784, 72793, 1), new Range32.ptr(73040, 73049, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(125264, 125273, 1)]), 1); + _Nl = new RangeTable.ptr(new sliceType([new Range16.ptr(5870, 5872, 1), new Range16.ptr(8544, 8578, 1), new Range16.ptr(8581, 8584, 1), new Range16.ptr(12295, 12321, 26), new Range16.ptr(12322, 12329, 1), new Range16.ptr(12344, 12346, 1), new Range16.ptr(42726, 42735, 1)]), new sliceType$1([new Range32.ptr(65856, 65908, 1), new Range32.ptr(66369, 66378, 9), new Range32.ptr(66513, 66517, 1), new Range32.ptr(74752, 74862, 1)]), 0); + _No = new RangeTable.ptr(new sliceType([new Range16.ptr(178, 179, 1), new Range16.ptr(185, 188, 3), new Range16.ptr(189, 190, 1), new Range16.ptr(2548, 2553, 1), new Range16.ptr(2930, 2935, 1), new Range16.ptr(3056, 3058, 1), new Range16.ptr(3192, 3198, 1), new Range16.ptr(3416, 3422, 1), new Range16.ptr(3440, 3448, 1), new Range16.ptr(3882, 3891, 1), new Range16.ptr(4969, 4988, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6618, 8304, 1686), new Range16.ptr(8308, 8313, 1), new Range16.ptr(8320, 8329, 1), new Range16.ptr(8528, 8543, 1), new Range16.ptr(8585, 9312, 727), new Range16.ptr(9313, 9371, 1), new Range16.ptr(9450, 9471, 1), new Range16.ptr(10102, 10131, 1), new Range16.ptr(11517, 12690, 1173), new Range16.ptr(12691, 12693, 1), new Range16.ptr(12832, 12841, 1), new Range16.ptr(12872, 12879, 1), new Range16.ptr(12881, 12895, 1), new Range16.ptr(12928, 12937, 1), new Range16.ptr(12977, 12991, 1), new Range16.ptr(43056, 43061, 1)]), new sliceType$1([new Range32.ptr(65799, 65843, 1), new Range32.ptr(65909, 65912, 1), new Range32.ptr(65930, 65931, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(66336, 66339, 1), new Range32.ptr(67672, 67679, 1), new Range32.ptr(67705, 67711, 1), new Range32.ptr(67751, 67759, 1), new Range32.ptr(67835, 67839, 1), new Range32.ptr(67862, 67867, 1), new Range32.ptr(68028, 68029, 1), new Range32.ptr(68032, 68047, 1), new Range32.ptr(68050, 68095, 1), new Range32.ptr(68160, 68167, 1), new Range32.ptr(68221, 68222, 1), new Range32.ptr(68253, 68255, 1), new Range32.ptr(68331, 68335, 1), new Range32.ptr(68440, 68447, 1), new Range32.ptr(68472, 68479, 1), new Range32.ptr(68521, 68527, 1), new Range32.ptr(68858, 68863, 1), new Range32.ptr(69216, 69246, 1), new Range32.ptr(69714, 69733, 1), new Range32.ptr(70113, 70132, 1), new Range32.ptr(71482, 71483, 1), new Range32.ptr(71914, 71922, 1), new Range32.ptr(72794, 72812, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(125127, 125135, 1), new Range32.ptr(127232, 127244, 1)]), 3); + _P = new RangeTable.ptr(new sliceType([new Range16.ptr(33, 35, 1), new Range16.ptr(37, 42, 1), new Range16.ptr(44, 47, 1), new Range16.ptr(58, 59, 1), new Range16.ptr(63, 64, 1), new Range16.ptr(91, 93, 1), new Range16.ptr(95, 123, 28), new Range16.ptr(125, 161, 36), new Range16.ptr(167, 171, 4), new Range16.ptr(182, 183, 1), new Range16.ptr(187, 191, 4), new Range16.ptr(894, 903, 9), new Range16.ptr(1370, 1375, 1), new Range16.ptr(1417, 1418, 1), new Range16.ptr(1470, 1472, 2), new Range16.ptr(1475, 1478, 3), new Range16.ptr(1523, 1524, 1), new Range16.ptr(1545, 1546, 1), new Range16.ptr(1548, 1549, 1), new Range16.ptr(1563, 1566, 3), new Range16.ptr(1567, 1642, 75), new Range16.ptr(1643, 1645, 1), new Range16.ptr(1748, 1792, 44), new Range16.ptr(1793, 1805, 1), new Range16.ptr(2039, 2041, 1), new Range16.ptr(2096, 2110, 1), new Range16.ptr(2142, 2404, 262), new Range16.ptr(2405, 2416, 11), new Range16.ptr(2557, 2800, 243), new Range16.ptr(3572, 3663, 91), new Range16.ptr(3674, 3675, 1), new Range16.ptr(3844, 3858, 1), new Range16.ptr(3860, 3898, 38), new Range16.ptr(3899, 3901, 1), new Range16.ptr(3973, 4048, 75), new Range16.ptr(4049, 4052, 1), new Range16.ptr(4057, 4058, 1), new Range16.ptr(4170, 4175, 1), new Range16.ptr(4347, 4960, 613), new Range16.ptr(4961, 4968, 1), new Range16.ptr(5120, 5741, 621), new Range16.ptr(5742, 5787, 45), new Range16.ptr(5788, 5867, 79), new Range16.ptr(5868, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6100, 6102, 1), new Range16.ptr(6104, 6106, 1), new Range16.ptr(6144, 6154, 1), new Range16.ptr(6468, 6469, 1), new Range16.ptr(6686, 6687, 1), new Range16.ptr(6816, 6822, 1), new Range16.ptr(6824, 6829, 1), new Range16.ptr(7002, 7008, 1), new Range16.ptr(7164, 7167, 1), new Range16.ptr(7227, 7231, 1), new Range16.ptr(7294, 7295, 1), new Range16.ptr(7360, 7367, 1), new Range16.ptr(7379, 8208, 829), new Range16.ptr(8209, 8231, 1), new Range16.ptr(8240, 8259, 1), new Range16.ptr(8261, 8273, 1), new Range16.ptr(8275, 8286, 1), new Range16.ptr(8317, 8318, 1), new Range16.ptr(8333, 8334, 1), new Range16.ptr(8968, 8971, 1), new Range16.ptr(9001, 9002, 1), new Range16.ptr(10088, 10101, 1), new Range16.ptr(10181, 10182, 1), new Range16.ptr(10214, 10223, 1), new Range16.ptr(10627, 10648, 1), new Range16.ptr(10712, 10715, 1), new Range16.ptr(10748, 10749, 1), new Range16.ptr(11513, 11516, 1), new Range16.ptr(11518, 11519, 1), new Range16.ptr(11632, 11776, 144), new Range16.ptr(11777, 11822, 1), new Range16.ptr(11824, 11849, 1), new Range16.ptr(12289, 12291, 1), new Range16.ptr(12296, 12305, 1), new Range16.ptr(12308, 12319, 1), new Range16.ptr(12336, 12349, 13), new Range16.ptr(12448, 12539, 91), new Range16.ptr(42238, 42239, 1), new Range16.ptr(42509, 42511, 1), new Range16.ptr(42611, 42622, 11), new Range16.ptr(42738, 42743, 1), new Range16.ptr(43124, 43127, 1), new Range16.ptr(43214, 43215, 1), new Range16.ptr(43256, 43258, 1), new Range16.ptr(43260, 43310, 50), new Range16.ptr(43311, 43359, 48), new Range16.ptr(43457, 43469, 1), new Range16.ptr(43486, 43487, 1), new Range16.ptr(43612, 43615, 1), new Range16.ptr(43742, 43743, 1), new Range16.ptr(43760, 43761, 1), new Range16.ptr(44011, 64830, 20819), new Range16.ptr(64831, 65040, 209), new Range16.ptr(65041, 65049, 1), new Range16.ptr(65072, 65106, 1), new Range16.ptr(65108, 65121, 1), new Range16.ptr(65123, 65128, 5), new Range16.ptr(65130, 65131, 1), new Range16.ptr(65281, 65283, 1), new Range16.ptr(65285, 65290, 1), new Range16.ptr(65292, 65295, 1), new Range16.ptr(65306, 65307, 1), new Range16.ptr(65311, 65312, 1), new Range16.ptr(65339, 65341, 1), new Range16.ptr(65343, 65371, 28), new Range16.ptr(65373, 65375, 2), new Range16.ptr(65376, 65381, 1)]), new sliceType$1([new Range32.ptr(65792, 65794, 1), new Range32.ptr(66463, 66512, 49), new Range32.ptr(66927, 67671, 744), new Range32.ptr(67871, 67903, 32), new Range32.ptr(68176, 68184, 1), new Range32.ptr(68223, 68336, 113), new Range32.ptr(68337, 68342, 1), new Range32.ptr(68409, 68415, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(69703, 69709, 1), new Range32.ptr(69819, 69820, 1), new Range32.ptr(69822, 69825, 1), new Range32.ptr(69952, 69955, 1), new Range32.ptr(70004, 70005, 1), new Range32.ptr(70085, 70089, 1), new Range32.ptr(70093, 70107, 14), new Range32.ptr(70109, 70111, 1), new Range32.ptr(70200, 70205, 1), new Range32.ptr(70313, 70731, 418), new Range32.ptr(70732, 70735, 1), new Range32.ptr(70747, 70749, 2), new Range32.ptr(70854, 71105, 251), new Range32.ptr(71106, 71127, 1), new Range32.ptr(71233, 71235, 1), new Range32.ptr(71264, 71276, 1), new Range32.ptr(71484, 71486, 1), new Range32.ptr(72255, 72262, 1), new Range32.ptr(72346, 72348, 1), new Range32.ptr(72350, 72354, 1), new Range32.ptr(72769, 72773, 1), new Range32.ptr(72816, 72817, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(92782, 92783, 1), new Range32.ptr(92917, 92983, 66), new Range32.ptr(92984, 92987, 1), new Range32.ptr(92996, 113823, 20827), new Range32.ptr(121479, 121483, 1), new Range32.ptr(125278, 125279, 1)]), 11); + _Pc = new RangeTable.ptr(new sliceType([new Range16.ptr(95, 8255, 8160), new Range16.ptr(8256, 8276, 20), new Range16.ptr(65075, 65076, 1), new Range16.ptr(65101, 65103, 1), new Range16.ptr(65343, 65343, 1)]), sliceType$1.nil, 0); + _Pd = new RangeTable.ptr(new sliceType([new Range16.ptr(45, 1418, 1373), new Range16.ptr(1470, 5120, 3650), new Range16.ptr(6150, 8208, 2058), new Range16.ptr(8209, 8213, 1), new Range16.ptr(11799, 11802, 3), new Range16.ptr(11834, 11835, 1), new Range16.ptr(11840, 12316, 476), new Range16.ptr(12336, 12448, 112), new Range16.ptr(65073, 65074, 1), new Range16.ptr(65112, 65123, 11), new Range16.ptr(65293, 65293, 1)]), sliceType$1.nil, 0); + _Pe = new RangeTable.ptr(new sliceType([new Range16.ptr(41, 93, 52), new Range16.ptr(125, 3899, 3774), new Range16.ptr(3901, 5788, 1887), new Range16.ptr(8262, 8318, 56), new Range16.ptr(8334, 8969, 635), new Range16.ptr(8971, 9002, 31), new Range16.ptr(10089, 10101, 2), new Range16.ptr(10182, 10215, 33), new Range16.ptr(10217, 10223, 2), new Range16.ptr(10628, 10648, 2), new Range16.ptr(10713, 10715, 2), new Range16.ptr(10749, 11811, 1062), new Range16.ptr(11813, 11817, 2), new Range16.ptr(12297, 12305, 2), new Range16.ptr(12309, 12315, 2), new Range16.ptr(12318, 12319, 1), new Range16.ptr(64830, 65048, 218), new Range16.ptr(65078, 65092, 2), new Range16.ptr(65096, 65114, 18), new Range16.ptr(65116, 65118, 2), new Range16.ptr(65289, 65341, 52), new Range16.ptr(65373, 65379, 3)]), sliceType$1.nil, 1); + _Pf = new RangeTable.ptr(new sliceType([new Range16.ptr(187, 8217, 8030), new Range16.ptr(8221, 8250, 29), new Range16.ptr(11779, 11781, 2), new Range16.ptr(11786, 11789, 3), new Range16.ptr(11805, 11809, 4)]), sliceType$1.nil, 0); + _Pi = new RangeTable.ptr(new sliceType([new Range16.ptr(171, 8216, 8045), new Range16.ptr(8219, 8220, 1), new Range16.ptr(8223, 8249, 26), new Range16.ptr(11778, 11780, 2), new Range16.ptr(11785, 11788, 3), new Range16.ptr(11804, 11808, 4)]), sliceType$1.nil, 0); + _Po = new RangeTable.ptr(new sliceType([new Range16.ptr(33, 35, 1), new Range16.ptr(37, 39, 1), new Range16.ptr(42, 46, 2), new Range16.ptr(47, 58, 11), new Range16.ptr(59, 63, 4), new Range16.ptr(64, 92, 28), new Range16.ptr(161, 167, 6), new Range16.ptr(182, 183, 1), new Range16.ptr(191, 894, 703), new Range16.ptr(903, 1370, 467), new Range16.ptr(1371, 1375, 1), new Range16.ptr(1417, 1472, 55), new Range16.ptr(1475, 1478, 3), new Range16.ptr(1523, 1524, 1), new Range16.ptr(1545, 1546, 1), new Range16.ptr(1548, 1549, 1), new Range16.ptr(1563, 1566, 3), new Range16.ptr(1567, 1642, 75), new Range16.ptr(1643, 1645, 1), new Range16.ptr(1748, 1792, 44), new Range16.ptr(1793, 1805, 1), new Range16.ptr(2039, 2041, 1), new Range16.ptr(2096, 2110, 1), new Range16.ptr(2142, 2404, 262), new Range16.ptr(2405, 2416, 11), new Range16.ptr(2557, 2800, 243), new Range16.ptr(3572, 3663, 91), new Range16.ptr(3674, 3675, 1), new Range16.ptr(3844, 3858, 1), new Range16.ptr(3860, 3973, 113), new Range16.ptr(4048, 4052, 1), new Range16.ptr(4057, 4058, 1), new Range16.ptr(4170, 4175, 1), new Range16.ptr(4347, 4960, 613), new Range16.ptr(4961, 4968, 1), new Range16.ptr(5741, 5742, 1), new Range16.ptr(5867, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6100, 6102, 1), new Range16.ptr(6104, 6106, 1), new Range16.ptr(6144, 6149, 1), new Range16.ptr(6151, 6154, 1), new Range16.ptr(6468, 6469, 1), new Range16.ptr(6686, 6687, 1), new Range16.ptr(6816, 6822, 1), new Range16.ptr(6824, 6829, 1), new Range16.ptr(7002, 7008, 1), new Range16.ptr(7164, 7167, 1), new Range16.ptr(7227, 7231, 1), new Range16.ptr(7294, 7295, 1), new Range16.ptr(7360, 7367, 1), new Range16.ptr(7379, 8214, 835), new Range16.ptr(8215, 8224, 9), new Range16.ptr(8225, 8231, 1), new Range16.ptr(8240, 8248, 1), new Range16.ptr(8251, 8254, 1), new Range16.ptr(8257, 8259, 1), new Range16.ptr(8263, 8273, 1), new Range16.ptr(8275, 8277, 2), new Range16.ptr(8278, 8286, 1), new Range16.ptr(11513, 11516, 1), new Range16.ptr(11518, 11519, 1), new Range16.ptr(11632, 11776, 144), new Range16.ptr(11777, 11782, 5), new Range16.ptr(11783, 11784, 1), new Range16.ptr(11787, 11790, 3), new Range16.ptr(11791, 11798, 1), new Range16.ptr(11800, 11801, 1), new Range16.ptr(11803, 11806, 3), new Range16.ptr(11807, 11818, 11), new Range16.ptr(11819, 11822, 1), new Range16.ptr(11824, 11833, 1), new Range16.ptr(11836, 11839, 1), new Range16.ptr(11841, 11843, 2), new Range16.ptr(11844, 11849, 1), new Range16.ptr(12289, 12291, 1), new Range16.ptr(12349, 12539, 190), new Range16.ptr(42238, 42239, 1), new Range16.ptr(42509, 42511, 1), new Range16.ptr(42611, 42622, 11), new Range16.ptr(42738, 42743, 1), new Range16.ptr(43124, 43127, 1), new Range16.ptr(43214, 43215, 1), new Range16.ptr(43256, 43258, 1), new Range16.ptr(43260, 43310, 50), new Range16.ptr(43311, 43359, 48), new Range16.ptr(43457, 43469, 1), new Range16.ptr(43486, 43487, 1), new Range16.ptr(43612, 43615, 1), new Range16.ptr(43742, 43743, 1), new Range16.ptr(43760, 43761, 1), new Range16.ptr(44011, 65040, 21029), new Range16.ptr(65041, 65046, 1), new Range16.ptr(65049, 65072, 23), new Range16.ptr(65093, 65094, 1), new Range16.ptr(65097, 65100, 1), new Range16.ptr(65104, 65106, 1), new Range16.ptr(65108, 65111, 1), new Range16.ptr(65119, 65121, 1), new Range16.ptr(65128, 65130, 2), new Range16.ptr(65131, 65281, 150), new Range16.ptr(65282, 65283, 1), new Range16.ptr(65285, 65287, 1), new Range16.ptr(65290, 65294, 2), new Range16.ptr(65295, 65306, 11), new Range16.ptr(65307, 65311, 4), new Range16.ptr(65312, 65340, 28), new Range16.ptr(65377, 65380, 3), new Range16.ptr(65381, 65381, 1)]), new sliceType$1([new Range32.ptr(65792, 65792, 1), new Range32.ptr(65793, 65794, 1), new Range32.ptr(66463, 66512, 49), new Range32.ptr(66927, 67671, 744), new Range32.ptr(67871, 67903, 32), new Range32.ptr(68176, 68184, 1), new Range32.ptr(68223, 68336, 113), new Range32.ptr(68337, 68342, 1), new Range32.ptr(68409, 68415, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(69703, 69709, 1), new Range32.ptr(69819, 69820, 1), new Range32.ptr(69822, 69825, 1), new Range32.ptr(69952, 69955, 1), new Range32.ptr(70004, 70005, 1), new Range32.ptr(70085, 70089, 1), new Range32.ptr(70093, 70107, 14), new Range32.ptr(70109, 70111, 1), new Range32.ptr(70200, 70205, 1), new Range32.ptr(70313, 70731, 418), new Range32.ptr(70732, 70735, 1), new Range32.ptr(70747, 70749, 2), new Range32.ptr(70854, 71105, 251), new Range32.ptr(71106, 71127, 1), new Range32.ptr(71233, 71235, 1), new Range32.ptr(71264, 71276, 1), new Range32.ptr(71484, 71486, 1), new Range32.ptr(72255, 72262, 1), new Range32.ptr(72346, 72348, 1), new Range32.ptr(72350, 72354, 1), new Range32.ptr(72769, 72773, 1), new Range32.ptr(72816, 72817, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(92782, 92783, 1), new Range32.ptr(92917, 92983, 66), new Range32.ptr(92984, 92987, 1), new Range32.ptr(92996, 113823, 20827), new Range32.ptr(121479, 121483, 1), new Range32.ptr(125278, 125279, 1)]), 8); + _Ps = new RangeTable.ptr(new sliceType([new Range16.ptr(40, 91, 51), new Range16.ptr(123, 3898, 3775), new Range16.ptr(3900, 5787, 1887), new Range16.ptr(8218, 8222, 4), new Range16.ptr(8261, 8317, 56), new Range16.ptr(8333, 8968, 635), new Range16.ptr(8970, 9001, 31), new Range16.ptr(10088, 10100, 2), new Range16.ptr(10181, 10214, 33), new Range16.ptr(10216, 10222, 2), new Range16.ptr(10627, 10647, 2), new Range16.ptr(10712, 10714, 2), new Range16.ptr(10748, 11810, 1062), new Range16.ptr(11812, 11816, 2), new Range16.ptr(11842, 12296, 454), new Range16.ptr(12298, 12304, 2), new Range16.ptr(12308, 12314, 2), new Range16.ptr(12317, 64831, 52514), new Range16.ptr(65047, 65077, 30), new Range16.ptr(65079, 65091, 2), new Range16.ptr(65095, 65113, 18), new Range16.ptr(65115, 65117, 2), new Range16.ptr(65288, 65339, 51), new Range16.ptr(65371, 65375, 4), new Range16.ptr(65378, 65378, 1)]), sliceType$1.nil, 1); + _S = new RangeTable.ptr(new sliceType([new Range16.ptr(36, 43, 7), new Range16.ptr(60, 62, 1), new Range16.ptr(94, 96, 2), new Range16.ptr(124, 126, 2), new Range16.ptr(162, 166, 1), new Range16.ptr(168, 169, 1), new Range16.ptr(172, 174, 2), new Range16.ptr(175, 177, 1), new Range16.ptr(180, 184, 4), new Range16.ptr(215, 247, 32), new Range16.ptr(706, 709, 1), new Range16.ptr(722, 735, 1), new Range16.ptr(741, 747, 1), new Range16.ptr(749, 751, 2), new Range16.ptr(752, 767, 1), new Range16.ptr(885, 900, 15), new Range16.ptr(901, 1014, 113), new Range16.ptr(1154, 1421, 267), new Range16.ptr(1422, 1423, 1), new Range16.ptr(1542, 1544, 1), new Range16.ptr(1547, 1550, 3), new Range16.ptr(1551, 1758, 207), new Range16.ptr(1769, 1789, 20), new Range16.ptr(1790, 2038, 248), new Range16.ptr(2546, 2547, 1), new Range16.ptr(2554, 2555, 1), new Range16.ptr(2801, 2928, 127), new Range16.ptr(3059, 3066, 1), new Range16.ptr(3199, 3407, 208), new Range16.ptr(3449, 3647, 198), new Range16.ptr(3841, 3843, 1), new Range16.ptr(3859, 3861, 2), new Range16.ptr(3862, 3863, 1), new Range16.ptr(3866, 3871, 1), new Range16.ptr(3892, 3896, 2), new Range16.ptr(4030, 4037, 1), new Range16.ptr(4039, 4044, 1), new Range16.ptr(4046, 4047, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4254, 4255, 1), new Range16.ptr(5008, 5017, 1), new Range16.ptr(6107, 6464, 357), new Range16.ptr(6622, 6655, 1), new Range16.ptr(7009, 7018, 1), new Range16.ptr(7028, 7036, 1), new Range16.ptr(8125, 8127, 2), new Range16.ptr(8128, 8129, 1), new Range16.ptr(8141, 8143, 1), new Range16.ptr(8157, 8159, 1), new Range16.ptr(8173, 8175, 1), new Range16.ptr(8189, 8190, 1), new Range16.ptr(8260, 8274, 14), new Range16.ptr(8314, 8316, 1), new Range16.ptr(8330, 8332, 1), new Range16.ptr(8352, 8383, 1), new Range16.ptr(8448, 8449, 1), new Range16.ptr(8451, 8454, 1), new Range16.ptr(8456, 8457, 1), new Range16.ptr(8468, 8470, 2), new Range16.ptr(8471, 8472, 1), new Range16.ptr(8478, 8483, 1), new Range16.ptr(8485, 8489, 2), new Range16.ptr(8494, 8506, 12), new Range16.ptr(8507, 8512, 5), new Range16.ptr(8513, 8516, 1), new Range16.ptr(8522, 8525, 1), new Range16.ptr(8527, 8586, 59), new Range16.ptr(8587, 8592, 5), new Range16.ptr(8593, 8967, 1), new Range16.ptr(8972, 9000, 1), new Range16.ptr(9003, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9372, 9449, 1), new Range16.ptr(9472, 10087, 1), new Range16.ptr(10132, 10180, 1), new Range16.ptr(10183, 10213, 1), new Range16.ptr(10224, 10626, 1), new Range16.ptr(10649, 10711, 1), new Range16.ptr(10716, 10747, 1), new Range16.ptr(10750, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11493, 11498, 1), new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12292, 12306, 14), new Range16.ptr(12307, 12320, 13), new Range16.ptr(12342, 12343, 1), new Range16.ptr(12350, 12351, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(12688, 12689, 1), new Range16.ptr(12694, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12842, 12871, 1), new Range16.ptr(12880, 12896, 16), new Range16.ptr(12897, 12927, 1), new Range16.ptr(12938, 12976, 1), new Range16.ptr(12992, 13054, 1), new Range16.ptr(13056, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42128, 42182, 1), new Range16.ptr(42752, 42774, 1), new Range16.ptr(42784, 42785, 1), new Range16.ptr(42889, 42890, 1), new Range16.ptr(43048, 43051, 1), new Range16.ptr(43062, 43065, 1), new Range16.ptr(43639, 43641, 1), new Range16.ptr(43867, 64297, 20430), new Range16.ptr(64434, 64449, 1), new Range16.ptr(65020, 65021, 1), new Range16.ptr(65122, 65124, 2), new Range16.ptr(65125, 65126, 1), new Range16.ptr(65129, 65284, 155), new Range16.ptr(65291, 65308, 17), new Range16.ptr(65309, 65310, 1), new Range16.ptr(65342, 65344, 2), new Range16.ptr(65372, 65374, 2), new Range16.ptr(65504, 65510, 1), new Range16.ptr(65512, 65518, 1), new Range16.ptr(65532, 65533, 1)]), new sliceType$1([new Range32.ptr(65847, 65855, 1), new Range32.ptr(65913, 65929, 1), new Range32.ptr(65932, 65934, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(65952, 66000, 48), new Range32.ptr(66001, 66044, 1), new Range32.ptr(67703, 67704, 1), new Range32.ptr(68296, 71487, 3191), new Range32.ptr(92988, 92991, 1), new Range32.ptr(92997, 113820, 20823), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119140, 1), new Range32.ptr(119146, 119148, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119296, 119361, 1), new Range32.ptr(119365, 119552, 187), new Range32.ptr(119553, 119638, 1), new Range32.ptr(120513, 120539, 26), new Range32.ptr(120571, 120597, 26), new Range32.ptr(120629, 120655, 26), new Range32.ptr(120687, 120713, 26), new Range32.ptr(120745, 120771, 26), new Range32.ptr(120832, 121343, 1), new Range32.ptr(121399, 121402, 1), new Range32.ptr(121453, 121460, 1), new Range32.ptr(121462, 121475, 1), new Range32.ptr(121477, 121478, 1), new Range32.ptr(126704, 126705, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129488, 16), new Range32.ptr(129489, 129510, 1)]), 10); + _Sc = new RangeTable.ptr(new sliceType([new Range16.ptr(36, 162, 126), new Range16.ptr(163, 165, 1), new Range16.ptr(1423, 1547, 124), new Range16.ptr(2546, 2547, 1), new Range16.ptr(2555, 2801, 246), new Range16.ptr(3065, 3647, 582), new Range16.ptr(6107, 8352, 2245), new Range16.ptr(8353, 8383, 1), new Range16.ptr(43064, 65020, 21956), new Range16.ptr(65129, 65284, 155), new Range16.ptr(65504, 65505, 1), new Range16.ptr(65509, 65510, 1)]), sliceType$1.nil, 2); + _Sk = new RangeTable.ptr(new sliceType([new Range16.ptr(94, 96, 2), new Range16.ptr(168, 175, 7), new Range16.ptr(180, 184, 4), new Range16.ptr(706, 709, 1), new Range16.ptr(722, 735, 1), new Range16.ptr(741, 747, 1), new Range16.ptr(749, 751, 2), new Range16.ptr(752, 767, 1), new Range16.ptr(885, 900, 15), new Range16.ptr(901, 8125, 7224), new Range16.ptr(8127, 8129, 1), new Range16.ptr(8141, 8143, 1), new Range16.ptr(8157, 8159, 1), new Range16.ptr(8173, 8175, 1), new Range16.ptr(8189, 8190, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(42752, 42774, 1), new Range16.ptr(42784, 42785, 1), new Range16.ptr(42889, 42890, 1), new Range16.ptr(43867, 64434, 20567), new Range16.ptr(64435, 64449, 1), new Range16.ptr(65342, 65344, 2), new Range16.ptr(65507, 65507, 1)]), new sliceType$1([new Range32.ptr(127995, 127995, 1), new Range32.ptr(127996, 127999, 1)]), 3); + _Sm = new RangeTable.ptr(new sliceType([new Range16.ptr(43, 60, 17), new Range16.ptr(61, 62, 1), new Range16.ptr(124, 126, 2), new Range16.ptr(172, 177, 5), new Range16.ptr(215, 247, 32), new Range16.ptr(1014, 1542, 528), new Range16.ptr(1543, 1544, 1), new Range16.ptr(8260, 8274, 14), new Range16.ptr(8314, 8316, 1), new Range16.ptr(8330, 8332, 1), new Range16.ptr(8472, 8512, 40), new Range16.ptr(8513, 8516, 1), new Range16.ptr(8523, 8592, 69), new Range16.ptr(8593, 8596, 1), new Range16.ptr(8602, 8603, 1), new Range16.ptr(8608, 8614, 3), new Range16.ptr(8622, 8654, 32), new Range16.ptr(8655, 8658, 3), new Range16.ptr(8660, 8692, 32), new Range16.ptr(8693, 8959, 1), new Range16.ptr(8992, 8993, 1), new Range16.ptr(9084, 9115, 31), new Range16.ptr(9116, 9139, 1), new Range16.ptr(9180, 9185, 1), new Range16.ptr(9655, 9665, 10), new Range16.ptr(9720, 9727, 1), new Range16.ptr(9839, 10176, 337), new Range16.ptr(10177, 10180, 1), new Range16.ptr(10183, 10213, 1), new Range16.ptr(10224, 10239, 1), new Range16.ptr(10496, 10626, 1), new Range16.ptr(10649, 10711, 1), new Range16.ptr(10716, 10747, 1), new Range16.ptr(10750, 11007, 1), new Range16.ptr(11056, 11076, 1), new Range16.ptr(11079, 11084, 1), new Range16.ptr(64297, 65122, 825), new Range16.ptr(65124, 65126, 1), new Range16.ptr(65291, 65308, 17), new Range16.ptr(65309, 65310, 1), new Range16.ptr(65372, 65374, 2), new Range16.ptr(65506, 65513, 7), new Range16.ptr(65514, 65516, 1)]), new sliceType$1([new Range32.ptr(120513, 120539, 26), new Range32.ptr(120571, 120597, 26), new Range32.ptr(120629, 120655, 26), new Range32.ptr(120687, 120713, 26), new Range32.ptr(120745, 120771, 26), new Range32.ptr(126704, 126705, 1)]), 5); + _So = new RangeTable.ptr(new sliceType([new Range16.ptr(166, 169, 3), new Range16.ptr(174, 176, 2), new Range16.ptr(1154, 1421, 267), new Range16.ptr(1422, 1550, 128), new Range16.ptr(1551, 1758, 207), new Range16.ptr(1769, 1789, 20), new Range16.ptr(1790, 2038, 248), new Range16.ptr(2554, 2928, 374), new Range16.ptr(3059, 3064, 1), new Range16.ptr(3066, 3199, 133), new Range16.ptr(3407, 3449, 42), new Range16.ptr(3841, 3843, 1), new Range16.ptr(3859, 3861, 2), new Range16.ptr(3862, 3863, 1), new Range16.ptr(3866, 3871, 1), new Range16.ptr(3892, 3896, 2), new Range16.ptr(4030, 4037, 1), new Range16.ptr(4039, 4044, 1), new Range16.ptr(4046, 4047, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4254, 4255, 1), new Range16.ptr(5008, 5017, 1), new Range16.ptr(6464, 6622, 158), new Range16.ptr(6623, 6655, 1), new Range16.ptr(7009, 7018, 1), new Range16.ptr(7028, 7036, 1), new Range16.ptr(8448, 8449, 1), new Range16.ptr(8451, 8454, 1), new Range16.ptr(8456, 8457, 1), new Range16.ptr(8468, 8470, 2), new Range16.ptr(8471, 8478, 7), new Range16.ptr(8479, 8483, 1), new Range16.ptr(8485, 8489, 2), new Range16.ptr(8494, 8506, 12), new Range16.ptr(8507, 8522, 15), new Range16.ptr(8524, 8525, 1), new Range16.ptr(8527, 8586, 59), new Range16.ptr(8587, 8597, 10), new Range16.ptr(8598, 8601, 1), new Range16.ptr(8604, 8607, 1), new Range16.ptr(8609, 8610, 1), new Range16.ptr(8612, 8613, 1), new Range16.ptr(8615, 8621, 1), new Range16.ptr(8623, 8653, 1), new Range16.ptr(8656, 8657, 1), new Range16.ptr(8659, 8661, 2), new Range16.ptr(8662, 8691, 1), new Range16.ptr(8960, 8967, 1), new Range16.ptr(8972, 8991, 1), new Range16.ptr(8994, 9000, 1), new Range16.ptr(9003, 9083, 1), new Range16.ptr(9085, 9114, 1), new Range16.ptr(9140, 9179, 1), new Range16.ptr(9186, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9372, 9449, 1), new Range16.ptr(9472, 9654, 1), new Range16.ptr(9656, 9664, 1), new Range16.ptr(9666, 9719, 1), new Range16.ptr(9728, 9838, 1), new Range16.ptr(9840, 10087, 1), new Range16.ptr(10132, 10175, 1), new Range16.ptr(10240, 10495, 1), new Range16.ptr(11008, 11055, 1), new Range16.ptr(11077, 11078, 1), new Range16.ptr(11085, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11493, 11498, 1), new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12292, 12306, 14), new Range16.ptr(12307, 12320, 13), new Range16.ptr(12342, 12343, 1), new Range16.ptr(12350, 12351, 1), new Range16.ptr(12688, 12689, 1), new Range16.ptr(12694, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12842, 12871, 1), new Range16.ptr(12880, 12896, 16), new Range16.ptr(12897, 12927, 1), new Range16.ptr(12938, 12976, 1), new Range16.ptr(12992, 13054, 1), new Range16.ptr(13056, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42128, 42182, 1), new Range16.ptr(43048, 43051, 1), new Range16.ptr(43062, 43063, 1), new Range16.ptr(43065, 43639, 574), new Range16.ptr(43640, 43641, 1), new Range16.ptr(65021, 65508, 487), new Range16.ptr(65512, 65517, 5), new Range16.ptr(65518, 65532, 14), new Range16.ptr(65533, 65533, 1)]), new sliceType$1([new Range32.ptr(65847, 65847, 1), new Range32.ptr(65848, 65855, 1), new Range32.ptr(65913, 65929, 1), new Range32.ptr(65932, 65934, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(65952, 66000, 48), new Range32.ptr(66001, 66044, 1), new Range32.ptr(67703, 67704, 1), new Range32.ptr(68296, 71487, 3191), new Range32.ptr(92988, 92991, 1), new Range32.ptr(92997, 113820, 20823), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119140, 1), new Range32.ptr(119146, 119148, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119296, 119361, 1), new Range32.ptr(119365, 119552, 187), new Range32.ptr(119553, 119638, 1), new Range32.ptr(120832, 121343, 1), new Range32.ptr(121399, 121402, 1), new Range32.ptr(121453, 121460, 1), new Range32.ptr(121462, 121475, 1), new Range32.ptr(121477, 121478, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 127994, 1), new Range32.ptr(128000, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129488, 16), new Range32.ptr(129489, 129510, 1)]), 2); + _Z = new RangeTable.ptr(new sliceType([new Range16.ptr(32, 160, 128), new Range16.ptr(5760, 8192, 2432), new Range16.ptr(8193, 8202, 1), new Range16.ptr(8232, 8233, 1), new Range16.ptr(8239, 8287, 48), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 1); + _Zl = new RangeTable.ptr(new sliceType([new Range16.ptr(8232, 8232, 1)]), sliceType$1.nil, 0); + _Zp = new RangeTable.ptr(new sliceType([new Range16.ptr(8233, 8233, 1)]), sliceType$1.nil, 0); + _Zs = new RangeTable.ptr(new sliceType([new Range16.ptr(32, 160, 128), new Range16.ptr(5760, 8192, 2432), new Range16.ptr(8193, 8202, 1), new Range16.ptr(8239, 8287, 48), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 1); + $pkg.Cc = _Cc; + $pkg.Cf = _Cf; + $pkg.Co = _Co; + $pkg.Cs = _Cs; + $pkg.Digit = _Nd; + $pkg.Nd = _Nd; + $pkg.Letter = _L; + $pkg.L = _L; + $pkg.Lm = _Lm; + $pkg.Lo = _Lo; + $pkg.Ll = _Ll; + $pkg.M = _M; + $pkg.Mc = _Mc; + $pkg.Me = _Me; + $pkg.Mn = _Mn; + $pkg.Nl = _Nl; + $pkg.No = _No; + $pkg.N = _N; + $pkg.C = _C; + $pkg.Pc = _Pc; + $pkg.Pd = _Pd; + $pkg.Pe = _Pe; + $pkg.Pf = _Pf; + $pkg.Pi = _Pi; + $pkg.Po = _Po; + $pkg.Ps = _Ps; + $pkg.P = _P; + $pkg.Sc = _Sc; + $pkg.Sk = _Sk; + $pkg.Sm = _Sm; + $pkg.So = _So; + $pkg.Z = _Z; + $pkg.S = _S; + $pkg.PrintRanges = new sliceType$2([$pkg.L, $pkg.M, $pkg.N, $pkg.P, $pkg.S]); + $pkg.Lt = _Lt; + $pkg.Lu = _Lu; + $pkg.Zl = _Zl; + $pkg.Zp = _Zp; + $pkg.Zs = _Zs; + $pkg.Categories = $makeMap($String.keyFor, [{ k: "C", v: $pkg.C }, { k: "Cc", v: $pkg.Cc }, { k: "Cf", v: $pkg.Cf }, { k: "Co", v: $pkg.Co }, { k: "Cs", v: $pkg.Cs }, { k: "L", v: $pkg.L }, { k: "Ll", v: $pkg.Ll }, { k: "Lm", v: $pkg.Lm }, { k: "Lo", v: $pkg.Lo }, { k: "Lt", v: $pkg.Lt }, { k: "Lu", v: $pkg.Lu }, { k: "M", v: $pkg.M }, { k: "Mc", v: $pkg.Mc }, { k: "Me", v: $pkg.Me }, { k: "Mn", v: $pkg.Mn }, { k: "N", v: $pkg.N }, { k: "Nd", v: $pkg.Nd }, { k: "Nl", v: $pkg.Nl }, { k: "No", v: $pkg.No }, { k: "P", v: $pkg.P }, { k: "Pc", v: $pkg.Pc }, { k: "Pd", v: $pkg.Pd }, { k: "Pe", v: $pkg.Pe }, { k: "Pf", v: $pkg.Pf }, { k: "Pi", v: $pkg.Pi }, { k: "Po", v: $pkg.Po }, { k: "Ps", v: $pkg.Ps }, { k: "S", v: $pkg.S }, { k: "Sc", v: $pkg.Sc }, { k: "Sk", v: $pkg.Sk }, { k: "Sm", v: $pkg.Sm }, { k: "So", v: $pkg.So }, { k: "Z", v: $pkg.Z }, { k: "Zl", v: $pkg.Zl }, { k: "Zp", v: $pkg.Zp }, { k: "Zs", v: $pkg.Zs }]); + _Adlam = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(125184, 125258, 1), new Range32.ptr(125264, 125273, 1), new Range32.ptr(125278, 125279, 1)]), 0); + _Ahom = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71424, 71449, 1), new Range32.ptr(71453, 71467, 1), new Range32.ptr(71472, 71487, 1)]), 0); + _Anatolian_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(82944, 83526, 1)]), 0); + _Arabic = new RangeTable.ptr(new sliceType([new Range16.ptr(1536, 1540, 1), new Range16.ptr(1542, 1547, 1), new Range16.ptr(1549, 1562, 1), new Range16.ptr(1564, 1564, 1), new Range16.ptr(1566, 1566, 1), new Range16.ptr(1568, 1599, 1), new Range16.ptr(1601, 1610, 1), new Range16.ptr(1622, 1647, 1), new Range16.ptr(1649, 1756, 1), new Range16.ptr(1758, 1791, 1), new Range16.ptr(1872, 1919, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2303, 1), new Range16.ptr(64336, 64449, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65021, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1)]), new sliceType$1([new Range32.ptr(69216, 69246, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126500, 1), new Range32.ptr(126503, 126503, 1), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126521, 1), new Range32.ptr(126523, 126523, 1), new Range32.ptr(126530, 126530, 1), new Range32.ptr(126535, 126535, 1), new Range32.ptr(126537, 126537, 1), new Range32.ptr(126539, 126539, 1), new Range32.ptr(126541, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126548, 1), new Range32.ptr(126551, 126551, 1), new Range32.ptr(126553, 126553, 1), new Range32.ptr(126555, 126555, 1), new Range32.ptr(126557, 126557, 1), new Range32.ptr(126559, 126559, 1), new Range32.ptr(126561, 126562, 1), new Range32.ptr(126564, 126564, 1), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126590, 1), new Range32.ptr(126592, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(126704, 126705, 1)]), 0); + _Armenian = new RangeTable.ptr(new sliceType([new Range16.ptr(1329, 1366, 1), new Range16.ptr(1369, 1375, 1), new Range16.ptr(1377, 1415, 1), new Range16.ptr(1418, 1418, 1), new Range16.ptr(1421, 1423, 1), new Range16.ptr(64275, 64279, 1)]), sliceType$1.nil, 0); + _Avestan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68352, 68405, 1), new Range32.ptr(68409, 68415, 1)]), 0); + _Balinese = new RangeTable.ptr(new sliceType([new Range16.ptr(6912, 6987, 1), new Range16.ptr(6992, 7036, 1)]), sliceType$1.nil, 0); + _Bamum = new RangeTable.ptr(new sliceType([new Range16.ptr(42656, 42743, 1)]), new sliceType$1([new Range32.ptr(92160, 92728, 1)]), 0); + _Bassa_Vah = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92880, 92909, 1), new Range32.ptr(92912, 92917, 1)]), 0); + _Batak = new RangeTable.ptr(new sliceType([new Range16.ptr(7104, 7155, 1), new Range16.ptr(7164, 7167, 1)]), sliceType$1.nil, 0); + _Bengali = new RangeTable.ptr(new sliceType([new Range16.ptr(2432, 2435, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2482, 1), new Range16.ptr(2486, 2489, 1), new Range16.ptr(2492, 2500, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2510, 1), new Range16.ptr(2519, 2519, 1), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2531, 1), new Range16.ptr(2534, 2557, 1)]), sliceType$1.nil, 0); + _Bhaiksuki = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72758, 1), new Range32.ptr(72760, 72773, 1), new Range32.ptr(72784, 72812, 1)]), 0); + _Bopomofo = new RangeTable.ptr(new sliceType([new Range16.ptr(746, 747, 1), new Range16.ptr(12549, 12590, 1), new Range16.ptr(12704, 12730, 1)]), sliceType$1.nil, 0); + _Brahmi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69632, 69709, 1), new Range32.ptr(69714, 69743, 1), new Range32.ptr(69759, 69759, 1)]), 0); + _Braille = new RangeTable.ptr(new sliceType([new Range16.ptr(10240, 10495, 1)]), sliceType$1.nil, 0); + _Buginese = new RangeTable.ptr(new sliceType([new Range16.ptr(6656, 6683, 1), new Range16.ptr(6686, 6687, 1)]), sliceType$1.nil, 0); + _Buhid = new RangeTable.ptr(new sliceType([new Range16.ptr(5952, 5971, 1)]), sliceType$1.nil, 0); + _Canadian_Aboriginal = new RangeTable.ptr(new sliceType([new Range16.ptr(5120, 5759, 1), new Range16.ptr(6320, 6389, 1)]), sliceType$1.nil, 0); + _Carian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66208, 66256, 1)]), 0); + _Caucasian_Albanian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66864, 66915, 1), new Range32.ptr(66927, 66927, 1)]), 0); + _Chakma = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69888, 69940, 1), new Range32.ptr(69942, 69955, 1)]), 0); + _Cham = new RangeTable.ptr(new sliceType([new Range16.ptr(43520, 43574, 1), new Range16.ptr(43584, 43597, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(43612, 43615, 1)]), sliceType$1.nil, 0); + _Cherokee = new RangeTable.ptr(new sliceType([new Range16.ptr(5024, 5109, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(43888, 43967, 1)]), sliceType$1.nil, 0); + _Common = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 64, 1), new Range16.ptr(91, 96, 1), new Range16.ptr(123, 169, 1), new Range16.ptr(171, 185, 1), new Range16.ptr(187, 191, 1), new Range16.ptr(215, 215, 1), new Range16.ptr(247, 247, 1), new Range16.ptr(697, 735, 1), new Range16.ptr(741, 745, 1), new Range16.ptr(748, 767, 1), new Range16.ptr(884, 884, 1), new Range16.ptr(894, 894, 1), new Range16.ptr(901, 901, 1), new Range16.ptr(903, 903, 1), new Range16.ptr(1417, 1417, 1), new Range16.ptr(1541, 1541, 1), new Range16.ptr(1548, 1548, 1), new Range16.ptr(1563, 1563, 1), new Range16.ptr(1567, 1567, 1), new Range16.ptr(1600, 1600, 1), new Range16.ptr(1757, 1757, 1), new Range16.ptr(2274, 2274, 1), new Range16.ptr(2404, 2405, 1), new Range16.ptr(3647, 3647, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4347, 4347, 1), new Range16.ptr(5867, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6146, 6147, 1), new Range16.ptr(6149, 6149, 1), new Range16.ptr(7379, 7379, 1), new Range16.ptr(7393, 7393, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7411, 1), new Range16.ptr(7413, 7415, 1), new Range16.ptr(8192, 8203, 1), new Range16.ptr(8206, 8292, 1), new Range16.ptr(8294, 8304, 1), new Range16.ptr(8308, 8318, 1), new Range16.ptr(8320, 8334, 1), new Range16.ptr(8352, 8383, 1), new Range16.ptr(8448, 8485, 1), new Range16.ptr(8487, 8489, 1), new Range16.ptr(8492, 8497, 1), new Range16.ptr(8499, 8525, 1), new Range16.ptr(8527, 8543, 1), new Range16.ptr(8585, 8587, 1), new Range16.ptr(8592, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9312, 10239, 1), new Range16.ptr(10496, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11776, 11849, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12288, 12292, 1), new Range16.ptr(12294, 12294, 1), new Range16.ptr(12296, 12320, 1), new Range16.ptr(12336, 12343, 1), new Range16.ptr(12348, 12351, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(12448, 12448, 1), new Range16.ptr(12539, 12540, 1), new Range16.ptr(12688, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12832, 12895, 1), new Range16.ptr(12927, 13007, 1), new Range16.ptr(13144, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42752, 42785, 1), new Range16.ptr(42888, 42890, 1), new Range16.ptr(43056, 43065, 1), new Range16.ptr(43310, 43310, 1), new Range16.ptr(43471, 43471, 1), new Range16.ptr(43867, 43867, 1), new Range16.ptr(64830, 64831, 1), new Range16.ptr(65040, 65049, 1), new Range16.ptr(65072, 65106, 1), new Range16.ptr(65108, 65126, 1), new Range16.ptr(65128, 65131, 1), new Range16.ptr(65279, 65279, 1), new Range16.ptr(65281, 65312, 1), new Range16.ptr(65339, 65344, 1), new Range16.ptr(65371, 65381, 1), new Range16.ptr(65392, 65392, 1), new Range16.ptr(65438, 65439, 1), new Range16.ptr(65504, 65510, 1), new Range16.ptr(65512, 65518, 1), new Range16.ptr(65529, 65533, 1)]), new sliceType$1([new Range32.ptr(65792, 65794, 1), new Range32.ptr(65799, 65843, 1), new Range32.ptr(65847, 65855, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(66000, 66044, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(113824, 113827, 1), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119142, 1), new Range32.ptr(119146, 119162, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119552, 119638, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(119808, 119892, 1), new Range32.ptr(119894, 119964, 1), new Range32.ptr(119966, 119967, 1), new Range32.ptr(119970, 119970, 1), new Range32.ptr(119973, 119974, 1), new Range32.ptr(119977, 119980, 1), new Range32.ptr(119982, 119993, 1), new Range32.ptr(119995, 119995, 1), new Range32.ptr(119997, 120003, 1), new Range32.ptr(120005, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120094, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120134, 1), new Range32.ptr(120138, 120144, 1), new Range32.ptr(120146, 120485, 1), new Range32.ptr(120488, 120779, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127232, 127244, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127487, 1), new Range32.ptr(127489, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129472, 1), new Range32.ptr(129488, 129510, 1), new Range32.ptr(917505, 917505, 1), new Range32.ptr(917536, 917631, 1)]), 7); + _Coptic = new RangeTable.ptr(new sliceType([new Range16.ptr(994, 1007, 1), new Range16.ptr(11392, 11507, 1), new Range16.ptr(11513, 11519, 1)]), sliceType$1.nil, 0); + _Cuneiform = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(73728, 74649, 1), new Range32.ptr(74752, 74862, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(74880, 75075, 1)]), 0); + _Cypriot = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67592, 1), new Range32.ptr(67594, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67644, 1), new Range32.ptr(67647, 67647, 1)]), 0); + _Cyrillic = new RangeTable.ptr(new sliceType([new Range16.ptr(1024, 1156, 1), new Range16.ptr(1159, 1327, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7467, 7467, 1), new Range16.ptr(7544, 7544, 1), new Range16.ptr(11744, 11775, 1), new Range16.ptr(42560, 42655, 1), new Range16.ptr(65070, 65071, 1)]), sliceType$1.nil, 0); + _Deseret = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66560, 66639, 1)]), 0); + _Devanagari = new RangeTable.ptr(new sliceType([new Range16.ptr(2304, 2384, 1), new Range16.ptr(2387, 2403, 1), new Range16.ptr(2406, 2431, 1), new Range16.ptr(43232, 43261, 1)]), sliceType$1.nil, 0); + _Duployan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(113820, 113823, 1)]), 0); + _Egyptian_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(77824, 78894, 1)]), 0); + _Elbasan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66816, 66855, 1)]), 0); + _Ethiopic = new RangeTable.ptr(new sliceType([new Range16.ptr(4608, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4696, 1), new Range16.ptr(4698, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4800, 1), new Range16.ptr(4802, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4957, 4988, 1), new Range16.ptr(4992, 5017, 1), new Range16.ptr(11648, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(43777, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1)]), sliceType$1.nil, 0); + _Georgian = new RangeTable.ptr(new sliceType([new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4295, 1), new Range16.ptr(4301, 4301, 1), new Range16.ptr(4304, 4346, 1), new Range16.ptr(4348, 4351, 1), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11559, 1), new Range16.ptr(11565, 11565, 1)]), sliceType$1.nil, 0); + _Glagolitic = new RangeTable.ptr(new sliceType([new Range16.ptr(11264, 11310, 1), new Range16.ptr(11312, 11358, 1)]), new sliceType$1([new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1)]), 0); + _Gothic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66352, 66378, 1)]), 0); + _Grantha = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70400, 70403, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70460, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70480, 70480, 1), new Range32.ptr(70487, 70487, 1), new Range32.ptr(70493, 70499, 1), new Range32.ptr(70502, 70508, 1), new Range32.ptr(70512, 70516, 1)]), 0); + _Greek = new RangeTable.ptr(new sliceType([new Range16.ptr(880, 883, 1), new Range16.ptr(885, 887, 1), new Range16.ptr(890, 893, 1), new Range16.ptr(895, 895, 1), new Range16.ptr(900, 900, 1), new Range16.ptr(902, 902, 1), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 908, 1), new Range16.ptr(910, 929, 1), new Range16.ptr(931, 993, 1), new Range16.ptr(1008, 1023, 1), new Range16.ptr(7462, 7466, 1), new Range16.ptr(7517, 7521, 1), new Range16.ptr(7526, 7530, 1), new Range16.ptr(7615, 7615, 1), new Range16.ptr(7936, 7957, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7968, 8005, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8025, 8025, 1), new Range16.ptr(8027, 8027, 1), new Range16.ptr(8029, 8029, 1), new Range16.ptr(8031, 8061, 1), new Range16.ptr(8064, 8116, 1), new Range16.ptr(8118, 8132, 1), new Range16.ptr(8134, 8147, 1), new Range16.ptr(8150, 8155, 1), new Range16.ptr(8157, 8175, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8190, 1), new Range16.ptr(8486, 8486, 1), new Range16.ptr(43877, 43877, 1)]), new sliceType$1([new Range32.ptr(65856, 65934, 1), new Range32.ptr(65952, 65952, 1), new Range32.ptr(119296, 119365, 1)]), 0); + _Gujarati = new RangeTable.ptr(new sliceType([new Range16.ptr(2689, 2691, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2748, 2757, 1), new Range16.ptr(2759, 2761, 1), new Range16.ptr(2763, 2765, 1), new Range16.ptr(2768, 2768, 1), new Range16.ptr(2784, 2787, 1), new Range16.ptr(2790, 2801, 1), new Range16.ptr(2809, 2815, 1)]), sliceType$1.nil, 0); + _Gurmukhi = new RangeTable.ptr(new sliceType([new Range16.ptr(2561, 2563, 1), new Range16.ptr(2565, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2620, 2620, 1), new Range16.ptr(2622, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2641, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2654, 1), new Range16.ptr(2662, 2677, 1)]), sliceType$1.nil, 0); + _Han = new RangeTable.ptr(new sliceType([new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12293, 12293, 1), new Range16.ptr(12295, 12295, 1), new Range16.ptr(12321, 12329, 1), new Range16.ptr(12344, 12347, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1)]), new sliceType$1([new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 0); + _Hangul = new RangeTable.ptr(new sliceType([new Range16.ptr(4352, 4607, 1), new Range16.ptr(12334, 12335, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12896, 12926, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(65440, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), sliceType$1.nil, 0); + _Hanunoo = new RangeTable.ptr(new sliceType([new Range16.ptr(5920, 5940, 1)]), sliceType$1.nil, 0); + _Hatran = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67835, 67839, 1)]), 0); + _Hebrew = new RangeTable.ptr(new sliceType([new Range16.ptr(1425, 1479, 1), new Range16.ptr(1488, 1514, 1), new Range16.ptr(1520, 1524, 1), new Range16.ptr(64285, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64318, 1), new Range16.ptr(64320, 64321, 1), new Range16.ptr(64323, 64324, 1), new Range16.ptr(64326, 64335, 1)]), sliceType$1.nil, 0); + _Hiragana = new RangeTable.ptr(new sliceType([new Range16.ptr(12353, 12438, 1), new Range16.ptr(12445, 12447, 1)]), new sliceType$1([new Range32.ptr(110593, 110878, 1), new Range32.ptr(127488, 127488, 1)]), 0); + _Imperial_Aramaic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67648, 67669, 1), new Range32.ptr(67671, 67679, 1)]), 0); + _Inherited = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1157, 1158, 1), new Range16.ptr(1611, 1621, 1), new Range16.ptr(1648, 1648, 1), new Range16.ptr(2385, 2386, 1), new Range16.ptr(6832, 6846, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7392, 1), new Range16.ptr(7394, 7400, 1), new Range16.ptr(7405, 7405, 1), new Range16.ptr(7412, 7412, 1), new Range16.ptr(7416, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8204, 8205, 1), new Range16.ptr(8400, 8432, 1), new Range16.ptr(12330, 12333, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(65024, 65039, 1), new Range16.ptr(65056, 65069, 1)]), new sliceType$1([new Range32.ptr(66045, 66045, 1), new Range32.ptr(66272, 66272, 1), new Range32.ptr(119143, 119145, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(917760, 917999, 1)]), 0); + _Inscriptional_Pahlavi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68448, 68466, 1), new Range32.ptr(68472, 68479, 1)]), 0); + _Inscriptional_Parthian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68416, 68437, 1), new Range32.ptr(68440, 68447, 1)]), 0); + _Javanese = new RangeTable.ptr(new sliceType([new Range16.ptr(43392, 43469, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43486, 43487, 1)]), sliceType$1.nil, 0); + _Kaithi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69760, 69825, 1)]), 0); + _Kannada = new RangeTable.ptr(new sliceType([new Range16.ptr(3200, 3203, 1), new Range16.ptr(3205, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3260, 3268, 1), new Range16.ptr(3270, 3272, 1), new Range16.ptr(3274, 3277, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3294, 3294, 1), new Range16.ptr(3296, 3299, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3313, 3314, 1)]), sliceType$1.nil, 0); + _Katakana = new RangeTable.ptr(new sliceType([new Range16.ptr(12449, 12538, 1), new Range16.ptr(12541, 12543, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13008, 13054, 1), new Range16.ptr(13056, 13143, 1), new Range16.ptr(65382, 65391, 1), new Range16.ptr(65393, 65437, 1)]), new sliceType$1([new Range32.ptr(110592, 110592, 1)]), 0); + _Kayah_Li = new RangeTable.ptr(new sliceType([new Range16.ptr(43264, 43309, 1), new Range16.ptr(43311, 43311, 1)]), sliceType$1.nil, 0); + _Kharoshthi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68096, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68167, 1), new Range32.ptr(68176, 68184, 1)]), 0); + _Khmer = new RangeTable.ptr(new sliceType([new Range16.ptr(6016, 6109, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6624, 6655, 1)]), sliceType$1.nil, 0); + _Khojki = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70206, 1)]), 0); + _Khudawadi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70320, 70378, 1), new Range32.ptr(70384, 70393, 1)]), 0); + _Lao = new RangeTable.ptr(new sliceType([new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3716, 1), new Range16.ptr(3719, 3720, 1), new Range16.ptr(3722, 3722, 1), new Range16.ptr(3725, 3725, 1), new Range16.ptr(3732, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3749, 1), new Range16.ptr(3751, 3751, 1), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3769, 1), new Range16.ptr(3771, 3773, 1), new Range16.ptr(3776, 3780, 1), new Range16.ptr(3782, 3782, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3804, 3807, 1)]), sliceType$1.nil, 0); + _Latin = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(97, 122, 1), new Range16.ptr(170, 170, 1), new Range16.ptr(186, 186, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 246, 1), new Range16.ptr(248, 696, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(7424, 7461, 1), new Range16.ptr(7468, 7516, 1), new Range16.ptr(7522, 7525, 1), new Range16.ptr(7531, 7543, 1), new Range16.ptr(7545, 7614, 1), new Range16.ptr(7680, 7935, 1), new Range16.ptr(8305, 8305, 1), new Range16.ptr(8319, 8319, 1), new Range16.ptr(8336, 8348, 1), new Range16.ptr(8490, 8491, 1), new Range16.ptr(8498, 8498, 1), new Range16.ptr(8526, 8526, 1), new Range16.ptr(8544, 8584, 1), new Range16.ptr(11360, 11391, 1), new Range16.ptr(42786, 42887, 1), new Range16.ptr(42891, 42926, 1), new Range16.ptr(42928, 42935, 1), new Range16.ptr(42999, 43007, 1), new Range16.ptr(43824, 43866, 1), new Range16.ptr(43868, 43876, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(65313, 65338, 1), new Range16.ptr(65345, 65370, 1)]), sliceType$1.nil, 6); + _Lepcha = new RangeTable.ptr(new sliceType([new Range16.ptr(7168, 7223, 1), new Range16.ptr(7227, 7241, 1), new Range16.ptr(7245, 7247, 1)]), sliceType$1.nil, 0); + _Limbu = new RangeTable.ptr(new sliceType([new Range16.ptr(6400, 6430, 1), new Range16.ptr(6432, 6443, 1), new Range16.ptr(6448, 6459, 1), new Range16.ptr(6464, 6464, 1), new Range16.ptr(6468, 6479, 1)]), sliceType$1.nil, 0); + _Linear_A = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1)]), 0); + _Linear_B = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1)]), 0); + _Lisu = new RangeTable.ptr(new sliceType([new Range16.ptr(42192, 42239, 1)]), sliceType$1.nil, 0); + _Lycian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66176, 66204, 1)]), 0); + _Lydian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67872, 67897, 1), new Range32.ptr(67903, 67903, 1)]), 0); + _Mahajani = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69968, 70006, 1)]), 0); + _Malayalam = new RangeTable.ptr(new sliceType([new Range16.ptr(3328, 3331, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3396, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3407, 1), new Range16.ptr(3412, 3427, 1), new Range16.ptr(3430, 3455, 1)]), sliceType$1.nil, 0); + _Mandaic = new RangeTable.ptr(new sliceType([new Range16.ptr(2112, 2139, 1), new Range16.ptr(2142, 2142, 1)]), sliceType$1.nil, 0); + _Manichaean = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68288, 68326, 1), new Range32.ptr(68331, 68342, 1)]), 0); + _Marchen = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72816, 72847, 1), new Range32.ptr(72850, 72871, 1), new Range32.ptr(72873, 72886, 1)]), 0); + _Masaram_Gondi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73014, 1), new Range32.ptr(73018, 73018, 1), new Range32.ptr(73020, 73021, 1), new Range32.ptr(73023, 73031, 1), new Range32.ptr(73040, 73049, 1)]), 0); + _Meetei_Mayek = new RangeTable.ptr(new sliceType([new Range16.ptr(43744, 43766, 1), new Range16.ptr(43968, 44013, 1), new Range16.ptr(44016, 44025, 1)]), sliceType$1.nil, 0); + _Mende_Kikakui = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(124928, 125124, 1), new Range32.ptr(125127, 125142, 1)]), 0); + _Meroitic_Cursive = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68000, 68023, 1), new Range32.ptr(68028, 68047, 1), new Range32.ptr(68050, 68095, 1)]), 0); + _Meroitic_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67968, 67999, 1)]), 0); + _Miao = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94078, 1), new Range32.ptr(94095, 94111, 1)]), 0); + _Modi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71168, 71236, 1), new Range32.ptr(71248, 71257, 1)]), 0); + _Mongolian = new RangeTable.ptr(new sliceType([new Range16.ptr(6144, 6145, 1), new Range16.ptr(6148, 6148, 1), new Range16.ptr(6150, 6158, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6176, 6263, 1), new Range16.ptr(6272, 6314, 1)]), new sliceType$1([new Range32.ptr(71264, 71276, 1)]), 0); + _Mro = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92736, 92766, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(92782, 92783, 1)]), 0); + _Multani = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70280, 1), new Range32.ptr(70282, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70313, 1)]), 0); + _Myanmar = new RangeTable.ptr(new sliceType([new Range16.ptr(4096, 4255, 1), new Range16.ptr(43488, 43518, 1), new Range16.ptr(43616, 43647, 1)]), sliceType$1.nil, 0); + _Nabataean = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67712, 67742, 1), new Range32.ptr(67751, 67759, 1)]), 0); + _New_Tai_Lue = new RangeTable.ptr(new sliceType([new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6608, 6618, 1), new Range16.ptr(6622, 6623, 1)]), sliceType$1.nil, 0); + _Newa = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70656, 70745, 1), new Range32.ptr(70747, 70747, 1), new Range32.ptr(70749, 70749, 1)]), 0); + _Nko = new RangeTable.ptr(new sliceType([new Range16.ptr(1984, 2042, 1)]), sliceType$1.nil, 0); + _Nushu = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(94177, 94177, 1), new Range32.ptr(110960, 111355, 1)]), 0); + _Ogham = new RangeTable.ptr(new sliceType([new Range16.ptr(5760, 5788, 1)]), sliceType$1.nil, 0); + _Ol_Chiki = new RangeTable.ptr(new sliceType([new Range16.ptr(7248, 7295, 1)]), sliceType$1.nil, 0); + _Old_Hungarian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68736, 68786, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(68858, 68863, 1)]), 0); + _Old_Italic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66304, 66339, 1), new Range32.ptr(66349, 66351, 1)]), 0); + _Old_North_Arabian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68224, 68255, 1)]), 0); + _Old_Permic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66384, 66426, 1)]), 0); + _Old_Persian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66517, 1)]), 0); + _Old_South_Arabian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68192, 68223, 1)]), 0); + _Old_Turkic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68608, 68680, 1)]), 0); + _Oriya = new RangeTable.ptr(new sliceType([new Range16.ptr(2817, 2819, 1), new Range16.ptr(2821, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2876, 2884, 1), new Range16.ptr(2887, 2888, 1), new Range16.ptr(2891, 2893, 1), new Range16.ptr(2902, 2903, 1), new Range16.ptr(2908, 2909, 1), new Range16.ptr(2911, 2915, 1), new Range16.ptr(2918, 2935, 1)]), sliceType$1.nil, 0); + _Osage = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66736, 66771, 1), new Range32.ptr(66776, 66811, 1)]), 0); + _Osmanya = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66688, 66717, 1), new Range32.ptr(66720, 66729, 1)]), 0); + _Pahawh_Hmong = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92928, 92997, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1)]), 0); + _Palmyrene = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67680, 67711, 1)]), 0); + _Pau_Cin_Hau = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72384, 72440, 1)]), 0); + _Phags_Pa = new RangeTable.ptr(new sliceType([new Range16.ptr(43072, 43127, 1)]), sliceType$1.nil, 0); + _Phoenician = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67840, 67867, 1), new Range32.ptr(67871, 67871, 1)]), 0); + _Psalter_Pahlavi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68480, 68497, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(68521, 68527, 1)]), 0); + _Rejang = new RangeTable.ptr(new sliceType([new Range16.ptr(43312, 43347, 1), new Range16.ptr(43359, 43359, 1)]), sliceType$1.nil, 0); + _Runic = new RangeTable.ptr(new sliceType([new Range16.ptr(5792, 5866, 1), new Range16.ptr(5870, 5880, 1)]), sliceType$1.nil, 0); + _Samaritan = new RangeTable.ptr(new sliceType([new Range16.ptr(2048, 2093, 1), new Range16.ptr(2096, 2110, 1)]), sliceType$1.nil, 0); + _Saurashtra = new RangeTable.ptr(new sliceType([new Range16.ptr(43136, 43205, 1), new Range16.ptr(43214, 43225, 1)]), sliceType$1.nil, 0); + _Sharada = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70016, 70093, 1), new Range32.ptr(70096, 70111, 1)]), 0); + _Shavian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66640, 66687, 1)]), 0); + _Siddham = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71040, 71093, 1), new Range32.ptr(71096, 71133, 1)]), 0); + _SignWriting = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(120832, 121483, 1), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1)]), 0); + _Sinhala = new RangeTable.ptr(new sliceType([new Range16.ptr(3458, 3459, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3517, 1), new Range16.ptr(3520, 3526, 1), new Range16.ptr(3530, 3530, 1), new Range16.ptr(3535, 3540, 1), new Range16.ptr(3542, 3542, 1), new Range16.ptr(3544, 3551, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3570, 3572, 1)]), new sliceType$1([new Range32.ptr(70113, 70132, 1)]), 0); + _Sora_Sompeng = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69840, 69864, 1), new Range32.ptr(69872, 69881, 1)]), 0); + _Soyombo = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72272, 72323, 1), new Range32.ptr(72326, 72348, 1), new Range32.ptr(72350, 72354, 1)]), 0); + _Sundanese = new RangeTable.ptr(new sliceType([new Range16.ptr(7040, 7103, 1), new Range16.ptr(7360, 7367, 1)]), sliceType$1.nil, 0); + _Syloti_Nagri = new RangeTable.ptr(new sliceType([new Range16.ptr(43008, 43051, 1)]), sliceType$1.nil, 0); + _Syriac = new RangeTable.ptr(new sliceType([new Range16.ptr(1792, 1805, 1), new Range16.ptr(1807, 1866, 1), new Range16.ptr(1869, 1871, 1), new Range16.ptr(2144, 2154, 1)]), sliceType$1.nil, 0); + _Tagalog = new RangeTable.ptr(new sliceType([new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5908, 1)]), sliceType$1.nil, 0); + _Tagbanwa = new RangeTable.ptr(new sliceType([new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6002, 6003, 1)]), sliceType$1.nil, 0); + _Tai_Le = new RangeTable.ptr(new sliceType([new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1)]), sliceType$1.nil, 0); + _Tai_Tham = new RangeTable.ptr(new sliceType([new Range16.ptr(6688, 6750, 1), new Range16.ptr(6752, 6780, 1), new Range16.ptr(6783, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6816, 6829, 1)]), sliceType$1.nil, 0); + _Tai_Viet = new RangeTable.ptr(new sliceType([new Range16.ptr(43648, 43714, 1), new Range16.ptr(43739, 43743, 1)]), sliceType$1.nil, 0); + _Takri = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71296, 71351, 1), new Range32.ptr(71360, 71369, 1)]), 0); + _Tamil = new RangeTable.ptr(new sliceType([new Range16.ptr(2946, 2947, 1), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2972, 1), new Range16.ptr(2974, 2975, 1), new Range16.ptr(2979, 2980, 1), new Range16.ptr(2984, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3006, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3021, 1), new Range16.ptr(3024, 3024, 1), new Range16.ptr(3031, 3031, 1), new Range16.ptr(3046, 3066, 1)]), sliceType$1.nil, 0); + _Tangut = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(94176, 94176, 1), new Range32.ptr(94208, 100332, 1), new Range32.ptr(100352, 101106, 1)]), 0); + _Telugu = new RangeTable.ptr(new sliceType([new Range16.ptr(3072, 3075, 1), new Range16.ptr(3077, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3140, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3160, 3162, 1), new Range16.ptr(3168, 3171, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3192, 3199, 1)]), sliceType$1.nil, 0); + _Thaana = new RangeTable.ptr(new sliceType([new Range16.ptr(1920, 1969, 1)]), sliceType$1.nil, 0); + _Thai = new RangeTable.ptr(new sliceType([new Range16.ptr(3585, 3642, 1), new Range16.ptr(3648, 3675, 1)]), sliceType$1.nil, 0); + _Tibetan = new RangeTable.ptr(new sliceType([new Range16.ptr(3840, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3953, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4030, 4044, 1), new Range16.ptr(4046, 4052, 1), new Range16.ptr(4057, 4058, 1)]), sliceType$1.nil, 0); + _Tifinagh = new RangeTable.ptr(new sliceType([new Range16.ptr(11568, 11623, 1), new Range16.ptr(11631, 11632, 1), new Range16.ptr(11647, 11647, 1)]), sliceType$1.nil, 0); + _Tirhuta = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70784, 70855, 1), new Range32.ptr(70864, 70873, 1)]), 0); + _Ugaritic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66432, 66461, 1), new Range32.ptr(66463, 66463, 1)]), 0); + _Vai = new RangeTable.ptr(new sliceType([new Range16.ptr(42240, 42539, 1)]), sliceType$1.nil, 0); + _Warang_Citi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71840, 71922, 1), new Range32.ptr(71935, 71935, 1)]), 0); + _Yi = new RangeTable.ptr(new sliceType([new Range16.ptr(40960, 42124, 1), new Range16.ptr(42128, 42182, 1)]), sliceType$1.nil, 0); + _Zanabazar_Square = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72192, 72263, 1)]), 0); + $pkg.Adlam = _Adlam; + $pkg.Ahom = _Ahom; + $pkg.Anatolian_Hieroglyphs = _Anatolian_Hieroglyphs; + $pkg.Arabic = _Arabic; + $pkg.Armenian = _Armenian; + $pkg.Avestan = _Avestan; + $pkg.Balinese = _Balinese; + $pkg.Bamum = _Bamum; + $pkg.Bassa_Vah = _Bassa_Vah; + $pkg.Batak = _Batak; + $pkg.Bengali = _Bengali; + $pkg.Bhaiksuki = _Bhaiksuki; + $pkg.Bopomofo = _Bopomofo; + $pkg.Brahmi = _Brahmi; + $pkg.Braille = _Braille; + $pkg.Buginese = _Buginese; + $pkg.Buhid = _Buhid; + $pkg.Canadian_Aboriginal = _Canadian_Aboriginal; + $pkg.Carian = _Carian; + $pkg.Caucasian_Albanian = _Caucasian_Albanian; + $pkg.Chakma = _Chakma; + $pkg.Cham = _Cham; + $pkg.Cherokee = _Cherokee; + $pkg.Common = _Common; + $pkg.Coptic = _Coptic; + $pkg.Cuneiform = _Cuneiform; + $pkg.Cypriot = _Cypriot; + $pkg.Cyrillic = _Cyrillic; + $pkg.Deseret = _Deseret; + $pkg.Devanagari = _Devanagari; + $pkg.Duployan = _Duployan; + $pkg.Egyptian_Hieroglyphs = _Egyptian_Hieroglyphs; + $pkg.Elbasan = _Elbasan; + $pkg.Ethiopic = _Ethiopic; + $pkg.Georgian = _Georgian; + $pkg.Glagolitic = _Glagolitic; + $pkg.Gothic = _Gothic; + $pkg.Grantha = _Grantha; + $pkg.Greek = _Greek; + $pkg.Gujarati = _Gujarati; + $pkg.Gurmukhi = _Gurmukhi; + $pkg.Han = _Han; + $pkg.Hangul = _Hangul; + $pkg.Hanunoo = _Hanunoo; + $pkg.Hatran = _Hatran; + $pkg.Hebrew = _Hebrew; + $pkg.Hiragana = _Hiragana; + $pkg.Imperial_Aramaic = _Imperial_Aramaic; + $pkg.Inherited = _Inherited; + $pkg.Inscriptional_Pahlavi = _Inscriptional_Pahlavi; + $pkg.Inscriptional_Parthian = _Inscriptional_Parthian; + $pkg.Javanese = _Javanese; + $pkg.Kaithi = _Kaithi; + $pkg.Kannada = _Kannada; + $pkg.Katakana = _Katakana; + $pkg.Kayah_Li = _Kayah_Li; + $pkg.Kharoshthi = _Kharoshthi; + $pkg.Khmer = _Khmer; + $pkg.Khojki = _Khojki; + $pkg.Khudawadi = _Khudawadi; + $pkg.Lao = _Lao; + $pkg.Latin = _Latin; + $pkg.Lepcha = _Lepcha; + $pkg.Limbu = _Limbu; + $pkg.Linear_A = _Linear_A; + $pkg.Linear_B = _Linear_B; + $pkg.Lisu = _Lisu; + $pkg.Lycian = _Lycian; + $pkg.Lydian = _Lydian; + $pkg.Mahajani = _Mahajani; + $pkg.Malayalam = _Malayalam; + $pkg.Mandaic = _Mandaic; + $pkg.Manichaean = _Manichaean; + $pkg.Marchen = _Marchen; + $pkg.Masaram_Gondi = _Masaram_Gondi; + $pkg.Meetei_Mayek = _Meetei_Mayek; + $pkg.Mende_Kikakui = _Mende_Kikakui; + $pkg.Meroitic_Cursive = _Meroitic_Cursive; + $pkg.Meroitic_Hieroglyphs = _Meroitic_Hieroglyphs; + $pkg.Miao = _Miao; + $pkg.Modi = _Modi; + $pkg.Mongolian = _Mongolian; + $pkg.Mro = _Mro; + $pkg.Multani = _Multani; + $pkg.Myanmar = _Myanmar; + $pkg.Nabataean = _Nabataean; + $pkg.New_Tai_Lue = _New_Tai_Lue; + $pkg.Newa = _Newa; + $pkg.Nko = _Nko; + $pkg.Nushu = _Nushu; + $pkg.Ogham = _Ogham; + $pkg.Ol_Chiki = _Ol_Chiki; + $pkg.Old_Hungarian = _Old_Hungarian; + $pkg.Old_Italic = _Old_Italic; + $pkg.Old_North_Arabian = _Old_North_Arabian; + $pkg.Old_Permic = _Old_Permic; + $pkg.Old_Persian = _Old_Persian; + $pkg.Old_South_Arabian = _Old_South_Arabian; + $pkg.Old_Turkic = _Old_Turkic; + $pkg.Oriya = _Oriya; + $pkg.Osage = _Osage; + $pkg.Osmanya = _Osmanya; + $pkg.Pahawh_Hmong = _Pahawh_Hmong; + $pkg.Palmyrene = _Palmyrene; + $pkg.Pau_Cin_Hau = _Pau_Cin_Hau; + $pkg.Phags_Pa = _Phags_Pa; + $pkg.Phoenician = _Phoenician; + $pkg.Psalter_Pahlavi = _Psalter_Pahlavi; + $pkg.Rejang = _Rejang; + $pkg.Runic = _Runic; + $pkg.Samaritan = _Samaritan; + $pkg.Saurashtra = _Saurashtra; + $pkg.Sharada = _Sharada; + $pkg.Shavian = _Shavian; + $pkg.Siddham = _Siddham; + $pkg.SignWriting = _SignWriting; + $pkg.Sinhala = _Sinhala; + $pkg.Sora_Sompeng = _Sora_Sompeng; + $pkg.Soyombo = _Soyombo; + $pkg.Sundanese = _Sundanese; + $pkg.Syloti_Nagri = _Syloti_Nagri; + $pkg.Syriac = _Syriac; + $pkg.Tagalog = _Tagalog; + $pkg.Tagbanwa = _Tagbanwa; + $pkg.Tai_Le = _Tai_Le; + $pkg.Tai_Tham = _Tai_Tham; + $pkg.Tai_Viet = _Tai_Viet; + $pkg.Takri = _Takri; + $pkg.Tamil = _Tamil; + $pkg.Tangut = _Tangut; + $pkg.Telugu = _Telugu; + $pkg.Thaana = _Thaana; + $pkg.Thai = _Thai; + $pkg.Tibetan = _Tibetan; + $pkg.Tifinagh = _Tifinagh; + $pkg.Tirhuta = _Tirhuta; + $pkg.Ugaritic = _Ugaritic; + $pkg.Vai = _Vai; + $pkg.Warang_Citi = _Warang_Citi; + $pkg.Yi = _Yi; + $pkg.Zanabazar_Square = _Zanabazar_Square; + $pkg.Scripts = $makeMap($String.keyFor, [{ k: "Adlam", v: $pkg.Adlam }, { k: "Ahom", v: $pkg.Ahom }, { k: "Anatolian_Hieroglyphs", v: $pkg.Anatolian_Hieroglyphs }, { k: "Arabic", v: $pkg.Arabic }, { k: "Armenian", v: $pkg.Armenian }, { k: "Avestan", v: $pkg.Avestan }, { k: "Balinese", v: $pkg.Balinese }, { k: "Bamum", v: $pkg.Bamum }, { k: "Bassa_Vah", v: $pkg.Bassa_Vah }, { k: "Batak", v: $pkg.Batak }, { k: "Bengali", v: $pkg.Bengali }, { k: "Bhaiksuki", v: $pkg.Bhaiksuki }, { k: "Bopomofo", v: $pkg.Bopomofo }, { k: "Brahmi", v: $pkg.Brahmi }, { k: "Braille", v: $pkg.Braille }, { k: "Buginese", v: $pkg.Buginese }, { k: "Buhid", v: $pkg.Buhid }, { k: "Canadian_Aboriginal", v: $pkg.Canadian_Aboriginal }, { k: "Carian", v: $pkg.Carian }, { k: "Caucasian_Albanian", v: $pkg.Caucasian_Albanian }, { k: "Chakma", v: $pkg.Chakma }, { k: "Cham", v: $pkg.Cham }, { k: "Cherokee", v: $pkg.Cherokee }, { k: "Common", v: $pkg.Common }, { k: "Coptic", v: $pkg.Coptic }, { k: "Cuneiform", v: $pkg.Cuneiform }, { k: "Cypriot", v: $pkg.Cypriot }, { k: "Cyrillic", v: $pkg.Cyrillic }, { k: "Deseret", v: $pkg.Deseret }, { k: "Devanagari", v: $pkg.Devanagari }, { k: "Duployan", v: $pkg.Duployan }, { k: "Egyptian_Hieroglyphs", v: $pkg.Egyptian_Hieroglyphs }, { k: "Elbasan", v: $pkg.Elbasan }, { k: "Ethiopic", v: $pkg.Ethiopic }, { k: "Georgian", v: $pkg.Georgian }, { k: "Glagolitic", v: $pkg.Glagolitic }, { k: "Gothic", v: $pkg.Gothic }, { k: "Grantha", v: $pkg.Grantha }, { k: "Greek", v: $pkg.Greek }, { k: "Gujarati", v: $pkg.Gujarati }, { k: "Gurmukhi", v: $pkg.Gurmukhi }, { k: "Han", v: $pkg.Han }, { k: "Hangul", v: $pkg.Hangul }, { k: "Hanunoo", v: $pkg.Hanunoo }, { k: "Hatran", v: $pkg.Hatran }, { k: "Hebrew", v: $pkg.Hebrew }, { k: "Hiragana", v: $pkg.Hiragana }, { k: "Imperial_Aramaic", v: $pkg.Imperial_Aramaic }, { k: "Inherited", v: $pkg.Inherited }, { k: "Inscriptional_Pahlavi", v: $pkg.Inscriptional_Pahlavi }, { k: "Inscriptional_Parthian", v: $pkg.Inscriptional_Parthian }, { k: "Javanese", v: $pkg.Javanese }, { k: "Kaithi", v: $pkg.Kaithi }, { k: "Kannada", v: $pkg.Kannada }, { k: "Katakana", v: $pkg.Katakana }, { k: "Kayah_Li", v: $pkg.Kayah_Li }, { k: "Kharoshthi", v: $pkg.Kharoshthi }, { k: "Khmer", v: $pkg.Khmer }, { k: "Khojki", v: $pkg.Khojki }, { k: "Khudawadi", v: $pkg.Khudawadi }, { k: "Lao", v: $pkg.Lao }, { k: "Latin", v: $pkg.Latin }, { k: "Lepcha", v: $pkg.Lepcha }, { k: "Limbu", v: $pkg.Limbu }, { k: "Linear_A", v: $pkg.Linear_A }, { k: "Linear_B", v: $pkg.Linear_B }, { k: "Lisu", v: $pkg.Lisu }, { k: "Lycian", v: $pkg.Lycian }, { k: "Lydian", v: $pkg.Lydian }, { k: "Mahajani", v: $pkg.Mahajani }, { k: "Malayalam", v: $pkg.Malayalam }, { k: "Mandaic", v: $pkg.Mandaic }, { k: "Manichaean", v: $pkg.Manichaean }, { k: "Marchen", v: $pkg.Marchen }, { k: "Masaram_Gondi", v: $pkg.Masaram_Gondi }, { k: "Meetei_Mayek", v: $pkg.Meetei_Mayek }, { k: "Mende_Kikakui", v: $pkg.Mende_Kikakui }, { k: "Meroitic_Cursive", v: $pkg.Meroitic_Cursive }, { k: "Meroitic_Hieroglyphs", v: $pkg.Meroitic_Hieroglyphs }, { k: "Miao", v: $pkg.Miao }, { k: "Modi", v: $pkg.Modi }, { k: "Mongolian", v: $pkg.Mongolian }, { k: "Mro", v: $pkg.Mro }, { k: "Multani", v: $pkg.Multani }, { k: "Myanmar", v: $pkg.Myanmar }, { k: "Nabataean", v: $pkg.Nabataean }, { k: "New_Tai_Lue", v: $pkg.New_Tai_Lue }, { k: "Newa", v: $pkg.Newa }, { k: "Nko", v: $pkg.Nko }, { k: "Nushu", v: $pkg.Nushu }, { k: "Ogham", v: $pkg.Ogham }, { k: "Ol_Chiki", v: $pkg.Ol_Chiki }, { k: "Old_Hungarian", v: $pkg.Old_Hungarian }, { k: "Old_Italic", v: $pkg.Old_Italic }, { k: "Old_North_Arabian", v: $pkg.Old_North_Arabian }, { k: "Old_Permic", v: $pkg.Old_Permic }, { k: "Old_Persian", v: $pkg.Old_Persian }, { k: "Old_South_Arabian", v: $pkg.Old_South_Arabian }, { k: "Old_Turkic", v: $pkg.Old_Turkic }, { k: "Oriya", v: $pkg.Oriya }, { k: "Osage", v: $pkg.Osage }, { k: "Osmanya", v: $pkg.Osmanya }, { k: "Pahawh_Hmong", v: $pkg.Pahawh_Hmong }, { k: "Palmyrene", v: $pkg.Palmyrene }, { k: "Pau_Cin_Hau", v: $pkg.Pau_Cin_Hau }, { k: "Phags_Pa", v: $pkg.Phags_Pa }, { k: "Phoenician", v: $pkg.Phoenician }, { k: "Psalter_Pahlavi", v: $pkg.Psalter_Pahlavi }, { k: "Rejang", v: $pkg.Rejang }, { k: "Runic", v: $pkg.Runic }, { k: "Samaritan", v: $pkg.Samaritan }, { k: "Saurashtra", v: $pkg.Saurashtra }, { k: "Sharada", v: $pkg.Sharada }, { k: "Shavian", v: $pkg.Shavian }, { k: "Siddham", v: $pkg.Siddham }, { k: "SignWriting", v: $pkg.SignWriting }, { k: "Sinhala", v: $pkg.Sinhala }, { k: "Sora_Sompeng", v: $pkg.Sora_Sompeng }, { k: "Soyombo", v: $pkg.Soyombo }, { k: "Sundanese", v: $pkg.Sundanese }, { k: "Syloti_Nagri", v: $pkg.Syloti_Nagri }, { k: "Syriac", v: $pkg.Syriac }, { k: "Tagalog", v: $pkg.Tagalog }, { k: "Tagbanwa", v: $pkg.Tagbanwa }, { k: "Tai_Le", v: $pkg.Tai_Le }, { k: "Tai_Tham", v: $pkg.Tai_Tham }, { k: "Tai_Viet", v: $pkg.Tai_Viet }, { k: "Takri", v: $pkg.Takri }, { k: "Tamil", v: $pkg.Tamil }, { k: "Tangut", v: $pkg.Tangut }, { k: "Telugu", v: $pkg.Telugu }, { k: "Thaana", v: $pkg.Thaana }, { k: "Thai", v: $pkg.Thai }, { k: "Tibetan", v: $pkg.Tibetan }, { k: "Tifinagh", v: $pkg.Tifinagh }, { k: "Tirhuta", v: $pkg.Tirhuta }, { k: "Ugaritic", v: $pkg.Ugaritic }, { k: "Vai", v: $pkg.Vai }, { k: "Warang_Citi", v: $pkg.Warang_Citi }, { k: "Yi", v: $pkg.Yi }, { k: "Zanabazar_Square", v: $pkg.Zanabazar_Square }]); + _CaseRanges = new sliceType$3([new CaseRange.ptr(65, 90, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(97, 122, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(181, 181, $toNativeArray($kindInt32, [743, 0, 743])), new CaseRange.ptr(192, 214, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(216, 222, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(224, 246, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(248, 254, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(255, 255, $toNativeArray($kindInt32, [121, 0, 121])), new CaseRange.ptr(256, 303, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(304, 304, $toNativeArray($kindInt32, [0, -199, 0])), new CaseRange.ptr(305, 305, $toNativeArray($kindInt32, [-232, 0, -232])), new CaseRange.ptr(306, 311, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(313, 328, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(330, 375, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(376, 376, $toNativeArray($kindInt32, [0, -121, 0])), new CaseRange.ptr(377, 382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(383, 383, $toNativeArray($kindInt32, [-300, 0, -300])), new CaseRange.ptr(384, 384, $toNativeArray($kindInt32, [195, 0, 195])), new CaseRange.ptr(385, 385, $toNativeArray($kindInt32, [0, 210, 0])), new CaseRange.ptr(386, 389, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(390, 390, $toNativeArray($kindInt32, [0, 206, 0])), new CaseRange.ptr(391, 392, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(393, 394, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(395, 396, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(398, 398, $toNativeArray($kindInt32, [0, 79, 0])), new CaseRange.ptr(399, 399, $toNativeArray($kindInt32, [0, 202, 0])), new CaseRange.ptr(400, 400, $toNativeArray($kindInt32, [0, 203, 0])), new CaseRange.ptr(401, 402, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(403, 403, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(404, 404, $toNativeArray($kindInt32, [0, 207, 0])), new CaseRange.ptr(405, 405, $toNativeArray($kindInt32, [97, 0, 97])), new CaseRange.ptr(406, 406, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(407, 407, $toNativeArray($kindInt32, [0, 209, 0])), new CaseRange.ptr(408, 409, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(410, 410, $toNativeArray($kindInt32, [163, 0, 163])), new CaseRange.ptr(412, 412, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(413, 413, $toNativeArray($kindInt32, [0, 213, 0])), new CaseRange.ptr(414, 414, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(415, 415, $toNativeArray($kindInt32, [0, 214, 0])), new CaseRange.ptr(416, 421, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(422, 422, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(423, 424, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(425, 425, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(428, 429, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(430, 430, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(431, 432, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(433, 434, $toNativeArray($kindInt32, [0, 217, 0])), new CaseRange.ptr(435, 438, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(439, 439, $toNativeArray($kindInt32, [0, 219, 0])), new CaseRange.ptr(440, 441, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(444, 445, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(447, 447, $toNativeArray($kindInt32, [56, 0, 56])), new CaseRange.ptr(452, 452, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(453, 453, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(454, 454, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(455, 455, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(456, 456, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(457, 457, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(458, 458, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(459, 459, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(460, 460, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(461, 476, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(477, 477, $toNativeArray($kindInt32, [-79, 0, -79])), new CaseRange.ptr(478, 495, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(497, 497, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(498, 498, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(499, 499, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(500, 501, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(502, 502, $toNativeArray($kindInt32, [0, -97, 0])), new CaseRange.ptr(503, 503, $toNativeArray($kindInt32, [0, -56, 0])), new CaseRange.ptr(504, 543, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(544, 544, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(546, 563, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(570, 570, $toNativeArray($kindInt32, [0, 10795, 0])), new CaseRange.ptr(571, 572, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(573, 573, $toNativeArray($kindInt32, [0, -163, 0])), new CaseRange.ptr(574, 574, $toNativeArray($kindInt32, [0, 10792, 0])), new CaseRange.ptr(575, 576, $toNativeArray($kindInt32, [10815, 0, 10815])), new CaseRange.ptr(577, 578, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(579, 579, $toNativeArray($kindInt32, [0, -195, 0])), new CaseRange.ptr(580, 580, $toNativeArray($kindInt32, [0, 69, 0])), new CaseRange.ptr(581, 581, $toNativeArray($kindInt32, [0, 71, 0])), new CaseRange.ptr(582, 591, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(592, 592, $toNativeArray($kindInt32, [10783, 0, 10783])), new CaseRange.ptr(593, 593, $toNativeArray($kindInt32, [10780, 0, 10780])), new CaseRange.ptr(594, 594, $toNativeArray($kindInt32, [10782, 0, 10782])), new CaseRange.ptr(595, 595, $toNativeArray($kindInt32, [-210, 0, -210])), new CaseRange.ptr(596, 596, $toNativeArray($kindInt32, [-206, 0, -206])), new CaseRange.ptr(598, 599, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(601, 601, $toNativeArray($kindInt32, [-202, 0, -202])), new CaseRange.ptr(603, 603, $toNativeArray($kindInt32, [-203, 0, -203])), new CaseRange.ptr(604, 604, $toNativeArray($kindInt32, [42319, 0, 42319])), new CaseRange.ptr(608, 608, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(609, 609, $toNativeArray($kindInt32, [42315, 0, 42315])), new CaseRange.ptr(611, 611, $toNativeArray($kindInt32, [-207, 0, -207])), new CaseRange.ptr(613, 613, $toNativeArray($kindInt32, [42280, 0, 42280])), new CaseRange.ptr(614, 614, $toNativeArray($kindInt32, [42308, 0, 42308])), new CaseRange.ptr(616, 616, $toNativeArray($kindInt32, [-209, 0, -209])), new CaseRange.ptr(617, 617, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(618, 618, $toNativeArray($kindInt32, [42308, 0, 42308])), new CaseRange.ptr(619, 619, $toNativeArray($kindInt32, [10743, 0, 10743])), new CaseRange.ptr(620, 620, $toNativeArray($kindInt32, [42305, 0, 42305])), new CaseRange.ptr(623, 623, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(625, 625, $toNativeArray($kindInt32, [10749, 0, 10749])), new CaseRange.ptr(626, 626, $toNativeArray($kindInt32, [-213, 0, -213])), new CaseRange.ptr(629, 629, $toNativeArray($kindInt32, [-214, 0, -214])), new CaseRange.ptr(637, 637, $toNativeArray($kindInt32, [10727, 0, 10727])), new CaseRange.ptr(640, 640, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(643, 643, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(647, 647, $toNativeArray($kindInt32, [42282, 0, 42282])), new CaseRange.ptr(648, 648, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(649, 649, $toNativeArray($kindInt32, [-69, 0, -69])), new CaseRange.ptr(650, 651, $toNativeArray($kindInt32, [-217, 0, -217])), new CaseRange.ptr(652, 652, $toNativeArray($kindInt32, [-71, 0, -71])), new CaseRange.ptr(658, 658, $toNativeArray($kindInt32, [-219, 0, -219])), new CaseRange.ptr(669, 669, $toNativeArray($kindInt32, [42261, 0, 42261])), new CaseRange.ptr(670, 670, $toNativeArray($kindInt32, [42258, 0, 42258])), new CaseRange.ptr(837, 837, $toNativeArray($kindInt32, [84, 0, 84])), new CaseRange.ptr(880, 883, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(886, 887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(891, 893, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(895, 895, $toNativeArray($kindInt32, [0, 116, 0])), new CaseRange.ptr(902, 902, $toNativeArray($kindInt32, [0, 38, 0])), new CaseRange.ptr(904, 906, $toNativeArray($kindInt32, [0, 37, 0])), new CaseRange.ptr(908, 908, $toNativeArray($kindInt32, [0, 64, 0])), new CaseRange.ptr(910, 911, $toNativeArray($kindInt32, [0, 63, 0])), new CaseRange.ptr(913, 929, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(931, 939, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(940, 940, $toNativeArray($kindInt32, [-38, 0, -38])), new CaseRange.ptr(941, 943, $toNativeArray($kindInt32, [-37, 0, -37])), new CaseRange.ptr(945, 961, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(962, 962, $toNativeArray($kindInt32, [-31, 0, -31])), new CaseRange.ptr(963, 971, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(972, 972, $toNativeArray($kindInt32, [-64, 0, -64])), new CaseRange.ptr(973, 974, $toNativeArray($kindInt32, [-63, 0, -63])), new CaseRange.ptr(975, 975, $toNativeArray($kindInt32, [0, 8, 0])), new CaseRange.ptr(976, 976, $toNativeArray($kindInt32, [-62, 0, -62])), new CaseRange.ptr(977, 977, $toNativeArray($kindInt32, [-57, 0, -57])), new CaseRange.ptr(981, 981, $toNativeArray($kindInt32, [-47, 0, -47])), new CaseRange.ptr(982, 982, $toNativeArray($kindInt32, [-54, 0, -54])), new CaseRange.ptr(983, 983, $toNativeArray($kindInt32, [-8, 0, -8])), new CaseRange.ptr(984, 1007, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1008, 1008, $toNativeArray($kindInt32, [-86, 0, -86])), new CaseRange.ptr(1009, 1009, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1010, 1010, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(1011, 1011, $toNativeArray($kindInt32, [-116, 0, -116])), new CaseRange.ptr(1012, 1012, $toNativeArray($kindInt32, [0, -60, 0])), new CaseRange.ptr(1013, 1013, $toNativeArray($kindInt32, [-96, 0, -96])), new CaseRange.ptr(1015, 1016, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1017, 1017, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(1018, 1019, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1021, 1023, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(1024, 1039, $toNativeArray($kindInt32, [0, 80, 0])), new CaseRange.ptr(1040, 1071, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(1072, 1103, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(1104, 1119, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1120, 1153, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1162, 1215, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1216, 1216, $toNativeArray($kindInt32, [0, 15, 0])), new CaseRange.ptr(1217, 1230, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1231, 1231, $toNativeArray($kindInt32, [-15, 0, -15])), new CaseRange.ptr(1232, 1327, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1329, 1366, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(1377, 1414, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(4256, 4293, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4295, 4295, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4301, 4301, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(5024, 5103, $toNativeArray($kindInt32, [0, 38864, 0])), new CaseRange.ptr(5104, 5109, $toNativeArray($kindInt32, [0, 8, 0])), new CaseRange.ptr(5112, 5117, $toNativeArray($kindInt32, [-8, 0, -8])), new CaseRange.ptr(7296, 7296, $toNativeArray($kindInt32, [-6254, 0, -6254])), new CaseRange.ptr(7297, 7297, $toNativeArray($kindInt32, [-6253, 0, -6253])), new CaseRange.ptr(7298, 7298, $toNativeArray($kindInt32, [-6244, 0, -6244])), new CaseRange.ptr(7299, 7300, $toNativeArray($kindInt32, [-6242, 0, -6242])), new CaseRange.ptr(7301, 7301, $toNativeArray($kindInt32, [-6243, 0, -6243])), new CaseRange.ptr(7302, 7302, $toNativeArray($kindInt32, [-6236, 0, -6236])), new CaseRange.ptr(7303, 7303, $toNativeArray($kindInt32, [-6181, 0, -6181])), new CaseRange.ptr(7304, 7304, $toNativeArray($kindInt32, [35266, 0, 35266])), new CaseRange.ptr(7545, 7545, $toNativeArray($kindInt32, [35332, 0, 35332])), new CaseRange.ptr(7549, 7549, $toNativeArray($kindInt32, [3814, 0, 3814])), new CaseRange.ptr(7680, 7829, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7835, 7835, $toNativeArray($kindInt32, [-59, 0, -59])), new CaseRange.ptr(7838, 7838, $toNativeArray($kindInt32, [0, -7615, 0])), new CaseRange.ptr(7840, 7935, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7936, 7943, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7944, 7951, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7952, 7957, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7960, 7965, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7968, 7975, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7976, 7983, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7984, 7991, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7992, 7999, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8000, 8005, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8008, 8013, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8017, 8017, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8019, 8019, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8021, 8021, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8023, 8023, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8025, 8025, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8027, 8027, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8029, 8029, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8031, 8031, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8032, 8039, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8040, 8047, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8048, 8049, $toNativeArray($kindInt32, [74, 0, 74])), new CaseRange.ptr(8050, 8053, $toNativeArray($kindInt32, [86, 0, 86])), new CaseRange.ptr(8054, 8055, $toNativeArray($kindInt32, [100, 0, 100])), new CaseRange.ptr(8056, 8057, $toNativeArray($kindInt32, [128, 0, 128])), new CaseRange.ptr(8058, 8059, $toNativeArray($kindInt32, [112, 0, 112])), new CaseRange.ptr(8060, 8061, $toNativeArray($kindInt32, [126, 0, 126])), new CaseRange.ptr(8064, 8071, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8072, 8079, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8080, 8087, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8088, 8095, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8096, 8103, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8104, 8111, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8112, 8113, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8115, 8115, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8120, 8121, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8122, 8123, $toNativeArray($kindInt32, [0, -74, 0])), new CaseRange.ptr(8124, 8124, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8126, 8126, $toNativeArray($kindInt32, [-7205, 0, -7205])), new CaseRange.ptr(8131, 8131, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8136, 8139, $toNativeArray($kindInt32, [0, -86, 0])), new CaseRange.ptr(8140, 8140, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8144, 8145, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8152, 8153, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8154, 8155, $toNativeArray($kindInt32, [0, -100, 0])), new CaseRange.ptr(8160, 8161, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8165, 8165, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(8168, 8169, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8170, 8171, $toNativeArray($kindInt32, [0, -112, 0])), new CaseRange.ptr(8172, 8172, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(8179, 8179, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8184, 8185, $toNativeArray($kindInt32, [0, -128, 0])), new CaseRange.ptr(8186, 8187, $toNativeArray($kindInt32, [0, -126, 0])), new CaseRange.ptr(8188, 8188, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8486, 8486, $toNativeArray($kindInt32, [0, -7517, 0])), new CaseRange.ptr(8490, 8490, $toNativeArray($kindInt32, [0, -8383, 0])), new CaseRange.ptr(8491, 8491, $toNativeArray($kindInt32, [0, -8262, 0])), new CaseRange.ptr(8498, 8498, $toNativeArray($kindInt32, [0, 28, 0])), new CaseRange.ptr(8526, 8526, $toNativeArray($kindInt32, [-28, 0, -28])), new CaseRange.ptr(8544, 8559, $toNativeArray($kindInt32, [0, 16, 0])), new CaseRange.ptr(8560, 8575, $toNativeArray($kindInt32, [-16, 0, -16])), new CaseRange.ptr(8579, 8580, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(9398, 9423, $toNativeArray($kindInt32, [0, 26, 0])), new CaseRange.ptr(9424, 9449, $toNativeArray($kindInt32, [-26, 0, -26])), new CaseRange.ptr(11264, 11310, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(11312, 11358, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(11360, 11361, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11362, 11362, $toNativeArray($kindInt32, [0, -10743, 0])), new CaseRange.ptr(11363, 11363, $toNativeArray($kindInt32, [0, -3814, 0])), new CaseRange.ptr(11364, 11364, $toNativeArray($kindInt32, [0, -10727, 0])), new CaseRange.ptr(11365, 11365, $toNativeArray($kindInt32, [-10795, 0, -10795])), new CaseRange.ptr(11366, 11366, $toNativeArray($kindInt32, [-10792, 0, -10792])), new CaseRange.ptr(11367, 11372, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11373, 11373, $toNativeArray($kindInt32, [0, -10780, 0])), new CaseRange.ptr(11374, 11374, $toNativeArray($kindInt32, [0, -10749, 0])), new CaseRange.ptr(11375, 11375, $toNativeArray($kindInt32, [0, -10783, 0])), new CaseRange.ptr(11376, 11376, $toNativeArray($kindInt32, [0, -10782, 0])), new CaseRange.ptr(11378, 11379, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11381, 11382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11390, 11391, $toNativeArray($kindInt32, [0, -10815, 0])), new CaseRange.ptr(11392, 11491, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11499, 11502, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11506, 11507, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11520, 11557, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11559, 11559, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11565, 11565, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(42560, 42605, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42624, 42651, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42786, 42799, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42802, 42863, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42873, 42876, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42877, 42877, $toNativeArray($kindInt32, [0, -35332, 0])), new CaseRange.ptr(42878, 42887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42891, 42892, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42893, 42893, $toNativeArray($kindInt32, [0, -42280, 0])), new CaseRange.ptr(42896, 42899, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42902, 42921, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42922, 42922, $toNativeArray($kindInt32, [0, -42308, 0])), new CaseRange.ptr(42923, 42923, $toNativeArray($kindInt32, [0, -42319, 0])), new CaseRange.ptr(42924, 42924, $toNativeArray($kindInt32, [0, -42315, 0])), new CaseRange.ptr(42925, 42925, $toNativeArray($kindInt32, [0, -42305, 0])), new CaseRange.ptr(42926, 42926, $toNativeArray($kindInt32, [0, -42308, 0])), new CaseRange.ptr(42928, 42928, $toNativeArray($kindInt32, [0, -42258, 0])), new CaseRange.ptr(42929, 42929, $toNativeArray($kindInt32, [0, -42282, 0])), new CaseRange.ptr(42930, 42930, $toNativeArray($kindInt32, [0, -42261, 0])), new CaseRange.ptr(42931, 42931, $toNativeArray($kindInt32, [0, 928, 0])), new CaseRange.ptr(42932, 42935, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(43859, 43859, $toNativeArray($kindInt32, [-928, 0, -928])), new CaseRange.ptr(43888, 43967, $toNativeArray($kindInt32, [-38864, 0, -38864])), new CaseRange.ptr(65313, 65338, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(65345, 65370, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(66560, 66599, $toNativeArray($kindInt32, [0, 40, 0])), new CaseRange.ptr(66600, 66639, $toNativeArray($kindInt32, [-40, 0, -40])), new CaseRange.ptr(66736, 66771, $toNativeArray($kindInt32, [0, 40, 0])), new CaseRange.ptr(66776, 66811, $toNativeArray($kindInt32, [-40, 0, -40])), new CaseRange.ptr(68736, 68786, $toNativeArray($kindInt32, [0, 64, 0])), new CaseRange.ptr(68800, 68850, $toNativeArray($kindInt32, [-64, 0, -64])), new CaseRange.ptr(71840, 71871, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(71872, 71903, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(125184, 125217, $toNativeArray($kindInt32, [0, 34, 0])), new CaseRange.ptr(125218, 125251, $toNativeArray($kindInt32, [-34, 0, -34]))]); + $pkg.CaseRanges = _CaseRanges; + properties = $toNativeArray($kindUint8, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 144, 130, 130, 130, 136, 130, 130, 130, 130, 130, 130, 136, 130, 130, 130, 130, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 130, 130, 136, 136, 136, 130, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 130, 130, 130, 136, 130, 136, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 130, 136, 130, 136, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 130, 136, 136, 136, 136, 136, 130, 136, 136, 224, 130, 136, 0, 136, 136, 136, 136, 132, 132, 136, 192, 130, 130, 136, 132, 224, 130, 132, 132, 132, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 136, 160, 160, 160, 160, 160, 160, 160, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 136, 192, 192, 192, 192, 192, 192, 192, 192]); + asciiFold = $toNativeArray($kindUint16, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95, 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 8490, 76, 77, 78, 79, 80, 81, 82, 383, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127]); + caseOrbit = new sliceType$4([new foldPair.ptr(75, 107), new foldPair.ptr(83, 115), new foldPair.ptr(107, 8490), new foldPair.ptr(115, 383), new foldPair.ptr(181, 924), new foldPair.ptr(197, 229), new foldPair.ptr(223, 7838), new foldPair.ptr(229, 8491), new foldPair.ptr(304, 304), new foldPair.ptr(305, 305), new foldPair.ptr(383, 83), new foldPair.ptr(452, 453), new foldPair.ptr(453, 454), new foldPair.ptr(454, 452), new foldPair.ptr(455, 456), new foldPair.ptr(456, 457), new foldPair.ptr(457, 455), new foldPair.ptr(458, 459), new foldPair.ptr(459, 460), new foldPair.ptr(460, 458), new foldPair.ptr(497, 498), new foldPair.ptr(498, 499), new foldPair.ptr(499, 497), new foldPair.ptr(837, 921), new foldPair.ptr(914, 946), new foldPair.ptr(917, 949), new foldPair.ptr(920, 952), new foldPair.ptr(921, 953), new foldPair.ptr(922, 954), new foldPair.ptr(924, 956), new foldPair.ptr(928, 960), new foldPair.ptr(929, 961), new foldPair.ptr(931, 962), new foldPair.ptr(934, 966), new foldPair.ptr(937, 969), new foldPair.ptr(946, 976), new foldPair.ptr(949, 1013), new foldPair.ptr(952, 977), new foldPair.ptr(953, 8126), new foldPair.ptr(954, 1008), new foldPair.ptr(956, 181), new foldPair.ptr(960, 982), new foldPair.ptr(961, 1009), new foldPair.ptr(962, 963), new foldPair.ptr(963, 931), new foldPair.ptr(966, 981), new foldPair.ptr(969, 8486), new foldPair.ptr(976, 914), new foldPair.ptr(977, 1012), new foldPair.ptr(981, 934), new foldPair.ptr(982, 928), new foldPair.ptr(1008, 922), new foldPair.ptr(1009, 929), new foldPair.ptr(1012, 920), new foldPair.ptr(1013, 917), new foldPair.ptr(1042, 1074), new foldPair.ptr(1044, 1076), new foldPair.ptr(1054, 1086), new foldPair.ptr(1057, 1089), new foldPair.ptr(1058, 1090), new foldPair.ptr(1066, 1098), new foldPair.ptr(1074, 7296), new foldPair.ptr(1076, 7297), new foldPair.ptr(1086, 7298), new foldPair.ptr(1089, 7299), new foldPair.ptr(1090, 7300), new foldPair.ptr(1098, 7302), new foldPair.ptr(1122, 1123), new foldPair.ptr(1123, 7303), new foldPair.ptr(7296, 1042), new foldPair.ptr(7297, 1044), new foldPair.ptr(7298, 1054), new foldPair.ptr(7299, 1057), new foldPair.ptr(7300, 7301), new foldPair.ptr(7301, 1058), new foldPair.ptr(7302, 1066), new foldPair.ptr(7303, 1122), new foldPair.ptr(7304, 42570), new foldPair.ptr(7776, 7777), new foldPair.ptr(7777, 7835), new foldPair.ptr(7835, 7776), new foldPair.ptr(7838, 223), new foldPair.ptr(8126, 837), new foldPair.ptr(8486, 937), new foldPair.ptr(8490, 75), new foldPair.ptr(8491, 197), new foldPair.ptr(42570, 42571), new foldPair.ptr(42571, 7304)]); + foldL = new RangeTable.ptr(new sliceType([new Range16.ptr(837, 837, 1)]), sliceType$1.nil, 0); + foldLl = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 222, 1), new Range16.ptr(256, 302, 2), new Range16.ptr(306, 310, 2), new Range16.ptr(313, 327, 2), new Range16.ptr(330, 376, 2), new Range16.ptr(377, 381, 2), new Range16.ptr(385, 386, 1), new Range16.ptr(388, 390, 2), new Range16.ptr(391, 393, 2), new Range16.ptr(394, 395, 1), new Range16.ptr(398, 401, 1), new Range16.ptr(403, 404, 1), new Range16.ptr(406, 408, 1), new Range16.ptr(412, 413, 1), new Range16.ptr(415, 416, 1), new Range16.ptr(418, 422, 2), new Range16.ptr(423, 425, 2), new Range16.ptr(428, 430, 2), new Range16.ptr(431, 433, 2), new Range16.ptr(434, 435, 1), new Range16.ptr(437, 439, 2), new Range16.ptr(440, 444, 4), new Range16.ptr(452, 453, 1), new Range16.ptr(455, 456, 1), new Range16.ptr(458, 459, 1), new Range16.ptr(461, 475, 2), new Range16.ptr(478, 494, 2), new Range16.ptr(497, 498, 1), new Range16.ptr(500, 502, 2), new Range16.ptr(503, 504, 1), new Range16.ptr(506, 562, 2), new Range16.ptr(570, 571, 1), new Range16.ptr(573, 574, 1), new Range16.ptr(577, 579, 2), new Range16.ptr(580, 582, 1), new Range16.ptr(584, 590, 2), new Range16.ptr(837, 880, 43), new Range16.ptr(882, 886, 4), new Range16.ptr(895, 902, 7), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 913, 2), new Range16.ptr(914, 929, 1), new Range16.ptr(931, 939, 1), new Range16.ptr(975, 984, 9), new Range16.ptr(986, 1006, 2), new Range16.ptr(1012, 1015, 3), new Range16.ptr(1017, 1018, 1), new Range16.ptr(1021, 1071, 1), new Range16.ptr(1120, 1152, 2), new Range16.ptr(1162, 1216, 2), new Range16.ptr(1217, 1229, 2), new Range16.ptr(1232, 1326, 2), new Range16.ptr(1329, 1366, 1), new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(5024, 5109, 1), new Range16.ptr(7680, 7828, 2), new Range16.ptr(7838, 7934, 2), new Range16.ptr(7944, 7951, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7976, 7983, 1), new Range16.ptr(7992, 7999, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8040, 8047, 1), new Range16.ptr(8072, 8079, 1), new Range16.ptr(8088, 8095, 1), new Range16.ptr(8104, 8111, 1), new Range16.ptr(8120, 8124, 1), new Range16.ptr(8136, 8140, 1), new Range16.ptr(8152, 8155, 1), new Range16.ptr(8168, 8172, 1), new Range16.ptr(8184, 8188, 1), new Range16.ptr(8486, 8490, 4), new Range16.ptr(8491, 8498, 7), new Range16.ptr(8579, 11264, 2685), new Range16.ptr(11265, 11310, 1), new Range16.ptr(11360, 11362, 2), new Range16.ptr(11363, 11364, 1), new Range16.ptr(11367, 11373, 2), new Range16.ptr(11374, 11376, 1), new Range16.ptr(11378, 11381, 3), new Range16.ptr(11390, 11392, 1), new Range16.ptr(11394, 11490, 2), new Range16.ptr(11499, 11501, 2), new Range16.ptr(11506, 42560, 31054), new Range16.ptr(42562, 42604, 2), new Range16.ptr(42624, 42650, 2), new Range16.ptr(42786, 42798, 2), new Range16.ptr(42802, 42862, 2), new Range16.ptr(42873, 42877, 2), new Range16.ptr(42878, 42886, 2), new Range16.ptr(42891, 42893, 2), new Range16.ptr(42896, 42898, 2), new Range16.ptr(42902, 42922, 2), new Range16.ptr(42923, 42926, 1), new Range16.ptr(42928, 42932, 1), new Range16.ptr(42934, 65313, 22379), new Range16.ptr(65314, 65338, 1)]), new sliceType$1([new Range32.ptr(66560, 66599, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(71840, 71871, 1), new Range32.ptr(125184, 125217, 1)]), 3); + foldLt = new RangeTable.ptr(new sliceType([new Range16.ptr(452, 454, 2), new Range16.ptr(455, 457, 2), new Range16.ptr(458, 460, 2), new Range16.ptr(497, 499, 2), new Range16.ptr(8064, 8071, 1), new Range16.ptr(8080, 8087, 1), new Range16.ptr(8096, 8103, 1), new Range16.ptr(8115, 8131, 16), new Range16.ptr(8179, 8179, 1)]), sliceType$1.nil, 0); + foldLu = new RangeTable.ptr(new sliceType([new Range16.ptr(97, 122, 1), new Range16.ptr(181, 223, 42), new Range16.ptr(224, 246, 1), new Range16.ptr(248, 255, 1), new Range16.ptr(257, 303, 2), new Range16.ptr(307, 311, 2), new Range16.ptr(314, 328, 2), new Range16.ptr(331, 375, 2), new Range16.ptr(378, 382, 2), new Range16.ptr(383, 384, 1), new Range16.ptr(387, 389, 2), new Range16.ptr(392, 396, 4), new Range16.ptr(402, 405, 3), new Range16.ptr(409, 410, 1), new Range16.ptr(414, 417, 3), new Range16.ptr(419, 421, 2), new Range16.ptr(424, 429, 5), new Range16.ptr(432, 436, 4), new Range16.ptr(438, 441, 3), new Range16.ptr(445, 447, 2), new Range16.ptr(453, 454, 1), new Range16.ptr(456, 457, 1), new Range16.ptr(459, 460, 1), new Range16.ptr(462, 476, 2), new Range16.ptr(477, 495, 2), new Range16.ptr(498, 499, 1), new Range16.ptr(501, 505, 4), new Range16.ptr(507, 543, 2), new Range16.ptr(547, 563, 2), new Range16.ptr(572, 575, 3), new Range16.ptr(576, 578, 2), new Range16.ptr(583, 591, 2), new Range16.ptr(592, 596, 1), new Range16.ptr(598, 599, 1), new Range16.ptr(601, 603, 2), new Range16.ptr(604, 608, 4), new Range16.ptr(609, 613, 2), new Range16.ptr(614, 616, 2), new Range16.ptr(617, 620, 1), new Range16.ptr(623, 625, 2), new Range16.ptr(626, 629, 3), new Range16.ptr(637, 643, 3), new Range16.ptr(647, 652, 1), new Range16.ptr(658, 669, 11), new Range16.ptr(670, 837, 167), new Range16.ptr(881, 883, 2), new Range16.ptr(887, 891, 4), new Range16.ptr(892, 893, 1), new Range16.ptr(940, 943, 1), new Range16.ptr(945, 974, 1), new Range16.ptr(976, 977, 1), new Range16.ptr(981, 983, 1), new Range16.ptr(985, 1007, 2), new Range16.ptr(1008, 1011, 1), new Range16.ptr(1013, 1019, 3), new Range16.ptr(1072, 1119, 1), new Range16.ptr(1121, 1153, 2), new Range16.ptr(1163, 1215, 2), new Range16.ptr(1218, 1230, 2), new Range16.ptr(1231, 1327, 2), new Range16.ptr(1377, 1414, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7545, 7549, 4), new Range16.ptr(7681, 7829, 2), new Range16.ptr(7835, 7841, 6), new Range16.ptr(7843, 7935, 2), new Range16.ptr(7936, 7943, 1), new Range16.ptr(7952, 7957, 1), new Range16.ptr(7968, 7975, 1), new Range16.ptr(7984, 7991, 1), new Range16.ptr(8000, 8005, 1), new Range16.ptr(8017, 8023, 2), new Range16.ptr(8032, 8039, 1), new Range16.ptr(8048, 8061, 1), new Range16.ptr(8112, 8113, 1), new Range16.ptr(8126, 8144, 18), new Range16.ptr(8145, 8160, 15), new Range16.ptr(8161, 8165, 4), new Range16.ptr(8526, 8580, 54), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11361, 11365, 4), new Range16.ptr(11366, 11372, 2), new Range16.ptr(11379, 11382, 3), new Range16.ptr(11393, 11491, 2), new Range16.ptr(11500, 11502, 2), new Range16.ptr(11507, 11520, 13), new Range16.ptr(11521, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(42561, 42605, 2), new Range16.ptr(42625, 42651, 2), new Range16.ptr(42787, 42799, 2), new Range16.ptr(42803, 42863, 2), new Range16.ptr(42874, 42876, 2), new Range16.ptr(42879, 42887, 2), new Range16.ptr(42892, 42897, 5), new Range16.ptr(42899, 42903, 4), new Range16.ptr(42905, 42921, 2), new Range16.ptr(42933, 42935, 2), new Range16.ptr(43859, 43888, 29), new Range16.ptr(43889, 43967, 1), new Range16.ptr(65345, 65370, 1)]), new sliceType$1([new Range32.ptr(66600, 66639, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(71872, 71903, 1), new Range32.ptr(125218, 125251, 1)]), 4); + foldM = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); + foldMn = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); + $pkg.FoldCategory = $makeMap($String.keyFor, [{ k: "L", v: foldL }, { k: "Ll", v: foldLl }, { k: "Lt", v: foldLt }, { k: "Lu", v: foldLu }, { k: "M", v: foldM }, { k: "Mn", v: foldMn }]); + foldCommon = new RangeTable.ptr(new sliceType([new Range16.ptr(924, 956, 32)]), sliceType$1.nil, 0); + foldGreek = new RangeTable.ptr(new sliceType([new Range16.ptr(181, 837, 656)]), sliceType$1.nil, 0); + foldInherited = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); + $pkg.FoldScript = $makeMap($String.keyFor, [{ k: "Common", v: foldCommon }, { k: "Greek", v: foldGreek }, { k: "Inherited", v: foldInherited }]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["reflect"] = (function() { + var $pkg = {}, $init, errors, js, math, runtime, strconv, sync, unicode, utf8, uncommonType, funcType, name, nameData, mapIter, Type, Kind, tflag, rtype, typeAlg, method, ChanDir, arrayType, chanType, imethod, interfaceType, mapType, ptrType, sliceType, structField, structType, Method, nameOff, typeOff, textOff, StructField, StructTag, fieldScan, Value, flag, ValueError, MapIter, sliceType$1, ptrType$1, sliceType$2, sliceType$3, ptrType$2, funcType$1, sliceType$4, ptrType$3, ptrType$4, sliceType$5, sliceType$6, sliceType$7, ptrType$5, ptrType$6, structType$3, sliceType$8, sliceType$9, ptrType$7, ptrType$8, sliceType$10, sliceType$11, ptrType$9, ptrType$10, sliceType$13, sliceType$14, ptrType$11, sliceType$15, ptrType$17, sliceType$18, funcType$3, funcType$4, funcType$5, ptrType$18, arrayType$8, ptrType$19, ptrType$20, initialized, uncommonTypeMap, nameMap, nameOffList, typeOffList, callHelper, jsObjectPtr, selectHelper, kindNames, uint8Type, init, jsType, reflectType, setKindType, newName, newNameOff, newTypeOff, internalStr, isWrapped, copyStruct, makeValue, MakeSlice, TypeOf, ValueOf, FuncOf, SliceOf, Zero, unsafe_New, makeInt, typedmemmove, keyFor, mapaccess, mapassign, mapdelete, mapiterinit, mapiterkey, mapitervalue, mapiternext, maplen, cvtDirect, methodReceiver, valueInterface, ifaceE2I, methodName, makeMethodValue, wrapJsObject, unwrapJsObject, getJsTag, chanrecv, chansend, Swapper, PtrTo, implements$1, directlyAssignable, haveIdenticalType, haveIdenticalUnderlyingType, toType, ifaceIndir, copyVal, overflowFloat32, New, convertOp, makeFloat, makeComplex, makeString, makeBytes, makeRunes, cvtInt, cvtUint, cvtFloatInt, cvtFloatUint, cvtIntFloat, cvtUintFloat, cvtFloat, cvtComplex, cvtIntString, cvtUintString, cvtBytesString, cvtStringBytes, cvtRunesString, cvtStringRunes, cvtT2I, cvtI2I; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + math = $packages["math"]; + runtime = $packages["runtime"]; + strconv = $packages["strconv"]; + sync = $packages["sync"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + uncommonType = $pkg.uncommonType = $newType(0, $kindStruct, "reflect.uncommonType", true, "reflect", false, function(pkgPath_, mcount_, xcount_, moff_, _methods_) { + this.$val = this; + if (arguments.length === 0) { + this.pkgPath = 0; + this.mcount = 0; + this.xcount = 0; + this.moff = 0; + this._methods = sliceType$5.nil; + return; + } + this.pkgPath = pkgPath_; + this.mcount = mcount_; + this.xcount = xcount_; + this.moff = moff_; + this._methods = _methods_; + }); + funcType = $pkg.funcType = $newType(0, $kindStruct, "reflect.funcType", true, "reflect", false, function(rtype_, inCount_, outCount_, _in_, _out_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.inCount = 0; + this.outCount = 0; + this._in = sliceType$2.nil; + this._out = sliceType$2.nil; + return; + } + this.rtype = rtype_; + this.inCount = inCount_; + this.outCount = outCount_; + this._in = _in_; + this._out = _out_; + }); + name = $pkg.name = $newType(0, $kindStruct, "reflect.name", true, "reflect", false, function(bytes_) { + this.$val = this; + if (arguments.length === 0) { + this.bytes = ptrType$4.nil; + return; + } + this.bytes = bytes_; + }); + nameData = $pkg.nameData = $newType(0, $kindStruct, "reflect.nameData", true, "reflect", false, function(name_, tag_, exported_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.tag = ""; + this.exported = false; + return; + } + this.name = name_; + this.tag = tag_; + this.exported = exported_; + }); + mapIter = $pkg.mapIter = $newType(0, $kindStruct, "reflect.mapIter", true, "reflect", false, function(t_, m_, keys_, i_, last_) { + this.$val = this; + if (arguments.length === 0) { + this.t = $ifaceNil; + this.m = null; + this.keys = null; + this.i = 0; + this.last = null; + return; + } + this.t = t_; + this.m = m_; + this.keys = keys_; + this.i = i_; + this.last = last_; + }); + Type = $pkg.Type = $newType(8, $kindInterface, "reflect.Type", true, "reflect", true, null); + Kind = $pkg.Kind = $newType(4, $kindUint, "reflect.Kind", true, "reflect", true, null); + tflag = $pkg.tflag = $newType(1, $kindUint8, "reflect.tflag", true, "reflect", false, null); + rtype = $pkg.rtype = $newType(0, $kindStruct, "reflect.rtype", true, "reflect", false, function(size_, ptrdata_, hash_, tflag_, align_, fieldAlign_, kind_, alg_, gcdata_, str_, ptrToThis_) { + this.$val = this; + if (arguments.length === 0) { + this.size = 0; + this.ptrdata = 0; + this.hash = 0; + this.tflag = 0; + this.align = 0; + this.fieldAlign = 0; + this.kind = 0; + this.alg = ptrType$3.nil; + this.gcdata = ptrType$4.nil; + this.str = 0; + this.ptrToThis = 0; + return; + } + this.size = size_; + this.ptrdata = ptrdata_; + this.hash = hash_; + this.tflag = tflag_; + this.align = align_; + this.fieldAlign = fieldAlign_; + this.kind = kind_; + this.alg = alg_; + this.gcdata = gcdata_; + this.str = str_; + this.ptrToThis = ptrToThis_; + }); + typeAlg = $pkg.typeAlg = $newType(0, $kindStruct, "reflect.typeAlg", true, "reflect", false, function(hash_, equal_) { + this.$val = this; + if (arguments.length === 0) { + this.hash = $throwNilPointerError; + this.equal = $throwNilPointerError; + return; + } + this.hash = hash_; + this.equal = equal_; + }); + method = $pkg.method = $newType(0, $kindStruct, "reflect.method", true, "reflect", false, function(name_, mtyp_, ifn_, tfn_) { + this.$val = this; + if (arguments.length === 0) { + this.name = 0; + this.mtyp = 0; + this.ifn = 0; + this.tfn = 0; + return; + } + this.name = name_; + this.mtyp = mtyp_; + this.ifn = ifn_; + this.tfn = tfn_; + }); + ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "reflect.ChanDir", true, "reflect", true, null); + arrayType = $pkg.arrayType = $newType(0, $kindStruct, "reflect.arrayType", true, "reflect", false, function(rtype_, elem_, slice_, len_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + this.slice = ptrType$1.nil; + this.len = 0; + return; + } + this.rtype = rtype_; + this.elem = elem_; + this.slice = slice_; + this.len = len_; + }); + chanType = $pkg.chanType = $newType(0, $kindStruct, "reflect.chanType", true, "reflect", false, function(rtype_, elem_, dir_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + this.dir = 0; + return; + } + this.rtype = rtype_; + this.elem = elem_; + this.dir = dir_; + }); + imethod = $pkg.imethod = $newType(0, $kindStruct, "reflect.imethod", true, "reflect", false, function(name_, typ_) { + this.$val = this; + if (arguments.length === 0) { + this.name = 0; + this.typ = 0; + return; + } + this.name = name_; + this.typ = typ_; + }); + interfaceType = $pkg.interfaceType = $newType(0, $kindStruct, "reflect.interfaceType", true, "reflect", false, function(rtype_, pkgPath_, methods_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.pkgPath = new name.ptr(ptrType$4.nil); + this.methods = sliceType$6.nil; + return; + } + this.rtype = rtype_; + this.pkgPath = pkgPath_; + this.methods = methods_; + }); + mapType = $pkg.mapType = $newType(0, $kindStruct, "reflect.mapType", true, "reflect", false, function(rtype_, key_, elem_, bucket_, keysize_, valuesize_, bucketsize_, flags_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.key = ptrType$1.nil; + this.elem = ptrType$1.nil; + this.bucket = ptrType$1.nil; + this.keysize = 0; + this.valuesize = 0; + this.bucketsize = 0; + this.flags = 0; + return; + } + this.rtype = rtype_; + this.key = key_; + this.elem = elem_; + this.bucket = bucket_; + this.keysize = keysize_; + this.valuesize = valuesize_; + this.bucketsize = bucketsize_; + this.flags = flags_; + }); + ptrType = $pkg.ptrType = $newType(0, $kindStruct, "reflect.ptrType", true, "reflect", false, function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + sliceType = $pkg.sliceType = $newType(0, $kindStruct, "reflect.sliceType", true, "reflect", false, function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + structField = $pkg.structField = $newType(0, $kindStruct, "reflect.structField", true, "reflect", false, function(name_, typ_, offsetEmbed_) { + this.$val = this; + if (arguments.length === 0) { + this.name = new name.ptr(ptrType$4.nil); + this.typ = ptrType$1.nil; + this.offsetEmbed = 0; + return; + } + this.name = name_; + this.typ = typ_; + this.offsetEmbed = offsetEmbed_; + }); + structType = $pkg.structType = $newType(0, $kindStruct, "reflect.structType", true, "reflect", false, function(rtype_, pkgPath_, fields_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.pkgPath = new name.ptr(ptrType$4.nil); + this.fields = sliceType$7.nil; + return; + } + this.rtype = rtype_; + this.pkgPath = pkgPath_; + this.fields = fields_; + }); + Method = $pkg.Method = $newType(0, $kindStruct, "reflect.Method", true, "reflect", true, function(Name_, PkgPath_, Type_, Func_, Index_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.PkgPath = ""; + this.Type = $ifaceNil; + this.Func = new Value.ptr(ptrType$1.nil, 0, 0); + this.Index = 0; + return; + } + this.Name = Name_; + this.PkgPath = PkgPath_; + this.Type = Type_; + this.Func = Func_; + this.Index = Index_; + }); + nameOff = $pkg.nameOff = $newType(4, $kindInt32, "reflect.nameOff", true, "reflect", false, null); + typeOff = $pkg.typeOff = $newType(4, $kindInt32, "reflect.typeOff", true, "reflect", false, null); + textOff = $pkg.textOff = $newType(4, $kindInt32, "reflect.textOff", true, "reflect", false, null); + StructField = $pkg.StructField = $newType(0, $kindStruct, "reflect.StructField", true, "reflect", true, function(Name_, PkgPath_, Type_, Tag_, Offset_, Index_, Anonymous_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.PkgPath = ""; + this.Type = $ifaceNil; + this.Tag = ""; + this.Offset = 0; + this.Index = sliceType$13.nil; + this.Anonymous = false; + return; + } + this.Name = Name_; + this.PkgPath = PkgPath_; + this.Type = Type_; + this.Tag = Tag_; + this.Offset = Offset_; + this.Index = Index_; + this.Anonymous = Anonymous_; + }); + StructTag = $pkg.StructTag = $newType(8, $kindString, "reflect.StructTag", true, "reflect", true, null); + fieldScan = $pkg.fieldScan = $newType(0, $kindStruct, "reflect.fieldScan", true, "reflect", false, function(typ_, index_) { + this.$val = this; + if (arguments.length === 0) { + this.typ = ptrType$11.nil; + this.index = sliceType$13.nil; + return; + } + this.typ = typ_; + this.index = index_; + }); + Value = $pkg.Value = $newType(0, $kindStruct, "reflect.Value", true, "reflect", true, function(typ_, ptr_, flag_) { + this.$val = this; + if (arguments.length === 0) { + this.typ = ptrType$1.nil; + this.ptr = 0; + this.flag = 0; + return; + } + this.typ = typ_; + this.ptr = ptr_; + this.flag = flag_; + }); + flag = $pkg.flag = $newType(4, $kindUintptr, "reflect.flag", true, "reflect", false, null); + ValueError = $pkg.ValueError = $newType(0, $kindStruct, "reflect.ValueError", true, "reflect", true, function(Method_, Kind_) { + this.$val = this; + if (arguments.length === 0) { + this.Method = ""; + this.Kind = 0; + return; + } + this.Method = Method_; + this.Kind = Kind_; + }); + MapIter = $pkg.MapIter = $newType(0, $kindStruct, "reflect.MapIter", true, "reflect", true, function(m_, it_) { + this.$val = this; + if (arguments.length === 0) { + this.m = new Value.ptr(ptrType$1.nil, 0, 0); + this.it = 0; + return; + } + this.m = m_; + this.it = it_; + }); + sliceType$1 = $sliceType(name); + ptrType$1 = $ptrType(rtype); + sliceType$2 = $sliceType(ptrType$1); + sliceType$3 = $sliceType($emptyInterface); + ptrType$2 = $ptrType(js.Object); + funcType$1 = $funcType([sliceType$3], [ptrType$2], true); + sliceType$4 = $sliceType($String); + ptrType$3 = $ptrType(typeAlg); + ptrType$4 = $ptrType($Uint8); + sliceType$5 = $sliceType(method); + sliceType$6 = $sliceType(imethod); + sliceType$7 = $sliceType(structField); + ptrType$5 = $ptrType(uncommonType); + ptrType$6 = $ptrType(nameData); + structType$3 = $structType("reflect", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); + sliceType$8 = $sliceType(ptrType$2); + sliceType$9 = $sliceType(Value); + ptrType$7 = $ptrType(mapIter); + ptrType$8 = $ptrType(funcType); + sliceType$10 = $sliceType(Type); + sliceType$11 = $sliceType(sliceType$8); + ptrType$9 = $ptrType(interfaceType); + ptrType$10 = $ptrType(imethod); + sliceType$13 = $sliceType($Int); + sliceType$14 = $sliceType(fieldScan); + ptrType$11 = $ptrType(structType); + sliceType$15 = $sliceType($Uint8); + ptrType$17 = $ptrType($UnsafePointer); + sliceType$18 = $sliceType($Int32); + funcType$3 = $funcType([$String], [$Bool], false); + funcType$4 = $funcType([$UnsafePointer, $Uintptr], [$Uintptr], false); + funcType$5 = $funcType([$UnsafePointer, $UnsafePointer], [$Bool], false); + ptrType$18 = $ptrType(structField); + arrayType$8 = $arrayType($Uintptr, 2); + ptrType$19 = $ptrType(MapIter); + ptrType$20 = $ptrType(ValueError); + init = function() { + var used, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; used = $f.used; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + used = (function(i) { + var i; + }); + $r = used((x = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$1 = new uncommonType.ptr(0, 0, 0, 0, sliceType$5.nil), new x$1.constructor.elem(x$1))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$2 = new method.ptr(0, 0, 0, 0), new x$2.constructor.elem(x$2))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$3 = new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, 0), new x$3.constructor.elem(x$3))); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$4 = new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, 0), new x$4.constructor.elem(x$4))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$5 = new funcType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), 0, 0, sliceType$2.nil, sliceType$2.nil), new x$5.constructor.elem(x$5))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$6 = new interfaceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$6.nil), new x$6.constructor.elem(x$6))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$7 = new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0), new x$7.constructor.elem(x$7))); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$8 = new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$8.constructor.elem(x$8))); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$9 = new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$9.constructor.elem(x$9))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$10 = new structType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$7.nil), new x$10.constructor.elem(x$10))); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$11 = new imethod.ptr(0, 0), new x$11.constructor.elem(x$11))); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$12 = new structField.ptr(new name.ptr(ptrType$4.nil), ptrType$1.nil, 0), new x$12.constructor.elem(x$12))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + initialized = true; + uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: init }; } $f.used = used; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + jsType = function(typ) { + var typ; + return typ.jsType; + }; + reflectType = function(typ) { + var _1, _i, _i$1, _i$2, _i$3, _key, _ref, _ref$1, _ref$2, _ref$3, dir, exported, exported$1, f, fields, i, i$1, i$2, i$3, i$4, i$5, imethods, in$1, m, m$1, m$2, methodSet, methods, offsetEmbed, out, outCount, params, reflectFields, reflectMethods, results, rt, typ, ut, xcount; + if (typ.reflectType === undefined) { + rt = new rtype.ptr(((($parseInt(typ.size) >> 0) >>> 0)), 0, 0, 0, 0, 0, ((($parseInt(typ.kind) >> 0) << 24 >>> 24)), ptrType$3.nil, ptrType$4.nil, newNameOff($clone(newName(internalStr(typ.string), "", !!(typ.exported)), name)), 0); + rt.jsType = typ; + typ.reflectType = rt; + methodSet = $methodSet(typ); + if (!(($parseInt(methodSet.length) === 0)) || !!(typ.named)) { + rt.tflag = (rt.tflag | (1)) >>> 0; + if (!!(typ.named)) { + rt.tflag = (rt.tflag | (4)) >>> 0; + } + reflectMethods = sliceType$5.nil; + i = 0; + while (true) { + if (!(i < $parseInt(methodSet.length))) { break; } + m = methodSet[i]; + exported = internalStr(m.pkg) === ""; + if (!exported) { + i = i + (1) >> 0; + continue; + } + reflectMethods = $append(reflectMethods, new method.ptr(newNameOff($clone(newName(internalStr(m.name), "", exported), name)), newTypeOff(reflectType(m.typ)), 0, 0)); + i = i + (1) >> 0; + } + xcount = ((reflectMethods.$length << 16 >>> 16)); + i$1 = 0; + while (true) { + if (!(i$1 < $parseInt(methodSet.length))) { break; } + m$1 = methodSet[i$1]; + exported$1 = internalStr(m$1.pkg) === ""; + if (exported$1) { + i$1 = i$1 + (1) >> 0; + continue; + } + reflectMethods = $append(reflectMethods, new method.ptr(newNameOff($clone(newName(internalStr(m$1.name), "", exported$1), name)), newTypeOff(reflectType(m$1.typ)), 0, 0)); + i$1 = i$1 + (1) >> 0; + } + ut = new uncommonType.ptr(newNameOff($clone(newName(internalStr(typ.pkg), "", false), name)), (($parseInt(methodSet.length) << 16 >>> 16)), xcount, 0, reflectMethods); + _key = rt; (uncommonTypeMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: ut }; + ut.jsType = typ; + } + _1 = rt.Kind(); + if (_1 === (17)) { + setKindType(rt, new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ptrType$1.nil, ((($parseInt(typ.len) >> 0) >>> 0)))); + } else if (_1 === (18)) { + dir = 3; + if (!!(typ.sendOnly)) { + dir = 2; + } + if (!!(typ.recvOnly)) { + dir = 1; + } + setKindType(rt, new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ((dir >>> 0)))); + } else if (_1 === (19)) { + params = typ.params; + in$1 = $makeSlice(sliceType$2, $parseInt(params.length)); + _ref = in$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i$2 = _i; + ((i$2 < 0 || i$2 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i$2] = reflectType(params[i$2])); + _i++; + } + results = typ.results; + out = $makeSlice(sliceType$2, $parseInt(results.length)); + _ref$1 = out; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$3 = _i$1; + ((i$3 < 0 || i$3 >= out.$length) ? ($throwRuntimeError("index out of range"), undefined) : out.$array[out.$offset + i$3] = reflectType(results[i$3])); + _i$1++; + } + outCount = (($parseInt(results.length) << 16 >>> 16)); + if (!!(typ.variadic)) { + outCount = (outCount | (32768)) >>> 0; + } + setKindType(rt, new funcType.ptr($clone(rt, rtype), (($parseInt(params.length) << 16 >>> 16)), outCount, in$1, out)); + } else if (_1 === (20)) { + methods = typ.methods; + imethods = $makeSlice(sliceType$6, $parseInt(methods.length)); + _ref$2 = imethods; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$4 = _i$2; + m$2 = methods[i$4]; + imethod.copy(((i$4 < 0 || i$4 >= imethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : imethods.$array[imethods.$offset + i$4]), new imethod.ptr(newNameOff($clone(newName(internalStr(m$2.name), "", internalStr(m$2.pkg) === ""), name)), newTypeOff(reflectType(m$2.typ)))); + _i$2++; + } + setKindType(rt, new interfaceType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkg), "", false), name), imethods)); + } else if (_1 === (21)) { + setKindType(rt, new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.key), reflectType(typ.elem), ptrType$1.nil, 0, 0, 0, 0)); + } else if (_1 === (22)) { + setKindType(rt, new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); + } else if (_1 === (23)) { + setKindType(rt, new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); + } else if (_1 === (25)) { + fields = typ.fields; + reflectFields = $makeSlice(sliceType$7, $parseInt(fields.length)); + _ref$3 = reflectFields; + _i$3 = 0; + while (true) { + if (!(_i$3 < _ref$3.$length)) { break; } + i$5 = _i$3; + f = fields[i$5]; + offsetEmbed = ((i$5 >>> 0)) << 1 >>> 0; + if (!!(f.embedded)) { + offsetEmbed = (offsetEmbed | (1)) >>> 0; + } + structField.copy(((i$5 < 0 || i$5 >= reflectFields.$length) ? ($throwRuntimeError("index out of range"), undefined) : reflectFields.$array[reflectFields.$offset + i$5]), new structField.ptr($clone(newName(internalStr(f.name), internalStr(f.tag), !!(f.exported)), name), reflectType(f.typ), offsetEmbed)); + _i$3++; + } + setKindType(rt, new structType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkgPath), "", false), name), reflectFields)); + } + } + return ((typ.reflectType)); + }; + setKindType = function(rt, kindType) { + var kindType, rt; + rt.kindType = kindType; + kindType.rtype = rt; + }; + uncommonType.ptr.prototype.methods = function() { + var t; + t = this; + return t._methods; + }; + uncommonType.prototype.methods = function() { return this.$val.methods(); }; + uncommonType.ptr.prototype.exportedMethods = function() { + var t; + t = this; + return $subslice(t._methods, 0, t.xcount, t.xcount); + }; + uncommonType.prototype.exportedMethods = function() { return this.$val.exportedMethods(); }; + rtype.ptr.prototype.uncommon = function() { + var _entry, t; + t = this; + return (_entry = uncommonTypeMap[ptrType$1.keyFor(t)], _entry !== undefined ? _entry.v : ptrType$5.nil); + }; + rtype.prototype.uncommon = function() { return this.$val.uncommon(); }; + funcType.ptr.prototype.in$ = function() { + var t; + t = this; + return t._in; + }; + funcType.prototype.in$ = function() { return this.$val.in$(); }; + funcType.ptr.prototype.out = function() { + var t; + t = this; + return t._out; + }; + funcType.prototype.out = function() { return this.$val.out(); }; + name.ptr.prototype.name = function() { + var _entry, n, s; + s = ""; + n = this; + s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).name; + return s; + }; + name.prototype.name = function() { return this.$val.name(); }; + name.ptr.prototype.tag = function() { + var _entry, n, s; + s = ""; + n = this; + s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).tag; + return s; + }; + name.prototype.tag = function() { return this.$val.tag(); }; + name.ptr.prototype.pkgPath = function() { + var n; + n = this; + return ""; + }; + name.prototype.pkgPath = function() { return this.$val.pkgPath(); }; + name.ptr.prototype.isExported = function() { + var _entry, n; + n = this; + return (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).exported; + }; + name.prototype.isExported = function() { return this.$val.isExported(); }; + newName = function(n, tag, exported) { + var _key, b, exported, n, tag; + b = $newDataPointer(0, ptrType$4); + _key = b; (nameMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$4.keyFor(_key)] = { k: _key, v: new nameData.ptr(n, tag, exported) }; + return new name.ptr(b); + }; + rtype.ptr.prototype.nameOff = function(off) { + var off, t, x; + t = this; + return (x = ((off >> 0)), ((x < 0 || x >= nameOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : nameOffList.$array[nameOffList.$offset + x])); + }; + rtype.prototype.nameOff = function(off) { return this.$val.nameOff(off); }; + newNameOff = function(n) { + var i, n; + i = nameOffList.$length; + nameOffList = $append(nameOffList, n); + return ((i >> 0)); + }; + rtype.ptr.prototype.typeOff = function(off) { + var off, t, x; + t = this; + return (x = ((off >> 0)), ((x < 0 || x >= typeOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : typeOffList.$array[typeOffList.$offset + x])); + }; + rtype.prototype.typeOff = function(off) { return this.$val.typeOff(off); }; + newTypeOff = function(t) { + var i, t; + i = typeOffList.$length; + typeOffList = $append(typeOffList, t); + return ((i >> 0)); + }; + internalStr = function(strObj) { + var c, strObj; + c = new structType$3.ptr(""); + c.str = strObj; + return c.str; + }; + isWrapped = function(typ) { + var typ; + return !!(jsType(typ).wrapped); + }; + copyStruct = function(dst, src, typ) { + var dst, fields, i, prop, src, typ; + fields = jsType(typ).fields; + i = 0; + while (true) { + if (!(i < $parseInt(fields.length))) { break; } + prop = $internalize(fields[i].prop, $String); + dst[$externalize(prop, $String)] = src[$externalize(prop, $String)]; + i = i + (1) >> 0; + } + }; + makeValue = function(t, v, fl) { + var _r, _r$1, _r$2, _r$3, _r$4, _r$5, _v, _v$1, fl, rt, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _v = $f._v; _v$1 = $f._v$1; fl = $f.fl; rt = $f.rt; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + rt = _r; + _r$1 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + if (_r$1 === 17) { _v$1 = true; $s = 5; continue s; } + _r$2 = t.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$1 = _r$2 === 25; case 5: + if (_v$1) { _v = true; $s = 4; continue s; } + _r$3 = t.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _v = _r$3 === 22; case 4: + /* */ if (_v) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (_v) { */ case 2: + _r$4 = t.Kind(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(rt, (v), (fl | ((_r$4 >>> 0))) >>> 0); + /* } */ case 3: + _r$5 = t.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(rt, ($newDataPointer(v, jsType(rt.ptrTo()))), (((fl | ((_r$5 >>> 0))) >>> 0) | 128) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeValue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._v = _v; $f._v$1 = _v$1; $f.fl = fl; $f.rt = rt; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + MakeSlice = function(typ, len, cap) { + var _r, _r$1, cap, len, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; len = $f.len; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + typ = [typ]; + _r = typ[0].Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 23))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 23))) { */ case 1: + $panic(new $String("reflect.MakeSlice of non-slice type")); + /* } */ case 2: + if (len < 0) { + $panic(new $String("reflect.MakeSlice: negative len")); + } + if (cap < 0) { + $panic(new $String("reflect.MakeSlice: negative cap")); + } + if (len > cap) { + $panic(new $String("reflect.MakeSlice: len > cap")); + } + _r$1 = makeValue(typ[0], $makeSlice(jsType(typ[0]), len, cap, (function(typ) { return function $b() { + var _r$1, _r$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$1 = typ[0].Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = jsType(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2.zero(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.$s = $s; $f.$r = $r; return $f; + }; })(typ)), 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: MakeSlice }; } $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.len = len; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.MakeSlice = MakeSlice; + TypeOf = function(i) { + var i; + if (!initialized) { + return new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + } + if ($interfaceIsEqual(i, $ifaceNil)) { + return $ifaceNil; + } + return reflectType(i.constructor); + }; + $pkg.TypeOf = TypeOf; + ValueOf = function(i) { + var _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(i, $ifaceNil)) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + _r = makeValue(reflectType(i.constructor), i.$val, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ValueOf }; } $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.ValueOf = ValueOf; + FuncOf = function(in$1, out, variadic) { + var _i, _i$1, _r, _ref, _ref$1, _v, _v$1, i, i$1, in$1, jsIn, jsOut, out, v, v$1, variadic, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; _v$1 = $f._v$1; i = $f.i; i$1 = $f.i$1; in$1 = $f.in$1; jsIn = $f.jsIn; jsOut = $f.jsOut; out = $f.out; v = $f.v; v$1 = $f.v$1; variadic = $f.variadic; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (!(variadic)) { _v = false; $s = 3; continue s; } + if (in$1.$length === 0) { _v$1 = true; $s = 4; continue s; } + _r = (x = in$1.$length - 1 >> 0, ((x < 0 || x >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x])).Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v$1 = !((_r === 23)); case 4: + _v = _v$1; case 3: + /* */ if (_v) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_v) { */ case 1: + $panic(new $String("reflect.FuncOf: last arg of variadic func must be slice")); + /* } */ case 2: + jsIn = $makeSlice(sliceType$8, in$1.$length); + _ref = in$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= jsIn.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsIn.$array[jsIn.$offset + i] = jsType(v)); + _i++; + } + jsOut = $makeSlice(sliceType$8, out.$length); + _ref$1 = out; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + v$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + ((i$1 < 0 || i$1 >= jsOut.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsOut.$array[jsOut.$offset + i$1] = jsType(v$1)); + _i$1++; + } + $s = -1; return reflectType($funcType($externalize(jsIn, sliceType$8), $externalize(jsOut, sliceType$8), $externalize(variadic, $Bool))); + /* */ } return; } if ($f === undefined) { $f = { $blk: FuncOf }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f._v$1 = _v$1; $f.i = i; $f.i$1 = i$1; $f.in$1 = in$1; $f.jsIn = jsIn; $f.jsOut = jsOut; $f.out = out; $f.v = v; $f.v$1 = v$1; $f.variadic = variadic; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.FuncOf = FuncOf; + rtype.ptr.prototype.ptrTo = function() { + var t; + t = this; + return reflectType($ptrType(jsType(t))); + }; + rtype.prototype.ptrTo = function() { return this.$val.ptrTo(); }; + SliceOf = function(t) { + var t; + return reflectType($sliceType(jsType(t))); + }; + $pkg.SliceOf = SliceOf; + Zero = function(typ) { + var _r, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeValue(typ, jsType(typ).zero(), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Zero }; } $f._r = _r; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Zero = Zero; + unsafe_New = function(typ) { + var _1, typ; + _1 = typ.Kind(); + if (_1 === (25)) { + return (new (jsType(typ).ptr)()); + } else if (_1 === (17)) { + return (jsType(typ).zero()); + } else { + return ($newDataPointer(jsType(typ).zero(), jsType(typ.ptrTo()))); + } + }; + makeInt = function(f, bits, t) { + var _1, _r, bits, f, ptr, t, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; bits = $f.bits; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.Kind(); + if (_1 === (3)) { + (ptr).$set(((bits.$low << 24 >> 24))); + } else if (_1 === (4)) { + (ptr).$set(((bits.$low << 16 >> 16))); + } else if ((_1 === (2)) || (_1 === (5))) { + (ptr).$set(((bits.$low >> 0))); + } else if (_1 === (6)) { + (ptr).$set((new $Int64(bits.$high, bits.$low))); + } else if (_1 === (8)) { + (ptr).$set(((bits.$low << 24 >>> 24))); + } else if (_1 === (9)) { + (ptr).$set(((bits.$low << 16 >>> 16))); + } else if ((_1 === (7)) || (_1 === (10)) || (_1 === (12))) { + (ptr).$set(((bits.$low >>> 0))); + } else if (_1 === (11)) { + (ptr).$set((bits)); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeInt }; } $f._1 = _1; $f._r = _r; $f.bits = bits; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + typedmemmove = function(t, dst, src) { + var dst, src, t; + dst.$set(src.$get()); + }; + keyFor = function(t, key) { + var k, key, kv, t; + kv = key; + if (!(kv.$get === undefined)) { + kv = kv.$get(); + } + k = $internalize(jsType(t.Key()).keyFor(kv), $String); + return [kv, k]; + }; + mapaccess = function(t, m, key) { + var _tuple, entry, k, key, m, t; + _tuple = keyFor(t, key); + k = _tuple[1]; + entry = m[$externalize(k, $String)]; + if (entry === undefined) { + return 0; + } + return ($newDataPointer(entry.v, jsType(PtrTo(t.Elem())))); + }; + mapassign = function(t, m, key, val) { + var _r, _tuple, entry, et, jsVal, k, key, kv, m, newVal, t, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; entry = $f.entry; et = $f.et; jsVal = $f.jsVal; k = $f.k; key = $f.key; kv = $f.kv; m = $f.m; newVal = $f.newVal; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tuple = keyFor(t, key); + kv = _tuple[0]; + k = _tuple[1]; + jsVal = val.$get(); + et = t.Elem(); + _r = et.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 25) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r === 25) { */ case 1: + newVal = jsType(et).zero(); + copyStruct(newVal, jsVal, et); + jsVal = newVal; + /* } */ case 2: + entry = new ($global.Object)(); + entry.k = kv; + entry.v = jsVal; + m[$externalize(k, $String)] = entry; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: mapassign }; } $f._r = _r; $f._tuple = _tuple; $f.entry = entry; $f.et = et; $f.jsVal = jsVal; $f.k = k; $f.key = key; $f.kv = kv; $f.m = m; $f.newVal = newVal; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + mapdelete = function(t, m, key) { + var _tuple, k, key, m, t; + _tuple = keyFor(t, key); + k = _tuple[1]; + delete m[$externalize(k, $String)]; + }; + mapIter.ptr.prototype.skipUntilValidKey = function() { + var iter, k; + iter = this; + while (true) { + if (!(iter.i < $parseInt(iter.keys.length))) { break; } + k = iter.keys[iter.i]; + if (!(iter.m[$externalize($internalize(k, $String), $String)] === undefined)) { + break; + } + iter.i = iter.i + (1) >> 0; + } + }; + mapIter.prototype.skipUntilValidKey = function() { return this.$val.skipUntilValidKey(); }; + mapiterinit = function(t, m) { + var m, t; + return (new mapIter.ptr(t, m, $keys(m), 0, null)); + }; + mapiterkey = function(it) { + var _r, _r$1, _r$2, it, iter, k, kv, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; kv = $f.kv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + iter = ($pointerOfStructConversion(it, ptrType$7)); + kv = null; + if (!(iter.last === null)) { + kv = iter.last; + } else { + iter.skipUntilValidKey(); + if (iter.i === $parseInt(iter.keys.length)) { + $s = -1; return 0; + } + k = iter.keys[iter.i]; + kv = iter.m[$externalize($internalize(k, $String), $String)]; + iter.last = kv; + } + _r = iter.t.Key(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return ($newDataPointer(kv.k, _r$2)); + /* */ } return; } if ($f === undefined) { $f = { $blk: mapiterkey }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.kv = kv; $f.$s = $s; $f.$r = $r; return $f; + }; + mapitervalue = function(it) { + var _r, _r$1, _r$2, it, iter, k, kv, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; kv = $f.kv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + iter = ($pointerOfStructConversion(it, ptrType$7)); + kv = null; + if (!(iter.last === null)) { + kv = iter.last; + } else { + iter.skipUntilValidKey(); + if (iter.i === $parseInt(iter.keys.length)) { + $s = -1; return 0; + } + k = iter.keys[iter.i]; + kv = iter.m[$externalize($internalize(k, $String), $String)]; + iter.last = kv; + } + _r = iter.t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return ($newDataPointer(kv.v, _r$2)); + /* */ } return; } if ($f === undefined) { $f = { $blk: mapitervalue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.kv = kv; $f.$s = $s; $f.$r = $r; return $f; + }; + mapiternext = function(it) { + var it, iter; + iter = ($pointerOfStructConversion(it, ptrType$7)); + iter.last = null; + iter.i = iter.i + (1) >> 0; + }; + maplen = function(m) { + var m; + return $parseInt($keys(m).length); + }; + cvtDirect = function(v, typ) { + var _1, _arg, _arg$1, _arg$2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, k, slice, srcVal, typ, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; k = $f.k; slice = $f.slice; srcVal = $f.srcVal; typ = $f.typ; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + srcVal = $clone(v, Value).object(); + /* */ if (srcVal === jsType(v.typ).nil) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (srcVal === jsType(v.typ).nil) { */ case 1: + _r = makeValue(typ, jsType(typ).nil, v.flag); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + val = null; + _r$1 = typ.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + k = _r$1; + _1 = k; + /* */ if (_1 === (23)) { $s = 6; continue; } + /* */ if (_1 === (22)) { $s = 7; continue; } + /* */ if (_1 === (25)) { $s = 8; continue; } + /* */ if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_1 === (23)) { */ case 6: + slice = new (jsType(typ))(srcVal.$array); + slice.$offset = srcVal.$offset; + slice.$length = srcVal.$length; + slice.$capacity = srcVal.$capacity; + val = $newDataPointer(slice, jsType(PtrTo(typ))); + $s = 11; continue; + /* } else if (_1 === (22)) { */ case 7: + _r$2 = typ.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = _r$2.Kind(); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 25) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_r$3 === 25) { */ case 12: + _r$4 = typ.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if ($interfaceIsEqual(_r$4, v.typ.Elem())) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if ($interfaceIsEqual(_r$4, v.typ.Elem())) { */ case 16: + val = srcVal; + /* break; */ $s = 4; continue; + /* } */ case 17: + val = new (jsType(typ))(); + _arg = val; + _arg$1 = srcVal; + _r$5 = typ.Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$2 = _r$5; + $r = copyStruct(_arg, _arg$1, _arg$2); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* break; */ $s = 4; continue; + /* } */ case 13: + val = new (jsType(typ))(srcVal.$get, srcVal.$set); + $s = 11; continue; + /* } else if (_1 === (25)) { */ case 8: + val = new (jsType(typ).ptr)(); + copyStruct(val, srcVal, typ); + $s = 11; continue; + /* } else if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { */ case 9: + val = v.ptr; + $s = 11; continue; + /* } else { */ case 10: + $panic(new ValueError.ptr("reflect.Convert", k)); + /* } */ case 11: + case 4: + _r$6 = typ.common(); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$7 = typ.Kind(); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$6, (val), (((new flag(v.flag).ro() | ((v.flag & 128) >>> 0)) >>> 0) | ((_r$7 >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtDirect }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.k = k; $f.slice = slice; $f.srcVal = srcVal; $f.typ = typ; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + methodReceiver = function(op, v, i) { + var _$39, fn, i, m, m$1, ms, op, prop, rcvr, t, tt, v, x; + _$39 = ptrType$1.nil; + t = ptrType$8.nil; + fn = 0; + prop = ""; + if (v.typ.Kind() === 20) { + tt = (v.typ.kindType); + if (i < 0 || i >= tt.methods.$length) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if (!$clone(tt.rtype.nameOff(m.name), name).isExported()) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + t = (tt.rtype.typeOff(m.typ).kindType); + prop = $clone(tt.rtype.nameOff(m.name), name).name(); + } else { + ms = v.typ.exportedMethods(); + if (((i >>> 0)) >= ((ms.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); + if (!$clone(v.typ.nameOff(m$1.name), name).isExported()) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + t = (v.typ.typeOff(m$1.mtyp).kindType); + prop = $internalize($methodSet(jsType(v.typ))[i].prop, $String); + } + rcvr = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + fn = (rcvr[$externalize(prop, $String)]); + return [_$39, t, fn]; + }; + valueInterface = function(v, safe) { + var _r, safe, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; safe = $f.safe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (v.flag === 0) { + $panic(new ValueError.ptr("reflect.Value.Interface", 0)); + } + if (safe && !((((v.flag & 96) >>> 0) === 0))) { + $panic(new $String("reflect.Value.Interface: cannot return value obtained from unexported field or method")); + } + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue("Interface", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + if (isWrapped(v.typ)) { + $s = -1; return ((new (jsType(v.typ))($clone(v, Value).object()))); + } + $s = -1; return (($clone(v, Value).object())); + /* */ } return; } if ($f === undefined) { $f = { $blk: valueInterface }; } $f._r = _r; $f.safe = safe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ifaceE2I = function(t, src, dst) { + var dst, src, t; + dst.$set(src); + }; + methodName = function() { + return "?FIXME?"; + }; + makeMethodValue = function(op, v) { + var _r, _tuple, fn, fv, op, rcvr, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; fn = $f.fn; fv = $f.fv; op = $f.op; rcvr = $f.rcvr; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fn = [fn]; + rcvr = [rcvr]; + if (((v.flag & 512) >>> 0) === 0) { + $panic(new $String("reflect: internal error: invalid use of makePartialFunc")); + } + _tuple = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); + fn[0] = _tuple[2]; + rcvr[0] = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr[0] = new (jsType(v.typ))(rcvr[0]); + } + fv = js.MakeFunc((function(fn, rcvr) { return function(this$1, arguments$1) { + var arguments$1, this$1; + return new $jsObjectPtr(fn[0].apply(rcvr[0], $externalize(arguments$1, sliceType$8))); + }; })(fn, rcvr)); + _r = $clone(v, Value).Type().common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r, (fv), (new flag(v.flag).ro() | 19) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeMethodValue }; } $f._r = _r; $f._tuple = _tuple; $f.fn = fn; $f.fv = fv; $f.op = op; $f.rcvr = rcvr; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.ptr.prototype.pointers = function() { + var _1, t; + t = this; + _1 = t.Kind(); + if ((_1 === (22)) || (_1 === (21)) || (_1 === (18)) || (_1 === (19)) || (_1 === (25)) || (_1 === (17))) { + return true; + } else { + return false; + } + }; + rtype.prototype.pointers = function() { return this.$val.pointers(); }; + rtype.ptr.prototype.Comparable = function() { + var _1, _r, _r$1, i, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; i = $f.i; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _1 = t.Kind(); + /* */ if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { $s = 2; continue; } + /* */ if (_1 === (17)) { $s = 3; continue; } + /* */ if (_1 === (25)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { */ case 2: + $s = -1; return false; + /* } else if (_1 === (17)) { */ case 3: + _r = t.Elem().Comparable(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (25)) { */ case 4: + i = 0; + /* while (true) { */ case 7: + /* if (!(i < t.NumField())) { break; } */ if(!(i < t.NumField())) { $s = 8; continue; } + _r$1 = t.Field(i).Type.Comparable(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!_r$1) { */ case 9: + $s = -1; return false; + /* } */ case 10: + i = i + (1) >> 0; + /* } */ $s = 7; continue; case 8: + /* } */ case 5: + case 1: + $s = -1; return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Comparable }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Comparable = function() { return this.$val.Comparable(); }; + rtype.ptr.prototype.Method = function(i) { + var _i, _i$1, _r, _ref, _ref$1, arg, fl, fn, ft, i, in$1, m, methods, mt, mtyp, out, p, pname, prop, ret, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; arg = $f.arg; fl = $f.fl; fn = $f.fn; ft = $f.ft; i = $f.i; in$1 = $f.in$1; m = $f.m; methods = $f.methods; mt = $f.mt; mtyp = $f.mtyp; out = $f.out; p = $f.p; pname = $f.pname; prop = $f.prop; ret = $f.ret; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + prop = [prop]; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + Method.copy(m, tt.Method(i)); + $s = -1; return m; + } + methods = t.exportedMethods(); + if (i < 0 || i >= methods.$length) { + $panic(new $String("reflect: Method index out of range")); + } + p = $clone(((i < 0 || i >= methods.$length) ? ($throwRuntimeError("index out of range"), undefined) : methods.$array[methods.$offset + i]), method); + pname = $clone(t.nameOff(p.name), name); + m.Name = $clone(pname, name).name(); + fl = 19; + mtyp = t.typeOff(p.mtyp); + ft = (mtyp.kindType); + in$1 = $makeSlice(sliceType$10, 0, (1 + ft.in$().$length >> 0)); + in$1 = $append(in$1, t); + _ref = ft.in$(); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + in$1 = $append(in$1, arg); + _i++; + } + out = $makeSlice(sliceType$10, 0, ft.out().$length); + _ref$1 = ft.out(); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + ret = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + out = $append(out, ret); + _i$1++; + } + _r = FuncOf(in$1, out, ft.rtype.IsVariadic()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + mt = _r; + m.Type = mt; + prop[0] = $internalize($methodSet(t.jsType)[i].prop, $String); + fn = js.MakeFunc((function(prop) { return function(this$1, arguments$1) { + var arguments$1, rcvr, this$1; + rcvr = (0 >= arguments$1.$length ? ($throwRuntimeError("index out of range"), undefined) : arguments$1.$array[arguments$1.$offset + 0]); + return new $jsObjectPtr(rcvr[$externalize(prop[0], $String)].apply(rcvr, $externalize($subslice(arguments$1, 1), sliceType$8))); + }; })(prop)); + m.Func = new Value.ptr($assertType(mt, ptrType$1), (fn), fl); + m.Index = i; + Method.copy(m, m); + $s = -1; return m; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Method }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.arg = arg; $f.fl = fl; $f.fn = fn; $f.ft = ft; $f.i = i; $f.in$1 = in$1; $f.m = m; $f.methods = methods; $f.mt = mt; $f.mtyp = mtyp; $f.out = out; $f.p = p; $f.pname = pname; $f.prop = prop; $f.ret = ret; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Method = function(i) { return this.$val.Method(i); }; + Value.ptr.prototype.object = function() { + var _1, newVal, v, val; + v = this; + if ((v.typ.Kind() === 17) || (v.typ.Kind() === 25)) { + return v.ptr; + } + if (!((((v.flag & 128) >>> 0) === 0))) { + val = v.ptr.$get(); + if (!(val === $ifaceNil) && !(val.constructor === jsType(v.typ))) { + switch (0) { default: + _1 = v.typ.Kind(); + if ((_1 === (11)) || (_1 === (6))) { + val = new (jsType(v.typ))(val.$high, val.$low); + } else if ((_1 === (15)) || (_1 === (16))) { + val = new (jsType(v.typ))(val.$real, val.$imag); + } else if (_1 === (23)) { + if (val === val.constructor.nil) { + val = jsType(v.typ).nil; + break; + } + newVal = new (jsType(v.typ))(val.$array); + newVal.$offset = val.$offset; + newVal.$length = val.$length; + newVal.$capacity = val.$capacity; + val = newVal; + } + } + } + return val; + } + return v.ptr; + }; + Value.prototype.object = function() { return this.$val.object(); }; + Value.ptr.prototype.assignTo = function(context, dst, target) { + var _r, _r$1, _r$2, context, dst, fl, target, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; context = $f.context; dst = $f.dst; fl = $f.fl; target = $f.target; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue(context, $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + _r$1 = directlyAssignable(dst, v.typ); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 5; continue; } + /* */ if (implements$1(dst, v.typ)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (_r$1) { */ case 5: + fl = (((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0; + fl = (fl | (((dst.Kind() >>> 0)))) >>> 0; + $s = -1; return new Value.ptr(dst, v.ptr, fl); + /* } else if (implements$1(dst, v.typ)) { */ case 6: + if (target === 0) { + target = unsafe_New(dst); + } + _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + if (dst.NumMethod() === 0) { + (target).$set(x); + } else { + ifaceE2I(dst, x, target); + } + $s = -1; return new Value.ptr(dst, target, 148); + /* } */ case 7: + case 4: + $panic(new $String(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())); + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.assignTo }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.context = context; $f.dst = dst; $f.fl = fl; $f.target = target; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.assignTo = function(context, dst, target) { return this.$val.assignTo(context, dst, target); }; + Value.ptr.prototype.call = function(op, in$1) { + var _1, _arg, _arg$1, _arg$2, _arg$3, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tuple, arg, argsArray, elem, fn, i, i$1, i$2, i$3, in$1, isSlice, m, n, nin, nout, op, origIn, rcvr, results, ret, slice, t, targ, v, x, x$1, x$2, xt, xt$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; arg = $f.arg; argsArray = $f.argsArray; elem = $f.elem; fn = $f.fn; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; in$1 = $f.in$1; isSlice = $f.isSlice; m = $f.m; n = $f.n; nin = $f.nin; nout = $f.nout; op = $f.op; origIn = $f.origIn; rcvr = $f.rcvr; results = $f.results; ret = $f.ret; slice = $f.slice; t = $f.t; targ = $f.targ; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; xt = $f.xt; xt$1 = $f.xt$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + t = ptrType$8.nil; + fn = 0; + rcvr = null; + if (!((((v.flag & 512) >>> 0) === 0))) { + _tuple = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); + t = _tuple[1]; + fn = _tuple[2]; + rcvr = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + } else { + t = (v.typ.kindType); + fn = ($clone(v, Value).object()); + rcvr = undefined; + } + if (fn === 0) { + $panic(new $String("reflect.Value.Call: call of nil function")); + } + isSlice = op === "CallSlice"; + n = t.rtype.NumIn(); + if (isSlice) { + if (!t.rtype.IsVariadic()) { + $panic(new $String("reflect: CallSlice of non-variadic function")); + } + if (in$1.$length < n) { + $panic(new $String("reflect: CallSlice with too few input arguments")); + } + if (in$1.$length > n) { + $panic(new $String("reflect: CallSlice with too many input arguments")); + } + } else { + if (t.rtype.IsVariadic()) { + n = n - (1) >> 0; + } + if (in$1.$length < n) { + $panic(new $String("reflect: Call with too few input arguments")); + } + if (!t.rtype.IsVariadic() && in$1.$length > n) { + $panic(new $String("reflect: Call with too many input arguments")); + } + } + _ref = in$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if ($clone(x, Value).Kind() === 0) { + $panic(new $String("reflect: " + op + " using zero Value argument")); + } + _i++; + } + i = 0; + /* while (true) { */ case 1: + /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } + _tmp = $clone(((i < 0 || i >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i]), Value).Type(); + _tmp$1 = t.rtype.In(i); + xt = _tmp; + targ = _tmp$1; + _r = xt.AssignableTo(targ); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!_r) { */ case 3: + _r$1 = xt.String(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = targ.String(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $panic(new $String("reflect: " + op + " using " + _r$1 + " as type " + _r$2)); + /* } */ case 4: + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + /* */ if (!isSlice && t.rtype.IsVariadic()) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!isSlice && t.rtype.IsVariadic()) { */ case 8: + m = in$1.$length - n >> 0; + _r$3 = MakeSlice(t.rtype.In(n), m, m); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + slice = _r$3; + _r$4 = t.rtype.In(n).Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + elem = _r$4; + i$1 = 0; + /* while (true) { */ case 12: + /* if (!(i$1 < m)) { break; } */ if(!(i$1 < m)) { $s = 13; continue; } + x$2 = (x$1 = n + i$1 >> 0, ((x$1 < 0 || x$1 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x$1])); + xt$1 = $clone(x$2, Value).Type(); + _r$5 = xt$1.AssignableTo(elem); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (!_r$5) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (!_r$5) { */ case 14: + _r$6 = xt$1.String(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$7 = elem.String(); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $panic(new $String("reflect: cannot use " + _r$6 + " as type " + _r$7 + " in " + op)); + /* } */ case 15: + _r$8 = $clone(slice, Value).Index(i$1); /* */ $s = 19; case 19: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + $r = $clone(_r$8, Value).Set($clone(x$2, Value)); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 + (1) >> 0; + /* } */ $s = 12; continue; case 13: + origIn = in$1; + in$1 = $makeSlice(sliceType$9, (n + 1 >> 0)); + $copySlice($subslice(in$1, 0, n), origIn); + ((n < 0 || n >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + n] = slice); + /* } */ case 9: + nin = in$1.$length; + if (!((nin === t.rtype.NumIn()))) { + $panic(new $String("reflect.Value.Call: wrong argument count")); + } + nout = t.rtype.NumOut(); + argsArray = new ($global.Array)(t.rtype.NumIn()); + _ref$1 = in$1; + _i$1 = 0; + /* while (true) { */ case 21: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 22; continue; } + i$2 = _i$1; + arg = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + _arg = t.rtype.In(i$2); + _r$9 = t.rtype.In(i$2).common(); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _arg$1 = _r$9; + _arg$2 = 0; + _r$10 = $clone(arg, Value).assignTo("reflect.Value.Call", _arg$1, _arg$2); /* */ $s = 24; case 24: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _r$11 = $clone(_r$10, Value).object(); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _arg$3 = _r$11; + _r$12 = unwrapJsObject(_arg, _arg$3); /* */ $s = 26; case 26: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + argsArray[i$2] = _r$12; + _i$1++; + /* } */ $s = 21; continue; case 22: + _r$13 = callHelper(new sliceType$3([new $jsObjectPtr(fn), new $jsObjectPtr(rcvr), new $jsObjectPtr(argsArray)])); /* */ $s = 27; case 27: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + results = _r$13; + _1 = nout; + /* */ if (_1 === (0)) { $s = 29; continue; } + /* */ if (_1 === (1)) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if (_1 === (0)) { */ case 29: + $s = -1; return sliceType$9.nil; + /* } else if (_1 === (1)) { */ case 30: + _r$14 = makeValue(t.rtype.Out(0), wrapJsObject(t.rtype.Out(0), results), 0); /* */ $s = 33; case 33: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + $s = -1; return new sliceType$9([$clone(_r$14, Value)]); + /* } else { */ case 31: + ret = $makeSlice(sliceType$9, nout); + _ref$2 = ret; + _i$2 = 0; + /* while (true) { */ case 34: + /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 35; continue; } + i$3 = _i$2; + _r$15 = makeValue(t.rtype.Out(i$3), wrapJsObject(t.rtype.Out(i$3), results[i$3]), 0); /* */ $s = 36; case 36: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + ((i$3 < 0 || i$3 >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i$3] = _r$15); + _i$2++; + /* } */ $s = 34; continue; case 35: + $s = -1; return ret; + /* } */ case 32: + case 28: + $s = -1; return sliceType$9.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.call }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.arg = arg; $f.argsArray = argsArray; $f.elem = elem; $f.fn = fn; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.in$1 = in$1; $f.isSlice = isSlice; $f.m = m; $f.n = n; $f.nin = nin; $f.nout = nout; $f.op = op; $f.origIn = origIn; $f.rcvr = rcvr; $f.results = results; $f.ret = ret; $f.slice = slice; $f.t = t; $f.targ = targ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.xt = xt; $f.xt$1 = xt$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.call = function(op, in$1) { return this.$val.call(op, in$1); }; + Value.ptr.prototype.Cap = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (17)) { + return v.typ.Len(); + } else if ((_1 === (18)) || (_1 === (23))) { + return $parseInt($clone(v, Value).object().$capacity) >> 0; + } + $panic(new ValueError.ptr("reflect.Value.Cap", k)); + }; + Value.prototype.Cap = function() { return this.$val.Cap(); }; + wrapJsObject = function(typ, val) { + var typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return new (jsType(jsObjectPtr))(val); + } + return val; + }; + unwrapJsObject = function(typ, val) { + var typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return val.object; + } + return val; + }; + Value.ptr.prototype.Elem = function() { + var _1, _r, fl, k, tt, typ, v, val, val$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; fl = $f.fl; k = $f.k; tt = $f.tt; typ = $f.typ; v = $f.v; val = $f.val; val$1 = $f.val$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + k = new flag(v.flag).kind(); + _1 = k; + /* */ if (_1 === (20)) { $s = 2; continue; } + /* */ if (_1 === (22)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_1 === (20)) { */ case 2: + val = $clone(v, Value).object(); + if (val === $ifaceNil) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = reflectType(val.constructor); + _r = makeValue(typ, val.$val, new flag(v.flag).ro()); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (22)) { */ case 3: + if ($clone(v, Value).IsNil()) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + val$1 = $clone(v, Value).object(); + tt = (v.typ.kindType); + fl = (((((v.flag & 96) >>> 0) | 128) >>> 0) | 256) >>> 0; + fl = (fl | (((tt.elem.Kind() >>> 0)))) >>> 0; + $s = -1; return new Value.ptr(tt.elem, (wrapJsObject(tt.elem, val$1)), fl); + /* } else { */ case 4: + $panic(new ValueError.ptr("reflect.Value.Elem", k)); + /* } */ case 5: + case 1: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Elem }; } $f._1 = _1; $f._r = _r; $f.fl = fl; $f.k = k; $f.tt = tt; $f.typ = typ; $f.v = v; $f.val = val; $f.val$1 = val$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Elem = function() { return this.$val.Elem(); }; + Value.ptr.prototype.Field = function(i) { + var _r, _r$1, _r$2, field, fl, i, jsTag, o, prop, s, tag, tt, typ, v, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; field = $f.field; fl = $f.fl; i = $f.i; jsTag = $f.jsTag; o = $f.o; prop = $f.prop; s = $f.s; tag = $f.tag; tt = $f.tt; typ = $f.typ; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + jsTag = [jsTag]; + prop = [prop]; + s = [s]; + typ = [typ]; + v = this; + if (!((new flag(v.flag).kind() === 25))) { + $panic(new ValueError.ptr("reflect.Value.Field", new flag(v.flag).kind())); + } + tt = (v.typ.kindType); + if (((i >>> 0)) >= ((tt.fields.$length >>> 0))) { + $panic(new $String("reflect: Field index out of range")); + } + prop[0] = $internalize(jsType(v.typ).fields[i].prop, $String); + field = (x = tt.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + typ[0] = field.typ; + fl = (((v.flag & 416) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; + if (!$clone(field.name, name).isExported()) { + if (field.embedded()) { + fl = (fl | (64)) >>> 0; + } else { + fl = (fl | (32)) >>> 0; + } + } + tag = $clone((x$1 = tt.fields, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])).name, name).tag(); + /* */ if (!(tag === "") && !((i === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(tag === "") && !((i === 0))) { */ case 1: + jsTag[0] = getJsTag(tag); + /* */ if (!(jsTag[0] === "")) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(jsTag[0] === "")) { */ case 3: + /* while (true) { */ case 5: + o = [o]; + _r = $clone(v, Value).Field(0); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* */ if (v.typ === jsObjectPtr) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (v.typ === jsObjectPtr) { */ case 8: + o[0] = $clone(v, Value).object().object; + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, o, prop, s, typ) { return function() { + return $internalize(o[0][$externalize(jsTag[0], $String)], jsType(typ[0])); + }; })(jsTag, o, prop, s, typ), (function(jsTag, o, prop, s, typ) { return function(x$2) { + var x$2; + o[0][$externalize(jsTag[0], $String)] = $externalize(x$2, jsType(typ[0])); + }; })(jsTag, o, prop, s, typ))), fl); + /* } */ case 9: + /* */ if (v.typ.Kind() === 22) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (v.typ.Kind() === 22) { */ case 10: + _r$1 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v = _r$1; + /* } */ case 11: + /* } */ $s = 5; continue; case 6: + /* } */ case 4: + /* } */ case 2: + s[0] = v.ptr; + /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 13: + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, prop, s, typ) { return function() { + return wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]); + }; })(jsTag, prop, s, typ), (function(jsTag, prop, s, typ) { return function(x$2) { + var x$2; + s[0][$externalize(prop[0], $String)] = unwrapJsObject(typ[0], x$2); + }; })(jsTag, prop, s, typ))), fl); + /* } */ case 14: + _r$2 = makeValue(typ[0], wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]), fl); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Field }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.field = field; $f.fl = fl; $f.i = i; $f.jsTag = jsTag; $f.o = o; $f.prop = prop; $f.s = s; $f.tag = tag; $f.tt = tt; $f.typ = typ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Field = function(i) { return this.$val.Field(i); }; + getJsTag = function(tag) { + var _tuple, i, name$1, qvalue, tag, value; + while (true) { + if (!(!(tag === ""))) { break; } + i = 0; + while (true) { + if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } + i = i + (1) >> 0; + } + tag = $substring(tag, i); + if (tag === "") { + break; + } + i = 0; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; } + i = i + (1) >> 0; + } + if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { + break; + } + name$1 = ($substring(tag, 0, i)); + tag = $substring(tag, (i + 1 >> 0)); + i = 1; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } + if (tag.charCodeAt(i) === 92) { + i = i + (1) >> 0; + } + i = i + (1) >> 0; + } + if (i >= tag.length) { + break; + } + qvalue = ($substring(tag, 0, (i + 1 >> 0))); + tag = $substring(tag, (i + 1 >> 0)); + if (name$1 === "js") { + _tuple = strconv.Unquote(qvalue); + value = _tuple[0]; + return value; + } + } + return ""; + }; + Value.ptr.prototype.Index = function(i) { + var _1, _r, _r$1, a, a$1, c, fl, fl$1, fl$2, i, k, s, str, tt, tt$1, typ, typ$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; a = $f.a; a$1 = $f.a$1; c = $f.c; fl = $f.fl; fl$1 = $f.fl$1; fl$2 = $f.fl$2; i = $f.i; k = $f.k; s = $f.s; str = $f.str; tt = $f.tt; tt$1 = $f.tt$1; typ = $f.typ; typ$1 = $f.typ$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + a$1 = [a$1]; + c = [c]; + i = [i]; + typ = [typ]; + typ$1 = [typ$1]; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (23)) { $s = 3; continue; } + /* */ if (_1 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_1 === (17)) { */ case 2: + tt = (v.typ.kindType); + if (i[0] < 0 || i[0] > ((tt.len >> 0))) { + $panic(new $String("reflect: array index out of range")); + } + typ[0] = tt.elem; + fl = (((((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; + a[0] = v.ptr; + /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 7: + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + return wrapJsObject(typ[0], a[0][i[0]]); + }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { + var x; + a[0][i[0]] = unwrapJsObject(typ[0], x); + }; })(a, a$1, c, i, typ, typ$1))), fl); + /* } */ case 8: + _r = makeValue(typ[0], wrapJsObject(typ[0], a[0][i[0]]), fl); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (23)) { */ case 3: + s = $clone(v, Value).object(); + if (i[0] < 0 || i[0] >= ($parseInt(s.$length) >> 0)) { + $panic(new $String("reflect: slice index out of range")); + } + tt$1 = (v.typ.kindType); + typ$1[0] = tt$1.elem; + fl$1 = (((384 | new flag(v.flag).ro()) >>> 0) | ((typ$1[0].Kind() >>> 0))) >>> 0; + i[0] = i[0] + (($parseInt(s.$offset) >> 0)) >> 0; + a$1[0] = s.$array; + /* */ if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { */ case 10: + $s = -1; return new Value.ptr(typ$1[0], (new (jsType(PtrTo(typ$1[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + return wrapJsObject(typ$1[0], a$1[0][i[0]]); + }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { + var x; + a$1[0][i[0]] = unwrapJsObject(typ$1[0], x); + }; })(a, a$1, c, i, typ, typ$1))), fl$1); + /* } */ case 11: + _r$1 = makeValue(typ$1[0], wrapJsObject(typ$1[0], a$1[0][i[0]]), fl$1); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } else if (_1 === (24)) { */ case 4: + str = (v.ptr).$get(); + if (i[0] < 0 || i[0] >= str.length) { + $panic(new $String("reflect: string index out of range")); + } + fl$2 = (((new flag(v.flag).ro() | 8) >>> 0) | 128) >>> 0; + c[0] = str.charCodeAt(i[0]); + $s = -1; return new Value.ptr(uint8Type, ((c.$ptr || (c.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, c)))), fl$2); + /* } else { */ case 5: + $panic(new ValueError.ptr("reflect.Value.Index", k)); + /* } */ case 6: + case 1: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Index }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.a$1 = a$1; $f.c = c; $f.fl = fl; $f.fl$1 = fl$1; $f.fl$2 = fl$2; $f.i = i; $f.k = k; $f.s = s; $f.str = str; $f.tt = tt; $f.tt$1 = tt$1; $f.typ = typ; $f.typ$1 = typ$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Index = function(i) { return this.$val.Index(i); }; + Value.ptr.prototype.InterfaceData = function() { + var v; + v = this; + $panic(errors.New("InterfaceData is not supported by GopherJS")); + }; + Value.prototype.InterfaceData = function() { return this.$val.InterfaceData(); }; + Value.ptr.prototype.IsNil = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (22)) || (_1 === (23))) { + return $clone(v, Value).object() === jsType(v.typ).nil; + } else if (_1 === (18)) { + return $clone(v, Value).object() === $chanNil; + } else if (_1 === (19)) { + return $clone(v, Value).object() === $throwNilPointerError; + } else if (_1 === (21)) { + return $clone(v, Value).object() === false; + } else if (_1 === (20)) { + return $clone(v, Value).object() === $ifaceNil; + } else if (_1 === (26)) { + return $clone(v, Value).object() === 0; + } else { + $panic(new ValueError.ptr("reflect.Value.IsNil", k)); + } + }; + Value.prototype.IsNil = function() { return this.$val.IsNil(); }; + Value.ptr.prototype.Len = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (17)) || (_1 === (24))) { + return $parseInt($clone(v, Value).object().length); + } else if (_1 === (23)) { + return $parseInt($clone(v, Value).object().$length) >> 0; + } else if (_1 === (18)) { + return $parseInt($clone(v, Value).object().$buffer.length) >> 0; + } else if (_1 === (21)) { + return $parseInt($keys($clone(v, Value).object()).length); + } else { + $panic(new ValueError.ptr("reflect.Value.Len", k)); + } + }; + Value.prototype.Len = function() { return this.$val.Len(); }; + Value.ptr.prototype.Pointer = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (18)) || (_1 === (21)) || (_1 === (22)) || (_1 === (26))) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return $clone(v, Value).object(); + } else if (_1 === (19)) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return 1; + } else if (_1 === (23)) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return $clone(v, Value).object().$array; + } else { + $panic(new ValueError.ptr("reflect.Value.Pointer", k)); + } + }; + Value.prototype.Pointer = function() { return this.$val.Pointer(); }; + Value.ptr.prototype.Set = function(x) { + var _1, _r, _r$1, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(x.flag).mustBeExported(); + _r = $clone(x, Value).assignTo("reflect.Set", v.typ, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + /* */ if (!((((v.flag & 128) >>> 0) === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((((v.flag & 128) >>> 0) === 0))) { */ case 2: + _1 = v.typ.Kind(); + /* */ if (_1 === (17)) { $s = 5; continue; } + /* */ if (_1 === (20)) { $s = 6; continue; } + /* */ if (_1 === (25)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_1 === (17)) { */ case 5: + jsType(v.typ).copy(v.ptr, x.ptr); + $s = 9; continue; + /* } else if (_1 === (20)) { */ case 6: + _r$1 = valueInterface($clone(x, Value), false); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v.ptr.$set(_r$1); + $s = 9; continue; + /* } else if (_1 === (25)) { */ case 7: + copyStruct(v.ptr, x.ptr, v.typ); + $s = 9; continue; + /* } else { */ case 8: + v.ptr.$set($clone(x, Value).object()); + /* } */ case 9: + case 4: + $s = -1; return; + /* } */ case 3: + v.ptr = x.ptr; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Set }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Set = function(x) { return this.$val.Set(x); }; + Value.ptr.prototype.SetBytes = function(x) { + var _r, _r$1, _v, slice, typedSlice, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; slice = $f.slice; typedSlice = $f.typedSlice; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 8))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 8))) { */ case 1: + $panic(new $String("reflect.Value.SetBytes of non-byte slice")); + /* } */ case 2: + slice = x; + if (!(v.typ.Name() === "")) { _v = true; $s = 6; continue s; } + _r$1 = v.typ.Elem().Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = !(_r$1 === ""); case 6: + /* */ if (_v) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_v) { */ case 4: + typedSlice = new (jsType(v.typ))(slice.$array); + typedSlice.$offset = slice.$offset; + typedSlice.$length = slice.$length; + typedSlice.$capacity = slice.$capacity; + slice = typedSlice; + /* } */ case 5: + v.ptr.$set(slice); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetBytes }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.slice = slice; $f.typedSlice = typedSlice; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.SetBytes = function(x) { return this.$val.SetBytes(x); }; + Value.ptr.prototype.SetCap = function(n) { + var n, newSlice, s, v; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + s = v.ptr.$get(); + if (n < ($parseInt(s.$length) >> 0) || n > ($parseInt(s.$capacity) >> 0)) { + $panic(new $String("reflect: slice capacity out of range in SetCap")); + } + newSlice = new (jsType(v.typ))(s.$array); + newSlice.$offset = s.$offset; + newSlice.$length = s.$length; + newSlice.$capacity = n; + v.ptr.$set(newSlice); + }; + Value.prototype.SetCap = function(n) { return this.$val.SetCap(n); }; + Value.ptr.prototype.SetLen = function(n) { + var n, newSlice, s, v; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + s = v.ptr.$get(); + if (n < 0 || n > ($parseInt(s.$capacity) >> 0)) { + $panic(new $String("reflect: slice length out of range in SetLen")); + } + newSlice = new (jsType(v.typ))(s.$array); + newSlice.$offset = s.$offset; + newSlice.$length = n; + newSlice.$capacity = s.$capacity; + v.ptr.$set(newSlice); + }; + Value.prototype.SetLen = function(n) { return this.$val.SetLen(n); }; + Value.ptr.prototype.Slice = function(i, j) { + var _1, _r, _r$1, cap, i, j, kind, s, str, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; i = $f.i; j = $f.j; kind = $f.kind; s = $f.s; str = $f.str; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + cap = 0; + typ = $ifaceNil; + s = null; + kind = new flag(v.flag).kind(); + _1 = kind; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (23)) { $s = 3; continue; } + /* */ if (_1 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_1 === (17)) { */ case 2: + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); + } + tt = (v.typ.kindType); + cap = ((tt.len >> 0)); + typ = SliceOf(tt.elem); + s = new (jsType(typ))($clone(v, Value).object()); + $s = 6; continue; + /* } else if (_1 === (23)) { */ case 3: + typ = v.typ; + s = $clone(v, Value).object(); + cap = $parseInt(s.$capacity) >> 0; + $s = 6; continue; + /* } else if (_1 === (24)) { */ case 4: + str = (v.ptr).$get(); + if (i < 0 || j < i || j > str.length) { + $panic(new $String("reflect.Value.Slice: string slice index out of bounds")); + } + _r = ValueOf(new $String($substring(str, i, j))); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else { */ case 5: + $panic(new ValueError.ptr("reflect.Value.Slice", kind)); + /* } */ case 6: + case 1: + if (i < 0 || j < i || j > cap) { + $panic(new $String("reflect.Value.Slice: slice index out of bounds")); + } + _r$1 = makeValue(typ, $subslice(s, i, j), new flag(v.flag).ro()); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.i = i; $f.j = j; $f.kind = kind; $f.s = s; $f.str = str; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Slice = function(i, j) { return this.$val.Slice(i, j); }; + Value.ptr.prototype.Slice3 = function(i, j, k) { + var _1, _r, cap, i, j, k, kind, s, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; cap = $f.cap; i = $f.i; j = $f.j; k = $f.k; kind = $f.kind; s = $f.s; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + cap = 0; + typ = $ifaceNil; + s = null; + kind = new flag(v.flag).kind(); + _1 = kind; + if (_1 === (17)) { + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); + } + tt = (v.typ.kindType); + cap = ((tt.len >> 0)); + typ = SliceOf(tt.elem); + s = new (jsType(typ))($clone(v, Value).object()); + } else if (_1 === (23)) { + typ = v.typ; + s = $clone(v, Value).object(); + cap = $parseInt(s.$capacity) >> 0; + } else { + $panic(new ValueError.ptr("reflect.Value.Slice3", kind)); + } + if (i < 0 || j < i || k < j || k > cap) { + $panic(new $String("reflect.Value.Slice3: slice index out of bounds")); + } + _r = makeValue(typ, $subslice(s, i, j, k), new flag(v.flag).ro()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice3 }; } $f._1 = _1; $f._r = _r; $f.cap = cap; $f.i = i; $f.j = j; $f.k = k; $f.kind = kind; $f.s = s; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Slice3 = function(i, j, k) { return this.$val.Slice3(i, j, k); }; + Value.ptr.prototype.Close = function() { + var v; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + $close($clone(v, Value).object()); + }; + Value.prototype.Close = function() { return this.$val.Close(); }; + chanrecv = function(ch, nb, val) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, ch, comms, nb, received, recvRes, selectRes, selected, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; ch = $f.ch; comms = $f.comms; nb = $f.nb; received = $f.received; recvRes = $f.recvRes; selectRes = $f.selectRes; selected = $f.selected; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + selected = false; + received = false; + comms = new sliceType$11([new sliceType$8([ch])]); + if (nb) { + comms = $append(comms, new sliceType$8([])); + } + _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + selectRes = _r; + if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { + _tmp = false; + _tmp$1 = false; + selected = _tmp; + received = _tmp$1; + $s = -1; return [selected, received]; + } + recvRes = selectRes[1]; + val.$set(recvRes[0]); + _tmp$2 = true; + _tmp$3 = !!(recvRes[1]); + selected = _tmp$2; + received = _tmp$3; + $s = -1; return [selected, received]; + /* */ } return; } if ($f === undefined) { $f = { $blk: chanrecv }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.received = received; $f.recvRes = recvRes; $f.selectRes = selectRes; $f.selected = selected; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + chansend = function(ch, val, nb) { + var _r, ch, comms, nb, selectRes, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; ch = $f.ch; comms = $f.comms; nb = $f.nb; selectRes = $f.selectRes; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + comms = new sliceType$11([new sliceType$8([ch, val.$get()])]); + if (nb) { + comms = $append(comms, new sliceType$8([])); + } + _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + selectRes = _r; + if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { + $s = -1; return false; + } + $s = -1; return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: chansend }; } $f._r = _r; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.selectRes = selectRes; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Swapper = function(slice) { + var _1, _r, a, off, slice, v, vLen, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; a = $f.a; off = $f.off; slice = $f.slice; v = $f.v; vLen = $f.vLen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + off = [off]; + vLen = [vLen]; + _r = ValueOf(slice); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + if (!(($clone(v, Value).Kind() === 23))) { + $panic(new ValueError.ptr("Swapper", $clone(v, Value).Kind())); + } + vLen[0] = (($clone(v, Value).Len() >>> 0)); + _1 = vLen[0]; + if (_1 === (0)) { + $s = -1; return (function(a, off, vLen) { return function(i, j) { + var i, j; + $panic(new $String("reflect: slice index out of range")); + }; })(a, off, vLen); + } else if (_1 === (1)) { + $s = -1; return (function(a, off, vLen) { return function(i, j) { + var i, j; + if (!((i === 0)) || !((j === 0))) { + $panic(new $String("reflect: slice index out of range")); + } + }; })(a, off, vLen); + } + a[0] = slice.$array; + off[0] = $parseInt(slice.$offset) >> 0; + $s = -1; return (function(a, off, vLen) { return function(i, j) { + var i, j, tmp; + if (((i >>> 0)) >= vLen[0] || ((j >>> 0)) >= vLen[0]) { + $panic(new $String("reflect: slice index out of range")); + } + i = i + (off[0]) >> 0; + j = j + (off[0]) >> 0; + tmp = a[0][i]; + a[0][i] = a[0][j]; + a[0][j] = tmp; + }; })(a, off, vLen); + /* */ } return; } if ($f === undefined) { $f = { $blk: Swapper }; } $f._1 = _1; $f._r = _r; $f.a = a; $f.off = off; $f.slice = slice; $f.v = v; $f.vLen = vLen; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Swapper = Swapper; + structField.ptr.prototype.offset = function() { + var f; + f = this; + return f.offsetEmbed >>> 1 >>> 0; + }; + structField.prototype.offset = function() { return this.$val.offset(); }; + structField.ptr.prototype.embedded = function() { + var f; + f = this; + return !((((f.offsetEmbed & 1) >>> 0) === 0)); + }; + structField.prototype.embedded = function() { return this.$val.embedded(); }; + Kind.prototype.String = function() { + var k; + k = this.$val; + if (((k >> 0)) < kindNames.$length) { + return ((k < 0 || k >= kindNames.$length) ? ($throwRuntimeError("index out of range"), undefined) : kindNames.$array[kindNames.$offset + k]); + } + return "kind" + strconv.Itoa(((k >> 0))); + }; + $ptrType(Kind).prototype.String = function() { return new Kind(this.$get()).String(); }; + rtype.ptr.prototype.String = function() { + var s, t; + t = this; + s = $clone(t.nameOff(t.str), name).name(); + if (!((((t.tflag & 2) >>> 0) === 0))) { + return $substring(s, 1); + } + return s; + }; + rtype.prototype.String = function() { return this.$val.String(); }; + rtype.ptr.prototype.Size = function() { + var t; + t = this; + return t.size; + }; + rtype.prototype.Size = function() { return this.$val.Size(); }; + rtype.ptr.prototype.Bits = function() { + var k, t; + t = this; + if (t === ptrType$1.nil) { + $panic(new $String("reflect: Bits of nil Type")); + } + k = t.Kind(); + if (k < 2 || k > 16) { + $panic(new $String("reflect: Bits of non-arithmetic Type " + t.String())); + } + return $imul(((t.size >> 0)), 8); + }; + rtype.prototype.Bits = function() { return this.$val.Bits(); }; + rtype.ptr.prototype.Align = function() { + var t; + t = this; + return ((t.align >> 0)); + }; + rtype.prototype.Align = function() { return this.$val.Align(); }; + rtype.ptr.prototype.FieldAlign = function() { + var t; + t = this; + return ((t.fieldAlign >> 0)); + }; + rtype.prototype.FieldAlign = function() { return this.$val.FieldAlign(); }; + rtype.ptr.prototype.Kind = function() { + var t; + t = this; + return ((((t.kind & 31) >>> 0) >>> 0)); + }; + rtype.prototype.Kind = function() { return this.$val.Kind(); }; + rtype.ptr.prototype.common = function() { + var t; + t = this; + return t; + }; + rtype.prototype.common = function() { return this.$val.common(); }; + rtype.ptr.prototype.exportedMethods = function() { + var t, ut; + t = this; + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + return sliceType$5.nil; + } + return ut.exportedMethods(); + }; + rtype.prototype.exportedMethods = function() { return this.$val.exportedMethods(); }; + rtype.ptr.prototype.NumMethod = function() { + var t, tt; + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + return tt.NumMethod(); + } + return t.exportedMethods().$length; + }; + rtype.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + rtype.ptr.prototype.MethodByName = function(name$1) { + var _i, _r, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, i, m, name$1, ok, p, t, tt, ut, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; i = $f.i; m = $f.m; name$1 = $f.name$1; ok = $f.ok; p = $f.p; t = $f.t; tt = $f.tt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + ok = false; + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + _tuple = tt.MethodByName(name$1); + Method.copy(m, _tuple[0]); + ok = _tuple[1]; + $s = -1; return [m, ok]; + } + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + _tmp = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + _tmp$1 = false; + Method.copy(m, _tmp); + ok = _tmp$1; + $s = -1; return [m, ok]; + } + _ref = ut.exportedMethods(); + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + p = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), method); + /* */ if ($clone(t.nameOff(p.name), name).name() === name$1) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($clone(t.nameOff(p.name), name).name() === name$1) { */ case 3: + _r = t.Method(i); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp$2 = $clone(_r, Method); + _tmp$3 = true; + Method.copy(m, _tmp$2); + ok = _tmp$3; + $s = -1; return [m, ok]; + /* } */ case 4: + _i++; + /* } */ $s = 1; continue; case 2: + _tmp$4 = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + _tmp$5 = false; + Method.copy(m, _tmp$4); + ok = _tmp$5; + $s = -1; return [m, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.MethodByName }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.i = i; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.p = p; $f.t = t; $f.tt = tt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + rtype.ptr.prototype.PkgPath = function() { + var t, ut; + t = this; + if (((t.tflag & 4) >>> 0) === 0) { + return ""; + } + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + return ""; + } + return $clone(t.nameOff(ut.pkgPath), name).name(); + }; + rtype.prototype.PkgPath = function() { return this.$val.PkgPath(); }; + rtype.ptr.prototype.Name = function() { + var i, s, t; + t = this; + if (((t.tflag & 4) >>> 0) === 0) { + return ""; + } + s = t.String(); + i = s.length - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + if (s.charCodeAt(i) === 46) { + break; + } + i = i - (1) >> 0; + } + return $substring(s, (i + 1 >> 0)); + }; + rtype.prototype.Name = function() { return this.$val.Name(); }; + rtype.ptr.prototype.ChanDir = function() { + var t, tt; + t = this; + if (!((t.Kind() === 18))) { + $panic(new $String("reflect: ChanDir of non-chan type")); + } + tt = (t.kindType); + return ((tt.dir >> 0)); + }; + rtype.prototype.ChanDir = function() { return this.$val.ChanDir(); }; + rtype.ptr.prototype.IsVariadic = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: IsVariadic of non-func type")); + } + tt = (t.kindType); + return !((((tt.outCount & 32768) >>> 0) === 0)); + }; + rtype.prototype.IsVariadic = function() { return this.$val.IsVariadic(); }; + rtype.ptr.prototype.Elem = function() { + var _1, t, tt, tt$1, tt$2, tt$3, tt$4; + t = this; + _1 = t.Kind(); + if (_1 === (17)) { + tt = (t.kindType); + return toType(tt.elem); + } else if (_1 === (18)) { + tt$1 = (t.kindType); + return toType(tt$1.elem); + } else if (_1 === (21)) { + tt$2 = (t.kindType); + return toType(tt$2.elem); + } else if (_1 === (22)) { + tt$3 = (t.kindType); + return toType(tt$3.elem); + } else if (_1 === (23)) { + tt$4 = (t.kindType); + return toType(tt$4.elem); + } + $panic(new $String("reflect: Elem of invalid type")); + }; + rtype.prototype.Elem = function() { return this.$val.Elem(); }; + rtype.ptr.prototype.Field = function(i) { + var i, t, tt; + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: Field of non-struct type")); + } + tt = (t.kindType); + return tt.Field(i); + }; + rtype.prototype.Field = function(i) { return this.$val.Field(i); }; + rtype.ptr.prototype.FieldByIndex = function(index) { + var _r, index, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; index = $f.index; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByIndex of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByIndex(index); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByIndex }; } $f._r = _r; $f.index = index; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + rtype.ptr.prototype.FieldByName = function(name$1) { + var _r, name$1, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; name$1 = $f.name$1; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByName of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByName }; } $f._r = _r; $f.name$1 = name$1; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + rtype.ptr.prototype.FieldByNameFunc = function(match) { + var _r, match, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; match = $f.match; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByNameFunc of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f.match = match; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + rtype.ptr.prototype.In = function(i) { + var i, t, tt, x; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: In of non-func type")); + } + tt = (t.kindType); + return toType((x = tt.in$(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); + }; + rtype.prototype.In = function(i) { return this.$val.In(i); }; + rtype.ptr.prototype.Key = function() { + var t, tt; + t = this; + if (!((t.Kind() === 21))) { + $panic(new $String("reflect: Key of non-map type")); + } + tt = (t.kindType); + return toType(tt.key); + }; + rtype.prototype.Key = function() { return this.$val.Key(); }; + rtype.ptr.prototype.Len = function() { + var t, tt; + t = this; + if (!((t.Kind() === 17))) { + $panic(new $String("reflect: Len of non-array type")); + } + tt = (t.kindType); + return ((tt.len >> 0)); + }; + rtype.prototype.Len = function() { return this.$val.Len(); }; + rtype.ptr.prototype.NumField = function() { + var t, tt; + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: NumField of non-struct type")); + } + tt = (t.kindType); + return tt.fields.$length; + }; + rtype.prototype.NumField = function() { return this.$val.NumField(); }; + rtype.ptr.prototype.NumIn = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: NumIn of non-func type")); + } + tt = (t.kindType); + return ((tt.inCount >> 0)); + }; + rtype.prototype.NumIn = function() { return this.$val.NumIn(); }; + rtype.ptr.prototype.NumOut = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: NumOut of non-func type")); + } + tt = (t.kindType); + return tt.out().$length; + }; + rtype.prototype.NumOut = function() { return this.$val.NumOut(); }; + rtype.ptr.prototype.Out = function(i) { + var i, t, tt, x; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: Out of non-func type")); + } + tt = (t.kindType); + return toType((x = tt.out(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); + }; + rtype.prototype.Out = function(i) { return this.$val.Out(i); }; + ChanDir.prototype.String = function() { + var _1, d; + d = this.$val; + _1 = d; + if (_1 === (2)) { + return "chan<-"; + } else if (_1 === (1)) { + return "<-chan"; + } else if (_1 === (3)) { + return "chan"; + } + return "ChanDir" + strconv.Itoa(((d >> 0))); + }; + $ptrType(ChanDir).prototype.String = function() { return new ChanDir(this.$get()).String(); }; + interfaceType.ptr.prototype.Method = function(i) { + var i, m, p, pname, t, x; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + t = this; + if (i < 0 || i >= t.methods.$length) { + return m; + } + p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + pname = $clone(t.rtype.nameOff(p.name), name); + m.Name = $clone(pname, name).name(); + if (!$clone(pname, name).isExported()) { + m.PkgPath = $clone(pname, name).pkgPath(); + if (m.PkgPath === "") { + m.PkgPath = $clone(t.pkgPath, name).name(); + } + } + m.Type = toType(t.rtype.typeOff(p.typ)); + m.Index = i; + return m; + }; + interfaceType.prototype.Method = function(i) { return this.$val.Method(i); }; + interfaceType.ptr.prototype.NumMethod = function() { + var t; + t = this; + return t.methods.$length; + }; + interfaceType.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + interfaceType.ptr.prototype.MethodByName = function(name$1) { + var _i, _ref, _tmp, _tmp$1, i, m, name$1, ok, p, t, x; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + ok = false; + t = this; + if (t === ptrType$9.nil) { + return [m, ok]; + } + p = ptrType$10.nil; + _ref = t.methods; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if ($clone(t.rtype.nameOff(p.name), name).name() === name$1) { + _tmp = $clone(t.Method(i), Method); + _tmp$1 = true; + Method.copy(m, _tmp); + ok = _tmp$1; + return [m, ok]; + } + _i++; + } + return [m, ok]; + }; + interfaceType.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + StructTag.prototype.Get = function(key) { + var _tuple, key, tag, v; + tag = this.$val; + _tuple = new StructTag(tag).Lookup(key); + v = _tuple[0]; + return v; + }; + $ptrType(StructTag).prototype.Get = function(key) { return new StructTag(this.$get()).Get(key); }; + StructTag.prototype.Lookup = function(key) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, i, key, name$1, ok, qvalue, tag, value, value$1; + value = ""; + ok = false; + tag = this.$val; + while (true) { + if (!(!(tag === ""))) { break; } + i = 0; + while (true) { + if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } + i = i + (1) >> 0; + } + tag = $substring(tag, i); + if (tag === "") { + break; + } + i = 0; + while (true) { + if (!(i < tag.length && tag.charCodeAt(i) > 32 && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)) && !((tag.charCodeAt(i) === 127)))) { break; } + i = i + (1) >> 0; + } + if ((i === 0) || (i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { + break; + } + name$1 = ($substring(tag, 0, i)); + tag = $substring(tag, (i + 1 >> 0)); + i = 1; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } + if (tag.charCodeAt(i) === 92) { + i = i + (1) >> 0; + } + i = i + (1) >> 0; + } + if (i >= tag.length) { + break; + } + qvalue = ($substring(tag, 0, (i + 1 >> 0))); + tag = $substring(tag, (i + 1 >> 0)); + if (key === name$1) { + _tuple = strconv.Unquote(qvalue); + value$1 = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + break; + } + _tmp = value$1; + _tmp$1 = true; + value = _tmp; + ok = _tmp$1; + return [value, ok]; + } + } + _tmp$2 = ""; + _tmp$3 = false; + value = _tmp$2; + ok = _tmp$3; + return [value, ok]; + }; + $ptrType(StructTag).prototype.Lookup = function(key) { return new StructTag(this.$get()).Lookup(key); }; + structType.ptr.prototype.Field = function(i) { + var f, i, p, t, tag, x; + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + t = this; + if (i < 0 || i >= t.fields.$length) { + $panic(new $String("reflect: Field index out of bounds")); + } + p = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + f.Type = toType(p.typ); + f.Name = $clone(p.name, name).name(); + f.Anonymous = p.embedded(); + if (!$clone(p.name, name).isExported()) { + f.PkgPath = $clone(t.pkgPath, name).name(); + } + tag = $clone(p.name, name).tag(); + if (!(tag === "")) { + f.Tag = (tag); + } + f.Offset = p.offset(); + f.Index = new sliceType$13([i]); + return f; + }; + structType.prototype.Field = function(i) { return this.$val.Field(i); }; + structType.ptr.prototype.FieldByIndex = function(index) { + var _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _v, f, ft, i, index, t, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _v = $f._v; f = $f.f; ft = $f.ft; i = $f.i; index = $f.index; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + t = this; + f.Type = toType(t.rtype); + _ref = index; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + /* */ if (i > 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (i > 0) { */ case 3: + ft = f.Type; + _r = ft.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + if (!(_r === 22)) { _v = false; $s = 7; continue s; } + _r$1 = ft.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v = _r$2 === 25; case 7: + /* */ if (_v) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_v) { */ case 5: + _r$3 = ft.Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ft = _r$3; + /* } */ case 6: + f.Type = ft; + /* } */ case 4: + _r$4 = f.Type.Field(x); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + StructField.copy(f, _r$4); + _i++; + /* } */ $s = 1; continue; case 2: + $s = -1; return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._v = _v; $f.f = f; $f.ft = ft; $f.i = i; $f.index = index; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + structType.ptr.prototype.FieldByNameFunc = function(match) { + var _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _key$2, _key$3, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, count, current, f, fname, i, index, match, next, nextCount, ntyp, ok, result, scan, styp, t, t$1, visited, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; count = $f.count; current = $f.current; f = $f.f; fname = $f.fname; i = $f.i; index = $f.index; match = $f.match; next = $f.next; nextCount = $f.nextCount; ntyp = $f.ntyp; ok = $f.ok; result = $f.result; scan = $f.scan; styp = $f.styp; t = $f.t; t$1 = $f.t$1; visited = $f.visited; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + ok = false; + t = this; + current = new sliceType$14([]); + next = new sliceType$14([new fieldScan.ptr(t, sliceType$13.nil)]); + nextCount = false; + visited = $makeMap(ptrType$11.keyFor, []); + /* while (true) { */ case 1: + /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; } + _tmp = next; + _tmp$1 = $subslice(current, 0, 0); + current = _tmp; + next = _tmp$1; + count = nextCount; + nextCount = false; + _ref = current; + _i = 0; + /* while (true) { */ case 3: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } + scan = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), fieldScan); + t$1 = scan.typ; + /* */ if ((_entry = visited[ptrType$11.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((_entry = visited[ptrType$11.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { */ case 5: + _i++; + /* continue; */ $s = 3; continue; + /* } */ case 6: + _key = t$1; (visited || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key)] = { k: _key, v: true }; + _ref$1 = t$1.fields; + _i$1 = 0; + /* while (true) { */ case 7: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; } + i = _i$1; + f = (x = t$1.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + fname = $clone(f.name, name).name(); + ntyp = ptrType$1.nil; + /* */ if (f.embedded()) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (f.embedded()) { */ case 9: + ntyp = f.typ; + /* */ if (ntyp.Kind() === 22) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (ntyp.Kind() === 22) { */ case 11: + _r = ntyp.Elem().common(); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ntyp = _r; + /* } */ case 12: + /* } */ case 10: + _r$1 = match(fname); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (_r$1) { */ case 14: + if ((_entry$1 = count[ptrType$11.keyFor(t$1)], _entry$1 !== undefined ? _entry$1.v : 0) > 1 || ok) { + _tmp$2 = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + _tmp$3 = false; + StructField.copy(result, _tmp$2); + ok = _tmp$3; + $s = -1; return [result, ok]; + } + StructField.copy(result, t$1.Field(i)); + result.Index = sliceType$13.nil; + result.Index = $appendSlice(result.Index, scan.index); + result.Index = $append(result.Index, i); + ok = true; + _i$1++; + /* continue; */ $s = 7; continue; + /* } */ case 15: + if (ok || ntyp === ptrType$1.nil || !((ntyp.Kind() === 25))) { + _i$1++; + /* continue; */ $s = 7; continue; + } + styp = (ntyp.kindType); + if ((_entry$2 = nextCount[ptrType$11.keyFor(styp)], _entry$2 !== undefined ? _entry$2.v : 0) > 0) { + _key$1 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$1)] = { k: _key$1, v: 2 }; + _i$1++; + /* continue; */ $s = 7; continue; + } + if (nextCount === false) { + nextCount = $makeMap(ptrType$11.keyFor, []); + } + _key$2 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$2)] = { k: _key$2, v: 1 }; + if ((_entry$3 = count[ptrType$11.keyFor(t$1)], _entry$3 !== undefined ? _entry$3.v : 0) > 1) { + _key$3 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$3)] = { k: _key$3, v: 2 }; + } + index = sliceType$13.nil; + index = $appendSlice(index, scan.index); + index = $append(index, i); + next = $append(next, new fieldScan.ptr(styp, index)); + _i$1++; + /* } */ $s = 7; continue; case 8: + _i++; + /* } */ $s = 3; continue; case 4: + if (ok) { + /* break; */ $s = 2; continue; + } + /* } */ $s = 1; continue; case 2: + $s = -1; return [result, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByNameFunc }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.count = count; $f.current = current; $f.f = f; $f.fname = fname; $f.i = i; $f.index = index; $f.match = match; $f.next = next; $f.nextCount = nextCount; $f.ntyp = ntyp; $f.ok = ok; $f.result = result; $f.scan = scan; $f.styp = styp; $f.t = t; $f.t$1 = t$1; $f.visited = visited; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + structType.ptr.prototype.FieldByName = function(name$1) { + var _i, _r, _ref, _tmp, _tmp$1, _tuple, f, hasEmbeds, i, name$1, present, t, tf, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; hasEmbeds = $f.hasEmbeds; i = $f.i; name$1 = $f.name$1; present = $f.present; t = $f.t; tf = $f.tf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name$1 = [name$1]; + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + present = false; + t = this; + hasEmbeds = false; + if (!(name$1[0] === "")) { + _ref = t.fields; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + tf = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if ($clone(tf.name, name).name() === name$1[0]) { + _tmp = $clone(t.Field(i), StructField); + _tmp$1 = true; + StructField.copy(f, _tmp); + present = _tmp$1; + $s = -1; return [f, present]; + } + if (tf.embedded()) { + hasEmbeds = true; + } + _i++; + } + } + if (!hasEmbeds) { + $s = -1; return [f, present]; + } + _r = t.FieldByNameFunc((function(name$1) { return function(s) { + var s; + return s === name$1[0]; + }; })(name$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + StructField.copy(f, _tuple[0]); + present = _tuple[1]; + $s = -1; return [f, present]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByName }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.hasEmbeds = hasEmbeds; $f.i = i; $f.name$1 = name$1; $f.present = present; $f.t = t; $f.tf = tf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + PtrTo = function(t) { + var t; + return $assertType(t, ptrType$1).ptrTo(); + }; + $pkg.PtrTo = PtrTo; + rtype.ptr.prototype.Implements = function(u) { + var _r, t, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.Implements")); + } + _r = u.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 20))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 20))) { */ case 1: + $panic(new $String("reflect: non-interface type passed to Type.Implements")); + /* } */ case 2: + $s = -1; return implements$1($assertType(u, ptrType$1), t); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Implements }; } $f._r = _r; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Implements = function(u) { return this.$val.Implements(u); }; + rtype.ptr.prototype.AssignableTo = function(u) { + var _r, t, u, uu, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.AssignableTo")); + } + uu = $assertType(u, ptrType$1); + _r = directlyAssignable(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r || implements$1(uu, t); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.AssignableTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.AssignableTo = function(u) { return this.$val.AssignableTo(u); }; + rtype.ptr.prototype.ConvertibleTo = function(u) { + var _r, t, u, uu, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.ConvertibleTo")); + } + uu = $assertType(u, ptrType$1); + _r = convertOp(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return !(_r === $throwNilPointerError); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.ConvertibleTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.ConvertibleTo = function(u) { return this.$val.ConvertibleTo(u); }; + implements$1 = function(T, V) { + var T, V, i, i$1, j, j$1, t, tm, tm$1, tmName, tmName$1, tmPkgPath, tmPkgPath$1, v, v$1, vm, vm$1, vmName, vmName$1, vmPkgPath, vmPkgPath$1, vmethods, x, x$1, x$2; + if (!((T.Kind() === 20))) { + return false; + } + t = (T.kindType); + if (t.methods.$length === 0) { + return true; + } + if (V.Kind() === 20) { + v = (V.kindType); + i = 0; + j = 0; + while (true) { + if (!(j < v.methods.$length)) { break; } + tm = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + tmName = $clone(t.rtype.nameOff(tm.name), name); + vm = (x$1 = v.methods, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])); + vmName = $clone(V.nameOff(vm.name), name); + if ($clone(vmName, name).name() === $clone(tmName, name).name() && V.typeOff(vm.typ) === t.rtype.typeOff(tm.typ)) { + if (!$clone(tmName, name).isExported()) { + tmPkgPath = $clone(tmName, name).pkgPath(); + if (tmPkgPath === "") { + tmPkgPath = $clone(t.pkgPath, name).name(); + } + vmPkgPath = $clone(vmName, name).pkgPath(); + if (vmPkgPath === "") { + vmPkgPath = $clone(v.pkgPath, name).name(); + } + if (!(tmPkgPath === vmPkgPath)) { + j = j + (1) >> 0; + continue; + } + } + i = i + (1) >> 0; + if (i >= t.methods.$length) { + return true; + } + } + j = j + (1) >> 0; + } + return false; + } + v$1 = V.uncommon(); + if (v$1 === ptrType$5.nil) { + return false; + } + i$1 = 0; + vmethods = v$1.methods(); + j$1 = 0; + while (true) { + if (!(j$1 < ((v$1.mcount >> 0)))) { break; } + tm$1 = (x$2 = t.methods, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])); + tmName$1 = $clone(t.rtype.nameOff(tm$1.name), name); + vm$1 = $clone(((j$1 < 0 || j$1 >= vmethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : vmethods.$array[vmethods.$offset + j$1]), method); + vmName$1 = $clone(V.nameOff(vm$1.name), name); + if ($clone(vmName$1, name).name() === $clone(tmName$1, name).name() && V.typeOff(vm$1.mtyp) === t.rtype.typeOff(tm$1.typ)) { + if (!$clone(tmName$1, name).isExported()) { + tmPkgPath$1 = $clone(tmName$1, name).pkgPath(); + if (tmPkgPath$1 === "") { + tmPkgPath$1 = $clone(t.pkgPath, name).name(); + } + vmPkgPath$1 = $clone(vmName$1, name).pkgPath(); + if (vmPkgPath$1 === "") { + vmPkgPath$1 = $clone(V.nameOff(v$1.pkgPath), name).name(); + } + if (!(tmPkgPath$1 === vmPkgPath$1)) { + j$1 = j$1 + (1) >> 0; + continue; + } + } + i$1 = i$1 + (1) >> 0; + if (i$1 >= t.methods.$length) { + return true; + } + } + j$1 = j$1 + (1) >> 0; + } + return false; + }; + directlyAssignable = function(T, V) { + var T, V, _r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _r = $f._r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (T === V) { + $s = -1; return true; + } + if (!(T.Name() === "") && !(V.Name() === "") || !((T.Kind() === V.Kind()))) { + $s = -1; return false; + } + _r = haveIdenticalUnderlyingType(T, V, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: directlyAssignable }; } $f.T = T; $f.V = V; $f._r = _r; $f.$s = $s; $f.$r = $r; return $f; + }; + haveIdenticalType = function(T, V, cmpTags) { + var T, V, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _v, cmpTags, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _v = $f._v; cmpTags = $f.cmpTags; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (cmpTags) { + $s = -1; return $interfaceIsEqual(T, V); + } + _r = T.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = V.Name(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + if (!(_r === _r$1)) { _v = true; $s = 3; continue s; } + _r$2 = T.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = V.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _v = !((_r$2 === _r$3)); case 3: + /* */ if (_v) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_v) { */ case 1: + $s = -1; return false; + /* } */ case 2: + _r$4 = T.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _arg = _r$4; + _r$5 = V.common(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + _r$6 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + $s = -1; return _r$6; + /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalType }; } $f.T = T; $f.V = V; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._v = _v; $f.cmpTags = cmpTags; $f.$s = $s; $f.$r = $r; return $f; + }; + haveIdenticalUnderlyingType = function(T, V, cmpTags) { + var T, V, _1, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _v, _v$1, _v$2, _v$3, cmpTags, i, i$1, i$2, kind, t, t$1, t$2, tf, v, v$1, v$2, vf, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; cmpTags = $f.cmpTags; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; kind = $f.kind; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; tf = $f.tf; v = $f.v; v$1 = $f.v$1; v$2 = $f.v$2; vf = $f.vf; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (T === V) { + $s = -1; return true; + } + kind = T.Kind(); + if (!((kind === V.Kind()))) { + $s = -1; return false; + } + if (1 <= kind && kind <= 16 || (kind === 24) || (kind === 26)) { + $s = -1; return true; + } + _1 = kind; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (18)) { $s = 3; continue; } + /* */ if (_1 === (19)) { $s = 4; continue; } + /* */ if (_1 === (20)) { $s = 5; continue; } + /* */ if (_1 === (21)) { $s = 6; continue; } + /* */ if ((_1 === (22)) || (_1 === (23))) { $s = 7; continue; } + /* */ if (_1 === (25)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_1 === (17)) { */ case 2: + if (!(T.Len() === V.Len())) { _v = false; $s = 10; continue s; } + _r = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 10: + $s = -1; return _v; + /* } else if (_1 === (18)) { */ case 3: + if (!(V.ChanDir() === 3)) { _v$1 = false; $s = 14; continue s; } + _r$1 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v$1 = _r$1; case 14: + /* */ if (_v$1) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_v$1) { */ case 12: + $s = -1; return true; + /* } */ case 13: + if (!(V.ChanDir() === T.ChanDir())) { _v$2 = false; $s = 16; continue s; } + _r$2 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$2 = _r$2; case 16: + $s = -1; return _v$2; + /* } else if (_1 === (19)) { */ case 4: + t = (T.kindType); + v = (V.kindType); + if (!((t.outCount === v.outCount)) || !((t.inCount === v.inCount))) { + $s = -1; return false; + } + i = 0; + /* while (true) { */ case 18: + /* if (!(i < t.rtype.NumIn())) { break; } */ if(!(i < t.rtype.NumIn())) { $s = 19; continue; } + _r$3 = haveIdenticalType(t.rtype.In(i), v.rtype.In(i), cmpTags); /* */ $s = 22; case 22: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (!_r$3) { */ case 20: + $s = -1; return false; + /* } */ case 21: + i = i + (1) >> 0; + /* } */ $s = 18; continue; case 19: + i$1 = 0; + /* while (true) { */ case 23: + /* if (!(i$1 < t.rtype.NumOut())) { break; } */ if(!(i$1 < t.rtype.NumOut())) { $s = 24; continue; } + _r$4 = haveIdenticalType(t.rtype.Out(i$1), v.rtype.Out(i$1), cmpTags); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (!_r$4) { */ case 25: + $s = -1; return false; + /* } */ case 26: + i$1 = i$1 + (1) >> 0; + /* } */ $s = 23; continue; case 24: + $s = -1; return true; + /* } else if (_1 === (20)) { */ case 5: + t$1 = (T.kindType); + v$1 = (V.kindType); + if ((t$1.methods.$length === 0) && (v$1.methods.$length === 0)) { + $s = -1; return true; + } + $s = -1; return false; + /* } else if (_1 === (21)) { */ case 6: + _r$5 = haveIdenticalType(T.Key(), V.Key(), cmpTags); /* */ $s = 29; case 29: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + if (!(_r$5)) { _v$3 = false; $s = 28; continue s; } + _r$6 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 30; case 30: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v$3 = _r$6; case 28: + $s = -1; return _v$3; + /* } else if ((_1 === (22)) || (_1 === (23))) { */ case 7: + _r$7 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 31; case 31: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return _r$7; + /* } else if (_1 === (25)) { */ case 8: + t$2 = (T.kindType); + v$2 = (V.kindType); + if (!((t$2.fields.$length === v$2.fields.$length))) { + $s = -1; return false; + } + if (!($clone(t$2.pkgPath, name).name() === $clone(v$2.pkgPath, name).name())) { + $s = -1; return false; + } + _ref = t$2.fields; + _i = 0; + /* while (true) { */ case 32: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 33; continue; } + i$2 = _i; + tf = (x = t$2.fields, ((i$2 < 0 || i$2 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i$2])); + vf = (x$1 = v$2.fields, ((i$2 < 0 || i$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i$2])); + if (!($clone(tf.name, name).name() === $clone(vf.name, name).name())) { + $s = -1; return false; + } + _r$8 = haveIdenticalType(tf.typ, vf.typ, cmpTags); /* */ $s = 36; case 36: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + /* */ if (!_r$8) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if (!_r$8) { */ case 34: + $s = -1; return false; + /* } */ case 35: + if (cmpTags && !($clone(tf.name, name).tag() === $clone(vf.name, name).tag())) { + $s = -1; return false; + } + if (!((tf.offsetEmbed === vf.offsetEmbed))) { + $s = -1; return false; + } + _i++; + /* } */ $s = 32; continue; case 33: + $s = -1; return true; + /* } */ case 9: + case 1: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalUnderlyingType }; } $f.T = T; $f.V = V; $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.cmpTags = cmpTags; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.kind = kind; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.tf = tf; $f.v = v; $f.v$1 = v$1; $f.v$2 = v$2; $f.vf = vf; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + toType = function(t) { + var t; + if (t === ptrType$1.nil) { + return $ifaceNil; + } + return t; + }; + ifaceIndir = function(t) { + var t; + return ((t.kind & 32) >>> 0) === 0; + }; + flag.prototype.kind = function() { + var f; + f = this.$val; + return ((((f & 31) >>> 0) >>> 0)); + }; + $ptrType(flag).prototype.kind = function() { return new flag(this.$get()).kind(); }; + flag.prototype.ro = function() { + var f; + f = this.$val; + if (!((((f & 96) >>> 0) === 0))) { + return 32; + } + return 0; + }; + $ptrType(flag).prototype.ro = function() { return new flag(this.$get()).ro(); }; + Value.ptr.prototype.pointer = function() { + var v; + v = this; + if (!((v.typ.size === 4)) || !v.typ.pointers()) { + $panic(new $String("can't call pointer on a non-pointer Value")); + } + if (!((((v.flag & 128) >>> 0) === 0))) { + return (v.ptr).$get(); + } + return v.ptr; + }; + Value.prototype.pointer = function() { return this.$val.pointer(); }; + ValueError.ptr.prototype.Error = function() { + var e; + e = this; + if (e.Kind === 0) { + return "reflect: call of " + e.Method + " on zero Value"; + } + return "reflect: call of " + e.Method + " on " + new Kind(e.Kind).String() + " Value"; + }; + ValueError.prototype.Error = function() { return this.$val.Error(); }; + flag.prototype.mustBe = function(expected) { + var expected, f; + f = this.$val; + if (!((new flag(f).kind() === expected))) { + $panic(new ValueError.ptr(methodName(), new flag(f).kind())); + } + }; + $ptrType(flag).prototype.mustBe = function(expected) { return new flag(this.$get()).mustBe(expected); }; + flag.prototype.mustBeExported = function() { + var f; + f = this.$val; + if (f === 0) { + $panic(new ValueError.ptr(methodName(), 0)); + } + if (!((((f & 96) >>> 0) === 0))) { + $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); + } + }; + $ptrType(flag).prototype.mustBeExported = function() { return new flag(this.$get()).mustBeExported(); }; + flag.prototype.mustBeAssignable = function() { + var f; + f = this.$val; + if (f === 0) { + $panic(new ValueError.ptr(methodName(), 0)); + } + if (!((((f & 96) >>> 0) === 0))) { + $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); + } + if (((f & 256) >>> 0) === 0) { + $panic(new $String("reflect: " + methodName() + " using unaddressable value")); + } + }; + $ptrType(flag).prototype.mustBeAssignable = function() { return new flag(this.$get()).mustBeAssignable(); }; + Value.ptr.prototype.Addr = function() { + var v; + v = this; + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Addr of unaddressable value")); + } + return new Value.ptr(v.typ.ptrTo(), v.ptr, (new flag(v.flag).ro() | 22) >>> 0); + }; + Value.prototype.Addr = function() { return this.$val.Addr(); }; + Value.ptr.prototype.Bool = function() { + var v; + v = this; + new flag(v.flag).mustBe(1); + return (v.ptr).$get(); + }; + Value.prototype.Bool = function() { return this.$val.Bool(); }; + Value.ptr.prototype.Bytes = function() { + var _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 8))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 8))) { */ case 1: + $panic(new $String("reflect.Value.Bytes of non-byte slice")); + /* } */ case 2: + $s = -1; return (v.ptr).$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Bytes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Bytes = function() { return this.$val.Bytes(); }; + Value.ptr.prototype.runes = function() { + var _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 5))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 5))) { */ case 1: + $panic(new $String("reflect.Value.Bytes of non-rune slice")); + /* } */ case 2: + $s = -1; return (v.ptr).$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.runes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.runes = function() { return this.$val.runes(); }; + Value.ptr.prototype.CanAddr = function() { + var v; + v = this; + return !((((v.flag & 256) >>> 0) === 0)); + }; + Value.prototype.CanAddr = function() { return this.$val.CanAddr(); }; + Value.ptr.prototype.CanSet = function() { + var v; + v = this; + return ((v.flag & 352) >>> 0) === 256; + }; + Value.prototype.CanSet = function() { return this.$val.CanSet(); }; + Value.ptr.prototype.Call = function(in$1) { + var _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(19); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).call("Call", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Call }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Call = function(in$1) { return this.$val.Call(in$1); }; + Value.ptr.prototype.CallSlice = function(in$1) { + var _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(19); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).call("CallSlice", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.CallSlice }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.CallSlice = function(in$1) { return this.$val.CallSlice(in$1); }; + Value.ptr.prototype.Complex = function() { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + return ((x = (v.ptr).$get(), new $Complex128(x.$real, x.$imag))); + } else if (_1 === (16)) { + return (v.ptr).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Complex", new flag(v.flag).kind())); + }; + Value.prototype.Complex = function() { return this.$val.Complex(); }; + Value.ptr.prototype.FieldByIndex = function(index) { + var _i, _r, _r$1, _r$2, _r$3, _ref, _v, i, index, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _v = $f._v; i = $f.i; index = $f.index; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (index.$length === 1) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (index.$length === 1) { */ case 1: + _r = $clone(v, Value).Field((0 >= index.$length ? ($throwRuntimeError("index out of range"), undefined) : index.$array[index.$offset + 0])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + new flag(v.flag).mustBe(25); + _ref = index; + _i = 0; + /* while (true) { */ case 4: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } + i = _i; + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + /* */ if (i > 0) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (i > 0) { */ case 6: + if (!($clone(v, Value).Kind() === 22)) { _v = false; $s = 10; continue s; } + _r$1 = v.typ.Elem().Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = _r$1 === 25; case 10: + /* */ if (_v) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_v) { */ case 8: + if ($clone(v, Value).IsNil()) { + $panic(new $String("reflect: indirection through nil pointer to embedded struct")); + } + _r$2 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* } */ case 9: + /* } */ case 7: + _r$3 = $clone(v, Value).Field(x); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + _i++; + /* } */ $s = 4; continue; case 5: + $s = -1; return v; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._v = _v; $f.i = i; $f.index = index; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + Value.ptr.prototype.FieldByName = function(name$1) { + var _r, _r$1, _tuple, f, name$1, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(25); + _r = v.typ.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + f = $clone(_tuple[0], StructField); + ok = _tuple[1]; + /* */ if (ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (ok) { */ case 2: + _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 3: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByName }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + Value.ptr.prototype.FieldByNameFunc = function(match) { + var _r, _r$1, _tuple, f, match, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; match = $f.match; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + _r = v.typ.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + f = $clone(_tuple[0], StructField); + ok = _tuple[1]; + /* */ if (ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (ok) { */ case 2: + _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 3: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.match = match; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + Value.ptr.prototype.Float = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + return ((v.ptr).$get()); + } else if (_1 === (14)) { + return (v.ptr).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Float", new flag(v.flag).kind())); + }; + Value.prototype.Float = function() { return this.$val.Float(); }; + Value.ptr.prototype.Int = function() { + var _1, k, p, v; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _1 = k; + if (_1 === (2)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (3)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (4)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (5)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (6)) { + return (p).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Int", new flag(v.flag).kind())); + }; + Value.prototype.Int = function() { return this.$val.Int(); }; + Value.ptr.prototype.CanInterface = function() { + var v; + v = this; + if (v.flag === 0) { + $panic(new ValueError.ptr("reflect.Value.CanInterface", 0)); + } + return ((v.flag & 96) >>> 0) === 0; + }; + Value.prototype.CanInterface = function() { return this.$val.CanInterface(); }; + Value.ptr.prototype.Interface = function() { + var _r, i, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = $ifaceNil; + v = this; + _r = valueInterface($clone(v, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + i = _r; + $s = -1; return i; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Interface }; } $f._r = _r; $f.i = i; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Interface = function() { return this.$val.Interface(); }; + Value.ptr.prototype.IsValid = function() { + var v; + v = this; + return !((v.flag === 0)); + }; + Value.prototype.IsValid = function() { return this.$val.IsValid(); }; + Value.ptr.prototype.Kind = function() { + var v; + v = this; + return new flag(v.flag).kind(); + }; + Value.prototype.Kind = function() { return this.$val.Kind(); }; + Value.ptr.prototype.MapIndex = function(key) { + var _r, e, fl, k, key, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; fl = $f.fl; k = $f.k; key = $f.key; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + tt = (v.typ.kindType); + _r = $clone(key, Value).assignTo("reflect.Value.MapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + k = 0; + if (!((((key.flag & 128) >>> 0) === 0))) { + k = key.ptr; + } else { + k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); + } + e = mapaccess(v.typ, $clone(v, Value).pointer(), k); + if (e === 0) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = tt.elem; + fl = new flag((((v.flag | key.flag) >>> 0))).ro(); + fl = (fl | (((typ.Kind() >>> 0)))) >>> 0; + $s = -1; return copyVal(typ, fl, e); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapIndex }; } $f._r = _r; $f.e = e; $f.fl = fl; $f.k = k; $f.key = key; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MapIndex = function(key) { return this.$val.MapIndex(key); }; + Value.ptr.prototype.MapKeys = function() { + var _r, a, fl, i, it, key, keyType, m, mlen, tt, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; fl = $f.fl; i = $f.i; it = $f.it; key = $f.key; keyType = $f.keyType; m = $f.m; mlen = $f.mlen; tt = $f.tt; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + tt = (v.typ.kindType); + keyType = tt.key; + fl = (new flag(v.flag).ro() | ((keyType.Kind() >>> 0))) >>> 0; + m = $clone(v, Value).pointer(); + mlen = 0; + if (!(m === 0)) { + mlen = maplen(m); + } + it = mapiterinit(v.typ, m); + a = $makeSlice(sliceType$9, mlen); + i = 0; + i = 0; + /* while (true) { */ case 1: + /* if (!(i < a.$length)) { break; } */ if(!(i < a.$length)) { $s = 2; continue; } + _r = mapiterkey(it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + if (key === 0) { + /* break; */ $s = 2; continue; + } + ((i < 0 || i >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + i] = copyVal(keyType, fl, key)); + mapiternext(it); + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return $subslice(a, 0, i); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapKeys }; } $f._r = _r; $f.a = a; $f.fl = fl; $f.i = i; $f.it = it; $f.key = key; $f.keyType = keyType; $f.m = m; $f.mlen = mlen; $f.tt = tt; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MapKeys = function() { return this.$val.MapKeys(); }; + MapIter.ptr.prototype.Key = function() { + var _arg, _arg$1, _arg$2, _r, _r$1, _r$2, it, ktype, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; ktype = $f.ktype; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + it = this; + if (it.it === 0) { + $panic(new $String("MapIter.Key called before Next")); + } + _r = mapiterkey(it.it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r === 0) { */ case 1: + $panic(new $String("MapIter.Key called on exhausted iterator")); + /* } */ case 2: + t = (it.m.typ.kindType); + ktype = t.key; + _arg = ktype; + _arg$1 = (new flag(it.m.flag).ro() | ((ktype.Kind() >>> 0))) >>> 0; + _r$1 = mapiterkey(it.it); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$2 = _r$1; + _r$2 = copyVal(_arg, _arg$1, _arg$2); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Key }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.ktype = ktype; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + MapIter.prototype.Key = function() { return this.$val.Key(); }; + MapIter.ptr.prototype.Value = function() { + var _arg, _arg$1, _arg$2, _r, _r$1, _r$2, it, t, vtype, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; t = $f.t; vtype = $f.vtype; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + it = this; + if (it.it === 0) { + $panic(new $String("MapIter.Value called before Next")); + } + _r = mapiterkey(it.it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r === 0) { */ case 1: + $panic(new $String("MapIter.Value called on exhausted iterator")); + /* } */ case 2: + t = (it.m.typ.kindType); + vtype = t.elem; + _arg = vtype; + _arg$1 = (new flag(it.m.flag).ro() | ((vtype.Kind() >>> 0))) >>> 0; + _r$1 = mapitervalue(it.it); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$2 = _r$1; + _r$2 = copyVal(_arg, _arg$1, _arg$2); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Value }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.t = t; $f.vtype = vtype; $f.$s = $s; $f.$r = $r; return $f; + }; + MapIter.prototype.Value = function() { return this.$val.Value(); }; + MapIter.ptr.prototype.Next = function() { + var _r, _r$1, it, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; it = $f.it; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + it = this; + /* */ if (it.it === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (it.it === 0) { */ case 1: + it.it = mapiterinit(it.m.typ, $clone(it.m, Value).pointer()); + $s = 3; continue; + /* } else { */ case 2: + _r = mapiterkey(it.it); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r === 0) { */ case 4: + $panic(new $String("MapIter.Next called on exhausted iterator")); + /* } */ case 5: + mapiternext(it.it); + /* } */ case 3: + _r$1 = mapiterkey(it.it); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return !(_r$1 === 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Next }; } $f._r = _r; $f._r$1 = _r$1; $f.it = it; $f.$s = $s; $f.$r = $r; return $f; + }; + MapIter.prototype.Next = function() { return this.$val.Next(); }; + Value.ptr.prototype.MapRange = function() { + var v; + v = this; + new flag(v.flag).mustBe(21); + return new MapIter.ptr($clone(v, Value), 0); + }; + Value.prototype.MapRange = function() { return this.$val.MapRange(); }; + copyVal = function(typ, fl, ptr) { + var c, fl, ptr, typ; + if (ifaceIndir(typ)) { + c = unsafe_New(typ); + typedmemmove(typ, c, ptr); + return new Value.ptr(typ, c, (fl | 128) >>> 0); + } + return new Value.ptr(typ, (ptr).$get(), fl); + }; + Value.ptr.prototype.Method = function(i) { + var fl, i, v; + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.Method", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0)) || ((i >>> 0)) >= ((v.typ.NumMethod() >>> 0))) { + $panic(new $String("reflect: Method index out of range")); + } + if ((v.typ.Kind() === 20) && $clone(v, Value).IsNil()) { + $panic(new $String("reflect: Method on nil interface value")); + } + fl = (v.flag & 160) >>> 0; + fl = (fl | (19)) >>> 0; + fl = (fl | ((((((i >>> 0)) << 10 >>> 0) | 512) >>> 0))) >>> 0; + return new Value.ptr(v.typ, v.ptr, fl); + }; + Value.prototype.Method = function(i) { return this.$val.Method(i); }; + Value.ptr.prototype.NumMethod = function() { + var v; + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.NumMethod", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { + return 0; + } + return v.typ.NumMethod(); + }; + Value.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + Value.ptr.prototype.MethodByName = function(name$1) { + var _r, _tuple, m, name$1, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; m = $f.m; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.MethodByName", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + _r = v.typ.MethodByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = $clone(_tuple[0], Method); + ok = _tuple[1]; + if (!ok) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + $s = -1; return $clone(v, Value).Method(m.Index); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MethodByName }; } $f._r = _r; $f._tuple = _tuple; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + Value.ptr.prototype.NumField = function() { + var tt, v; + v = this; + new flag(v.flag).mustBe(25); + tt = (v.typ.kindType); + return tt.fields.$length; + }; + Value.prototype.NumField = function() { return this.$val.NumField(); }; + Value.ptr.prototype.OverflowComplex = function(x) { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + return overflowFloat32(x.$real) || overflowFloat32(x.$imag); + } else if (_1 === (16)) { + return false; + } + $panic(new ValueError.ptr("reflect.Value.OverflowComplex", new flag(v.flag).kind())); + }; + Value.prototype.OverflowComplex = function(x) { return this.$val.OverflowComplex(x); }; + Value.ptr.prototype.OverflowFloat = function(x) { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + return overflowFloat32(x); + } else if (_1 === (14)) { + return false; + } + $panic(new ValueError.ptr("reflect.Value.OverflowFloat", new flag(v.flag).kind())); + }; + Value.prototype.OverflowFloat = function(x) { return this.$val.OverflowFloat(x); }; + overflowFloat32 = function(x) { + var x; + if (x < 0) { + x = -x; + } + return 3.4028234663852886e+38 < x && x <= 1.7976931348623157e+308; + }; + Value.ptr.prototype.OverflowInt = function(x) { + var _1, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + bitSize = $imul(v.typ.size, 8) >>> 0; + trunc = $shiftRightInt64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); + return !((x.$high === trunc.$high && x.$low === trunc.$low)); + } + $panic(new ValueError.ptr("reflect.Value.OverflowInt", new flag(v.flag).kind())); + }; + Value.prototype.OverflowInt = function(x) { return this.$val.OverflowInt(x); }; + Value.ptr.prototype.OverflowUint = function(x) { + var _1, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (7)) || (_1 === (12)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11))) { + bitSize = $imul(v.typ.size, 8) >>> 0; + trunc = $shiftRightUint64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); + return !((x.$high === trunc.$high && x.$low === trunc.$low)); + } + $panic(new ValueError.ptr("reflect.Value.OverflowUint", new flag(v.flag).kind())); + }; + Value.prototype.OverflowUint = function(x) { return this.$val.OverflowUint(x); }; + Value.ptr.prototype.Recv = function() { + var _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).recv(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + x = _tuple[0]; + ok = _tuple[1]; + $s = -1; return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Recv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Recv = function() { return this.$val.Recv(); }; + Value.ptr.prototype.recv = function(nb) { + var _r, _tuple, nb, ok, p, selected, t, tt, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; nb = $f.nb; ok = $f.ok; p = $f.p; selected = $f.selected; t = $f.t; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + val = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + tt = (v.typ.kindType); + if ((((tt.dir >> 0)) & 1) === 0) { + $panic(new $String("reflect: recv on send-only channel")); + } + t = tt.elem; + val = new Value.ptr(t, 0, ((t.Kind() >>> 0))); + p = 0; + if (ifaceIndir(t)) { + p = unsafe_New(t); + val.ptr = p; + val.flag = (val.flag | (128)) >>> 0; + } else { + p = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); + } + _r = chanrecv($clone(v, Value).pointer(), nb, p); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + selected = _tuple[0]; + ok = _tuple[1]; + if (!selected) { + val = new Value.ptr(ptrType$1.nil, 0, 0); + } + $s = -1; return [val, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.recv }; } $f._r = _r; $f._tuple = _tuple; $f.nb = nb; $f.ok = ok; $f.p = p; $f.selected = selected; $f.t = t; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.recv = function(nb) { return this.$val.recv(nb); }; + Value.ptr.prototype.Send = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).send($clone(x, Value), false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Send }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Send = function(x) { return this.$val.Send(x); }; + Value.ptr.prototype.send = function(x, nb) { + var _r, _r$1, nb, p, selected, tt, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; nb = $f.nb; p = $f.p; selected = $f.selected; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + selected = false; + v = this; + tt = (v.typ.kindType); + if ((((tt.dir >> 0)) & 2) === 0) { + $panic(new $String("reflect: send on recv-only channel")); + } + new flag(x.flag).mustBeExported(); + _r = $clone(x, Value).assignTo("reflect.Value.Send", tt.elem, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + p = 0; + if (!((((x.flag & 128) >>> 0) === 0))) { + p = x.ptr; + } else { + p = ((x.$ptr_ptr || (x.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, x)))); + } + _r$1 = chansend($clone(v, Value).pointer(), p, nb); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + selected = _r$1; + $s = -1; return selected; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.send }; } $f._r = _r; $f._r$1 = _r$1; $f.nb = nb; $f.p = p; $f.selected = selected; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.send = function(x, nb) { return this.$val.send(x, nb); }; + Value.ptr.prototype.SetBool = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(1); + (v.ptr).$set(x); + }; + Value.prototype.SetBool = function(x) { return this.$val.SetBool(x); }; + Value.ptr.prototype.setRunes = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 5))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 5))) { */ case 1: + $panic(new $String("reflect.Value.setRunes of non-rune slice")); + /* } */ case 2: + (v.ptr).$set(x); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.setRunes }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.setRunes = function(x) { return this.$val.setRunes(x); }; + Value.ptr.prototype.SetComplex = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + (v.ptr).$set((new $Complex64(x.$real, x.$imag))); + } else if (_1 === (16)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetComplex", new flag(v.flag).kind())); + } + }; + Value.prototype.SetComplex = function(x) { return this.$val.SetComplex(x); }; + Value.ptr.prototype.SetFloat = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + (v.ptr).$set(($fround(x))); + } else if (_1 === (14)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetFloat", new flag(v.flag).kind())); + } + }; + Value.prototype.SetFloat = function(x) { return this.$val.SetFloat(x); }; + Value.ptr.prototype.SetInt = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (2)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); + } else if (_1 === (3)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24))); + } else if (_1 === (4)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 16 >> 16))); + } else if (_1 === (5)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); + } else if (_1 === (6)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetInt", new flag(v.flag).kind())); + } + }; + Value.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; + Value.ptr.prototype.SetMapIndex = function(key, val) { + var _r, _r$1, e, k, key, tt, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; e = $f.e; k = $f.k; key = $f.key; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + new flag(v.flag).mustBeExported(); + new flag(key.flag).mustBeExported(); + tt = (v.typ.kindType); + _r = $clone(key, Value).assignTo("reflect.Value.SetMapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + k = 0; + if (!((((key.flag & 128) >>> 0) === 0))) { + k = key.ptr; + } else { + k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); + } + if (val.typ === ptrType$1.nil) { + mapdelete(v.typ, $clone(v, Value).pointer(), k); + $s = -1; return; + } + new flag(val.flag).mustBeExported(); + _r$1 = $clone(val, Value).assignTo("reflect.Value.SetMapIndex", tt.elem, 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + val = _r$1; + e = 0; + if (!((((val.flag & 128) >>> 0) === 0))) { + e = val.ptr; + } else { + e = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); + } + $r = mapassign(v.typ, $clone(v, Value).pointer(), k, e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetMapIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.e = e; $f.k = k; $f.key = key; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.SetMapIndex = function(key, val) { return this.$val.SetMapIndex(key, val); }; + Value.ptr.prototype.SetUint = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (7)) { + (v.ptr).$set(((x.$low >>> 0))); + } else if (_1 === (8)) { + (v.ptr).$set(((x.$low << 24 >>> 24))); + } else if (_1 === (9)) { + (v.ptr).$set(((x.$low << 16 >>> 16))); + } else if (_1 === (10)) { + (v.ptr).$set(((x.$low >>> 0))); + } else if (_1 === (11)) { + (v.ptr).$set(x); + } else if (_1 === (12)) { + (v.ptr).$set(((x.$low >>> 0))); + } else { + $panic(new ValueError.ptr("reflect.Value.SetUint", new flag(v.flag).kind())); + } + }; + Value.prototype.SetUint = function(x) { return this.$val.SetUint(x); }; + Value.ptr.prototype.SetPointer = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(26); + (v.ptr).$set(x); + }; + Value.prototype.SetPointer = function(x) { return this.$val.SetPointer(x); }; + Value.ptr.prototype.SetString = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(24); + (v.ptr).$set(x); + }; + Value.prototype.SetString = function(x) { return this.$val.SetString(x); }; + Value.ptr.prototype.String = function() { + var _1, _r, k, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; k = $f.k; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (0)) { + $s = -1; return ""; + } else if (_1 === (24)) { + $s = -1; return (v.ptr).$get(); + } + _r = $clone(v, Value).Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return "<" + _r + " Value>"; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.String }; } $f._1 = _1; $f._r = _r; $f.k = k; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.String = function() { return this.$val.String(); }; + Value.ptr.prototype.TryRecv = function() { + var _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).recv(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + x = _tuple[0]; + ok = _tuple[1]; + $s = -1; return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TryRecv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.TryRecv = function() { return this.$val.TryRecv(); }; + Value.ptr.prototype.TrySend = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).send($clone(x, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TrySend }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.TrySend = function(x) { return this.$val.TrySend(x); }; + Value.ptr.prototype.Type = function() { + var f, i, m, m$1, ms, tt, v, x; + v = this; + f = v.flag; + if (f === 0) { + $panic(new ValueError.ptr("reflect.Value.Type", 0)); + } + if (((f & 512) >>> 0) === 0) { + return v.typ; + } + i = ((v.flag >> 0)) >> 10 >> 0; + if (v.typ.Kind() === 20) { + tt = (v.typ.kindType); + if (((i >>> 0)) >= ((tt.methods.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + return v.typ.typeOff(m.typ); + } + ms = v.typ.exportedMethods(); + if (((i >>> 0)) >= ((ms.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); + return v.typ.typeOff(m$1.mtyp); + }; + Value.prototype.Type = function() { return this.$val.Type(); }; + Value.ptr.prototype.Uint = function() { + var _1, k, p, v, x; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _1 = k; + if (_1 === (7)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (8)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (9)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (10)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (11)) { + return (p).$get(); + } else if (_1 === (12)) { + return ((x = (p).$get(), new $Uint64(0, x.constructor === Number ? x : 1))); + } + $panic(new ValueError.ptr("reflect.Value.Uint", new flag(v.flag).kind())); + }; + Value.prototype.Uint = function() { return this.$val.Uint(); }; + Value.ptr.prototype.UnsafeAddr = function() { + var v; + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.UnsafeAddr", 0)); + } + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.UnsafeAddr of unaddressable value")); + } + return (v.ptr); + }; + Value.prototype.UnsafeAddr = function() { return this.$val.UnsafeAddr(); }; + New = function(typ) { + var fl, ptr, t, typ; + if ($interfaceIsEqual(typ, $ifaceNil)) { + $panic(new $String("reflect: New(nil)")); + } + t = $assertType(typ, ptrType$1); + ptr = unsafe_New(t); + fl = 22; + return new Value.ptr(t.ptrTo(), ptr, fl); + }; + $pkg.New = New; + Value.ptr.prototype.Convert = function(t) { + var _r, _r$1, _r$2, _r$3, _r$4, op, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; op = $f.op; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue("Convert", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + _r$1 = t.common(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = convertOp(_r$1, v.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + op = _r$2; + /* */ if (op === $throwNilPointerError) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (op === $throwNilPointerError) { */ case 6: + _r$3 = t.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $panic(new $String("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + _r$3)); + /* } */ case 7: + _r$4 = op($clone(v, Value), t); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Convert }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.op = op; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Convert = function(t) { return this.$val.Convert(t); }; + convertOp = function(dst, src) { + var _1, _2, _3, _4, _5, _6, _7, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _v, _v$1, _v$2, dst, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _5 = $f._5; _6 = $f._6; _7 = $f._7; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; dst = $f.dst; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _1 = src.Kind(); + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 2; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 3; continue; } + /* */ if ((_1 === (13)) || (_1 === (14))) { $s = 4; continue; } + /* */ if ((_1 === (15)) || (_1 === (16))) { $s = 5; continue; } + /* */ if (_1 === (24)) { $s = 6; continue; } + /* */ if (_1 === (23)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 2: + _2 = dst.Kind(); + if ((_2 === (2)) || (_2 === (3)) || (_2 === (4)) || (_2 === (5)) || (_2 === (6)) || (_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10)) || (_2 === (11)) || (_2 === (12))) { + $s = -1; return cvtInt; + } else if ((_2 === (13)) || (_2 === (14))) { + $s = -1; return cvtIntFloat; + } else if (_2 === (24)) { + $s = -1; return cvtIntString; + } + $s = 8; continue; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 3: + _3 = dst.Kind(); + if ((_3 === (2)) || (_3 === (3)) || (_3 === (4)) || (_3 === (5)) || (_3 === (6)) || (_3 === (7)) || (_3 === (8)) || (_3 === (9)) || (_3 === (10)) || (_3 === (11)) || (_3 === (12))) { + $s = -1; return cvtUint; + } else if ((_3 === (13)) || (_3 === (14))) { + $s = -1; return cvtUintFloat; + } else if (_3 === (24)) { + $s = -1; return cvtUintString; + } + $s = 8; continue; + /* } else if ((_1 === (13)) || (_1 === (14))) { */ case 4: + _4 = dst.Kind(); + if ((_4 === (2)) || (_4 === (3)) || (_4 === (4)) || (_4 === (5)) || (_4 === (6))) { + $s = -1; return cvtFloatInt; + } else if ((_4 === (7)) || (_4 === (8)) || (_4 === (9)) || (_4 === (10)) || (_4 === (11)) || (_4 === (12))) { + $s = -1; return cvtFloatUint; + } else if ((_4 === (13)) || (_4 === (14))) { + $s = -1; return cvtFloat; + } + $s = 8; continue; + /* } else if ((_1 === (15)) || (_1 === (16))) { */ case 5: + _5 = dst.Kind(); + if ((_5 === (15)) || (_5 === (16))) { + $s = -1; return cvtComplex; + } + $s = 8; continue; + /* } else if (_1 === (24)) { */ case 6: + if (!(dst.Kind() === 23)) { _v = false; $s = 11; continue s; } + _r = dst.Elem().PkgPath(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r === ""; case 11: + /* */ if (_v) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_v) { */ case 9: + _r$1 = dst.Elem().Kind(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _6 = _r$1; + if (_6 === (8)) { + $s = -1; return cvtStringBytes; + } else if (_6 === (5)) { + $s = -1; return cvtStringRunes; + } + case 13: + /* } */ case 10: + $s = 8; continue; + /* } else if (_1 === (23)) { */ case 7: + if (!(dst.Kind() === 24)) { _v$1 = false; $s = 17; continue s; } + _r$2 = src.Elem().PkgPath(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$1 = _r$2 === ""; case 17: + /* */ if (_v$1) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (_v$1) { */ case 15: + _r$3 = src.Elem().Kind(); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _7 = _r$3; + if (_7 === (8)) { + $s = -1; return cvtBytesString; + } else if (_7 === (5)) { + $s = -1; return cvtRunesString; + } + case 19: + /* } */ case 16: + /* } */ case 8: + case 1: + _r$4 = haveIdenticalUnderlyingType(dst, src, false); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (_r$4) { */ case 21: + $s = -1; return cvtDirect; + /* } */ case 22: + if (!((dst.Kind() === 22) && dst.Name() === "" && (src.Kind() === 22) && src.Name() === "")) { _v$2 = false; $s = 26; continue s; } + _r$5 = dst.Elem().common(); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg = _r$5; + _r$6 = src.Elem().common(); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$1 = _r$6; + _r$7 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 29; case 29: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v$2 = _r$7; case 26: + /* */ if (_v$2) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (_v$2) { */ case 24: + $s = -1; return cvtDirect; + /* } */ case 25: + if (implements$1(dst, src)) { + if (src.Kind() === 20) { + $s = -1; return cvtI2I; + } + $s = -1; return cvtT2I; + } + $s = -1; return $throwNilPointerError; + /* */ } return; } if ($f === undefined) { $f = { $blk: convertOp }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._5 = _5; $f._6 = _6; $f._7 = _7; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.dst = dst; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + makeFloat = function(f, v, t) { + var _1, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.size; + if (_1 === (4)) { + (ptr).$set(($fround(v))); + } else if (_1 === (8)) { + (ptr).$set(v); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeFloat }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeComplex = function(f, v, t) { + var _1, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.size; + if (_1 === (8)) { + (ptr).$set((new $Complex64(v.$real, v.$imag))); + } else if (_1 === (16)) { + (ptr).$set(v); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeComplex }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeString = function(f, v, t) { + var _r, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ret = _r; + $clone(ret, Value).SetString(v); + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeString }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeBytes = function(f, v, t) { + var _r, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ret = _r; + $r = $clone(ret, Value).SetBytes(v); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeBytes }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeRunes = function(f, v, t) { + var _r, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ret = _r; + $r = $clone(ret, Value).setRunes(v); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeRunes }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtInt = function(v, t) { + var _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), ((x = $clone(v, Value).Int(), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUint = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), $clone(v, Value).Uint(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloatInt = function(v, t) { + var _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), ((x = (new $Int64(0, $clone(v, Value).Float())), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloatUint = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), (new $Uint64(0, $clone(v, Value).Float())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Int())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Uint())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), $clone(v, Value).Float(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtComplex = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeComplex(new flag(v.flag).ro(), $clone(v, Value).Complex(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtComplex }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntString = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Int().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintString = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Uint().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtBytesString = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = ($bytesToString(_r)); + _arg$2 = t; + _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtBytesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtStringBytes = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = (new sliceType$15($stringToBytes(_r))); + _arg$2 = t; + _r$1 = makeBytes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringBytes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtRunesString = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).runes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = ($runesToString(_r)); + _arg$2 = t; + _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtRunesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtStringRunes = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = (new sliceType$18($stringToRunes(_r))); + _arg$2 = t; + _r$1 = makeRunes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringRunes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtT2I = function(v, typ) { + var _r, _r$1, _r$2, _r$3, _r$4, target, typ, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; target = $f.target; typ = $f.typ; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = unsafe_New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + target = _r$1; + _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + _r$3 = typ.NumMethod(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$3 === 0) { */ case 4: + (target).$set(x); + $s = 6; continue; + /* } else { */ case 5: + ifaceE2I($assertType(typ, ptrType$1), x, target); + /* } */ case 6: + _r$4 = typ.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$4, target, (((new flag(v.flag).ro() | 128) >>> 0) | 20) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtT2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.target = target; $f.typ = typ; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtI2I = function(v, typ) { + var _r, _r$1, _r$2, ret, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; ret = $f.ret; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if ($clone(v, Value).IsNil()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(v, Value).IsNil()) { */ case 1: + _r = Zero(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ret = _r; + ret.flag = (ret.flag | (new flag(v.flag).ro())) >>> 0; + $s = -1; return ret; + /* } */ case 2: + _r$1 = $clone(v, Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = cvtT2I($clone(_r$1, Value), typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtI2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.ret = ret; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrType$5.methods = [{prop: "methods", name: "methods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}, {prop: "exportedMethods", name: "exportedMethods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}]; + ptrType$8.methods = [{prop: "in$", name: "in", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}, {prop: "out", name: "out", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}]; + name.methods = [{prop: "name", name: "name", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "tag", name: "tag", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "isExported", name: "isExported", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "data", name: "data", pkg: "reflect", typ: $funcType([$Int, $String], [ptrType$4], false)}, {prop: "nameLen", name: "nameLen", pkg: "reflect", typ: $funcType([], [$Int], false)}, {prop: "tagLen", name: "tagLen", pkg: "reflect", typ: $funcType([], [$Int], false)}]; + ptrType$7.methods = [{prop: "skipUntilValidKey", name: "skipUntilValidKey", pkg: "reflect", typ: $funcType([], [], false)}]; + Kind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}, {prop: "nameOff", name: "nameOff", pkg: "reflect", typ: $funcType([nameOff], [name], false)}, {prop: "typeOff", name: "typeOff", pkg: "reflect", typ: $funcType([typeOff], [ptrType$1], false)}, {prop: "ptrTo", name: "ptrTo", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "pointers", name: "pointers", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "textOff", name: "textOff", pkg: "reflect", typ: $funcType([textOff], [$UnsafePointer], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "exportedMethods", name: "exportedMethods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}]; + ChanDir.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$9.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}]; + ptrType$18.methods = [{prop: "offset", name: "offset", pkg: "reflect", typ: $funcType([], [$Uintptr], false)}, {prop: "embedded", name: "embedded", pkg: "reflect", typ: $funcType([], [$Bool], false)}]; + ptrType$11.methods = [{prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}]; + StructTag.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [$String, $Bool], false)}]; + Value.methods = [{prop: "object", name: "object", pkg: "reflect", typ: $funcType([], [ptrType$2], false)}, {prop: "assignTo", name: "assignTo", pkg: "reflect", typ: $funcType([$String, ptrType$1, $UnsafePointer], [Value], false)}, {prop: "call", name: "call", pkg: "reflect", typ: $funcType([$String, sliceType$9], [sliceType$9], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "InterfaceData", name: "InterfaceData", pkg: "", typ: $funcType([], [arrayType$8], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Pointer", name: "Pointer", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([Value], [], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$15], [], false)}, {prop: "SetCap", name: "SetCap", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Slice", name: "Slice", pkg: "", typ: $funcType([$Int, $Int], [Value], false)}, {prop: "Slice3", name: "Slice3", pkg: "", typ: $funcType([$Int, $Int, $Int], [Value], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "pointer", name: "pointer", pkg: "reflect", typ: $funcType([], [$UnsafePointer], false)}, {prop: "Addr", name: "Addr", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$15], false)}, {prop: "runes", name: "runes", pkg: "reflect", typ: $funcType([], [sliceType$18], false)}, {prop: "CanAddr", name: "CanAddr", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CanSet", name: "CanSet", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "CallSlice", name: "CallSlice", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "Complex", name: "Complex", pkg: "", typ: $funcType([], [$Complex128], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [Value], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [Value], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "CanInterface", name: "CanInterface", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "MapIndex", name: "MapIndex", pkg: "", typ: $funcType([Value], [Value], false)}, {prop: "MapKeys", name: "MapKeys", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "MapRange", name: "MapRange", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OverflowComplex", name: "OverflowComplex", pkg: "", typ: $funcType([$Complex128], [$Bool], false)}, {prop: "OverflowFloat", name: "OverflowFloat", pkg: "", typ: $funcType([$Float64], [$Bool], false)}, {prop: "OverflowInt", name: "OverflowInt", pkg: "", typ: $funcType([$Int64], [$Bool], false)}, {prop: "OverflowUint", name: "OverflowUint", pkg: "", typ: $funcType([$Uint64], [$Bool], false)}, {prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "recv", name: "recv", pkg: "reflect", typ: $funcType([$Bool], [Value, $Bool], false)}, {prop: "Send", name: "Send", pkg: "", typ: $funcType([Value], [], false)}, {prop: "send", name: "send", pkg: "reflect", typ: $funcType([Value, $Bool], [$Bool], false)}, {prop: "SetBool", name: "SetBool", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "setRunes", name: "setRunes", pkg: "reflect", typ: $funcType([sliceType$18], [], false)}, {prop: "SetComplex", name: "SetComplex", pkg: "", typ: $funcType([$Complex128], [], false)}, {prop: "SetFloat", name: "SetFloat", pkg: "", typ: $funcType([$Float64], [], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "SetMapIndex", name: "SetMapIndex", pkg: "", typ: $funcType([Value, Value], [], false)}, {prop: "SetUint", name: "SetUint", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "SetPointer", name: "SetPointer", pkg: "", typ: $funcType([$UnsafePointer], [], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TryRecv", name: "TryRecv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "TrySend", name: "TrySend", pkg: "", typ: $funcType([Value], [$Bool], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "UnsafeAddr", name: "UnsafeAddr", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Convert", name: "Convert", pkg: "", typ: $funcType([Type], [Value], false)}]; + flag.methods = [{prop: "kind", name: "kind", pkg: "reflect", typ: $funcType([], [Kind], false)}, {prop: "ro", name: "ro", pkg: "reflect", typ: $funcType([], [flag], false)}, {prop: "mustBe", name: "mustBe", pkg: "reflect", typ: $funcType([Kind], [], false)}, {prop: "mustBeExported", name: "mustBeExported", pkg: "reflect", typ: $funcType([], [], false)}, {prop: "mustBeAssignable", name: "mustBeAssignable", pkg: "reflect", typ: $funcType([], [], false)}]; + ptrType$20.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$19.methods = [{prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([], [$Bool], false)}]; + uncommonType.init("reflect", [{prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "mcount", name: "mcount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "xcount", name: "xcount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "moff", name: "moff", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "_methods", name: "_methods", embedded: false, exported: false, typ: sliceType$5, tag: ""}]); + funcType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: "reflect:\"func\""}, {prop: "inCount", name: "inCount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "outCount", name: "outCount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "_in", name: "_in", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "_out", name: "_out", embedded: false, exported: false, typ: sliceType$2, tag: ""}]); + name.init("reflect", [{prop: "bytes", name: "bytes", embedded: false, exported: false, typ: ptrType$4, tag: ""}]); + nameData.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tag", name: "tag", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "exported", name: "exported", embedded: false, exported: false, typ: $Bool, tag: ""}]); + mapIter.init("reflect", [{prop: "t", name: "t", embedded: false, exported: false, typ: Type, tag: ""}, {prop: "m", name: "m", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "keys", name: "keys", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "last", name: "last", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); + Type.init([{prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}]); + rtype.init("reflect", [{prop: "size", name: "size", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "ptrdata", name: "ptrdata", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "hash", name: "hash", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "tflag", name: "tflag", embedded: false, exported: false, typ: tflag, tag: ""}, {prop: "align", name: "align", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "fieldAlign", name: "fieldAlign", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "kind", name: "kind", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "alg", name: "alg", embedded: false, exported: false, typ: ptrType$3, tag: ""}, {prop: "gcdata", name: "gcdata", embedded: false, exported: false, typ: ptrType$4, tag: ""}, {prop: "str", name: "str", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "ptrToThis", name: "ptrToThis", embedded: false, exported: false, typ: typeOff, tag: ""}]); + typeAlg.init("reflect", [{prop: "hash", name: "hash", embedded: false, exported: false, typ: funcType$4, tag: ""}, {prop: "equal", name: "equal", embedded: false, exported: false, typ: funcType$5, tag: ""}]); + method.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "mtyp", name: "mtyp", embedded: false, exported: false, typ: typeOff, tag: ""}, {prop: "ifn", name: "ifn", embedded: false, exported: false, typ: textOff, tag: ""}, {prop: "tfn", name: "tfn", embedded: false, exported: false, typ: textOff, tag: ""}]); + arrayType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "slice", name: "slice", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); + chanType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "dir", name: "dir", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); + imethod.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: typeOff, tag: ""}]); + interfaceType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: name, tag: ""}, {prop: "methods", name: "methods", embedded: false, exported: false, typ: sliceType$6, tag: ""}]); + mapType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "key", name: "key", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "bucket", name: "bucket", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "keysize", name: "keysize", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "valuesize", name: "valuesize", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "bucketsize", name: "bucketsize", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "flags", name: "flags", embedded: false, exported: false, typ: $Uint32, tag: ""}]); + ptrType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); + sliceType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); + structField.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: name, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "offsetEmbed", name: "offsetEmbed", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); + structType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: name, tag: ""}, {prop: "fields", name: "fields", embedded: false, exported: false, typ: sliceType$7, tag: ""}]); + Method.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", embedded: false, exported: true, typ: Type, tag: ""}, {prop: "Func", name: "Func", embedded: false, exported: true, typ: Value, tag: ""}, {prop: "Index", name: "Index", embedded: false, exported: true, typ: $Int, tag: ""}]); + StructField.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", embedded: false, exported: true, typ: Type, tag: ""}, {prop: "Tag", name: "Tag", embedded: false, exported: true, typ: StructTag, tag: ""}, {prop: "Offset", name: "Offset", embedded: false, exported: true, typ: $Uintptr, tag: ""}, {prop: "Index", name: "Index", embedded: false, exported: true, typ: sliceType$13, tag: ""}, {prop: "Anonymous", name: "Anonymous", embedded: false, exported: true, typ: $Bool, tag: ""}]); + fieldScan.init("reflect", [{prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$11, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: sliceType$13, tag: ""}]); + Value.init("reflect", [{prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "ptr", name: "ptr", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "flag", name: "flag", embedded: true, exported: false, typ: flag, tag: ""}]); + ValueError.init("", [{prop: "Method", name: "Method", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Kind", name: "Kind", embedded: false, exported: true, typ: Kind, tag: ""}]); + MapIter.init("reflect", [{prop: "m", name: "m", embedded: false, exported: false, typ: Value, tag: ""}, {prop: "it", name: "it", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + nameOffList = sliceType$1.nil; + typeOffList = sliceType$2.nil; + initialized = false; + uncommonTypeMap = {}; + nameMap = {}; + callHelper = $assertType($internalize($call, $emptyInterface), funcType$1); + selectHelper = $assertType($internalize($select, $emptyInterface), funcType$1); + jsObjectPtr = reflectType($jsObjectPtr); + kindNames = new sliceType$4(["invalid", "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "array", "chan", "func", "interface", "map", "ptr", "slice", "string", "struct", "unsafe.Pointer"]); + uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); + $r = init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["sort"] = (function() { + var $pkg = {}, $init, reflect, lessSwap, IntSlice, sliceType, funcType, funcType$1, Search, SearchInts, Slice, insertionSort, siftDown, heapSort, medianOfThree, swapRange, doPivot, quickSort, Sort, maxDepth, Ints, Stable, stable, symMerge, rotate, insertionSort_func, siftDown_func, heapSort_func, medianOfThree_func, doPivot_func, quickSort_func; + reflect = $packages["reflect"]; + lessSwap = $pkg.lessSwap = $newType(0, $kindStruct, "sort.lessSwap", true, "sort", false, function(Less_, Swap_) { + this.$val = this; + if (arguments.length === 0) { + this.Less = $throwNilPointerError; + this.Swap = $throwNilPointerError; + return; + } + this.Less = Less_; + this.Swap = Swap_; + }); + IntSlice = $pkg.IntSlice = $newType(12, $kindSlice, "sort.IntSlice", true, "sort", true, null); + sliceType = $sliceType($Int); + funcType = $funcType([$Int, $Int], [$Bool], false); + funcType$1 = $funcType([$Int, $Int], [], false); + Search = function(n, f) { + var _r, _tmp, _tmp$1, f, h, i, j, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; f = $f.f; h = $f.h; i = $f.i; j = $f.j; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tmp = 0; + _tmp$1 = n; + i = _tmp; + j = _tmp$1; + /* while (true) { */ case 1: + /* if (!(i < j)) { break; } */ if(!(i < j)) { $s = 2; continue; } + h = ((((((i + j >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + _r = f(h); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!_r) { */ case 3: + i = h + 1 >> 0; + $s = 5; continue; + /* } else { */ case 4: + j = h; + /* } */ case 5: + /* } */ $s = 1; continue; case 2: + $s = -1; return i; + /* */ } return; } if ($f === undefined) { $f = { $blk: Search }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.f = f; $f.h = h; $f.i = i; $f.j = j; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Search = Search; + SearchInts = function(a, x) { + var _r, a, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + x = [x]; + _r = Search(a[0].$length, (function(a, x) { return function(i) { + var i; + return ((i < 0 || i >= a[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : a[0].$array[a[0].$offset + i]) >= x[0]; + }; })(a, x)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: SearchInts }; } $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.SearchInts = SearchInts; + IntSlice.prototype.Search = function(x) { + var _r, p, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _r = SearchInts($subslice(new sliceType(p.$array), p.$offset, p.$offset + p.$length), x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: IntSlice.prototype.Search }; } $f._r = _r; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(IntSlice).prototype.Search = function(x) { return this.$get().Search(x); }; + Slice = function(slice, less) { + var _r, _r$1, length, less, rv, slice, swap, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; length = $f.length; less = $f.less; rv = $f.rv; slice = $f.slice; swap = $f.swap; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = reflect.ValueOf(slice); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + rv = _r; + _r$1 = reflect.Swapper(slice); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + swap = _r$1; + length = $clone(rv, reflect.Value).Len(); + $r = quickSort_func(new lessSwap.ptr(less, swap), 0, length, maxDepth(length)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Slice }; } $f._r = _r; $f._r$1 = _r$1; $f.length = length; $f.less = less; $f.rv = rv; $f.slice = slice; $f.swap = swap; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Slice = Slice; + insertionSort = function(data, a, b) { + var _r, _v, a, b, data, i, j, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _v = $f._v; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = a + 1 >> 0; + /* while (true) { */ case 1: + /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 2; continue; } + j = i; + /* while (true) { */ case 3: + if (!(j > a)) { _v = false; $s = 5; continue s; } + _r = data.Less(j, j - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 5: + /* if (!(_v)) { break; } */ if(!(_v)) { $s = 4; continue; } + $r = data.Swap(j, j - 1 >> 0); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + j = j - (1) >> 0; + /* } */ $s = 3; continue; case 4: + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: insertionSort }; } $f._r = _r; $f._v = _v; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f; + }; + siftDown = function(data, lo, hi, first) { + var _r, _r$1, _v, child, data, first, hi, lo, root, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; child = $f.child; data = $f.data; first = $f.first; hi = $f.hi; lo = $f.lo; root = $f.root; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + root = lo; + /* while (true) { */ case 1: + child = ($imul(2, root)) + 1 >> 0; + if (child >= hi) { + /* break; */ $s = 2; continue; + } + if (!((child + 1 >> 0) < hi)) { _v = false; $s = 5; continue s; } + _r = data.Less(first + child >> 0, (first + child >> 0) + 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 5: + /* */ if (_v) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_v) { */ case 3: + child = child + (1) >> 0; + /* } */ case 4: + _r$1 = data.Less(first + root >> 0, first + child >> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!_r$1) { */ case 7: + $s = -1; return; + /* } */ case 8: + $r = data.Swap(first + root >> 0, first + child >> 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + root = child; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: siftDown }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.child = child; $f.data = data; $f.first = first; $f.hi = hi; $f.lo = lo; $f.root = root; $f.$s = $s; $f.$r = $r; return $f; + }; + heapSort = function(data, a, b) { + var _q, a, b, data, first, hi, i, i$1, lo, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; a = $f.a; b = $f.b; data = $f.data; first = $f.first; hi = $f.hi; i = $f.i; i$1 = $f.i$1; lo = $f.lo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + first = a; + lo = 0; + hi = b - a >> 0; + i = (_q = ((hi - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* while (true) { */ case 1: + /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 2; continue; } + $r = siftDown(data, i, hi, first); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i - (1) >> 0; + /* } */ $s = 1; continue; case 2: + i$1 = hi - 1 >> 0; + /* while (true) { */ case 4: + /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 5; continue; } + $r = data.Swap(first, first + i$1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = siftDown(data, lo, i$1, first); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 - (1) >> 0; + /* } */ $s = 4; continue; case 5: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: heapSort }; } $f._q = _q; $f.a = a; $f.b = b; $f.data = data; $f.first = first; $f.hi = hi; $f.i = i; $f.i$1 = i$1; $f.lo = lo; $f.$s = $s; $f.$r = $r; return $f; + }; + medianOfThree = function(data, m1, m0, m2) { + var _r, _r$1, _r$2, data, m0, m1, m2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; data = $f.data; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = data.Less(m1, m0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + $r = data.Swap(m1, m0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _r$1 = data.Less(m2, m1); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_r$1) { */ case 5: + $r = data.Swap(m2, m1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$2 = data.Less(m1, m0); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (_r$2) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_r$2) { */ case 9: + $r = data.Swap(m1, m0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + /* } */ case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: medianOfThree }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.data = data; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.$s = $s; $f.$r = $r; return $f; + }; + swapRange = function(data, a, b, n) { + var a, b, data, i, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; b = $f.b; data = $f.data; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = 0; + /* while (true) { */ case 1: + /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } + $r = data.Swap(a + i >> 0, b + i >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: swapRange }; } $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + doPivot = function(data, lo, hi) { + var _q, _q$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$2, _tmp$3, _v, _v$1, _v$2, _v$3, _v$4, a, b, c, data, dups, hi, lo, m, midhi, midlo, pivot, protect, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; a = $f.a; b = $f.b; c = $f.c; data = $f.data; dups = $f.dups; hi = $f.hi; lo = $f.lo; m = $f.m; midhi = $f.midhi; midlo = $f.midlo; pivot = $f.pivot; protect = $f.protect; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + midlo = 0; + midhi = 0; + m = ((((((lo + hi >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((hi - lo >> 0) > 40) { */ case 1: + s = (_q = ((hi - lo >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + $r = medianOfThree(data, lo, lo + s >> 0, lo + ($imul(2, s)) >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = medianOfThree(data, m, m - s >> 0, m + s >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = medianOfThree(data, hi - 1 >> 0, (hi - 1 >> 0) - s >> 0, (hi - 1 >> 0) - ($imul(2, s)) >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $r = medianOfThree(data, lo, m, hi - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + pivot = lo; + _tmp = lo + 1 >> 0; + _tmp$1 = hi - 1 >> 0; + a = _tmp; + c = _tmp$1; + /* while (true) { */ case 7: + if (!(a < c)) { _v = false; $s = 9; continue s; } + _r = data.Less(a, pivot); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 9: + /* if (!(_v)) { break; } */ if(!(_v)) { $s = 8; continue; } + a = a + (1) >> 0; + /* } */ $s = 7; continue; case 8: + b = a; + /* while (true) { */ case 11: + /* while (true) { */ case 13: + if (!(b < c)) { _v$1 = false; $s = 15; continue s; } + _r$1 = data.Less(pivot, b); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v$1 = !_r$1; case 15: + /* if (!(_v$1)) { break; } */ if(!(_v$1)) { $s = 14; continue; } + b = b + (1) >> 0; + /* } */ $s = 13; continue; case 14: + /* while (true) { */ case 17: + if (!(b < c)) { _v$2 = false; $s = 19; continue s; } + _r$2 = data.Less(pivot, c - 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$2 = _r$2; case 19: + /* if (!(_v$2)) { break; } */ if(!(_v$2)) { $s = 18; continue; } + c = c - (1) >> 0; + /* } */ $s = 17; continue; case 18: + if (b >= c) { + /* break; */ $s = 12; continue; + } + $r = data.Swap(b, c - 1 >> 0); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = b + (1) >> 0; + c = c - (1) >> 0; + /* } */ $s = 11; continue; case 12: + protect = (hi - c >> 0) < 5; + /* */ if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { */ case 22: + dups = 0; + _r$3 = data.Less(pivot, hi - 1 >> 0); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (!_r$3) { */ case 24: + $r = data.Swap(c, hi - 1 >> 0); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + c = c + (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 25: + _r$4 = data.Less(b - 1 >> 0, pivot); /* */ $s = 30; case 30: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 28; continue; } + /* */ $s = 29; continue; + /* if (!_r$4) { */ case 28: + b = b - (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 29: + _r$5 = data.Less(m, pivot); /* */ $s = 33; case 33: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (!_r$5) { $s = 31; continue; } + /* */ $s = 32; continue; + /* if (!_r$5) { */ case 31: + $r = data.Swap(m, b - 1 >> 0); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = b - (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 32: + protect = dups > 1; + /* } */ case 23: + /* */ if (protect) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (protect) { */ case 35: + /* while (true) { */ case 37: + /* while (true) { */ case 39: + if (!(a < b)) { _v$3 = false; $s = 41; continue s; } + _r$6 = data.Less(b - 1 >> 0, pivot); /* */ $s = 42; case 42: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v$3 = !_r$6; case 41: + /* if (!(_v$3)) { break; } */ if(!(_v$3)) { $s = 40; continue; } + b = b - (1) >> 0; + /* } */ $s = 39; continue; case 40: + /* while (true) { */ case 43: + if (!(a < b)) { _v$4 = false; $s = 45; continue s; } + _r$7 = data.Less(a, pivot); /* */ $s = 46; case 46: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v$4 = _r$7; case 45: + /* if (!(_v$4)) { break; } */ if(!(_v$4)) { $s = 44; continue; } + a = a + (1) >> 0; + /* } */ $s = 43; continue; case 44: + if (a >= b) { + /* break; */ $s = 38; continue; + } + $r = data.Swap(a, b - 1 >> 0); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = a + (1) >> 0; + b = b - (1) >> 0; + /* } */ $s = 37; continue; case 38: + /* } */ case 36: + $r = data.Swap(pivot, b - 1 >> 0); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tmp$2 = b - 1 >> 0; + _tmp$3 = c; + midlo = _tmp$2; + midhi = _tmp$3; + $s = -1; return [midlo, midhi]; + /* */ } return; } if ($f === undefined) { $f = { $blk: doPivot }; } $f._q = _q; $f._q$1 = _q$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.dups = dups; $f.hi = hi; $f.lo = lo; $f.m = m; $f.midhi = midhi; $f.midlo = midlo; $f.pivot = pivot; $f.protect = protect; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + quickSort = function(data, a, b, maxDepth$1) { + var _r, _r$1, _tuple, a, b, data, i, maxDepth$1, mhi, mlo, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; i = $f.i; maxDepth$1 = $f.maxDepth$1; mhi = $f.mhi; mlo = $f.mlo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* while (true) { */ case 1: + /* if (!((b - a >> 0) > 12)) { break; } */ if(!((b - a >> 0) > 12)) { $s = 2; continue; } + /* */ if (maxDepth$1 === 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (maxDepth$1 === 0) { */ case 3: + $r = heapSort(data, a, b); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 4: + maxDepth$1 = maxDepth$1 - (1) >> 0; + _r = doPivot(data, a, b); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + mlo = _tuple[0]; + mhi = _tuple[1]; + /* */ if ((mlo - a >> 0) < (b - mhi >> 0)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((mlo - a >> 0) < (b - mhi >> 0)) { */ case 7: + $r = quickSort(data, a, mlo, maxDepth$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = mhi; + $s = 9; continue; + /* } else { */ case 8: + $r = quickSort(data, mhi, b, maxDepth$1); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = mlo; + /* } */ case 9: + /* } */ $s = 1; continue; case 2: + /* */ if ((b - a >> 0) > 1) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((b - a >> 0) > 1) { */ case 12: + i = a + 6 >> 0; + /* while (true) { */ case 14: + /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 15; continue; } + _r$1 = data.Less(i, i - 6 >> 0); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (_r$1) { */ case 16: + $r = data.Swap(i, i - 6 >> 0); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 17: + i = i + (1) >> 0; + /* } */ $s = 14; continue; case 15: + $r = insertionSort(data, a, b); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 13: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: quickSort }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.maxDepth$1 = maxDepth$1; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f; + }; + Sort = function(data) { + var _r, data, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; data = $f.data; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + n = _r; + $r = quickSort(data, 0, n, maxDepth(n)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f._r = _r; $f.data = data; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sort = Sort; + maxDepth = function(n) { + var depth, i, n; + depth = 0; + i = n; + while (true) { + if (!(i > 0)) { break; } + depth = depth + (1) >> 0; + i = (i >> $min((1), 31)) >> 0; + } + return $imul(depth, 2); + }; + IntSlice.prototype.Len = function() { + var p; + p = this; + return p.$length; + }; + $ptrType(IntSlice).prototype.Len = function() { return this.$get().Len(); }; + IntSlice.prototype.Less = function(i, j) { + var i, j, p; + p = this; + return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); + }; + $ptrType(IntSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + IntSlice.prototype.Swap = function(i, j) { + var _tmp, _tmp$1, i, j, p; + p = this; + _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); + _tmp$1 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); + ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); + ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$1); + }; + $ptrType(IntSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + IntSlice.prototype.Sort = function() { + var p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + $r = Sort(p); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: IntSlice.prototype.Sort }; } $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(IntSlice).prototype.Sort = function() { return this.$get().Sort(); }; + Ints = function(a) { + var a, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = Sort(($subslice(new IntSlice(a.$array), a.$offset, a.$offset + a.$length))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Ints }; } $f.a = a; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Ints = Ints; + Stable = function(data) { + var _arg, _arg$1, _r, data, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; data = $f.data; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = data; + _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = _r; + $r = stable(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Stable }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.data = data; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Stable = Stable; + stable = function(data, n) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, a, b, blockSize, data, m, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; a = $f.a; b = $f.b; blockSize = $f.blockSize; data = $f.data; m = $f.m; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + blockSize = 20; + _tmp = 0; + _tmp$1 = blockSize; + a = _tmp; + b = _tmp$1; + /* while (true) { */ case 1: + /* if (!(b <= n)) { break; } */ if(!(b <= n)) { $s = 2; continue; } + $r = insertionSort(data, a, b); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = b; + b = b + (blockSize) >> 0; + /* } */ $s = 1; continue; case 2: + $r = insertionSort(data, a, n); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* while (true) { */ case 5: + /* if (!(blockSize < n)) { break; } */ if(!(blockSize < n)) { $s = 6; continue; } + _tmp$2 = 0; + _tmp$3 = $imul(2, blockSize); + a = _tmp$2; + b = _tmp$3; + /* while (true) { */ case 7: + /* if (!(b <= n)) { break; } */ if(!(b <= n)) { $s = 8; continue; } + $r = symMerge(data, a, a + blockSize >> 0, b); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = b; + b = b + (($imul(2, blockSize))) >> 0; + /* } */ $s = 7; continue; case 8: + m = a + blockSize >> 0; + /* */ if (m < n) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (m < n) { */ case 10: + $r = symMerge(data, a, m, n); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 11: + blockSize = $imul(blockSize, (2)); + /* } */ $s = 5; continue; case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: stable }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.a = a; $f.b = b; $f.blockSize = blockSize; $f.data = data; $f.m = m; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + symMerge = function(data, a, m, b) { + var _r, _r$1, _r$2, _tmp, _tmp$1, a, b, c, data, end, h, h$1, i, i$1, j, j$1, k, k$1, m, mid, n, p, r, start, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; c = $f.c; data = $f.data; end = $f.end; h = $f.h; h$1 = $f.h$1; i = $f.i; i$1 = $f.i$1; j = $f.j; j$1 = $f.j$1; k = $f.k; k$1 = $f.k$1; m = $f.m; mid = $f.mid; n = $f.n; p = $f.p; r = $f.r; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if ((m - a >> 0) === 1) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((m - a >> 0) === 1) { */ case 1: + i = m; + j = b; + /* while (true) { */ case 3: + /* if (!(i < j)) { break; } */ if(!(i < j)) { $s = 4; continue; } + h = ((((((i + j >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + _r = data.Less(h, a); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_r) { */ case 5: + i = h + 1 >> 0; + $s = 7; continue; + /* } else { */ case 6: + j = h; + /* } */ case 7: + /* } */ $s = 3; continue; case 4: + k = a; + /* while (true) { */ case 9: + /* if (!(k < (i - 1 >> 0))) { break; } */ if(!(k < (i - 1 >> 0))) { $s = 10; continue; } + $r = data.Swap(k, k + 1 >> 0); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + k = k + (1) >> 0; + /* } */ $s = 9; continue; case 10: + $s = -1; return; + /* } */ case 2: + /* */ if ((b - m >> 0) === 1) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((b - m >> 0) === 1) { */ case 12: + i$1 = a; + j$1 = m; + /* while (true) { */ case 14: + /* if (!(i$1 < j$1)) { break; } */ if(!(i$1 < j$1)) { $s = 15; continue; } + h$1 = ((((((i$1 + j$1 >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + _r$1 = data.Less(m, h$1); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (!_r$1) { */ case 16: + i$1 = h$1 + 1 >> 0; + $s = 18; continue; + /* } else { */ case 17: + j$1 = h$1; + /* } */ case 18: + /* } */ $s = 14; continue; case 15: + k$1 = m; + /* while (true) { */ case 20: + /* if (!(k$1 > i$1)) { break; } */ if(!(k$1 > i$1)) { $s = 21; continue; } + $r = data.Swap(k$1, k$1 - 1 >> 0); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + k$1 = k$1 - (1) >> 0; + /* } */ $s = 20; continue; case 21: + $s = -1; return; + /* } */ case 13: + mid = ((((((a + b >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + n = mid + m >> 0; + _tmp = 0; + _tmp$1 = 0; + start = _tmp; + r = _tmp$1; + if (m > mid) { + start = n - b >> 0; + r = mid; + } else { + start = a; + r = m; + } + p = n - 1 >> 0; + /* while (true) { */ case 23: + /* if (!(start < r)) { break; } */ if(!(start < r)) { $s = 24; continue; } + c = ((((((start + r >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + _r$2 = data.Less(p - c >> 0, c); /* */ $s = 28; case 28: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (!_r$2) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (!_r$2) { */ case 25: + start = c + 1 >> 0; + $s = 27; continue; + /* } else { */ case 26: + r = c; + /* } */ case 27: + /* } */ $s = 23; continue; case 24: + end = n - start >> 0; + /* */ if (start < m && m < end) { $s = 29; continue; } + /* */ $s = 30; continue; + /* if (start < m && m < end) { */ case 29: + $r = rotate(data, start, m, end); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 30: + /* */ if (a < start && start < mid) { $s = 32; continue; } + /* */ $s = 33; continue; + /* if (a < start && start < mid) { */ case 32: + $r = symMerge(data, a, start, mid); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 33: + /* */ if (mid < end && end < b) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (mid < end && end < b) { */ case 35: + $r = symMerge(data, mid, end, b); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 36: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: symMerge }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.end = end; $f.h = h; $f.h$1 = h$1; $f.i = i; $f.i$1 = i$1; $f.j = j; $f.j$1 = j$1; $f.k = k; $f.k$1 = k$1; $f.m = m; $f.mid = mid; $f.n = n; $f.p = p; $f.r = r; $f.start = start; $f.$s = $s; $f.$r = $r; return $f; + }; + rotate = function(data, a, m, b) { + var a, b, data, i, j, m, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = m - a >> 0; + j = b - m >> 0; + /* while (true) { */ case 1: + /* if (!(!((i === j)))) { break; } */ if(!(!((i === j)))) { $s = 2; continue; } + /* */ if (i > j) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (i > j) { */ case 3: + $r = swapRange(data, m - i >> 0, m, j); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i - (j) >> 0; + $s = 5; continue; + /* } else { */ case 4: + $r = swapRange(data, m - i >> 0, (m + j >> 0) - i >> 0, i); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + j = j - (i) >> 0; + /* } */ case 5: + /* } */ $s = 1; continue; case 2: + $r = swapRange(data, m - i >> 0, m, i); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: rotate }; } $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.m = m; $f.$s = $s; $f.$r = $r; return $f; + }; + insertionSort_func = function(data, a, b) { + var _r, _v, a, b, data, i, j, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _v = $f._v; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = a + 1 >> 0; + /* while (true) { */ case 1: + /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 2; continue; } + j = i; + /* while (true) { */ case 3: + if (!(j > a)) { _v = false; $s = 5; continue s; } + _r = data.Less(j, j - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 5: + /* if (!(_v)) { break; } */ if(!(_v)) { $s = 4; continue; } + $r = data.Swap(j, j - 1 >> 0); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + j = j - (1) >> 0; + /* } */ $s = 3; continue; case 4: + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: insertionSort_func }; } $f._r = _r; $f._v = _v; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f; + }; + siftDown_func = function(data, lo, hi, first) { + var _r, _r$1, _v, child, data, first, hi, lo, root, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; child = $f.child; data = $f.data; first = $f.first; hi = $f.hi; lo = $f.lo; root = $f.root; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + root = lo; + /* while (true) { */ case 1: + child = ($imul(2, root)) + 1 >> 0; + if (child >= hi) { + /* break; */ $s = 2; continue; + } + if (!((child + 1 >> 0) < hi)) { _v = false; $s = 5; continue s; } + _r = data.Less(first + child >> 0, (first + child >> 0) + 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 5: + /* */ if (_v) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_v) { */ case 3: + child = child + (1) >> 0; + /* } */ case 4: + _r$1 = data.Less(first + root >> 0, first + child >> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!_r$1) { */ case 7: + $s = -1; return; + /* } */ case 8: + $r = data.Swap(first + root >> 0, first + child >> 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + root = child; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: siftDown_func }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.child = child; $f.data = data; $f.first = first; $f.hi = hi; $f.lo = lo; $f.root = root; $f.$s = $s; $f.$r = $r; return $f; + }; + heapSort_func = function(data, a, b) { + var _q, a, b, data, first, hi, i, i$1, lo, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; a = $f.a; b = $f.b; data = $f.data; first = $f.first; hi = $f.hi; i = $f.i; i$1 = $f.i$1; lo = $f.lo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + first = a; + lo = 0; + hi = b - a >> 0; + i = (_q = ((hi - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* while (true) { */ case 1: + /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 2; continue; } + $r = siftDown_func($clone(data, lessSwap), i, hi, first); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i - (1) >> 0; + /* } */ $s = 1; continue; case 2: + i$1 = hi - 1 >> 0; + /* while (true) { */ case 4: + /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 5; continue; } + $r = data.Swap(first, first + i$1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = siftDown_func($clone(data, lessSwap), lo, i$1, first); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 - (1) >> 0; + /* } */ $s = 4; continue; case 5: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: heapSort_func }; } $f._q = _q; $f.a = a; $f.b = b; $f.data = data; $f.first = first; $f.hi = hi; $f.i = i; $f.i$1 = i$1; $f.lo = lo; $f.$s = $s; $f.$r = $r; return $f; + }; + medianOfThree_func = function(data, m1, m0, m2) { + var _r, _r$1, _r$2, data, m0, m1, m2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; data = $f.data; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = data.Less(m1, m0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + $r = data.Swap(m1, m0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _r$1 = data.Less(m2, m1); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_r$1) { */ case 5: + $r = data.Swap(m2, m1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$2 = data.Less(m1, m0); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (_r$2) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_r$2) { */ case 9: + $r = data.Swap(m1, m0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + /* } */ case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: medianOfThree_func }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.data = data; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.$s = $s; $f.$r = $r; return $f; + }; + doPivot_func = function(data, lo, hi) { + var _q, _q$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$2, _tmp$3, _v, _v$1, _v$2, _v$3, _v$4, a, b, c, data, dups, hi, lo, m, midhi, midlo, pivot, protect, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; a = $f.a; b = $f.b; c = $f.c; data = $f.data; dups = $f.dups; hi = $f.hi; lo = $f.lo; m = $f.m; midhi = $f.midhi; midlo = $f.midlo; pivot = $f.pivot; protect = $f.protect; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + midlo = 0; + midhi = 0; + m = ((((((lo + hi >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); + /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((hi - lo >> 0) > 40) { */ case 1: + s = (_q = ((hi - lo >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + $r = medianOfThree_func($clone(data, lessSwap), lo, lo + s >> 0, lo + ($imul(2, s)) >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = medianOfThree_func($clone(data, lessSwap), m, m - s >> 0, m + s >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = medianOfThree_func($clone(data, lessSwap), hi - 1 >> 0, (hi - 1 >> 0) - s >> 0, (hi - 1 >> 0) - ($imul(2, s)) >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $r = medianOfThree_func($clone(data, lessSwap), lo, m, hi - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + pivot = lo; + _tmp = lo + 1 >> 0; + _tmp$1 = hi - 1 >> 0; + a = _tmp; + c = _tmp$1; + /* while (true) { */ case 7: + if (!(a < c)) { _v = false; $s = 9; continue s; } + _r = data.Less(a, pivot); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 9: + /* if (!(_v)) { break; } */ if(!(_v)) { $s = 8; continue; } + a = a + (1) >> 0; + /* } */ $s = 7; continue; case 8: + b = a; + /* while (true) { */ case 11: + /* while (true) { */ case 13: + if (!(b < c)) { _v$1 = false; $s = 15; continue s; } + _r$1 = data.Less(pivot, b); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v$1 = !_r$1; case 15: + /* if (!(_v$1)) { break; } */ if(!(_v$1)) { $s = 14; continue; } + b = b + (1) >> 0; + /* } */ $s = 13; continue; case 14: + /* while (true) { */ case 17: + if (!(b < c)) { _v$2 = false; $s = 19; continue s; } + _r$2 = data.Less(pivot, c - 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$2 = _r$2; case 19: + /* if (!(_v$2)) { break; } */ if(!(_v$2)) { $s = 18; continue; } + c = c - (1) >> 0; + /* } */ $s = 17; continue; case 18: + if (b >= c) { + /* break; */ $s = 12; continue; + } + $r = data.Swap(b, c - 1 >> 0); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = b + (1) >> 0; + c = c - (1) >> 0; + /* } */ $s = 11; continue; case 12: + protect = (hi - c >> 0) < 5; + /* */ if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { */ case 22: + dups = 0; + _r$3 = data.Less(pivot, hi - 1 >> 0); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (!_r$3) { */ case 24: + $r = data.Swap(c, hi - 1 >> 0); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + c = c + (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 25: + _r$4 = data.Less(b - 1 >> 0, pivot); /* */ $s = 30; case 30: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 28; continue; } + /* */ $s = 29; continue; + /* if (!_r$4) { */ case 28: + b = b - (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 29: + _r$5 = data.Less(m, pivot); /* */ $s = 33; case 33: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (!_r$5) { $s = 31; continue; } + /* */ $s = 32; continue; + /* if (!_r$5) { */ case 31: + $r = data.Swap(m, b - 1 >> 0); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = b - (1) >> 0; + dups = dups + (1) >> 0; + /* } */ case 32: + protect = dups > 1; + /* } */ case 23: + /* */ if (protect) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (protect) { */ case 35: + /* while (true) { */ case 37: + /* while (true) { */ case 39: + if (!(a < b)) { _v$3 = false; $s = 41; continue s; } + _r$6 = data.Less(b - 1 >> 0, pivot); /* */ $s = 42; case 42: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v$3 = !_r$6; case 41: + /* if (!(_v$3)) { break; } */ if(!(_v$3)) { $s = 40; continue; } + b = b - (1) >> 0; + /* } */ $s = 39; continue; case 40: + /* while (true) { */ case 43: + if (!(a < b)) { _v$4 = false; $s = 45; continue s; } + _r$7 = data.Less(a, pivot); /* */ $s = 46; case 46: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v$4 = _r$7; case 45: + /* if (!(_v$4)) { break; } */ if(!(_v$4)) { $s = 44; continue; } + a = a + (1) >> 0; + /* } */ $s = 43; continue; case 44: + if (a >= b) { + /* break; */ $s = 38; continue; + } + $r = data.Swap(a, b - 1 >> 0); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = a + (1) >> 0; + b = b - (1) >> 0; + /* } */ $s = 37; continue; case 38: + /* } */ case 36: + $r = data.Swap(pivot, b - 1 >> 0); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tmp$2 = b - 1 >> 0; + _tmp$3 = c; + midlo = _tmp$2; + midhi = _tmp$3; + $s = -1; return [midlo, midhi]; + /* */ } return; } if ($f === undefined) { $f = { $blk: doPivot_func }; } $f._q = _q; $f._q$1 = _q$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.dups = dups; $f.hi = hi; $f.lo = lo; $f.m = m; $f.midhi = midhi; $f.midlo = midlo; $f.pivot = pivot; $f.protect = protect; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + quickSort_func = function(data, a, b, maxDepth$1) { + var _r, _r$1, _tuple, a, b, data, i, maxDepth$1, mhi, mlo, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; i = $f.i; maxDepth$1 = $f.maxDepth$1; mhi = $f.mhi; mlo = $f.mlo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* while (true) { */ case 1: + /* if (!((b - a >> 0) > 12)) { break; } */ if(!((b - a >> 0) > 12)) { $s = 2; continue; } + /* */ if (maxDepth$1 === 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (maxDepth$1 === 0) { */ case 3: + $r = heapSort_func($clone(data, lessSwap), a, b); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 4: + maxDepth$1 = maxDepth$1 - (1) >> 0; + _r = doPivot_func($clone(data, lessSwap), a, b); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + mlo = _tuple[0]; + mhi = _tuple[1]; + /* */ if ((mlo - a >> 0) < (b - mhi >> 0)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((mlo - a >> 0) < (b - mhi >> 0)) { */ case 7: + $r = quickSort_func($clone(data, lessSwap), a, mlo, maxDepth$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + a = mhi; + $s = 9; continue; + /* } else { */ case 8: + $r = quickSort_func($clone(data, lessSwap), mhi, b, maxDepth$1); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + b = mlo; + /* } */ case 9: + /* } */ $s = 1; continue; case 2: + /* */ if ((b - a >> 0) > 1) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((b - a >> 0) > 1) { */ case 12: + i = a + 6 >> 0; + /* while (true) { */ case 14: + /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 15; continue; } + _r$1 = data.Less(i, i - 6 >> 0); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (_r$1) { */ case 16: + $r = data.Swap(i, i - 6 >> 0); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 17: + i = i + (1) >> 0; + /* } */ $s = 14; continue; case 15: + $r = insertionSort_func($clone(data, lessSwap), a, b); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 13: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: quickSort_func }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.maxDepth$1 = maxDepth$1; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f; + }; + IntSlice.methods = [{prop: "Search", name: "Search", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Sort", name: "Sort", pkg: "", typ: $funcType([], [], false)}]; + lessSwap.init("", [{prop: "Less", name: "Less", embedded: false, exported: true, typ: funcType, tag: ""}, {prop: "Swap", name: "Swap", embedded: false, exported: true, typ: funcType$1, tag: ""}]); + IntSlice.init($Int); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = reflect.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/fmtsort"] = (function() { + var $pkg = {}, $init, reflect, sort, SortedMap, ptrType, sliceType, Sort, compare, nilCompare, floatCompare, isNaN; + reflect = $packages["reflect"]; + sort = $packages["sort"]; + SortedMap = $pkg.SortedMap = $newType(0, $kindStruct, "fmtsort.SortedMap", true, "internal/fmtsort", true, function(Key_, Value_) { + this.$val = this; + if (arguments.length === 0) { + this.Key = sliceType.nil; + this.Value = sliceType.nil; + return; + } + this.Key = Key_; + this.Value = Value_; + }); + ptrType = $ptrType(SortedMap); + sliceType = $sliceType(reflect.Value); + SortedMap.ptr.prototype.Len = function() { + var o; + o = this; + return o.Key.$length; + }; + SortedMap.prototype.Len = function() { return this.$val.Len(); }; + SortedMap.ptr.prototype.Less = function(i, j) { + var _r, i, j, o, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; j = $f.j; o = $f.o; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + o = this; + _r = compare($clone((x = o.Key, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])), reflect.Value), $clone((x$1 = o.Key, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])), reflect.Value)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r < 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: SortedMap.ptr.prototype.Less }; } $f._r = _r; $f.i = i; $f.j = j; $f.o = o; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + SortedMap.prototype.Less = function(i, j) { return this.$val.Less(i, j); }; + SortedMap.ptr.prototype.Swap = function(i, j) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, i, j, o, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + o = this; + _tmp = (x = o.Key, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); + _tmp$1 = (x$1 = o.Key, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); + (x$2 = o.Key, ((i < 0 || i >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i] = _tmp)); + (x$3 = o.Key, ((j < 0 || j >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + j] = _tmp$1)); + _tmp$2 = (x$4 = o.Value, ((j < 0 || j >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + j])); + _tmp$3 = (x$5 = o.Value, ((i < 0 || i >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + i])); + (x$6 = o.Value, ((i < 0 || i >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i] = _tmp$2)); + (x$7 = o.Value, ((j < 0 || j >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + j] = _tmp$3)); + }; + SortedMap.prototype.Swap = function(i, j) { return this.$val.Swap(i, j); }; + Sort = function(mapValue) { + var _r, _r$1, _r$2, _r$3, i, iter, key, mapValue, sorted, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; iter = $f.iter; key = $f.key; mapValue = $f.mapValue; sorted = $f.sorted; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(mapValue, reflect.Value).Type().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 21))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 21))) { */ case 1: + $s = -1; return ptrType.nil; + /* } */ case 2: + key = $makeSlice(sliceType, $clone(mapValue, reflect.Value).Len()); + value = $makeSlice(sliceType, key.$length); + iter = $clone(mapValue, reflect.Value).MapRange(); + i = 0; + /* while (true) { */ case 4: + _r$1 = iter.Next(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* if (!(_r$1)) { break; } */ if(!(_r$1)) { $s = 5; continue; } + _r$2 = iter.Key(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + ((i < 0 || i >= key.$length) ? ($throwRuntimeError("index out of range"), undefined) : key.$array[key.$offset + i] = _r$2); + _r$3 = iter.Value(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ((i < 0 || i >= value.$length) ? ($throwRuntimeError("index out of range"), undefined) : value.$array[value.$offset + i] = _r$3); + i = i + (1) >> 0; + /* } */ $s = 4; continue; case 5: + sorted = new SortedMap.ptr(key, value); + $r = sort.Stable(sorted); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return sorted; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.iter = iter; $f.key = key; $f.mapValue = mapValue; $f.sorted = sorted; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sort = Sort; + compare = function(aVal, bVal) { + var _1, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, a, a$1, a$2, a$3, a$4, a$5, aType, aVal, ap, b, b$1, b$2, b$3, b$4, b$5, bType, bVal, bp, c, c$1, c$2, c$3, c$4, c$5, i, i$1, ok, ok$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; a$1 = $f.a$1; a$2 = $f.a$2; a$3 = $f.a$3; a$4 = $f.a$4; a$5 = $f.a$5; aType = $f.aType; aVal = $f.aVal; ap = $f.ap; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; b$3 = $f.b$3; b$4 = $f.b$4; b$5 = $f.b$5; bType = $f.bType; bVal = $f.bVal; bp = $f.bp; c = $f.c; c$1 = $f.c$1; c$2 = $f.c$2; c$3 = $f.c$3; c$4 = $f.c$4; c$5 = $f.c$5; i = $f.i; i$1 = $f.i$1; ok = $f.ok; ok$1 = $f.ok$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tmp = $clone(aVal, reflect.Value).Type(); + _tmp$1 = $clone(bVal, reflect.Value).Type(); + aType = _tmp; + bType = _tmp$1; + if (!($interfaceIsEqual(aType, bType))) { + $s = -1; return -1; + } + _1 = $clone(aVal, reflect.Value).Kind(); + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 2; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 3; continue; } + /* */ if (_1 === (24)) { $s = 4; continue; } + /* */ if ((_1 === (13)) || (_1 === (14))) { $s = 5; continue; } + /* */ if ((_1 === (15)) || (_1 === (16))) { $s = 6; continue; } + /* */ if (_1 === (1)) { $s = 7; continue; } + /* */ if (_1 === (22)) { $s = 8; continue; } + /* */ if (_1 === (18)) { $s = 9; continue; } + /* */ if (_1 === (25)) { $s = 10; continue; } + /* */ if (_1 === (17)) { $s = 11; continue; } + /* */ if (_1 === (20)) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 2: + _tmp$2 = $clone(aVal, reflect.Value).Int(); + _tmp$3 = $clone(bVal, reflect.Value).Int(); + a = _tmp$2; + b = _tmp$3; + if ((a.$high < b.$high || (a.$high === b.$high && a.$low < b.$low))) { + $s = -1; return -1; + } else if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { + $s = -1; return 1; + } else { + $s = -1; return 0; + } + $s = 14; continue; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 3: + _tmp$4 = $clone(aVal, reflect.Value).Uint(); + _tmp$5 = $clone(bVal, reflect.Value).Uint(); + a$1 = _tmp$4; + b$1 = _tmp$5; + if ((a$1.$high < b$1.$high || (a$1.$high === b$1.$high && a$1.$low < b$1.$low))) { + $s = -1; return -1; + } else if ((a$1.$high > b$1.$high || (a$1.$high === b$1.$high && a$1.$low > b$1.$low))) { + $s = -1; return 1; + } else { + $s = -1; return 0; + } + $s = 14; continue; + /* } else if (_1 === (24)) { */ case 4: + _r = $clone(aVal, reflect.Value).String(); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp$6 = _r; + _r$1 = $clone(bVal, reflect.Value).String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tmp$7 = _r$1; + a$2 = _tmp$6; + b$2 = _tmp$7; + if (a$2 < b$2) { + $s = -1; return -1; + } else if (a$2 > b$2) { + $s = -1; return 1; + } else { + $s = -1; return 0; + } + $s = 14; continue; + /* } else if ((_1 === (13)) || (_1 === (14))) { */ case 5: + $s = -1; return floatCompare($clone(aVal, reflect.Value).Float(), $clone(bVal, reflect.Value).Float()); + /* } else if ((_1 === (15)) || (_1 === (16))) { */ case 6: + _tmp$8 = $clone(aVal, reflect.Value).Complex(); + _tmp$9 = $clone(bVal, reflect.Value).Complex(); + a$3 = _tmp$8; + b$3 = _tmp$9; + c = floatCompare(a$3.$real, b$3.$real); + if (!((c === 0))) { + $s = -1; return c; + } + $s = -1; return floatCompare(a$3.$imag, b$3.$imag); + /* } else if (_1 === (1)) { */ case 7: + _tmp$10 = $clone(aVal, reflect.Value).Bool(); + _tmp$11 = $clone(bVal, reflect.Value).Bool(); + a$4 = _tmp$10; + b$4 = _tmp$11; + if (a$4 === b$4) { + $s = -1; return 0; + } else if (a$4) { + $s = -1; return 1; + } else { + $s = -1; return -1; + } + $s = 14; continue; + /* } else if (_1 === (22)) { */ case 8: + _tmp$12 = $clone(aVal, reflect.Value).Pointer(); + _tmp$13 = $clone(bVal, reflect.Value).Pointer(); + a$5 = _tmp$12; + b$5 = _tmp$13; + if (a$5 < b$5) { + $s = -1; return -1; + } else if (a$5 > b$5) { + $s = -1; return 1; + } else { + $s = -1; return 0; + } + $s = 14; continue; + /* } else if (_1 === (18)) { */ case 9: + _tuple = nilCompare($clone(aVal, reflect.Value), $clone(bVal, reflect.Value)); + c$1 = _tuple[0]; + ok = _tuple[1]; + if (ok) { + $s = -1; return c$1; + } + _tmp$14 = $clone(aVal, reflect.Value).Pointer(); + _tmp$15 = $clone(bVal, reflect.Value).Pointer(); + ap = _tmp$14; + bp = _tmp$15; + if (ap < bp) { + $s = -1; return -1; + } else if (ap > bp) { + $s = -1; return 1; + } else { + $s = -1; return 0; + } + $s = 14; continue; + /* } else if (_1 === (25)) { */ case 10: + i = 0; + /* while (true) { */ case 17: + /* if (!(i < $clone(aVal, reflect.Value).NumField())) { break; } */ if(!(i < $clone(aVal, reflect.Value).NumField())) { $s = 18; continue; } + _r$2 = $clone(aVal, reflect.Value).Field(i); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _arg = $clone(_r$2, reflect.Value); + _r$3 = $clone(bVal, reflect.Value).Field(i); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _arg$1 = $clone(_r$3, reflect.Value); + _r$4 = compare(_arg, _arg$1); /* */ $s = 21; case 21: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + c$2 = _r$4; + if (!((c$2 === 0))) { + $s = -1; return c$2; + } + i = i + (1) >> 0; + /* } */ $s = 17; continue; case 18: + $s = -1; return 0; + /* } else if (_1 === (17)) { */ case 11: + i$1 = 0; + /* while (true) { */ case 22: + /* if (!(i$1 < $clone(aVal, reflect.Value).Len())) { break; } */ if(!(i$1 < $clone(aVal, reflect.Value).Len())) { $s = 23; continue; } + _r$5 = $clone(aVal, reflect.Value).Index(i$1); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$2 = $clone(_r$5, reflect.Value); + _r$6 = $clone(bVal, reflect.Value).Index(i$1); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$3 = $clone(_r$6, reflect.Value); + _r$7 = compare(_arg$2, _arg$3); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + c$3 = _r$7; + if (!((c$3 === 0))) { + $s = -1; return c$3; + } + i$1 = i$1 + (1) >> 0; + /* } */ $s = 22; continue; case 23: + $s = -1; return 0; + /* } else if (_1 === (20)) { */ case 12: + _tuple$1 = nilCompare($clone(aVal, reflect.Value), $clone(bVal, reflect.Value)); + c$4 = _tuple$1[0]; + ok$1 = _tuple$1[1]; + if (ok$1) { + $s = -1; return c$4; + } + _r$8 = $clone(aVal, reflect.Value).Elem(); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _r$9 = $clone(_r$8, reflect.Value).Type(); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$10 = reflect.ValueOf(_r$9); /* */ $s = 29; case 29: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _arg$4 = $clone(_r$10, reflect.Value); + _r$11 = $clone(bVal, reflect.Value).Elem(); /* */ $s = 30; case 30: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _r$12 = $clone(_r$11, reflect.Value).Type(); /* */ $s = 31; case 31: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _r$13 = reflect.ValueOf(_r$12); /* */ $s = 32; case 32: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _arg$5 = $clone(_r$13, reflect.Value); + _r$14 = compare(_arg$4, _arg$5); /* */ $s = 33; case 33: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + c$5 = _r$14; + if (!((c$5 === 0))) { + $s = -1; return c$5; + } + _r$15 = $clone(aVal, reflect.Value).Elem(); /* */ $s = 34; case 34: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + _arg$6 = $clone(_r$15, reflect.Value); + _r$16 = $clone(bVal, reflect.Value).Elem(); /* */ $s = 35; case 35: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + _arg$7 = $clone(_r$16, reflect.Value); + _r$17 = compare(_arg$6, _arg$7); /* */ $s = 36; case 36: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + $s = -1; return _r$17; + /* } else { */ case 13: + _r$18 = aType.String(); /* */ $s = 37; case 37: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + $panic(new $String("bad type in compare: " + _r$18)); + /* } */ case 14: + case 1: + $s = -1; return 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: compare }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.a$1 = a$1; $f.a$2 = a$2; $f.a$3 = a$3; $f.a$4 = a$4; $f.a$5 = a$5; $f.aType = aType; $f.aVal = aVal; $f.ap = ap; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.b$3 = b$3; $f.b$4 = b$4; $f.b$5 = b$5; $f.bType = bType; $f.bVal = bVal; $f.bp = bp; $f.c = c; $f.c$1 = c$1; $f.c$2 = c$2; $f.c$3 = c$3; $f.c$4 = c$4; $f.c$5 = c$5; $f.i = i; $f.i$1 = i$1; $f.ok = ok; $f.ok$1 = ok$1; $f.$s = $s; $f.$r = $r; return $f; + }; + nilCompare = function(aVal, bVal) { + var aVal, bVal; + if ($clone(aVal, reflect.Value).IsNil()) { + if ($clone(bVal, reflect.Value).IsNil()) { + return [0, true]; + } + return [-1, true]; + } + if ($clone(bVal, reflect.Value).IsNil()) { + return [1, true]; + } + return [0, false]; + }; + floatCompare = function(a, b) { + var a, b; + if (isNaN(a)) { + return -1; + } else if (isNaN(b)) { + return 1; + } else if (a < b) { + return -1; + } else if (a > b) { + return 1; + } + return 0; + }; + isNaN = function(a) { + var a; + return !((a === a)); + }; + ptrType.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; + SortedMap.init("", [{prop: "Key", name: "Key", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "Value", name: "Value", embedded: false, exported: true, typ: sliceType, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = reflect.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["syscall"] = (function() { + var $pkg = {}, $init, js, race, runtime, sync, RawConn, SockaddrLinklayer, SockaddrNetlink, mmapper, Errno, Sockaddr, SockaddrInet4, SockaddrInet6, SockaddrUnix, Timespec, Stat_t, RawSockaddrInet4, RawSockaddrInet6, RawSockaddrUnix, RawSockaddrLinklayer, RawSockaddrNetlink, RawSockaddr, RawSockaddrAny, _Socklen, Linger, Iovec, IPMreq, IPMreqn, IPv6Mreq, Msghdr, sliceType, sliceType$1, ptrType$2, ptrType$4, arrayType$1, ptrType$9, arrayType$2, ptrType$12, arrayType$4, arrayType$5, arrayType$8, arrayType$9, arrayType$10, arrayType$11, ptrType$19, ptrType$20, structType, ptrType$23, funcType, funcType$1, ptrType$25, ptrType$26, mapType, funcType$2, funcType$3, ptrType$27, ptrType$28, ptrType$29, ptrType$30, ptrType$32, warningPrinted, lineBuffer, syscallModule, alreadyTriedToLoad, minusOne, envs, mapper, errEAGAIN, errEINVAL, errENOENT, ioSync, ioSync$24ptr, errors, init, printWarning, printToConsole, Exit, indexByte, runtime_envs, syscallByName, Syscall, Syscall6, BytePtrFromString, readInt, readIntBE, readIntLE, ParseDirent, CloseOnExec, SetNonblock, msanRead, msanWrite, itoa, uitoa, anyToSockaddr, Accept, Accept4, SetsockoptIPMreqn, Recvmsg, SendmsgN, ReadDirent, direntIno, direntReclen, direntNamlen, Lstat, errnoErr, Read, Write, GetsockoptInt, Recvfrom, Sendto, SetsockoptByte, SetsockoptInt, SetsockoptInet4Addr, SetsockoptIPMreq, SetsockoptIPv6Mreq, SetsockoptLinger, Close, Dup, Fchdir, Fchmod, fcntl, Fsync, Getdents, read, write, munmap, Fchown, Fstat, Ftruncate, Pread, Pwrite, Seek, Shutdown, accept, accept4, fstatat, getsockopt, setsockopt, recvfrom, sendto, recvmsg, sendmsg, mmap; + js = $packages["github.com/gopherjs/gopherjs/js"]; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + RawConn = $pkg.RawConn = $newType(8, $kindInterface, "syscall.RawConn", true, "syscall", true, null); + SockaddrLinklayer = $pkg.SockaddrLinklayer = $newType(0, $kindStruct, "syscall.SockaddrLinklayer", true, "syscall", true, function(Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Protocol = 0; + this.Ifindex = 0; + this.Hatype = 0; + this.Pkttype = 0; + this.Halen = 0; + this.Addr = arrayType$1.zero(); + this.raw = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()); + return; + } + this.Protocol = Protocol_; + this.Ifindex = Ifindex_; + this.Hatype = Hatype_; + this.Pkttype = Pkttype_; + this.Halen = Halen_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrNetlink = $pkg.SockaddrNetlink = $newType(0, $kindStruct, "syscall.SockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Pad = 0; + this.Pid = 0; + this.Groups = 0; + this.raw = new RawSockaddrNetlink.ptr(0, 0, 0, 0); + return; + } + this.Family = Family_; + this.Pad = Pad_; + this.Pid = Pid_; + this.Groups = Groups_; + this.raw = raw_; + }); + mmapper = $pkg.mmapper = $newType(0, $kindStruct, "syscall.mmapper", true, "syscall", false, function(Mutex_, active_, mmap_, munmap_) { + this.$val = this; + if (arguments.length === 0) { + this.Mutex = new sync.Mutex.ptr(0, 0); + this.active = false; + this.mmap = $throwNilPointerError; + this.munmap = $throwNilPointerError; + return; + } + this.Mutex = Mutex_; + this.active = active_; + this.mmap = mmap_; + this.munmap = munmap_; + }); + Errno = $pkg.Errno = $newType(4, $kindUintptr, "syscall.Errno", true, "syscall", true, null); + Sockaddr = $pkg.Sockaddr = $newType(8, $kindInterface, "syscall.Sockaddr", true, "syscall", true, null); + SockaddrInet4 = $pkg.SockaddrInet4 = $newType(0, $kindStruct, "syscall.SockaddrInet4", true, "syscall", true, function(Port_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Port = 0; + this.Addr = arrayType$9.zero(); + this.raw = new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero()); + return; + } + this.Port = Port_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrInet6 = $pkg.SockaddrInet6 = $newType(0, $kindStruct, "syscall.SockaddrInet6", true, "syscall", true, function(Port_, ZoneId_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Port = 0; + this.ZoneId = 0; + this.Addr = arrayType$2.zero(); + this.raw = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0); + return; + } + this.Port = Port_; + this.ZoneId = ZoneId_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrUnix = $pkg.SockaddrUnix = $newType(0, $kindStruct, "syscall.SockaddrUnix", true, "syscall", true, function(Name_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.raw = new RawSockaddrUnix.ptr(0, arrayType$8.zero()); + return; + } + this.Name = Name_; + this.raw = raw_; + }); + Timespec = $pkg.Timespec = $newType(0, $kindStruct, "syscall.Timespec", true, "syscall", true, function(Sec_, Nsec_) { + this.$val = this; + if (arguments.length === 0) { + this.Sec = new $Int64(0, 0); + this.Nsec = new $Int64(0, 0); + return; + } + this.Sec = Sec_; + this.Nsec = Nsec_; + }); + Stat_t = $pkg.Stat_t = $newType(0, $kindStruct, "syscall.Stat_t", true, "syscall", true, function(Dev_, Ino_, Nlink_, Mode_, Uid_, Gid_, X__pad0_, Rdev_, Size_, Blksize_, Blocks_, Atim_, Mtim_, Ctim_, X__unused_) { + this.$val = this; + if (arguments.length === 0) { + this.Dev = new $Uint64(0, 0); + this.Ino = new $Uint64(0, 0); + this.Nlink = new $Uint64(0, 0); + this.Mode = 0; + this.Uid = 0; + this.Gid = 0; + this.X__pad0 = 0; + this.Rdev = new $Uint64(0, 0); + this.Size = new $Int64(0, 0); + this.Blksize = new $Int64(0, 0); + this.Blocks = new $Int64(0, 0); + this.Atim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.Mtim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.Ctim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.X__unused = arrayType$5.zero(); + return; + } + this.Dev = Dev_; + this.Ino = Ino_; + this.Nlink = Nlink_; + this.Mode = Mode_; + this.Uid = Uid_; + this.Gid = Gid_; + this.X__pad0 = X__pad0_; + this.Rdev = Rdev_; + this.Size = Size_; + this.Blksize = Blksize_; + this.Blocks = Blocks_; + this.Atim = Atim_; + this.Mtim = Mtim_; + this.Ctim = Ctim_; + this.X__unused = X__unused_; + }); + RawSockaddrInet4 = $pkg.RawSockaddrInet4 = $newType(0, $kindStruct, "syscall.RawSockaddrInet4", true, "syscall", true, function(Family_, Port_, Addr_, Zero_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Port = 0; + this.Addr = arrayType$9.zero(); + this.Zero = arrayType$1.zero(); + return; + } + this.Family = Family_; + this.Port = Port_; + this.Addr = Addr_; + this.Zero = Zero_; + }); + RawSockaddrInet6 = $pkg.RawSockaddrInet6 = $newType(0, $kindStruct, "syscall.RawSockaddrInet6", true, "syscall", true, function(Family_, Port_, Flowinfo_, Addr_, Scope_id_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Port = 0; + this.Flowinfo = 0; + this.Addr = arrayType$2.zero(); + this.Scope_id = 0; + return; + } + this.Family = Family_; + this.Port = Port_; + this.Flowinfo = Flowinfo_; + this.Addr = Addr_; + this.Scope_id = Scope_id_; + }); + RawSockaddrUnix = $pkg.RawSockaddrUnix = $newType(0, $kindStruct, "syscall.RawSockaddrUnix", true, "syscall", true, function(Family_, Path_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Path = arrayType$8.zero(); + return; + } + this.Family = Family_; + this.Path = Path_; + }); + RawSockaddrLinklayer = $pkg.RawSockaddrLinklayer = $newType(0, $kindStruct, "syscall.RawSockaddrLinklayer", true, "syscall", true, function(Family_, Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Protocol = 0; + this.Ifindex = 0; + this.Hatype = 0; + this.Pkttype = 0; + this.Halen = 0; + this.Addr = arrayType$1.zero(); + return; + } + this.Family = Family_; + this.Protocol = Protocol_; + this.Ifindex = Ifindex_; + this.Hatype = Hatype_; + this.Pkttype = Pkttype_; + this.Halen = Halen_; + this.Addr = Addr_; + }); + RawSockaddrNetlink = $pkg.RawSockaddrNetlink = $newType(0, $kindStruct, "syscall.RawSockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Pad = 0; + this.Pid = 0; + this.Groups = 0; + return; + } + this.Family = Family_; + this.Pad = Pad_; + this.Pid = Pid_; + this.Groups = Groups_; + }); + RawSockaddr = $pkg.RawSockaddr = $newType(0, $kindStruct, "syscall.RawSockaddr", true, "syscall", true, function(Family_, Data_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Data = arrayType$10.zero(); + return; + } + this.Family = Family_; + this.Data = Data_; + }); + RawSockaddrAny = $pkg.RawSockaddrAny = $newType(0, $kindStruct, "syscall.RawSockaddrAny", true, "syscall", true, function(Addr_, Pad_) { + this.$val = this; + if (arguments.length === 0) { + this.Addr = new RawSockaddr.ptr(0, arrayType$10.zero()); + this.Pad = arrayType$11.zero(); + return; + } + this.Addr = Addr_; + this.Pad = Pad_; + }); + _Socklen = $pkg._Socklen = $newType(4, $kindUint32, "syscall._Socklen", true, "syscall", false, null); + Linger = $pkg.Linger = $newType(0, $kindStruct, "syscall.Linger", true, "syscall", true, function(Onoff_, Linger_) { + this.$val = this; + if (arguments.length === 0) { + this.Onoff = 0; + this.Linger = 0; + return; + } + this.Onoff = Onoff_; + this.Linger = Linger_; + }); + Iovec = $pkg.Iovec = $newType(0, $kindStruct, "syscall.Iovec", true, "syscall", true, function(Base_, Len_) { + this.$val = this; + if (arguments.length === 0) { + this.Base = ptrType$2.nil; + this.Len = new $Uint64(0, 0); + return; + } + this.Base = Base_; + this.Len = Len_; + }); + IPMreq = $pkg.IPMreq = $newType(0, $kindStruct, "syscall.IPMreq", true, "syscall", true, function(Multiaddr_, Interface_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$9.zero(); + this.Interface = arrayType$9.zero(); + return; + } + this.Multiaddr = Multiaddr_; + this.Interface = Interface_; + }); + IPMreqn = $pkg.IPMreqn = $newType(0, $kindStruct, "syscall.IPMreqn", true, "syscall", true, function(Multiaddr_, Address_, Ifindex_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$9.zero(); + this.Address = arrayType$9.zero(); + this.Ifindex = 0; + return; + } + this.Multiaddr = Multiaddr_; + this.Address = Address_; + this.Ifindex = Ifindex_; + }); + IPv6Mreq = $pkg.IPv6Mreq = $newType(0, $kindStruct, "syscall.IPv6Mreq", true, "syscall", true, function(Multiaddr_, Interface_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$2.zero(); + this.Interface = 0; + return; + } + this.Multiaddr = Multiaddr_; + this.Interface = Interface_; + }); + Msghdr = $pkg.Msghdr = $newType(0, $kindStruct, "syscall.Msghdr", true, "syscall", true, function(Name_, Namelen_, Pad_cgo_0_, Iov_, Iovlen_, Control_, Controllen_, Flags_, Pad_cgo_1_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ptrType$2.nil; + this.Namelen = 0; + this.Pad_cgo_0 = arrayType$9.zero(); + this.Iov = ptrType$20.nil; + this.Iovlen = new $Uint64(0, 0); + this.Control = ptrType$2.nil; + this.Controllen = new $Uint64(0, 0); + this.Flags = 0; + this.Pad_cgo_1 = arrayType$9.zero(); + return; + } + this.Name = Name_; + this.Namelen = Namelen_; + this.Pad_cgo_0 = Pad_cgo_0_; + this.Iov = Iov_; + this.Iovlen = Iovlen_; + this.Control = Control_; + this.Controllen = Controllen_; + this.Flags = Flags_; + this.Pad_cgo_1 = Pad_cgo_1_; + }); + sliceType = $sliceType($Uint8); + sliceType$1 = $sliceType($String); + ptrType$2 = $ptrType($Uint8); + ptrType$4 = $ptrType($Int32); + arrayType$1 = $arrayType($Uint8, 8); + ptrType$9 = $ptrType($Uint16); + arrayType$2 = $arrayType($Uint8, 16); + ptrType$12 = $ptrType(SockaddrNetlink); + arrayType$4 = $arrayType($Uint8, 32); + arrayType$5 = $arrayType($Int64, 3); + arrayType$8 = $arrayType($Int8, 108); + arrayType$9 = $arrayType($Uint8, 4); + arrayType$10 = $arrayType($Int8, 14); + arrayType$11 = $arrayType($Int8, 96); + ptrType$19 = $ptrType(_Socklen); + ptrType$20 = $ptrType(Iovec); + structType = $structType("syscall", [{prop: "addr", name: "addr", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: $Int, tag: ""}]); + ptrType$23 = $ptrType($Int64); + funcType = $funcType([$Uintptr], [], false); + funcType$1 = $funcType([$Uintptr], [$Bool], false); + ptrType$25 = $ptrType(SockaddrLinklayer); + ptrType$26 = $ptrType(mmapper); + mapType = $mapType(ptrType$2, sliceType); + funcType$2 = $funcType([$Uintptr, $Uintptr, $Int, $Int, $Int, $Int64], [$Uintptr, $error], false); + funcType$3 = $funcType([$Uintptr, $Uintptr], [$error], false); + ptrType$27 = $ptrType(SockaddrInet4); + ptrType$28 = $ptrType(SockaddrInet6); + ptrType$29 = $ptrType(SockaddrUnix); + ptrType$30 = $ptrType(Timespec); + ptrType$32 = $ptrType(Msghdr); + init = function() { + $flushConsole = (function() { + if (!((lineBuffer.$length === 0))) { + $global.console.log($externalize(($bytesToString(lineBuffer)), $String)); + lineBuffer = sliceType.nil; + } + }); + }; + printWarning = function() { + if (!warningPrinted) { + $global.console.error($externalize("warning: system calls not available, see https://github.com/gopherjs/gopherjs/blob/master/doc/syscalls.md", $String)); + } + warningPrinted = true; + }; + printToConsole = function(b) { + var b, goPrintToConsole, i; + goPrintToConsole = $global.goPrintToConsole; + if (!(goPrintToConsole === undefined)) { + goPrintToConsole(b); + return; + } + lineBuffer = $appendSlice(lineBuffer, b); + while (true) { + i = indexByte(lineBuffer, 10); + if (i === -1) { + break; + } + $global.console.log($externalize(($bytesToString($subslice(lineBuffer, 0, i))), $String)); + lineBuffer = $subslice(lineBuffer, (i + 1 >> 0)); + } + }; + Exit = function(code) { + var code; + Syscall(231, ((code >>> 0)), 0, 0); + }; + $pkg.Exit = Exit; + indexByte = function(s, c) { + var _i, _ref, b, c, i, s; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b === c) { + return i; + } + _i++; + } + return -1; + }; + runtime_envs = function() { + var envkeys, envs$1, i, jsEnv, key, process; + process = $global.process; + if (process === undefined) { + return sliceType$1.nil; + } + jsEnv = process.env; + envkeys = $global.Object.keys(jsEnv); + envs$1 = $makeSlice(sliceType$1, $parseInt(envkeys.length)); + i = 0; + while (true) { + if (!(i < $parseInt(envkeys.length))) { break; } + key = $internalize(envkeys[i], $String); + ((i < 0 || i >= envs$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : envs$1.$array[envs$1.$offset + i] = key + "=" + $internalize(jsEnv[$externalize(key, $String)], $String)); + i = i + (1) >> 0; + } + return envs$1; + }; + syscallByName = function(name) { + var name, require, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([(function() { + $recover(); + }), []]); + if (syscallModule === null) { + if (alreadyTriedToLoad) { + return null; + } + alreadyTriedToLoad = true; + require = $global.require; + if (require === undefined) { + $panic(new $String("")); + } + syscallModule = require($externalize("syscall", $String)); + } + return syscallModule[$externalize(name, $String)]; + /* */ } catch(err) { $err = err; return null; } finally { $callDeferred($deferred, $err); } + }; + Syscall = function(trap, a1, a2, a3) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, a1, a2, a3, array, err, f, r, r1, r2, slice, trap; + r1 = 0; + r2 = 0; + err = 0; + f = syscallByName("Syscall"); + if (!(f === null)) { + r = f(trap, a1, a2, a3); + _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); + _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); + _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); + r1 = _tmp; + r2 = _tmp$1; + err = _tmp$2; + return [r1, r2, err]; + } + if ((trap === 1) && ((a1 === 1) || (a1 === 2))) { + array = a2; + slice = $makeSlice(sliceType, $parseInt(array.length)); + slice.$array = array; + printToConsole(slice); + _tmp$3 = (($parseInt(array.length) >>> 0)); + _tmp$4 = 0; + _tmp$5 = 0; + r1 = _tmp$3; + r2 = _tmp$4; + err = _tmp$5; + return [r1, r2, err]; + } + if (trap === 231) { + runtime.Goexit(); + } + printWarning(); + _tmp$6 = ((minusOne >>> 0)); + _tmp$7 = 0; + _tmp$8 = 13; + r1 = _tmp$6; + r2 = _tmp$7; + err = _tmp$8; + return [r1, r2, err]; + }; + $pkg.Syscall = Syscall; + Syscall6 = function(trap, a1, a2, a3, a4, a5, a6) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a1, a2, a3, a4, a5, a6, err, f, r, r1, r2, trap; + r1 = 0; + r2 = 0; + err = 0; + f = syscallByName("Syscall6"); + if (!(f === null)) { + r = f(trap, a1, a2, a3, a4, a5, a6); + _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); + _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); + _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); + r1 = _tmp; + r2 = _tmp$1; + err = _tmp$2; + return [r1, r2, err]; + } + if (!((trap === 202))) { + printWarning(); + } + _tmp$3 = ((minusOne >>> 0)); + _tmp$4 = 0; + _tmp$5 = 13; + r1 = _tmp$3; + r2 = _tmp$4; + err = _tmp$5; + return [r1, r2, err]; + }; + $pkg.Syscall6 = Syscall6; + BytePtrFromString = function(s) { + var _i, _ref, array, b, i, s; + array = new ($global.Uint8Array)(s.length + 1 >> 0); + _ref = (new sliceType($stringToBytes(s))); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b === 0) { + return [ptrType$2.nil, new Errno(22)]; + } + array[i] = b; + _i++; + } + array[s.length] = 0; + return [((array)), $ifaceNil]; + }; + $pkg.BytePtrFromString = BytePtrFromString; + readInt = function(b, off, size) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, off, ok, size, u; + u = new $Uint64(0, 0); + ok = false; + if (b.$length < (((off + size >>> 0) >> 0))) { + _tmp = new $Uint64(0, 0); + _tmp$1 = false; + u = _tmp; + ok = _tmp$1; + return [u, ok]; + } + if (false) { + _tmp$2 = readIntBE($subslice(b, off), size); + _tmp$3 = true; + u = _tmp$2; + ok = _tmp$3; + return [u, ok]; + } + _tmp$4 = readIntLE($subslice(b, off), size); + _tmp$5 = true; + u = _tmp$4; + ok = _tmp$5; + return [u, ok]; + }; + readIntBE = function(b, size) { + var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + _1 = size; + if (_1 === (1)) { + return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); + } else if (_1 === (2)) { + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return (x = (new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), x$1 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); + } else if (_1 === (4)) { + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), x$5 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); + } else if (_1 === (8)) { + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$15 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); + } else { + $panic(new $String("syscall: readInt with unsupported size")); + } + }; + readIntLE = function(b, size) { + var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + _1 = size; + if (_1 === (1)) { + return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); + } else if (_1 === (2)) { + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return (x = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$1 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); + } else if (_1 === (4)) { + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$5 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); + } else if (_1 === (8)) { + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$15 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); + } else { + $panic(new $String("syscall: readInt with unsupported size")); + } + }; + ParseDirent = function(buf, max, names) { + var _i, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, buf, c, consumed, count, i, ino, max, name, names, namlen, newnames, ok, origlen, rec, reclen, x, x$1, x$2; + consumed = 0; + count = 0; + newnames = sliceType$1.nil; + origlen = buf.$length; + count = 0; + while (true) { + if (!(!((max === 0)) && buf.$length > 0)) { break; } + _tuple = direntReclen(buf); + reclen = _tuple[0]; + ok = _tuple[1]; + if (!ok || (x = (new $Uint64(0, buf.$length)), (reclen.$high > x.$high || (reclen.$high === x.$high && reclen.$low > x.$low)))) { + _tmp = origlen; + _tmp$1 = count; + _tmp$2 = names; + consumed = _tmp; + count = _tmp$1; + newnames = _tmp$2; + return [consumed, count, newnames]; + } + rec = $subslice(buf, 0, $flatten64(reclen)); + buf = $subslice(buf, $flatten64(reclen)); + _tuple$1 = direntIno(rec); + ino = _tuple$1[0]; + ok = _tuple$1[1]; + if (!ok) { + break; + } + if ((ino.$high === 0 && ino.$low === 0)) { + continue; + } + _tuple$2 = direntNamlen(rec); + namlen = _tuple$2[0]; + ok = _tuple$2[1]; + if (!ok || (x$1 = new $Uint64(0 + namlen.$high, 19 + namlen.$low), x$2 = (new $Uint64(0, rec.$length)), (x$1.$high > x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { + break; + } + name = $subslice(rec, 19, $flatten64(new $Uint64(0 + namlen.$high, 19 + namlen.$low))); + _ref = name; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (c === 0) { + name = $subslice(name, 0, i); + break; + } + _i++; + } + if (($bytesToString(name)) === "." || ($bytesToString(name)) === "..") { + continue; + } + max = max - (1) >> 0; + count = count + (1) >> 0; + names = $append(names, ($bytesToString(name))); + } + _tmp$3 = origlen - buf.$length >> 0; + _tmp$4 = count; + _tmp$5 = names; + consumed = _tmp$3; + count = _tmp$4; + newnames = _tmp$5; + return [consumed, count, newnames]; + }; + $pkg.ParseDirent = ParseDirent; + CloseOnExec = function(fd) { + var fd; + fcntl(fd, 2, 1); + }; + $pkg.CloseOnExec = CloseOnExec; + SetNonblock = function(fd, nonblocking) { + var _tuple, _tuple$1, err, fd, flag, nonblocking; + err = $ifaceNil; + _tuple = fcntl(fd, 3, 0); + flag = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + err = err; + return err; + } + if (nonblocking) { + flag = flag | (2048); + } else { + flag = (flag & ~(2048)) >> 0; + } + _tuple$1 = fcntl(fd, 4, flag); + err = _tuple$1[1]; + err = err; + return err; + }; + $pkg.SetNonblock = SetNonblock; + msanRead = function(addr, len) { + var addr, len; + }; + msanWrite = function(addr, len) { + var addr, len; + }; + itoa = function(val) { + var val; + if (val < 0) { + return "-" + uitoa(((-val >>> 0))); + } + return uitoa(((val >>> 0))); + }; + uitoa = function(val) { + var _q, _r, buf, i, val; + buf = arrayType$4.zero(); + i = 31; + while (true) { + if (!(val >= 10)) { break; } + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((_r = val % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); + i = i - (1) >> 0; + val = (_q = val / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + } + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((val + 48 >>> 0) << 24 >>> 24))); + return ($bytesToString($subslice(new sliceType(buf), i))); + }; + Timespec.ptr.prototype.Unix = function() { + var _tmp, _tmp$1, nsec, sec, ts; + sec = new $Int64(0, 0); + nsec = new $Int64(0, 0); + ts = this; + _tmp = (ts.Sec); + _tmp$1 = (ts.Nsec); + sec = _tmp; + nsec = _tmp$1; + return [sec, nsec]; + }; + Timespec.prototype.Unix = function() { return this.$val.Unix(); }; + Timespec.ptr.prototype.Nano = function() { + var ts, x, x$1; + ts = this; + return (x = $mul64((ts.Sec), new $Int64(0, 1000000000)), x$1 = (ts.Nsec), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); + }; + Timespec.prototype.Nano = function() { return this.$val.Nano(); }; + SockaddrInet4.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, p, sa, x, x$1, x$2; + sa = this; + if (sa.Port < 0 || sa.Port > 65535) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 2; + p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); + p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); + p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); + i = 0; + while (true) { + if (!(i < 4)) { break; } + (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(16); + return [(_array), 16, $ifaceNil]; + }; + SockaddrInet4.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrInet6.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, p, sa, x, x$1, x$2; + sa = this; + if (sa.Port < 0 || sa.Port > 65535) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 10; + p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); + p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); + p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); + sa.raw.Scope_id = sa.ZoneId; + i = 0; + while (true) { + if (!(i < 16)) { break; } + (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(28); + return [(_array), 28, $ifaceNil]; + }; + SockaddrInet6.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrUnix.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, n, name, sa, sl, x; + sa = this; + name = sa.Name; + n = name.length; + if (n > 108) { + return [0, 0, new Errno(22)]; + } + if ((n === 108) && !((name.charCodeAt(0) === 64))) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 1; + i = 0; + while (true) { + if (!(i < n)) { break; } + (x = sa.raw.Path, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i] = ((name.charCodeAt(i) << 24 >> 24)))); + i = i + (1) >> 0; + } + sl = 2; + if (n > 0) { + sl = sl + ((((n >>> 0)) + 1 >>> 0)) >>> 0; + } + if (sa.raw.Path[0] === 64) { + sa.raw.Path[0] = 0; + sl = sl - (1) >>> 0; + } + _array = new Uint8Array(110); + return [(_array), sl, $ifaceNil]; + }; + SockaddrUnix.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrLinklayer.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, sa, x, x$1; + sa = this; + if (sa.Ifindex < 0 || sa.Ifindex > 2147483647) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 17; + sa.raw.Protocol = sa.Protocol; + sa.raw.Ifindex = ((sa.Ifindex >> 0)); + sa.raw.Hatype = sa.Hatype; + sa.raw.Pkttype = sa.Pkttype; + sa.raw.Halen = sa.Halen; + i = 0; + while (true) { + if (!(i < 8)) { break; } + (x$1 = sa.raw.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = sa.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(20); + return [(_array), 20, $ifaceNil]; + }; + SockaddrLinklayer.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrNetlink.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, sa; + sa = this; + sa.raw.Family = 16; + sa.raw.Pad = sa.Pad; + sa.raw.Pid = sa.Pid; + sa.raw.Groups = sa.Groups; + _array = new Uint8Array(12); + return [(_array), 12, $ifaceNil]; + }; + SockaddrNetlink.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + anyToSockaddr = function(rsa) { + var _1, _array, _array$1, _array$2, _array$3, _array$4, _array$5, _array$6, _array$7, _array$8, _array$9, _struct, _struct$1, _struct$2, _struct$3, _struct$4, _struct$5, _struct$6, _struct$7, _struct$8, _struct$9, _view, _view$1, _view$2, _view$3, _view$4, _view$5, _view$6, _view$7, _view$8, _view$9, bytes, i, i$1, i$2, n, p, p$1, pp, pp$1, pp$2, pp$3, pp$4, rsa, sa, sa$1, sa$2, sa$3, sa$4, x, x$1, x$2, x$3, x$4, x$5, x$6; + _1 = rsa.Addr.Family; + if (_1 === (16)) { + _array$1 = new Uint8Array(112); + pp = ((_array = (_array$1), _struct = new RawSockaddrNetlink.ptr(0, 0, 0, 0), _view = new DataView(_array.buffer, _array.byteOffset), _struct.Family = _view.getUint16(0, true), _struct.Pad = _view.getUint16(2, true), _struct.Pid = _view.getUint32(4, true), _struct.Groups = _view.getUint32(8, true), _struct)); + _struct$1 = rsa, _view$1 = new DataView(_array$1.buffer, _array$1.byteOffset), _struct$1.Addr.Family = _view$1.getUint16(0, true), _struct$1.Addr.Data = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 2, _array$1.buffer.byteLength)), _struct$1.Pad = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 16, _array$1.buffer.byteLength)); + sa = new SockaddrNetlink.ptr(0, 0, 0, 0, new RawSockaddrNetlink.ptr(0, 0, 0, 0)); + sa.Family = pp.Family; + sa.Pad = pp.Pad; + sa.Pid = pp.Pid; + sa.Groups = pp.Groups; + return [sa, $ifaceNil]; + } else if (_1 === (17)) { + _array$3 = new Uint8Array(112); + pp$1 = ((_array$2 = (_array$3), _struct$2 = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()), _view$2 = new DataView(_array$2.buffer, _array$2.byteOffset), _struct$2.Family = _view$2.getUint16(0, true), _struct$2.Protocol = _view$2.getUint16(2, true), _struct$2.Ifindex = _view$2.getInt32(4, true), _struct$2.Hatype = _view$2.getUint16(8, true), _struct$2.Pkttype = _view$2.getUint8(10, true), _struct$2.Halen = _view$2.getUint8(11, true), _struct$2.Addr = new ($nativeArray($kindUint8))(_array$2.buffer, $min(_array$2.byteOffset + 12, _array$2.buffer.byteLength)), _struct$2)); + _struct$3 = rsa, _view$3 = new DataView(_array$3.buffer, _array$3.byteOffset), _struct$3.Addr.Family = _view$3.getUint16(0, true), _struct$3.Addr.Data = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 2, _array$3.buffer.byteLength)), _struct$3.Pad = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 16, _array$3.buffer.byteLength)); + sa$1 = new SockaddrLinklayer.ptr(0, 0, 0, 0, 0, arrayType$1.zero(), new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero())); + sa$1.Protocol = pp$1.Protocol; + sa$1.Ifindex = ((pp$1.Ifindex >> 0)); + sa$1.Hatype = pp$1.Hatype; + sa$1.Pkttype = pp$1.Pkttype; + sa$1.Halen = pp$1.Halen; + i = 0; + while (true) { + if (!(i < 8)) { break; } + (x$1 = sa$1.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = pp$1.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); + i = i + (1) >> 0; + } + return [sa$1, $ifaceNil]; + } else if (_1 === (1)) { + _array$5 = new Uint8Array(112); + pp$2 = ((_array$4 = (_array$5), _struct$4 = new RawSockaddrUnix.ptr(0, arrayType$8.zero()), _view$4 = new DataView(_array$4.buffer, _array$4.byteOffset), _struct$4.Family = _view$4.getUint16(0, true), _struct$4.Path = new ($nativeArray($kindInt8))(_array$4.buffer, $min(_array$4.byteOffset + 2, _array$4.buffer.byteLength)), _struct$4)); + _struct$5 = rsa, _view$5 = new DataView(_array$5.buffer, _array$5.byteOffset), _struct$5.Addr.Family = _view$5.getUint16(0, true), _struct$5.Addr.Data = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 2, _array$5.buffer.byteLength)), _struct$5.Pad = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 16, _array$5.buffer.byteLength)); + sa$2 = new SockaddrUnix.ptr("", new RawSockaddrUnix.ptr(0, arrayType$8.zero())); + if (pp$2.Path[0] === 0) { + pp$2.Path[0] = 64; + } + n = 0; + while (true) { + if (!(n < 108 && !(((x$2 = pp$2.Path, ((n < 0 || n >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[n])) === 0)))) { break; } + n = n + (1) >> 0; + } + bytes = $subslice(new sliceType((($sliceToArray(new sliceType(pp$2.Path))))), 0, n); + sa$2.Name = ($bytesToString(bytes)); + return [sa$2, $ifaceNil]; + } else if (_1 === (2)) { + _array$7 = new Uint8Array(112); + pp$3 = ((_array$6 = (_array$7), _struct$6 = new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero()), _view$6 = new DataView(_array$6.buffer, _array$6.byteOffset), _struct$6.Family = _view$6.getUint16(0, true), _struct$6.Port = _view$6.getUint16(2, true), _struct$6.Addr = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 4, _array$6.buffer.byteLength)), _struct$6.Zero = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 8, _array$6.buffer.byteLength)), _struct$6)); + _struct$7 = rsa, _view$7 = new DataView(_array$7.buffer, _array$7.byteOffset), _struct$7.Addr.Family = _view$7.getUint16(0, true), _struct$7.Addr.Data = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 2, _array$7.buffer.byteLength)), _struct$7.Pad = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 16, _array$7.buffer.byteLength)); + sa$3 = new SockaddrInet4.ptr(0, arrayType$9.zero(), new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero())); + p = (((pp$3.$ptr_Port || (pp$3.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$3))))); + sa$3.Port = ((((p.nilCheck, p[0]) >> 0)) << 8 >> 0) + (((p.nilCheck, p[1]) >> 0)) >> 0; + i$1 = 0; + while (true) { + if (!(i$1 < 4)) { break; } + (x$4 = sa$3.Addr, ((i$1 < 0 || i$1 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[i$1] = (x$3 = pp$3.Addr, ((i$1 < 0 || i$1 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[i$1])))); + i$1 = i$1 + (1) >> 0; + } + return [sa$3, $ifaceNil]; + } else if (_1 === (10)) { + _array$9 = new Uint8Array(112); + pp$4 = ((_array$8 = (_array$9), _struct$8 = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0), _view$8 = new DataView(_array$8.buffer, _array$8.byteOffset), _struct$8.Family = _view$8.getUint16(0, true), _struct$8.Port = _view$8.getUint16(2, true), _struct$8.Flowinfo = _view$8.getUint32(4, true), _struct$8.Addr = new ($nativeArray($kindUint8))(_array$8.buffer, $min(_array$8.byteOffset + 8, _array$8.buffer.byteLength)), _struct$8.Scope_id = _view$8.getUint32(24, true), _struct$8)); + _struct$9 = rsa, _view$9 = new DataView(_array$9.buffer, _array$9.byteOffset), _struct$9.Addr.Family = _view$9.getUint16(0, true), _struct$9.Addr.Data = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 2, _array$9.buffer.byteLength)), _struct$9.Pad = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 16, _array$9.buffer.byteLength)); + sa$4 = new SockaddrInet6.ptr(0, 0, arrayType$2.zero(), new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0)); + p$1 = (((pp$4.$ptr_Port || (pp$4.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$4))))); + sa$4.Port = ((((p$1.nilCheck, p$1[0]) >> 0)) << 8 >> 0) + (((p$1.nilCheck, p$1[1]) >> 0)) >> 0; + sa$4.ZoneId = pp$4.Scope_id; + i$2 = 0; + while (true) { + if (!(i$2 < 16)) { break; } + (x$6 = sa$4.Addr, ((i$2 < 0 || i$2 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i$2] = (x$5 = pp$4.Addr, ((i$2 < 0 || i$2 >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i$2])))); + i$2 = i$2 + (1) >> 0; + } + return [sa$4, $ifaceNil]; + } + return [$ifaceNil, new Errno(97)]; + }; + Accept = function(fd) { + var _tuple, _tuple$1, err, fd, len, len$24ptr, nfd, rsa, sa; + nfd = 0; + sa = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); + len = 112; + _tuple = accept(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; })))); + nfd = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [nfd, sa, err]; + } + _tuple$1 = anyToSockaddr(rsa); + sa = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + Close(nfd); + nfd = 0; + } + return [nfd, sa, err]; + }; + $pkg.Accept = Accept; + Accept4 = function(fd, flags) { + var _tuple, _tuple$1, err, fd, flags, len, len$24ptr, nfd, rsa, sa; + nfd = 0; + sa = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); + len = 112; + _tuple = accept4(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; }))), flags); + nfd = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [nfd, sa, err]; + } + if (len > 112) { + $panic(new $String("RawSockaddrAny too small")); + } + _tuple$1 = anyToSockaddr(rsa); + sa = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + Close(nfd); + nfd = 0; + } + return [nfd, sa, err]; + }; + $pkg.Accept4 = Accept4; + SetsockoptIPMreqn = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(12); + err = setsockopt(fd, level, opt, (_array), 12); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Address = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)), _struct.Ifindex = _view.getInt32(8, true); + return err; + }; + $pkg.SetsockoptIPMreqn = SetsockoptIPMreqn; + Recvmsg = function(fd, p, oob, flags) { + var _array, _struct, _tuple, _tuple$1, _tuple$2, _view, dummy, dummy$24ptr, err, fd, flags, from, iov, msg, n, oob, oobn, p, recvflags, rsa, sockType; + n = 0; + oobn = 0; + recvflags = 0; + from = $ifaceNil; + err = $ifaceNil; + msg = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$9.zero(), ptrType$20.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$9.zero()); + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); + _array = new Uint8Array(112); + msg.Name = ((_array)); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + msg.Namelen = 112; + iov = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); + if (p.$length > 0) { + iov.Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); + iov.SetLen(p.$length); + } + dummy = 0; + if (oob.$length > 0) { + if (p.$length === 0) { + sockType = 0; + _tuple = GetsockoptInt(fd, 1, 3); + sockType = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, oobn, recvflags, from, err]; + } + if (!((sockType === 2))) { + iov.Base = (dummy$24ptr || (dummy$24ptr = new ptrType$2(function() { return dummy; }, function($v) { dummy = $v; }))); + iov.SetLen(1); + } + } + msg.Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); + msg.SetControllen(oob.$length); + } + msg.Iov = iov; + msg.Iovlen = new $Uint64(0, 1); + _tuple$1 = recvmsg(fd, msg, flags); + n = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, oobn, recvflags, from, err]; + } + oobn = ((msg.Controllen.$low >> 0)); + recvflags = ((msg.Flags >> 0)); + if (!((rsa.Addr.Family === 0))) { + _tuple$2 = anyToSockaddr(rsa); + from = _tuple$2[0]; + err = _tuple$2[1]; + } + return [n, oobn, recvflags, from, err]; + }; + $pkg.Recvmsg = Recvmsg; + SendmsgN = function(fd, p, oob, to, flags) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, dummy, err, err$1, fd, flags, iov, msg, n, oob, p, ptr, salen, sockType, to, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; dummy = $f.dummy; err = $f.err; err$1 = $f.err$1; fd = $f.fd; flags = $f.flags; iov = $f.iov; msg = $f.msg; n = $f.n; oob = $f.oob; p = $f.p; ptr = $f.ptr; salen = $f.salen; sockType = $f.sockType; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + dummy = [dummy]; + iov = [iov]; + msg = [msg]; + n = 0; + err = $ifaceNil; + ptr = 0; + salen = 0; + /* */ if (!($interfaceIsEqual(to, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(to, $ifaceNil))) { */ case 1: + err$1 = $ifaceNil; + _r = to.sockaddr(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ptr = _tuple[0]; + salen = _tuple[1]; + err$1 = _tuple[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + /* } */ case 2: + msg[0] = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$9.zero(), ptrType$20.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$9.zero()); + msg[0].Name = (ptr); + msg[0].Namelen = ((salen >>> 0)); + iov[0] = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); + if (p.$length > 0) { + iov[0].Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); + iov[0].SetLen(p.$length); + } + dummy[0] = 0; + if (oob.$length > 0) { + if (p.$length === 0) { + sockType = 0; + _tuple$1 = GetsockoptInt(fd, 1, 3); + sockType = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$2 = 0; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + if (!((sockType === 2))) { + iov[0].Base = (dummy.$ptr || (dummy.$ptr = new ptrType$2(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, dummy))); + iov[0].SetLen(1); + } + } + msg[0].Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); + msg[0].SetControllen(oob.$length); + } + msg[0].Iov = iov[0]; + msg[0].Iovlen = new $Uint64(0, 1); + _tuple$2 = sendmsg(fd, msg[0], flags); + n = _tuple$2[0]; + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$4 = 0; + _tmp$5 = err; + n = _tmp$4; + err = _tmp$5; + $s = -1; return [n, err]; + } + if (oob.$length > 0 && (p.$length === 0)) { + n = 0; + } + _tmp$6 = n; + _tmp$7 = $ifaceNil; + n = _tmp$6; + err = _tmp$7; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: SendmsgN }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.dummy = dummy; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.flags = flags; $f.iov = iov; $f.msg = msg; $f.n = n; $f.oob = oob; $f.p = p; $f.ptr = ptr; $f.salen = salen; $f.sockType = sockType; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.SendmsgN = SendmsgN; + ReadDirent = function(fd, buf) { + var _tuple, buf, err, fd, n; + n = 0; + err = $ifaceNil; + _tuple = Getdents(fd, buf); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + $pkg.ReadDirent = ReadDirent; + direntIno = function(buf) { + var buf; + return readInt(buf, 0, 8); + }; + direntReclen = function(buf) { + var buf; + return readInt(buf, 16, 2); + }; + direntNamlen = function(buf) { + var _tuple, buf, ok, reclen; + _tuple = direntReclen(buf); + reclen = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + return [new $Uint64(0, 0), false]; + } + return [new $Uint64(reclen.$high - 0, reclen.$low - 19), true]; + }; + Lstat = function(path, stat) { + var err, path, stat; + err = $ifaceNil; + err = fstatat(-100, path, stat, 256); + return err; + }; + $pkg.Lstat = Lstat; + Iovec.ptr.prototype.SetLen = function(length) { + var iov, length; + iov = this; + iov.Len = (new $Uint64(0, length)); + }; + Iovec.prototype.SetLen = function(length) { return this.$val.SetLen(length); }; + Msghdr.ptr.prototype.SetControllen = function(length) { + var length, msghdr; + msghdr = this; + msghdr.Controllen = (new $Uint64(0, length)); + }; + Msghdr.prototype.SetControllen = function(length) { return this.$val.SetControllen(length); }; + mmapper.ptr.prototype.Mmap = function(fd, offset, length, prot, flags) { + var _key, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, addr, b, data, err, errno, fd, flags, length, m, offset, p, prot, sl, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _key = $f._key; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; addr = $f.addr; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; fd = $f.fd; flags = $f.flags; length = $f.length; m = $f.m; offset = $f.offset; p = $f.p; prot = $f.prot; sl = $f.sl; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + sl = [sl]; + data = sliceType.nil; + err = $ifaceNil; + m = this; + if (length <= 0) { + _tmp = sliceType.nil; + _tmp$1 = new Errno(22); + data = _tmp; + err = _tmp$1; + $s = -1; return [data, err]; + } + _r = m.mmap(0, ((length >>> 0)), prot, flags, fd, offset); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + addr = _tuple[0]; + errno = _tuple[1]; + if (!($interfaceIsEqual(errno, $ifaceNil))) { + _tmp$2 = sliceType.nil; + _tmp$3 = errno; + data = _tmp$2; + err = _tmp$3; + $s = -1; return [data, err]; + } + sl[0] = new structType.ptr(addr, length, length); + b = sl[0]; + p = $indexPtr(b.$array, b.$offset + (b.$capacity - 1 >> 0), ptrType$2); + $r = m.Mutex.Lock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); + _key = p; (m.active || $throwRuntimeError("assignment to entry in nil map"))[ptrType$2.keyFor(_key)] = { k: _key, v: b }; + _tmp$4 = b; + _tmp$5 = $ifaceNil; + data = _tmp$4; + err = _tmp$5; + $s = -1; return [data, err]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [data, err]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Mmap }; } $f._key = _key; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.addr = addr; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.fd = fd; $f.flags = flags; $f.length = length; $f.m = m; $f.offset = offset; $f.p = p; $f.prot = prot; $f.sl = sl; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + mmapper.prototype.Mmap = function(fd, offset, length, prot, flags) { return this.$val.Mmap(fd, offset, length, prot, flags); }; + mmapper.ptr.prototype.Munmap = function(data) { + var _entry, _r, b, data, err, errno, m, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; m = $f.m; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + err = $ifaceNil; + m = this; + if ((data.$length === 0) || !((data.$length === data.$capacity))) { + err = new Errno(22); + $s = -1; return err; + } + p = $indexPtr(data.$array, data.$offset + (data.$capacity - 1 >> 0), ptrType$2); + $r = m.Mutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); + b = (_entry = m.active[ptrType$2.keyFor(p)], _entry !== undefined ? _entry.v : sliceType.nil); + if (b === sliceType.nil || !($indexPtr(b.$array, b.$offset + 0, ptrType$2) === $indexPtr(data.$array, data.$offset + 0, ptrType$2))) { + err = new Errno(22); + $s = -1; return err; + } + _r = m.munmap((($sliceToArray(b))), ((b.$length >>> 0))); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + errno = _r; + if (!($interfaceIsEqual(errno, $ifaceNil))) { + err = errno; + $s = -1; return err; + } + delete m.active[ptrType$2.keyFor(p)]; + err = $ifaceNil; + $s = -1; return err; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Munmap }; } $f._entry = _entry; $f._r = _r; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.m = m; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + mmapper.prototype.Munmap = function(data) { return this.$val.Munmap(data); }; + Errno.prototype.Error = function() { + var e, s; + e = this.$val; + if (0 <= ((e >> 0)) && ((e >> 0)) < 133) { + s = ((e < 0 || e >= errors.length) ? ($throwRuntimeError("index out of range"), undefined) : errors[e]); + if (!(s === "")) { + return s; + } + } + return "errno " + itoa(((e >> 0))); + }; + $ptrType(Errno).prototype.Error = function() { return new Errno(this.$get()).Error(); }; + Errno.prototype.Temporary = function() { + var e; + e = this.$val; + return (e === 4) || (e === 24) || new Errno(e).Timeout(); + }; + $ptrType(Errno).prototype.Temporary = function() { return new Errno(this.$get()).Temporary(); }; + Errno.prototype.Timeout = function() { + var e; + e = this.$val; + return (e === 11) || (e === 11) || (e === 110); + }; + $ptrType(Errno).prototype.Timeout = function() { return new Errno(this.$get()).Timeout(); }; + errnoErr = function(e) { + var _1, e; + _1 = e; + if (_1 === (0)) { + return $ifaceNil; + } else if (_1 === (11)) { + return errEAGAIN; + } else if (_1 === (22)) { + return errEINVAL; + } else if (_1 === (2)) { + return errENOENT; + } + return new Errno(e); + }; + Read = function(fd, p) { + var _tuple, err, fd, n, p; + n = 0; + err = $ifaceNil; + _tuple = read(fd, p); + n = _tuple[0]; + err = _tuple[1]; + if (false) { + if (n > 0) { + race.WriteRange(($sliceToArray(p)), n); + } + if ($interfaceIsEqual(err, $ifaceNil)) { + race.Acquire(((ioSync$24ptr || (ioSync$24ptr = new ptrType$23(function() { return ioSync; }, function($v) { ioSync = $v; }))))); + } + } + if (false && n > 0) { + msanWrite(($sliceToArray(p)), n); + } + return [n, err]; + }; + $pkg.Read = Read; + Write = function(fd, p) { + var _tuple, err, fd, n, p; + n = 0; + err = $ifaceNil; + if (false) { + race.ReleaseMerge(((ioSync$24ptr || (ioSync$24ptr = new ptrType$23(function() { return ioSync; }, function($v) { ioSync = $v; }))))); + } + _tuple = write(fd, p); + n = _tuple[0]; + err = _tuple[1]; + if (false && n > 0) { + race.ReadRange(($sliceToArray(p)), n); + } + if (false && n > 0) { + msanRead(($sliceToArray(p)), n); + } + return [n, err]; + }; + $pkg.Write = Write; + GetsockoptInt = function(fd, level, opt) { + var _tmp, _tmp$1, err, fd, level, n, n$24ptr, opt, vallen, vallen$24ptr, value; + value = 0; + err = $ifaceNil; + n = 0; + vallen = 4; + err = getsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), (vallen$24ptr || (vallen$24ptr = new ptrType$19(function() { return vallen; }, function($v) { vallen = $v; })))); + _tmp = ((n >> 0)); + _tmp$1 = err; + value = _tmp; + err = _tmp$1; + return [value, err]; + }; + $pkg.GetsockoptInt = GetsockoptInt; + Recvfrom = function(fd, p, flags) { + var _tuple, _tuple$1, err, fd, flags, from, len, len$24ptr, n, p, rsa; + n = 0; + from = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); + len = 112; + _tuple = recvfrom(fd, p, flags, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; })))); + n = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, from, err]; + } + if (!((rsa.Addr.Family === 0))) { + _tuple$1 = anyToSockaddr(rsa); + from = _tuple$1[0]; + err = _tuple$1[1]; + } + return [n, from, err]; + }; + $pkg.Recvfrom = Recvfrom; + Sendto = function(fd, p, flags, to) { + var _r, _tuple, err, fd, flags, n, p, ptr, to, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; fd = $f.fd; flags = $f.flags; n = $f.n; p = $f.p; ptr = $f.ptr; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + err = $ifaceNil; + _r = to.sockaddr(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ptr = _tuple[0]; + n = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + err = err; + $s = -1; return err; + } + err = sendto(fd, p, flags, ptr, n); + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sendto }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.fd = fd; $f.flags = flags; $f.n = n; $f.p = p; $f.ptr = ptr; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sendto = Sendto; + SetsockoptByte = function(fd, level, opt, value) { + var err, fd, level, opt, value, value$24ptr; + err = $ifaceNil; + err = setsockopt(fd, level, opt, ((value$24ptr || (value$24ptr = new ptrType$2(function() { return value; }, function($v) { value = $v; })))), 1); + return err; + }; + $pkg.SetsockoptByte = SetsockoptByte; + SetsockoptInt = function(fd, level, opt, value) { + var err, fd, level, n, n$24ptr, opt, value; + err = $ifaceNil; + n = ((value >> 0)); + err = setsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), 4); + return err; + }; + $pkg.SetsockoptInt = SetsockoptInt; + SetsockoptInet4Addr = function(fd, level, opt, value) { + var err, fd, level, opt, value; + err = $ifaceNil; + err = setsockopt(fd, level, opt, ($sliceToArray(new sliceType(value))), 4); + return err; + }; + $pkg.SetsockoptInet4Addr = SetsockoptInet4Addr; + SetsockoptIPMreq = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(8); + err = setsockopt(fd, level, opt, (_array), 8); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)); + return err; + }; + $pkg.SetsockoptIPMreq = SetsockoptIPMreq; + SetsockoptIPv6Mreq = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(20); + err = setsockopt(fd, level, opt, (_array), 20); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = _view.getUint32(16, true); + return err; + }; + $pkg.SetsockoptIPv6Mreq = SetsockoptIPv6Mreq; + SetsockoptLinger = function(fd, level, opt, l) { + var _array, _struct, _view, err, fd, l, level, opt; + err = $ifaceNil; + _array = new Uint8Array(8); + err = setsockopt(fd, level, opt, (_array), 8); + _struct = l, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Onoff = _view.getInt32(0, true), _struct.Linger = _view.getInt32(4, true); + return err; + }; + $pkg.SetsockoptLinger = SetsockoptLinger; + Close = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(3, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Close = Close; + Dup = function(oldfd) { + var _tuple, e1, err, fd, oldfd, r0; + fd = 0; + err = $ifaceNil; + _tuple = Syscall(32, ((oldfd >>> 0)), 0, 0); + r0 = _tuple[0]; + e1 = _tuple[2]; + fd = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [fd, err]; + }; + $pkg.Dup = Dup; + Fchdir = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(81, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchdir = Fchdir; + Fchmod = function(fd, mode) { + var _tuple, e1, err, fd, mode; + err = $ifaceNil; + _tuple = Syscall(91, ((fd >>> 0)), ((mode >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchmod = Fchmod; + fcntl = function(fd, cmd, arg) { + var _tuple, arg, cmd, e1, err, fd, r0, val; + val = 0; + err = $ifaceNil; + _tuple = Syscall(72, ((fd >>> 0)), ((cmd >>> 0)), ((arg >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + val = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [val, err]; + }; + Fsync = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(74, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fsync = Fsync; + Getdents = function(fd, buf) { + var _p0, _tuple, buf, e1, err, fd, n, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (buf.$length > 0) { + _p0 = ($sliceToArray(buf)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(217, ((fd >>> 0)), (_p0), ((buf.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Getdents = Getdents; + read = function(fd, p) { + var _p0, _tuple, e1, err, fd, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(0, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + write = function(fd, p) { + var _p0, _tuple, e1, err, fd, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(1, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + munmap = function(addr, length) { + var _tuple, addr, e1, err, length; + err = $ifaceNil; + _tuple = Syscall(11, (addr), (length), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + Fchown = function(fd, uid, gid) { + var _tuple, e1, err, fd, gid, uid; + err = $ifaceNil; + _tuple = Syscall(93, ((fd >>> 0)), ((uid >>> 0)), ((gid >>> 0))); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchown = Fchown; + Fstat = function(fd, stat) { + var _array, _struct, _tuple, _view, e1, err, fd, stat; + err = $ifaceNil; + _array = new Uint8Array(144); + _tuple = Syscall(5, ((fd >>> 0)), ((_array)), 0); + _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fstat = Fstat; + Ftruncate = function(fd, length) { + var _tuple, e1, err, fd, length; + err = $ifaceNil; + _tuple = Syscall(77, ((fd >>> 0)), ((length.$low >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Ftruncate = Ftruncate; + Pread = function(fd, p, offset) { + var _p0, _tuple, e1, err, fd, n, offset, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(17, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Pread = Pread; + Pwrite = function(fd, p, offset) { + var _p0, _tuple, e1, err, fd, n, offset, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(18, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Pwrite = Pwrite; + Seek = function(fd, offset, whence) { + var _tuple, e1, err, fd, off, offset, r0, whence; + off = new $Int64(0, 0); + err = $ifaceNil; + _tuple = Syscall(8, ((fd >>> 0)), ((offset.$low >>> 0)), ((whence >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + off = (new $Int64(0, r0.constructor === Number ? r0 : 1)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [off, err]; + }; + $pkg.Seek = Seek; + Shutdown = function(fd, how) { + var _tuple, e1, err, fd, how; + err = $ifaceNil; + _tuple = Syscall(48, ((fd >>> 0)), ((how >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Shutdown = Shutdown; + accept = function(s, rsa, addrlen) { + var _array, _struct, _tuple, _view, addrlen, e1, err, fd, r0, rsa, s; + fd = 0; + err = $ifaceNil; + _array = new Uint8Array(112); + _tuple = Syscall(43, ((s >>> 0)), ((_array)), ((addrlen))); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + fd = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [fd, err]; + }; + accept4 = function(s, rsa, addrlen, flags) { + var _array, _struct, _tuple, _view, addrlen, e1, err, fd, flags, r0, rsa, s; + fd = 0; + err = $ifaceNil; + _array = new Uint8Array(112); + _tuple = Syscall6(288, ((s >>> 0)), ((_array)), ((addrlen)), ((flags >>> 0)), 0, 0); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + fd = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [fd, err]; + }; + fstatat = function(fd, path, stat, flags) { + var _array, _p0, _struct, _tuple, _tuple$1, _view, e1, err, fd, flags, path, stat; + err = $ifaceNil; + _p0 = ptrType$2.nil; + _tuple = BytePtrFromString(path); + _p0 = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + _array = new Uint8Array(144); + _tuple$1 = Syscall6(262, ((fd >>> 0)), ((_p0)), ((_array)), ((flags >>> 0)), 0, 0); + _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); + e1 = _tuple$1[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + getsockopt = function(s, level, name, val, vallen) { + var _tuple, e1, err, level, name, s, val, vallen; + err = $ifaceNil; + _tuple = Syscall6(55, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), ((vallen)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + setsockopt = function(s, level, name, val, vallen) { + var _tuple, e1, err, level, name, s, val, vallen; + err = $ifaceNil; + _tuple = Syscall6(54, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), (vallen), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + recvfrom = function(fd, p, flags, from, fromlen) { + var _array, _p0, _struct, _tuple, _view, e1, err, fd, flags, from, fromlen, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _array = new Uint8Array(112); + _tuple = Syscall6(45, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((flags >>> 0)), ((_array)), ((fromlen))); + _struct = from, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + sendto = function(s, buf, flags, to, addrlen) { + var _p0, _tuple, addrlen, buf, e1, err, flags, s, to; + err = $ifaceNil; + _p0 = 0; + if (buf.$length > 0) { + _p0 = ($sliceToArray(buf)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(44, ((s >>> 0)), (_p0), ((buf.$length >>> 0)), ((flags >>> 0)), (to), ((addrlen >>> 0))); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + recvmsg = function(s, msg, flags) { + var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; + n = 0; + err = $ifaceNil; + _array = new Uint8Array(48); + _tuple = Syscall(47, ((s >>> 0)), ((_array)), ((flags >>> 0))); + _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + sendmsg = function(s, msg, flags) { + var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; + n = 0; + err = $ifaceNil; + _array = new Uint8Array(48); + _tuple = Syscall(46, ((s >>> 0)), ((_array)), ((flags >>> 0))); + _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + mmap = function(addr, length, prot, flags, fd, offset) { + var _tuple, addr, e1, err, fd, flags, length, offset, prot, r0, xaddr; + xaddr = 0; + err = $ifaceNil; + _tuple = Syscall6(9, (addr), (length), ((prot >>> 0)), ((flags >>> 0)), ((fd >>> 0)), ((offset.$low >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + xaddr = (r0); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [xaddr, err]; + }; + ptrType$25.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$12.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$26.methods = [{prop: "Mmap", name: "Mmap", pkg: "", typ: $funcType([$Int, $Int64, $Int, $Int, $Int], [sliceType, $error], false)}, {prop: "Munmap", name: "Munmap", pkg: "", typ: $funcType([sliceType], [$error], false)}]; + Errno.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$27.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$28.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$29.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$30.methods = [{prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64, $Int64], false)}, {prop: "Nano", name: "Nano", pkg: "", typ: $funcType([], [$Int64], false)}]; + ptrType$20.methods = [{prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}]; + ptrType$32.methods = [{prop: "SetControllen", name: "SetControllen", pkg: "", typ: $funcType([$Int], [], false)}]; + RawConn.init([{prop: "Control", name: "Control", pkg: "", typ: $funcType([funcType], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([funcType$1], [$error], false)}]); + SockaddrLinklayer.init("syscall", [{prop: "Protocol", name: "Protocol", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Hatype", name: "Hatype", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$1, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrLinklayer, tag: ""}]); + SockaddrNetlink.init("syscall", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrNetlink, tag: ""}]); + mmapper.init("syscall", [{prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: sync.Mutex, tag: ""}, {prop: "active", name: "active", embedded: false, exported: false, typ: mapType, tag: ""}, {prop: "mmap", name: "mmap", embedded: false, exported: false, typ: funcType$2, tag: ""}, {prop: "munmap", name: "munmap", embedded: false, exported: false, typ: funcType$3, tag: ""}]); + Sockaddr.init([{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]); + SockaddrInet4.init("syscall", [{prop: "Port", name: "Port", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrInet4, tag: ""}]); + SockaddrInet6.init("syscall", [{prop: "Port", name: "Port", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "ZoneId", name: "ZoneId", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrInet6, tag: ""}]); + SockaddrUnix.init("syscall", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrUnix, tag: ""}]); + Timespec.init("", [{prop: "Sec", name: "Sec", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Nsec", name: "Nsec", embedded: false, exported: true, typ: $Int64, tag: ""}]); + Stat_t.init("", [{prop: "Dev", name: "Dev", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Ino", name: "Ino", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Nlink", name: "Nlink", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Mode", name: "Mode", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Uid", name: "Uid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Gid", name: "Gid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "X__pad0", name: "X__pad0", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Rdev", name: "Rdev", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Size", name: "Size", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blksize", name: "Blksize", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blocks", name: "Blocks", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Atim", name: "Atim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "Mtim", name: "Mtim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "Ctim", name: "Ctim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "X__unused", name: "X__unused", embedded: false, exported: true, typ: arrayType$5, tag: ""}]); + RawSockaddrInet4.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Zero", name: "Zero", embedded: false, exported: true, typ: arrayType$1, tag: ""}]); + RawSockaddrInet6.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Flowinfo", name: "Flowinfo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Scope_id", name: "Scope_id", embedded: false, exported: true, typ: $Uint32, tag: ""}]); + RawSockaddrUnix.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Path", name: "Path", embedded: false, exported: true, typ: arrayType$8, tag: ""}]); + RawSockaddrLinklayer.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Protocol", name: "Protocol", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Hatype", name: "Hatype", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$1, tag: ""}]); + RawSockaddrNetlink.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", embedded: false, exported: true, typ: $Uint32, tag: ""}]); + RawSockaddr.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Data", name: "Data", embedded: false, exported: true, typ: arrayType$10, tag: ""}]); + RawSockaddrAny.init("", [{prop: "Addr", name: "Addr", embedded: false, exported: true, typ: RawSockaddr, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: arrayType$11, tag: ""}]); + Linger.init("", [{prop: "Onoff", name: "Onoff", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Linger", name: "Linger", embedded: false, exported: true, typ: $Int32, tag: ""}]); + Iovec.init("", [{prop: "Base", name: "Base", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Len", name: "Len", embedded: false, exported: true, typ: $Uint64, tag: ""}]); + IPMreq.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Interface", name: "Interface", embedded: false, exported: true, typ: arrayType$9, tag: ""}]); + IPMreqn.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Address", name: "Address", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int32, tag: ""}]); + IPv6Mreq.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Interface", name: "Interface", embedded: false, exported: true, typ: $Uint32, tag: ""}]); + Msghdr.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Namelen", name: "Namelen", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Iov", name: "Iov", embedded: false, exported: true, typ: ptrType$20, tag: ""}, {prop: "Iovlen", name: "Iovlen", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Control", name: "Control", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Controllen", name: "Controllen", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Flags", name: "Flags", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Pad_cgo_1", name: "Pad_cgo_1", embedded: false, exported: true, typ: arrayType$9, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + lineBuffer = sliceType.nil; + syscallModule = null; + $pkg.ForkLock = new sync.RWMutex.ptr(new sync.Mutex.ptr(0, 0), 0, 0, 0, 0); + ioSync = new $Int64(0, 0); + warningPrinted = false; + alreadyTriedToLoad = false; + minusOne = -1; + envs = runtime_envs(); + $pkg.Stdin = 0; + $pkg.Stdout = 1; + $pkg.Stderr = 2; + errEAGAIN = new Errno(11); + errEINVAL = new Errno(22); + errENOENT = new Errno(2); + errors = $toNativeArray($kindString, ["", "operation not permitted", "no such file or directory", "no such process", "interrupted system call", "input/output error", "no such device or address", "argument list too long", "exec format error", "bad file descriptor", "no child processes", "resource temporarily unavailable", "cannot allocate memory", "permission denied", "bad address", "block device required", "device or resource busy", "file exists", "invalid cross-device link", "no such device", "not a directory", "is a directory", "invalid argument", "too many open files in system", "too many open files", "inappropriate ioctl for device", "text file busy", "file too large", "no space left on device", "illegal seek", "read-only file system", "too many links", "broken pipe", "numerical argument out of domain", "numerical result out of range", "resource deadlock avoided", "file name too long", "no locks available", "function not implemented", "directory not empty", "too many levels of symbolic links", "", "no message of desired type", "identifier removed", "channel number out of range", "level 2 not synchronized", "level 3 halted", "level 3 reset", "link number out of range", "protocol driver not attached", "no CSI structure available", "level 2 halted", "invalid exchange", "invalid request descriptor", "exchange full", "no anode", "invalid request code", "invalid slot", "", "bad font file format", "device not a stream", "no data available", "timer expired", "out of streams resources", "machine is not on the network", "package not installed", "object is remote", "link has been severed", "advertise error", "srmount error", "communication error on send", "protocol error", "multihop attempted", "RFS specific error", "bad message", "value too large for defined data type", "name not unique on network", "file descriptor in bad state", "remote address changed", "can not access a needed shared library", "accessing a corrupted shared library", ".lib section in a.out corrupted", "attempting to link in too many shared libraries", "cannot exec a shared library directly", "invalid or incomplete multibyte or wide character", "interrupted system call should be restarted", "streams pipe error", "too many users", "socket operation on non-socket", "destination address required", "message too long", "protocol wrong type for socket", "protocol not available", "protocol not supported", "socket type not supported", "operation not supported", "protocol family not supported", "address family not supported by protocol", "address already in use", "cannot assign requested address", "network is down", "network is unreachable", "network dropped connection on reset", "software caused connection abort", "connection reset by peer", "no buffer space available", "transport endpoint is already connected", "transport endpoint is not connected", "cannot send after transport endpoint shutdown", "too many references: cannot splice", "connection timed out", "connection refused", "host is down", "no route to host", "operation already in progress", "operation now in progress", "stale NFS file handle", "structure needs cleaning", "not a XENIX named type file", "no XENIX semaphores available", "is a named type file", "remote I/O error", "disk quota exceeded", "no medium found", "wrong medium type", "operation canceled", "required key not available", "key has expired", "key has been revoked", "key was rejected by service", "owner died", "state not recoverable", "operation not possible due to RF-kill"]); + mapper = new mmapper.ptr(new sync.Mutex.ptr(0, 0), {}, mmap, munmap); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/gopherjs/gopherjs/nosync"] = (function() { + var $pkg = {}, $init, Map, Mutex, WaitGroup, Once, Pool, funcType, ptrType, mapType, ptrType$1, ptrType$3, funcType$1, ptrType$4, sliceType, ptrType$5, funcType$2; + Map = $pkg.Map = $newType(0, $kindStruct, "nosync.Map", true, "github.com/gopherjs/gopherjs/nosync", true, function(m_) { + this.$val = this; + if (arguments.length === 0) { + this.m = false; + return; + } + this.m = m_; + }); + Mutex = $pkg.Mutex = $newType(0, $kindStruct, "nosync.Mutex", true, "github.com/gopherjs/gopherjs/nosync", true, function(locked_) { + this.$val = this; + if (arguments.length === 0) { + this.locked = false; + return; + } + this.locked = locked_; + }); + WaitGroup = $pkg.WaitGroup = $newType(0, $kindStruct, "nosync.WaitGroup", true, "github.com/gopherjs/gopherjs/nosync", true, function(counter_) { + this.$val = this; + if (arguments.length === 0) { + this.counter = 0; + return; + } + this.counter = counter_; + }); + Once = $pkg.Once = $newType(0, $kindStruct, "nosync.Once", true, "github.com/gopherjs/gopherjs/nosync", true, function(doing_, done_) { + this.$val = this; + if (arguments.length === 0) { + this.doing = false; + this.done = false; + return; + } + this.doing = doing_; + this.done = done_; + }); + Pool = $pkg.Pool = $newType(0, $kindStruct, "nosync.Pool", true, "github.com/gopherjs/gopherjs/nosync", true, function(store_, New_) { + this.$val = this; + if (arguments.length === 0) { + this.store = sliceType.nil; + this.New = $throwNilPointerError; + return; + } + this.store = store_; + this.New = New_; + }); + funcType = $funcType([$emptyInterface, $emptyInterface], [$Bool], false); + ptrType = $ptrType(Map); + mapType = $mapType($emptyInterface, $emptyInterface); + ptrType$1 = $ptrType(Mutex); + ptrType$3 = $ptrType(WaitGroup); + funcType$1 = $funcType([], [], false); + ptrType$4 = $ptrType(Once); + sliceType = $sliceType($emptyInterface); + ptrType$5 = $ptrType(Pool); + funcType$2 = $funcType([], [$emptyInterface], false); + Map.ptr.prototype.Load = function(key) { + var _entry, _tmp, _tmp$1, _tuple, key, m, ok, value; + value = $ifaceNil; + ok = false; + m = this; + _tuple = (_entry = m.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); + value = _tuple[0]; + ok = _tuple[1]; + _tmp = value; + _tmp$1 = ok; + value = _tmp; + ok = _tmp$1; + return [value, ok]; + }; + Map.prototype.Load = function(key) { return this.$val.Load(key); }; + Map.ptr.prototype.Store = function(key, value) { + var _key, key, m, value; + m = this; + if (m.m === false) { + m.m = {}; + } + _key = key; (m.m || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: value }; + }; + Map.prototype.Store = function(key, value) { return this.$val.Store(key, value); }; + Map.ptr.prototype.LoadOrStore = function(key, value) { + var _entry, _key, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, actual, key, loaded, m, ok, value, value$1; + actual = $ifaceNil; + loaded = false; + m = this; + _tuple = (_entry = m.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); + value$1 = _tuple[0]; + ok = _tuple[1]; + if (ok) { + _tmp = value$1; + _tmp$1 = true; + actual = _tmp; + loaded = _tmp$1; + return [actual, loaded]; + } + if (m.m === false) { + m.m = {}; + } + _key = key; (m.m || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: value }; + _tmp$2 = value; + _tmp$3 = false; + actual = _tmp$2; + loaded = _tmp$3; + return [actual, loaded]; + }; + Map.prototype.LoadOrStore = function(key, value) { return this.$val.LoadOrStore(key, value); }; + Map.ptr.prototype.Delete = function(key) { + var key, m; + m = this; + if (m.m === false) { + return; + } + delete m.m[$emptyInterface.keyFor(key)]; + }; + Map.prototype.Delete = function(key) { return this.$val.Delete(key); }; + Map.ptr.prototype.Range = function(f) { + var _entry, _i, _keys, _r, _ref, f, k, m, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _r = $f._r; _ref = $f._ref; f = $f.f; k = $f.k; m = $f.m; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + _ref = m.m; + _i = 0; + _keys = $keys(_ref); + /* while (true) { */ case 1: + /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 2; continue; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + /* continue; */ $s = 1; continue; + } + k = _entry.k; + v = _entry.v; + _r = f(k, v); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!_r) { */ case 3: + /* break; */ $s = 2; continue; + /* } */ case 4: + _i++; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Range }; } $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._r = _r; $f._ref = _ref; $f.f = f; $f.k = k; $f.m = m; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.Range = function(f) { return this.$val.Range(f); }; + Mutex.ptr.prototype.Lock = function() { + var m; + m = this; + if (m.locked) { + $panic(new $String("nosync: mutex is already locked")); + } + m.locked = true; + }; + Mutex.prototype.Lock = function() { return this.$val.Lock(); }; + Mutex.ptr.prototype.Unlock = function() { + var m; + m = this; + if (!m.locked) { + $panic(new $String("nosync: unlock of unlocked mutex")); + } + m.locked = false; + }; + Mutex.prototype.Unlock = function() { return this.$val.Unlock(); }; + WaitGroup.ptr.prototype.Add = function(delta) { + var delta, wg; + wg = this; + wg.counter = wg.counter + (delta) >> 0; + if (wg.counter < 0) { + $panic(new $String("sync: negative WaitGroup counter")); + } + }; + WaitGroup.prototype.Add = function(delta) { return this.$val.Add(delta); }; + WaitGroup.ptr.prototype.Done = function() { + var wg; + wg = this; + wg.Add(-1); + }; + WaitGroup.prototype.Done = function() { return this.$val.Done(); }; + WaitGroup.ptr.prototype.Wait = function() { + var wg; + wg = this; + if (!((wg.counter === 0))) { + $panic(new $String("sync: WaitGroup counter not zero")); + } + }; + WaitGroup.prototype.Wait = function() { return this.$val.Wait(); }; + Once.ptr.prototype.Do = function(f) { + var f, o, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; f = $f.f; o = $f.o; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + o = [o]; + o[0] = this; + if (o[0].done) { + $s = -1; return; + } + if (o[0].doing) { + $panic(new $String("nosync: Do called within f")); + } + o[0].doing = true; + $deferred.push([(function(o) { return function() { + o[0].doing = false; + o[0].done = true; + }; })(o), []]); + $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.f = f; $f.o = o; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + Once.prototype.Do = function(f) { return this.$val.Do(f); }; + Pool.ptr.prototype.Get = function() { + var _r, p, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (p.store.$length === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (p.store.$length === 0) { */ case 1: + /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(p.New === $throwNilPointerError)) { */ case 3: + _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 2: + x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); + $s = -1; return x$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Pool.prototype.Get = function() { return this.$val.Get(); }; + Pool.ptr.prototype.Put = function(x) { + var p, x; + p = this; + if ($interfaceIsEqual(x, $ifaceNil)) { + return; + } + p.store = $append(p.store, x); + }; + Pool.prototype.Put = function(x) { return this.$val.Put(x); }; + ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [], false)}, {prop: "LoadOrStore", name: "LoadOrStore", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "Range", name: "Range", pkg: "", typ: $funcType([funcType], [], false)}]; + ptrType$1.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + ptrType$3.methods = [{prop: "Add", name: "Add", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [], false)}, {prop: "Wait", name: "Wait", pkg: "", typ: $funcType([], [], false)}]; + ptrType$4.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType$1], [], false)}]; + ptrType$5.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}]; + Map.init("github.com/gopherjs/gopherjs/nosync", [{prop: "m", name: "m", embedded: false, exported: false, typ: mapType, tag: ""}]); + Mutex.init("github.com/gopherjs/gopherjs/nosync", [{prop: "locked", name: "locked", embedded: false, exported: false, typ: $Bool, tag: ""}]); + WaitGroup.init("github.com/gopherjs/gopherjs/nosync", [{prop: "counter", name: "counter", embedded: false, exported: false, typ: $Int, tag: ""}]); + Once.init("github.com/gopherjs/gopherjs/nosync", [{prop: "doing", name: "doing", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "done", name: "done", embedded: false, exported: false, typ: $Bool, tag: ""}]); + Pool.init("github.com/gopherjs/gopherjs/nosync", [{prop: "store", name: "store", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: funcType$2, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["time"] = (function() { + var $pkg = {}, $init, errors, js, nosync, runtime, syscall, ParseError, Time, Month, Weekday, Duration, Location, zone, zoneTrans, sliceType, sliceType$1, ptrType, sliceType$2, arrayType, sliceType$3, arrayType$1, arrayType$2, ptrType$2, arrayType$3, ptrType$4, ptrType$7, zoneSources, std0x, longDayNames, shortDayNames, shortMonthNames, longMonthNames, atoiError, errBad, errLeadingInt, months, days, daysBefore, startNano, utcLoc, utcLoc$24ptr, localLoc, localLoc$24ptr, localOnce, errLocation, badData, x, init, initLocal, runtimeNano, now, indexByte, startsWithLowerCase, nextStdChunk, match, lookup, appendInt, atoi, formatNano, quote, isDigit, getnum, cutspace, skip, Parse, parse, parseTimeZone, parseGMT, parseSignedOffset, parseNanoseconds, leadingInt, absWeekday, absClock, fmtFrac, fmtInt, lessThanHalf, Since, absDate, daysIn, Now, unixTime, Unix, isLeap, norm, Date, div, FixedZone; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + runtime = $packages["runtime"]; + syscall = $packages["syscall"]; + ParseError = $pkg.ParseError = $newType(0, $kindStruct, "time.ParseError", true, "time", true, function(Layout_, Value_, LayoutElem_, ValueElem_, Message_) { + this.$val = this; + if (arguments.length === 0) { + this.Layout = ""; + this.Value = ""; + this.LayoutElem = ""; + this.ValueElem = ""; + this.Message = ""; + return; + } + this.Layout = Layout_; + this.Value = Value_; + this.LayoutElem = LayoutElem_; + this.ValueElem = ValueElem_; + this.Message = Message_; + }); + Time = $pkg.Time = $newType(0, $kindStruct, "time.Time", true, "time", true, function(wall_, ext_, loc_) { + this.$val = this; + if (arguments.length === 0) { + this.wall = new $Uint64(0, 0); + this.ext = new $Int64(0, 0); + this.loc = ptrType$2.nil; + return; + } + this.wall = wall_; + this.ext = ext_; + this.loc = loc_; + }); + Month = $pkg.Month = $newType(4, $kindInt, "time.Month", true, "time", true, null); + Weekday = $pkg.Weekday = $newType(4, $kindInt, "time.Weekday", true, "time", true, null); + Duration = $pkg.Duration = $newType(8, $kindInt64, "time.Duration", true, "time", true, null); + Location = $pkg.Location = $newType(0, $kindStruct, "time.Location", true, "time", true, function(name_, zone_, tx_, cacheStart_, cacheEnd_, cacheZone_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.zone = sliceType.nil; + this.tx = sliceType$1.nil; + this.cacheStart = new $Int64(0, 0); + this.cacheEnd = new $Int64(0, 0); + this.cacheZone = ptrType.nil; + return; + } + this.name = name_; + this.zone = zone_; + this.tx = tx_; + this.cacheStart = cacheStart_; + this.cacheEnd = cacheEnd_; + this.cacheZone = cacheZone_; + }); + zone = $pkg.zone = $newType(0, $kindStruct, "time.zone", true, "time", false, function(name_, offset_, isDST_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.offset = 0; + this.isDST = false; + return; + } + this.name = name_; + this.offset = offset_; + this.isDST = isDST_; + }); + zoneTrans = $pkg.zoneTrans = $newType(0, $kindStruct, "time.zoneTrans", true, "time", false, function(when_, index_, isstd_, isutc_) { + this.$val = this; + if (arguments.length === 0) { + this.when = new $Int64(0, 0); + this.index = 0; + this.isstd = false; + this.isutc = false; + return; + } + this.when = when_; + this.index = index_; + this.isstd = isstd_; + this.isutc = isutc_; + }); + sliceType = $sliceType(zone); + sliceType$1 = $sliceType(zoneTrans); + ptrType = $ptrType(zone); + sliceType$2 = $sliceType($String); + arrayType = $arrayType($Uint8, 20); + sliceType$3 = $sliceType($Uint8); + arrayType$1 = $arrayType($Uint8, 9); + arrayType$2 = $arrayType($Uint8, 64); + ptrType$2 = $ptrType(Location); + arrayType$3 = $arrayType($Uint8, 32); + ptrType$4 = $ptrType(ParseError); + ptrType$7 = $ptrType(Time); + init = function() { + $unused(Unix(new $Int64(0, 0), new $Int64(0, 0))); + }; + initLocal = function() { + var d, i, j, s; + d = new ($global.Date)(); + s = $internalize(d, $String); + i = indexByte(s, 40); + j = indexByte(s, 41); + if ((i === -1) || (j === -1)) { + localLoc.name = "UTC"; + return; + } + localLoc.name = $substring(s, (i + 1 >> 0), j); + localLoc.zone = new sliceType([new zone.ptr(localLoc.name, $imul(($parseInt(d.getTimezoneOffset()) >> 0), -60), false)]); + }; + runtimeNano = function() { + return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); + }; + now = function() { + var _tmp, _tmp$1, _tmp$2, mono, n, nsec, sec, x$1; + sec = new $Int64(0, 0); + nsec = 0; + mono = new $Int64(0, 0); + n = runtimeNano(); + _tmp = $div64(n, new $Int64(0, 1000000000), false); + _tmp$1 = (((x$1 = $div64(n, new $Int64(0, 1000000000), true), x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0)); + _tmp$2 = n; + sec = _tmp; + nsec = _tmp$1; + mono = _tmp$2; + return [sec, nsec, mono]; + }; + indexByte = function(s, c) { + var c, s; + return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; + }; + startsWithLowerCase = function(str) { + var c, str; + if (str.length === 0) { + return false; + } + c = str.charCodeAt(0); + return 97 <= c && c <= 122; + }; + nextStdChunk = function(layout) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$51, _tmp$52, _tmp$53, _tmp$54, _tmp$55, _tmp$56, _tmp$57, _tmp$58, _tmp$59, _tmp$6, _tmp$60, _tmp$61, _tmp$62, _tmp$63, _tmp$64, _tmp$65, _tmp$66, _tmp$67, _tmp$68, _tmp$69, _tmp$7, _tmp$70, _tmp$71, _tmp$72, _tmp$73, _tmp$74, _tmp$75, _tmp$76, _tmp$77, _tmp$78, _tmp$79, _tmp$8, _tmp$80, _tmp$81, _tmp$82, _tmp$83, _tmp$84, _tmp$85, _tmp$86, _tmp$9, c, ch, i, j, layout, prefix, std, std$1, suffix, x$1; + prefix = ""; + std = 0; + suffix = ""; + i = 0; + while (true) { + if (!(i < layout.length)) { break; } + c = ((layout.charCodeAt(i) >> 0)); + _1 = c; + if (_1 === (74)) { + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Jan") { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "January") { + _tmp = $substring(layout, 0, i); + _tmp$1 = 257; + _tmp$2 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp; + std = _tmp$1; + suffix = _tmp$2; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { + _tmp$3 = $substring(layout, 0, i); + _tmp$4 = 258; + _tmp$5 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$3; + std = _tmp$4; + suffix = _tmp$5; + return [prefix, std, suffix]; + } + } + } else if (_1 === (77)) { + if (layout.length >= (i + 3 >> 0)) { + if ($substring(layout, i, (i + 3 >> 0)) === "Mon") { + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Monday") { + _tmp$6 = $substring(layout, 0, i); + _tmp$7 = 261; + _tmp$8 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$6; + std = _tmp$7; + suffix = _tmp$8; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { + _tmp$9 = $substring(layout, 0, i); + _tmp$10 = 262; + _tmp$11 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$9; + std = _tmp$10; + suffix = _tmp$11; + return [prefix, std, suffix]; + } + } + if ($substring(layout, i, (i + 3 >> 0)) === "MST") { + _tmp$12 = $substring(layout, 0, i); + _tmp$13 = 21; + _tmp$14 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$12; + std = _tmp$13; + suffix = _tmp$14; + return [prefix, std, suffix]; + } + } + } else if (_1 === (48)) { + if (layout.length >= (i + 2 >> 0) && 49 <= layout.charCodeAt((i + 1 >> 0)) && layout.charCodeAt((i + 1 >> 0)) <= 54) { + _tmp$15 = $substring(layout, 0, i); + _tmp$16 = (x$1 = layout.charCodeAt((i + 1 >> 0)) - 49 << 24 >>> 24, ((x$1 < 0 || x$1 >= std0x.length) ? ($throwRuntimeError("index out of range"), undefined) : std0x[x$1])); + _tmp$17 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$15; + std = _tmp$16; + suffix = _tmp$17; + return [prefix, std, suffix]; + } + } else if (_1 === (49)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 53)) { + _tmp$18 = $substring(layout, 0, i); + _tmp$19 = 522; + _tmp$20 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$18; + std = _tmp$19; + suffix = _tmp$20; + return [prefix, std, suffix]; + } + _tmp$21 = $substring(layout, 0, i); + _tmp$22 = 259; + _tmp$23 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$21; + std = _tmp$22; + suffix = _tmp$23; + return [prefix, std, suffix]; + } else if (_1 === (50)) { + if (layout.length >= (i + 4 >> 0) && $substring(layout, i, (i + 4 >> 0)) === "2006") { + _tmp$24 = $substring(layout, 0, i); + _tmp$25 = 273; + _tmp$26 = $substring(layout, (i + 4 >> 0)); + prefix = _tmp$24; + std = _tmp$25; + suffix = _tmp$26; + return [prefix, std, suffix]; + } + _tmp$27 = $substring(layout, 0, i); + _tmp$28 = 263; + _tmp$29 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$27; + std = _tmp$28; + suffix = _tmp$29; + return [prefix, std, suffix]; + } else if (_1 === (95)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 50)) { + if (layout.length >= (i + 5 >> 0) && $substring(layout, (i + 1 >> 0), (i + 5 >> 0)) === "2006") { + _tmp$30 = $substring(layout, 0, (i + 1 >> 0)); + _tmp$31 = 273; + _tmp$32 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$30; + std = _tmp$31; + suffix = _tmp$32; + return [prefix, std, suffix]; + } + _tmp$33 = $substring(layout, 0, i); + _tmp$34 = 264; + _tmp$35 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$33; + std = _tmp$34; + suffix = _tmp$35; + return [prefix, std, suffix]; + } + } else if (_1 === (51)) { + _tmp$36 = $substring(layout, 0, i); + _tmp$37 = 523; + _tmp$38 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$36; + std = _tmp$37; + suffix = _tmp$38; + return [prefix, std, suffix]; + } else if (_1 === (52)) { + _tmp$39 = $substring(layout, 0, i); + _tmp$40 = 525; + _tmp$41 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$39; + std = _tmp$40; + suffix = _tmp$41; + return [prefix, std, suffix]; + } else if (_1 === (53)) { + _tmp$42 = $substring(layout, 0, i); + _tmp$43 = 527; + _tmp$44 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$42; + std = _tmp$43; + suffix = _tmp$44; + return [prefix, std, suffix]; + } else if (_1 === (80)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 77)) { + _tmp$45 = $substring(layout, 0, i); + _tmp$46 = 531; + _tmp$47 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$45; + std = _tmp$46; + suffix = _tmp$47; + return [prefix, std, suffix]; + } + } else if (_1 === (112)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 109)) { + _tmp$48 = $substring(layout, 0, i); + _tmp$49 = 532; + _tmp$50 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$48; + std = _tmp$49; + suffix = _tmp$50; + return [prefix, std, suffix]; + } + } else if (_1 === (45)) { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "-070000") { + _tmp$51 = $substring(layout, 0, i); + _tmp$52 = 28; + _tmp$53 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp$51; + std = _tmp$52; + suffix = _tmp$53; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "-07:00:00") { + _tmp$54 = $substring(layout, 0, i); + _tmp$55 = 31; + _tmp$56 = $substring(layout, (i + 9 >> 0)); + prefix = _tmp$54; + std = _tmp$55; + suffix = _tmp$56; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "-0700") { + _tmp$57 = $substring(layout, 0, i); + _tmp$58 = 27; + _tmp$59 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$57; + std = _tmp$58; + suffix = _tmp$59; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "-07:00") { + _tmp$60 = $substring(layout, 0, i); + _tmp$61 = 30; + _tmp$62 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$60; + std = _tmp$61; + suffix = _tmp$62; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "-07") { + _tmp$63 = $substring(layout, 0, i); + _tmp$64 = 29; + _tmp$65 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$63; + std = _tmp$64; + suffix = _tmp$65; + return [prefix, std, suffix]; + } + } else if (_1 === (90)) { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "Z070000") { + _tmp$66 = $substring(layout, 0, i); + _tmp$67 = 23; + _tmp$68 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp$66; + std = _tmp$67; + suffix = _tmp$68; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "Z07:00:00") { + _tmp$69 = $substring(layout, 0, i); + _tmp$70 = 26; + _tmp$71 = $substring(layout, (i + 9 >> 0)); + prefix = _tmp$69; + std = _tmp$70; + suffix = _tmp$71; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "Z0700") { + _tmp$72 = $substring(layout, 0, i); + _tmp$73 = 22; + _tmp$74 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$72; + std = _tmp$73; + suffix = _tmp$74; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Z07:00") { + _tmp$75 = $substring(layout, 0, i); + _tmp$76 = 25; + _tmp$77 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$75; + std = _tmp$76; + suffix = _tmp$77; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Z07") { + _tmp$78 = $substring(layout, 0, i); + _tmp$79 = 24; + _tmp$80 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$78; + std = _tmp$79; + suffix = _tmp$80; + return [prefix, std, suffix]; + } + } else if (_1 === (46)) { + if ((i + 1 >> 0) < layout.length && ((layout.charCodeAt((i + 1 >> 0)) === 48) || (layout.charCodeAt((i + 1 >> 0)) === 57))) { + ch = layout.charCodeAt((i + 1 >> 0)); + j = i + 1 >> 0; + while (true) { + if (!(j < layout.length && (layout.charCodeAt(j) === ch))) { break; } + j = j + (1) >> 0; + } + if (!isDigit(layout, j)) { + std$1 = 32; + if (layout.charCodeAt((i + 1 >> 0)) === 57) { + std$1 = 33; + } + std$1 = std$1 | ((((j - ((i + 1 >> 0)) >> 0)) << 16 >> 0)); + _tmp$81 = $substring(layout, 0, i); + _tmp$82 = std$1; + _tmp$83 = $substring(layout, j); + prefix = _tmp$81; + std = _tmp$82; + suffix = _tmp$83; + return [prefix, std, suffix]; + } + } + } + i = i + (1) >> 0; + } + _tmp$84 = layout; + _tmp$85 = 0; + _tmp$86 = ""; + prefix = _tmp$84; + std = _tmp$85; + suffix = _tmp$86; + return [prefix, std, suffix]; + }; + match = function(s1, s2) { + var c1, c2, i, s1, s2; + i = 0; + while (true) { + if (!(i < s1.length)) { break; } + c1 = s1.charCodeAt(i); + c2 = s2.charCodeAt(i); + if (!((c1 === c2))) { + c1 = (c1 | (32)) >>> 0; + c2 = (c2 | (32)) >>> 0; + if (!((c1 === c2)) || c1 < 97 || c1 > 122) { + return false; + } + } + i = i + (1) >> 0; + } + return true; + }; + lookup = function(tab, val) { + var _i, _ref, i, tab, v, val; + _ref = tab; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (val.length >= v.length && match($substring(val, 0, v.length), v)) { + return [i, $substring(val, v.length), $ifaceNil]; + } + _i++; + } + return [-1, val, errBad]; + }; + appendInt = function(b, x$1, width) { + var _q, b, buf, i, q, u, w, width, x$1; + u = ((x$1 >>> 0)); + if (x$1 < 0) { + b = $append(b, 45); + u = ((-x$1 >>> 0)); + } + buf = arrayType.zero(); + i = 20; + while (true) { + if (!(u >= 10)) { break; } + i = i - (1) >> 0; + q = (_q = u / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((48 + u >>> 0) - (q * 10 >>> 0) >>> 0) << 24 >>> 24))); + u = q; + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((48 + u >>> 0) << 24 >>> 24))); + w = 20 - i >> 0; + while (true) { + if (!(w < width)) { break; } + b = $append(b, 48); + w = w + (1) >> 0; + } + return $appendSlice(b, $subslice(new sliceType$3(buf), i)); + }; + atoi = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, neg, q, rem, s, x$1; + x$1 = 0; + err = $ifaceNil; + neg = false; + if (!(s === "") && ((s.charCodeAt(0) === 45) || (s.charCodeAt(0) === 43))) { + neg = s.charCodeAt(0) === 45; + s = $substring(s, 1); + } + _tuple = leadingInt(s); + q = _tuple[0]; + rem = _tuple[1]; + err = _tuple[2]; + x$1 = (((q.$low + ((q.$high >> 31) * 4294967296)) >> 0)); + if (!($interfaceIsEqual(err, $ifaceNil)) || !(rem === "")) { + _tmp = 0; + _tmp$1 = atoiError; + x$1 = _tmp; + err = _tmp$1; + return [x$1, err]; + } + if (neg) { + x$1 = -x$1; + } + _tmp$2 = x$1; + _tmp$3 = $ifaceNil; + x$1 = _tmp$2; + err = _tmp$3; + return [x$1, err]; + }; + formatNano = function(b, nanosec, n, trim) { + var _q, _r, b, buf, n, nanosec, start, trim, u, x$1; + u = nanosec; + buf = arrayType$1.zero(); + start = 9; + while (true) { + if (!(start > 0)) { break; } + start = start - (1) >> 0; + ((start < 0 || start >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[start] = ((((_r = u % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); + u = (_q = u / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + } + if (n > 9) { + n = 9; + } + if (trim) { + while (true) { + if (!(n > 0 && ((x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x$1])) === 48))) { break; } + n = n - (1) >> 0; + } + if (n === 0) { + return b; + } + } + b = $append(b, 46); + return $appendSlice(b, $subslice(new sliceType$3(buf), 0, n)); + }; + Time.ptr.prototype.String = function() { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, buf, m0, m1, m2, s, sign, t, wid, x$1, x$2, x$3, x$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; buf = $f.buf; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; s = $f.s; sign = $f.sign; t = $f.t; wid = $f.wid; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Format("2006-01-02 15:04:05.999999999 -0700 MST"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + m2 = ((x$3 = t.ext, new $Uint64(x$3.$high, x$3.$low))); + sign = 43; + if ((x$4 = t.ext, (x$4.$high < 0 || (x$4.$high === 0 && x$4.$low < 0)))) { + sign = 45; + m2 = new $Uint64(-m2.$high, -m2.$low); + } + _tmp = $div64(m2, new $Uint64(0, 1000000000), false); + _tmp$1 = $div64(m2, new $Uint64(0, 1000000000), true); + m1 = _tmp; + m2 = _tmp$1; + _tmp$2 = $div64(m1, new $Uint64(0, 1000000000), false); + _tmp$3 = $div64(m1, new $Uint64(0, 1000000000), true); + m0 = _tmp$2; + m1 = _tmp$3; + buf = sliceType$3.nil; + buf = $appendSlice(buf, " m="); + buf = $append(buf, sign); + wid = 0; + if (!((m0.$high === 0 && m0.$low === 0))) { + buf = appendInt(buf, ((m0.$low >> 0)), 0); + wid = 9; + } + buf = appendInt(buf, ((m1.$low >> 0)), wid); + buf = $append(buf, 46); + buf = appendInt(buf, ((m2.$low >> 0)), 9); + s = s + (($bytesToString(buf))); + } + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.String }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.buf = buf; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.s = s; $f.sign = sign; $f.t = t; $f.wid = wid; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.String = function() { return this.$val.String(); }; + Time.ptr.prototype.Format = function(layout) { + var _r, b, buf, layout, max, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; buf = $f.buf; layout = $f.layout; max = $f.max; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + b = sliceType$3.nil; + max = layout.length + 10 >> 0; + if (max < 64) { + buf = arrayType$2.zero(); + b = $subslice(new sliceType$3(buf), 0, 0); + } else { + b = $makeSlice(sliceType$3, 0, max); + } + _r = $clone(t, Time).AppendFormat(b, layout); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + $s = -1; return ($bytesToString(b)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Format }; } $f._r = _r; $f.b = b; $f.buf = buf; $f.layout = layout; $f.max = max; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Format = function(layout) { return this.$val.Format(layout); }; + Time.ptr.prototype.AppendFormat = function(b, layout) { + var _1, _q, _q$1, _q$2, _q$3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, _tuple$2, _tuple$3, abs, absoffset, b, day, hour, hr, hr$1, layout, m, min, month, name, offset, prefix, s, sec, std, suffix, t, y, year, zone$1, zone$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; abs = $f.abs; absoffset = $f.absoffset; b = $f.b; day = $f.day; hour = $f.hour; hr = $f.hr; hr$1 = $f.hr$1; layout = $f.layout; m = $f.m; min = $f.min; month = $f.month; name = $f.name; offset = $f.offset; prefix = $f.prefix; s = $f.s; sec = $f.sec; std = $f.std; suffix = $f.suffix; t = $f.t; y = $f.y; year = $f.year; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).locabs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + name = _tuple[0]; + offset = _tuple[1]; + abs = _tuple[2]; + year = -1; + month = 0; + day = 0; + hour = -1; + min = 0; + sec = 0; + while (true) { + if (!(!(layout === ""))) { break; } + _tuple$1 = nextStdChunk(layout); + prefix = _tuple$1[0]; + std = _tuple$1[1]; + suffix = _tuple$1[2]; + if (!(prefix === "")) { + b = $appendSlice(b, prefix); + } + if (std === 0) { + break; + } + layout = suffix; + if (year < 0 && !(((std & 256) === 0))) { + _tuple$2 = absDate(abs, true); + year = _tuple$2[0]; + month = _tuple$2[1]; + day = _tuple$2[2]; + } + if (hour < 0 && !(((std & 512) === 0))) { + _tuple$3 = absClock(abs); + hour = _tuple$3[0]; + min = _tuple$3[1]; + sec = _tuple$3[2]; + } + switch (0) { default: + _1 = std & 65535; + if (_1 === (274)) { + y = year; + if (y < 0) { + y = -y; + } + b = appendInt(b, (_r$1 = y % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")), 2); + } else if (_1 === (273)) { + b = appendInt(b, year, 4); + } else if (_1 === (258)) { + b = $appendSlice(b, $substring(new Month(month).String(), 0, 3)); + } else if (_1 === (257)) { + m = new Month(month).String(); + b = $appendSlice(b, m); + } else if (_1 === (259)) { + b = appendInt(b, ((month >> 0)), 0); + } else if (_1 === (260)) { + b = appendInt(b, ((month >> 0)), 2); + } else if (_1 === (262)) { + b = $appendSlice(b, $substring(new Weekday(absWeekday(abs)).String(), 0, 3)); + } else if (_1 === (261)) { + s = new Weekday(absWeekday(abs)).String(); + b = $appendSlice(b, s); + } else if (_1 === (263)) { + b = appendInt(b, day, 0); + } else if (_1 === (264)) { + if (day < 10) { + b = $append(b, 32); + } + b = appendInt(b, day, 0); + } else if (_1 === (265)) { + b = appendInt(b, day, 2); + } else if (_1 === (522)) { + b = appendInt(b, hour, 2); + } else if (_1 === (523)) { + hr = (_r$2 = hour % 12, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")); + if (hr === 0) { + hr = 12; + } + b = appendInt(b, hr, 0); + } else if (_1 === (524)) { + hr$1 = (_r$3 = hour % 12, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (hr$1 === 0) { + hr$1 = 12; + } + b = appendInt(b, hr$1, 2); + } else if (_1 === (525)) { + b = appendInt(b, min, 0); + } else if (_1 === (526)) { + b = appendInt(b, min, 2); + } else if (_1 === (527)) { + b = appendInt(b, sec, 0); + } else if (_1 === (528)) { + b = appendInt(b, sec, 2); + } else if (_1 === (531)) { + if (hour >= 12) { + b = $appendSlice(b, "PM"); + } else { + b = $appendSlice(b, "AM"); + } + } else if (_1 === (532)) { + if (hour >= 12) { + b = $appendSlice(b, "pm"); + } else { + b = $appendSlice(b, "am"); + } + } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (30)) || (_1 === (28)) || (_1 === (29)) || (_1 === (31))) { + if ((offset === 0) && ((std === 22) || (std === 25) || (std === 23) || (std === 24) || (std === 26))) { + b = $append(b, 90); + break; + } + zone$1 = (_q = offset / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + absoffset = offset; + if (zone$1 < 0) { + b = $append(b, 45); + zone$1 = -zone$1; + absoffset = -absoffset; + } else { + b = $append(b, 43); + } + b = appendInt(b, (_q$1 = zone$1 / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 2); + if ((std === 25) || (std === 30) || (std === 26) || (std === 31)) { + b = $append(b, 58); + } + if (!((std === 29)) && !((std === 24))) { + b = appendInt(b, (_r$4 = zone$1 % 60, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")), 2); + } + if ((std === 23) || (std === 28) || (std === 31) || (std === 26)) { + if ((std === 31) || (std === 26)) { + b = $append(b, 58); + } + b = appendInt(b, (_r$5 = absoffset % 60, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")), 2); + } + } else if (_1 === (21)) { + if (!(name === "")) { + b = $appendSlice(b, name); + break; + } + zone$2 = (_q$2 = offset / 60, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")); + if (zone$2 < 0) { + b = $append(b, 45); + zone$2 = -zone$2; + } else { + b = $append(b, 43); + } + b = appendInt(b, (_q$3 = zone$2 / 60, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")), 2); + b = appendInt(b, (_r$6 = zone$2 % 60, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")), 2); + } else if ((_1 === (32)) || (_1 === (33))) { + b = formatNano(b, (($clone(t, Time).Nanosecond() >>> 0)), std >> 16 >> 0, (std & 65535) === 33); + } + } + } + $s = -1; return b; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AppendFormat }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.abs = abs; $f.absoffset = absoffset; $f.b = b; $f.day = day; $f.hour = hour; $f.hr = hr; $f.hr$1 = hr$1; $f.layout = layout; $f.m = m; $f.min = min; $f.month = month; $f.name = name; $f.offset = offset; $f.prefix = prefix; $f.s = s; $f.sec = sec; $f.std = std; $f.suffix = suffix; $f.t = t; $f.y = y; $f.year = year; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.AppendFormat = function(b, layout) { return this.$val.AppendFormat(b, layout); }; + quote = function(s) { + var s; + return "\"" + s + "\""; + }; + ParseError.ptr.prototype.Error = function() { + var e; + e = this; + if (e.Message === "") { + return "parsing time " + quote(e.Value) + " as " + quote(e.Layout) + ": cannot parse " + quote(e.ValueElem) + " as " + quote(e.LayoutElem); + } + return "parsing time " + quote(e.Value) + e.Message; + }; + ParseError.prototype.Error = function() { return this.$val.Error(); }; + isDigit = function(s, i) { + var c, i, s; + if (s.length <= i) { + return false; + } + c = s.charCodeAt(i); + return 48 <= c && c <= 57; + }; + getnum = function(s, fixed) { + var fixed, s; + if (!isDigit(s, 0)) { + return [0, s, errBad]; + } + if (!isDigit(s, 1)) { + if (fixed) { + return [0, s, errBad]; + } + return [(((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), $substring(s, 1), $ifaceNil]; + } + return [($imul((((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), 10)) + (((s.charCodeAt(1) - 48 << 24 >>> 24) >> 0)) >> 0, $substring(s, 2), $ifaceNil]; + }; + cutspace = function(s) { + var s; + while (true) { + if (!(s.length > 0 && (s.charCodeAt(0) === 32))) { break; } + s = $substring(s, 1); + } + return s; + }; + skip = function(value, prefix) { + var prefix, value; + while (true) { + if (!(prefix.length > 0)) { break; } + if (prefix.charCodeAt(0) === 32) { + if (value.length > 0 && !((value.charCodeAt(0) === 32))) { + return [value, errBad]; + } + prefix = cutspace(prefix); + value = cutspace(value); + continue; + } + if ((value.length === 0) || !((value.charCodeAt(0) === prefix.charCodeAt(0)))) { + return [value, errBad]; + } + prefix = $substring(prefix, 1); + value = $substring(value, 1); + } + return [value, $ifaceNil]; + }; + Parse = function(layout, value) { + var _r, layout, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; layout = $f.layout; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = parse(layout, value, $pkg.UTC, $pkg.Local); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f._r = _r; $f.layout = layout; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Parse = Parse; + parse = function(layout, value, defaultLocation, local) { + var _1, _2, _3, _4, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$16, _tuple$17, _tuple$18, _tuple$19, _tuple$2, _tuple$20, _tuple$21, _tuple$22, _tuple$23, _tuple$24, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, alayout, amSet, avalue, day, defaultLocation, err, hour, hour$1, hr, i, layout, local, min, min$1, mm, month, n, n$1, name, ndigit, nsec, offset, offset$1, ok, ok$1, p, pmSet, prefix, rangeErrString, sec, seconds, sign, ss, std, stdstr, suffix, t, t$1, value, x$1, x$2, year, z, zoneName, zoneOffset, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$29 = $f._tmp$29; _tmp$3 = $f._tmp$3; _tmp$30 = $f._tmp$30; _tmp$31 = $f._tmp$31; _tmp$32 = $f._tmp$32; _tmp$33 = $f._tmp$33; _tmp$34 = $f._tmp$34; _tmp$35 = $f._tmp$35; _tmp$36 = $f._tmp$36; _tmp$37 = $f._tmp$37; _tmp$38 = $f._tmp$38; _tmp$39 = $f._tmp$39; _tmp$4 = $f._tmp$4; _tmp$40 = $f._tmp$40; _tmp$41 = $f._tmp$41; _tmp$42 = $f._tmp$42; _tmp$43 = $f._tmp$43; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$16 = $f._tuple$16; _tuple$17 = $f._tuple$17; _tuple$18 = $f._tuple$18; _tuple$19 = $f._tuple$19; _tuple$2 = $f._tuple$2; _tuple$20 = $f._tuple$20; _tuple$21 = $f._tuple$21; _tuple$22 = $f._tuple$22; _tuple$23 = $f._tuple$23; _tuple$24 = $f._tuple$24; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; alayout = $f.alayout; amSet = $f.amSet; avalue = $f.avalue; day = $f.day; defaultLocation = $f.defaultLocation; err = $f.err; hour = $f.hour; hour$1 = $f.hour$1; hr = $f.hr; i = $f.i; layout = $f.layout; local = $f.local; min = $f.min; min$1 = $f.min$1; mm = $f.mm; month = $f.month; n = $f.n; n$1 = $f.n$1; name = $f.name; ndigit = $f.ndigit; nsec = $f.nsec; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; pmSet = $f.pmSet; prefix = $f.prefix; rangeErrString = $f.rangeErrString; sec = $f.sec; seconds = $f.seconds; sign = $f.sign; ss = $f.ss; std = $f.std; stdstr = $f.stdstr; suffix = $f.suffix; t = $f.t; t$1 = $f.t$1; value = $f.value; x$1 = $f.x$1; x$2 = $f.x$2; year = $f.year; z = $f.z; zoneName = $f.zoneName; zoneOffset = $f.zoneOffset; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tmp = layout; + _tmp$1 = value; + alayout = _tmp; + avalue = _tmp$1; + rangeErrString = ""; + amSet = false; + pmSet = false; + year = 0; + month = 1; + day = 1; + hour = 0; + min = 0; + sec = 0; + nsec = 0; + z = ptrType$2.nil; + zoneOffset = -1; + zoneName = ""; + while (true) { + err = $ifaceNil; + _tuple = nextStdChunk(layout); + prefix = _tuple[0]; + std = _tuple[1]; + suffix = _tuple[2]; + stdstr = $substring(layout, prefix.length, (layout.length - suffix.length >> 0)); + _tuple$1 = skip(value, prefix); + value = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, prefix, value, "")]; + } + if (std === 0) { + if (!((value.length === 0))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": extra text: " + value)]; + } + break; + } + layout = suffix; + p = ""; + switch (0) { default: + _1 = std & 65535; + if (_1 === (274)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$2 = $substring(value, 0, 2); + _tmp$3 = $substring(value, 2); + p = _tmp$2; + value = _tmp$3; + _tuple$2 = atoi(p); + year = _tuple$2[0]; + err = _tuple$2[1]; + if (year >= 69) { + year = year + (1900) >> 0; + } else { + year = year + (2000) >> 0; + } + } else if (_1 === (273)) { + if (value.length < 4 || !isDigit(value, 0)) { + err = errBad; + break; + } + _tmp$4 = $substring(value, 0, 4); + _tmp$5 = $substring(value, 4); + p = _tmp$4; + value = _tmp$5; + _tuple$3 = atoi(p); + year = _tuple$3[0]; + err = _tuple$3[1]; + } else if (_1 === (258)) { + _tuple$4 = lookup(shortMonthNames, value); + month = _tuple$4[0]; + value = _tuple$4[1]; + err = _tuple$4[2]; + month = month + (1) >> 0; + } else if (_1 === (257)) { + _tuple$5 = lookup(longMonthNames, value); + month = _tuple$5[0]; + value = _tuple$5[1]; + err = _tuple$5[2]; + month = month + (1) >> 0; + } else if ((_1 === (259)) || (_1 === (260))) { + _tuple$6 = getnum(value, std === 260); + month = _tuple$6[0]; + value = _tuple$6[1]; + err = _tuple$6[2]; + if (month <= 0 || 12 < month) { + rangeErrString = "month"; + } + } else if (_1 === (262)) { + _tuple$7 = lookup(shortDayNames, value); + value = _tuple$7[1]; + err = _tuple$7[2]; + } else if (_1 === (261)) { + _tuple$8 = lookup(longDayNames, value); + value = _tuple$8[1]; + err = _tuple$8[2]; + } else if ((_1 === (263)) || (_1 === (264)) || (_1 === (265))) { + if ((std === 264) && value.length > 0 && (value.charCodeAt(0) === 32)) { + value = $substring(value, 1); + } + _tuple$9 = getnum(value, std === 265); + day = _tuple$9[0]; + value = _tuple$9[1]; + err = _tuple$9[2]; + if (day < 0) { + rangeErrString = "day"; + } + } else if (_1 === (522)) { + _tuple$10 = getnum(value, false); + hour = _tuple$10[0]; + value = _tuple$10[1]; + err = _tuple$10[2]; + if (hour < 0 || 24 <= hour) { + rangeErrString = "hour"; + } + } else if ((_1 === (523)) || (_1 === (524))) { + _tuple$11 = getnum(value, std === 524); + hour = _tuple$11[0]; + value = _tuple$11[1]; + err = _tuple$11[2]; + if (hour < 0 || 12 < hour) { + rangeErrString = "hour"; + } + } else if ((_1 === (525)) || (_1 === (526))) { + _tuple$12 = getnum(value, std === 526); + min = _tuple$12[0]; + value = _tuple$12[1]; + err = _tuple$12[2]; + if (min < 0 || 60 <= min) { + rangeErrString = "minute"; + } + } else if ((_1 === (527)) || (_1 === (528))) { + _tuple$13 = getnum(value, std === 528); + sec = _tuple$13[0]; + value = _tuple$13[1]; + err = _tuple$13[2]; + if (sec < 0 || 60 <= sec) { + rangeErrString = "second"; + break; + } + if (value.length >= 2 && (value.charCodeAt(0) === 46) && isDigit(value, 1)) { + _tuple$14 = nextStdChunk(layout); + std = _tuple$14[1]; + std = std & (65535); + if ((std === 32) || (std === 33)) { + break; + } + n = 2; + while (true) { + if (!(n < value.length && isDigit(value, n))) { break; } + n = n + (1) >> 0; + } + _tuple$15 = parseNanoseconds(value, n); + nsec = _tuple$15[0]; + rangeErrString = _tuple$15[1]; + err = _tuple$15[2]; + value = $substring(value, n); + } + } else if (_1 === (531)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$6 = $substring(value, 0, 2); + _tmp$7 = $substring(value, 2); + p = _tmp$6; + value = _tmp$7; + _2 = p; + if (_2 === ("PM")) { + pmSet = true; + } else if (_2 === ("AM")) { + amSet = true; + } else { + err = errBad; + } + } else if (_1 === (532)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$8 = $substring(value, 0, 2); + _tmp$9 = $substring(value, 2); + p = _tmp$8; + value = _tmp$9; + _3 = p; + if (_3 === ("pm")) { + pmSet = true; + } else if (_3 === ("am")) { + amSet = true; + } else { + err = errBad; + } + } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (29)) || (_1 === (30)) || (_1 === (28)) || (_1 === (31))) { + if (((std === 22) || (std === 24) || (std === 25)) && value.length >= 1 && (value.charCodeAt(0) === 90)) { + value = $substring(value, 1); + z = $pkg.UTC; + break; + } + _tmp$10 = ""; + _tmp$11 = ""; + _tmp$12 = ""; + _tmp$13 = ""; + sign = _tmp$10; + hour$1 = _tmp$11; + min$1 = _tmp$12; + seconds = _tmp$13; + if ((std === 25) || (std === 30)) { + if (value.length < 6) { + err = errBad; + break; + } + if (!((value.charCodeAt(3) === 58))) { + err = errBad; + break; + } + _tmp$14 = $substring(value, 0, 1); + _tmp$15 = $substring(value, 1, 3); + _tmp$16 = $substring(value, 4, 6); + _tmp$17 = "00"; + _tmp$18 = $substring(value, 6); + sign = _tmp$14; + hour$1 = _tmp$15; + min$1 = _tmp$16; + seconds = _tmp$17; + value = _tmp$18; + } else if ((std === 29) || (std === 24)) { + if (value.length < 3) { + err = errBad; + break; + } + _tmp$19 = $substring(value, 0, 1); + _tmp$20 = $substring(value, 1, 3); + _tmp$21 = "00"; + _tmp$22 = "00"; + _tmp$23 = $substring(value, 3); + sign = _tmp$19; + hour$1 = _tmp$20; + min$1 = _tmp$21; + seconds = _tmp$22; + value = _tmp$23; + } else if ((std === 26) || (std === 31)) { + if (value.length < 9) { + err = errBad; + break; + } + if (!((value.charCodeAt(3) === 58)) || !((value.charCodeAt(6) === 58))) { + err = errBad; + break; + } + _tmp$24 = $substring(value, 0, 1); + _tmp$25 = $substring(value, 1, 3); + _tmp$26 = $substring(value, 4, 6); + _tmp$27 = $substring(value, 7, 9); + _tmp$28 = $substring(value, 9); + sign = _tmp$24; + hour$1 = _tmp$25; + min$1 = _tmp$26; + seconds = _tmp$27; + value = _tmp$28; + } else if ((std === 23) || (std === 28)) { + if (value.length < 7) { + err = errBad; + break; + } + _tmp$29 = $substring(value, 0, 1); + _tmp$30 = $substring(value, 1, 3); + _tmp$31 = $substring(value, 3, 5); + _tmp$32 = $substring(value, 5, 7); + _tmp$33 = $substring(value, 7); + sign = _tmp$29; + hour$1 = _tmp$30; + min$1 = _tmp$31; + seconds = _tmp$32; + value = _tmp$33; + } else { + if (value.length < 5) { + err = errBad; + break; + } + _tmp$34 = $substring(value, 0, 1); + _tmp$35 = $substring(value, 1, 3); + _tmp$36 = $substring(value, 3, 5); + _tmp$37 = "00"; + _tmp$38 = $substring(value, 5); + sign = _tmp$34; + hour$1 = _tmp$35; + min$1 = _tmp$36; + seconds = _tmp$37; + value = _tmp$38; + } + _tmp$39 = 0; + _tmp$40 = 0; + _tmp$41 = 0; + hr = _tmp$39; + mm = _tmp$40; + ss = _tmp$41; + _tuple$16 = atoi(hour$1); + hr = _tuple$16[0]; + err = _tuple$16[1]; + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$17 = atoi(min$1); + mm = _tuple$17[0]; + err = _tuple$17[1]; + } + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$18 = atoi(seconds); + ss = _tuple$18[0]; + err = _tuple$18[1]; + } + zoneOffset = ($imul(((($imul(hr, 60)) + mm >> 0)), 60)) + ss >> 0; + _4 = sign.charCodeAt(0); + if (_4 === (43)) { + } else if (_4 === (45)) { + zoneOffset = -zoneOffset; + } else { + err = errBad; + } + } else if (_1 === (21)) { + if (value.length >= 3 && $substring(value, 0, 3) === "UTC") { + z = $pkg.UTC; + value = $substring(value, 3); + break; + } + _tuple$19 = parseTimeZone(value); + n$1 = _tuple$19[0]; + ok = _tuple$19[1]; + if (!ok) { + err = errBad; + break; + } + _tmp$42 = $substring(value, 0, n$1); + _tmp$43 = $substring(value, n$1); + zoneName = _tmp$42; + value = _tmp$43; + } else if (_1 === (32)) { + ndigit = 1 + ((std >> 16 >> 0)) >> 0; + if (value.length < ndigit) { + err = errBad; + break; + } + _tuple$20 = parseNanoseconds(value, ndigit); + nsec = _tuple$20[0]; + rangeErrString = _tuple$20[1]; + err = _tuple$20[2]; + value = $substring(value, ndigit); + } else if (_1 === (33)) { + if (value.length < 2 || !((value.charCodeAt(0) === 46)) || value.charCodeAt(1) < 48 || 57 < value.charCodeAt(1)) { + break; + } + i = 0; + while (true) { + if (!(i < 9 && (i + 1 >> 0) < value.length && 48 <= value.charCodeAt((i + 1 >> 0)) && value.charCodeAt((i + 1 >> 0)) <= 57)) { break; } + i = i + (1) >> 0; + } + _tuple$21 = parseNanoseconds(value, 1 + i >> 0); + nsec = _tuple$21[0]; + rangeErrString = _tuple$21[1]; + err = _tuple$21[2]; + value = $substring(value, (1 + i >> 0)); + } + } + if (!(rangeErrString === "")) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range")]; + } + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, "")]; + } + } + if (pmSet && hour < 12) { + hour = hour + (12) >> 0; + } else if (amSet && (hour === 12)) { + hour = 0; + } + if (day < 1 || day > daysIn(((month >> 0)), year)) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": day out of range")]; + } + /* */ if (!(z === ptrType$2.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(z === ptrType$2.nil)) { */ case 1: + _r = Date(year, ((month >> 0)), day, hour, min, sec, nsec, z); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return [_r, $ifaceNil]; + /* } */ case 2: + /* */ if (!((zoneOffset === -1))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!((zoneOffset === -1))) { */ case 4: + _r$1 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + t = $clone(_r$1, Time); + t.addSec((x$1 = (new $Int64(0, zoneOffset)), new $Int64(-x$1.$high, -x$1.$low))); + _r$2 = local.lookup(t.unixSec()); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$22 = _r$2; + name = _tuple$22[0]; + offset = _tuple$22[1]; + if ((offset === zoneOffset) && (zoneName === "" || name === zoneName)) { + t.setLoc(local); + $s = -1; return [t, $ifaceNil]; + } + t.setLoc(FixedZone(zoneName, zoneOffset)); + $s = -1; return [t, $ifaceNil]; + /* } */ case 5: + /* */ if (!(zoneName === "")) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!(zoneName === "")) { */ case 8: + _r$3 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + t$1 = $clone(_r$3, Time); + _r$4 = local.lookupName(zoneName, t$1.unixSec()); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$23 = _r$4; + offset$1 = _tuple$23[0]; + ok$1 = _tuple$23[1]; + if (ok$1) { + t$1.addSec((x$2 = (new $Int64(0, offset$1)), new $Int64(-x$2.$high, -x$2.$low))); + t$1.setLoc(local); + $s = -1; return [t$1, $ifaceNil]; + } + if (zoneName.length > 3 && $substring(zoneName, 0, 3) === "GMT") { + _tuple$24 = atoi($substring(zoneName, 3)); + offset$1 = _tuple$24[0]; + offset$1 = $imul(offset$1, (3600)); + } + t$1.setLoc(FixedZone(zoneName, offset$1)); + $s = -1; return [t$1, $ifaceNil]; + /* } */ case 9: + _r$5 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, defaultLocation); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return [_r$5, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parse }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$29 = _tmp$29; $f._tmp$3 = _tmp$3; $f._tmp$30 = _tmp$30; $f._tmp$31 = _tmp$31; $f._tmp$32 = _tmp$32; $f._tmp$33 = _tmp$33; $f._tmp$34 = _tmp$34; $f._tmp$35 = _tmp$35; $f._tmp$36 = _tmp$36; $f._tmp$37 = _tmp$37; $f._tmp$38 = _tmp$38; $f._tmp$39 = _tmp$39; $f._tmp$4 = _tmp$4; $f._tmp$40 = _tmp$40; $f._tmp$41 = _tmp$41; $f._tmp$42 = _tmp$42; $f._tmp$43 = _tmp$43; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$16 = _tuple$16; $f._tuple$17 = _tuple$17; $f._tuple$18 = _tuple$18; $f._tuple$19 = _tuple$19; $f._tuple$2 = _tuple$2; $f._tuple$20 = _tuple$20; $f._tuple$21 = _tuple$21; $f._tuple$22 = _tuple$22; $f._tuple$23 = _tuple$23; $f._tuple$24 = _tuple$24; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.alayout = alayout; $f.amSet = amSet; $f.avalue = avalue; $f.day = day; $f.defaultLocation = defaultLocation; $f.err = err; $f.hour = hour; $f.hour$1 = hour$1; $f.hr = hr; $f.i = i; $f.layout = layout; $f.local = local; $f.min = min; $f.min$1 = min$1; $f.mm = mm; $f.month = month; $f.n = n; $f.n$1 = n$1; $f.name = name; $f.ndigit = ndigit; $f.nsec = nsec; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.pmSet = pmSet; $f.prefix = prefix; $f.rangeErrString = rangeErrString; $f.sec = sec; $f.seconds = seconds; $f.sign = sign; $f.ss = ss; $f.std = std; $f.stdstr = stdstr; $f.suffix = suffix; $f.t = t; $f.t$1 = t$1; $f.value = value; $f.x$1 = x$1; $f.x$2 = x$2; $f.year = year; $f.z = z; $f.zoneName = zoneName; $f.zoneOffset = zoneOffset; $f.$s = $s; $f.$r = $r; return $f; + }; + parseTimeZone = function(value) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c, length, nUpper, ok, ok$1, value; + length = 0; + ok = false; + if (value.length < 3) { + _tmp = 0; + _tmp$1 = false; + length = _tmp; + ok = _tmp$1; + return [length, ok]; + } + if (value.length >= 4 && ($substring(value, 0, 4) === "ChST" || $substring(value, 0, 4) === "MeST")) { + _tmp$2 = 4; + _tmp$3 = true; + length = _tmp$2; + ok = _tmp$3; + return [length, ok]; + } + if ($substring(value, 0, 3) === "GMT") { + length = parseGMT(value); + _tmp$4 = length; + _tmp$5 = true; + length = _tmp$4; + ok = _tmp$5; + return [length, ok]; + } + if ((value.charCodeAt(0) === 43) || (value.charCodeAt(0) === 45)) { + length = parseSignedOffset(value); + ok$1 = length > 0; + _tmp$6 = length; + _tmp$7 = ok$1; + length = _tmp$6; + ok = _tmp$7; + return [length, ok]; + } + nUpper = 0; + nUpper = 0; + while (true) { + if (!(nUpper < 6)) { break; } + if (nUpper >= value.length) { + break; + } + c = value.charCodeAt(nUpper); + if (c < 65 || 90 < c) { + break; + } + nUpper = nUpper + (1) >> 0; + } + _1 = nUpper; + if ((_1 === (0)) || (_1 === (1)) || (_1 === (2)) || (_1 === (6))) { + _tmp$8 = 0; + _tmp$9 = false; + length = _tmp$8; + ok = _tmp$9; + return [length, ok]; + } else if (_1 === (5)) { + if (value.charCodeAt(4) === 84) { + _tmp$10 = 5; + _tmp$11 = true; + length = _tmp$10; + ok = _tmp$11; + return [length, ok]; + } + } else if (_1 === (4)) { + if ((value.charCodeAt(3) === 84) || $substring(value, 0, 4) === "WITA") { + _tmp$12 = 4; + _tmp$13 = true; + length = _tmp$12; + ok = _tmp$13; + return [length, ok]; + } + } else if (_1 === (3)) { + _tmp$14 = 3; + _tmp$15 = true; + length = _tmp$14; + ok = _tmp$15; + return [length, ok]; + } + _tmp$16 = 0; + _tmp$17 = false; + length = _tmp$16; + ok = _tmp$17; + return [length, ok]; + }; + parseGMT = function(value) { + var value; + value = $substring(value, 3); + if (value.length === 0) { + return 3; + } + return 3 + parseSignedOffset(value) >> 0; + }; + parseSignedOffset = function(value) { + var _tuple, err, rem, sign, value, x$1; + sign = value.charCodeAt(0); + if (!((sign === 45)) && !((sign === 43))) { + return 0; + } + _tuple = leadingInt($substring(value, 1)); + x$1 = _tuple[0]; + rem = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil)) || $substring(value, 1) === rem) { + return 0; + } + if (sign === 45) { + x$1 = new $Int64(-x$1.$high, -x$1.$low); + } + if ((x$1.$high < -1 || (x$1.$high === -1 && x$1.$low < 4294967273)) || (0 < x$1.$high || (0 === x$1.$high && 23 < x$1.$low))) { + return 0; + } + return value.length - rem.length >> 0; + }; + parseNanoseconds = function(value, nbytes) { + var _tuple, err, i, nbytes, ns, rangeErrString, scaleDigits, value; + ns = 0; + rangeErrString = ""; + err = $ifaceNil; + if (!((value.charCodeAt(0) === 46))) { + err = errBad; + return [ns, rangeErrString, err]; + } + _tuple = atoi($substring(value, 1, nbytes)); + ns = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [ns, rangeErrString, err]; + } + if (ns < 0 || 1000000000 <= ns) { + rangeErrString = "fractional second"; + return [ns, rangeErrString, err]; + } + scaleDigits = 10 - nbytes >> 0; + i = 0; + while (true) { + if (!(i < scaleDigits)) { break; } + ns = $imul(ns, (10)); + i = i + (1) >> 0; + } + return [ns, rangeErrString, err]; + }; + leadingInt = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, c, err, i, rem, s, x$1, x$2, x$3, x$4; + x$1 = new $Int64(0, 0); + rem = ""; + err = $ifaceNil; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + c = s.charCodeAt(i); + if (c < 48 || c > 57) { + break; + } + if ((x$1.$high > 214748364 || (x$1.$high === 214748364 && x$1.$low > 3435973836))) { + _tmp = new $Int64(0, 0); + _tmp$1 = ""; + _tmp$2 = errLeadingInt; + x$1 = _tmp; + rem = _tmp$1; + err = _tmp$2; + return [x$1, rem, err]; + } + x$1 = (x$2 = (x$3 = $mul64(x$1, new $Int64(0, 10)), x$4 = (new $Int64(0, c)), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), new $Int64(x$2.$high - 0, x$2.$low - 48)); + if ((x$1.$high < 0 || (x$1.$high === 0 && x$1.$low < 0))) { + _tmp$3 = new $Int64(0, 0); + _tmp$4 = ""; + _tmp$5 = errLeadingInt; + x$1 = _tmp$3; + rem = _tmp$4; + err = _tmp$5; + return [x$1, rem, err]; + } + i = i + (1) >> 0; + } + _tmp$6 = x$1; + _tmp$7 = $substring(s, i); + _tmp$8 = $ifaceNil; + x$1 = _tmp$6; + rem = _tmp$7; + err = _tmp$8; + return [x$1, rem, err]; + }; + Time.ptr.prototype.nsec = function() { + var t, x$1; + t = this; + return (((x$1 = t.wall, new $Uint64(x$1.$high & 0, (x$1.$low & 1073741823) >>> 0)).$low >> 0)); + }; + Time.prototype.nsec = function() { return this.$val.nsec(); }; + Time.ptr.prototype.sec = function() { + var t, x$1, x$2, x$3, x$4; + t = this; + if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + return (x$3 = ((x$4 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$4.$high, x$4.$low))), new $Int64(13 + x$3.$high, 3618733952 + x$3.$low)); + } + return t.ext; + }; + Time.prototype.sec = function() { return this.$val.sec(); }; + Time.ptr.prototype.unixSec = function() { + var t, x$1; + t = this; + return (x$1 = t.sec(), new $Int64(x$1.$high + -15, x$1.$low + 2288912640)); + }; + Time.prototype.unixSec = function() { return this.$val.unixSec(); }; + Time.ptr.prototype.addSec = function(d) { + var d, dsec, sec, t, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + sec = ((x$3 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$3.$high, x$3.$low))); + dsec = new $Int64(sec.$high + d.$high, sec.$low + d.$low); + if ((0 < dsec.$high || (0 === dsec.$high && 0 <= dsec.$low)) && (dsec.$high < 1 || (dsec.$high === 1 && dsec.$low <= 4294967295))) { + t.wall = (x$4 = (x$5 = (x$6 = t.wall, new $Uint64(x$6.$high & 0, (x$6.$low & 1073741823) >>> 0)), x$7 = $shiftLeft64((new $Uint64(dsec.$high, dsec.$low)), 30), new $Uint64(x$5.$high | x$7.$high, (x$5.$low | x$7.$low) >>> 0)), new $Uint64(x$4.$high | 2147483648, (x$4.$low | 0) >>> 0)); + return; + } + t.stripMono(); + } + t.ext = (x$8 = t.ext, x$9 = d, new $Int64(x$8.$high + x$9.$high, x$8.$low + x$9.$low)); + }; + Time.prototype.addSec = function(d) { return this.$val.addSec(d); }; + Time.ptr.prototype.setLoc = function(loc) { + var loc, t; + t = this; + if (loc === utcLoc) { + loc = ptrType$2.nil; + } + t.stripMono(); + t.loc = loc; + }; + Time.prototype.setLoc = function(loc) { return this.$val.setLoc(loc); }; + Time.ptr.prototype.stripMono = function() { + var t, x$1, x$2, x$3, x$4; + t = this; + if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + t.ext = t.sec(); + t.wall = (x$3 = t.wall, x$4 = new $Uint64(0, 1073741823), new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)); + } + }; + Time.prototype.stripMono = function() { return this.$val.stripMono(); }; + Time.ptr.prototype.After = function(u) { + var t, ts, u, us, x$1, x$2, x$3, x$4, x$5, x$6; + t = this; + if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + return (x$5 = t.ext, x$6 = u.ext, (x$5.$high > x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low))); + } + ts = t.sec(); + us = u.sec(); + return (ts.$high > us.$high || (ts.$high === us.$high && ts.$low > us.$low)) || (ts.$high === us.$high && ts.$low === us.$low) && t.nsec() > u.nsec(); + }; + Time.prototype.After = function(u) { return this.$val.After(u); }; + Time.ptr.prototype.Before = function(u) { + var t, u, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + return (x$5 = t.ext, x$6 = u.ext, (x$5.$high < x$6.$high || (x$5.$high === x$6.$high && x$5.$low < x$6.$low))); + } + return (x$7 = t.sec(), x$8 = u.sec(), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low < x$8.$low))) || (x$9 = t.sec(), x$10 = u.sec(), (x$9.$high === x$10.$high && x$9.$low === x$10.$low)) && t.nsec() < u.nsec(); + }; + Time.prototype.Before = function(u) { return this.$val.Before(u); }; + Time.ptr.prototype.Equal = function(u) { + var t, u, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; + t = this; + if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + return (x$5 = t.ext, x$6 = u.ext, (x$5.$high === x$6.$high && x$5.$low === x$6.$low)); + } + return (x$7 = t.sec(), x$8 = u.sec(), (x$7.$high === x$8.$high && x$7.$low === x$8.$low)) && (t.nsec() === u.nsec()); + }; + Time.prototype.Equal = function(u) { return this.$val.Equal(u); }; + Month.prototype.String = function() { + var buf, m, n, x$1; + m = this.$val; + if (1 <= m && m <= 12) { + return (x$1 = m - 1 >> 0, ((x$1 < 0 || x$1 >= months.length) ? ($throwRuntimeError("index out of range"), undefined) : months[x$1])); + } + buf = $makeSlice(sliceType$3, 20); + n = fmtInt(buf, (new $Uint64(0, m))); + return "%!Month(" + ($bytesToString($subslice(buf, n))) + ")"; + }; + $ptrType(Month).prototype.String = function() { return new Month(this.$get()).String(); }; + Weekday.prototype.String = function() { + var buf, d, n; + d = this.$val; + if (0 <= d && d <= 6) { + return ((d < 0 || d >= days.length) ? ($throwRuntimeError("index out of range"), undefined) : days[d]); + } + buf = $makeSlice(sliceType$3, 20); + n = fmtInt(buf, (new $Uint64(0, d))); + return "%!Weekday(" + ($bytesToString($subslice(buf, n))) + ")"; + }; + $ptrType(Weekday).prototype.String = function() { return new Weekday(this.$get()).String(); }; + Time.ptr.prototype.IsZero = function() { + var t, x$1; + t = this; + return (x$1 = t.sec(), (x$1.$high === 0 && x$1.$low === 0)) && (t.nsec() === 0); + }; + Time.prototype.IsZero = function() { return this.$val.IsZero(); }; + Time.ptr.prototype.abs = function() { + var _r, _r$1, _tuple, l, offset, sec, t, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; l = $f.l; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + l = t.loc; + /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: + _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + /* } */ case 2: + sec = t.unixSec(); + /* */ if (!(l === utcLoc)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(l === utcLoc)) { */ case 4: + /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 6: + sec = (x$3 = (new $Int64(0, l.cacheZone.offset)), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low)); + $s = 8; continue; + /* } else { */ case 7: + _r$1 = l.lookup(sec); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + offset = _tuple[1]; + sec = (x$4 = (new $Int64(0, offset)), new $Int64(sec.$high + x$4.$high, sec.$low + x$4.$low)); + /* } */ case 8: + /* } */ case 5: + $s = -1; return ((x$5 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$5.$high, x$5.$low))); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.abs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.l = l; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.abs = function() { return this.$val.abs(); }; + Time.ptr.prototype.locabs = function() { + var _r, _r$1, _tuple, abs, l, name, offset, sec, t, x$1, x$2, x$3, x$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; abs = $f.abs; l = $f.l; name = $f.name; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + abs = new $Uint64(0, 0); + t = this; + l = t.loc; + /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: + _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + /* } */ case 2: + sec = t.unixSec(); + /* */ if (!(l === utcLoc)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(l === utcLoc)) { */ case 4: + /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 7: + name = l.cacheZone.name; + offset = l.cacheZone.offset; + $s = 9; continue; + /* } else { */ case 8: + _r$1 = l.lookup(sec); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + name = _tuple[0]; + offset = _tuple[1]; + /* } */ case 9: + sec = (x$3 = (new $Int64(0, offset)), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low)); + $s = 6; continue; + /* } else { */ case 5: + name = "UTC"; + /* } */ case 6: + abs = ((x$4 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$4.$high, x$4.$low))); + $s = -1; return [name, offset, abs]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.locabs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.abs = abs; $f.l = l; $f.name = name; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.locabs = function() { return this.$val.locabs(); }; + Time.ptr.prototype.Date = function() { + var _r, _tuple, day, month, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; month = $f.month; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + month = 0; + day = 0; + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + $s = -1; return [year, month, day]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Date }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.month = month; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Date = function() { return this.$val.Date(); }; + Time.ptr.prototype.Year = function() { + var _r, _tuple, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + $s = -1; return year; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Year }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Year = function() { return this.$val.Year(); }; + Time.ptr.prototype.Month = function() { + var _r, _tuple, month, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; month = $f.month; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + month = _tuple[1]; + $s = -1; return month; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Month }; } $f._r = _r; $f._tuple = _tuple; $f.month = month; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Month = function() { return this.$val.Month(); }; + Time.ptr.prototype.Day = function() { + var _r, _tuple, day, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + day = _tuple[2]; + $s = -1; return day; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Day }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Day = function() { return this.$val.Day(); }; + Time.ptr.prototype.Weekday = function() { + var _r, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absWeekday(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Weekday }; } $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Weekday = function() { return this.$val.Weekday(); }; + absWeekday = function(abs) { + var _q, abs, sec; + sec = $div64((new $Uint64(abs.$high + 0, abs.$low + 86400)), new $Uint64(0, 604800), true); + return (((_q = ((sec.$low >> 0)) / 86400, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + }; + Time.ptr.prototype.ISOWeek = function() { + var _q, _r, _r$1, _r$2, _r$3, _r$4, _tuple, day, dec31wday, jan1wday, month, t, wday, week, yday, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; day = $f.day; dec31wday = $f.dec31wday; jan1wday = $f.jan1wday; month = $f.month; t = $f.t; wday = $f.wday; week = $f.week; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + week = 0; + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + yday = _tuple[3]; + _r$2 = $clone(t, Time).Weekday(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + wday = (_r$1 = (((_r$2 + 6 >> 0) >> 0)) % 7, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); + week = (_q = (((yday - wday >> 0) + 7 >> 0)) / 7, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + jan1wday = (_r$3 = (((wday - yday >> 0) + 371 >> 0)) % 7, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (1 <= jan1wday && jan1wday <= 3) { + week = week + (1) >> 0; + } + if (week === 0) { + year = year - (1) >> 0; + week = 52; + if ((jan1wday === 4) || ((jan1wday === 5) && isLeap(year))) { + week = week + (1) >> 0; + } + } + if ((month === 12) && day >= 29 && wday < 3) { + dec31wday = (_r$4 = (((wday + 31 >> 0) - day >> 0)) % 7, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); + if (0 <= dec31wday && dec31wday <= 2) { + year = year + (1) >> 0; + week = 1; + } + } + $s = -1; return [year, week]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.ISOWeek }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.day = day; $f.dec31wday = dec31wday; $f.jan1wday = jan1wday; $f.month = month; $f.t = t; $f.wday = wday; $f.week = week; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.ISOWeek = function() { return this.$val.ISOWeek(); }; + Time.ptr.prototype.Clock = function() { + var _r, _r$1, _tuple, hour, min, sec, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; hour = $f.hour; min = $f.min; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + hour = 0; + min = 0; + sec = 0; + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absClock(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + hour = _tuple[0]; + min = _tuple[1]; + sec = _tuple[2]; + $s = -1; return [hour, min, sec]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Clock }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.hour = hour; $f.min = min; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Clock = function() { return this.$val.Clock(); }; + absClock = function(abs) { + var _q, _q$1, abs, hour, min, sec; + hour = 0; + min = 0; + sec = 0; + sec = (($div64(abs, new $Uint64(0, 86400), true).$low >> 0)); + hour = (_q = sec / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + sec = sec - (($imul(hour, 3600))) >> 0; + min = (_q$1 = sec / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + sec = sec - (($imul(min, 60))) >> 0; + return [hour, min, sec]; + }; + Time.ptr.prototype.Hour = function() { + var _q, _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (_q = (($div64(_r, new $Uint64(0, 86400), true).$low >> 0)) / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Hour }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Hour = function() { return this.$val.Hour(); }; + Time.ptr.prototype.Minute = function() { + var _q, _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (_q = (($div64(_r, new $Uint64(0, 3600), true).$low >> 0)) / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Minute }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Minute = function() { return this.$val.Minute(); }; + Time.ptr.prototype.Second = function() { + var _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (($div64(_r, new $Uint64(0, 60), true).$low >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Second }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Second = function() { return this.$val.Second(); }; + Time.ptr.prototype.Nanosecond = function() { + var t; + t = this; + return ((t.nsec() >> 0)); + }; + Time.prototype.Nanosecond = function() { return this.$val.Nanosecond(); }; + Time.ptr.prototype.YearDay = function() { + var _r, _tuple, t, yday, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; yday = $f.yday; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + yday = _tuple[3]; + $s = -1; return yday + 1 >> 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.YearDay }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.yday = yday; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.YearDay = function() { return this.$val.YearDay(); }; + Duration.prototype.String = function() { + var _tuple, _tuple$1, buf, d, neg, prec, u, w; + d = this; + buf = arrayType$3.zero(); + w = 32; + u = (new $Uint64(d.$high, d.$low)); + neg = (d.$high < 0 || (d.$high === 0 && d.$low < 0)); + if (neg) { + u = new $Uint64(-u.$high, -u.$low); + } + if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000000))) { + prec = 0; + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); + w = w - (1) >> 0; + if ((u.$high === 0 && u.$low === 0)) { + return "0s"; + } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000))) { + prec = 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 110); + } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000))) { + prec = 3; + w = w - (1) >> 0; + $copyString($subslice(new sliceType$3(buf), w), "\xC2\xB5"); + } else { + prec = 6; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); + } + _tuple = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, prec); + w = _tuple[0]; + u = _tuple[1]; + w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); + } else { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); + _tuple$1 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, 9); + w = _tuple$1[0]; + u = _tuple$1[1]; + w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); + u = $div64(u, (new $Uint64(0, 60)), false); + if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); + w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); + u = $div64(u, (new $Uint64(0, 60)), false); + if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 104); + w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); + } + } + } + if (neg) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + } + return ($bytesToString($subslice(new sliceType$3(buf), w))); + }; + $ptrType(Duration).prototype.String = function() { return this.$get().String(); }; + fmtFrac = function(buf, v, prec) { + var _tmp, _tmp$1, buf, digit, i, nv, nw, prec, print, v, w; + nw = 0; + nv = new $Uint64(0, 0); + w = buf.$length; + print = false; + i = 0; + while (true) { + if (!(i < prec)) { break; } + digit = $div64(v, new $Uint64(0, 10), true); + print = print || !((digit.$high === 0 && digit.$low === 0)); + if (print) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = (((digit.$low << 24 >>> 24)) + 48 << 24 >>> 24)); + } + v = $div64(v, (new $Uint64(0, 10)), false); + i = i + (1) >> 0; + } + if (print) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + } + _tmp = w; + _tmp$1 = v; + nw = _tmp; + nv = _tmp$1; + return [nw, nv]; + }; + fmtInt = function(buf, v) { + var buf, v, w; + w = buf.$length; + if ((v.$high === 0 && v.$low === 0)) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); + } else { + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = ((($div64(v, new $Uint64(0, 10), true).$low << 24 >>> 24)) + 48 << 24 >>> 24)); + v = $div64(v, (new $Uint64(0, 10)), false); + } + } + return w; + }; + Duration.prototype.Nanoseconds = function() { + var d; + d = this; + return (new $Int64(d.$high, d.$low)); + }; + $ptrType(Duration).prototype.Nanoseconds = function() { return this.$get().Nanoseconds(); }; + Duration.prototype.Seconds = function() { + var d, nsec, sec; + d = this; + sec = $div64(d, new Duration(0, 1000000000), false); + nsec = $div64(d, new Duration(0, 1000000000), true); + return ($flatten64(sec)) + ($flatten64(nsec)) / 1e+09; + }; + $ptrType(Duration).prototype.Seconds = function() { return this.$get().Seconds(); }; + Duration.prototype.Minutes = function() { + var d, min, nsec; + d = this; + min = $div64(d, new Duration(13, 4165425152), false); + nsec = $div64(d, new Duration(13, 4165425152), true); + return ($flatten64(min)) + ($flatten64(nsec)) / 6e+10; + }; + $ptrType(Duration).prototype.Minutes = function() { return this.$get().Minutes(); }; + Duration.prototype.Hours = function() { + var d, hour, nsec; + d = this; + hour = $div64(d, new Duration(838, 817405952), false); + nsec = $div64(d, new Duration(838, 817405952), true); + return ($flatten64(hour)) + ($flatten64(nsec)) / 3.6e+12; + }; + $ptrType(Duration).prototype.Hours = function() { return this.$get().Hours(); }; + Duration.prototype.Truncate = function(m) { + var d, m, x$1; + d = this; + if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { + return d; + } + return (x$1 = $div64(d, m, true), new Duration(d.$high - x$1.$high, d.$low - x$1.$low)); + }; + $ptrType(Duration).prototype.Truncate = function(m) { return this.$get().Truncate(m); }; + lessThanHalf = function(x$1, y) { + var x$1, x$2, x$3, x$4, x$5, y; + return (x$2 = (x$3 = (new $Uint64(x$1.$high, x$1.$low)), x$4 = (new $Uint64(x$1.$high, x$1.$low)), new $Uint64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), x$5 = (new $Uint64(y.$high, y.$low)), (x$2.$high < x$5.$high || (x$2.$high === x$5.$high && x$2.$low < x$5.$low))); + }; + Duration.prototype.Round = function(m) { + var d, d1, d1$1, m, r, x$1, x$2; + d = this; + if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { + return d; + } + r = $div64(d, m, true); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0))) { + r = new Duration(-r.$high, -r.$low); + if (lessThanHalf(r, m)) { + return new Duration(d.$high + r.$high, d.$low + r.$low); + } + d1 = (x$1 = new Duration(d.$high - m.$high, d.$low - m.$low), new Duration(x$1.$high + r.$high, x$1.$low + r.$low)); + if ((d1.$high < d.$high || (d1.$high === d.$high && d1.$low < d.$low))) { + return d1; + } + return new Duration(-2147483648, 0); + } + if (lessThanHalf(r, m)) { + return new Duration(d.$high - r.$high, d.$low - r.$low); + } + d1$1 = (x$2 = new Duration(d.$high + m.$high, d.$low + m.$low), new Duration(x$2.$high - r.$high, x$2.$low - r.$low)); + if ((d1$1.$high > d.$high || (d1$1.$high === d.$high && d1$1.$low > d.$low))) { + return d1$1; + } + return new Duration(2147483647, 4294967295); + }; + $ptrType(Duration).prototype.Round = function(m) { return this.$get().Round(m); }; + Time.ptr.prototype.Add = function(d) { + var d, dsec, nsec, t, te, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + dsec = ((x$1 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$1.$high, x$1.$low))); + nsec = t.nsec() + (((x$2 = $div64(d, new Duration(0, 1000000000), true), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)) >> 0; + if (nsec >= 1000000000) { + dsec = (x$3 = new $Int64(0, 1), new $Int64(dsec.$high + x$3.$high, dsec.$low + x$3.$low)); + nsec = nsec - (1000000000) >> 0; + } else if (nsec < 0) { + dsec = (x$4 = new $Int64(0, 1), new $Int64(dsec.$high - x$4.$high, dsec.$low - x$4.$low)); + nsec = nsec + (1000000000) >> 0; + } + t.wall = (x$5 = (x$6 = t.wall, new $Uint64(x$6.$high & ~0, (x$6.$low & ~1073741823) >>> 0)), x$7 = (new $Uint64(0, nsec)), new $Uint64(x$5.$high | x$7.$high, (x$5.$low | x$7.$low) >>> 0)); + t.addSec(dsec); + if (!((x$8 = (x$9 = t.wall, new $Uint64(x$9.$high & 2147483648, (x$9.$low & 0) >>> 0)), (x$8.$high === 0 && x$8.$low === 0)))) { + te = (x$10 = t.ext, x$11 = (new $Int64(d.$high, d.$low)), new $Int64(x$10.$high + x$11.$high, x$10.$low + x$11.$low)); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (x$12 = t.ext, (te.$high > x$12.$high || (te.$high === x$12.$high && te.$low > x$12.$low))) || (d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (x$13 = t.ext, (te.$high < x$13.$high || (te.$high === x$13.$high && te.$low < x$13.$low)))) { + t.stripMono(); + } else { + t.ext = te; + } + } + return t; + }; + Time.prototype.Add = function(d) { return this.$val.Add(d); }; + Time.ptr.prototype.Sub = function(u) { + var d, d$1, t, te, u, ue, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + te = t.ext; + ue = u.ext; + d = ((x$5 = new $Int64(te.$high - ue.$high, te.$low - ue.$low), new Duration(x$5.$high, x$5.$low))); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (te.$high > ue.$high || (te.$high === ue.$high && te.$low > ue.$low))) { + return new Duration(2147483647, 4294967295); + } + if ((d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (te.$high < ue.$high || (te.$high === ue.$high && te.$low < ue.$low))) { + return new Duration(-2147483648, 0); + } + return d; + } + d$1 = (x$6 = $mul64(((x$7 = (x$8 = t.sec(), x$9 = u.sec(), new $Int64(x$8.$high - x$9.$high, x$8.$low - x$9.$low)), new Duration(x$7.$high, x$7.$low))), new Duration(0, 1000000000)), x$10 = (new Duration(0, (t.nsec() - u.nsec() >> 0))), new Duration(x$6.$high + x$10.$high, x$6.$low + x$10.$low)); + if ($clone($clone(u, Time).Add(d$1), Time).Equal($clone(t, Time))) { + return d$1; + } else if ($clone(t, Time).Before($clone(u, Time))) { + return new Duration(-2147483648, 0); + } else { + return new Duration(2147483647, 4294967295); + } + }; + Time.prototype.Sub = function(u) { return this.$val.Sub(u); }; + Since = function(t) { + var now$1, t, x$1, x$2, x$3; + now$1 = new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil); + if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { + Time.copy(now$1, new Time.ptr(new $Uint64(2147483648, 0), (x$3 = runtimeNano(), new $Int64(x$3.$high - startNano.$high, x$3.$low - startNano.$low)), ptrType$2.nil)); + } else { + Time.copy(now$1, Now()); + } + return $clone(now$1, Time).Sub($clone(t, Time)); + }; + $pkg.Since = Since; + Time.ptr.prototype.AddDate = function(years, months$1, days$1) { + var _r, _r$1, _r$2, _tuple, _tuple$1, day, days$1, hour, min, month, months$1, sec, t, year, years, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; day = $f.day; days$1 = $f.days$1; hour = $f.hour; min = $f.min; month = $f.month; months$1 = $f.months$1; sec = $f.sec; t = $f.t; year = $f.year; years = $f.years; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Date(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + _r$1 = $clone(t, Time).Clock(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + hour = _tuple$1[0]; + min = _tuple$1[1]; + sec = _tuple$1[2]; + _r$2 = Date(year + years >> 0, month + ((months$1 >> 0)) >> 0, day + days$1 >> 0, hour, min, sec, ((t.nsec() >> 0)), $clone(t, Time).Location()); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AddDate }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.day = day; $f.days$1 = days$1; $f.hour = hour; $f.min = min; $f.month = month; $f.months$1 = months$1; $f.sec = sec; $f.t = t; $f.year = year; $f.years = years; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.AddDate = function(years, months$1, days$1) { return this.$val.AddDate(years, months$1, days$1); }; + Time.ptr.prototype.date = function(full) { + var _r, _r$1, _tuple, day, full, month, t, yday, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; day = $f.day; full = $f.full; month = $f.month; t = $f.t; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + month = 0; + day = 0; + yday = 0; + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absDate(_r, full); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + yday = _tuple[3]; + $s = -1; return [year, month, day, yday]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.date }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.day = day; $f.full = full; $f.month = month; $f.t = t; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.date = function(full) { return this.$val.date(full); }; + absDate = function(abs, full) { + var _q, abs, begin, d, day, end, full, month, n, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, yday, year; + year = 0; + month = 0; + day = 0; + yday = 0; + d = $div64(abs, new $Uint64(0, 86400), false); + n = $div64(d, new $Uint64(0, 146097), false); + y = $mul64(new $Uint64(0, 400), n); + d = (x$1 = $mul64(new $Uint64(0, 146097), n), new $Uint64(d.$high - x$1.$high, d.$low - x$1.$low)); + n = $div64(d, new $Uint64(0, 36524), false); + n = (x$2 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$2.$high, n.$low - x$2.$low)); + y = (x$3 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high + x$3.$high, y.$low + x$3.$low)); + d = (x$4 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high - x$4.$high, d.$low - x$4.$low)); + n = $div64(d, new $Uint64(0, 1461), false); + y = (x$5 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high + x$5.$high, y.$low + x$5.$low)); + d = (x$6 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high - x$6.$high, d.$low - x$6.$low)); + n = $div64(d, new $Uint64(0, 365), false); + n = (x$7 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$7.$high, n.$low - x$7.$low)); + y = (x$8 = n, new $Uint64(y.$high + x$8.$high, y.$low + x$8.$low)); + d = (x$9 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high - x$9.$high, d.$low - x$9.$low)); + year = (((x$10 = (x$11 = (new $Int64(y.$high, y.$low)), new $Int64(x$11.$high + -69, x$11.$low + 4075721025)), x$10.$low + ((x$10.$high >> 31) * 4294967296)) >> 0)); + yday = ((d.$low >> 0)); + if (!full) { + return [year, month, day, yday]; + } + day = yday; + if (isLeap(year)) { + if (day > 59) { + day = day - (1) >> 0; + } else if ((day === 59)) { + month = 2; + day = 29; + return [year, month, day, yday]; + } + } + month = (((_q = day / 31, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + end = (((x$12 = month + 1 >> 0, ((x$12 < 0 || x$12 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$12])) >> 0)); + begin = 0; + if (day >= end) { + month = month + (1) >> 0; + begin = end; + } else { + begin = ((((month < 0 || month >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[month]) >> 0)); + } + month = month + (1) >> 0; + day = (day - begin >> 0) + 1 >> 0; + return [year, month, day, yday]; + }; + daysIn = function(m, year) { + var m, x$1, year; + if ((m === 2) && isLeap(year)) { + return 29; + } + return (((((m < 0 || m >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[m]) - (x$1 = m - 1 >> 0, ((x$1 < 0 || x$1 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$1])) >> 0) >> 0)); + }; + Now = function() { + var _tuple, mono, nsec, sec, x$1, x$2, x$3, x$4, x$5, x$6; + _tuple = now(); + sec = _tuple[0]; + nsec = _tuple[1]; + mono = _tuple[2]; + mono = (x$1 = startNano, new $Int64(mono.$high - x$1.$high, mono.$low - x$1.$low)); + sec = (x$2 = new $Int64(0, 2682288000), new $Int64(sec.$high + x$2.$high, sec.$low + x$2.$low)); + if (!((x$3 = $shiftRightUint64((new $Uint64(sec.$high, sec.$low)), 33), (x$3.$high === 0 && x$3.$low === 0)))) { + return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 13, sec.$low + 3618733952), $pkg.Local); + } + return new Time.ptr((x$4 = (x$5 = $shiftLeft64((new $Uint64(sec.$high, sec.$low)), 30), new $Uint64(2147483648 | x$5.$high, (0 | x$5.$low) >>> 0)), x$6 = (new $Uint64(0, nsec)), new $Uint64(x$4.$high | x$6.$high, (x$4.$low | x$6.$low) >>> 0)), mono, $pkg.Local); + }; + $pkg.Now = Now; + unixTime = function(sec, nsec) { + var nsec, sec; + return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 14, sec.$low + 2006054656), $pkg.Local); + }; + Time.ptr.prototype.UTC = function() { + var t; + t = this; + t.setLoc(utcLoc); + return t; + }; + Time.prototype.UTC = function() { return this.$val.UTC(); }; + Time.ptr.prototype.Local = function() { + var t; + t = this; + t.setLoc($pkg.Local); + return t; + }; + Time.prototype.Local = function() { return this.$val.Local(); }; + Time.ptr.prototype.In = function(loc) { + var loc, t; + t = this; + if (loc === ptrType$2.nil) { + $panic(new $String("time: missing Location in call to Time.In")); + } + t.setLoc(loc); + return t; + }; + Time.prototype.In = function(loc) { return this.$val.In(loc); }; + Time.ptr.prototype.Location = function() { + var l, t; + t = this; + l = t.loc; + if (l === ptrType$2.nil) { + l = $pkg.UTC; + } + return l; + }; + Time.prototype.Location = function() { return this.$val.Location(); }; + Time.ptr.prototype.Zone = function() { + var _r, _tuple, name, offset, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; name = $f.name; offset = $f.offset; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + t = this; + _r = t.loc.lookup(t.unixSec()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + name = _tuple[0]; + offset = _tuple[1]; + $s = -1; return [name, offset]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Zone }; } $f._r = _r; $f._tuple = _tuple; $f.name = name; $f.offset = offset; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Zone = function() { return this.$val.Zone(); }; + Time.ptr.prototype.Unix = function() { + var t; + t = this; + return t.unixSec(); + }; + Time.prototype.Unix = function() { return this.$val.Unix(); }; + Time.ptr.prototype.UnixNano = function() { + var t, x$1, x$2; + t = this; + return (x$1 = $mul64((t.unixSec()), new $Int64(0, 1000000000)), x$2 = (new $Int64(0, t.nsec())), new $Int64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)); + }; + Time.prototype.UnixNano = function() { return this.$val.UnixNano(); }; + Time.ptr.prototype.MarshalBinary = function() { + var _q, _r, _r$1, _tuple, enc, nsec, offset, offsetMin, sec, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; enc = $f.enc; nsec = $f.nsec; offset = $f.offset; offsetMin = $f.offsetMin; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + offsetMin = 0; + /* */ if ($clone(t, Time).Location() === $pkg.UTC) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(t, Time).Location() === $pkg.UTC) { */ case 1: + offsetMin = -1; + $s = 3; continue; + /* } else { */ case 2: + _r = $clone(t, Time).Zone(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + offset = _tuple[1]; + if (!(((_r$1 = offset % 60, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0))) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: zone offset has fractional minute")]; + } + offset = (_q = offset / (60), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + if (offset < -32768 || (offset === -1) || offset > 32767) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: unexpected zone offset")]; + } + offsetMin = ((offset << 16 >> 16)); + /* } */ case 3: + sec = t.sec(); + nsec = t.nsec(); + enc = new sliceType$3([1, (($shiftRightInt64(sec, 56).$low << 24 >>> 24)), (($shiftRightInt64(sec, 48).$low << 24 >>> 24)), (($shiftRightInt64(sec, 40).$low << 24 >>> 24)), (($shiftRightInt64(sec, 32).$low << 24 >>> 24)), (($shiftRightInt64(sec, 24).$low << 24 >>> 24)), (($shiftRightInt64(sec, 16).$low << 24 >>> 24)), (($shiftRightInt64(sec, 8).$low << 24 >>> 24)), ((sec.$low << 24 >>> 24)), (((nsec >> 24 >> 0) << 24 >>> 24)), (((nsec >> 16 >> 0) << 24 >>> 24)), (((nsec >> 8 >> 0) << 24 >>> 24)), ((nsec << 24 >>> 24)), (((offsetMin >> 8 << 16 >> 16) << 24 >>> 24)), ((offsetMin << 24 >>> 24))]); + $s = -1; return [enc, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalBinary }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.enc = enc; $f.nsec = nsec; $f.offset = offset; $f.offsetMin = offsetMin; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); }; + Time.ptr.prototype.UnmarshalBinary = function(data) { + var _r, _tuple, buf, data, localoff, nsec, offset, sec, t, x$1, x$10, x$11, x$12, x$13, x$14, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; data = $f.data; localoff = $f.localoff; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + buf = data; + if (buf.$length === 0) { + $s = -1; return errors.New("Time.UnmarshalBinary: no data"); + } + if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { + $s = -1; return errors.New("Time.UnmarshalBinary: unsupported version"); + } + if (!((buf.$length === 15))) { + $s = -1; return errors.New("Time.UnmarshalBinary: invalid length"); + } + buf = $subslice(buf, 1); + sec = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (x$7 = (new $Int64(0, (7 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 7]))), x$8 = $shiftLeft64((new $Int64(0, (6 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 6]))), 8), new $Int64(x$7.$high | x$8.$high, (x$7.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Int64(0, (5 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 5]))), 16), new $Int64(x$6.$high | x$9.$high, (x$6.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Int64(0, (4 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 4]))), 24), new $Int64(x$5.$high | x$10.$high, (x$5.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Int64(0, (3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]))), 32), new $Int64(x$4.$high | x$11.$high, (x$4.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Int64(0, (2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]))), 40), new $Int64(x$3.$high | x$12.$high, (x$3.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Int64(0, (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]))), 48), new $Int64(x$2.$high | x$13.$high, (x$2.$low | x$13.$low) >>> 0)), x$14 = $shiftLeft64((new $Int64(0, (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]))), 56), new $Int64(x$1.$high | x$14.$high, (x$1.$low | x$14.$low) >>> 0)); + buf = $subslice(buf, 8); + nsec = (((((3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]) >> 0)) | ((((2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]) >> 0)) << 8 >> 0)) | ((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) >> 0)) << 16 >> 0)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) >> 0)) << 24 >> 0); + buf = $subslice(buf, 4); + offset = $imul(((((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) << 16 >> 16)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) << 16 >> 16)) << 8 << 16 >> 16)) >> 0)), 60); + Time.copy(t, new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil)); + t.wall = (new $Uint64(0, nsec)); + t.ext = sec; + /* */ if (offset === -60) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (offset === -60) { */ case 1: + t.setLoc(utcLoc); + $s = 3; continue; + /* } else { */ case 2: + _r = $pkg.Local.lookup(t.unixSec()); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + localoff = _tuple[1]; + if (offset === localoff) { + t.setLoc($pkg.Local); + } else { + t.setLoc(FixedZone("", offset)); + } + /* } */ case 3: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalBinary }; } $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.data = data; $f.localoff = localoff; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalBinary = function(data) { return this.$val.UnmarshalBinary(data); }; + Time.ptr.prototype.GobEncode = function() { + var _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).MarshalBinary(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobEncode }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.GobEncode = function() { return this.$val.GobEncode(); }; + Time.ptr.prototype.GobDecode = function(data) { + var _r, data, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; data = $f.data; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = t.UnmarshalBinary(data); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobDecode }; } $f._r = _r; $f.data = data; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.GobDecode = function(data) { return this.$val.GobDecode(data); }; + Time.ptr.prototype.MarshalJSON = function() { + var _r, _r$1, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + y = _r; + if (y < 0 || y >= 10000) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")]; + } + b = $makeSlice(sliceType$3, 0, 37); + b = $append(b, 34); + _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + b = _r$1; + b = $append(b, 34); + $s = -1; return [b, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalJSON }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); }; + Time.ptr.prototype.UnmarshalJSON = function(data) { + var _r, _tuple, data, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (($bytesToString(data)) === "null") { + $s = -1; return $ifaceNil; + } + err = $ifaceNil; + _r = Parse("\"2006-01-02T15:04:05Z07:00\"", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + Time.copy(t, _tuple[0]); + err = _tuple[1]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalJSON }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalJSON = function(data) { return this.$val.UnmarshalJSON(data); }; + Time.ptr.prototype.MarshalText = function() { + var _r, _r$1, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + y = _r; + if (y < 0 || y >= 10000) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalText: year outside of range [0,9999]")]; + } + b = $makeSlice(sliceType$3, 0, 35); + _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return [_r$1, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalText }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalText = function() { return this.$val.MarshalText(); }; + Time.ptr.prototype.UnmarshalText = function(data) { + var _r, _tuple, data, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + err = $ifaceNil; + _r = Parse("2006-01-02T15:04:05Z07:00", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + Time.copy(t, _tuple[0]); + err = _tuple[1]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalText }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalText = function(data) { return this.$val.UnmarshalText(data); }; + Unix = function(sec, nsec) { + var n, nsec, sec, x$1, x$2, x$3, x$4; + if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0)) || (nsec.$high > 0 || (nsec.$high === 0 && nsec.$low >= 1000000000))) { + n = $div64(nsec, new $Int64(0, 1000000000), false); + sec = (x$1 = n, new $Int64(sec.$high + x$1.$high, sec.$low + x$1.$low)); + nsec = (x$2 = $mul64(n, new $Int64(0, 1000000000)), new $Int64(nsec.$high - x$2.$high, nsec.$low - x$2.$low)); + if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0))) { + nsec = (x$3 = new $Int64(0, 1000000000), new $Int64(nsec.$high + x$3.$high, nsec.$low + x$3.$low)); + sec = (x$4 = new $Int64(0, 1), new $Int64(sec.$high - x$4.$high, sec.$low - x$4.$low)); + } + } + return unixTime(sec, (((nsec.$low + ((nsec.$high >> 31) * 4294967296)) >> 0))); + }; + $pkg.Unix = Unix; + isLeap = function(year) { + var _r, _r$1, _r$2, year; + return ((_r = year % 4, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0) && (!(((_r$1 = year % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0)) || ((_r$2 = year % 400, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0)); + }; + norm = function(hi, lo, base) { + var _q, _q$1, _tmp, _tmp$1, base, hi, lo, n, n$1, nhi, nlo; + nhi = 0; + nlo = 0; + if (lo < 0) { + n = (_q = ((-lo - 1 >> 0)) / base, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0; + hi = hi - (n) >> 0; + lo = lo + (($imul(n, base))) >> 0; + } + if (lo >= base) { + n$1 = (_q$1 = lo / base, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + hi = hi + (n$1) >> 0; + lo = lo - (($imul(n$1, base))) >> 0; + } + _tmp = hi; + _tmp$1 = lo; + nhi = _tmp; + nlo = _tmp$1; + return [nhi, nlo]; + }; + Date = function(year, month, day, hour, min, sec, nsec, loc) { + var _r, _r$1, _r$2, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, abs, d, day, end, hour, loc, m, min, month, n, nsec, offset, sec, start, t, unix, utc, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; abs = $f.abs; d = $f.d; day = $f.day; end = $f.end; hour = $f.hour; loc = $f.loc; m = $f.m; min = $f.min; month = $f.month; n = $f.n; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; start = $f.start; t = $f.t; unix = $f.unix; utc = $f.utc; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (loc === ptrType$2.nil) { + $panic(new $String("time: missing Location in call to Date")); + } + m = ((month >> 0)) - 1 >> 0; + _tuple = norm(year, m, 12); + year = _tuple[0]; + m = _tuple[1]; + month = ((m >> 0)) + 1 >> 0; + _tuple$1 = norm(sec, nsec, 1000000000); + sec = _tuple$1[0]; + nsec = _tuple$1[1]; + _tuple$2 = norm(min, sec, 60); + min = _tuple$2[0]; + sec = _tuple$2[1]; + _tuple$3 = norm(hour, min, 60); + hour = _tuple$3[0]; + min = _tuple$3[1]; + _tuple$4 = norm(day, hour, 24); + day = _tuple$4[0]; + hour = _tuple$4[1]; + y = ((x$1 = (x$2 = (new $Int64(0, year)), new $Int64(x$2.$high - -69, x$2.$low - 4075721025)), new $Uint64(x$1.$high, x$1.$low))); + n = $div64(y, new $Uint64(0, 400), false); + y = (x$3 = $mul64(new $Uint64(0, 400), n), new $Uint64(y.$high - x$3.$high, y.$low - x$3.$low)); + d = $mul64(new $Uint64(0, 146097), n); + n = $div64(y, new $Uint64(0, 100), false); + y = (x$4 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high - x$4.$high, y.$low - x$4.$low)); + d = (x$5 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high + x$5.$high, d.$low + x$5.$low)); + n = $div64(y, new $Uint64(0, 4), false); + y = (x$6 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high - x$6.$high, y.$low - x$6.$low)); + d = (x$7 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high + x$7.$high, d.$low + x$7.$low)); + n = y; + d = (x$8 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high + x$8.$high, d.$low + x$8.$low)); + d = (x$9 = (new $Uint64(0, (x$10 = month - 1 >> 0, ((x$10 < 0 || x$10 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$10])))), new $Uint64(d.$high + x$9.$high, d.$low + x$9.$low)); + if (isLeap(year) && month >= 3) { + d = (x$11 = new $Uint64(0, 1), new $Uint64(d.$high + x$11.$high, d.$low + x$11.$low)); + } + d = (x$12 = (new $Uint64(0, (day - 1 >> 0))), new $Uint64(d.$high + x$12.$high, d.$low + x$12.$low)); + abs = $mul64(d, new $Uint64(0, 86400)); + abs = (x$13 = (new $Uint64(0, ((($imul(hour, 3600)) + ($imul(min, 60)) >> 0) + sec >> 0))), new $Uint64(abs.$high + x$13.$high, abs.$low + x$13.$low)); + unix = (x$14 = (new $Int64(abs.$high, abs.$low)), new $Int64(x$14.$high + -2147483647, x$14.$low + 3844486912)); + _r = loc.lookup(unix); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$5 = _r; + offset = _tuple$5[1]; + start = _tuple$5[2]; + end = _tuple$5[3]; + /* */ if (!((offset === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((offset === 0))) { */ case 2: + utc = (x$15 = (new $Int64(0, offset)), new $Int64(unix.$high - x$15.$high, unix.$low - x$15.$low)); + /* */ if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { $s = 5; continue; } + /* */ if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { */ case 5: + _r$1 = loc.lookup(new $Int64(start.$high - 0, start.$low - 1)); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$6 = _r$1; + offset = _tuple$6[1]; + $s = 7; continue; + /* } else if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { */ case 6: + _r$2 = loc.lookup(end); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$7 = _r$2; + offset = _tuple$7[1]; + /* } */ case 7: + case 4: + unix = (x$16 = (new $Int64(0, offset)), new $Int64(unix.$high - x$16.$high, unix.$low - x$16.$low)); + /* } */ case 3: + t = $clone(unixTime(unix, ((nsec >> 0))), Time); + t.setLoc(loc); + $s = -1; return t; + /* */ } return; } if ($f === undefined) { $f = { $blk: Date }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.abs = abs; $f.d = d; $f.day = day; $f.end = end; $f.hour = hour; $f.loc = loc; $f.m = m; $f.min = min; $f.month = month; $f.n = n; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.start = start; $f.t = t; $f.unix = unix; $f.utc = utc; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Date = Date; + Time.ptr.prototype.Truncate = function(d) { + var _tuple, d, r, t; + t = this; + t.stripMono(); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple = div($clone(t, Time), d); + r = _tuple[1]; + return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); + }; + Time.prototype.Truncate = function(d) { return this.$val.Truncate(d); }; + Time.ptr.prototype.Round = function(d) { + var _tuple, d, r, t; + t = this; + t.stripMono(); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple = div($clone(t, Time), d); + r = _tuple[1]; + if (lessThanHalf(r, d)) { + return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); + } + return $clone(t, Time).Add(new Duration(d.$high - r.$high, d.$low - r.$low)); + }; + Time.prototype.Round = function(d) { return this.$val.Round(d); }; + div = function(t, d) { + var _q, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, d, d0, d1, d1$1, neg, nsec, qmod2, r, sec, sec$1, t, tmp, u0, u0x, u1, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + qmod2 = 0; + r = new Duration(0, 0); + neg = false; + nsec = t.nsec(); + sec = t.sec(); + if ((sec.$high < 0 || (sec.$high === 0 && sec.$low < 0))) { + neg = true; + sec = new $Int64(-sec.$high, -sec.$low); + nsec = -nsec; + if (nsec < 0) { + nsec = nsec + (1000000000) >> 0; + sec = (x$1 = new $Int64(0, 1), new $Int64(sec.$high - x$1.$high, sec.$low - x$1.$low)); + } + } + if ((d.$high < 0 || (d.$high === 0 && d.$low < 1000000000)) && (x$2 = $div64(new Duration(0, 1000000000), (new Duration(d.$high + d.$high, d.$low + d.$low)), true), (x$2.$high === 0 && x$2.$low === 0))) { + qmod2 = (((_q = nsec / (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) & 1; + r = (new Duration(0, (_r = nsec % (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), _r === _r ? _r : $throwRuntimeError("integer divide by zero")))); + } else if ((x$3 = $div64(d, new Duration(0, 1000000000), true), (x$3.$high === 0 && x$3.$low === 0))) { + d1 = ((x$4 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$4.$high, x$4.$low))); + qmod2 = (((x$5 = $div64(sec, d1, false), x$5.$low + ((x$5.$high >> 31) * 4294967296)) >> 0)) & 1; + r = (x$6 = $mul64(((x$7 = $div64(sec, d1, true), new Duration(x$7.$high, x$7.$low))), new Duration(0, 1000000000)), x$8 = (new Duration(0, nsec)), new Duration(x$6.$high + x$8.$high, x$6.$low + x$8.$low)); + } else { + sec$1 = (new $Uint64(sec.$high, sec.$low)); + tmp = $mul64(($shiftRightUint64(sec$1, 32)), new $Uint64(0, 1000000000)); + u1 = $shiftRightUint64(tmp, 32); + u0 = $shiftLeft64(tmp, 32); + tmp = $mul64((new $Uint64(sec$1.$high & 0, (sec$1.$low & 4294967295) >>> 0)), new $Uint64(0, 1000000000)); + _tmp = u0; + _tmp$1 = new $Uint64(u0.$high + tmp.$high, u0.$low + tmp.$low); + u0x = _tmp; + u0 = _tmp$1; + if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { + u1 = (x$9 = new $Uint64(0, 1), new $Uint64(u1.$high + x$9.$high, u1.$low + x$9.$low)); + } + _tmp$2 = u0; + _tmp$3 = (x$10 = (new $Uint64(0, nsec)), new $Uint64(u0.$high + x$10.$high, u0.$low + x$10.$low)); + u0x = _tmp$2; + u0 = _tmp$3; + if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { + u1 = (x$11 = new $Uint64(0, 1), new $Uint64(u1.$high + x$11.$high, u1.$low + x$11.$low)); + } + d1$1 = (new $Uint64(d.$high, d.$low)); + while (true) { + if (!(!((x$12 = $shiftRightUint64(d1$1, 63), (x$12.$high === 0 && x$12.$low === 1))))) { break; } + d1$1 = $shiftLeft64(d1$1, (1)); + } + d0 = new $Uint64(0, 0); + while (true) { + qmod2 = 0; + if ((u1.$high > d1$1.$high || (u1.$high === d1$1.$high && u1.$low > d1$1.$low)) || (u1.$high === d1$1.$high && u1.$low === d1$1.$low) && (u0.$high > d0.$high || (u0.$high === d0.$high && u0.$low >= d0.$low))) { + qmod2 = 1; + _tmp$4 = u0; + _tmp$5 = new $Uint64(u0.$high - d0.$high, u0.$low - d0.$low); + u0x = _tmp$4; + u0 = _tmp$5; + if ((u0.$high > u0x.$high || (u0.$high === u0x.$high && u0.$low > u0x.$low))) { + u1 = (x$13 = new $Uint64(0, 1), new $Uint64(u1.$high - x$13.$high, u1.$low - x$13.$low)); + } + u1 = (x$14 = d1$1, new $Uint64(u1.$high - x$14.$high, u1.$low - x$14.$low)); + } + if ((d1$1.$high === 0 && d1$1.$low === 0) && (x$15 = (new $Uint64(d.$high, d.$low)), (d0.$high === x$15.$high && d0.$low === x$15.$low))) { + break; + } + d0 = $shiftRightUint64(d0, (1)); + d0 = (x$16 = $shiftLeft64((new $Uint64(d1$1.$high & 0, (d1$1.$low & 1) >>> 0)), 63), new $Uint64(d0.$high | x$16.$high, (d0.$low | x$16.$low) >>> 0)); + d1$1 = $shiftRightUint64(d1$1, (1)); + } + r = (new Duration(u0.$high, u0.$low)); + } + if (neg && !((r.$high === 0 && r.$low === 0))) { + qmod2 = (qmod2 ^ (1)) >> 0; + r = new Duration(d.$high - r.$high, d.$low - r.$low); + } + return [qmod2, r]; + }; + Location.ptr.prototype.get = function() { + var l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + if (l === ptrType$2.nil) { + $s = -1; return utcLoc; + } + /* */ if (l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === localLoc) { */ case 1: + $r = localOnce.Do(initLocal); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return l; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.get }; } $f.l = l; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.get = function() { return this.$val.get(); }; + Location.ptr.prototype.String = function() { + var _r, l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r.name; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.String }; } $f._r = _r; $f.l = l; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.String = function() { return this.$val.String(); }; + FixedZone = function(name, offset) { + var l, name, offset, x$1; + l = new Location.ptr(name, new sliceType([new zone.ptr(name, offset, false)]), new sliceType$1([new zoneTrans.ptr(new $Int64(-2147483648, 0), 0, false, false)]), new $Int64(-2147483648, 0), new $Int64(2147483647, 4294967295), ptrType.nil); + l.cacheZone = (x$1 = l.zone, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); + return l; + }; + $pkg.FixedZone = FixedZone; + Location.ptr.prototype.lookup = function(sec) { + var _q, _r, end, hi, l, lim, lo, m, name, offset, sec, start, tx, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, zone$1, zone$2, zone$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; end = $f.end; hi = $f.hi; l = $f.l; lim = $f.lim; lo = $f.lo; m = $f.m; name = $f.name; offset = $f.offset; sec = $f.sec; start = $f.start; tx = $f.tx; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; zone$1 = $f.zone$1; zone$2 = $f.zone$2; zone$3 = $f.zone$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + start = new $Int64(0, 0); + end = new $Int64(0, 0); + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + if (l.zone.$length === 0) { + name = "UTC"; + offset = 0; + start = new $Int64(-2147483648, 0); + end = new $Int64(2147483647, 4294967295); + $s = -1; return [name, offset, start, end]; + } + zone$1 = l.cacheZone; + if (!(zone$1 === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { + name = zone$1.name; + offset = zone$1.offset; + start = l.cacheStart; + end = l.cacheEnd; + $s = -1; return [name, offset, start, end]; + } + if ((l.tx.$length === 0) || (x$3 = (x$4 = l.tx, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])).when, (sec.$high < x$3.$high || (sec.$high === x$3.$high && sec.$low < x$3.$low)))) { + zone$2 = (x$5 = l.zone, x$6 = l.lookupFirstZone(), ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6])); + name = zone$2.name; + offset = zone$2.offset; + start = new $Int64(-2147483648, 0); + if (l.tx.$length > 0) { + end = (x$7 = l.tx, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])).when; + } else { + end = new $Int64(2147483647, 4294967295); + } + $s = -1; return [name, offset, start, end]; + } + tx = l.tx; + end = new $Int64(2147483647, 4294967295); + lo = 0; + hi = tx.$length; + while (true) { + if (!((hi - lo >> 0) > 1)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + lim = ((m < 0 || m >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + m]).when; + if ((sec.$high < lim.$high || (sec.$high === lim.$high && sec.$low < lim.$low))) { + end = lim; + hi = m; + } else { + lo = m; + } + } + zone$3 = (x$8 = l.zone, x$9 = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).index, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])); + name = zone$3.name; + offset = zone$3.offset; + start = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).when; + $s = -1; return [name, offset, start, end]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookup }; } $f._q = _q; $f._r = _r; $f.end = end; $f.hi = hi; $f.l = l; $f.lim = lim; $f.lo = lo; $f.m = m; $f.name = name; $f.offset = offset; $f.sec = sec; $f.start = start; $f.tx = tx; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.zone$3 = zone$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.lookup = function(sec) { return this.$val.lookup(sec); }; + Location.ptr.prototype.lookupFirstZone = function() { + var _i, _ref, l, x$1, x$2, x$3, x$4, x$5, x$6, zi, zi$1; + l = this; + if (!l.firstZoneUsed()) { + return 0; + } + if (l.tx.$length > 0 && (x$1 = l.zone, x$2 = (x$3 = l.tx, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).index, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])).isDST) { + zi = (((x$4 = l.tx, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])).index >> 0)) - 1 >> 0; + while (true) { + if (!(zi >= 0)) { break; } + if (!(x$5 = l.zone, ((zi < 0 || zi >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + zi])).isDST) { + return zi; + } + zi = zi - (1) >> 0; + } + } + _ref = l.zone; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + zi$1 = _i; + if (!(x$6 = l.zone, ((zi$1 < 0 || zi$1 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + zi$1])).isDST) { + return zi$1; + } + _i++; + } + return 0; + }; + Location.prototype.lookupFirstZone = function() { return this.$val.lookupFirstZone(); }; + Location.ptr.prototype.firstZoneUsed = function() { + var _i, _ref, l, tx; + l = this; + _ref = l.tx; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + tx = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), zoneTrans); + if (tx.index === 0) { + return true; + } + _i++; + } + return false; + }; + Location.prototype.firstZoneUsed = function() { return this.$val.firstZoneUsed(); }; + Location.ptr.prototype.lookupName = function(name, unix) { + var _i, _i$1, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, i, i$1, l, nam, name, offset, offset$1, ok, unix, x$1, x$2, x$3, zone$1, zone$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; i = $f.i; i$1 = $f.i$1; l = $f.l; nam = $f.nam; name = $f.name; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; unix = $f.unix; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + offset = 0; + ok = false; + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + _ref = l.zone; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + i = _i; + zone$1 = (x$1 = l.zone, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); + /* */ if (zone$1.name === name) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (zone$1.name === name) { */ case 4: + _r$1 = l.lookup((x$2 = (new $Int64(0, zone$1.offset)), new $Int64(unix.$high - x$2.$high, unix.$low - x$2.$low))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + nam = _tuple[0]; + offset$1 = _tuple[1]; + if (nam === zone$1.name) { + _tmp = offset$1; + _tmp$1 = true; + offset = _tmp; + ok = _tmp$1; + $s = -1; return [offset, ok]; + } + /* } */ case 5: + _i++; + /* } */ $s = 2; continue; case 3: + _ref$1 = l.zone; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + zone$2 = (x$3 = l.zone, ((i$1 < 0 || i$1 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i$1])); + if (zone$2.name === name) { + _tmp$2 = zone$2.offset; + _tmp$3 = true; + offset = _tmp$2; + ok = _tmp$3; + $s = -1; return [offset, ok]; + } + _i$1++; + } + $s = -1; return [offset, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookupName }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.i = i; $f.i$1 = i$1; $f.l = l; $f.nam = nam; $f.name = name; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.unix = unix; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.lookupName = function(name, unix) { return this.$val.lookupName(name, unix); }; + ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + Time.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "AppendFormat", name: "AppendFormat", pkg: "", typ: $funcType([sliceType$3, $String], [sliceType$3], false)}, {prop: "After", name: "After", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Before", name: "Before", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "IsZero", name: "IsZero", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "abs", name: "abs", pkg: "time", typ: $funcType([], [$Uint64], false)}, {prop: "locabs", name: "locabs", pkg: "time", typ: $funcType([], [$String, $Int, $Uint64], false)}, {prop: "Date", name: "Date", pkg: "", typ: $funcType([], [$Int, Month, $Int], false)}, {prop: "Year", name: "Year", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Month", name: "Month", pkg: "", typ: $funcType([], [Month], false)}, {prop: "Day", name: "Day", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Weekday", name: "Weekday", pkg: "", typ: $funcType([], [Weekday], false)}, {prop: "ISOWeek", name: "ISOWeek", pkg: "", typ: $funcType([], [$Int, $Int], false)}, {prop: "Clock", name: "Clock", pkg: "", typ: $funcType([], [$Int, $Int, $Int], false)}, {prop: "Hour", name: "Hour", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Minute", name: "Minute", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Second", name: "Second", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Nanosecond", name: "Nanosecond", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "YearDay", name: "YearDay", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([Time], [Duration], false)}, {prop: "AddDate", name: "AddDate", pkg: "", typ: $funcType([$Int, $Int, $Int], [Time], false)}, {prop: "date", name: "date", pkg: "time", typ: $funcType([$Bool], [$Int, Month, $Int, $Int], false)}, {prop: "UTC", name: "UTC", pkg: "", typ: $funcType([], [Time], false)}, {prop: "Local", name: "Local", pkg: "", typ: $funcType([], [Time], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([ptrType$2], [Time], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$2], false)}, {prop: "Zone", name: "Zone", pkg: "", typ: $funcType([], [$String, $Int], false)}, {prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "UnixNano", name: "UnixNano", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Time], false)}]; + ptrType$7.methods = [{prop: "nsec", name: "nsec", pkg: "time", typ: $funcType([], [$Int32], false)}, {prop: "sec", name: "sec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "unixSec", name: "unixSec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "addSec", name: "addSec", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "setLoc", name: "setLoc", pkg: "time", typ: $funcType([ptrType$2], [], false)}, {prop: "stripMono", name: "stripMono", pkg: "time", typ: $funcType([], [], false)}, {prop: "setMono", name: "setMono", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "mono", name: "mono", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$3], [$error], false)}]; + Month.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + Weekday.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + Duration.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Nanoseconds", name: "Nanoseconds", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seconds", name: "Seconds", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Minutes", name: "Minutes", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Hours", name: "Hours", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Duration], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Duration], false)}]; + ptrType$2.methods = [{prop: "get", name: "get", pkg: "time", typ: $funcType([], [ptrType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "lookup", name: "lookup", pkg: "time", typ: $funcType([$Int64], [$String, $Int, $Int64, $Int64], false)}, {prop: "lookupFirstZone", name: "lookupFirstZone", pkg: "time", typ: $funcType([], [$Int], false)}, {prop: "firstZoneUsed", name: "firstZoneUsed", pkg: "time", typ: $funcType([], [$Bool], false)}, {prop: "lookupName", name: "lookupName", pkg: "time", typ: $funcType([$String, $Int64], [$Int, $Bool], false)}]; + ParseError.init("", [{prop: "Layout", name: "Layout", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Value", name: "Value", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "LayoutElem", name: "LayoutElem", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "ValueElem", name: "ValueElem", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Message", name: "Message", embedded: false, exported: true, typ: $String, tag: ""}]); + Time.init("time", [{prop: "wall", name: "wall", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "ext", name: "ext", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "loc", name: "loc", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); + Location.init("time", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "zone", name: "zone", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "tx", name: "tx", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "cacheStart", name: "cacheStart", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheEnd", name: "cacheEnd", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheZone", name: "cacheZone", embedded: false, exported: false, typ: ptrType, tag: ""}]); + zone.init("time", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "offset", name: "offset", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "isDST", name: "isDST", embedded: false, exported: false, typ: $Bool, tag: ""}]); + zoneTrans.init("time", [{prop: "when", name: "when", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "isstd", name: "isstd", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "isutc", name: "isutc", embedded: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + localLoc = new Location.ptr("", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); + localOnce = new nosync.Once.ptr(false, false); + zoneSources = new sliceType$2([runtime.GOROOT() + "/lib/time/zoneinfo.zip"]); + std0x = $toNativeArray($kindInt, [260, 265, 524, 526, 528, 274]); + longDayNames = new sliceType$2(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); + shortDayNames = new sliceType$2(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]); + shortMonthNames = new sliceType$2(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]); + longMonthNames = new sliceType$2(["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); + atoiError = errors.New("time: invalid number"); + errBad = errors.New("bad value for field"); + errLeadingInt = errors.New("time: bad [0-9]*"); + months = $toNativeArray($kindString, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); + days = $toNativeArray($kindString, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); + daysBefore = $toNativeArray($kindInt32, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]); + startNano = (x = runtimeNano(), new $Int64(x.$high - 0, x.$low - 1)); + utcLoc = new Location.ptr("UTC", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); + $pkg.UTC = utcLoc; + $pkg.Local = localLoc; + errLocation = errors.New("time: invalid location name"); + badData = errors.New("malformed time zone information"); + $unused(new sliceType$2(["/usr/share/zoneinfo/", "/usr/share/lib/zoneinfo/", "/usr/lib/locale/TZ/", runtime.GOROOT() + "/lib/time/zoneinfo.zip"])); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/poll"] = (function() { + var $pkg = {}, $init, errors, io, runtime, atomic, syscall, time, pollDesc, TimeoutError, fdMutex, FD, ptrType, chanType, sliceType, ptrType$1, ptrType$2, arrayType, sliceType$2, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, sliceType$3, ptrType$12, funcType, funcType$1, ptrType$13, ptrType$14, ptrType$15, ptrType$16, sliceType$4, ptrType$17, semWaiters, tryDupCloexec, tryDupCloexec$24ptr, runtime_Semacquire, runtime_Semrelease, errClosing, consume, fcntl, DupCloseOnExec, dupCloseOnExecOld, writev, accept; + errors = $packages["errors"]; + io = $packages["io"]; + runtime = $packages["runtime"]; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + time = $packages["time"]; + pollDesc = $pkg.pollDesc = $newType(0, $kindStruct, "poll.pollDesc", true, "internal/poll", false, function(closing_) { + this.$val = this; + if (arguments.length === 0) { + this.closing = false; + return; + } + this.closing = closing_; + }); + TimeoutError = $pkg.TimeoutError = $newType(0, $kindStruct, "poll.TimeoutError", true, "internal/poll", true, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + fdMutex = $pkg.fdMutex = $newType(0, $kindStruct, "poll.fdMutex", true, "internal/poll", false, function(state_, rsema_, wsema_) { + this.$val = this; + if (arguments.length === 0) { + this.state = new $Uint64(0, 0); + this.rsema = 0; + this.wsema = 0; + return; + } + this.state = state_; + this.rsema = rsema_; + this.wsema = wsema_; + }); + FD = $pkg.FD = $newType(0, $kindStruct, "poll.FD", true, "internal/poll", true, function(fdmu_, Sysfd_, pd_, iovecs_, csema_, isBlocking_, IsStream_, ZeroReadIsEOF_, isFile_) { + this.$val = this; + if (arguments.length === 0) { + this.fdmu = new fdMutex.ptr(new $Uint64(0, 0), 0, 0); + this.Sysfd = 0; + this.pd = new pollDesc.ptr(false); + this.iovecs = ptrType$6.nil; + this.csema = 0; + this.isBlocking = 0; + this.IsStream = false; + this.ZeroReadIsEOF = false; + this.isFile = false; + return; + } + this.fdmu = fdmu_; + this.Sysfd = Sysfd_; + this.pd = pd_; + this.iovecs = iovecs_; + this.csema = csema_; + this.isBlocking = isBlocking_; + this.IsStream = IsStream_; + this.ZeroReadIsEOF = ZeroReadIsEOF_; + this.isFile = isFile_; + }); + ptrType = $ptrType($Uint32); + chanType = $chanType($Bool, false, false); + sliceType = $sliceType(chanType); + ptrType$1 = $ptrType($Uint64); + ptrType$2 = $ptrType($Int32); + arrayType = $arrayType($Uint8, 4); + sliceType$2 = $sliceType(syscall.Iovec); + ptrType$6 = $ptrType(sliceType$2); + ptrType$7 = $ptrType($Uint8); + ptrType$8 = $ptrType(FD); + ptrType$9 = $ptrType(pollDesc); + ptrType$10 = $ptrType(TimeoutError); + ptrType$11 = $ptrType(fdMutex); + sliceType$3 = $sliceType($Uint8); + ptrType$12 = $ptrType(syscall.Stat_t); + funcType = $funcType([$Uintptr], [], false); + funcType$1 = $funcType([$Uintptr], [$Bool], false); + ptrType$13 = $ptrType(syscall.Linger); + ptrType$14 = $ptrType(syscall.IPMreqn); + ptrType$15 = $ptrType(syscall.IPMreq); + ptrType$16 = $ptrType(syscall.IPv6Mreq); + sliceType$4 = $sliceType(sliceType$3); + ptrType$17 = $ptrType(sliceType$4); + pollDesc.ptr.prototype.init = function(fd) { + var fd, pd; + pd = this; + return $ifaceNil; + }; + pollDesc.prototype.init = function(fd) { return this.$val.init(fd); }; + pollDesc.ptr.prototype.close = function() { + var pd; + pd = this; + }; + pollDesc.prototype.close = function() { return this.$val.close(); }; + pollDesc.ptr.prototype.evict = function() { + var pd; + pd = this; + pd.closing = true; + }; + pollDesc.prototype.evict = function() { return this.$val.evict(); }; + pollDesc.ptr.prototype.prepare = function(mode, isFile) { + var isFile, mode, pd; + pd = this; + if (pd.closing) { + return errClosing(isFile); + } + return $ifaceNil; + }; + pollDesc.prototype.prepare = function(mode, isFile) { return this.$val.prepare(mode, isFile); }; + pollDesc.ptr.prototype.prepareRead = function(isFile) { + var isFile, pd; + pd = this; + return pd.prepare(114, isFile); + }; + pollDesc.prototype.prepareRead = function(isFile) { return this.$val.prepareRead(isFile); }; + pollDesc.ptr.prototype.prepareWrite = function(isFile) { + var isFile, pd; + pd = this; + return pd.prepare(119, isFile); + }; + pollDesc.prototype.prepareWrite = function(isFile) { return this.$val.prepareWrite(isFile); }; + pollDesc.ptr.prototype.wait = function(mode, isFile) { + var isFile, mode, pd; + pd = this; + if (pd.closing) { + return errClosing(isFile); + } + return $pkg.ErrTimeout; + }; + pollDesc.prototype.wait = function(mode, isFile) { return this.$val.wait(mode, isFile); }; + pollDesc.ptr.prototype.waitRead = function(isFile) { + var isFile, pd; + pd = this; + return pd.wait(114, isFile); + }; + pollDesc.prototype.waitRead = function(isFile) { return this.$val.waitRead(isFile); }; + pollDesc.ptr.prototype.waitWrite = function(isFile) { + var isFile, pd; + pd = this; + return pd.wait(119, isFile); + }; + pollDesc.prototype.waitWrite = function(isFile) { return this.$val.waitWrite(isFile); }; + pollDesc.ptr.prototype.pollable = function() { + return true; + }; + pollDesc.prototype.pollable = function() { return this.$val.pollable(); }; + FD.ptr.prototype.SetDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; + FD.ptr.prototype.SetReadDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; + FD.ptr.prototype.SetWriteDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; + runtime_Semacquire = function(s) { + var _entry, _key, _r, ch, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; _r = $f._r; ch = $f.ch; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (s.$get() === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (s.$get() === 0) { */ case 1: + ch = new $Chan($Bool, 0); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: $append((_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil), ch) }; + _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r[0]; + /* } */ case 2: + s.$set(s.$get() - (1) >>> 0); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semacquire }; } $f._entry = _entry; $f._key = _key; $f._r = _r; $f.ch = ch; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_Semrelease = function(s) { + var _entry, _key, ch, s, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; ch = $f.ch; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s.$set(s.$get() + (1) >>> 0); + w = (_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil); + if (w.$length === 0) { + $s = -1; return; + } + ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); + w = $subslice(w, 1); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: w }; + if (w.$length === 0) { + delete semWaiters[ptrType.keyFor(s)]; + } + $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._key = _key; $f.ch = ch; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + errClosing = function(isFile) { + var isFile; + if (isFile) { + return $pkg.ErrFileClosing; + } + return $pkg.ErrNetClosing; + }; + TimeoutError.ptr.prototype.Error = function() { + var e; + e = this; + return "i/o timeout"; + }; + TimeoutError.prototype.Error = function() { return this.$val.Error(); }; + TimeoutError.ptr.prototype.Timeout = function() { + var e; + e = this; + return true; + }; + TimeoutError.prototype.Timeout = function() { return this.$val.Timeout(); }; + TimeoutError.ptr.prototype.Temporary = function() { + var e; + e = this; + return true; + }; + TimeoutError.prototype.Temporary = function() { return this.$val.Temporary(); }; + consume = function(v, n) { + var ln0, n, v, x, x$1, x$2, x$3; + while (true) { + if (!(v.$get().$length > 0)) { break; } + ln0 = (new $Int64(0, (x = v.$get(), (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])).$length)); + if ((ln0.$high > n.$high || (ln0.$high === n.$high && ln0.$low > n.$low))) { + (x$2 = v.$get(), (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0] = $subslice((x$1 = v.$get(), (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])), $flatten64(n)))); + return; + } + n = (x$3 = ln0, new $Int64(n.$high - x$3.$high, n.$low - x$3.$low)); + v.$set($subslice((v.$get()), 1)); + } + }; + FD.ptr.prototype.Fsync = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fsync(fd.Sysfd); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fsync }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fsync = function() { return this.$val.Fsync(); }; + fcntl = function(fd, cmd, arg) { + var _tuple, arg, cmd, e, fd, r; + _tuple = syscall.Syscall(72, ((fd >>> 0)), ((cmd >>> 0)), ((arg >>> 0))); + r = _tuple[0]; + e = _tuple[2]; + if (!((e === 0))) { + return [((r >> 0)), new syscall.Errno((e))]; + } + return [((r >> 0)), $ifaceNil]; + }; + fdMutex.ptr.prototype.incref = function() { + var mu, new$1, old, x, x$1; + mu = this; + while (true) { + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + return false; + } + new$1 = new $Uint64(old.$high + 0, old.$low + 8); + if ((x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); + } + if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { + return true; + } + } + }; + fdMutex.prototype.incref = function() { return this.$val.incref(); }; + fdMutex.ptr.prototype.increfAndClose = function() { + var mu, new$1, old, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; mu = $f.mu; new$1 = $f.new$1; old = $f.old; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + $s = -1; return false; + } + new$1 = (x$1 = new $Uint64(old.$high | 0, (old.$low | 1) >>> 0), new $Uint64(x$1.$high + 0, x$1.$low + 8)); + if ((x$2 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$2.$high === 0 && x$2.$low === 0))) { + $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); + } + new$1 = (x$3 = new $Uint64(2147483647, 4286578688), new $Uint64(new$1.$high & ~x$3.$high, (new$1.$low & ~x$3.$low) >>> 0)); + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + /* while (true) { */ case 5: + /* if (!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { break; } */ if(!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { $s = 6; continue; } + old = (x$5 = new $Uint64(0, 8388608), new $Uint64(old.$high - x$5.$high, old.$low - x$5.$low)); + $r = runtime_Semrelease((mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ $s = 5; continue; case 6: + /* while (true) { */ case 8: + /* if (!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { break; } */ if(!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { $s = 9; continue; } + old = (x$7 = new $Uint64(2048, 0), new $Uint64(old.$high - x$7.$high, old.$low - x$7.$low)); + $r = runtime_Semrelease((mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu)))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ $s = 8; continue; case 9: + $s = -1; return true; + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.increfAndClose }; } $f.mu = mu; $f.new$1 = new$1; $f.old = old; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.increfAndClose = function() { return this.$val.increfAndClose(); }; + fdMutex.ptr.prototype.decref = function() { + var mu, new$1, old, x, x$1; + mu = this; + while (true) { + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if ((x = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x.$high === 0 && x.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + new$1 = new $Uint64(old.$high - 0, old.$low - 8); + if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { + return (x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$1.$high === 0 && x$1.$low === 1)); + } + } + }; + fdMutex.prototype.decref = function() { return this.$val.decref(); }; + fdMutex.ptr.prototype.rwlock = function(read) { + var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + _tmp$2 = new $Uint64(0, 0); + mutexBit = _tmp; + mutexWait = _tmp$1; + mutexMask = _tmp$2; + mutexSema = ptrType.nil; + if (read) { + mutexBit = new $Uint64(0, 2); + mutexWait = new $Uint64(0, 8388608); + mutexMask = new $Uint64(2047, 4286578688); + mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); + } else { + mutexBit = new $Uint64(0, 4); + mutexWait = new $Uint64(2048, 0); + mutexMask = new $Uint64(2147481600, 0); + mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); + } + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + $s = -1; return false; + } + new$1 = new $Uint64(0, 0); + if ((x$1 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + new$1 = (x$2 = new $Uint64(old.$high | mutexBit.$high, (old.$low | mutexBit.$low) >>> 0), new $Uint64(x$2.$high + 0, x$2.$low + 8)); + if ((x$3 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$3.$high === 0 && x$3.$low === 0))) { + $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); + } + } else { + new$1 = new $Uint64(old.$high + mutexWait.$high, old.$low + mutexWait.$low); + if ((x$4 = new $Uint64(new$1.$high & mutexMask.$high, (new$1.$low & mutexMask.$low) >>> 0), (x$4.$high === 0 && x$4.$low === 0))) { + $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); + } + } + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + if ((x$5 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0))) { + $s = -1; return true; + } + $r = runtime_Semacquire(mutexSema); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.rwlock = function(read) { return this.$val.rwlock(read); }; + fdMutex.ptr.prototype.rwunlock = function(read) { + var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, x$6, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + _tmp$2 = new $Uint64(0, 0); + mutexBit = _tmp; + mutexWait = _tmp$1; + mutexMask = _tmp$2; + mutexSema = ptrType.nil; + if (read) { + mutexBit = new $Uint64(0, 2); + mutexWait = new $Uint64(0, 8388608); + mutexMask = new $Uint64(2047, 4286578688); + mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); + } else { + mutexBit = new $Uint64(0, 4); + mutexWait = new $Uint64(2048, 0); + mutexMask = new $Uint64(2147481600, 0); + mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); + } + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if ((x = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x.$high === 0 && x.$low === 0)) || (x$1 = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + new$1 = (x$2 = new $Uint64(old.$high & ~mutexBit.$high, (old.$low & ~mutexBit.$low) >>> 0), new $Uint64(x$2.$high - 0, x$2.$low - 8)); + if (!((x$3 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$3.$high === 0 && x$3.$low === 0)))) { + new$1 = (x$4 = mutexWait, new $Uint64(new$1.$high - x$4.$high, new$1.$low - x$4.$low)); + } + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + /* */ if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { */ case 5: + $r = runtime_Semrelease(mutexSema); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + $s = -1; return (x$6 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$6.$high === 0 && x$6.$low === 1)); + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwunlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.rwunlock = function(read) { return this.$val.rwunlock(read); }; + FD.ptr.prototype.incref = function() { + var fd; + fd = this; + if (!fd.fdmu.incref()) { + return errClosing(fd.isFile); + } + return $ifaceNil; + }; + FD.prototype.incref = function() { return this.$val.incref(); }; + FD.ptr.prototype.decref = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + /* */ if (fd.fdmu.decref()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (fd.fdmu.decref()) { */ case 1: + _r = fd.destroy(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.decref }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.decref = function() { return this.$val.decref(); }; + FD.ptr.prototype.readLock = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.readLock = function() { return this.$val.readLock(); }; + FD.ptr.prototype.readUnlock = function() { + var _r, _r$1, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwunlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.readUnlock = function() { return this.$val.readUnlock(); }; + FD.ptr.prototype.writeLock = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.writeLock = function() { return this.$val.writeLock(); }; + FD.ptr.prototype.writeUnlock = function() { + var _r, _r$1, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwunlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.writeUnlock = function() { return this.$val.writeUnlock(); }; + FD.ptr.prototype.eofError = function(n, err) { + var err, fd, n; + fd = this; + if ((n === 0) && $interfaceIsEqual(err, $ifaceNil) && fd.ZeroReadIsEOF) { + return io.EOF; + } + return err; + }; + FD.prototype.eofError = function(n, err) { return this.$val.eofError(n, err); }; + FD.ptr.prototype.Fchmod = function(mode) { + var err, fd, mode, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; mode = $f.mode; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchmod(fd.Sysfd, mode); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchmod }; } $f.err = err; $f.fd = fd; $f.mode = mode; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchmod = function(mode) { return this.$val.Fchmod(mode); }; + FD.ptr.prototype.Fchown = function(uid, gid) { + var err, fd, gid, uid, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; gid = $f.gid; uid = $f.uid; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchown(fd.Sysfd, uid, gid); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchown }; } $f.err = err; $f.fd = fd; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchown = function(uid, gid) { return this.$val.Fchown(uid, gid); }; + FD.ptr.prototype.Ftruncate = function(size) { + var err, fd, size, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; size = $f.size; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Ftruncate(fd.Sysfd, size); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Ftruncate }; } $f.err = err; $f.fd = fd; $f.size = size; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Ftruncate = function(size) { return this.$val.Ftruncate(size); }; + FD.ptr.prototype.Init = function(net, pollable) { + var err, fd, net, pollable; + fd = this; + if (net === "file") { + fd.isFile = true; + } + if (!pollable) { + fd.isBlocking = 1; + return $ifaceNil; + } + err = fd.pd.init(fd); + if (!($interfaceIsEqual(err, $ifaceNil))) { + fd.isBlocking = 1; + } + return err; + }; + FD.prototype.Init = function(net, pollable) { return this.$val.Init(net, pollable); }; + FD.ptr.prototype.destroy = function() { + var _r, err, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + fd.pd.close(); + _r = $pkg.CloseFunc(fd.Sysfd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + fd.Sysfd = -1; + $r = runtime_Semrelease((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.destroy }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.destroy = function() { return this.$val.destroy(); }; + FD.ptr.prototype.Close = function() { + var _r, _r$1, err, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.increfAndClose(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + fd.pd.evict(); + _r$1 = fd.decref(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err = _r$1; + /* */ if (fd.isBlocking === 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (fd.isBlocking === 0) { */ case 5: + $r = runtime_Semacquire((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Close }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.Close = function() { return this.$val.Close(); }; + FD.ptr.prototype.Shutdown = function(how) { + var err, fd, how, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; how = $f.how; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Shutdown(fd.Sysfd, how); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Shutdown }; } $f.err = err; $f.fd = fd; $f.how = how; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Shutdown = function(how) { return this.$val.Shutdown(how); }; + FD.ptr.prototype.SetBlocking = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + atomic.StoreUint32((fd.$ptr_isBlocking || (fd.$ptr_isBlocking = new ptrType(function() { return this.$target.isBlocking; }, function($v) { this.$target.isBlocking = $v; }, fd))), 1); + $s = -1; return syscall.SetNonblock(fd.Sysfd, false); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetBlocking }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetBlocking = function() { return this.$val.SetBlocking(); }; + FD.ptr.prototype.Read = function(p) { + var _r, _tuple, err, err$1, err$2, fd, n, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + if (p.$length === 0) { + $s = -1; return [0, $ifaceNil]; + } + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + if (fd.IsStream && p.$length > 1073741824) { + p = $subslice(p, 0, 1073741824); + } + while (true) { + _tuple = syscall.Read(fd.Sysfd, p); + n = _tuple[0]; + err$2 = _tuple[1]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + if (false && $interfaceIsEqual(err$2, new syscall.Errno(4))) { + continue; + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, err$2]; + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Read }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Read = function(p) { return this.$val.Read(p); }; + FD.ptr.prototype.Pread = function(p, off) { + var _r, _tuple, err, err$1, fd, n, off, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; off = $f.off; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + if (fd.IsStream && p.$length > 1073741824) { + p = $subslice(p, 0, 1073741824); + } + _tuple = syscall.Pread(fd.Sysfd, p, off); + n = _tuple[0]; + err$1 = _tuple[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + n = 0; + } + _r = fd.decref(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + err$1 = fd.eofError(n, err$1); + $s = -1; return [n, err$1]; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pread }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.off = off; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.Pread = function(p, off) { return this.$val.Pread(p, off); }; + FD.ptr.prototype.ReadFrom = function(p) { + var _r, _tuple, err, err$1, err$2, fd, n, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, $ifaceNil, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, $ifaceNil, err$1]; + } + while (true) { + _tuple = syscall.Recvfrom(fd.Sysfd, p, 0); + n = _tuple[0]; + sa = _tuple[1]; + err$2 = _tuple[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, sa, err$2]; + } + $s = -1; return [0, $ifaceNil, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadFrom }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadFrom = function(p) { return this.$val.ReadFrom(p); }; + FD.ptr.prototype.ReadMsg = function(p, oob) { + var _r, _tuple, err, err$1, err$2, fd, flags, n, oob, oobn, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; flags = $f.flags; n = $f.n; oob = $f.oob; oobn = $f.oobn; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, 0, 0, $ifaceNil, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, 0, 0, $ifaceNil, err$1]; + } + while (true) { + _tuple = syscall.Recvmsg(fd.Sysfd, p, oob, 0); + n = _tuple[0]; + oobn = _tuple[1]; + flags = _tuple[2]; + sa = _tuple[3]; + err$2 = _tuple[4]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, oobn, flags, sa, err$2]; + } + $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadMsg }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.flags = flags; $f.n = n; $f.oob = oob; $f.oobn = oobn; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadMsg = function(p, oob) { return this.$val.ReadMsg(p, oob); }; + FD.ptr.prototype.Write = function(p) { + var _r, _tuple, err, err$1, err$2, fd, max, n, nn, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + nn = 0; + while (true) { + max = p.$length; + if (fd.IsStream && (max - nn >> 0) > 1073741824) { + max = nn + 1073741824 >> 0; + } + _tuple = syscall.Write(fd.Sysfd, $subslice(p, nn, max)); + n = _tuple[0]; + err$2 = _tuple[1]; + if (n > 0) { + nn = nn + (n) >> 0; + } + if (nn === p.$length) { + $s = -1; return [nn, err$2]; + } + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [nn, err$2]; + } + if (n === 0) { + $s = -1; return [nn, io.ErrUnexpectedEOF]; + } + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Write }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Write = function(p) { return this.$val.Write(p); }; + FD.ptr.prototype.Pwrite = function(p, off) { + var _tuple, err, err$1, fd, max, n, nn, off, p, x, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; off = $f.off; p = $f.p; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + nn = 0; + while (true) { + max = p.$length; + if (fd.IsStream && (max - nn >> 0) > 1073741824) { + max = nn + 1073741824 >> 0; + } + _tuple = syscall.Pwrite(fd.Sysfd, $subslice(p, nn, max), (x = (new $Int64(0, nn)), new $Int64(off.$high + x.$high, off.$low + x.$low))); + n = _tuple[0]; + err$1 = _tuple[1]; + if (n > 0) { + nn = nn + (n) >> 0; + } + if (nn === p.$length) { + $s = -1; return [nn, err$1]; + } + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [nn, err$1]; + } + if (n === 0) { + $s = -1; return [nn, io.ErrUnexpectedEOF]; + } + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pwrite }; } $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.off = off; $f.p = p; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Pwrite = function(p, off) { return this.$val.Pwrite(p, off); }; + FD.ptr.prototype.WriteTo = function(p, sa) { + var _r, _r$1, err, err$1, err$2, fd, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + /* while (true) { */ case 2: + _r$1 = syscall.Sendto(fd.Sysfd, p, 0, sa); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err$2 = _r$1; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [0, err$2]; + } + $s = -1; return [p.$length, $ifaceNil]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteTo }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteTo = function(p, sa) { return this.$val.WriteTo(p, sa); }; + FD.ptr.prototype.WriteMsg = function(p, oob, sa) { + var _r, _r$1, _tuple, err, err$1, err$2, fd, n, oob, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; oob = $f.oob; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, 0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, 0, err$1]; + } + /* while (true) { */ case 2: + _r$1 = syscall.SendmsgN(fd.Sysfd, p, oob, sa, 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err$2 = _tuple[1]; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [n, 0, err$2]; + } + $s = -1; return [n, oob.$length, err$2]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, 0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteMsg }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.oob = oob; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteMsg = function(p, oob, sa) { return this.$val.WriteMsg(p, oob, sa); }; + FD.ptr.prototype.Accept = function() { + var _1, _r, _r$1, _tuple, err, err$1, err$2, errcall, fd, rsa, s, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; errcall = $f.errcall; fd = $f.fd; rsa = $f.rsa; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "", err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "", err$1]; + } + /* while (true) { */ case 2: + _r$1 = accept(fd.Sysfd); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + s = _tuple[0]; + rsa = _tuple[1]; + errcall = _tuple[2]; + err$2 = _tuple[3]; + if ($interfaceIsEqual(err$2, $ifaceNil)) { + $s = -1; return [s, rsa, "", err$2]; + } + _1 = err$2; + if ($interfaceIsEqual(_1, new syscall.Errno((11)))) { + if (fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + } else if ($interfaceIsEqual(_1, new syscall.Errno((103)))) { + /* continue; */ $s = 2; continue; + } + $s = -1; return [-1, $ifaceNil, errcall, err$2]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, $ifaceNil, "", $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.errcall = errcall; $f.fd = fd; $f.rsa = rsa; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Accept = function() { return this.$val.Accept(); }; + FD.ptr.prototype.Seek = function(offset, whence) { + var err, fd, offset, whence, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; offset = $f.offset; whence = $f.whence; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Seek(fd.Sysfd, offset, whence); + /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Seek }; } $f.err = err; $f.fd = fd; $f.offset = offset; $f.whence = whence; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + FD.ptr.prototype.ReadDirent = function(buf) { + var _tuple, buf, err, err$1, fd, n, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; buf = $f.buf; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + while (true) { + _tuple = syscall.ReadDirent(fd.Sysfd, buf); + n = _tuple[0]; + err$1 = _tuple[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$1, new syscall.Errno(11)) && fd.pd.pollable()) { + err$1 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$1, $ifaceNil)) { + continue; + } + } + } + $s = -1; return [n, err$1]; + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadDirent }; } $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadDirent = function(buf) { return this.$val.ReadDirent(buf); }; + FD.ptr.prototype.Fchdir = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchdir(fd.Sysfd); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchdir }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchdir = function() { return this.$val.Fchdir(); }; + FD.ptr.prototype.Fstat = function(s) { + var err, fd, s, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fstat(fd.Sysfd, s); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fstat }; } $f.err = err; $f.fd = fd; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fstat = function(s) { return this.$val.Fstat(s); }; + DupCloseOnExec = function(fd) { + var _1, _r, _tuple, e1, fd, r0, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _tuple = $f._tuple; e1 = $f.e1; fd = $f.fd; r0 = $f.r0; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (atomic.LoadInt32((tryDupCloexec$24ptr || (tryDupCloexec$24ptr = new ptrType$2(function() { return tryDupCloexec; }, function($v) { tryDupCloexec = $v; })))) === 1) { + _tuple = fcntl(fd, 1030, 0); + r0 = _tuple[0]; + e1 = _tuple[1]; + if ($interfaceIsEqual(e1, $ifaceNil)) { + $s = -1; return [r0, "", $ifaceNil]; + } + _1 = $assertType(e1, syscall.Errno); + if ((_1 === (22)) || (_1 === (38))) { + atomic.StoreInt32((tryDupCloexec$24ptr || (tryDupCloexec$24ptr = new ptrType$2(function() { return tryDupCloexec; }, function($v) { tryDupCloexec = $v; }))), 0); + } else { + $s = -1; return [-1, "fcntl", e1]; + } + } + _r = dupCloseOnExecOld(fd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: DupCloseOnExec }; } $f._1 = _1; $f._r = _r; $f._tuple = _tuple; $f.e1 = e1; $f.fd = fd; $f.r0 = r0; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.DupCloseOnExec = DupCloseOnExec; + dupCloseOnExecOld = function(fd) { + var _tuple, err, fd, newfd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; err = $f.err; fd = $f.fd; newfd = $f.newfd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $r = syscall.ForkLock.RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(syscall.ForkLock, "RUnlock"), []]); + _tuple = syscall.Dup(fd); + newfd = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, "dup", err]; + } + syscall.CloseOnExec(newfd); + $s = -1; return [newfd, "", $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: dupCloseOnExecOld }; } $f._tuple = _tuple; $f.err = err; $f.fd = fd; $f.newfd = newfd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.ptr.prototype.Dup = function() { + var _r, err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, "", err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + _r = DupCloseOnExec(fd.Sysfd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Dup }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Dup = function() { return this.$val.Dup(); }; + FD.ptr.prototype.WaitWrite = function() { + var fd; + fd = this; + return fd.pd.waitWrite(fd.isFile); + }; + FD.prototype.WaitWrite = function() { return this.$val.WaitWrite(); }; + FD.ptr.prototype.WriteOnce = function(p) { + var _r, err, fd, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + $s = -1; return syscall.Write(fd.Sysfd, p); + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteOnce }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteOnce = function(p) { return this.$val.WriteOnce(p); }; + FD.ptr.prototype.RawControl = function(f) { + var err, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $r = f(((fd.Sysfd >>> 0))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawControl }; } $f.err = err; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawControl = function(f) { return this.$val.RawControl(f); }; + FD.ptr.prototype.RawRead = function(f) { + var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return err$1; + } + /* while (true) { */ case 2: + _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 5: + err$2 = fd.pd.waitRead(fd.isFile); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return err$2; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawRead }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawRead = function(f) { return this.$val.RawRead(f); }; + FD.ptr.prototype.RawWrite = function(f) { + var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return err$1; + } + /* while (true) { */ case 2: + _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 5: + err$2 = fd.pd.waitWrite(fd.isFile); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return err$2; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawWrite }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawWrite = function(f) { return this.$val.RawWrite(f); }; + writev = function(fd, iovecs) { + var _tuple, e, fd, iovecs, r; + _tuple = syscall.Syscall(20, ((fd >>> 0)), (($sliceToArray(iovecs))), ((iovecs.$length >>> 0))); + r = _tuple[0]; + e = _tuple[2]; + if (!((e === 0))) { + return [r, new syscall.Errno((e))]; + } + return [r, $ifaceNil]; + }; + accept = function(s) { + var _1, _r, _r$1, _r$2, _tuple, _tuple$1, err, ns, s, sa, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; err = $f.err; ns = $f.ns; s = $f.s; sa = $f.sa; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.Accept4Func(s, 526336); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ns = _tuple[0]; + sa = _tuple[1]; + err = _tuple[2]; + _1 = err; + if ($interfaceIsEqual(_1, $ifaceNil)) { + $s = -1; return [ns, sa, "", $ifaceNil]; + } else if ($interfaceIsEqual(_1, new syscall.Errno((38)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((22)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((13)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((14)))) { + } else { + $s = -1; return [-1, sa, "accept4", err]; + } + _r$1 = $pkg.AcceptFunc(s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + ns = _tuple$1[0]; + sa = _tuple$1[1]; + err = _tuple$1[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + syscall.CloseOnExec(ns); + } + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "accept", err]; + } + err = syscall.SetNonblock(ns, true); + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 3: + _r$2 = $pkg.CloseFunc(ns); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + $s = -1; return [-1, $ifaceNil, "setnonblock", err]; + /* } */ case 4: + $s = -1; return [ns, sa, "", $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.err = err; $f.ns = ns; $f.s = s; $f.sa = sa; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.ptr.prototype.SetsockoptInt = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptInt(fd.Sysfd, level, name, arg); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInt }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptInt = function(level, name, arg) { return this.$val.SetsockoptInt(level, name, arg); }; + FD.ptr.prototype.SetsockoptInet4Addr = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptInet4Addr(fd.Sysfd, level, name, $clone(arg, arrayType)); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInet4Addr }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptInet4Addr = function(level, name, arg) { return this.$val.SetsockoptInet4Addr(level, name, arg); }; + FD.ptr.prototype.SetsockoptLinger = function(level, name, l) { + var err, fd, l, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; l = $f.l; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptLinger(fd.Sysfd, level, name, l); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptLinger }; } $f.err = err; $f.fd = fd; $f.l = l; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptLinger = function(level, name, l) { return this.$val.SetsockoptLinger(level, name, l); }; + FD.ptr.prototype.SetsockoptIPMreqn = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPMreqn(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreqn }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPMreqn = function(level, name, mreq) { return this.$val.SetsockoptIPMreqn(level, name, mreq); }; + FD.ptr.prototype.SetsockoptByte = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptByte(fd.Sysfd, level, name, arg); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptByte }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptByte = function(level, name, arg) { return this.$val.SetsockoptByte(level, name, arg); }; + FD.ptr.prototype.SetsockoptIPMreq = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPMreq(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPMreq = function(level, name, mreq) { return this.$val.SetsockoptIPMreq(level, name, mreq); }; + FD.ptr.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPv6Mreq(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPv6Mreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { return this.$val.SetsockoptIPv6Mreq(level, name, mreq); }; + FD.ptr.prototype.Writev = function(v) { + var _i, _r, _ref, _tuple, chunk, err, err$1, err$2, fd, iovecs, maxVec, n, v, wrote, x, x$1, x$2, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; chunk = $f.chunk; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; iovecs = $f.iovecs; maxVec = $f.maxVec; n = $f.n; v = $f.v; wrote = $f.wrote; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + iovecs = [iovecs]; + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err$1]; + } + iovecs[0] = sliceType$2.nil; + if (!(fd.iovecs === ptrType$6.nil)) { + iovecs[0] = fd.iovecs.$get(); + } + maxVec = 1024; + n = new $Int64(0, 0); + err$2 = $ifaceNil; + /* while (true) { */ case 2: + /* if (!(v.$get().$length > 0)) { break; } */ if(!(v.$get().$length > 0)) { $s = 3; continue; } + iovecs[0] = $subslice(iovecs[0], 0, 0); + _ref = v.$get(); + _i = 0; + /* while (true) { */ case 4: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } + chunk = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (chunk.$length === 0) { + _i++; + /* continue; */ $s = 4; continue; + } + iovecs[0] = $append(iovecs[0], new syscall.Iovec.ptr($indexPtr(chunk.$array, chunk.$offset + 0, ptrType$7), new $Uint64(0, 0))); + if (fd.IsStream && chunk.$length > 1073741824) { + (x = iovecs[0].$length - 1 >> 0, ((x < 0 || x >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x])).SetLen(1073741824); + /* break; */ $s = 5; continue; + } + (x$1 = iovecs[0].$length - 1 >> 0, ((x$1 < 0 || x$1 >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x$1])).SetLen(chunk.$length); + if (iovecs[0].$length === maxVec) { + /* break; */ $s = 5; continue; + } + _i++; + /* } */ $s = 4; continue; case 5: + if (iovecs[0].$length === 0) { + /* break; */ $s = 3; continue; + } + fd.iovecs = (iovecs.$ptr || (iovecs.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, iovecs))); + wrote = 0; + _tuple = writev(fd.Sysfd, iovecs[0]); + wrote = _tuple[0]; + err$2 = _tuple[1]; + if (wrote === 4294967295) { + wrote = 0; + } + $r = $pkg.TestHookDidWritev(((wrote >> 0))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + n = (x$2 = (new $Int64(0, wrote.constructor === Number ? wrote : 1)), new $Int64(n.$high + x$2.$high, n.$low + x$2.$low)); + consume(v, (new $Int64(0, wrote.constructor === Number ? wrote : 1))); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + if ($assertType(err$2, syscall.Errno) === 11) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + /* break; */ $s = 3; continue; + } + if ((n.$high === 0 && n.$low === 0)) { + err$2 = io.ErrUnexpectedEOF; + /* break; */ $s = 3; continue; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return [n, err$2]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Writev }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.chunk = chunk; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.iovecs = iovecs; $f.maxVec = maxVec; $f.n = n; $f.v = v; $f.wrote = wrote; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Writev = function(v) { return this.$val.Writev(v); }; + ptrType$9.methods = [{prop: "init", name: "init", pkg: "internal/poll", typ: $funcType([ptrType$8], [$error], false)}, {prop: "close", name: "close", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "evict", name: "evict", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "prepare", name: "prepare", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "prepareRead", name: "prepareRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "prepareWrite", name: "prepareWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "wait", name: "wait", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "waitRead", name: "waitRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitWrite", name: "waitWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitCanceled", name: "waitCanceled", pkg: "internal/poll", typ: $funcType([$Int], [], false)}, {prop: "pollable", name: "pollable", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}]; + ptrType$10.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$11.methods = [{prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "increfAndClose", name: "increfAndClose", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "rwlock", name: "rwlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}, {prop: "rwunlock", name: "rwunlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}]; + ptrType$8.methods = [{prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "Fsync", name: "Fsync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readLock", name: "readLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readUnlock", name: "readUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "writeLock", name: "writeLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "writeUnlock", name: "writeUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "eofError", name: "eofError", pkg: "internal/poll", typ: $funcType([$Int, $error], [$error], false)}, {prop: "Fchmod", name: "Fchmod", pkg: "", typ: $funcType([$Uint32], [$error], false)}, {prop: "Fchown", name: "Fchown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Ftruncate", name: "Ftruncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([$String, $Bool], [$error], false)}, {prop: "destroy", name: "destroy", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Shutdown", name: "Shutdown", pkg: "", typ: $funcType([$Int], [$error], false)}, {prop: "SetBlocking", name: "SetBlocking", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Pread", name: "Pread", pkg: "", typ: $funcType([sliceType$3, $Int64], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([sliceType$3], [$Int, syscall.Sockaddr, $error], false)}, {prop: "ReadMsg", name: "ReadMsg", pkg: "", typ: $funcType([sliceType$3, sliceType$3], [$Int, $Int, $Int, syscall.Sockaddr, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Pwrite", name: "Pwrite", pkg: "", typ: $funcType([sliceType$3, $Int64], [$Int, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([sliceType$3, syscall.Sockaddr], [$Int, $error], false)}, {prop: "WriteMsg", name: "WriteMsg", pkg: "", typ: $funcType([sliceType$3, sliceType$3, syscall.Sockaddr], [$Int, $Int, $error], false)}, {prop: "Accept", name: "Accept", pkg: "", typ: $funcType([], [$Int, syscall.Sockaddr, $String, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "ReadDirent", name: "ReadDirent", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Fchdir", name: "Fchdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Fstat", name: "Fstat", pkg: "", typ: $funcType([ptrType$12], [$error], false)}, {prop: "Dup", name: "Dup", pkg: "", typ: $funcType([], [$Int, $String, $error], false)}, {prop: "WaitWrite", name: "WaitWrite", pkg: "", typ: $funcType([], [$error], false)}, {prop: "WriteOnce", name: "WriteOnce", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "RawControl", name: "RawControl", pkg: "", typ: $funcType([funcType], [$error], false)}, {prop: "RawRead", name: "RawRead", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "RawWrite", name: "RawWrite", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "SetsockoptInt", name: "SetsockoptInt", pkg: "", typ: $funcType([$Int, $Int, $Int], [$error], false)}, {prop: "SetsockoptInet4Addr", name: "SetsockoptInet4Addr", pkg: "", typ: $funcType([$Int, $Int, arrayType], [$error], false)}, {prop: "SetsockoptLinger", name: "SetsockoptLinger", pkg: "", typ: $funcType([$Int, $Int, ptrType$13], [$error], false)}, {prop: "SetsockoptIPMreqn", name: "SetsockoptIPMreqn", pkg: "", typ: $funcType([$Int, $Int, ptrType$14], [$error], false)}, {prop: "SetsockoptByte", name: "SetsockoptByte", pkg: "", typ: $funcType([$Int, $Int, $Uint8], [$error], false)}, {prop: "SetsockoptIPMreq", name: "SetsockoptIPMreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$15], [$error], false)}, {prop: "SetsockoptIPv6Mreq", name: "SetsockoptIPv6Mreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$16], [$error], false)}, {prop: "Writev", name: "Writev", pkg: "", typ: $funcType([ptrType$17], [$Int64, $error], false)}]; + pollDesc.init("internal/poll", [{prop: "closing", name: "closing", embedded: false, exported: false, typ: $Bool, tag: ""}]); + TimeoutError.init("", []); + fdMutex.init("internal/poll", [{prop: "state", name: "state", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "rsema", name: "rsema", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "wsema", name: "wsema", embedded: false, exported: false, typ: $Uint32, tag: ""}]); + FD.init("internal/poll", [{prop: "fdmu", name: "fdmu", embedded: false, exported: false, typ: fdMutex, tag: ""}, {prop: "Sysfd", name: "Sysfd", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "pd", name: "pd", embedded: false, exported: false, typ: pollDesc, tag: ""}, {prop: "iovecs", name: "iovecs", embedded: false, exported: false, typ: ptrType$6, tag: ""}, {prop: "csema", name: "csema", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "isBlocking", name: "isBlocking", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "IsStream", name: "IsStream", embedded: false, exported: true, typ: $Bool, tag: ""}, {prop: "ZeroReadIsEOF", name: "ZeroReadIsEOF", embedded: false, exported: true, typ: $Bool, tag: ""}, {prop: "isFile", name: "isFile", embedded: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + semWaiters = {}; + $pkg.ErrNetClosing = errors.New("use of closed network connection"); + $pkg.ErrFileClosing = errors.New("use of closed file"); + $pkg.ErrNoDeadline = errors.New("file type does not support deadline"); + $pkg.ErrTimeout = new TimeoutError.ptr(); + $pkg.TestHookDidWritev = (function(wrote) { + var wrote; + }); + tryDupCloexec = 1; + $pkg.Accept4Func = syscall.Accept4; + $pkg.CloseFunc = syscall.Close; + $pkg.AcceptFunc = syscall.Accept; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/syscall/unix"] = (function() { + var $pkg = {}, $init, atomic, syscall, IsNonblock; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + IsNonblock = function(fd) { + var _tmp, _tmp$1, err, fd, nonblocking; + nonblocking = false; + err = $ifaceNil; + _tmp = false; + _tmp$1 = $ifaceNil; + nonblocking = _tmp; + err = _tmp$1; + return [nonblocking, err]; + }; + $pkg.IsNonblock = IsNonblock; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = atomic.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/testlog"] = (function() { + var $pkg = {}, $init, atomic, Interface, ptrType, logger, Logger, Stat; + atomic = $packages["sync/atomic"]; + Interface = $pkg.Interface = $newType(8, $kindInterface, "testlog.Interface", true, "internal/testlog", true, null); + ptrType = $ptrType(Interface); + Logger = function() { + var impl; + impl = logger.Load(); + if ($interfaceIsEqual(impl, $ifaceNil)) { + return $ifaceNil; + } + return $assertType(impl, ptrType).$get(); + }; + $pkg.Logger = Logger; + Stat = function(name) { + var log, name, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; log = $f.log; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + log = Logger(); + /* */ if (!($interfaceIsEqual(log, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(log, $ifaceNil))) { */ case 1: + $r = log.Stat(name); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Stat }; } $f.log = log; $f.name = name; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Stat = Stat; + Interface.init([{prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Getenv", name: "Getenv", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Open", name: "Open", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([$String], [], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = atomic.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + logger = new atomic.Value.ptr($ifaceNil); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["os"] = (function() { + var $pkg = {}, $init, errors, js, poll, unix, testlog, io, runtime, sync, atomic, syscall, time, dirInfo, timeout, PathError, SyscallError, LinkError, file, rawConn, File, FileInfo, FileMode, fileStat, sliceType, ptrType, sliceType$1, ptrType$1, sliceType$2, ptrType$2, ptrType$3, ptrType$4, sliceType$5, ptrType$12, arrayType$1, ptrType$13, funcType$1, ptrType$15, arrayType$6, ptrType$16, funcType$2, funcType$3, ptrType$18, errFinished, lstat, runtime_args, init, runtime_beforeExit, NewSyscallError, IsNotExist, underlyingError, wrapSyscallError, isNotExist, sigpipe, syscallMode, NewFile, newFile, epipecheck, basename, init$1, Exit, newRawConn, Lstat, fillFileStatFromSys, timespecToTime, lstatNolog; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + poll = $packages["internal/poll"]; + unix = $packages["internal/syscall/unix"]; + testlog = $packages["internal/testlog"]; + io = $packages["io"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + time = $packages["time"]; + dirInfo = $pkg.dirInfo = $newType(0, $kindStruct, "os.dirInfo", true, "os", false, function(buf_, nbuf_, bufp_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = sliceType$2.nil; + this.nbuf = 0; + this.bufp = 0; + return; + } + this.buf = buf_; + this.nbuf = nbuf_; + this.bufp = bufp_; + }); + timeout = $pkg.timeout = $newType(8, $kindInterface, "os.timeout", true, "os", false, null); + PathError = $pkg.PathError = $newType(0, $kindStruct, "os.PathError", true, "os", true, function(Op_, Path_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = ""; + this.Path = ""; + this.Err = $ifaceNil; + return; + } + this.Op = Op_; + this.Path = Path_; + this.Err = Err_; + }); + SyscallError = $pkg.SyscallError = $newType(0, $kindStruct, "os.SyscallError", true, "os", true, function(Syscall_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Syscall = ""; + this.Err = $ifaceNil; + return; + } + this.Syscall = Syscall_; + this.Err = Err_; + }); + LinkError = $pkg.LinkError = $newType(0, $kindStruct, "os.LinkError", true, "os", true, function(Op_, Old_, New_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = ""; + this.Old = ""; + this.New = ""; + this.Err = $ifaceNil; + return; + } + this.Op = Op_; + this.Old = Old_; + this.New = New_; + this.Err = Err_; + }); + file = $pkg.file = $newType(0, $kindStruct, "os.file", true, "os", false, function(pfd_, name_, dirinfo_, nonblock_, stdoutOrErr_) { + this.$val = this; + if (arguments.length === 0) { + this.pfd = new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), 0, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, 0, false, false, false); + this.name = ""; + this.dirinfo = ptrType$1.nil; + this.nonblock = false; + this.stdoutOrErr = false; + return; + } + this.pfd = pfd_; + this.name = name_; + this.dirinfo = dirinfo_; + this.nonblock = nonblock_; + this.stdoutOrErr = stdoutOrErr_; + }); + rawConn = $pkg.rawConn = $newType(0, $kindStruct, "os.rawConn", true, "os", false, function(file_) { + this.$val = this; + if (arguments.length === 0) { + this.file = ptrType.nil; + return; + } + this.file = file_; + }); + File = $pkg.File = $newType(0, $kindStruct, "os.File", true, "os", true, function(file_) { + this.$val = this; + if (arguments.length === 0) { + this.file = ptrType$13.nil; + return; + } + this.file = file_; + }); + FileInfo = $pkg.FileInfo = $newType(8, $kindInterface, "os.FileInfo", true, "os", true, null); + FileMode = $pkg.FileMode = $newType(4, $kindUint32, "os.FileMode", true, "os", true, null); + fileStat = $pkg.fileStat = $newType(0, $kindStruct, "os.fileStat", true, "os", false, function(name_, size_, mode_, modTime_, sys_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.size = new $Int64(0, 0); + this.mode = 0; + this.modTime = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil); + this.sys = new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero()); + return; + } + this.name = name_; + this.size = size_; + this.mode = mode_; + this.modTime = modTime_; + this.sys = sys_; + }); + sliceType = $sliceType($String); + ptrType = $ptrType(File); + sliceType$1 = $sliceType(FileInfo); + ptrType$1 = $ptrType(dirInfo); + sliceType$2 = $sliceType($Uint8); + ptrType$2 = $ptrType(PathError); + ptrType$3 = $ptrType(LinkError); + ptrType$4 = $ptrType(SyscallError); + sliceType$5 = $sliceType(syscall.Iovec); + ptrType$12 = $ptrType(sliceType$5); + arrayType$1 = $arrayType($Int64, 3); + ptrType$13 = $ptrType(file); + funcType$1 = $funcType([ptrType$13], [$error], false); + ptrType$15 = $ptrType(time.Location); + arrayType$6 = $arrayType($Uint8, 32); + ptrType$16 = $ptrType(fileStat); + funcType$2 = $funcType([$Uintptr], [], false); + funcType$3 = $funcType([$Uintptr], [$Bool], false); + ptrType$18 = $ptrType(rawConn); + runtime_args = function() { + return $pkg.Args; + }; + init = function() { + var argv, i, process; + process = $global.process; + if (!(process === undefined)) { + argv = process.argv; + $pkg.Args = $makeSlice(sliceType, ($parseInt(argv.length) - 1 >> 0)); + i = 0; + while (true) { + if (!(i < ($parseInt(argv.length) - 1 >> 0))) { break; } + ((i < 0 || i >= $pkg.Args.$length) ? ($throwRuntimeError("index out of range"), undefined) : $pkg.Args.$array[$pkg.Args.$offset + i] = $internalize(argv[(i + 1 >> 0)], $String)); + i = i + (1) >> 0; + } + } + if ($pkg.Args.$length === 0) { + $pkg.Args = new sliceType(["?"]); + } + }; + runtime_beforeExit = function() { + }; + File.ptr.prototype.Readdir = function(n) { + var _r, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return [sliceType$1.nil, $pkg.ErrInvalid]; + } + _r = f.readdir(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdir }; } $f._r = _r; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Readdir = function(n) { return this.$val.Readdir(n); }; + File.ptr.prototype.Readdirnames = function(n) { + var _r, _tmp, _tmp$1, _tuple, err, f, n, names, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f === ptrType.nil) { + _tmp = sliceType.nil; + _tmp$1 = $pkg.ErrInvalid; + names = _tmp; + err = _tmp$1; + $s = -1; return [names, err]; + } + _r = f.readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + names = _tuple[0]; + err = _tuple[1]; + $s = -1; return [names, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Readdirnames = function(n) { return this.$val.Readdirnames(n); }; + dirInfo.ptr.prototype.close = function() { + var d; + d = this; + }; + dirInfo.prototype.close = function() { return this.$val.close(); }; + File.ptr.prototype.readdirnames = function(n) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, d, err, errno, f, n, names, nb, nc, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; d = $f.d; err = $f.err; errno = $f.errno; f = $f.f; n = $f.n; names = $f.names; nb = $f.nb; nc = $f.nc; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f.file.dirinfo === ptrType$1.nil) { + f.file.dirinfo = new dirInfo.ptr(sliceType$2.nil, 0, 0); + f.file.dirinfo.buf = $makeSlice(sliceType$2, 8192); + } + d = f.file.dirinfo; + size = n; + if (size <= 0) { + size = 100; + n = -1; + } + names = $makeSlice(sliceType, 0, size); + /* while (true) { */ case 1: + /* if (!(!((n === 0)))) { break; } */ if(!(!((n === 0)))) { $s = 2; continue; } + /* */ if (d.bufp >= d.nbuf) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (d.bufp >= d.nbuf) { */ case 3: + d.bufp = 0; + errno = $ifaceNil; + _r = f.file.pfd.ReadDirent(d.buf); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + d.nbuf = _tuple[0]; + errno = _tuple[1]; + runtime.KeepAlive(f); + if (!($interfaceIsEqual(errno, $ifaceNil))) { + _tmp = names; + _tmp$1 = wrapSyscallError("readdirent", errno); + names = _tmp; + err = _tmp$1; + $s = -1; return [names, err]; + } + if (d.nbuf <= 0) { + /* break; */ $s = 2; continue; + } + /* } */ case 4: + _tmp$2 = 0; + _tmp$3 = 0; + nb = _tmp$2; + nc = _tmp$3; + _tuple$1 = syscall.ParseDirent($subslice(d.buf, d.bufp, d.nbuf), n, names); + nb = _tuple$1[0]; + nc = _tuple$1[1]; + names = _tuple$1[2]; + d.bufp = d.bufp + (nb) >> 0; + n = n - (nc) >> 0; + /* } */ $s = 1; continue; case 2: + if (n >= 0 && (names.$length === 0)) { + _tmp$4 = names; + _tmp$5 = io.EOF; + names = _tmp$4; + err = _tmp$5; + $s = -1; return [names, err]; + } + _tmp$6 = names; + _tmp$7 = $ifaceNil; + names = _tmp$6; + err = _tmp$7; + $s = -1; return [names, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.d = d; $f.err = err; $f.errno = errno; $f.f = f; $f.n = n; $f.names = names; $f.nb = nb; $f.nc = nc; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.readdirnames = function(n) { return this.$val.readdirnames(n); }; + PathError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Op + " " + e.Path + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + PathError.prototype.Error = function() { return this.$val.Error(); }; + PathError.ptr.prototype.Timeout = function() { + var _r, _tuple, _v, e, ok, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _tuple = $assertType(e.Err, timeout, true); + t = _tuple[0]; + ok = _tuple[1]; + if (!(ok)) { _v = false; $s = 1; continue s; } + _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 1: + $s = -1; return _v; + /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + PathError.prototype.Timeout = function() { return this.$val.Timeout(); }; + SyscallError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Syscall + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + SyscallError.prototype.Error = function() { return this.$val.Error(); }; + SyscallError.ptr.prototype.Timeout = function() { + var _r, _tuple, _v, e, ok, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _tuple = $assertType(e.Err, timeout, true); + t = _tuple[0]; + ok = _tuple[1]; + if (!(ok)) { _v = false; $s = 1; continue s; } + _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 1: + $s = -1; return _v; + /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + SyscallError.prototype.Timeout = function() { return this.$val.Timeout(); }; + NewSyscallError = function(syscall$1, err) { + var err, syscall$1; + if ($interfaceIsEqual(err, $ifaceNil)) { + return $ifaceNil; + } + return new SyscallError.ptr(syscall$1, err); + }; + $pkg.NewSyscallError = NewSyscallError; + IsNotExist = function(err) { + var err; + return isNotExist(err); + }; + $pkg.IsNotExist = IsNotExist; + underlyingError = function(err) { + var _ref, err, err$1, err$2, err$3; + _ref = err; + if ($assertType(_ref, ptrType$2, true)[1]) { + err$1 = _ref.$val; + return err$1.Err; + } else if ($assertType(_ref, ptrType$3, true)[1]) { + err$2 = _ref.$val; + return err$2.Err; + } else if ($assertType(_ref, ptrType$4, true)[1]) { + err$3 = _ref.$val; + return err$3.Err; + } + return err; + }; + wrapSyscallError = function(name, err) { + var _tuple, err, name, ok; + _tuple = $assertType(err, syscall.Errno, true); + ok = _tuple[1]; + if (ok) { + err = NewSyscallError(name, err); + } + return err; + }; + isNotExist = function(err) { + var err; + err = underlyingError(err); + return $interfaceIsEqual(err, new syscall.Errno(2)) || $interfaceIsEqual(err, $pkg.ErrNotExist); + }; + File.ptr.prototype.Name = function() { + var f; + f = this; + return f.file.name; + }; + File.prototype.Name = function() { return this.$val.Name(); }; + LinkError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Op + " " + e.Old + " " + e.New + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: LinkError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + LinkError.prototype.Error = function() { return this.$val.Error(); }; + File.ptr.prototype.Read = function(b) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("read"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + _r = f.read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + e = _tuple[1]; + _tmp$2 = n; + _tmp$3 = f.wrapErr("read", e); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Read = function(b) { return this.$val.Read(b); }; + File.ptr.prototype.ReadAt = function(b, off) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("read"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp$2 = 0; + _tmp$3 = new PathError.ptr("readat", f.file.name, errors.New("negative offset")); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* while (true) { */ case 1: + /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } + _r = f.pread(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("read", e); + /* break; */ $s = 2; continue; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); + /* } */ $s = 1; continue; case 2: + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.ReadAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; + File.ptr.prototype.Write = function(b) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("write"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + _r = f.write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + e = _tuple[1]; + if (n < 0) { + n = 0; + } + if (!((n === b.$length))) { + err = io.ErrShortWrite; + } + epipecheck(f, e); + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("write", e); + } + _tmp$2 = n; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Write = function(b) { return this.$val.Write(b); }; + File.ptr.prototype.WriteAt = function(b, off) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("write"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp$2 = 0; + _tmp$3 = new PathError.ptr("writeat", f.file.name, errors.New("negative offset")); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* while (true) { */ case 1: + /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } + _r = f.pwrite(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("write", e); + /* break; */ $s = 2; continue; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); + /* } */ $s = 1; continue; case 2: + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.WriteAt = function(b, off) { return this.$val.WriteAt(b, off); }; + File.ptr.prototype.Seek = function(offset, whence) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, e, err, err$1, f, offset, r, ret, whence, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; offset = $f.offset; r = $f.r; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + err$1 = f.checkValid("seek"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = new $Int64(0, 0); + _tmp$1 = err$1; + ret = _tmp; + err = _tmp$1; + $s = -1; return [ret, err]; + } + _r = f.seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + e = _tuple[1]; + if ($interfaceIsEqual(e, $ifaceNil) && !(f.file.dirinfo === ptrType$1.nil) && !((r.$high === 0 && r.$low === 0))) { + e = new syscall.Errno(21); + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp$2 = new $Int64(0, 0); + _tmp$3 = f.wrapErr("seek", e); + ret = _tmp$2; + err = _tmp$3; + $s = -1; return [ret, err]; + } + _tmp$4 = r; + _tmp$5 = $ifaceNil; + ret = _tmp$4; + err = _tmp$5; + $s = -1; return [ret, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.offset = offset; $f.r = r; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + File.ptr.prototype.WriteString = function(s) { + var _r, _tuple, err, f, n, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.Write((new sliceType$2($stringToBytes(s)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteString }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + File.ptr.prototype.wrapErr = function(op, err) { + var err, f, op; + f = this; + if ($interfaceIsEqual(err, $ifaceNil) || $interfaceIsEqual(err, io.EOF)) { + return err; + } + if ($interfaceIsEqual(err, poll.ErrFileClosing)) { + err = $pkg.ErrClosed; + } + return new PathError.ptr(op, f.file.name, err); + }; + File.prototype.wrapErr = function(op, err) { return this.$val.wrapErr(op, err); }; + File.ptr.prototype.Chmod = function(mode) { + var _r, f, mode, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = f.chmod(mode); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chmod }; } $f._r = _r; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chmod = function(mode) { return this.$val.Chmod(mode); }; + File.ptr.prototype.SetDeadline = function(t) { + var f, t; + f = this; + return f.setDeadline($clone(t, time.Time)); + }; + File.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; + File.ptr.prototype.SetReadDeadline = function(t) { + var f, t; + f = this; + return f.setReadDeadline($clone(t, time.Time)); + }; + File.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; + File.ptr.prototype.SetWriteDeadline = function(t) { + var f, t; + f = this; + return f.setWriteDeadline($clone(t, time.Time)); + }; + File.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; + File.ptr.prototype.SyscallConn = function() { + var _returncast, err, f; + f = this; + err = f.checkValid("SyscallConn"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [$ifaceNil, err]; + } + _returncast = newRawConn(f); + return [_returncast[0], _returncast[1]]; + }; + File.prototype.SyscallConn = function() { return this.$val.SyscallConn(); }; + sigpipe = function() { + $throwRuntimeError("native function not implemented: os.sigpipe"); + }; + syscallMode = function(i) { + var i, o; + o = 0; + o = (o | (((new FileMode(i).Perm() >>> 0)))) >>> 0; + if (!((((i & 8388608) >>> 0) === 0))) { + o = (o | (2048)) >>> 0; + } + if (!((((i & 4194304) >>> 0) === 0))) { + o = (o | (1024)) >>> 0; + } + if (!((((i & 1048576) >>> 0) === 0))) { + o = (o | (512)) >>> 0; + } + return o; + }; + File.ptr.prototype.chmod = function(mode) { + var _r, e, err, f, mode, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chmod"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchmod(syscallMode(mode)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chmod", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.chmod }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.chmod = function(mode) { return this.$val.chmod(mode); }; + File.ptr.prototype.Chown = function(uid, gid) { + var _r, e, err, f, gid, uid, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; gid = $f.gid; uid = $f.uid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chown"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchown(uid, gid); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chown", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chown }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chown = function(uid, gid) { return this.$val.Chown(uid, gid); }; + File.ptr.prototype.Truncate = function(size) { + var _r, e, err, f, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("truncate"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Ftruncate(size); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("truncate", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Truncate }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Truncate = function(size) { return this.$val.Truncate(size); }; + File.ptr.prototype.Sync = function() { + var _r, e, err, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("sync"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fsync(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("sync", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Sync }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Sync = function() { return this.$val.Sync(); }; + File.ptr.prototype.Chdir = function() { + var _r, e, err, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chdir"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchdir(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chdir", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chdir }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chdir = function() { return this.$val.Chdir(); }; + File.ptr.prototype.setDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetDeadline($clone(t, time.Time)); + }; + File.prototype.setDeadline = function(t) { return this.$val.setDeadline(t); }; + File.ptr.prototype.setReadDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetReadDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetReadDeadline($clone(t, time.Time)); + }; + File.prototype.setReadDeadline = function(t) { return this.$val.setReadDeadline(t); }; + File.ptr.prototype.setWriteDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetWriteDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetWriteDeadline($clone(t, time.Time)); + }; + File.prototype.setWriteDeadline = function(t) { return this.$val.setWriteDeadline(t); }; + File.ptr.prototype.checkValid = function(op) { + var f, op; + f = this; + if (f === ptrType.nil) { + return $pkg.ErrInvalid; + } + return $ifaceNil; + }; + File.prototype.checkValid = function(op) { return this.$val.checkValid(op); }; + File.ptr.prototype.Fd = function() { + var _r, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return 4294967295; + } + /* */ if (f.file.nonblock) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (f.file.nonblock) { */ case 1: + _r = f.file.pfd.SetBlocking(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + /* } */ case 2: + $s = -1; return ((f.file.pfd.Sysfd >>> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Fd }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Fd = function() { return this.$val.Fd(); }; + NewFile = function(fd, name) { + var _tuple, err, fd, kind, name, nb; + kind = 0; + _tuple = unix.IsNonblock(((fd >> 0))); + nb = _tuple[0]; + err = _tuple[1]; + if ($interfaceIsEqual(err, $ifaceNil) && nb) { + kind = 3; + } + return newFile(fd, name, kind); + }; + $pkg.NewFile = NewFile; + newFile = function(fd, name, kind) { + var _1, err, err$1, err$2, err$3, f, fd, fdi, kind, name, pollable, st; + fdi = ((fd >> 0)); + if (fdi < 0) { + return ptrType.nil; + } + f = new File.ptr(new file.ptr(new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), fdi, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, 0, true, true, false), name, ptrType$1.nil, false, (fdi === 1) || (fdi === 2))); + pollable = (kind === 1) || (kind === 2) || (kind === 3); + if (kind === 1) { + st = new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero()); + _1 = "linux"; + if (_1 === ("freebsd")) { + pollable = false; + } else if (_1 === ("dragonfly") || _1 === ("netbsd") || _1 === ("openbsd")) { + err = syscall.Fstat(fdi, st); + if ($interfaceIsEqual(err, $ifaceNil) && (((st.Mode & 61440) >>> 0) === 32768)) { + pollable = false; + } + } else if (_1 === ("darwin")) { + err$1 = syscall.Fstat(fdi, st); + if ($interfaceIsEqual(err$1, $ifaceNil) && ((((st.Mode & 61440) >>> 0) === 4096) || (((st.Mode & 61440) >>> 0) === 32768))) { + pollable = false; + } + } + } + err$2 = f.file.pfd.Init("file", pollable); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + } else if (pollable) { + err$3 = syscall.SetNonblock(fdi, true); + if ($interfaceIsEqual(err$3, $ifaceNil)) { + f.file.nonblock = true; + } + } + runtime.SetFinalizer(f.file, new funcType$1($methodExpr(ptrType$13, "close"))); + return f; + }; + epipecheck = function(file$1, e) { + var e, file$1; + if ($interfaceIsEqual(e, new syscall.Errno(32)) && file$1.file.stdoutOrErr) { + sigpipe(); + } + }; + File.ptr.prototype.Close = function() { + var _r, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return $pkg.ErrInvalid; + } + _r = f.file.close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Close }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Close = function() { return this.$val.Close(); }; + file.ptr.prototype.close = function() { + var _r, e, err, file$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; file$1 = $f.file$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + file$1 = this; + if (file$1 === ptrType$13.nil) { + $s = -1; return new syscall.Errno(22); + } + if (!(file$1.dirinfo === ptrType$1.nil)) { + file$1.dirinfo.close(); + } + err = $ifaceNil; + _r = file$1.pfd.Close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + if ($interfaceIsEqual(e, poll.ErrFileClosing)) { + e = $pkg.ErrClosed; + } + err = new PathError.ptr("close", file$1.name, e); + } + runtime.SetFinalizer(file$1, $ifaceNil); + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: file.ptr.prototype.close }; } $f._r = _r; $f.e = e; $f.err = err; $f.file$1 = file$1; $f.$s = $s; $f.$r = $r; return $f; + }; + file.prototype.close = function() { return this.$val.close(); }; + File.ptr.prototype.read = function(b) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.read = function(b) { return this.$val.read(b); }; + File.ptr.prototype.pread = function(b, off) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Pread(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pread }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.pread = function(b, off) { return this.$val.pread(b, off); }; + File.ptr.prototype.write = function(b) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.write = function(b) { return this.$val.write(b); }; + File.ptr.prototype.pwrite = function(b, off) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Pwrite(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pwrite }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.pwrite = function(b, off) { return this.$val.pwrite(b, off); }; + File.ptr.prototype.seek = function(offset, whence) { + var _r, _tmp, _tmp$1, _tuple, err, f, offset, ret, whence, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; offset = $f.offset; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + _r = f.file.pfd.Seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ret = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = ret; + _tmp$1 = err; + ret = _tmp; + err = _tmp$1; + $s = -1; return [ret, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.offset = offset; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.seek = function(offset, whence) { return this.$val.seek(offset, whence); }; + File.ptr.prototype.readdir = function(n) { + var _i, _r, _r$1, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, dirname, err, f, fi, filename, fip, lerr, n, names, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dirname = $f.dirname; err = $f.err; f = $f.f; fi = $f.fi; filename = $f.filename; fip = $f.fip; lerr = $f.lerr; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fi = sliceType$1.nil; + err = $ifaceNil; + f = this; + dirname = f.file.name; + if (dirname === "") { + dirname = "."; + } + _r = f.Readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + names = _tuple[0]; + err = _tuple[1]; + fi = $makeSlice(sliceType$1, 0, names.$length); + _ref = names; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + filename = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + _r$1 = lstat(dirname + "/" + filename); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + fip = _tuple$1[0]; + lerr = _tuple$1[1]; + if (IsNotExist(lerr)) { + _i++; + /* continue; */ $s = 2; continue; + } + if (!($interfaceIsEqual(lerr, $ifaceNil))) { + _tmp = fi; + _tmp$1 = lerr; + fi = _tmp; + err = _tmp$1; + $s = -1; return [fi, err]; + } + fi = $append(fi, fip); + _i++; + /* } */ $s = 2; continue; case 3: + if ((fi.$length === 0) && $interfaceIsEqual(err, $ifaceNil) && n > 0) { + err = io.EOF; + } + _tmp$2 = fi; + _tmp$3 = err; + fi = _tmp$2; + err = _tmp$3; + $s = -1; return [fi, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdir }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dirname = dirname; $f.err = err; $f.f = f; $f.fi = fi; $f.filename = filename; $f.fip = fip; $f.lerr = lerr; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.readdir = function(n) { return this.$val.readdir(n); }; + basename = function(name) { + var i, name; + i = name.length - 1 >> 0; + while (true) { + if (!(i > 0 && (name.charCodeAt(i) === 47))) { break; } + name = $substring(name, 0, i); + i = i - (1) >> 0; + } + i = i - (1) >> 0; + while (true) { + if (!(i >= 0)) { break; } + if (name.charCodeAt(i) === 47) { + name = $substring(name, (i + 1 >> 0)); + break; + } + i = i - (1) >> 0; + } + return name; + }; + init$1 = function() { + if (false) { + return; + } + $pkg.Args = runtime_args(); + }; + Exit = function(code) { + var code; + if (code === 0) { + runtime_beforeExit(); + } + syscall.Exit(code); + }; + $pkg.Exit = Exit; + rawConn.ptr.prototype.Control = function(f) { + var _r, c, err, err$1, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + err = c.file.checkValid("SyscallConn.Control"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = c.file.file.pfd.RawControl(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err$1 = _r; + runtime.KeepAlive(c.file); + $s = -1; return err$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Control }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + rawConn.prototype.Control = function(f) { return this.$val.Control(f); }; + rawConn.ptr.prototype.Read = function(f) { + var _r, c, err, err$1, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + err = c.file.checkValid("SyscallConn.Read"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = c.file.file.pfd.RawRead(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err$1 = _r; + runtime.KeepAlive(c.file); + $s = -1; return err$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Read }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + rawConn.prototype.Read = function(f) { return this.$val.Read(f); }; + rawConn.ptr.prototype.Write = function(f) { + var _r, c, err, err$1, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + err = c.file.checkValid("SyscallConn.Write"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = c.file.file.pfd.RawWrite(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err$1 = _r; + runtime.KeepAlive(c.file); + $s = -1; return err$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Write }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + rawConn.prototype.Write = function(f) { return this.$val.Write(f); }; + newRawConn = function(file$1) { + var file$1; + return [new rawConn.ptr(file$1), $ifaceNil]; + }; + Lstat = function(name) { + var name, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = testlog.Stat(name); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return lstatNolog(name); + /* */ } return; } if ($f === undefined) { $f = { $blk: Lstat }; } $f.name = name; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Lstat = Lstat; + fillFileStatFromSys = function(fs, name) { + var _1, fs, name; + fs.name = basename(name); + fs.size = fs.sys.Size; + time.Time.copy(fs.modTime, timespecToTime($clone(fs.sys.Mtim, syscall.Timespec))); + fs.mode = ((((fs.sys.Mode & 511) >>> 0) >>> 0)); + _1 = (fs.sys.Mode & 61440) >>> 0; + if (_1 === (24576)) { + fs.mode = (fs.mode | (67108864)) >>> 0; + } else if (_1 === (8192)) { + fs.mode = (fs.mode | (69206016)) >>> 0; + } else if (_1 === (16384)) { + fs.mode = (fs.mode | (2147483648)) >>> 0; + } else if (_1 === (4096)) { + fs.mode = (fs.mode | (33554432)) >>> 0; + } else if (_1 === (40960)) { + fs.mode = (fs.mode | (134217728)) >>> 0; + } else if (_1 === (32768)) { + } else if (_1 === (49152)) { + fs.mode = (fs.mode | (16777216)) >>> 0; + } + if (!((((fs.sys.Mode & 1024) >>> 0) === 0))) { + fs.mode = (fs.mode | (4194304)) >>> 0; + } + if (!((((fs.sys.Mode & 2048) >>> 0) === 0))) { + fs.mode = (fs.mode | (8388608)) >>> 0; + } + if (!((((fs.sys.Mode & 512) >>> 0) === 0))) { + fs.mode = (fs.mode | (1048576)) >>> 0; + } + }; + timespecToTime = function(ts) { + var ts; + return time.Unix((ts.Sec), (ts.Nsec)); + }; + File.ptr.prototype.Stat = function() { + var _r, err, f, fs, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; fs = $f.fs; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fs = [fs]; + f = this; + if (f === ptrType.nil) { + $s = -1; return [$ifaceNil, $pkg.ErrInvalid]; + } + fs[0] = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero())); + _r = f.file.pfd.Fstat(fs[0].sys); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [$ifaceNil, new PathError.ptr("stat", f.file.name, err)]; + } + fillFileStatFromSys(fs[0], f.file.name); + $s = -1; return [fs[0], $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Stat }; } $f._r = _r; $f.err = err; $f.f = f; $f.fs = fs; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Stat = function() { return this.$val.Stat(); }; + lstatNolog = function(name) { + var err, fs, name; + fs = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero())); + err = syscall.Lstat(name, fs.sys); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [$ifaceNil, new PathError.ptr("lstat", name, err)]; + } + fillFileStatFromSys(fs, name); + return [fs, $ifaceNil]; + }; + FileMode.prototype.String = function() { + var _i, _i$1, _ref, _ref$1, _rune, _rune$1, buf, c, c$1, i, i$1, m, w, y, y$1; + m = this.$val; + buf = arrayType$6.zero(); + w = 0; + _ref = "dalTLDpSugct?"; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + c = _rune[0]; + if (!((((m & (((y = (((31 - i >> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c << 24 >>> 24))); + w = w + (1) >> 0; + } + _i += _rune[1]; + } + if (w === 0) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + w = w + (1) >> 0; + } + _ref$1 = "rwxrwxrwx"; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.length)) { break; } + _rune$1 = $decodeRune(_ref$1, _i$1); + i$1 = _i$1; + c$1 = _rune$1[0]; + if (!((((m & (((y$1 = (((8 - i$1 >> 0) >>> 0)), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0) === 0))) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c$1 << 24 >>> 24))); + } else { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + } + w = w + (1) >> 0; + _i$1 += _rune$1[1]; + } + return ($bytesToString($subslice(new sliceType$2(buf), 0, w))); + }; + $ptrType(FileMode).prototype.String = function() { return new FileMode(this.$get()).String(); }; + FileMode.prototype.IsDir = function() { + var m; + m = this.$val; + return !((((m & 2147483648) >>> 0) === 0)); + }; + $ptrType(FileMode).prototype.IsDir = function() { return new FileMode(this.$get()).IsDir(); }; + FileMode.prototype.IsRegular = function() { + var m; + m = this.$val; + return ((m & 2401763328) >>> 0) === 0; + }; + $ptrType(FileMode).prototype.IsRegular = function() { return new FileMode(this.$get()).IsRegular(); }; + FileMode.prototype.Perm = function() { + var m; + m = this.$val; + return (m & 511) >>> 0; + }; + $ptrType(FileMode).prototype.Perm = function() { return new FileMode(this.$get()).Perm(); }; + fileStat.ptr.prototype.Name = function() { + var fs; + fs = this; + return fs.name; + }; + fileStat.prototype.Name = function() { return this.$val.Name(); }; + fileStat.ptr.prototype.IsDir = function() { + var fs; + fs = this; + return new FileMode(fs.Mode()).IsDir(); + }; + fileStat.prototype.IsDir = function() { return this.$val.IsDir(); }; + fileStat.ptr.prototype.Size = function() { + var fs; + fs = this; + return fs.size; + }; + fileStat.prototype.Size = function() { return this.$val.Size(); }; + fileStat.ptr.prototype.Mode = function() { + var fs; + fs = this; + return fs.mode; + }; + fileStat.prototype.Mode = function() { return this.$val.Mode(); }; + fileStat.ptr.prototype.ModTime = function() { + var fs; + fs = this; + return fs.modTime; + }; + fileStat.prototype.ModTime = function() { return this.$val.ModTime(); }; + fileStat.ptr.prototype.Sys = function() { + var fs; + fs = this; + return fs.sys; + }; + fileStat.prototype.Sys = function() { return this.$val.Sys(); }; + ptrType$1.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [], false)}]; + ptrType$2.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$13.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [$error], false)}]; + ptrType$18.methods = [{prop: "Control", name: "Control", pkg: "", typ: $funcType([funcType$2], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([funcType$3], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([funcType$3], [$error], false)}]; + ptrType.methods = [{prop: "Readdir", name: "Readdir", pkg: "", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "Readdirnames", name: "Readdirnames", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "readdirnames", name: "readdirnames", pkg: "os", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteAt", name: "WriteAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "wrapErr", name: "wrapErr", pkg: "os", typ: $funcType([$String, $error], [$error], false)}, {prop: "Chmod", name: "Chmod", pkg: "", typ: $funcType([FileMode], [$error], false)}, {prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SyscallConn", name: "SyscallConn", pkg: "", typ: $funcType([], [syscall.RawConn, $error], false)}, {prop: "chmod", name: "chmod", pkg: "os", typ: $funcType([FileMode], [$error], false)}, {prop: "Chown", name: "Chown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Sync", name: "Sync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "setDeadline", name: "setDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setReadDeadline", name: "setReadDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setWriteDeadline", name: "setWriteDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "checkValid", name: "checkValid", pkg: "os", typ: $funcType([$String], [$error], false)}, {prop: "Fd", name: "Fd", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "read", name: "read", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pread", name: "pread", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "write", name: "write", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pwrite", name: "pwrite", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "seek", name: "seek", pkg: "os", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "readdir", name: "readdir", pkg: "os", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([], [FileInfo, $error], false)}]; + FileMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsRegular", name: "IsRegular", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([], [FileMode], false)}]; + ptrType$16.methods = [{prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]; + dirInfo.init("os", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "nbuf", name: "nbuf", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "bufp", name: "bufp", embedded: false, exported: false, typ: $Int, tag: ""}]); + timeout.init([{prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]); + PathError.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Path", name: "Path", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); + SyscallError.init("", [{prop: "Syscall", name: "Syscall", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); + LinkError.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Old", name: "Old", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); + file.init("os", [{prop: "pfd", name: "pfd", embedded: false, exported: false, typ: poll.FD, tag: ""}, {prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "dirinfo", name: "dirinfo", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "nonblock", name: "nonblock", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "stdoutOrErr", name: "stdoutOrErr", embedded: false, exported: false, typ: $Bool, tag: ""}]); + rawConn.init("os", [{prop: "file", name: "file", embedded: false, exported: false, typ: ptrType, tag: ""}]); + File.init("os", [{prop: "file", name: "file", embedded: true, exported: false, typ: ptrType$13, tag: ""}]); + FileInfo.init([{prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]); + fileStat.init("os", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "size", name: "size", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "mode", name: "mode", embedded: false, exported: false, typ: FileMode, tag: ""}, {prop: "modTime", name: "modTime", embedded: false, exported: false, typ: time.Time, tag: ""}, {prop: "sys", name: "sys", embedded: false, exported: false, typ: syscall.Stat_t, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = poll.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unix.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = testlog.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Args = sliceType.nil; + $pkg.ErrInvalid = errors.New("invalid argument"); + $pkg.ErrPermission = errors.New("permission denied"); + $pkg.ErrExist = errors.New("file already exists"); + $pkg.ErrNotExist = errors.New("file does not exist"); + $pkg.ErrClosed = errors.New("file already closed"); + errFinished = errors.New("os: process already finished"); + $pkg.Stdin = NewFile(((syscall.Stdin >>> 0)), "/dev/stdin"); + $pkg.Stdout = NewFile(((syscall.Stdout >>> 0)), "/dev/stdout"); + $pkg.Stderr = NewFile(((syscall.Stderr >>> 0)), "/dev/stderr"); + lstat = Lstat; + init(); + init$1(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["fmt"] = (function() { + var $pkg = {}, $init, errors, fmtsort, io, math, os, reflect, strconv, sync, utf8, fmtFlags, fmt, State, Formatter, Stringer, GoStringer, buffer, pp, ScanState, scanError, ss, ssave, sliceType, ptrType, ptrType$1, arrayType, arrayType$1, sliceType$1, sliceType$2, arrayType$2, ptrType$2, ptrType$5, ptrType$25, funcType, ppFree, space, ssFree, complexError, boolError, newPrinter, Fprintf, Sprintf, Errorf, Fprint, Sprint, Sprintln, getField, tooLarge, parsenum, intFromArg, parseArgNumber, isSpace, notSpace, indexRune; + errors = $packages["errors"]; + fmtsort = $packages["internal/fmtsort"]; + io = $packages["io"]; + math = $packages["math"]; + os = $packages["os"]; + reflect = $packages["reflect"]; + strconv = $packages["strconv"]; + sync = $packages["sync"]; + utf8 = $packages["unicode/utf8"]; + fmtFlags = $pkg.fmtFlags = $newType(0, $kindStruct, "fmt.fmtFlags", true, "fmt", false, function(widPresent_, precPresent_, minus_, plus_, sharp_, space_, zero_, plusV_, sharpV_) { + this.$val = this; + if (arguments.length === 0) { + this.widPresent = false; + this.precPresent = false; + this.minus = false; + this.plus = false; + this.sharp = false; + this.space = false; + this.zero = false; + this.plusV = false; + this.sharpV = false; + return; + } + this.widPresent = widPresent_; + this.precPresent = precPresent_; + this.minus = minus_; + this.plus = plus_; + this.sharp = sharp_; + this.space = space_; + this.zero = zero_; + this.plusV = plusV_; + this.sharpV = sharpV_; + }); + fmt = $pkg.fmt = $newType(0, $kindStruct, "fmt.fmt", true, "fmt", false, function(buf_, fmtFlags_, wid_, prec_, intbuf_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = ptrType$1.nil; + this.fmtFlags = new fmtFlags.ptr(false, false, false, false, false, false, false, false, false); + this.wid = 0; + this.prec = 0; + this.intbuf = arrayType.zero(); + return; + } + this.buf = buf_; + this.fmtFlags = fmtFlags_; + this.wid = wid_; + this.prec = prec_; + this.intbuf = intbuf_; + }); + State = $pkg.State = $newType(8, $kindInterface, "fmt.State", true, "fmt", true, null); + Formatter = $pkg.Formatter = $newType(8, $kindInterface, "fmt.Formatter", true, "fmt", true, null); + Stringer = $pkg.Stringer = $newType(8, $kindInterface, "fmt.Stringer", true, "fmt", true, null); + GoStringer = $pkg.GoStringer = $newType(8, $kindInterface, "fmt.GoStringer", true, "fmt", true, null); + buffer = $pkg.buffer = $newType(12, $kindSlice, "fmt.buffer", true, "fmt", false, null); + pp = $pkg.pp = $newType(0, $kindStruct, "fmt.pp", true, "fmt", false, function(buf_, arg_, value_, fmt_, reordered_, goodArgNum_, panicking_, erroring_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = buffer.nil; + this.arg = $ifaceNil; + this.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + this.fmt = new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()); + this.reordered = false; + this.goodArgNum = false; + this.panicking = false; + this.erroring = false; + return; + } + this.buf = buf_; + this.arg = arg_; + this.value = value_; + this.fmt = fmt_; + this.reordered = reordered_; + this.goodArgNum = goodArgNum_; + this.panicking = panicking_; + this.erroring = erroring_; + }); + ScanState = $pkg.ScanState = $newType(8, $kindInterface, "fmt.ScanState", true, "fmt", true, null); + scanError = $pkg.scanError = $newType(0, $kindStruct, "fmt.scanError", true, "fmt", false, function(err_) { + this.$val = this; + if (arguments.length === 0) { + this.err = $ifaceNil; + return; + } + this.err = err_; + }); + ss = $pkg.ss = $newType(0, $kindStruct, "fmt.ss", true, "fmt", false, function(rs_, buf_, count_, atEOF_, ssave_) { + this.$val = this; + if (arguments.length === 0) { + this.rs = $ifaceNil; + this.buf = buffer.nil; + this.count = 0; + this.atEOF = false; + this.ssave = new ssave.ptr(false, false, false, 0, 0, 0); + return; + } + this.rs = rs_; + this.buf = buf_; + this.count = count_; + this.atEOF = atEOF_; + this.ssave = ssave_; + }); + ssave = $pkg.ssave = $newType(0, $kindStruct, "fmt.ssave", true, "fmt", false, function(validSave_, nlIsEnd_, nlIsSpace_, argLimit_, limit_, maxWid_) { + this.$val = this; + if (arguments.length === 0) { + this.validSave = false; + this.nlIsEnd = false; + this.nlIsSpace = false; + this.argLimit = 0; + this.limit = 0; + this.maxWid = 0; + return; + } + this.validSave = validSave_; + this.nlIsEnd = nlIsEnd_; + this.nlIsSpace = nlIsSpace_; + this.argLimit = argLimit_; + this.limit = limit_; + this.maxWid = maxWid_; + }); + sliceType = $sliceType($emptyInterface); + ptrType = $ptrType(reflect.rtype); + ptrType$1 = $ptrType(buffer); + arrayType = $arrayType($Uint8, 68); + arrayType$1 = $arrayType($Uint16, 2); + sliceType$1 = $sliceType(arrayType$1); + sliceType$2 = $sliceType($Uint8); + arrayType$2 = $arrayType($Uint8, 5); + ptrType$2 = $ptrType(pp); + ptrType$5 = $ptrType(ss); + ptrType$25 = $ptrType(fmt); + funcType = $funcType([$Int32], [$Bool], false); + fmt.ptr.prototype.clearflags = function() { + var f; + f = this; + fmtFlags.copy(f.fmtFlags, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false)); + }; + fmt.prototype.clearflags = function() { return this.$val.clearflags(); }; + fmt.ptr.prototype.init = function(buf) { + var buf, f; + f = this; + f.buf = buf; + f.clearflags(); + }; + fmt.prototype.init = function(buf) { return this.$val.init(buf); }; + fmt.ptr.prototype.writePadding = function(n) { + var _i, _ref, buf, f, i, n, newLen, oldLen, padByte, padding; + f = this; + if (n <= 0) { + return; + } + buf = f.buf.$get(); + oldLen = buf.$length; + newLen = oldLen + n >> 0; + if (newLen > buf.$capacity) { + buf = $makeSlice(buffer, (($imul(buf.$capacity, 2)) + n >> 0)); + $copySlice(buf, f.buf.$get()); + } + padByte = 32; + if (f.fmtFlags.zero) { + padByte = 48; + } + padding = $subslice(buf, oldLen, newLen); + _ref = padding; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= padding.$length) ? ($throwRuntimeError("index out of range"), undefined) : padding.$array[padding.$offset + i] = padByte); + _i++; + } + f.buf.$set($subslice(buf, 0, newLen)); + }; + fmt.prototype.writePadding = function(n) { return this.$val.writePadding(n); }; + fmt.ptr.prototype.pad = function(b) { + var b, f, width; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.Write(b); + return; + } + width = f.wid - utf8.RuneCount(b) >> 0; + if (!f.fmtFlags.minus) { + f.writePadding(width); + f.buf.Write(b); + } else { + f.buf.Write(b); + f.writePadding(width); + } + }; + fmt.prototype.pad = function(b) { return this.$val.pad(b); }; + fmt.ptr.prototype.padString = function(s) { + var f, s, width; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.WriteString(s); + return; + } + width = f.wid - utf8.RuneCountInString(s) >> 0; + if (!f.fmtFlags.minus) { + f.writePadding(width); + f.buf.WriteString(s); + } else { + f.buf.WriteString(s); + f.writePadding(width); + } + }; + fmt.prototype.padString = function(s) { return this.$val.padString(s); }; + fmt.ptr.prototype.fmtBoolean = function(v) { + var f, v; + f = this; + if (v) { + f.padString("true"); + } else { + f.padString("false"); + } + }; + fmt.prototype.fmtBoolean = function(v) { return this.$val.fmtBoolean(v); }; + fmt.ptr.prototype.fmtUnicode = function(u) { + var buf, f, i, oldZero, prec, u, width; + f = this; + buf = $subslice(new sliceType$2(f.intbuf), 0); + prec = 4; + if (f.fmtFlags.precPresent && f.prec > 4) { + prec = f.prec; + width = (((2 + prec >> 0) + 2 >> 0) + 4 >> 0) + 1 >> 0; + if (width > buf.$length) { + buf = $makeSlice(sliceType$2, width); + } + } + i = buf.$length; + if (f.fmtFlags.sharp && (u.$high < 0 || (u.$high === 0 && u.$low <= 1114111)) && strconv.IsPrint(((u.$low >> 0)))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); + i = i - (utf8.RuneLen(((u.$low >> 0)))) >> 0; + utf8.EncodeRune($subslice(buf, i), ((u.$low >> 0))); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); + } + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); + prec = prec - (1) >> 0; + u = $shiftRightUint64(u, (4)); + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(u))); + prec = prec - (1) >> 0; + while (true) { + if (!(prec > 0)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + prec = prec - (1) >> 0; + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 85); + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.pad($subslice(buf, i)); + f.fmtFlags.zero = oldZero; + }; + fmt.prototype.fmtUnicode = function(u) { return this.$val.fmtUnicode(u); }; + fmt.ptr.prototype.fmtInteger = function(u, base, isSigned, digits) { + var _1, _2, base, buf, digits, f, i, isSigned, negative, next, oldZero, oldZero$1, prec, u, width, x, x$1, x$2, x$3, x$4; + f = this; + negative = isSigned && (x = (new $Int64(u.$high, u.$low)), (x.$high < 0 || (x.$high === 0 && x.$low < 0))); + if (negative) { + u = new $Uint64(-u.$high, -u.$low); + } + buf = $subslice(new sliceType$2(f.intbuf), 0); + if (f.fmtFlags.widPresent || f.fmtFlags.precPresent) { + width = (3 + f.wid >> 0) + f.prec >> 0; + if (width > buf.$length) { + buf = $makeSlice(sliceType$2, width); + } + } + prec = 0; + if (f.fmtFlags.precPresent) { + prec = f.prec; + if ((prec === 0) && (u.$high === 0 && u.$low === 0)) { + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.writePadding(f.wid); + f.fmtFlags.zero = oldZero; + return; + } + } else if (f.fmtFlags.zero && f.fmtFlags.widPresent) { + prec = f.wid; + if (negative || f.fmtFlags.plus || f.fmtFlags.space) { + prec = prec - (1) >> 0; + } + } + i = buf.$length; + _1 = base; + if (_1 === (10)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 10)))) { break; } + i = i - (1) >> 0; + next = $div64(u, new $Uint64(0, 10), false); + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$1 = new $Uint64(0 + u.$high, 48 + u.$low), x$2 = $mul64(next, new $Uint64(0, 10)), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)).$low << 24 >>> 24))); + u = next; + } + } else if (_1 === (16)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); + u = $shiftRightUint64(u, (4)); + } + } else if (_1 === (8)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 8)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$3 = new $Uint64(u.$high & 0, (u.$low & 7) >>> 0), new $Uint64(0 + x$3.$high, 48 + x$3.$low)).$low << 24 >>> 24))); + u = $shiftRightUint64(u, (3)); + } + } else if (_1 === (2)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 2)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$4 = new $Uint64(u.$high & 0, (u.$low & 1) >>> 0), new $Uint64(0 + x$4.$high, 48 + x$4.$low)).$low << 24 >>> 24))); + u = $shiftRightUint64(u, (1)); + } + } else { + $panic(new $String("fmt: unknown base; can't happen")); + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(u))); + while (true) { + if (!(i > 0 && prec > (buf.$length - i >> 0))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + if (f.fmtFlags.sharp) { + _2 = base; + if (_2 === (8)) { + if (!((((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i]) === 48))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + } else if (_2 === (16)) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt(16)); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + } + if (negative) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 45); + } else if (f.fmtFlags.plus) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); + } else if (f.fmtFlags.space) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); + } + oldZero$1 = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.pad($subslice(buf, i)); + f.fmtFlags.zero = oldZero$1; + }; + fmt.prototype.fmtInteger = function(u, base, isSigned, digits) { return this.$val.fmtInteger(u, base, isSigned, digits); }; + fmt.ptr.prototype.truncateString = function(s) { + var _i, _ref, _rune, f, i, n, s; + f = this; + if (f.fmtFlags.precPresent) { + n = f.prec; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + n = n - (1) >> 0; + if (n < 0) { + return $substring(s, 0, i); + } + _i += _rune[1]; + } + } + return s; + }; + fmt.prototype.truncateString = function(s) { return this.$val.truncateString(s); }; + fmt.ptr.prototype.truncate = function(b) { + var _tuple, b, f, i, n, wid; + f = this; + if (f.fmtFlags.precPresent) { + n = f.prec; + i = 0; + while (true) { + if (!(i < b.$length)) { break; } + n = n - (1) >> 0; + if (n < 0) { + return $subslice(b, 0, i); + } + wid = 1; + if (((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) >= 128) { + _tuple = utf8.DecodeRune($subslice(b, i)); + wid = _tuple[1]; + } + i = i + (wid) >> 0; + } + } + return b; + }; + fmt.prototype.truncate = function(b) { return this.$val.truncate(b); }; + fmt.ptr.prototype.fmtS = function(s) { + var f, s; + f = this; + s = f.truncateString(s); + f.padString(s); + }; + fmt.prototype.fmtS = function(s) { return this.$val.fmtS(s); }; + fmt.ptr.prototype.fmtBs = function(b) { + var b, f; + f = this; + b = f.truncate(b); + f.pad(b); + }; + fmt.prototype.fmtBs = function(b) { return this.$val.fmtBs(b); }; + fmt.ptr.prototype.fmtSbx = function(s, b, digits) { + var b, buf, c, digits, f, i, length, s, width; + f = this; + length = b.$length; + if (b === sliceType$2.nil) { + length = s.length; + } + if (f.fmtFlags.precPresent && f.prec < length) { + length = f.prec; + } + width = $imul(2, length); + if (width > 0) { + if (f.fmtFlags.space) { + if (f.fmtFlags.sharp) { + width = $imul(width, (2)); + } + width = width + ((length - 1 >> 0)) >> 0; + } else if (f.fmtFlags.sharp) { + width = width + (2) >> 0; + } + } else { + if (f.fmtFlags.widPresent) { + f.writePadding(f.wid); + } + return; + } + if (f.fmtFlags.widPresent && f.wid > width && !f.fmtFlags.minus) { + f.writePadding(f.wid - width >> 0); + } + buf = f.buf.$get(); + if (f.fmtFlags.sharp) { + buf = $append(buf, 48, digits.charCodeAt(16)); + } + c = 0; + i = 0; + while (true) { + if (!(i < length)) { break; } + if (f.fmtFlags.space && i > 0) { + buf = $append(buf, 32); + if (f.fmtFlags.sharp) { + buf = $append(buf, 48, digits.charCodeAt(16)); + } + } + if (!(b === sliceType$2.nil)) { + c = ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]); + } else { + c = s.charCodeAt(i); + } + buf = $append(buf, digits.charCodeAt((c >>> 4 << 24 >>> 24)), digits.charCodeAt(((c & 15) >>> 0))); + i = i + (1) >> 0; + } + f.buf.$set(buf); + if (f.fmtFlags.widPresent && f.wid > width && f.fmtFlags.minus) { + f.writePadding(f.wid - width >> 0); + } + }; + fmt.prototype.fmtSbx = function(s, b, digits) { return this.$val.fmtSbx(s, b, digits); }; + fmt.ptr.prototype.fmtSx = function(s, digits) { + var digits, f, s; + f = this; + f.fmtSbx(s, sliceType$2.nil, digits); + }; + fmt.prototype.fmtSx = function(s, digits) { return this.$val.fmtSx(s, digits); }; + fmt.ptr.prototype.fmtBx = function(b, digits) { + var b, digits, f; + f = this; + f.fmtSbx("", b, digits); + }; + fmt.prototype.fmtBx = function(b, digits) { return this.$val.fmtBx(b, digits); }; + fmt.ptr.prototype.fmtQ = function(s) { + var buf, f, s; + f = this; + s = f.truncateString(s); + if (f.fmtFlags.sharp && strconv.CanBackquote(s)) { + f.padString("`" + s + "`"); + return; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + if (f.fmtFlags.plus) { + f.pad(strconv.AppendQuoteToASCII(buf, s)); + } else { + f.pad(strconv.AppendQuote(buf, s)); + } + }; + fmt.prototype.fmtQ = function(s) { return this.$val.fmtQ(s); }; + fmt.ptr.prototype.fmtC = function(c) { + var buf, c, f, r, w; + f = this; + r = ((c.$low >> 0)); + if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { + r = 65533; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + w = utf8.EncodeRune($subslice(buf, 0, 4), r); + f.pad($subslice(buf, 0, w)); + }; + fmt.prototype.fmtC = function(c) { return this.$val.fmtC(c); }; + fmt.ptr.prototype.fmtQc = function(c) { + var buf, c, f, r; + f = this; + r = ((c.$low >> 0)); + if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { + r = 65533; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + if (f.fmtFlags.plus) { + f.pad(strconv.AppendQuoteRuneToASCII(buf, r)); + } else { + f.pad(strconv.AppendQuoteRune(buf, r)); + } + }; + fmt.prototype.fmtQc = function(c) { return this.$val.fmtQc(c); }; + fmt.ptr.prototype.fmtFloat = function(v, size, verb, prec) { + var _1, _2, digits, f, hasDecimalPoint, i, num, oldZero, prec, size, tail, tailBuf, v, verb; + f = this; + if (f.fmtFlags.precPresent) { + prec = f.prec; + } + num = strconv.AppendFloat($subslice(new sliceType$2(f.intbuf), 0, 1), v, ((verb << 24 >>> 24)), prec, size); + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 45) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 43)) { + num = $subslice(num, 1); + } else { + (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 43); + } + if (f.fmtFlags.space && ((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43) && !f.fmtFlags.plus) { + (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 32); + } + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 73) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78)) { + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78) && !f.fmtFlags.space && !f.fmtFlags.plus) { + num = $subslice(num, 1); + } + f.pad(num); + f.fmtFlags.zero = oldZero; + return; + } + if (f.fmtFlags.sharp && !((verb === 98))) { + digits = 0; + _1 = verb; + if ((_1 === (118)) || (_1 === (103)) || (_1 === (71))) { + digits = prec; + if (digits === -1) { + digits = 6; + } + } + tailBuf = arrayType$2.zero(); + tail = $subslice(new sliceType$2(tailBuf), 0, 0); + hasDecimalPoint = false; + i = 1; + while (true) { + if (!(i < num.$length)) { break; } + _2 = ((i < 0 || i >= num.$length) ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + i]); + if (_2 === (46)) { + hasDecimalPoint = true; + } else if ((_2 === (101)) || (_2 === (69))) { + tail = $appendSlice(tail, $subslice(num, i)); + num = $subslice(num, 0, i); + } else { + digits = digits - (1) >> 0; + } + i = i + (1) >> 0; + } + if (!hasDecimalPoint) { + num = $append(num, 46); + } + while (true) { + if (!(digits > 0)) { break; } + num = $append(num, 48); + digits = digits - (1) >> 0; + } + num = $appendSlice(num, tail); + } + if (f.fmtFlags.plus || !(((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43))) { + if (f.fmtFlags.zero && f.fmtFlags.widPresent && f.wid > num.$length) { + f.buf.WriteByte((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0])); + f.writePadding(f.wid - num.$length >> 0); + f.buf.Write($subslice(num, 1)); + return; + } + f.pad(num); + return; + } + f.pad($subslice(num, 1)); + }; + fmt.prototype.fmtFloat = function(v, size, verb, prec) { return this.$val.fmtFloat(v, size, verb, prec); }; + $ptrType(buffer).prototype.Write = function(p) { + var b, p; + b = this; + b.$set($appendSlice(b.$get(), p)); + }; + $ptrType(buffer).prototype.WriteString = function(s) { + var b, s; + b = this; + b.$set($appendSlice(b.$get(), s)); + }; + $ptrType(buffer).prototype.WriteByte = function(c) { + var b, c; + b = this; + b.$set($append(b.$get(), c)); + }; + $ptrType(buffer).prototype.WriteRune = function(r) { + var b, bp, n, r, w, x; + bp = this; + if (r < 128) { + bp.$set($append(bp.$get(), ((r << 24 >>> 24)))); + return; + } + b = bp.$get(); + n = b.$length; + while (true) { + if (!((n + 4 >> 0) > b.$capacity)) { break; } + b = $append(b, 0); + } + w = utf8.EncodeRune((x = $subslice(b, n, (n + 4 >> 0)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)), r); + bp.$set($subslice(b, 0, (n + w >> 0))); + }; + newPrinter = function() { + var _r, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = ppFree.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = $assertType(_r, ptrType$2); + p.panicking = false; + p.erroring = false; + p.fmt.init((p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p)))); + $s = -1; return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: newPrinter }; } $f._r = _r; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.ptr.prototype.free = function() { + var p; + p = this; + if (p.buf.$capacity > 65536) { + return; + } + p.buf = $subslice(p.buf, 0, 0); + p.arg = $ifaceNil; + p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + ppFree.Put(p); + }; + pp.prototype.free = function() { return this.$val.free(); }; + pp.ptr.prototype.Width = function() { + var _tmp, _tmp$1, ok, p, wid; + wid = 0; + ok = false; + p = this; + _tmp = p.fmt.wid; + _tmp$1 = p.fmt.fmtFlags.widPresent; + wid = _tmp; + ok = _tmp$1; + return [wid, ok]; + }; + pp.prototype.Width = function() { return this.$val.Width(); }; + pp.ptr.prototype.Precision = function() { + var _tmp, _tmp$1, ok, p, prec; + prec = 0; + ok = false; + p = this; + _tmp = p.fmt.prec; + _tmp$1 = p.fmt.fmtFlags.precPresent; + prec = _tmp; + ok = _tmp$1; + return [prec, ok]; + }; + pp.prototype.Precision = function() { return this.$val.Precision(); }; + pp.ptr.prototype.Flag = function(b) { + var _1, b, p; + p = this; + _1 = b; + if (_1 === (45)) { + return p.fmt.fmtFlags.minus; + } else if (_1 === (43)) { + return p.fmt.fmtFlags.plus || p.fmt.fmtFlags.plusV; + } else if (_1 === (35)) { + return p.fmt.fmtFlags.sharp || p.fmt.fmtFlags.sharpV; + } else if (_1 === (32)) { + return p.fmt.fmtFlags.space; + } else if (_1 === (48)) { + return p.fmt.fmtFlags.zero; + } + return false; + }; + pp.prototype.Flag = function(b) { return this.$val.Flag(b); }; + pp.ptr.prototype.Write = function(b) { + var _tmp, _tmp$1, b, err, p, ret; + ret = 0; + err = $ifaceNil; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(b); + _tmp = b.$length; + _tmp$1 = $ifaceNil; + ret = _tmp; + err = _tmp$1; + return [ret, err]; + }; + pp.prototype.Write = function(b) { return this.$val.Write(b); }; + pp.ptr.prototype.WriteString = function(s) { + var _tmp, _tmp$1, err, p, ret, s; + ret = 0; + err = $ifaceNil; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(s); + _tmp = s.length; + _tmp$1 = $ifaceNil; + ret = _tmp; + err = _tmp$1; + return [ret, err]; + }; + pp.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + Fprintf = function(w, format, a) { + var _r, _r$1, _tuple, a, err, format, n, p, w, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintf }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Fprintf = Fprintf; + Sprintf = function(format, a) { + var _r, a, format, p, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; format = $f.format; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + s = ($bytesToString(p.buf)); + p.free(); + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintf }; } $f._r = _r; $f.a = a; $f.format = format; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sprintf = Sprintf; + Errorf = function(format, a) { + var _r, _r$1, a, format, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; a = $f.a; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = Sprintf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = errors.New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Errorf }; } $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.format = format; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Errorf = Errorf; + Fprint = function(w, a) { + var _r, _r$1, _tuple, a, err, n, p, w, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrint(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprint }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Fprint = Fprint; + Sprint = function(a) { + var _r, a, p, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrint(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + s = ($bytesToString(p.buf)); + p.free(); + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sprint }; } $f._r = _r; $f.a = a; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sprint = Sprint; + Sprintln = function(a) { + var _r, a, p, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintln(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + s = ($bytesToString(p.buf)); + p.free(); + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintln }; } $f._r = _r; $f.a = a; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sprintln = Sprintln; + getField = function(v, i) { + var _r, _r$1, i, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(v, reflect.Value).Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + val = _r; + /* */ if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { */ case 2: + _r$1 = $clone(val, reflect.Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + val = _r$1; + /* } */ case 3: + $s = -1; return val; + /* */ } return; } if ($f === undefined) { $f = { $blk: getField }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + tooLarge = function(x) { + var x; + return x > 1000000 || x < -1000000; + }; + parsenum = function(s, start, end) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, end, isnum, newi, num, s, start; + num = 0; + isnum = false; + newi = 0; + if (start >= end) { + _tmp = 0; + _tmp$1 = false; + _tmp$2 = end; + num = _tmp; + isnum = _tmp$1; + newi = _tmp$2; + return [num, isnum, newi]; + } + newi = start; + while (true) { + if (!(newi < end && 48 <= s.charCodeAt(newi) && s.charCodeAt(newi) <= 57)) { break; } + if (tooLarge(num)) { + _tmp$3 = 0; + _tmp$4 = false; + _tmp$5 = end; + num = _tmp$3; + isnum = _tmp$4; + newi = _tmp$5; + return [num, isnum, newi]; + } + num = ($imul(num, 10)) + (((s.charCodeAt(newi) - 48 << 24 >>> 24) >> 0)) >> 0; + isnum = true; + newi = newi + (1) >> 0; + } + return [num, isnum, newi]; + }; + pp.ptr.prototype.unknownType = function(v) { + var _r, p, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + if (!$clone(v, reflect.Value).IsValid()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); + _r = $clone(v, reflect.Value).Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.unknownType }; } $f._r = _r; $f.p = p; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.unknownType = function(v) { return this.$val.unknownType(v); }; + pp.ptr.prototype.badVerb = function(verb) { + var _r, _r$1, p, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.erroring = true; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + /* */ if (!($interfaceIsEqual(p.arg, $ifaceNil))) { $s = 2; continue; } + /* */ if ($clone(p.value, reflect.Value).IsValid()) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!($interfaceIsEqual(p.arg, $ifaceNil))) { */ case 2: + _r = reflect.TypeOf(p.arg).String(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printArg(p.arg, 118); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 5; continue; + /* } else if ($clone(p.value, reflect.Value).IsValid()) { */ case 3: + _r$1 = $clone(p.value, reflect.Value).Type().String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printValue($clone(p.value, reflect.Value), 118, 0); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 5; continue; + /* } else { */ case 4: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + /* } */ case 5: + case 1: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + p.erroring = false; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.badVerb }; } $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.badVerb = function(verb) { return this.$val.badVerb(verb); }; + pp.ptr.prototype.fmtBool = function(v, verb) { + var _1, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (116)) || (_1 === (118))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (116)) || (_1 === (118))) { */ case 2: + p.fmt.fmtBoolean(v); + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBool }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtBool = function(v, verb) { return this.$val.fmtBool(v, verb); }; + pp.ptr.prototype.fmt0x64 = function(v, leading0x) { + var leading0x, p, sharp, v; + p = this; + sharp = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = leading0x; + p.fmt.fmtInteger(v, 16, false, "0123456789abcdefx"); + p.fmt.fmtFlags.sharp = sharp; + }; + pp.prototype.fmt0x64 = function(v, leading0x) { return this.$val.fmt0x64(v, leading0x); }; + pp.ptr.prototype.fmtInteger = function(v, isSigned, verb) { + var _1, isSigned, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; isSigned = $f.isSigned; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if (_1 === (100)) { $s = 3; continue; } + /* */ if (_1 === (98)) { $s = 4; continue; } + /* */ if (_1 === (111)) { $s = 5; continue; } + /* */ if (_1 === (120)) { $s = 6; continue; } + /* */ if (_1 === (88)) { $s = 7; continue; } + /* */ if (_1 === (99)) { $s = 8; continue; } + /* */ if (_1 === (113)) { $s = 9; continue; } + /* */ if (_1 === (85)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_1 === (118)) { */ case 2: + if (p.fmt.fmtFlags.sharpV && !isSigned) { + p.fmt0x64(v, true); + } else { + p.fmt.fmtInteger(v, 10, isSigned, "0123456789abcdefx"); + } + $s = 12; continue; + /* } else if (_1 === (100)) { */ case 3: + p.fmt.fmtInteger(v, 10, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (98)) { */ case 4: + p.fmt.fmtInteger(v, 2, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (111)) { */ case 5: + p.fmt.fmtInteger(v, 8, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (120)) { */ case 6: + p.fmt.fmtInteger(v, 16, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (88)) { */ case 7: + p.fmt.fmtInteger(v, 16, isSigned, "0123456789ABCDEFX"); + $s = 12; continue; + /* } else if (_1 === (99)) { */ case 8: + p.fmt.fmtC(v); + $s = 12; continue; + /* } else if (_1 === (113)) { */ case 9: + /* */ if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 13: + p.fmt.fmtQc(v); + $s = 15; continue; + /* } else { */ case 14: + $r = p.badVerb(verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 15: + $s = 12; continue; + /* } else if (_1 === (85)) { */ case 10: + p.fmt.fmtUnicode(v); + $s = 12; continue; + /* } else { */ case 11: + $r = p.badVerb(verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 12: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtInteger }; } $f._1 = _1; $f.isSigned = isSigned; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtInteger = function(v, isSigned, verb) { return this.$val.fmtInteger(v, isSigned, verb); }; + pp.ptr.prototype.fmtFloat = function(v, size, verb) { + var _1, p, size, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { $s = 3; continue; } + /* */ if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { $s = 4; continue; } + /* */ if (_1 === (70)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_1 === (118)) { */ case 2: + p.fmt.fmtFloat(v, size, 103, -1); + $s = 7; continue; + /* } else if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { */ case 3: + p.fmt.fmtFloat(v, size, verb, -1); + $s = 7; continue; + /* } else if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { */ case 4: + p.fmt.fmtFloat(v, size, verb, 6); + $s = 7; continue; + /* } else if (_1 === (70)) { */ case 5: + p.fmt.fmtFloat(v, size, 102, 6); + $s = 7; continue; + /* } else { */ case 6: + $r = p.badVerb(verb); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 7: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat }; } $f._1 = _1; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtFloat = function(v, size, verb) { return this.$val.fmtFloat(v, size, verb); }; + pp.ptr.prototype.fmtComplex = function(v, size, verb) { + var _1, _q, _q$1, oldPlus, p, size, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; oldPlus = $f.oldPlus; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { */ case 2: + oldPlus = p.fmt.fmtFlags.plus; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + $r = p.fmtFloat(v.$real, (_q = size / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + p.fmt.fmtFlags.plus = true; + $r = p.fmtFloat(v.$imag, (_q$1 = size / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("i)"); + p.fmt.fmtFlags.plus = oldPlus; + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f.oldPlus = oldPlus; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtComplex = function(v, size, verb) { return this.$val.fmtComplex(v, size, verb); }; + pp.ptr.prototype.fmtString = function(v, verb) { + var _1, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if (_1 === (115)) { $s = 3; continue; } + /* */ if (_1 === (120)) { $s = 4; continue; } + /* */ if (_1 === (88)) { $s = 5; continue; } + /* */ if (_1 === (113)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (_1 === (118)) { */ case 2: + if (p.fmt.fmtFlags.sharpV) { + p.fmt.fmtQ(v); + } else { + p.fmt.fmtS(v); + } + $s = 8; continue; + /* } else if (_1 === (115)) { */ case 3: + p.fmt.fmtS(v); + $s = 8; continue; + /* } else if (_1 === (120)) { */ case 4: + p.fmt.fmtSx(v, "0123456789abcdefx"); + $s = 8; continue; + /* } else if (_1 === (88)) { */ case 5: + p.fmt.fmtSx(v, "0123456789ABCDEFX"); + $s = 8; continue; + /* } else if (_1 === (113)) { */ case 6: + p.fmt.fmtQ(v); + $s = 8; continue; + /* } else { */ case 7: + $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtString }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtString = function(v, verb) { return this.$val.fmtString(v, verb); }; + pp.ptr.prototype.fmtBytes = function(v, verb, typeString) { + var _1, _i, _i$1, _r, _ref, _ref$1, c, c$1, i, i$1, p, typeString, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; c$1 = $f.c$1; i = $f.i; i$1 = $f.i$1; p = $f.p; typeString = $f.typeString; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (100))) { $s = 2; continue; } + /* */ if (_1 === (115)) { $s = 3; continue; } + /* */ if (_1 === (120)) { $s = 4; continue; } + /* */ if (_1 === (88)) { $s = 5; continue; } + /* */ if (_1 === (113)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((_1 === (118)) || (_1 === (100))) { */ case 2: + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(typeString); + if (v === sliceType$2.nil) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + _ref = v; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + p.fmt0x64((new $Uint64(0, c)), true); + _i++; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); + _ref$1 = v; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + c$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + if (i$1 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + p.fmt.fmtInteger((new $Uint64(0, c$1)), 10, false, "0123456789abcdefx"); + _i$1++; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + } + $s = 8; continue; + /* } else if (_1 === (115)) { */ case 3: + p.fmt.fmtBs(v); + $s = 8; continue; + /* } else if (_1 === (120)) { */ case 4: + p.fmt.fmtBx(v, "0123456789abcdefx"); + $s = 8; continue; + /* } else if (_1 === (88)) { */ case 5: + p.fmt.fmtBx(v, "0123456789ABCDEFX"); + $s = 8; continue; + /* } else if (_1 === (113)) { */ case 6: + p.fmt.fmtQ(($bytesToString(v))); + $s = 8; continue; + /* } else { */ case 7: + _r = reflect.ValueOf(v); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r, reflect.Value), verb, 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBytes }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.c$1 = c$1; $f.i = i; $f.i$1 = i$1; $f.p = p; $f.typeString = typeString; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtBytes = function(v, verb, typeString) { return this.$val.fmtBytes(v, verb, typeString); }; + pp.ptr.prototype.fmtPointer = function(value, verb) { + var _1, _2, _r, p, u, value, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; p = $f.p; u = $f.u; value = $f.value; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + u = 0; + _1 = $clone(value, reflect.Value).Kind(); + /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { */ case 2: + u = $clone(value, reflect.Value).Pointer(); + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 4: + case 1: + _2 = verb; + /* */ if (_2 === (118)) { $s = 7; continue; } + /* */ if (_2 === (112)) { $s = 8; continue; } + /* */ if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_2 === (118)) { */ case 7: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 12: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + _r = $clone(value, reflect.Value).Type().String(); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(")("); + if (u === 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("nil"); + } else { + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), true); + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + $s = 14; continue; + /* } else { */ case 13: + if (u === 0) { + p.fmt.padString(""); + } else { + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); + } + /* } */ case 14: + $s = 11; continue; + /* } else if (_2 === (112)) { */ case 8: + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); + $s = 11; continue; + /* } else if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { */ case 9: + $r = p.fmtInteger((new $Uint64(0, u.constructor === Number ? u : 1)), false, verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 11; continue; + /* } else { */ case 10: + $r = p.badVerb(verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 11: + case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtPointer }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f.p = p; $f.u = u; $f.value = value; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtPointer = function(value, verb) { return this.$val.fmtPointer(value, verb); }; + pp.ptr.prototype.catchPanic = function(arg, verb, method) { + var _r, arg, err, method, oldFlags, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; arg = $f.arg; err = $f.err; method = $f.method; oldFlags = $f.oldFlags; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + err = $recover(); + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 1: + _r = reflect.ValueOf(arg); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = -1; return; + } + if (p.panicking) { + $panic(err); + } + oldFlags = $clone(p.fmt.fmtFlags, fmtFlags); + p.fmt.clearflags(); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(PANIC="); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(method); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(" method: "); + p.panicking = true; + $r = p.printArg(err, 118); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + p.panicking = false; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + fmtFlags.copy(p.fmt.fmtFlags, oldFlags); + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.catchPanic }; } $f._r = _r; $f.arg = arg; $f.err = err; $f.method = method; $f.oldFlags = oldFlags; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.catchPanic = function(arg, verb, method) { return this.$val.catchPanic(arg, verb, method); }; + pp.ptr.prototype.handleMethods = function(verb) { + var _1, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, formatter, handled, ok, ok$1, p, stringer, v, v$1, verb, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; formatter = $f.formatter; handled = $f.handled; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; stringer = $f.stringer; v = $f.v; v$1 = $f.v$1; verb = $f.verb; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + handled = false; + p = this; + if (p.erroring) { + $s = -1; return handled; + } + _tuple = $assertType(p.arg, Formatter, true); + formatter = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "Format"]]); + $r = formatter.Format(p, verb); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 2: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 4: + _tuple$1 = $assertType(p.arg, GoStringer, true); + stringer = _tuple$1[0]; + ok$1 = _tuple$1[1]; + /* */ if (ok$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (ok$1) { */ case 7: + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "GoString"]]); + _r = stringer.GoString(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.fmt.fmtS(_r); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 8: + $s = 6; continue; + /* } else { */ case 5: + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { */ case 12: + _ref = p.arg; + /* */ if ($assertType(_ref, $error, true)[1]) { $s = 14; continue; } + /* */ if ($assertType(_ref, Stringer, true)[1]) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if ($assertType(_ref, $error, true)[1]) { */ case 14: + v = _ref; + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "Error"]]); + _r$1 = v.Error(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = p.fmtString(_r$1, verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } else if ($assertType(_ref, Stringer, true)[1]) { */ case 15: + v$1 = _ref; + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "String"]]); + _r$2 = v$1.String(); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = p.fmtString(_r$2, verb); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 16: + /* } */ case 13: + case 11: + /* } */ case 6: + handled = false; + $s = -1; return handled; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return handled; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: pp.ptr.prototype.handleMethods }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.formatter = formatter; $f.handled = handled; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.stringer = stringer; $f.v = v; $f.v$1 = v$1; $f.verb = verb; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + pp.prototype.handleMethods = function(verb) { return this.$val.handleMethods(verb); }; + pp.ptr.prototype.printArg = function(arg, verb) { + var _1, _2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, arg, f, f$1, f$10, f$11, f$12, f$13, f$14, f$15, f$16, f$17, f$18, f$19, f$2, f$3, f$4, f$5, f$6, f$7, f$8, f$9, p, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; arg = $f.arg; f = $f.f; f$1 = $f.f$1; f$10 = $f.f$10; f$11 = $f.f$11; f$12 = $f.f$12; f$13 = $f.f$13; f$14 = $f.f$14; f$15 = $f.f$15; f$16 = $f.f$16; f$17 = $f.f$17; f$18 = $f.f$18; f$19 = $f.f$19; f$2 = $f.f$2; f$3 = $f.f$3; f$4 = $f.f$4; f$5 = $f.f$5; f$6 = $f.f$6; f$7 = $f.f$7; f$8 = $f.f$8; f$9 = $f.f$9; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.arg = arg; + p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 1: + _1 = verb; + /* */ if ((_1 === (84)) || (_1 === (118))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_1 === (84)) || (_1 === (118))) { */ case 4: + p.fmt.padString(""); + $s = 6; continue; + /* } else { */ case 5: + $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + case 3: + $s = -1; return; + /* } */ case 2: + _2 = verb; + /* */ if (_2 === (84)) { $s = 9; continue; } + /* */ if (_2 === (112)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_2 === (84)) { */ case 9: + _r = reflect.TypeOf(arg).String(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.fmt.fmtS(_r); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } else if (_2 === (112)) { */ case 10: + _r$1 = reflect.ValueOf(arg); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = p.fmtPointer($clone(_r$1, reflect.Value), 112); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 11: + case 8: + _ref = arg; + /* */ if ($assertType(_ref, $Bool, true)[1]) { $s = 16; continue; } + /* */ if ($assertType(_ref, $Float32, true)[1]) { $s = 17; continue; } + /* */ if ($assertType(_ref, $Float64, true)[1]) { $s = 18; continue; } + /* */ if ($assertType(_ref, $Complex64, true)[1]) { $s = 19; continue; } + /* */ if ($assertType(_ref, $Complex128, true)[1]) { $s = 20; continue; } + /* */ if ($assertType(_ref, $Int, true)[1]) { $s = 21; continue; } + /* */ if ($assertType(_ref, $Int8, true)[1]) { $s = 22; continue; } + /* */ if ($assertType(_ref, $Int16, true)[1]) { $s = 23; continue; } + /* */ if ($assertType(_ref, $Int32, true)[1]) { $s = 24; continue; } + /* */ if ($assertType(_ref, $Int64, true)[1]) { $s = 25; continue; } + /* */ if ($assertType(_ref, $Uint, true)[1]) { $s = 26; continue; } + /* */ if ($assertType(_ref, $Uint8, true)[1]) { $s = 27; continue; } + /* */ if ($assertType(_ref, $Uint16, true)[1]) { $s = 28; continue; } + /* */ if ($assertType(_ref, $Uint32, true)[1]) { $s = 29; continue; } + /* */ if ($assertType(_ref, $Uint64, true)[1]) { $s = 30; continue; } + /* */ if ($assertType(_ref, $Uintptr, true)[1]) { $s = 31; continue; } + /* */ if ($assertType(_ref, $String, true)[1]) { $s = 32; continue; } + /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 33; continue; } + /* */ if ($assertType(_ref, reflect.Value, true)[1]) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if ($assertType(_ref, $Bool, true)[1]) { */ case 16: + f = _ref.$val; + $r = p.fmtBool(f, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Float32, true)[1]) { */ case 17: + f$1 = _ref.$val; + $r = p.fmtFloat((f$1), 32, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Float64, true)[1]) { */ case 18: + f$2 = _ref.$val; + $r = p.fmtFloat(f$2, 64, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Complex64, true)[1]) { */ case 19: + f$3 = _ref.$val; + $r = p.fmtComplex((new $Complex128(f$3.$real, f$3.$imag)), 64, verb); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Complex128, true)[1]) { */ case 20: + f$4 = _ref.$val; + $r = p.fmtComplex(f$4, 128, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int, true)[1]) { */ case 21: + f$5 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$5)), true, verb); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int8, true)[1]) { */ case 22: + f$6 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$6)), true, verb); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int16, true)[1]) { */ case 23: + f$7 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$7)), true, verb); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int32, true)[1]) { */ case 24: + f$8 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$8)), true, verb); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int64, true)[1]) { */ case 25: + f$9 = _ref.$val; + $r = p.fmtInteger((new $Uint64(f$9.$high, f$9.$low)), true, verb); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint, true)[1]) { */ case 26: + f$10 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$10)), false, verb); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint8, true)[1]) { */ case 27: + f$11 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$11)), false, verb); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint16, true)[1]) { */ case 28: + f$12 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$12)), false, verb); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint32, true)[1]) { */ case 29: + f$13 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$13)), false, verb); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint64, true)[1]) { */ case 30: + f$14 = _ref.$val; + $r = p.fmtInteger(f$14, false, verb); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uintptr, true)[1]) { */ case 31: + f$15 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$15.constructor === Number ? f$15 : 1)), false, verb); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $String, true)[1]) { */ case 32: + f$16 = _ref.$val; + $r = p.fmtString(f$16, verb); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 33: + f$17 = _ref.$val; + $r = p.fmtBytes(f$17, verb, "[]byte"); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, reflect.Value, true)[1]) { */ case 34: + f$18 = _ref.$val; + /* */ if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { $s = 55; continue; } + /* */ $s = 56; continue; + /* if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { */ case 55: + _r$2 = $clone(f$18, reflect.Value).Interface(); /* */ $s = 57; case 57: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p.arg = _r$2; + _r$3 = p.handleMethods(verb); /* */ $s = 60; case 60: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3) { $s = 58; continue; } + /* */ $s = 59; continue; + /* if (_r$3) { */ case 58: + $s = -1; return; + /* } */ case 59: + /* } */ case 56: + $r = p.printValue($clone(f$18, reflect.Value), verb, 0); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else { */ case 35: + f$19 = _ref; + _r$4 = p.handleMethods(verb); /* */ $s = 64; case 64: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 62; continue; } + /* */ $s = 63; continue; + /* if (!_r$4) { */ case 62: + _r$5 = reflect.ValueOf(f$19); /* */ $s = 65; case 65: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$5, reflect.Value), verb, 0); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 63: + /* } */ case 36: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printArg }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.arg = arg; $f.f = f; $f.f$1 = f$1; $f.f$10 = f$10; $f.f$11 = f$11; $f.f$12 = f$12; $f.f$13 = f$13; $f.f$14 = f$14; $f.f$15 = f$15; $f.f$16 = f$16; $f.f$17 = f$17; $f.f$18 = f$18; $f.f$19 = f$19; $f.f$2 = f$2; $f.f$3 = f$3; $f.f$4 = f$4; $f.f$5 = f$5; $f.f$6 = f$6; $f.f$7 = f$7; $f.f$8 = f$8; $f.f$9 = f$9; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printArg = function(arg, verb) { return this.$val.printArg(arg, verb); }; + pp.ptr.prototype.printValue = function(value, verb, depth) { + var _1, _2, _3, _4, _arg, _arg$1, _arg$2, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, a, bytes, depth, f, i, i$1, i$2, i$3, i$4, key, name, p, sorted, t, value, value$1, verb, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; a = $f.a; bytes = $f.bytes; depth = $f.depth; f = $f.f; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; key = $f.key; name = $f.name; p = $f.p; sorted = $f.sorted; t = $f.t; value = $f.value; value$1 = $f.value$1; verb = $f.verb; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { */ case 1: + _r = $clone(value, reflect.Value).Interface(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p.arg = _r; + _r$1 = p.handleMethods(verb); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return; + /* } */ case 5: + /* } */ case 2: + p.arg = $ifaceNil; + p.value = value; + f = value; + _1 = $clone(value, reflect.Value).Kind(); + /* */ if (_1 === (0)) { $s = 8; continue; } + /* */ if (_1 === (1)) { $s = 9; continue; } + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 10; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 11; continue; } + /* */ if (_1 === (13)) { $s = 12; continue; } + /* */ if (_1 === (14)) { $s = 13; continue; } + /* */ if (_1 === (15)) { $s = 14; continue; } + /* */ if (_1 === (16)) { $s = 15; continue; } + /* */ if (_1 === (24)) { $s = 16; continue; } + /* */ if (_1 === (21)) { $s = 17; continue; } + /* */ if (_1 === (25)) { $s = 18; continue; } + /* */ if (_1 === (20)) { $s = 19; continue; } + /* */ if ((_1 === (17)) || (_1 === (23))) { $s = 20; continue; } + /* */ if (_1 === (22)) { $s = 21; continue; } + /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (_1 === (0)) { */ case 8: + /* */ if (depth === 0) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (depth === 0) { */ case 25: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 27; continue; + /* } else { */ case 26: + _2 = verb; + /* */ if (_2 === (118)) { $s = 29; continue; } + /* */ $s = 30; continue; + /* if (_2 === (118)) { */ case 29: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 31; continue; + /* } else { */ case 30: + $r = p.badVerb(verb); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 31: + case 28: + /* } */ case 27: + $s = 24; continue; + /* } else if (_1 === (1)) { */ case 9: + $r = p.fmtBool($clone(f, reflect.Value).Bool(), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 10: + $r = p.fmtInteger(((x = $clone(f, reflect.Value).Int(), new $Uint64(x.$high, x.$low))), true, verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 11: + $r = p.fmtInteger($clone(f, reflect.Value).Uint(), false, verb); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (13)) { */ case 12: + $r = p.fmtFloat($clone(f, reflect.Value).Float(), 32, verb); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (14)) { */ case 13: + $r = p.fmtFloat($clone(f, reflect.Value).Float(), 64, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (15)) { */ case 14: + $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 64, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (16)) { */ case 15: + $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 128, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (24)) { */ case 16: + _r$2 = $clone(f, reflect.Value).String(); /* */ $s = 40; case 40: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = p.fmtString(_r$2, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (21)) { */ case 17: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 42; continue; } + /* */ $s = 43; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 42: + _r$3 = $clone(f, reflect.Value).Type().String(); /* */ $s = 45; case 45: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$3); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if ($clone(f, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + $s = 44; continue; + /* } else { */ case 43: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("map["); + /* } */ case 44: + _r$4 = fmtsort.Sort($clone(f, reflect.Value)); /* */ $s = 47; case 47: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + sorted = _r$4; + _ref = sorted.Key; + _i = 0; + /* while (true) { */ case 48: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 49; continue; } + i = _i; + key = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i > 0) { + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + } + $r = p.printValue($clone(key, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); + $r = p.printValue($clone((x$1 = sorted.Value, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])), reflect.Value), verb, depth + 1 >> 0); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 48; continue; case 49: + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + } + $s = 24; continue; + /* } else if (_1 === (25)) { */ case 18: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 52; continue; } + /* */ $s = 53; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 52: + _r$5 = $clone(f, reflect.Value).Type().String(); /* */ $s = 54; case 54: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$5); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 53: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + i$1 = 0; + /* while (true) { */ case 56: + /* if (!(i$1 < $clone(f, reflect.Value).NumField())) { break; } */ if(!(i$1 < $clone(f, reflect.Value).NumField())) { $s = 57; continue; } + if (i$1 > 0) { + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + } + /* */ if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { $s = 58; continue; } + /* */ $s = 59; continue; + /* if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { */ case 58: + _r$6 = $clone(f, reflect.Value).Type().Field(i$1); /* */ $s = 60; case 60: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + name = _r$6.Name; + if (!(name === "")) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(name); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); + } + /* } */ case 59: + _r$7 = getField($clone(f, reflect.Value), i$1); /* */ $s = 61; case 61: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$7, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 + (1) >> 0; + /* } */ $s = 56; continue; case 57: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + $s = 24; continue; + /* } else if (_1 === (20)) { */ case 19: + _r$8 = $clone(f, reflect.Value).Elem(); /* */ $s = 63; case 63: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + value$1 = _r$8; + /* */ if (!$clone(value$1, reflect.Value).IsValid()) { $s = 64; continue; } + /* */ $s = 65; continue; + /* if (!$clone(value$1, reflect.Value).IsValid()) { */ case 64: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 67; continue; } + /* */ $s = 68; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 67: + _r$9 = $clone(f, reflect.Value).Type().String(); /* */ $s = 70; case 70: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$9); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = 69; continue; + /* } else { */ case 68: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + /* } */ case 69: + $s = 66; continue; + /* } else { */ case 65: + $r = p.printValue($clone(value$1, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 72; case 72: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 66: + $s = 24; continue; + /* } else if ((_1 === (17)) || (_1 === (23))) { */ case 20: + _3 = verb; + /* */ if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { $s = 74; continue; } + /* */ $s = 75; continue; + /* if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { */ case 74: + t = $clone(f, reflect.Value).Type(); + _r$10 = t.Elem(); /* */ $s = 78; case 78: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _r$11 = _r$10.Kind(); /* */ $s = 79; case 79: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + /* */ if (_r$11 === 8) { $s = 76; continue; } + /* */ $s = 77; continue; + /* if (_r$11 === 8) { */ case 76: + bytes = sliceType$2.nil; + /* */ if ($clone(f, reflect.Value).Kind() === 23) { $s = 80; continue; } + /* */ if ($clone(f, reflect.Value).CanAddr()) { $s = 81; continue; } + /* */ $s = 82; continue; + /* if ($clone(f, reflect.Value).Kind() === 23) { */ case 80: + _r$12 = $clone(f, reflect.Value).Bytes(); /* */ $s = 84; case 84: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + bytes = _r$12; + $s = 83; continue; + /* } else if ($clone(f, reflect.Value).CanAddr()) { */ case 81: + _r$13 = $clone(f, reflect.Value).Slice(0, $clone(f, reflect.Value).Len()); /* */ $s = 85; case 85: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _r$14 = $clone(_r$13, reflect.Value).Bytes(); /* */ $s = 86; case 86: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + bytes = _r$14; + $s = 83; continue; + /* } else { */ case 82: + bytes = $makeSlice(sliceType$2, $clone(f, reflect.Value).Len()); + _ref$1 = bytes; + _i$1 = 0; + /* while (true) { */ case 87: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 88; continue; } + i$2 = _i$1; + _r$15 = $clone(f, reflect.Value).Index(i$2); /* */ $s = 89; case 89: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + _r$16 = $clone(_r$15, reflect.Value).Uint(); /* */ $s = 90; case 90: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + ((i$2 < 0 || i$2 >= bytes.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes.$array[bytes.$offset + i$2] = ((_r$16.$low << 24 >>> 24))); + _i$1++; + /* } */ $s = 87; continue; case 88: + /* } */ case 83: + _arg = bytes; + _arg$1 = verb; + _r$17 = t.String(); /* */ $s = 91; case 91: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + _arg$2 = _r$17; + $r = p.fmtBytes(_arg, _arg$1, _arg$2); /* */ $s = 92; case 92: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 77: + /* } */ case 75: + case 73: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 93; continue; } + /* */ $s = 94; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 93: + _r$18 = $clone(f, reflect.Value).Type().String(); /* */ $s = 96; case 96: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$18); /* */ $s = 97; case 97: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (($clone(f, reflect.Value).Kind() === 23) && $clone(f, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + i$3 = 0; + /* while (true) { */ case 98: + /* if (!(i$3 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$3 < $clone(f, reflect.Value).Len())) { $s = 99; continue; } + if (i$3 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + _r$19 = $clone(f, reflect.Value).Index(i$3); /* */ $s = 100; case 100: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$19, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 101; case 101: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$3 = i$3 + (1) >> 0; + /* } */ $s = 98; continue; case 99: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + $s = 95; continue; + /* } else { */ case 94: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); + i$4 = 0; + /* while (true) { */ case 102: + /* if (!(i$4 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$4 < $clone(f, reflect.Value).Len())) { $s = 103; continue; } + if (i$4 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + _r$20 = $clone(f, reflect.Value).Index(i$4); /* */ $s = 104; case 104: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$20, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$4 = i$4 + (1) >> 0; + /* } */ $s = 102; continue; case 103: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + /* } */ case 95: + $s = 24; continue; + /* } else if (_1 === (22)) { */ case 21: + /* */ if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { $s = 106; continue; } + /* */ $s = 107; continue; + /* if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { */ case 106: + _r$21 = $clone(f, reflect.Value).Elem(); /* */ $s = 109; case 109: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; } + a = _r$21; + _4 = $clone(a, reflect.Value).Kind(); + /* */ if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { $s = 110; continue; } + /* */ $s = 111; continue; + /* if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { */ case 110: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); + $r = p.printValue($clone(a, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 112; case 112: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 111: + case 108: + /* } */ case 107: + $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 113; case 113: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { */ case 22: + $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else { */ case 23: + $r = p.unknownType($clone(f, reflect.Value)); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 24: + case 7: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printValue }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f.a = a; $f.bytes = bytes; $f.depth = depth; $f.f = f; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.key = key; $f.name = name; $f.p = p; $f.sorted = sorted; $f.t = t; $f.value = value; $f.value$1 = value$1; $f.verb = verb; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printValue = function(value, verb, depth) { return this.$val.printValue(value, verb, depth); }; + intFromArg = function(a, argNum) { + var _1, _r, _tuple, a, argNum, isInt, n, n$1, newArgNum, num, v, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _tuple = $f._tuple; a = $f.a; argNum = $f.argNum; isInt = $f.isInt; n = $f.n; n$1 = $f.n$1; newArgNum = $f.newArgNum; num = $f.num; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + num = 0; + isInt = false; + newArgNum = 0; + newArgNum = argNum; + /* */ if (argNum < a.$length) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (argNum < a.$length) { */ case 1: + _tuple = $assertType(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), $Int, true); + num = _tuple[0]; + isInt = _tuple[1]; + /* */ if (!isInt) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!isInt) { */ case 3: + _r = reflect.ValueOf(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum])); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + _1 = $clone(v, reflect.Value).Kind(); + if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + n = $clone(v, reflect.Value).Int(); + if ((x = (new $Int64(0, (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)))), (x.$high === n.$high && x.$low === n.$low))) { + num = (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)); + isInt = true; + } + } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { + n$1 = $clone(v, reflect.Value).Uint(); + if ((x$1 = (new $Int64(n$1.$high, n$1.$low)), (x$1.$high > 0 || (x$1.$high === 0 && x$1.$low >= 0))) && (x$2 = (new $Uint64(0, ((n$1.$low >> 0)))), (x$2.$high === n$1.$high && x$2.$low === n$1.$low))) { + num = ((n$1.$low >> 0)); + isInt = true; + } + } + case 5: + /* } */ case 4: + newArgNum = argNum + 1 >> 0; + if (tooLarge(num)) { + num = 0; + isInt = false; + } + /* } */ case 2: + $s = -1; return [num, isInt, newArgNum]; + /* */ } return; } if ($f === undefined) { $f = { $blk: intFromArg }; } $f._1 = _1; $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.argNum = argNum; $f.isInt = isInt; $f.n = n; $f.n$1 = n$1; $f.newArgNum = newArgNum; $f.num = num; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + parseArgNumber = function(format) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, format, i, index, newi, ok, ok$1, wid, width; + index = 0; + wid = 0; + ok = false; + if (format.length < 3) { + _tmp = 0; + _tmp$1 = 1; + _tmp$2 = false; + index = _tmp; + wid = _tmp$1; + ok = _tmp$2; + return [index, wid, ok]; + } + i = 1; + while (true) { + if (!(i < format.length)) { break; } + if (format.charCodeAt(i) === 93) { + _tuple = parsenum(format, 1, i); + width = _tuple[0]; + ok$1 = _tuple[1]; + newi = _tuple[2]; + if (!ok$1 || !((newi === i))) { + _tmp$3 = 0; + _tmp$4 = i + 1 >> 0; + _tmp$5 = false; + index = _tmp$3; + wid = _tmp$4; + ok = _tmp$5; + return [index, wid, ok]; + } + _tmp$6 = width - 1 >> 0; + _tmp$7 = i + 1 >> 0; + _tmp$8 = true; + index = _tmp$6; + wid = _tmp$7; + ok = _tmp$8; + return [index, wid, ok]; + } + i = i + (1) >> 0; + } + _tmp$9 = 0; + _tmp$10 = 1; + _tmp$11 = false; + index = _tmp$9; + wid = _tmp$10; + ok = _tmp$11; + return [index, wid, ok]; + }; + pp.ptr.prototype.argNumber = function(argNum, format, i, numArgs) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, argNum, format, found, i, index, newArgNum, newi, numArgs, ok, p, wid; + newArgNum = 0; + newi = 0; + found = false; + p = this; + if (format.length <= i || !((format.charCodeAt(i) === 91))) { + _tmp = argNum; + _tmp$1 = i; + _tmp$2 = false; + newArgNum = _tmp; + newi = _tmp$1; + found = _tmp$2; + return [newArgNum, newi, found]; + } + p.reordered = true; + _tuple = parseArgNumber($substring(format, i)); + index = _tuple[0]; + wid = _tuple[1]; + ok = _tuple[2]; + if (ok && 0 <= index && index < numArgs) { + _tmp$3 = index; + _tmp$4 = i + wid >> 0; + _tmp$5 = true; + newArgNum = _tmp$3; + newi = _tmp$4; + found = _tmp$5; + return [newArgNum, newi, found]; + } + p.goodArgNum = false; + _tmp$6 = argNum; + _tmp$7 = i + wid >> 0; + _tmp$8 = ok; + newArgNum = _tmp$6; + newi = _tmp$7; + found = _tmp$8; + return [newArgNum, newi, found]; + }; + pp.prototype.argNumber = function(argNum, format, i, numArgs) { return this.$val.argNumber(argNum, format, i, numArgs); }; + pp.ptr.prototype.badArgNum = function(verb) { + var p, verb; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(BADINDEX)"); + }; + pp.prototype.badArgNum = function(verb) { return this.$val.badArgNum(verb); }; + pp.ptr.prototype.missingArg = function(verb) { + var p, verb; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(MISSING)"); + }; + pp.prototype.missingArg = function(verb) { return this.$val.missingArg(verb); }; + pp.ptr.prototype.doPrintf = function(format, a) { + var _1, _i, _r, _r$1, _r$2, _ref, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, a, afterIndex, arg, argNum, c, end, format, i, i$1, lasti, p, size, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; a = $f.a; afterIndex = $f.afterIndex; arg = $f.arg; argNum = $f.argNum; c = $f.c; end = $f.end; format = $f.format; i = $f.i; i$1 = $f.i$1; lasti = $f.lasti; p = $f.p; size = $f.size; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + end = format.length; + argNum = 0; + afterIndex = false; + p.reordered = false; + i = 0; + /* while (true) { */ case 1: + /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 2; continue; } + p.goodArgNum = true; + lasti = i; + while (true) { + if (!(i < end && !((format.charCodeAt(i) === 37)))) { break; } + i = i + (1) >> 0; + } + if (i > lasti) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString($substring(format, lasti, i)); + } + if (i >= end) { + /* break; */ $s = 2; continue; + } + i = i + (1) >> 0; + p.fmt.clearflags(); + /* while (true) { */ case 3: + /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 4; continue; } + c = format.charCodeAt(i); + _1 = c; + /* */ if (_1 === (35)) { $s = 6; continue; } + /* */ if (_1 === (48)) { $s = 7; continue; } + /* */ if (_1 === (43)) { $s = 8; continue; } + /* */ if (_1 === (45)) { $s = 9; continue; } + /* */ if (_1 === (32)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_1 === (35)) { */ case 6: + p.fmt.fmtFlags.sharp = true; + $s = 12; continue; + /* } else if (_1 === (48)) { */ case 7: + p.fmt.fmtFlags.zero = !p.fmt.fmtFlags.minus; + $s = 12; continue; + /* } else if (_1 === (43)) { */ case 8: + p.fmt.fmtFlags.plus = true; + $s = 12; continue; + /* } else if (_1 === (45)) { */ case 9: + p.fmt.fmtFlags.minus = true; + p.fmt.fmtFlags.zero = false; + $s = 12; continue; + /* } else if (_1 === (32)) { */ case 10: + p.fmt.fmtFlags.space = true; + $s = 12; continue; + /* } else { */ case 11: + /* */ if (97 <= c && c <= 122 && argNum < a.$length) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (97 <= c && c <= 122 && argNum < a.$length) { */ case 13: + if (c === 118) { + p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; + p.fmt.fmtFlags.plus = false; + } + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), ((c >> 0))); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + i = i + (1) >> 0; + /* continue formatLoop; */ $s = 1; continue s; + /* } */ case 14: + /* break simpleFormat; */ $s = 4; continue s; + /* } */ case 12: + case 5: + i = i + (1) >> 0; + /* } */ $s = 3; continue; case 4: + _tuple = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple[0]; + i = _tuple[1]; + afterIndex = _tuple[2]; + /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 16: + i = i + (1) >> 0; + _r = intFromArg(a, argNum); /* */ $s = 19; case 19: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + p.fmt.wid = _tuple$1[0]; + p.fmt.fmtFlags.widPresent = _tuple$1[1]; + argNum = _tuple$1[2]; + if (!p.fmt.fmtFlags.widPresent) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADWIDTH)"); + } + if (p.fmt.wid < 0) { + p.fmt.wid = -p.fmt.wid; + p.fmt.fmtFlags.minus = true; + p.fmt.fmtFlags.zero = false; + } + afterIndex = false; + $s = 18; continue; + /* } else { */ case 17: + _tuple$2 = parsenum(format, i, end); + p.fmt.wid = _tuple$2[0]; + p.fmt.fmtFlags.widPresent = _tuple$2[1]; + i = _tuple$2[2]; + if (afterIndex && p.fmt.fmtFlags.widPresent) { + p.goodArgNum = false; + } + /* } */ case 18: + /* */ if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { */ case 20: + i = i + (1) >> 0; + if (afterIndex) { + p.goodArgNum = false; + } + _tuple$3 = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple$3[0]; + i = _tuple$3[1]; + afterIndex = _tuple$3[2]; + /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 22: + i = i + (1) >> 0; + _r$1 = intFromArg(a, argNum); /* */ $s = 25; case 25: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$4 = _r$1; + p.fmt.prec = _tuple$4[0]; + p.fmt.fmtFlags.precPresent = _tuple$4[1]; + argNum = _tuple$4[2]; + if (p.fmt.prec < 0) { + p.fmt.prec = 0; + p.fmt.fmtFlags.precPresent = false; + } + if (!p.fmt.fmtFlags.precPresent) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADPREC)"); + } + afterIndex = false; + $s = 24; continue; + /* } else { */ case 23: + _tuple$5 = parsenum(format, i, end); + p.fmt.prec = _tuple$5[0]; + p.fmt.fmtFlags.precPresent = _tuple$5[1]; + i = _tuple$5[2]; + if (!p.fmt.fmtFlags.precPresent) { + p.fmt.prec = 0; + p.fmt.fmtFlags.precPresent = true; + } + /* } */ case 24: + /* } */ case 21: + if (!afterIndex) { + _tuple$6 = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple$6[0]; + i = _tuple$6[1]; + afterIndex = _tuple$6[2]; + } + if (i >= end) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(NOVERB)"); + /* break; */ $s = 2; continue; + } + _tmp = ((format.charCodeAt(i) >> 0)); + _tmp$1 = 1; + verb = _tmp; + size = _tmp$1; + if (verb >= 128) { + _tuple$7 = utf8.DecodeRuneInString($substring(format, i)); + verb = _tuple$7[0]; + size = _tuple$7[1]; + } + i = i + (size) >> 0; + /* */ if ((verb === 37)) { $s = 27; continue; } + /* */ if (!p.goodArgNum) { $s = 28; continue; } + /* */ if (argNum >= a.$length) { $s = 29; continue; } + /* */ if ((verb === 118)) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if ((verb === 37)) { */ case 27: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(37); + $s = 32; continue; + /* } else if (!p.goodArgNum) { */ case 28: + p.badArgNum(verb); + $s = 32; continue; + /* } else if (argNum >= a.$length) { */ case 29: + p.missingArg(verb); + $s = 32; continue; + /* } else if ((verb === 118)) { */ case 30: + p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; + p.fmt.fmtFlags.plus = false; + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + $s = 32; continue; + /* } else { */ case 31: + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + /* } */ case 32: + case 26: + /* } */ $s = 1; continue; case 2: + /* */ if (!p.reordered && argNum < a.$length) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (!p.reordered && argNum < a.$length) { */ case 35: + p.fmt.clearflags(); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(EXTRA "); + _ref = $subslice(a, argNum); + _i = 0; + /* while (true) { */ case 37: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 38; continue; } + i$1 = _i; + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i$1 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 39; continue; } + /* */ $s = 40; continue; + /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 39: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 41; continue; + /* } else { */ case 40: + _r$2 = reflect.TypeOf(arg).String(); /* */ $s = 42; case 42: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printArg(arg, 118); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 41: + _i++; + /* } */ $s = 37; continue; case 38: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + /* } */ case 36: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintf }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.a = a; $f.afterIndex = afterIndex; $f.arg = arg; $f.argNum = argNum; $f.c = c; $f.end = end; $f.format = format; $f.i = i; $f.i$1 = i$1; $f.lasti = lasti; $f.p = p; $f.size = size; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.doPrintf = function(format, a) { return this.$val.doPrintf(format, a); }; + pp.ptr.prototype.doPrint = function(a) { + var _i, _r, _ref, _v, a, arg, argNum, isString, p, prevString, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _v = $f._v; a = $f.a; arg = $f.arg; argNum = $f.argNum; isString = $f.isString; p = $f.p; prevString = $f.prevString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + prevString = false; + _ref = a; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + argNum = _i; + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!(!($interfaceIsEqual(arg, $ifaceNil)))) { _v = false; $s = 3; continue s; } + _r = reflect.TypeOf(arg).Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r === 24; case 3: + isString = _v; + if (argNum > 0 && !isString && !prevString) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + $r = p.printArg(arg, 118); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + prevString = isString; + _i++; + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrint }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._v = _v; $f.a = a; $f.arg = arg; $f.argNum = argNum; $f.isString = isString; $f.p = p; $f.prevString = prevString; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.doPrint = function(a) { return this.$val.doPrint(a); }; + pp.ptr.prototype.doPrintln = function(a) { + var _i, _ref, a, arg, argNum, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _ref = $f._ref; a = $f.a; arg = $f.arg; argNum = $f.argNum; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _ref = a; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + argNum = _i; + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (argNum > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + $r = p.printArg(arg, 118); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 1; continue; case 2: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(10); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintln }; } $f._i = _i; $f._ref = _ref; $f.a = a; $f.arg = arg; $f.argNum = argNum; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.doPrintln = function(a) { return this.$val.doPrintln(a); }; + ss.ptr.prototype.Read = function(buf) { + var _tmp, _tmp$1, buf, err, n, s; + n = 0; + err = $ifaceNil; + s = this; + _tmp = 0; + _tmp$1 = errors.New("ScanState's Read should not be called. Use ReadRune"); + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + ss.prototype.Read = function(buf) { return this.$val.Read(buf); }; + ss.ptr.prototype.ReadRune = function() { + var _r, _tuple, err, r, s, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = 0; + size = 0; + err = $ifaceNil; + s = this; + if (s.atEOF || s.count >= s.ssave.argLimit) { + err = io.EOF; + $s = -1; return [r, size, err]; + } + _r = s.rs.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + size = _tuple[1]; + err = _tuple[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + s.count = s.count + (1) >> 0; + if (s.ssave.nlIsEnd && (r === 10)) { + s.atEOF = true; + } + } else if ($interfaceIsEqual(err, io.EOF)) { + s.atEOF = true; + } + $s = -1; return [r, size, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.ReadRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.ReadRune = function() { return this.$val.ReadRune(); }; + ss.ptr.prototype.Width = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, ok, s, wid; + wid = 0; + ok = false; + s = this; + if (s.ssave.maxWid === 1073741824) { + _tmp = 0; + _tmp$1 = false; + wid = _tmp; + ok = _tmp$1; + return [wid, ok]; + } + _tmp$2 = s.ssave.maxWid; + _tmp$3 = true; + wid = _tmp$2; + ok = _tmp$3; + return [wid, ok]; + }; + ss.prototype.Width = function() { return this.$val.Width(); }; + ss.ptr.prototype.getRune = function() { + var _r, _tuple, err, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = 0; + s = this; + _r = s.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + r = -1; + $s = -1; return r; + } + s.error(err); + } + $s = -1; return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.getRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.getRune = function() { return this.$val.getRune(); }; + ss.ptr.prototype.UnreadRune = function() { + var _r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _r = s.rs.UnreadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + s.atEOF = false; + s.count = s.count - (1) >> 0; + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.UnreadRune }; } $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + ss.ptr.prototype.error = function(err) { + var err, s, x; + s = this; + $panic((x = new scanError.ptr(err), new x.constructor.elem(x))); + }; + ss.prototype.error = function(err) { return this.$val.error(err); }; + ss.ptr.prototype.errorString = function(err) { + var err, s, x; + s = this; + $panic((x = new scanError.ptr(errors.New(err)), new x.constructor.elem(x))); + }; + ss.prototype.errorString = function(err) { return this.$val.errorString(err); }; + ss.ptr.prototype.Token = function(skipSpace, f) { + var _r, err, f, s, skipSpace, tok, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; s = $f.s; skipSpace = $f.skipSpace; tok = $f.tok; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + err = [err]; + tok = sliceType$2.nil; + err[0] = $ifaceNil; + s = this; + $deferred.push([(function(err) { return function() { + var _tuple, e, ok, se; + e = $recover(); + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tuple = $assertType(e, scanError, true); + se = $clone(_tuple[0], scanError); + ok = _tuple[1]; + if (ok) { + err[0] = se.err; + } else { + $panic(e); + } + } + }; })(err), []]); + if (f === $throwNilPointerError) { + f = notSpace; + } + s.buf = $subslice(s.buf, 0, 0); + _r = s.token(skipSpace, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + tok = _r; + $s = -1; return [tok, err[0]]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [tok, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ss.ptr.prototype.Token }; } $f._r = _r; $f.err = err; $f.f = f; $f.s = s; $f.skipSpace = skipSpace; $f.tok = tok; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + ss.prototype.Token = function(skipSpace, f) { return this.$val.Token(skipSpace, f); }; + isSpace = function(r) { + var _i, _ref, r, rng, rx; + if (r >= 65536) { + return false; + } + rx = ((r << 16 >>> 16)); + _ref = space; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + rng = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), arrayType$1); + if (rx < rng[0]) { + return false; + } + if (rx <= rng[1]) { + return true; + } + _i++; + } + return false; + }; + notSpace = function(r) { + var r; + return !isSpace(r); + }; + ss.ptr.prototype.free = function(old) { + var old, s; + s = this; + if (old.validSave) { + ssave.copy(s.ssave, old); + return; + } + if (s.buf.$capacity > 1024) { + return; + } + s.buf = $subslice(s.buf, 0, 0); + s.rs = $ifaceNil; + ssFree.Put(s); + }; + ss.prototype.free = function(old) { return this.$val.free(old); }; + ss.ptr.prototype.SkipSpace = function() { + var _r, _r$1, _r$2, _v, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _v = $f._v; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + /* while (true) { */ case 1: + _r = s.getRune(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + if (r === -1) { + $s = -1; return; + } + if (!(r === 13)) { _v = false; $s = 6; continue s; } + _r$1 = s.peek("\n"); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = _r$1; case 6: + /* */ if (_v) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_v) { */ case 4: + /* continue; */ $s = 1; continue; + /* } */ case 5: + /* */ if (r === 10) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (r === 10) { */ case 8: + if (s.ssave.nlIsSpace) { + /* continue; */ $s = 1; continue; + } + s.errorString("unexpected newline"); + $s = -1; return; + /* } */ case 9: + /* */ if (!isSpace(r)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!isSpace(r)) { */ case 10: + _r$2 = s.UnreadRune(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* break; */ $s = 2; continue; + /* } */ case 11: + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.SkipSpace }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._v = _v; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.SkipSpace = function() { return this.$val.SkipSpace(); }; + ss.ptr.prototype.token = function(skipSpace, f) { + var _r, _r$1, _r$2, f, r, s, skipSpace, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; f = $f.f; r = $f.r; s = $f.s; skipSpace = $f.skipSpace; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + /* */ if (skipSpace) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (skipSpace) { */ case 1: + $r = s.SkipSpace(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + /* while (true) { */ case 4: + _r = s.getRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + if (r === -1) { + /* break; */ $s = 5; continue; + } + _r$1 = f(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!_r$1) { */ case 7: + _r$2 = s.UnreadRune(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* break; */ $s = 5; continue; + /* } */ case 8: + (s.$ptr_buf || (s.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, s))).WriteRune(r); + /* } */ $s = 4; continue; case 5: + $s = -1; return (x = s.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.token }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.f = f; $f.r = r; $f.s = s; $f.skipSpace = skipSpace; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.token = function(skipSpace, f) { return this.$val.token(skipSpace, f); }; + indexRune = function(s, r) { + var _i, _ref, _rune, c, i, r, s; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + c = _rune[0]; + if (c === r) { + return i; + } + _i += _rune[1]; + } + return -1; + }; + ss.ptr.prototype.peek = function(ok) { + var _r, _r$1, ok, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; ok = $f.ok; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _r = s.getRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + /* */ if (!((r === -1))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((r === -1))) { */ case 2: + _r$1 = s.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 3: + $s = -1; return indexRune(ok, r) >= 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.peek }; } $f._r = _r; $f._r$1 = _r$1; $f.ok = ok; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.peek = function(ok) { return this.$val.peek(ok); }; + ptrType$25.methods = [{prop: "clearflags", name: "clearflags", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "fmt", typ: $funcType([ptrType$1], [], false)}, {prop: "writePadding", name: "writePadding", pkg: "fmt", typ: $funcType([$Int], [], false)}, {prop: "pad", name: "pad", pkg: "fmt", typ: $funcType([sliceType$2], [], false)}, {prop: "padString", name: "padString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtBoolean", name: "fmtBoolean", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "fmtUnicode", name: "fmtUnicode", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtInteger", name: "fmtInteger", pkg: "fmt", typ: $funcType([$Uint64, $Int, $Bool, $String], [], false)}, {prop: "truncateString", name: "truncateString", pkg: "fmt", typ: $funcType([$String], [$String], false)}, {prop: "truncate", name: "truncate", pkg: "fmt", typ: $funcType([sliceType$2], [sliceType$2], false)}, {prop: "fmtS", name: "fmtS", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtBs", name: "fmtBs", pkg: "fmt", typ: $funcType([sliceType$2], [], false)}, {prop: "fmtSbx", name: "fmtSbx", pkg: "fmt", typ: $funcType([$String, sliceType$2, $String], [], false)}, {prop: "fmtSx", name: "fmtSx", pkg: "fmt", typ: $funcType([$String, $String], [], false)}, {prop: "fmtBx", name: "fmtBx", pkg: "fmt", typ: $funcType([sliceType$2, $String], [], false)}, {prop: "fmtQ", name: "fmtQ", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtC", name: "fmtC", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtQc", name: "fmtQc", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtFloat", name: "fmtFloat", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32, $Int], [], false)}]; + ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [], false)}]; + ptrType$2.methods = [{prop: "free", name: "free", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "unknownType", name: "unknownType", pkg: "fmt", typ: $funcType([reflect.Value], [], false)}, {prop: "badVerb", name: "badVerb", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "fmtBool", name: "fmtBool", pkg: "fmt", typ: $funcType([$Bool, $Int32], [], false)}, {prop: "fmt0x64", name: "fmt0x64", pkg: "fmt", typ: $funcType([$Uint64, $Bool], [], false)}, {prop: "fmtInteger", name: "fmtInteger", pkg: "fmt", typ: $funcType([$Uint64, $Bool, $Int32], [], false)}, {prop: "fmtFloat", name: "fmtFloat", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32], [], false)}, {prop: "fmtComplex", name: "fmtComplex", pkg: "fmt", typ: $funcType([$Complex128, $Int, $Int32], [], false)}, {prop: "fmtString", name: "fmtString", pkg: "fmt", typ: $funcType([$String, $Int32], [], false)}, {prop: "fmtBytes", name: "fmtBytes", pkg: "fmt", typ: $funcType([sliceType$2, $Int32, $String], [], false)}, {prop: "fmtPointer", name: "fmtPointer", pkg: "fmt", typ: $funcType([reflect.Value, $Int32], [], false)}, {prop: "catchPanic", name: "catchPanic", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32, $String], [], false)}, {prop: "handleMethods", name: "handleMethods", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "printArg", name: "printArg", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "printValue", name: "printValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [], false)}, {prop: "argNumber", name: "argNumber", pkg: "fmt", typ: $funcType([$Int, $String, $Int, $Int], [$Int, $Int, $Bool], false)}, {prop: "badArgNum", name: "badArgNum", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "missingArg", name: "missingArg", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "doPrintf", name: "doPrintf", pkg: "fmt", typ: $funcType([$String, sliceType], [], false)}, {prop: "doPrint", name: "doPrint", pkg: "fmt", typ: $funcType([sliceType], [], false)}, {prop: "doPrintln", name: "doPrintln", pkg: "fmt", typ: $funcType([sliceType], [], false)}]; + ptrType$5.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "getRune", name: "getRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "mustReadRune", name: "mustReadRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "error", name: "error", pkg: "fmt", typ: $funcType([$error], [], false)}, {prop: "errorString", name: "errorString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType$2, $error], false)}, {prop: "free", name: "free", pkg: "fmt", typ: $funcType([ssave], [], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "token", name: "token", pkg: "fmt", typ: $funcType([$Bool, funcType], [sliceType$2], false)}, {prop: "consume", name: "consume", pkg: "fmt", typ: $funcType([$String, $Bool], [$Bool], false)}, {prop: "peek", name: "peek", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "notEOF", name: "notEOF", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "accept", name: "accept", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "okVerb", name: "okVerb", pkg: "fmt", typ: $funcType([$Int32, $String, $String], [$Bool], false)}, {prop: "scanBool", name: "scanBool", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "getBase", name: "getBase", pkg: "fmt", typ: $funcType([$Int32], [$Int, $String], false)}, {prop: "scanNumber", name: "scanNumber", pkg: "fmt", typ: $funcType([$String, $Bool], [$String], false)}, {prop: "scanRune", name: "scanRune", pkg: "fmt", typ: $funcType([$Int], [$Int64], false)}, {prop: "scanBasePrefix", name: "scanBasePrefix", pkg: "fmt", typ: $funcType([], [$Int, $String, $Bool], false)}, {prop: "scanInt", name: "scanInt", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Int64], false)}, {prop: "scanUint", name: "scanUint", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Uint64], false)}, {prop: "floatToken", name: "floatToken", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "complexTokens", name: "complexTokens", pkg: "fmt", typ: $funcType([], [$String, $String], false)}, {prop: "convertFloat", name: "convertFloat", pkg: "fmt", typ: $funcType([$String, $Int], [$Float64], false)}, {prop: "scanComplex", name: "scanComplex", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Complex128], false)}, {prop: "convertString", name: "convertString", pkg: "fmt", typ: $funcType([$Int32], [$String], false)}, {prop: "quotedString", name: "quotedString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "hexByte", name: "hexByte", pkg: "fmt", typ: $funcType([], [$Uint8, $Bool], false)}, {prop: "hexString", name: "hexString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "scanOne", name: "scanOne", pkg: "fmt", typ: $funcType([$Int32, $emptyInterface], [], false)}, {prop: "doScan", name: "doScan", pkg: "fmt", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "advance", name: "advance", pkg: "fmt", typ: $funcType([$String], [$Int], false)}, {prop: "doScanf", name: "doScanf", pkg: "fmt", typ: $funcType([$String, sliceType], [$Int, $error], false)}]; + fmtFlags.init("fmt", [{prop: "widPresent", name: "widPresent", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "precPresent", name: "precPresent", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "minus", name: "minus", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "plus", name: "plus", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharp", name: "sharp", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "space", name: "space", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "zero", name: "zero", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "plusV", name: "plusV", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharpV", name: "sharpV", embedded: false, exported: false, typ: $Bool, tag: ""}]); + fmt.init("fmt", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "fmtFlags", name: "fmtFlags", embedded: true, exported: false, typ: fmtFlags, tag: ""}, {prop: "wid", name: "wid", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "prec", name: "prec", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "intbuf", name: "intbuf", embedded: false, exported: false, typ: arrayType, tag: ""}]); + State.init([{prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}]); + Formatter.init([{prop: "Format", name: "Format", pkg: "", typ: $funcType([State, $Int32], [], false)}]); + Stringer.init([{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]); + GoStringer.init([{prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]); + buffer.init($Uint8); + pp.init("fmt", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: buffer, tag: ""}, {prop: "arg", name: "arg", embedded: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "value", name: "value", embedded: false, exported: false, typ: reflect.Value, tag: ""}, {prop: "fmt", name: "fmt", embedded: false, exported: false, typ: fmt, tag: ""}, {prop: "reordered", name: "reordered", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "goodArgNum", name: "goodArgNum", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "panicking", name: "panicking", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "erroring", name: "erroring", embedded: false, exported: false, typ: $Bool, tag: ""}]); + ScanState.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType$2, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}]); + scanError.init("fmt", [{prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}]); + ss.init("fmt", [{prop: "rs", name: "rs", embedded: false, exported: false, typ: io.RuneScanner, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: buffer, tag: ""}, {prop: "count", name: "count", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "atEOF", name: "atEOF", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "ssave", name: "ssave", embedded: true, exported: false, typ: ssave, tag: ""}]); + ssave.init("fmt", [{prop: "validSave", name: "validSave", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsEnd", name: "nlIsEnd", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsSpace", name: "nlIsSpace", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "argLimit", name: "argLimit", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "limit", name: "limit", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "maxWid", name: "maxWid", embedded: false, exported: false, typ: $Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmtsort.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = os.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ppFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { + return new pp.ptr(buffer.nil, $ifaceNil, new reflect.Value.ptr(ptrType.nil, 0, 0), new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()), false, false, false, false); + })); + space = new sliceType$1([$toNativeArray($kindUint16, [9, 13]), $toNativeArray($kindUint16, [32, 32]), $toNativeArray($kindUint16, [133, 133]), $toNativeArray($kindUint16, [160, 160]), $toNativeArray($kindUint16, [5760, 5760]), $toNativeArray($kindUint16, [8192, 8202]), $toNativeArray($kindUint16, [8232, 8233]), $toNativeArray($kindUint16, [8239, 8239]), $toNativeArray($kindUint16, [8287, 8287]), $toNativeArray($kindUint16, [12288, 12288])]); + ssFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { + return new ss.ptr($ifaceNil, buffer.nil, 0, false, new ssave.ptr(false, false, false, 0, 0, 0)); + })); + complexError = errors.New("syntax error scanning complex number"); + boolError = errors.New("syntax error scanning boolean"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["strings"] = (function() { + var $pkg = {}, $init, errors, js, bytealg, io, sync, unicode, utf8, Builder, Reader, ptrType, sliceType, ptrType$6, IndexByte, Index, NewReader, Contains, ContainsRune, IndexRune, HasPrefix; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + bytealg = $packages["internal/bytealg"]; + io = $packages["io"]; + sync = $packages["sync"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + Builder = $pkg.Builder = $newType(0, $kindStruct, "strings.Builder", true, "strings", true, function(addr_, buf_) { + this.$val = this; + if (arguments.length === 0) { + this.addr = ptrType.nil; + this.buf = sliceType.nil; + return; + } + this.addr = addr_; + this.buf = buf_; + }); + Reader = $pkg.Reader = $newType(0, $kindStruct, "strings.Reader", true, "strings", true, function(s_, i_, prevRune_) { + this.$val = this; + if (arguments.length === 0) { + this.s = ""; + this.i = new $Int64(0, 0); + this.prevRune = 0; + return; + } + this.s = s_; + this.i = i_; + this.prevRune = prevRune_; + }); + ptrType = $ptrType(Builder); + sliceType = $sliceType($Uint8); + ptrType$6 = $ptrType(Reader); + IndexByte = function(s, c) { + var c, s; + return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; + }; + $pkg.IndexByte = IndexByte; + Index = function(s, sep) { + var s, sep; + return $parseInt(s.indexOf(sep)) >> 0; + }; + $pkg.Index = Index; + Builder.ptr.prototype.String = function() { + var b; + b = this; + return ($bytesToString(b.buf)); + }; + Builder.prototype.String = function() { return this.$val.String(); }; + Builder.ptr.prototype.copyCheck = function() { + var b; + b = this; + if (b.addr === ptrType.nil) { + b.addr = b; + } else if (!(b.addr === b)) { + $panic(new $String("strings: illegal use of non-zero Builder copied by value")); + } + }; + Builder.prototype.copyCheck = function() { return this.$val.copyCheck(); }; + Builder.ptr.prototype.Len = function() { + var b; + b = this; + return b.buf.$length; + }; + Builder.prototype.Len = function() { return this.$val.Len(); }; + Builder.ptr.prototype.Cap = function() { + var b; + b = this; + return b.buf.$capacity; + }; + Builder.prototype.Cap = function() { return this.$val.Cap(); }; + Builder.ptr.prototype.Reset = function() { + var b; + b = this; + b.addr = ptrType.nil; + b.buf = sliceType.nil; + }; + Builder.prototype.Reset = function() { return this.$val.Reset(); }; + Builder.ptr.prototype.grow = function(n) { + var b, buf, n; + b = this; + buf = $makeSlice(sliceType, b.buf.$length, (($imul(2, b.buf.$capacity)) + n >> 0)); + $copySlice(buf, b.buf); + b.buf = buf; + }; + Builder.prototype.grow = function(n) { return this.$val.grow(n); }; + Builder.ptr.prototype.Grow = function(n) { + var b, n; + b = this; + b.copyCheck(); + if (n < 0) { + $panic(new $String("strings.Builder.Grow: negative count")); + } + if ((b.buf.$capacity - b.buf.$length >> 0) < n) { + b.grow(n); + } + }; + Builder.prototype.Grow = function(n) { return this.$val.Grow(n); }; + Builder.ptr.prototype.Write = function(p) { + var b, p; + b = this; + b.copyCheck(); + b.buf = $appendSlice(b.buf, p); + return [p.$length, $ifaceNil]; + }; + Builder.prototype.Write = function(p) { return this.$val.Write(p); }; + Builder.ptr.prototype.WriteByte = function(c) { + var b, c; + b = this; + b.copyCheck(); + b.buf = $append(b.buf, c); + return $ifaceNil; + }; + Builder.prototype.WriteByte = function(c) { return this.$val.WriteByte(c); }; + Builder.ptr.prototype.WriteRune = function(r) { + var b, l, n, r; + b = this; + b.copyCheck(); + if (r < 128) { + b.buf = $append(b.buf, ((r << 24 >>> 24))); + return [1, $ifaceNil]; + } + l = b.buf.$length; + if ((b.buf.$capacity - l >> 0) < 4) { + b.grow(4); + } + n = utf8.EncodeRune($subslice(b.buf, l, (l + 4 >> 0)), r); + b.buf = $subslice(b.buf, 0, (l + n >> 0)); + return [n, $ifaceNil]; + }; + Builder.prototype.WriteRune = function(r) { return this.$val.WriteRune(r); }; + Builder.ptr.prototype.WriteString = function(s) { + var b, s; + b = this; + b.copyCheck(); + b.buf = $appendSlice(b.buf, s); + return [s.length, $ifaceNil]; + }; + Builder.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + Reader.ptr.prototype.Len = function() { + var r, x, x$1, x$2, x$3, x$4; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + return 0; + } + return (((x$2 = (x$3 = (new $Int64(0, r.s.length)), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); + }; + Reader.prototype.Len = function() { return this.$val.Len(); }; + Reader.ptr.prototype.Size = function() { + var r; + r = this; + return (new $Int64(0, r.s.length)); + }; + Reader.prototype.Size = function() { return this.$val.Size(); }; + Reader.ptr.prototype.Read = function(b) { + var _tmp, _tmp$1, b, err, n, r, x, x$1, x$2, x$3; + n = 0; + err = $ifaceNil; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + _tmp = 0; + _tmp$1 = io.EOF; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + r.prevRune = -1; + n = $copyString(b, $substring(r.s, $flatten64(r.i))); + r.i = (x$2 = r.i, x$3 = (new $Int64(0, n)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); + return [n, err]; + }; + Reader.prototype.Read = function(b) { return this.$val.Read(b); }; + Reader.ptr.prototype.ReadAt = function(b, off) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x; + n = 0; + err = $ifaceNil; + r = this; + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp = 0; + _tmp$1 = errors.New("strings.Reader.ReadAt: negative offset"); + n = _tmp; + err = _tmp$1; + return [n, err]; + } + if ((x = (new $Int64(0, r.s.length)), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) { + _tmp$2 = 0; + _tmp$3 = io.EOF; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + n = $copyString(b, $substring(r.s, $flatten64(off))); + if (n < b.$length) { + err = io.EOF; + } + return [n, err]; + }; + Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; + Reader.ptr.prototype.ReadByte = function() { + var b, r, x, x$1, x$2, x$3; + r = this; + r.prevRune = -1; + if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + return [0, io.EOF]; + } + b = r.s.charCodeAt($flatten64(r.i)); + r.i = (x$2 = r.i, x$3 = new $Int64(0, 1), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); + return [b, $ifaceNil]; + }; + Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; + Reader.ptr.prototype.UnreadByte = function() { + var r, x, x$1, x$2; + r = this; + if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { + return errors.New("strings.Reader.UnreadByte: at beginning of string"); + } + r.prevRune = -1; + r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + return $ifaceNil; + }; + Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; + Reader.ptr.prototype.ReadRune = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6; + ch = 0; + size = 0; + err = $ifaceNil; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + r.prevRune = -1; + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = io.EOF; + ch = _tmp; + size = _tmp$1; + err = _tmp$2; + return [ch, size, err]; + } + r.prevRune = (((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); + c = r.s.charCodeAt($flatten64(r.i)); + if (c < 128) { + r.i = (x$3 = r.i, x$4 = new $Int64(0, 1), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)); + _tmp$3 = ((c >> 0)); + _tmp$4 = 1; + _tmp$5 = $ifaceNil; + ch = _tmp$3; + size = _tmp$4; + err = _tmp$5; + return [ch, size, err]; + } + _tuple = utf8.DecodeRuneInString($substring(r.s, $flatten64(r.i))); + ch = _tuple[0]; + size = _tuple[1]; + r.i = (x$5 = r.i, x$6 = (new $Int64(0, size)), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)); + return [ch, size, err]; + }; + Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); }; + Reader.ptr.prototype.UnreadRune = function() { + var r, x; + r = this; + if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { + return errors.New("strings.Reader.UnreadRune: at beginning of string"); + } + if (r.prevRune < 0) { + return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune"); + } + r.i = (new $Int64(0, r.prevRune)); + r.prevRune = -1; + return $ifaceNil; + }; + Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + Reader.ptr.prototype.Seek = function(offset, whence) { + var _1, abs, offset, r, whence, x, x$1; + r = this; + r.prevRune = -1; + abs = new $Int64(0, 0); + _1 = whence; + if (_1 === (0)) { + abs = offset; + } else if (_1 === (1)) { + abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low)); + } else if (_1 === (2)) { + abs = (x$1 = (new $Int64(0, r.s.length)), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low)); + } else { + return [new $Int64(0, 0), errors.New("strings.Reader.Seek: invalid whence")]; + } + if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) { + return [new $Int64(0, 0), errors.New("strings.Reader.Seek: negative position")]; + } + r.i = abs; + return [abs, $ifaceNil]; + }; + Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + Reader.ptr.prototype.WriteTo = function(w) { + var _r, _tmp, _tmp$1, _tuple, err, m, n, r, s, w, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; m = $f.m; n = $f.n; r = $f.r; s = $f.s; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Int64(0, 0); + err = $ifaceNil; + r = this; + r.prevRune = -1; + if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + _tmp = new $Int64(0, 0); + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + s = $substring(r.s, $flatten64(r.i)); + _r = io.WriteString(w, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + err = _tuple[1]; + if (m > s.length) { + $panic(new $String("strings.Reader.WriteTo: invalid WriteString count")); + } + r.i = (x$2 = r.i, x$3 = (new $Int64(0, m)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); + n = (new $Int64(0, m)); + if (!((m === s.length)) && $interfaceIsEqual(err, $ifaceNil)) { + err = io.ErrShortWrite; + } + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.s = s; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; + Reader.ptr.prototype.Reset = function(s) { + var r, s; + r = this; + Reader.copy(r, new Reader.ptr(s, new $Int64(0, 0), -1)); + }; + Reader.prototype.Reset = function(s) { return this.$val.Reset(s); }; + NewReader = function(s) { + var s; + return new Reader.ptr(s, new $Int64(0, 0), -1); + }; + $pkg.NewReader = NewReader; + Contains = function(s, substr) { + var s, substr; + return Index(s, substr) >= 0; + }; + $pkg.Contains = Contains; + ContainsRune = function(s, r) { + var r, s; + return IndexRune(s, r) >= 0; + }; + $pkg.ContainsRune = ContainsRune; + IndexRune = function(s, r) { + var _i, _ref, _rune, i, r, r$1, s; + if (0 <= r && r < 128) { + return IndexByte(s, ((r << 24 >>> 24))); + } else if ((r === 65533)) { + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + r$1 = _rune[0]; + if (r$1 === 65533) { + return i; + } + _i += _rune[1]; + } + return -1; + } else if (!utf8.ValidRune(r)) { + return -1; + } else { + return Index(s, ($encodeRune(r))); + } + }; + $pkg.IndexRune = IndexRune; + HasPrefix = function(s, prefix) { + var prefix, s; + return s.length >= prefix.length && $substring(s, 0, prefix.length) === prefix; + }; + $pkg.HasPrefix = HasPrefix; + ptrType.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "copyCheck", name: "copyCheck", pkg: "strings", typ: $funcType([], [], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "grow", name: "grow", pkg: "strings", typ: $funcType([$Int], [], false)}, {prop: "Grow", name: "Grow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}]; + ptrType$6.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([$String], [], false)}]; + Builder.init("strings", [{prop: "addr", name: "addr", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}]); + Reader.init("strings", [{prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", embedded: false, exported: false, typ: $Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bytealg.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["encoding/hex"] = (function() { + var $pkg = {}, $init, errors, fmt, io, strings, sliceType$1, EncodedLen, Encode, EncodeToString; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + io = $packages["io"]; + strings = $packages["strings"]; + sliceType$1 = $sliceType($Uint8); + EncodedLen = function(n) { + var n; + return $imul(n, 2); + }; + $pkg.EncodedLen = EncodedLen; + Encode = function(dst, src) { + var _i, _ref, dst, i, src, v, x, x$1; + _ref = src; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + (x = $imul(i, 2), ((x < 0 || x >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x] = "0123456789abcdef".charCodeAt((v >>> 4 << 24 >>> 24)))); + (x$1 = ($imul(i, 2)) + 1 >> 0, ((x$1 < 0 || x$1 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$1] = "0123456789abcdef".charCodeAt(((v & 15) >>> 0)))); + _i++; + } + return $imul(src.$length, 2); + }; + $pkg.Encode = Encode; + EncodeToString = function(src) { + var dst, src; + dst = $makeSlice(sliceType$1, EncodedLen(src.$length)); + Encode(dst, src); + return ($bytesToString(dst)); + }; + $pkg.EncodeToString = EncodeToString; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrLength = errors.New("encoding/hex: odd length hex string"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["bytes"] = (function() { + var $pkg = {}, $init, errors, bytealg, io, unicode, utf8, Buffer, readOp, asciiSet, Reader, ptrType, sliceType, ptrType$1, arrayType$1, ptrType$2, errNegativeRead, IndexByte, Equal, makeSlice, HasPrefix, TrimRightFunc, lastIndexFunc, makeASCIISet, makeCutsetFunc, TrimRight, EqualFold, Index, indexRabinKarp, hashStr, NewReader; + errors = $packages["errors"]; + bytealg = $packages["internal/bytealg"]; + io = $packages["io"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + Buffer = $pkg.Buffer = $newType(0, $kindStruct, "bytes.Buffer", true, "bytes", true, function(buf_, off_, lastRead_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = sliceType.nil; + this.off = 0; + this.lastRead = 0; + return; + } + this.buf = buf_; + this.off = off_; + this.lastRead = lastRead_; + }); + readOp = $pkg.readOp = $newType(1, $kindInt8, "bytes.readOp", true, "bytes", false, null); + asciiSet = $pkg.asciiSet = $newType(32, $kindArray, "bytes.asciiSet", true, "bytes", false, null); + Reader = $pkg.Reader = $newType(0, $kindStruct, "bytes.Reader", true, "bytes", true, function(s_, i_, prevRune_) { + this.$val = this; + if (arguments.length === 0) { + this.s = sliceType.nil; + this.i = new $Int64(0, 0); + this.prevRune = 0; + return; + } + this.s = s_; + this.i = i_; + this.prevRune = prevRune_; + }); + ptrType = $ptrType(Buffer); + sliceType = $sliceType($Uint8); + ptrType$1 = $ptrType(asciiSet); + arrayType$1 = $arrayType($Uint32, 8); + ptrType$2 = $ptrType(Reader); + IndexByte = function(s, c) { + var _i, _ref, b, c, i, s; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b === c) { + return i; + } + _i++; + } + return -1; + }; + $pkg.IndexByte = IndexByte; + Equal = function(a, b) { + var _i, _ref, a, b, c, i; + if (!((a.$length === b.$length))) { + return false; + } + _ref = a; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((c === ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i])))) { + return false; + } + _i++; + } + return true; + }; + $pkg.Equal = Equal; + Buffer.ptr.prototype.Bytes = function() { + var b; + b = this; + return $subslice(b.buf, b.off); + }; + Buffer.prototype.Bytes = function() { return this.$val.Bytes(); }; + Buffer.ptr.prototype.String = function() { + var b; + b = this; + if (b === ptrType.nil) { + return ""; + } + return ($bytesToString($subslice(b.buf, b.off))); + }; + Buffer.prototype.String = function() { return this.$val.String(); }; + Buffer.ptr.prototype.empty = function() { + var b; + b = this; + return b.buf.$length <= b.off; + }; + Buffer.prototype.empty = function() { return this.$val.empty(); }; + Buffer.ptr.prototype.Len = function() { + var b; + b = this; + return b.buf.$length - b.off >> 0; + }; + Buffer.prototype.Len = function() { return this.$val.Len(); }; + Buffer.ptr.prototype.Cap = function() { + var b; + b = this; + return b.buf.$capacity; + }; + Buffer.prototype.Cap = function() { return this.$val.Cap(); }; + Buffer.ptr.prototype.Truncate = function(n) { + var b, n; + b = this; + if (n === 0) { + b.Reset(); + return; + } + b.lastRead = 0; + if (n < 0 || n > b.Len()) { + $panic(new $String("bytes.Buffer: truncation out of range")); + } + b.buf = $subslice(b.buf, 0, (b.off + n >> 0)); + }; + Buffer.prototype.Truncate = function(n) { return this.$val.Truncate(n); }; + Buffer.ptr.prototype.Reset = function() { + var b; + b = this; + b.buf = $subslice(b.buf, 0, 0); + b.off = 0; + b.lastRead = 0; + }; + Buffer.prototype.Reset = function() { return this.$val.Reset(); }; + Buffer.ptr.prototype.tryGrowByReslice = function(n) { + var b, l, n; + b = this; + l = b.buf.$length; + if (n <= (b.buf.$capacity - l >> 0)) { + b.buf = $subslice(b.buf, 0, (l + n >> 0)); + return [l, true]; + } + return [0, false]; + }; + Buffer.prototype.tryGrowByReslice = function(n) { return this.$val.tryGrowByReslice(n); }; + Buffer.ptr.prototype.grow = function(n) { + var _q, _tuple, b, buf, c, i, m, n, ok; + b = this; + m = b.Len(); + if ((m === 0) && !((b.off === 0))) { + b.Reset(); + } + _tuple = b.tryGrowByReslice(n); + i = _tuple[0]; + ok = _tuple[1]; + if (ok) { + return i; + } + if (b.buf === sliceType.nil && n <= 64) { + b.buf = $makeSlice(sliceType, n, 64); + return 0; + } + c = b.buf.$capacity; + if (n <= ((_q = c / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) - m >> 0)) { + $copySlice(b.buf, $subslice(b.buf, b.off)); + } else if (c > ((2147483647 - c >> 0) - n >> 0)) { + $panic($pkg.ErrTooLarge); + } else { + buf = makeSlice(($imul(2, c)) + n >> 0); + $copySlice(buf, $subslice(b.buf, b.off)); + b.buf = buf; + } + b.off = 0; + b.buf = $subslice(b.buf, 0, (m + n >> 0)); + return m; + }; + Buffer.prototype.grow = function(n) { return this.$val.grow(n); }; + Buffer.ptr.prototype.Grow = function(n) { + var b, m, n; + b = this; + if (n < 0) { + $panic(new $String("bytes.Buffer.Grow: negative count")); + } + m = b.grow(n); + b.buf = $subslice(b.buf, 0, m); + }; + Buffer.prototype.Grow = function(n) { return this.$val.Grow(n); }; + Buffer.ptr.prototype.Write = function(p) { + var _tmp, _tmp$1, _tuple, b, err, m, n, ok, p; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + _tuple = b.tryGrowByReslice(p.$length); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = b.grow(p.$length); + } + _tmp = $copySlice($subslice(b.buf, m), p); + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + Buffer.prototype.Write = function(p) { return this.$val.Write(p); }; + Buffer.ptr.prototype.WriteString = function(s) { + var _tmp, _tmp$1, _tuple, b, err, m, n, ok, s; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + _tuple = b.tryGrowByReslice(s.length); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = b.grow(s.length); + } + _tmp = $copyString($subslice(b.buf, m), s); + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + Buffer.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + Buffer.ptr.prototype.ReadFrom = function(r) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, i, m, n, r, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; i = $f.i; m = $f.m; n = $f.n; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Int64(0, 0); + err = $ifaceNil; + b = this; + b.lastRead = 0; + /* while (true) { */ case 1: + i = b.grow(512); + b.buf = $subslice(b.buf, 0, i); + _r = r.Read($subslice(b.buf, i, b.buf.$capacity)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (m < 0) { + $panic(errNegativeRead); + } + b.buf = $subslice(b.buf, 0, (i + m >> 0)); + n = (x = (new $Int64(0, m)), new $Int64(n.$high + x.$high, n.$low + x.$low)); + if ($interfaceIsEqual(e, io.EOF)) { + _tmp = n; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp$2 = n; + _tmp$3 = e; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* } */ $s = 1; continue; case 2: + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.ReadFrom }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.i = i; $f.m = m; $f.n = n; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Buffer.prototype.ReadFrom = function(r) { return this.$val.ReadFrom(r); }; + makeSlice = function(n) { + var n, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([(function() { + if (!($interfaceIsEqual($recover(), $ifaceNil))) { + $panic($pkg.ErrTooLarge); + } + }), []]); + return $makeSlice(sliceType, n); + /* */ } catch(err) { $err = err; return sliceType.nil; } finally { $callDeferred($deferred, $err); } + }; + Buffer.ptr.prototype.WriteTo = function(w) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, b, e, err, m, n, nBytes, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; n = $f.n; nBytes = $f.nBytes; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Int64(0, 0); + err = $ifaceNil; + b = this; + b.lastRead = 0; + nBytes = b.Len(); + /* */ if (nBytes > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (nBytes > 0) { */ case 1: + _r = w.Write($subslice(b.buf, b.off)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (m > nBytes) { + $panic(new $String("bytes.Buffer.WriteTo: invalid Write count")); + } + b.off = b.off + (m) >> 0; + n = (new $Int64(0, m)); + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp = n; + _tmp$1 = e; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if (!((m === nBytes))) { + _tmp$2 = n; + _tmp$3 = io.ErrShortWrite; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* } */ case 2: + b.Reset(); + _tmp$4 = n; + _tmp$5 = $ifaceNil; + n = _tmp$4; + err = _tmp$5; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.n = n; $f.nBytes = nBytes; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + Buffer.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; + Buffer.ptr.prototype.WriteByte = function(c) { + var _tuple, b, c, m, ok, x; + b = this; + b.lastRead = 0; + _tuple = b.tryGrowByReslice(1); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = b.grow(1); + } + (x = b.buf, ((m < 0 || m >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + m] = c)); + return $ifaceNil; + }; + Buffer.prototype.WriteByte = function(c) { return this.$val.WriteByte(c); }; + Buffer.ptr.prototype.WriteRune = function(r) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, err, m, n, ok, r; + n = 0; + err = $ifaceNil; + b = this; + if (r < 128) { + b.WriteByte(((r << 24 >>> 24))); + _tmp = 1; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + b.lastRead = 0; + _tuple = b.tryGrowByReslice(4); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = b.grow(4); + } + n = utf8.EncodeRune($subslice(b.buf, m, (m + 4 >> 0)), r); + b.buf = $subslice(b.buf, 0, (m + n >> 0)); + _tmp$2 = n; + _tmp$3 = $ifaceNil; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + }; + Buffer.prototype.WriteRune = function(r) { return this.$val.WriteRune(r); }; + Buffer.ptr.prototype.Read = function(p) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, err, n, p; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + if (b.empty()) { + b.Reset(); + if (p.$length === 0) { + _tmp = 0; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + _tmp$2 = 0; + _tmp$3 = io.EOF; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + n = $copySlice(p, $subslice(b.buf, b.off)); + b.off = b.off + (n) >> 0; + if (n > 0) { + b.lastRead = -1; + } + _tmp$4 = n; + _tmp$5 = $ifaceNil; + n = _tmp$4; + err = _tmp$5; + return [n, err]; + }; + Buffer.prototype.Read = function(p) { return this.$val.Read(p); }; + Buffer.ptr.prototype.Next = function(n) { + var b, data, m, n; + b = this; + b.lastRead = 0; + m = b.Len(); + if (n > m) { + n = m; + } + data = $subslice(b.buf, b.off, (b.off + n >> 0)); + b.off = b.off + (n) >> 0; + if (n > 0) { + b.lastRead = -1; + } + return data; + }; + Buffer.prototype.Next = function(n) { return this.$val.Next(n); }; + Buffer.ptr.prototype.ReadByte = function() { + var b, c, x, x$1; + b = this; + if (b.empty()) { + b.Reset(); + return [0, io.EOF]; + } + c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + b.off = b.off + (1) >> 0; + b.lastRead = -1; + return [c, $ifaceNil]; + }; + Buffer.prototype.ReadByte = function() { return this.$val.ReadByte(); }; + Buffer.ptr.prototype.ReadRune = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, b, c, err, n, r, size, x, x$1; + r = 0; + size = 0; + err = $ifaceNil; + b = this; + if (b.empty()) { + b.Reset(); + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = io.EOF; + r = _tmp; + size = _tmp$1; + err = _tmp$2; + return [r, size, err]; + } + c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (c < 128) { + b.off = b.off + (1) >> 0; + b.lastRead = 1; + _tmp$3 = ((c >> 0)); + _tmp$4 = 1; + _tmp$5 = $ifaceNil; + r = _tmp$3; + size = _tmp$4; + err = _tmp$5; + return [r, size, err]; + } + _tuple = utf8.DecodeRune($subslice(b.buf, b.off)); + r = _tuple[0]; + n = _tuple[1]; + b.off = b.off + (n) >> 0; + b.lastRead = ((n << 24 >> 24)); + _tmp$6 = r; + _tmp$7 = n; + _tmp$8 = $ifaceNil; + r = _tmp$6; + size = _tmp$7; + err = _tmp$8; + return [r, size, err]; + }; + Buffer.prototype.ReadRune = function() { return this.$val.ReadRune(); }; + Buffer.ptr.prototype.UnreadRune = function() { + var b; + b = this; + if (b.lastRead <= 0) { + return errors.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune"); + } + if (b.off >= ((b.lastRead >> 0))) { + b.off = b.off - (((b.lastRead >> 0))) >> 0; + } + b.lastRead = 0; + return $ifaceNil; + }; + Buffer.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + Buffer.ptr.prototype.UnreadByte = function() { + var b; + b = this; + if (b.lastRead === 0) { + return errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read"); + } + b.lastRead = 0; + if (b.off > 0) { + b.off = b.off - (1) >> 0; + } + return $ifaceNil; + }; + Buffer.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; + Buffer.ptr.prototype.ReadBytes = function(delim) { + var _tmp, _tmp$1, _tuple, b, delim, err, line, slice; + line = sliceType.nil; + err = $ifaceNil; + b = this; + _tuple = b.readSlice(delim); + slice = _tuple[0]; + err = _tuple[1]; + line = $appendSlice(line, slice); + _tmp = line; + _tmp$1 = err; + line = _tmp; + err = _tmp$1; + return [line, err]; + }; + Buffer.prototype.ReadBytes = function(delim) { return this.$val.ReadBytes(delim); }; + Buffer.ptr.prototype.readSlice = function(delim) { + var _tmp, _tmp$1, b, delim, end, err, i, line; + line = sliceType.nil; + err = $ifaceNil; + b = this; + i = IndexByte($subslice(b.buf, b.off), delim); + end = (b.off + i >> 0) + 1 >> 0; + if (i < 0) { + end = b.buf.$length; + err = io.EOF; + } + line = $subslice(b.buf, b.off, end); + b.off = end; + b.lastRead = -1; + _tmp = line; + _tmp$1 = err; + line = _tmp; + err = _tmp$1; + return [line, err]; + }; + Buffer.prototype.readSlice = function(delim) { return this.$val.readSlice(delim); }; + Buffer.ptr.prototype.ReadString = function(delim) { + var _tmp, _tmp$1, _tuple, b, delim, err, line, slice; + line = ""; + err = $ifaceNil; + b = this; + _tuple = b.readSlice(delim); + slice = _tuple[0]; + err = _tuple[1]; + _tmp = ($bytesToString(slice)); + _tmp$1 = err; + line = _tmp; + err = _tmp$1; + return [line, err]; + }; + Buffer.prototype.ReadString = function(delim) { return this.$val.ReadString(delim); }; + HasPrefix = function(s, prefix) { + var prefix, s; + return s.$length >= prefix.$length && Equal($subslice(s, 0, prefix.$length), prefix); + }; + $pkg.HasPrefix = HasPrefix; + TrimRightFunc = function(s, f) { + var _r, _tuple, f, i, s, wid, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; f = $f.f; i = $f.i; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = lastIndexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + i = _r; + if (i >= 0 && ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) >= 128) { + _tuple = utf8.DecodeRune($subslice(s, i)); + wid = _tuple[1]; + i = i + (wid) >> 0; + } else { + i = i + (1) >> 0; + } + $s = -1; return $subslice(s, 0, i); + /* */ } return; } if ($f === undefined) { $f = { $blk: TrimRightFunc }; } $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.TrimRightFunc = TrimRightFunc; + lastIndexFunc = function(s, f, truth) { + var _r, _tmp, _tmp$1, _tuple, f, i, r, s, size, truth, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; i = $f.i; r = $f.r; s = $f.s; size = $f.size; truth = $f.truth; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = s.$length; + /* while (true) { */ case 1: + /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 2; continue; } + _tmp = (((x = i - 1 >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) >> 0)); + _tmp$1 = 1; + r = _tmp; + size = _tmp$1; + if (r >= 128) { + _tuple = utf8.DecodeLastRune($subslice(s, 0, i)); + r = _tuple[0]; + size = _tuple[1]; + } + i = i - (size) >> 0; + _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === truth) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_r === truth) { */ case 3: + $s = -1; return i; + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return -1; + /* */ } return; } if ($f === undefined) { $f = { $blk: lastIndexFunc }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.r = r; $f.s = s; $f.size = size; $f.truth = truth; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + makeASCIISet = function(chars) { + var _index, _tmp, _tmp$1, _tmp$2, _tmp$3, as, c, chars, i, ok, y; + as = arrayType$1.zero(); + ok = false; + i = 0; + while (true) { + if (!(i < chars.length)) { break; } + c = chars.charCodeAt(i); + if (c >= 128) { + _tmp = $clone(as, asciiSet); + _tmp$1 = false; + asciiSet.copy(as, _tmp); + ok = _tmp$1; + return [as, ok]; + } + _index = c >>> 5 << 24 >>> 24; + ((_index < 0 || _index >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[_index] = ((((_index < 0 || _index >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[_index]) | (((y = ((((c & 31) >>> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0)); + i = i + (1) >> 0; + } + _tmp$2 = $clone(as, asciiSet); + _tmp$3 = true; + asciiSet.copy(as, _tmp$2); + ok = _tmp$3; + return [as, ok]; + }; + asciiSet.prototype.contains = function(c) { + var as, c, x, y; + as = this.$val; + return !((((((x = c >>> 5 << 24 >>> 24, (as.nilCheck, ((x < 0 || x >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[x]))) & (((y = ((((c & 31) >>> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0)) === 0)); + }; + $ptrType(asciiSet).prototype.contains = function(c) { return (new asciiSet(this.$get())).contains(c); }; + makeCutsetFunc = function(cutset) { + var _tuple, as, cutset, isASCII; + if ((cutset.length === 1) && cutset.charCodeAt(0) < 128) { + return (function(r) { + var r; + return r === ((cutset.charCodeAt(0) >> 0)); + }); + } + _tuple = makeASCIISet(cutset); + as = $clone(_tuple[0], asciiSet); + isASCII = _tuple[1]; + if (isASCII) { + return (function(r) { + var r; + return r < 128 && new ptrType$1(as).contains(((r << 24 >>> 24))); + }); + } + return (function(r) { + var _i, _ref, _rune, c, r; + _ref = cutset; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + c = _rune[0]; + if (c === r) { + return true; + } + _i += _rune[1]; + } + return false; + }); + }; + TrimRight = function(s, cutset) { + var _r, cutset, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; cutset = $f.cutset; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = TrimRightFunc(s, makeCutsetFunc(cutset)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: TrimRight }; } $f._r = _r; $f.cutset = cutset; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.TrimRight = TrimRight; + EqualFold = function(s, t) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, r, r$1, r$2, s, size, size$1, sr, t, tr; + while (true) { + if (!(!((s.$length === 0)) && !((t.$length === 0)))) { break; } + _tmp = 0; + _tmp$1 = 0; + sr = _tmp; + tr = _tmp$1; + if ((0 >= s.$length ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + 0]) < 128) { + _tmp$2 = (((0 >= s.$length ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + 0]) >> 0)); + _tmp$3 = $subslice(s, 1); + sr = _tmp$2; + s = _tmp$3; + } else { + _tuple = utf8.DecodeRune(s); + r = _tuple[0]; + size = _tuple[1]; + _tmp$4 = r; + _tmp$5 = $subslice(s, size); + sr = _tmp$4; + s = _tmp$5; + } + if ((0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]) < 128) { + _tmp$6 = (((0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]) >> 0)); + _tmp$7 = $subslice(t, 1); + tr = _tmp$6; + t = _tmp$7; + } else { + _tuple$1 = utf8.DecodeRune(t); + r$1 = _tuple$1[0]; + size$1 = _tuple$1[1]; + _tmp$8 = r$1; + _tmp$9 = $subslice(t, size$1); + tr = _tmp$8; + t = _tmp$9; + } + if (tr === sr) { + continue; + } + if (tr < sr) { + _tmp$10 = sr; + _tmp$11 = tr; + tr = _tmp$10; + sr = _tmp$11; + } + if (tr < 128) { + if (65 <= sr && sr <= 90 && (tr === ((sr + 97 >> 0) - 65 >> 0))) { + continue; + } + return false; + } + r$2 = unicode.SimpleFold(sr); + while (true) { + if (!(!((r$2 === sr)) && r$2 < tr)) { break; } + r$2 = unicode.SimpleFold(r$2); + } + if (r$2 === tr) { + continue; + } + return false; + } + return s.$length === t.$length; + }; + $pkg.EqualFold = EqualFold; + Index = function(s, sep) { + var c0, c0$1, c1, c1$1, fails, fails$1, i, i$1, j, n, o, o$1, r, s, sep, t, t$1, x, x$1; + n = sep.$length; + if ((n === 0)) { + return 0; + } else if ((n === 1)) { + return IndexByte(s, (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0])); + } else if ((n === s.$length)) { + if (Equal(sep, s)) { + return 0; + } + return -1; + } else if (n > s.$length) { + return -1; + } else if (n <= bytealg.MaxLen) { + if (s.$length <= 0) { + return bytealg.Index(s, sep); + } + c0 = (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0]); + c1 = (1 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 1]); + i = 0; + t = (s.$length - n >> 0) + 1 >> 0; + fails = 0; + while (true) { + if (!(i < t)) { break; } + if (!((((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) === c0))) { + o = IndexByte($subslice(s, i, t), c0); + if (o < 0) { + return -1; + } + i = i + (o) >> 0; + } + if (((x = i + 1 >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) === c1) && Equal($subslice(s, i, (i + n >> 0)), sep)) { + return i; + } + fails = fails + (1) >> 0; + i = i + (1) >> 0; + if (fails > bytealg.Cutover(i)) { + r = bytealg.Index($subslice(s, i), sep); + if (r >= 0) { + return r + i >> 0; + } + return -1; + } + } + return -1; + } + c0$1 = (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0]); + c1$1 = (1 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 1]); + i$1 = 0; + fails$1 = 0; + t$1 = (s.$length - n >> 0) + 1 >> 0; + while (true) { + if (!(i$1 < t$1)) { break; } + if (!((((i$1 < 0 || i$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i$1]) === c0$1))) { + o$1 = IndexByte($subslice(s, i$1, t$1), c0$1); + if (o$1 < 0) { + break; + } + i$1 = i$1 + (o$1) >> 0; + } + if (((x$1 = i$1 + 1 >> 0, ((x$1 < 0 || x$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x$1])) === c1$1) && Equal($subslice(s, i$1, (i$1 + n >> 0)), sep)) { + return i$1; + } + i$1 = i$1 + (1) >> 0; + fails$1 = fails$1 + (1) >> 0; + if (fails$1 >= (4 + (i$1 >> 4 >> 0) >> 0) && i$1 < t$1) { + j = indexRabinKarp($subslice(s, i$1), sep); + if (j < 0) { + return -1; + } + return i$1 + j >> 0; + } + } + return -1; + }; + $pkg.Index = Index; + indexRabinKarp = function(s, sep) { + var _tuple, h, hashsep, i, i$1, n, pow, s, sep, x; + _tuple = hashStr(sep); + hashsep = _tuple[0]; + pow = _tuple[1]; + n = sep.$length; + h = 0; + i = 0; + while (true) { + if (!(i < n)) { break; } + h = ($imul(h, 16777619) >>> 0) + ((((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) >>> 0)) >>> 0; + i = i + (1) >> 0; + } + if ((h === hashsep) && Equal($subslice(s, 0, n), sep)) { + return 0; + } + i$1 = n; + while (true) { + if (!(i$1 < s.$length)) { break; } + h = $imul(h, (16777619)) >>> 0; + h = h + (((((i$1 < 0 || i$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i$1]) >>> 0))) >>> 0; + h = h - (($imul(pow, (((x = i$1 - n >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) >>> 0))) >>> 0)) >>> 0; + i$1 = i$1 + (1) >> 0; + if ((h === hashsep) && Equal($subslice(s, (i$1 - n >> 0), i$1), sep)) { + return i$1 - n >> 0; + } + } + return -1; + }; + hashStr = function(sep) { + var _tmp, _tmp$1, hash, i, i$1, pow, sep, sq; + hash = 0; + i = 0; + while (true) { + if (!(i < sep.$length)) { break; } + hash = ($imul(hash, 16777619) >>> 0) + ((((i < 0 || i >= sep.$length) ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + i]) >>> 0)) >>> 0; + i = i + (1) >> 0; + } + _tmp = 1; + _tmp$1 = 16777619; + pow = _tmp; + sq = _tmp$1; + i$1 = sep.$length; + while (true) { + if (!(i$1 > 0)) { break; } + if (!(((i$1 & 1) === 0))) { + pow = $imul(pow, (sq)) >>> 0; + } + sq = $imul(sq, (sq)) >>> 0; + i$1 = (i$1 >> $min((1), 31)) >> 0; + } + return [hash, pow]; + }; + Reader.ptr.prototype.Len = function() { + var r, x, x$1, x$2, x$3, x$4; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + return 0; + } + return (((x$2 = (x$3 = (new $Int64(0, r.s.$length)), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); + }; + Reader.prototype.Len = function() { return this.$val.Len(); }; + Reader.ptr.prototype.Size = function() { + var r; + r = this; + return (new $Int64(0, r.s.$length)); + }; + Reader.prototype.Size = function() { return this.$val.Size(); }; + Reader.ptr.prototype.Read = function(b) { + var _tmp, _tmp$1, b, err, n, r, x, x$1, x$2, x$3; + n = 0; + err = $ifaceNil; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + _tmp = 0; + _tmp$1 = io.EOF; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + r.prevRune = -1; + n = $copySlice(b, $subslice(r.s, $flatten64(r.i))); + r.i = (x$2 = r.i, x$3 = (new $Int64(0, n)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); + return [n, err]; + }; + Reader.prototype.Read = function(b) { return this.$val.Read(b); }; + Reader.ptr.prototype.ReadAt = function(b, off) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x; + n = 0; + err = $ifaceNil; + r = this; + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp = 0; + _tmp$1 = errors.New("bytes.Reader.ReadAt: negative offset"); + n = _tmp; + err = _tmp$1; + return [n, err]; + } + if ((x = (new $Int64(0, r.s.$length)), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) { + _tmp$2 = 0; + _tmp$3 = io.EOF; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + n = $copySlice(b, $subslice(r.s, $flatten64(off))); + if (n < b.$length) { + err = io.EOF; + } + return [n, err]; + }; + Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; + Reader.ptr.prototype.ReadByte = function() { + var b, r, x, x$1, x$2, x$3, x$4, x$5; + r = this; + r.prevRune = -1; + if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + return [0, io.EOF]; + } + b = (x$2 = r.s, x$3 = r.i, (($flatten64(x$3) < 0 || $flatten64(x$3) >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + $flatten64(x$3)])); + r.i = (x$4 = r.i, x$5 = new $Int64(0, 1), new $Int64(x$4.$high + x$5.$high, x$4.$low + x$5.$low)); + return [b, $ifaceNil]; + }; + Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; + Reader.ptr.prototype.UnreadByte = function() { + var r, x, x$1, x$2; + r = this; + if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { + return errors.New("bytes.Reader.UnreadByte: at beginning of slice"); + } + r.prevRune = -1; + r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + return $ifaceNil; + }; + Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; + Reader.ptr.prototype.ReadRune = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; + ch = 0; + size = 0; + err = $ifaceNil; + r = this; + if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + r.prevRune = -1; + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = io.EOF; + ch = _tmp; + size = _tmp$1; + err = _tmp$2; + return [ch, size, err]; + } + r.prevRune = (((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); + c = (x$3 = r.s, x$4 = r.i, (($flatten64(x$4) < 0 || $flatten64(x$4) >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + $flatten64(x$4)])); + if (c < 128) { + r.i = (x$5 = r.i, x$6 = new $Int64(0, 1), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)); + _tmp$3 = ((c >> 0)); + _tmp$4 = 1; + _tmp$5 = $ifaceNil; + ch = _tmp$3; + size = _tmp$4; + err = _tmp$5; + return [ch, size, err]; + } + _tuple = utf8.DecodeRune($subslice(r.s, $flatten64(r.i))); + ch = _tuple[0]; + size = _tuple[1]; + r.i = (x$7 = r.i, x$8 = (new $Int64(0, size)), new $Int64(x$7.$high + x$8.$high, x$7.$low + x$8.$low)); + return [ch, size, err]; + }; + Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); }; + Reader.ptr.prototype.UnreadRune = function() { + var r, x; + r = this; + if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { + return errors.New("bytes.Reader.UnreadRune: at beginning of slice"); + } + if (r.prevRune < 0) { + return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune"); + } + r.i = (new $Int64(0, r.prevRune)); + r.prevRune = -1; + return $ifaceNil; + }; + Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + Reader.ptr.prototype.Seek = function(offset, whence) { + var _1, abs, offset, r, whence, x, x$1; + r = this; + r.prevRune = -1; + abs = new $Int64(0, 0); + _1 = whence; + if (_1 === (0)) { + abs = offset; + } else if (_1 === (1)) { + abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low)); + } else if (_1 === (2)) { + abs = (x$1 = (new $Int64(0, r.s.$length)), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low)); + } else { + return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: invalid whence")]; + } + if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) { + return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: negative position")]; + } + r.i = abs; + return [abs, $ifaceNil]; + }; + Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + Reader.ptr.prototype.WriteTo = function(w) { + var _r, _tmp, _tmp$1, _tuple, b, err, m, n, r, w, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; m = $f.m; n = $f.n; r = $f.r; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Int64(0, 0); + err = $ifaceNil; + r = this; + r.prevRune = -1; + if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { + _tmp = new $Int64(0, 0); + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + b = $subslice(r.s, $flatten64(r.i)); + _r = w.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + err = _tuple[1]; + if (m > b.$length) { + $panic(new $String("bytes.Reader.WriteTo: invalid Write count")); + } + r.i = (x$2 = r.i, x$3 = (new $Int64(0, m)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); + n = (new $Int64(0, m)); + if (!((m === b.$length)) && $interfaceIsEqual(err, $ifaceNil)) { + err = io.ErrShortWrite; + } + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; + Reader.ptr.prototype.Reset = function(b) { + var b, r; + r = this; + Reader.copy(r, new Reader.ptr(b, new $Int64(0, 0), -1)); + }; + Reader.prototype.Reset = function(b) { return this.$val.Reset(b); }; + NewReader = function(b) { + var b; + return new Reader.ptr(b, new $Int64(0, 0), -1); + }; + $pkg.NewReader = NewReader; + ptrType.methods = [{prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "empty", name: "empty", pkg: "bytes", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "tryGrowByReslice", name: "tryGrowByReslice", pkg: "bytes", typ: $funcType([$Int], [$Int, $Bool], false)}, {prop: "grow", name: "grow", pkg: "bytes", typ: $funcType([$Int], [$Int], false)}, {prop: "Grow", name: "Grow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([io.Reader], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$Int, $error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([$Int], [sliceType], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadBytes", name: "ReadBytes", pkg: "", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "readSlice", name: "readSlice", pkg: "bytes", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "ReadString", name: "ReadString", pkg: "", typ: $funcType([$Uint8], [$String, $error], false)}]; + ptrType$1.methods = [{prop: "contains", name: "contains", pkg: "bytes", typ: $funcType([$Uint8], [$Bool], false)}]; + ptrType$2.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([sliceType], [], false)}]; + Buffer.init("bytes", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "off", name: "off", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "lastRead", name: "lastRead", embedded: false, exported: false, typ: readOp, tag: ""}]); + asciiSet.init($Uint32, 8); + Reader.init("bytes", [{prop: "s", name: "s", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", embedded: false, exported: false, typ: $Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrTooLarge = errors.New("bytes.Buffer: too large"); + errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["encoding"] = (function() { + var $pkg = {}, $init, TextMarshaler, TextUnmarshaler, sliceType; + TextMarshaler = $pkg.TextMarshaler = $newType(8, $kindInterface, "encoding.TextMarshaler", true, "encoding", true, null); + TextUnmarshaler = $pkg.TextUnmarshaler = $newType(8, $kindInterface, "encoding.TextUnmarshaler", true, "encoding", true, null); + sliceType = $sliceType($Uint8); + TextMarshaler.init([{prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType, $error], false)}]); + TextUnmarshaler.init([{prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType], [$error], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["encoding/binary"] = (function() { + var $pkg = {}, $init, errors, io, math, reflect, littleEndian, bigEndian, sliceType, overflow; + errors = $packages["errors"]; + io = $packages["io"]; + math = $packages["math"]; + reflect = $packages["reflect"]; + littleEndian = $pkg.littleEndian = $newType(0, $kindStruct, "binary.littleEndian", true, "encoding/binary", false, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + bigEndian = $pkg.bigEndian = $newType(0, $kindStruct, "binary.bigEndian", true, "encoding/binary", false, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + sliceType = $sliceType($Uint8); + littleEndian.ptr.prototype.Uint16 = function(b) { + var b; + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) << 16 >>> 16)) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) << 16 >>> 16)) << 8 << 16 >>> 16)) >>> 0; + }; + littleEndian.prototype.Uint16 = function(b) { return this.$val.Uint16(b); }; + littleEndian.ptr.prototype.PutUint16 = function(b, v) { + var b, v; + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 8 << 16 >>> 16) << 24 >>> 24))); + }; + littleEndian.prototype.PutUint16 = function(b, v) { return this.$val.PutUint16(b, v); }; + littleEndian.ptr.prototype.Uint32 = function(b) { + var b; + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return ((((((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) << 24 >>> 0)) >>> 0; + }; + littleEndian.prototype.Uint32 = function(b) { return this.$val.Uint32(b); }; + littleEndian.ptr.prototype.PutUint32 = function(b, v) { + var b, v; + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 8 >>> 0) << 24 >>> 24))); + (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (((v >>> 16 >>> 0) << 24 >>> 24))); + (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (((v >>> 24 >>> 0) << 24 >>> 24))); + }; + littleEndian.prototype.PutUint32 = function(b, v) { return this.$val.PutUint32(b, v); }; + littleEndian.ptr.prototype.Uint64 = function(b) { + var b, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$7 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); + }; + littleEndian.prototype.Uint64 = function(b) { return this.$val.Uint64(b); }; + littleEndian.ptr.prototype.PutUint64 = function(b, v) { + var b, v; + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v.$low << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (($shiftRightUint64(v, 8).$low << 24 >>> 24))); + (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (($shiftRightUint64(v, 16).$low << 24 >>> 24))); + (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (($shiftRightUint64(v, 24).$low << 24 >>> 24))); + (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4] = (($shiftRightUint64(v, 32).$low << 24 >>> 24))); + (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5] = (($shiftRightUint64(v, 40).$low << 24 >>> 24))); + (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6] = (($shiftRightUint64(v, 48).$low << 24 >>> 24))); + (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7] = (($shiftRightUint64(v, 56).$low << 24 >>> 24))); + }; + littleEndian.prototype.PutUint64 = function(b, v) { return this.$val.PutUint64(b, v); }; + littleEndian.ptr.prototype.String = function() { + return "LittleEndian"; + }; + littleEndian.prototype.String = function() { return this.$val.String(); }; + littleEndian.ptr.prototype.GoString = function() { + return "binary.LittleEndian"; + }; + littleEndian.prototype.GoString = function() { return this.$val.GoString(); }; + bigEndian.ptr.prototype.Uint16 = function(b) { + var b; + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) << 16 >>> 16)) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) << 16 >>> 16)) << 8 << 16 >>> 16)) >>> 0; + }; + bigEndian.prototype.Uint16 = function(b) { return this.$val.Uint16(b); }; + bigEndian.ptr.prototype.PutUint16 = function(b, v) { + var b, v; + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (((v >>> 8 << 16 >>> 16) << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = ((v << 24 >>> 24))); + }; + bigEndian.prototype.PutUint16 = function(b, v) { return this.$val.PutUint16(b, v); }; + bigEndian.ptr.prototype.Uint32 = function(b) { + var b; + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return ((((((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) << 24 >>> 0)) >>> 0; + }; + bigEndian.prototype.Uint32 = function(b) { return this.$val.Uint32(b); }; + bigEndian.ptr.prototype.PutUint32 = function(b, v) { + var b, v; + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (((v >>> 24 >>> 0) << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 16 >>> 0) << 24 >>> 24))); + (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (((v >>> 8 >>> 0) << 24 >>> 24))); + (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = ((v << 24 >>> 24))); + }; + bigEndian.prototype.PutUint32 = function(b, v) { return this.$val.PutUint32(b, v); }; + bigEndian.ptr.prototype.Uint64 = function(b) { + var b, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$7 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); + }; + bigEndian.prototype.Uint64 = function(b) { return this.$val.Uint64(b); }; + bigEndian.ptr.prototype.PutUint64 = function(b, v) { + var b, v; + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (($shiftRightUint64(v, 56).$low << 24 >>> 24))); + (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (($shiftRightUint64(v, 48).$low << 24 >>> 24))); + (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (($shiftRightUint64(v, 40).$low << 24 >>> 24))); + (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (($shiftRightUint64(v, 32).$low << 24 >>> 24))); + (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4] = (($shiftRightUint64(v, 24).$low << 24 >>> 24))); + (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5] = (($shiftRightUint64(v, 16).$low << 24 >>> 24))); + (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6] = (($shiftRightUint64(v, 8).$low << 24 >>> 24))); + (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7] = ((v.$low << 24 >>> 24))); + }; + bigEndian.prototype.PutUint64 = function(b, v) { return this.$val.PutUint64(b, v); }; + bigEndian.ptr.prototype.String = function() { + return "BigEndian"; + }; + bigEndian.prototype.String = function() { return this.$val.String(); }; + bigEndian.ptr.prototype.GoString = function() { + return "binary.BigEndian"; + }; + bigEndian.prototype.GoString = function() { return this.$val.GoString(); }; + littleEndian.methods = [{prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]; + bigEndian.methods = [{prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]; + littleEndian.init("", []); + bigEndian.init("", []); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.LittleEndian = new littleEndian.ptr(); + $pkg.BigEndian = new bigEndian.ptr(); + overflow = errors.New("binary: varint overflows a 64-bit integer"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["encoding/base64"] = (function() { + var $pkg = {}, $init, binary, io, strconv, Encoding, encoder, CorruptInputError, arrayType, arrayType$1, sliceType, ptrType, arrayType$2, arrayType$3, arrayType$4, ptrType$1, NewEncoding, NewEncoder; + binary = $packages["encoding/binary"]; + io = $packages["io"]; + strconv = $packages["strconv"]; + Encoding = $pkg.Encoding = $newType(0, $kindStruct, "base64.Encoding", true, "encoding/base64", true, function(encode_, decodeMap_, padChar_, strict_) { + this.$val = this; + if (arguments.length === 0) { + this.encode = arrayType.zero(); + this.decodeMap = arrayType$1.zero(); + this.padChar = 0; + this.strict = false; + return; + } + this.encode = encode_; + this.decodeMap = decodeMap_; + this.padChar = padChar_; + this.strict = strict_; + }); + encoder = $pkg.encoder = $newType(0, $kindStruct, "base64.encoder", true, "encoding/base64", false, function(err_, enc_, w_, buf_, nbuf_, out_) { + this.$val = this; + if (arguments.length === 0) { + this.err = $ifaceNil; + this.enc = ptrType.nil; + this.w = $ifaceNil; + this.buf = arrayType$2.zero(); + this.nbuf = 0; + this.out = arrayType$3.zero(); + return; + } + this.err = err_; + this.enc = enc_; + this.w = w_; + this.buf = buf_; + this.nbuf = nbuf_; + this.out = out_; + }); + CorruptInputError = $pkg.CorruptInputError = $newType(8, $kindInt64, "base64.CorruptInputError", true, "encoding/base64", true, null); + arrayType = $arrayType($Uint8, 64); + arrayType$1 = $arrayType($Uint8, 256); + sliceType = $sliceType($Uint8); + ptrType = $ptrType(Encoding); + arrayType$2 = $arrayType($Uint8, 3); + arrayType$3 = $arrayType($Uint8, 1024); + arrayType$4 = $arrayType($Uint8, 4); + ptrType$1 = $ptrType(encoder); + NewEncoding = function(encoder$1) { + var e, encoder$1, i, i$1, i$2, x, x$1, x$2; + if (!((encoder$1.length === 64))) { + $panic(new $String("encoding alphabet is not 64-bytes long")); + } + i = 0; + while (true) { + if (!(i < encoder$1.length)) { break; } + if ((encoder$1.charCodeAt(i) === 10) || (encoder$1.charCodeAt(i) === 13)) { + $panic(new $String("encoding alphabet contains newline character")); + } + i = i + (1) >> 0; + } + e = new Encoding.ptr(arrayType.zero(), arrayType$1.zero(), 0, false); + e.padChar = 61; + $copyString(new sliceType(e.encode), encoder$1); + i$1 = 0; + while (true) { + if (!(i$1 < 256)) { break; } + (x = e.decodeMap, ((i$1 < 0 || i$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i$1] = 255)); + i$1 = i$1 + (1) >> 0; + } + i$2 = 0; + while (true) { + if (!(i$2 < encoder$1.length)) { break; } + (x$1 = e.decodeMap, x$2 = encoder$1.charCodeAt(i$2), ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2] = ((i$2 << 24 >>> 24)))); + i$2 = i$2 + (1) >> 0; + } + return e; + }; + $pkg.NewEncoding = NewEncoding; + Encoding.ptr.prototype.WithPadding = function(padding) { + var enc, i, padding, x; + enc = this; + if ((padding === 13) || (padding === 10) || padding > 255) { + $panic(new $String("invalid padding")); + } + i = 0; + while (true) { + if (!(i < 64)) { break; } + if ((((x = enc.encode, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])) >> 0)) === padding) { + $panic(new $String("padding contained in alphabet")); + } + i = i + (1) >> 0; + } + enc.padChar = padding; + return enc; + }; + Encoding.prototype.WithPadding = function(padding) { return this.$val.WithPadding(padding); }; + Encoding.ptr.prototype.Strict = function() { + var enc; + enc = this; + enc.strict = true; + return enc; + }; + Encoding.prototype.Strict = function() { return this.$val.Strict(); }; + Encoding.ptr.prototype.Encode = function(dst, src) { + var _1, _q, _tmp, _tmp$1, di, dst, enc, n, remain, si, src, val, val$1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$25, x$26, x$27, x$28, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + enc = this; + if (src.$length === 0) { + return; + } + _tmp = 0; + _tmp$1 = 0; + di = _tmp; + si = _tmp$1; + n = $imul(((_q = src.$length / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))), 3); + while (true) { + if (!(si < n)) { break; } + val = (((((((x = si + 0 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) >>> 0)) << 16 >>> 0) | ((((x$1 = si + 1 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) >>> 0)) << 8 >>> 0)) >>> 0) | (((x$2 = si + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) >>> 0))) >>> 0; + (x$5 = di + 0 >> 0, ((x$5 < 0 || x$5 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$5] = (x$3 = enc.encode, x$4 = ((val >>> 18 >>> 0) & 63) >>> 0, ((x$4 < 0 || x$4 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[x$4])))); + (x$8 = di + 1 >> 0, ((x$8 < 0 || x$8 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$8] = (x$6 = enc.encode, x$7 = ((val >>> 12 >>> 0) & 63) >>> 0, ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])))); + (x$11 = di + 2 >> 0, ((x$11 < 0 || x$11 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$11] = (x$9 = enc.encode, x$10 = ((val >>> 6 >>> 0) & 63) >>> 0, ((x$10 < 0 || x$10 >= x$9.length) ? ($throwRuntimeError("index out of range"), undefined) : x$9[x$10])))); + (x$14 = di + 3 >> 0, ((x$14 < 0 || x$14 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$14] = (x$12 = enc.encode, x$13 = (val & 63) >>> 0, ((x$13 < 0 || x$13 >= x$12.length) ? ($throwRuntimeError("index out of range"), undefined) : x$12[x$13])))); + si = si + (3) >> 0; + di = di + (4) >> 0; + } + remain = src.$length - si >> 0; + if (remain === 0) { + return; + } + val$1 = (((x$15 = si + 0 >> 0, ((x$15 < 0 || x$15 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$15])) >>> 0)) << 16 >>> 0; + if (remain === 2) { + val$1 = (val$1 | (((((x$16 = si + 1 >> 0, ((x$16 < 0 || x$16 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$16])) >>> 0)) << 8 >>> 0))) >>> 0; + } + (x$19 = di + 0 >> 0, ((x$19 < 0 || x$19 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$19] = (x$17 = enc.encode, x$18 = ((val$1 >>> 18 >>> 0) & 63) >>> 0, ((x$18 < 0 || x$18 >= x$17.length) ? ($throwRuntimeError("index out of range"), undefined) : x$17[x$18])))); + (x$22 = di + 1 >> 0, ((x$22 < 0 || x$22 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$22] = (x$20 = enc.encode, x$21 = ((val$1 >>> 12 >>> 0) & 63) >>> 0, ((x$21 < 0 || x$21 >= x$20.length) ? ($throwRuntimeError("index out of range"), undefined) : x$20[x$21])))); + _1 = remain; + if (_1 === (2)) { + (x$25 = di + 2 >> 0, ((x$25 < 0 || x$25 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$25] = (x$23 = enc.encode, x$24 = ((val$1 >>> 6 >>> 0) & 63) >>> 0, ((x$24 < 0 || x$24 >= x$23.length) ? ($throwRuntimeError("index out of range"), undefined) : x$23[x$24])))); + if (!((enc.padChar === -1))) { + (x$26 = di + 3 >> 0, ((x$26 < 0 || x$26 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$26] = ((enc.padChar << 24 >>> 24)))); + } + } else if (_1 === (1)) { + if (!((enc.padChar === -1))) { + (x$27 = di + 2 >> 0, ((x$27 < 0 || x$27 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$27] = ((enc.padChar << 24 >>> 24)))); + (x$28 = di + 3 >> 0, ((x$28 < 0 || x$28 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$28] = ((enc.padChar << 24 >>> 24)))); + } + } + }; + Encoding.prototype.Encode = function(dst, src) { return this.$val.Encode(dst, src); }; + Encoding.ptr.prototype.EncodeToString = function(src) { + var buf, enc, src; + enc = this; + buf = $makeSlice(sliceType, enc.EncodedLen(src.$length)); + enc.Encode(buf, src); + return ($bytesToString(buf)); + }; + Encoding.prototype.EncodeToString = function(src) { return this.$val.EncodeToString(src); }; + encoder.ptr.prototype.Write = function(p) { + var _q, _r, _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, e, err, i, i$1, n, nn, p, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; e = $f.e; err = $f.err; i = $f.i; i$1 = $f.i$1; n = $f.n; nn = $f.nn; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + e = this; + if (!($interfaceIsEqual(e.err, $ifaceNil))) { + _tmp = 0; + _tmp$1 = e.err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + /* */ if (e.nbuf > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (e.nbuf > 0) { */ case 1: + i = 0; + i = 0; + while (true) { + if (!(i < p.$length && e.nbuf < 3)) { break; } + (x = e.buf, x$1 = e.nbuf, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1] = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]))); + e.nbuf = e.nbuf + (1) >> 0; + i = i + (1) >> 0; + } + n = n + (i) >> 0; + p = $subslice(p, i); + if (e.nbuf < 3) { + $s = -1; return [n, err]; + } + e.enc.Encode(new sliceType(e.out), new sliceType(e.buf)); + _r = e.w.Write($subslice(new sliceType(e.out), 0, 4)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + e.err = _tuple[1]; + if (!($interfaceIsEqual(e.err, $ifaceNil))) { + _tmp$2 = n; + _tmp$3 = e.err; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + e.nbuf = 0; + /* } */ case 2: + /* while (true) { */ case 4: + /* if (!(p.$length >= 3)) { break; } */ if(!(p.$length >= 3)) { $s = 5; continue; } + nn = 768; + if (nn > p.$length) { + nn = p.$length; + nn = nn - ((_r$1 = nn % 3, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))) >> 0; + } + e.enc.Encode(new sliceType(e.out), $subslice(p, 0, nn)); + _r$2 = e.w.Write($subslice(new sliceType(e.out), 0, ($imul((_q = nn / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), 4)))); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + e.err = _tuple$1[1]; + if (!($interfaceIsEqual(e.err, $ifaceNil))) { + _tmp$4 = n; + _tmp$5 = e.err; + n = _tmp$4; + err = _tmp$5; + $s = -1; return [n, err]; + } + n = n + (nn) >> 0; + p = $subslice(p, nn); + /* } */ $s = 4; continue; case 5: + i$1 = 0; + while (true) { + if (!(i$1 < p.$length)) { break; } + (x$2 = e.buf, ((i$1 < 0 || i$1 >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i$1] = ((i$1 < 0 || i$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i$1]))); + i$1 = i$1 + (1) >> 0; + } + e.nbuf = p.$length; + n = n + (p.$length) >> 0; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Write }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.e = e; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.n = n; $f.nn = nn; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + encoder.prototype.Write = function(p) { return this.$val.Write(p); }; + encoder.ptr.prototype.Close = function() { + var _r, _tuple, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + /* */ if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { */ case 1: + e.enc.Encode(new sliceType(e.out), $subslice(new sliceType(e.buf), 0, e.nbuf)); + _r = e.w.Write($subslice(new sliceType(e.out), 0, e.enc.EncodedLen(e.nbuf))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + e.err = _tuple[1]; + e.nbuf = 0; + /* } */ case 2: + $s = -1; return e.err; + /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Close }; } $f._r = _r; $f._tuple = _tuple; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + encoder.prototype.Close = function() { return this.$val.Close(); }; + NewEncoder = function(enc, w) { + var enc, w; + return new encoder.ptr($ifaceNil, enc, w, arrayType$2.zero(), 0, arrayType$3.zero()); + }; + $pkg.NewEncoder = NewEncoder; + Encoding.ptr.prototype.EncodedLen = function(n) { + var _q, _q$1, enc, n; + enc = this; + if (enc.padChar === -1) { + return (_q = ((($imul(n, 8)) + 5 >> 0)) / 6, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + } + return $imul((_q$1 = ((n + 2 >> 0)) / 3, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 4); + }; + Encoding.prototype.EncodedLen = function(n) { return this.$val.EncodedLen(n); }; + CorruptInputError.prototype.Error = function() { + var e; + e = this; + return "illegal base64 data at input byte " + strconv.FormatInt((new $Int64(e.$high, e.$low)), 10); + }; + $ptrType(CorruptInputError).prototype.Error = function() { return this.$get().Error(); }; + Encoding.ptr.prototype.decodeQuantum = function(dst, src, si) { + var _1, _2, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dbuf, dinc, dlen, dst, enc, err, in$1, j, n, nsi, out, si, src, val, x; + nsi = 0; + n = 0; + err = $ifaceNil; + enc = this; + dbuf = arrayType$4.zero(); + _tmp = 3; + _tmp$1 = 4; + dinc = _tmp; + dlen = _tmp$1; + j = 0; + while (true) { + if (!(j < 4)) { break; } + if (src.$length === si) { + if ((j === 0)) { + _tmp$2 = si; + _tmp$3 = 0; + _tmp$4 = $ifaceNil; + nsi = _tmp$2; + n = _tmp$3; + err = _tmp$4; + return [nsi, n, err]; + } else if (((j === 1)) || (!((enc.padChar === -1)))) { + _tmp$5 = si; + _tmp$6 = 0; + _tmp$7 = (new CorruptInputError(0, (si - j >> 0))); + nsi = _tmp$5; + n = _tmp$6; + err = _tmp$7; + return [nsi, n, err]; + } + _tmp$8 = j - 1 >> 0; + _tmp$9 = j; + dinc = _tmp$8; + dlen = _tmp$9; + break; + } + in$1 = ((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]); + si = si + (1) >> 0; + out = (x = enc.decodeMap, ((in$1 < 0 || in$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[in$1])); + if (!((out === 255))) { + ((j < 0 || j >= dbuf.length) ? ($throwRuntimeError("index out of range"), undefined) : dbuf[j] = out); + j = j + (1) >> 0; + continue; + } + if ((in$1 === 10) || (in$1 === 13)) { + j = j - (1) >> 0; + j = j + (1) >> 0; + continue; + } + if (!((((in$1 >> 0)) === enc.padChar))) { + _tmp$10 = si; + _tmp$11 = 0; + _tmp$12 = (new CorruptInputError(0, (si - 1 >> 0))); + nsi = _tmp$10; + n = _tmp$11; + err = _tmp$12; + return [nsi, n, err]; + } + _1 = j; + if ((_1 === (0)) || (_1 === (1))) { + _tmp$13 = si; + _tmp$14 = 0; + _tmp$15 = (new CorruptInputError(0, (si - 1 >> 0))); + nsi = _tmp$13; + n = _tmp$14; + err = _tmp$15; + return [nsi, n, err]; + } else if (_1 === (2)) { + while (true) { + if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 13)))) { break; } + si = si + (1) >> 0; + } + if (si === src.$length) { + _tmp$16 = si; + _tmp$17 = 0; + _tmp$18 = (new CorruptInputError(0, src.$length)); + nsi = _tmp$16; + n = _tmp$17; + err = _tmp$18; + return [nsi, n, err]; + } + if (!((((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) >> 0)) === enc.padChar))) { + _tmp$19 = si; + _tmp$20 = 0; + _tmp$21 = (new CorruptInputError(0, (si - 1 >> 0))); + nsi = _tmp$19; + n = _tmp$20; + err = _tmp$21; + return [nsi, n, err]; + } + si = si + (1) >> 0; + } + while (true) { + if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 13)))) { break; } + si = si + (1) >> 0; + } + if (si < src.$length) { + err = (new CorruptInputError(0, si)); + } + _tmp$22 = 3; + _tmp$23 = j; + dinc = _tmp$22; + dlen = _tmp$23; + break; + } + val = ((((((((dbuf[0] >>> 0)) << 18 >>> 0) | (((dbuf[1] >>> 0)) << 12 >>> 0)) >>> 0) | (((dbuf[2] >>> 0)) << 6 >>> 0)) >>> 0) | ((dbuf[3] >>> 0))) >>> 0; + _tmp$24 = (((val >>> 0 >>> 0) << 24 >>> 24)); + _tmp$25 = (((val >>> 8 >>> 0) << 24 >>> 24)); + _tmp$26 = (((val >>> 16 >>> 0) << 24 >>> 24)); + dbuf[2] = _tmp$24; + dbuf[1] = _tmp$25; + dbuf[0] = _tmp$26; + _2 = dlen; + if (_2 === (4)) { + (2 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 2] = dbuf[2]); + dbuf[2] = 0; + (1 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 1] = dbuf[1]); + if (enc.strict && !((dbuf[2] === 0))) { + _tmp$27 = si; + _tmp$28 = 0; + _tmp$29 = (new CorruptInputError(0, (si - 1 >> 0))); + nsi = _tmp$27; + n = _tmp$28; + err = _tmp$29; + return [nsi, n, err]; + } + dbuf[1] = 0; + (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); + if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { + _tmp$30 = si; + _tmp$31 = 0; + _tmp$32 = (new CorruptInputError(0, (si - 2 >> 0))); + nsi = _tmp$30; + n = _tmp$31; + err = _tmp$32; + return [nsi, n, err]; + } + } else if (_2 === (3)) { + (1 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 1] = dbuf[1]); + if (enc.strict && !((dbuf[2] === 0))) { + _tmp$33 = si; + _tmp$34 = 0; + _tmp$35 = (new CorruptInputError(0, (si - 1 >> 0))); + nsi = _tmp$33; + n = _tmp$34; + err = _tmp$35; + return [nsi, n, err]; + } + dbuf[1] = 0; + (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); + if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { + _tmp$36 = si; + _tmp$37 = 0; + _tmp$38 = (new CorruptInputError(0, (si - 2 >> 0))); + nsi = _tmp$36; + n = _tmp$37; + err = _tmp$38; + return [nsi, n, err]; + } + } else if (_2 === (2)) { + (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); + if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { + _tmp$39 = si; + _tmp$40 = 0; + _tmp$41 = (new CorruptInputError(0, (si - 2 >> 0))); + nsi = _tmp$39; + n = _tmp$40; + err = _tmp$41; + return [nsi, n, err]; + } + } + dst = $subslice(dst, dinc); + _tmp$42 = si; + _tmp$43 = dlen - 1 >> 0; + _tmp$44 = err; + nsi = _tmp$42; + n = _tmp$43; + err = _tmp$44; + return [nsi, n, err]; + }; + Encoding.prototype.decodeQuantum = function(dst, src, si) { return this.$val.decodeQuantum(dst, src, si); }; + Encoding.ptr.prototype.DecodeString = function(s) { + var _tuple, dbuf, enc, err, n, s; + enc = this; + dbuf = $makeSlice(sliceType, enc.DecodedLen(s.length)); + _tuple = enc.Decode(dbuf, (new sliceType($stringToBytes(s)))); + n = _tuple[0]; + err = _tuple[1]; + return [$subslice(dbuf, 0, n), err]; + }; + Encoding.prototype.DecodeString = function(s) { return this.$val.DecodeString(s); }; + Encoding.ptr.prototype.Decode = function(dst, src) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, dn, dn$1, dst, enc, err, n, ninc, ninc$1, ninc$2, ok, ok$1, si, src; + n = 0; + err = $ifaceNil; + enc = this; + if (src.$length === 0) { + _tmp = 0; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + si = 0; + while (true) { + if (!(false && (src.$length - si >> 0) >= 8 && (dst.$length - n >> 0) >= 8)) { break; } + _tuple = enc.decode64($subslice(src, si)); + dn = _tuple[0]; + ok = _tuple[1]; + if (ok) { + $clone(binary.BigEndian, binary.bigEndian).PutUint64($subslice(dst, n), dn); + n = n + (6) >> 0; + si = si + (8) >> 0; + } else { + ninc = 0; + _tuple$1 = enc.decodeQuantum($subslice(dst, n), src, si); + si = _tuple$1[0]; + ninc = _tuple$1[1]; + err = _tuple$1[2]; + n = n + (ninc) >> 0; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$2 = n; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + } + } + while (true) { + if (!((src.$length - si >> 0) >= 4 && (dst.$length - n >> 0) >= 4)) { break; } + _tuple$2 = enc.decode32($subslice(src, si)); + dn$1 = _tuple$2[0]; + ok$1 = _tuple$2[1]; + if (ok$1) { + $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(dst, n), dn$1); + n = n + (3) >> 0; + si = si + (4) >> 0; + } else { + ninc$1 = 0; + _tuple$3 = enc.decodeQuantum($subslice(dst, n), src, si); + si = _tuple$3[0]; + ninc$1 = _tuple$3[1]; + err = _tuple$3[2]; + n = n + (ninc$1) >> 0; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$4 = n; + _tmp$5 = err; + n = _tmp$4; + err = _tmp$5; + return [n, err]; + } + } + } + while (true) { + if (!(si < src.$length)) { break; } + ninc$2 = 0; + _tuple$4 = enc.decodeQuantum($subslice(dst, n), src, si); + si = _tuple$4[0]; + ninc$2 = _tuple$4[1]; + err = _tuple$4[2]; + n = n + (ninc$2) >> 0; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$6 = n; + _tmp$7 = err; + n = _tmp$6; + err = _tmp$7; + return [n, err]; + } + } + _tmp$8 = n; + _tmp$9 = err; + n = _tmp$8; + err = _tmp$9; + return [n, err]; + }; + Encoding.prototype.Decode = function(dst, src) { return this.$val.Decode(dst, src); }; + Encoding.ptr.prototype.decode32 = function(src) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dn, enc, n, ok, src, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + dn = 0; + ok = false; + enc = this; + n = 0; + $unused((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3])); + n = (((x = enc.decodeMap, x$1 = (0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]), ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])) >>> 0)); + if (n === 255) { + _tmp = 0; + _tmp$1 = false; + dn = _tmp; + ok = _tmp$1; + return [dn, ok]; + } + dn = (dn | ((n << 26 >>> 0))) >>> 0; + n = (((x$2 = enc.decodeMap, x$3 = (1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]), ((x$3 < 0 || x$3 >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[x$3])) >>> 0)); + if (n === 255) { + _tmp$2 = 0; + _tmp$3 = false; + dn = _tmp$2; + ok = _tmp$3; + return [dn, ok]; + } + dn = (dn | ((n << 20 >>> 0))) >>> 0; + n = (((x$4 = enc.decodeMap, x$5 = (2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]), ((x$5 < 0 || x$5 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[x$5])) >>> 0)); + if (n === 255) { + _tmp$4 = 0; + _tmp$5 = false; + dn = _tmp$4; + ok = _tmp$5; + return [dn, ok]; + } + dn = (dn | ((n << 14 >>> 0))) >>> 0; + n = (((x$6 = enc.decodeMap, x$7 = (3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]), ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])) >>> 0)); + if (n === 255) { + _tmp$6 = 0; + _tmp$7 = false; + dn = _tmp$6; + ok = _tmp$7; + return [dn, ok]; + } + dn = (dn | ((n << 8 >>> 0))) >>> 0; + _tmp$8 = dn; + _tmp$9 = true; + dn = _tmp$8; + ok = _tmp$9; + return [dn, ok]; + }; + Encoding.prototype.decode32 = function(src) { return this.$val.decode32(src); }; + Encoding.ptr.prototype.decode64 = function(src) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dn, enc, n, ok, src, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + dn = new $Uint64(0, 0); + ok = false; + enc = this; + n = new $Uint64(0, 0); + $unused((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7])); + n = (new $Uint64(0, (x = enc.decodeMap, x$1 = (0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]), ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp = new $Uint64(0, 0); + _tmp$1 = false; + dn = _tmp; + ok = _tmp$1; + return [dn, ok]; + } + dn = (x$2 = $shiftLeft64(n, 58), new $Uint64(dn.$high | x$2.$high, (dn.$low | x$2.$low) >>> 0)); + n = (new $Uint64(0, (x$3 = enc.decodeMap, x$4 = (1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]), ((x$4 < 0 || x$4 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[x$4])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$2 = new $Uint64(0, 0); + _tmp$3 = false; + dn = _tmp$2; + ok = _tmp$3; + return [dn, ok]; + } + dn = (x$5 = $shiftLeft64(n, 52), new $Uint64(dn.$high | x$5.$high, (dn.$low | x$5.$low) >>> 0)); + n = (new $Uint64(0, (x$6 = enc.decodeMap, x$7 = (2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]), ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$4 = new $Uint64(0, 0); + _tmp$5 = false; + dn = _tmp$4; + ok = _tmp$5; + return [dn, ok]; + } + dn = (x$8 = $shiftLeft64(n, 46), new $Uint64(dn.$high | x$8.$high, (dn.$low | x$8.$low) >>> 0)); + n = (new $Uint64(0, (x$9 = enc.decodeMap, x$10 = (3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]), ((x$10 < 0 || x$10 >= x$9.length) ? ($throwRuntimeError("index out of range"), undefined) : x$9[x$10])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$6 = new $Uint64(0, 0); + _tmp$7 = false; + dn = _tmp$6; + ok = _tmp$7; + return [dn, ok]; + } + dn = (x$11 = $shiftLeft64(n, 40), new $Uint64(dn.$high | x$11.$high, (dn.$low | x$11.$low) >>> 0)); + n = (new $Uint64(0, (x$12 = enc.decodeMap, x$13 = (4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4]), ((x$13 < 0 || x$13 >= x$12.length) ? ($throwRuntimeError("index out of range"), undefined) : x$12[x$13])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$8 = new $Uint64(0, 0); + _tmp$9 = false; + dn = _tmp$8; + ok = _tmp$9; + return [dn, ok]; + } + dn = (x$14 = $shiftLeft64(n, 34), new $Uint64(dn.$high | x$14.$high, (dn.$low | x$14.$low) >>> 0)); + n = (new $Uint64(0, (x$15 = enc.decodeMap, x$16 = (5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5]), ((x$16 < 0 || x$16 >= x$15.length) ? ($throwRuntimeError("index out of range"), undefined) : x$15[x$16])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$10 = new $Uint64(0, 0); + _tmp$11 = false; + dn = _tmp$10; + ok = _tmp$11; + return [dn, ok]; + } + dn = (x$17 = $shiftLeft64(n, 28), new $Uint64(dn.$high | x$17.$high, (dn.$low | x$17.$low) >>> 0)); + n = (new $Uint64(0, (x$18 = enc.decodeMap, x$19 = (6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6]), ((x$19 < 0 || x$19 >= x$18.length) ? ($throwRuntimeError("index out of range"), undefined) : x$18[x$19])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$12 = new $Uint64(0, 0); + _tmp$13 = false; + dn = _tmp$12; + ok = _tmp$13; + return [dn, ok]; + } + dn = (x$20 = $shiftLeft64(n, 22), new $Uint64(dn.$high | x$20.$high, (dn.$low | x$20.$low) >>> 0)); + n = (new $Uint64(0, (x$21 = enc.decodeMap, x$22 = (7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7]), ((x$22 < 0 || x$22 >= x$21.length) ? ($throwRuntimeError("index out of range"), undefined) : x$21[x$22])))); + if ((n.$high === 0 && n.$low === 255)) { + _tmp$14 = new $Uint64(0, 0); + _tmp$15 = false; + dn = _tmp$14; + ok = _tmp$15; + return [dn, ok]; + } + dn = (x$23 = $shiftLeft64(n, 16), new $Uint64(dn.$high | x$23.$high, (dn.$low | x$23.$low) >>> 0)); + _tmp$16 = dn; + _tmp$17 = true; + dn = _tmp$16; + ok = _tmp$17; + return [dn, ok]; + }; + Encoding.prototype.decode64 = function(src) { return this.$val.decode64(src); }; + Encoding.ptr.prototype.DecodedLen = function(n) { + var _q, _q$1, enc, n; + enc = this; + if (enc.padChar === -1) { + return (_q = ($imul(n, 6)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + } + return $imul((_q$1 = n / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 3); + }; + Encoding.prototype.DecodedLen = function(n) { return this.$val.DecodedLen(n); }; + Encoding.methods = [{prop: "WithPadding", name: "WithPadding", pkg: "", typ: $funcType([$Int32], [ptrType], false)}, {prop: "Strict", name: "Strict", pkg: "", typ: $funcType([], [ptrType], false)}]; + ptrType.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([sliceType, sliceType], [], false)}, {prop: "EncodeToString", name: "EncodeToString", pkg: "", typ: $funcType([sliceType], [$String], false)}, {prop: "EncodedLen", name: "EncodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "decodeQuantum", name: "decodeQuantum", pkg: "encoding/base64", typ: $funcType([sliceType, sliceType, $Int], [$Int, $Int, $error], false)}, {prop: "DecodeString", name: "DecodeString", pkg: "", typ: $funcType([$String], [sliceType, $error], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([sliceType, sliceType], [$Int, $error], false)}, {prop: "decode32", name: "decode32", pkg: "encoding/base64", typ: $funcType([sliceType], [$Uint32, $Bool], false)}, {prop: "decode64", name: "decode64", pkg: "encoding/base64", typ: $funcType([sliceType], [$Uint64, $Bool], false)}, {prop: "DecodedLen", name: "DecodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}]; + ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}]; + CorruptInputError.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + Encoding.init("encoding/base64", [{prop: "encode", name: "encode", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "decodeMap", name: "decodeMap", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "padChar", name: "padChar", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "strict", name: "strict", embedded: false, exported: false, typ: $Bool, tag: ""}]); + encoder.init("encoding/base64", [{prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}, {prop: "enc", name: "enc", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "w", name: "w", embedded: false, exported: false, typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: arrayType$2, tag: ""}, {prop: "nbuf", name: "nbuf", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: arrayType$3, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = binary.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.StdEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"); + $pkg.URLEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"); + $pkg.RawStdEncoding = $clone($pkg.StdEncoding, Encoding).WithPadding(-1); + $pkg.RawURLEncoding = $clone($pkg.URLEncoding, Encoding).WithPadding(-1); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["unicode/utf16"] = (function() { + var $pkg = {}, $init; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["encoding/json"] = (function() { + var $pkg = {}, $init, bytes, encoding, base64, errors, fmt, nosync, io, math, reflect, sort, strconv, strings, unicode, utf16, utf8, Number, Marshaler, UnsupportedTypeError, UnsupportedValueError, MarshalerError, encodeState, jsonError, encOpts, encoderFunc, floatEncoder, structEncoder, mapEncoder, sliceEncoder, arrayEncoder, ptrEncoder, condAddrEncoder, reflectWithString, field, byIndex, SyntaxError, scanner, tagOptions, sliceType, sliceType$1, ptrType, ptrType$1, ptrType$2, sliceType$2, ptrType$5, sliceType$3, ptrType$7, arrayType, sliceType$4, ptrType$14, ptrType$15, ptrType$17, ptrType$18, funcType, ptrType$19, ptrType$20, funcType$1, textUnmarshalerType, numberType, hex, encodeStatePool, encoderCache, marshalerType, textMarshalerType, float32Encoder, float64Encoder, fieldCache, safeSet, htmlSafeSet, _r, _r$1, _r$2, isValidNumber, Marshal, HTMLEscape, newEncodeState, isEmptyValue, valueEncoder, typeEncoder, newTypeEncoder, invalidValueEncoder, marshalerEncoder, addrMarshalerEncoder, textMarshalerEncoder, addrTextMarshalerEncoder, boolEncoder, intEncoder, uintEncoder, stringEncoder, interfaceEncoder, unsupportedTypeEncoder, newStructEncoder, newMapEncoder, encodeByteSlice, newSliceEncoder, newArrayEncoder, newPtrEncoder, newCondAddrEncoder, isValidTag, typeByIndex, typeFields, dominantField, cachedTypeFields, foldFunc, equalFoldRight, asciiEqualFold, simpleLetterEqualFold, compact, isSpace, stateBeginValueOrEmpty, stateBeginValue, stateBeginStringOrEmpty, stateBeginString, stateEndValue, stateEndTop, stateInString, stateInStringEsc, stateInStringEscU, stateInStringEscU1, stateInStringEscU12, stateInStringEscU123, stateNeg, state1, state0, stateDot, stateDot0, stateE, stateESign, stateE0, stateT, stateTr, stateTru, stateF, stateFa, stateFal, stateFals, stateN, stateNu, stateNul, stateError, quoteChar, parseTag; + bytes = $packages["bytes"]; + encoding = $packages["encoding"]; + base64 = $packages["encoding/base64"]; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + io = $packages["io"]; + math = $packages["math"]; + reflect = $packages["reflect"]; + sort = $packages["sort"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + unicode = $packages["unicode"]; + utf16 = $packages["unicode/utf16"]; + utf8 = $packages["unicode/utf8"]; + Number = $pkg.Number = $newType(8, $kindString, "json.Number", true, "encoding/json", true, null); + Marshaler = $pkg.Marshaler = $newType(8, $kindInterface, "json.Marshaler", true, "encoding/json", true, null); + UnsupportedTypeError = $pkg.UnsupportedTypeError = $newType(0, $kindStruct, "json.UnsupportedTypeError", true, "encoding/json", true, function(Type_) { + this.$val = this; + if (arguments.length === 0) { + this.Type = $ifaceNil; + return; + } + this.Type = Type_; + }); + UnsupportedValueError = $pkg.UnsupportedValueError = $newType(0, $kindStruct, "json.UnsupportedValueError", true, "encoding/json", true, function(Value_, Str_) { + this.$val = this; + if (arguments.length === 0) { + this.Value = new reflect.Value.ptr(ptrType$5.nil, 0, 0); + this.Str = ""; + return; + } + this.Value = Value_; + this.Str = Str_; + }); + MarshalerError = $pkg.MarshalerError = $newType(0, $kindStruct, "json.MarshalerError", true, "encoding/json", true, function(Type_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Type = $ifaceNil; + this.Err = $ifaceNil; + return; + } + this.Type = Type_; + this.Err = Err_; + }); + encodeState = $pkg.encodeState = $newType(0, $kindStruct, "json.encodeState", true, "encoding/json", false, function(Buffer_, scratch_) { + this.$val = this; + if (arguments.length === 0) { + this.Buffer = new bytes.Buffer.ptr(sliceType$1.nil, 0, 0); + this.scratch = arrayType.zero(); + return; + } + this.Buffer = Buffer_; + this.scratch = scratch_; + }); + jsonError = $pkg.jsonError = $newType(0, $kindStruct, "json.jsonError", true, "encoding/json", false, function(error_) { + this.$val = this; + if (arguments.length === 0) { + this.error = $ifaceNil; + return; + } + this.error = error_; + }); + encOpts = $pkg.encOpts = $newType(0, $kindStruct, "json.encOpts", true, "encoding/json", false, function(quoted_, escapeHTML_) { + this.$val = this; + if (arguments.length === 0) { + this.quoted = false; + this.escapeHTML = false; + return; + } + this.quoted = quoted_; + this.escapeHTML = escapeHTML_; + }); + encoderFunc = $pkg.encoderFunc = $newType(4, $kindFunc, "json.encoderFunc", true, "encoding/json", false, null); + floatEncoder = $pkg.floatEncoder = $newType(4, $kindInt, "json.floatEncoder", true, "encoding/json", false, null); + structEncoder = $pkg.structEncoder = $newType(0, $kindStruct, "json.structEncoder", true, "encoding/json", false, function(fields_) { + this.$val = this; + if (arguments.length === 0) { + this.fields = sliceType$3.nil; + return; + } + this.fields = fields_; + }); + mapEncoder = $pkg.mapEncoder = $newType(0, $kindStruct, "json.mapEncoder", true, "encoding/json", false, function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + sliceEncoder = $pkg.sliceEncoder = $newType(0, $kindStruct, "json.sliceEncoder", true, "encoding/json", false, function(arrayEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.arrayEnc = $throwNilPointerError; + return; + } + this.arrayEnc = arrayEnc_; + }); + arrayEncoder = $pkg.arrayEncoder = $newType(0, $kindStruct, "json.arrayEncoder", true, "encoding/json", false, function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + ptrEncoder = $pkg.ptrEncoder = $newType(0, $kindStruct, "json.ptrEncoder", true, "encoding/json", false, function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + condAddrEncoder = $pkg.condAddrEncoder = $newType(0, $kindStruct, "json.condAddrEncoder", true, "encoding/json", false, function(canAddrEnc_, elseEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.canAddrEnc = $throwNilPointerError; + this.elseEnc = $throwNilPointerError; + return; + } + this.canAddrEnc = canAddrEnc_; + this.elseEnc = elseEnc_; + }); + reflectWithString = $pkg.reflectWithString = $newType(0, $kindStruct, "json.reflectWithString", true, "encoding/json", false, function(v_, s_) { + this.$val = this; + if (arguments.length === 0) { + this.v = new reflect.Value.ptr(ptrType$5.nil, 0, 0); + this.s = ""; + return; + } + this.v = v_; + this.s = s_; + }); + field = $pkg.field = $newType(0, $kindStruct, "json.field", true, "encoding/json", false, function(name_, nameBytes_, equalFold_, nameNonEsc_, nameEscHTML_, tag_, index_, typ_, omitEmpty_, quoted_, encoder_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.nameBytes = sliceType$1.nil; + this.equalFold = $throwNilPointerError; + this.nameNonEsc = ""; + this.nameEscHTML = ""; + this.tag = false; + this.index = sliceType$2.nil; + this.typ = $ifaceNil; + this.omitEmpty = false; + this.quoted = false; + this.encoder = $throwNilPointerError; + return; + } + this.name = name_; + this.nameBytes = nameBytes_; + this.equalFold = equalFold_; + this.nameNonEsc = nameNonEsc_; + this.nameEscHTML = nameEscHTML_; + this.tag = tag_; + this.index = index_; + this.typ = typ_; + this.omitEmpty = omitEmpty_; + this.quoted = quoted_; + this.encoder = encoder_; + }); + byIndex = $pkg.byIndex = $newType(12, $kindSlice, "json.byIndex", true, "encoding/json", false, null); + SyntaxError = $pkg.SyntaxError = $newType(0, $kindStruct, "json.SyntaxError", true, "encoding/json", true, function(msg_, Offset_) { + this.$val = this; + if (arguments.length === 0) { + this.msg = ""; + this.Offset = new $Int64(0, 0); + return; + } + this.msg = msg_; + this.Offset = Offset_; + }); + scanner = $pkg.scanner = $newType(0, $kindStruct, "json.scanner", true, "encoding/json", false, function(step_, endTop_, parseState_, err_, bytes_) { + this.$val = this; + if (arguments.length === 0) { + this.step = $throwNilPointerError; + this.endTop = false; + this.parseState = sliceType$2.nil; + this.err = $ifaceNil; + this.bytes = new $Int64(0, 0); + return; + } + this.step = step_; + this.endTop = endTop_; + this.parseState = parseState_; + this.err = err_; + this.bytes = bytes_; + }); + tagOptions = $pkg.tagOptions = $newType(8, $kindString, "json.tagOptions", true, "encoding/json", false, null); + sliceType = $sliceType($emptyInterface); + sliceType$1 = $sliceType($Uint8); + ptrType = $ptrType(encoding.TextUnmarshaler); + ptrType$1 = $ptrType(Marshaler); + ptrType$2 = $ptrType(encoding.TextMarshaler); + sliceType$2 = $sliceType($Int); + ptrType$5 = $ptrType(reflect.rtype); + sliceType$3 = $sliceType(field); + ptrType$7 = $ptrType(encodeState); + arrayType = $arrayType($Uint8, 64); + sliceType$4 = $sliceType(reflectWithString); + ptrType$14 = $ptrType(UnsupportedTypeError); + ptrType$15 = $ptrType(UnsupportedValueError); + ptrType$17 = $ptrType(MarshalerError); + ptrType$18 = $ptrType(reflectWithString); + funcType = $funcType([sliceType$1, sliceType$1], [$Bool], false); + ptrType$19 = $ptrType(SyntaxError); + ptrType$20 = $ptrType(scanner); + funcType$1 = $funcType([ptrType$20, $Uint8], [$Int], false); + Number.prototype.String = function() { + var n; + n = this.$val; + return (n); + }; + $ptrType(Number).prototype.String = function() { return new Number(this.$get()).String(); }; + Number.prototype.Float64 = function() { + var n; + n = this.$val; + return strconv.ParseFloat((n), 64); + }; + $ptrType(Number).prototype.Float64 = function() { return new Number(this.$get()).Float64(); }; + Number.prototype.Int64 = function() { + var n; + n = this.$val; + return strconv.ParseInt((n), 10, 64); + }; + $ptrType(Number).prototype.Int64 = function() { return new Number(this.$get()).Int64(); }; + isValidNumber = function(s) { + var s; + if (s === "") { + return false; + } + if (s.charCodeAt(0) === 45) { + s = $substring(s, 1); + if (s === "") { + return false; + } + } + if ((s.charCodeAt(0) === 48)) { + s = $substring(s, 1); + } else if (49 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57) { + s = $substring(s, 1); + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = $substring(s, 1); + } + } else { + return false; + } + if (s.length >= 2 && (s.charCodeAt(0) === 46) && 48 <= s.charCodeAt(1) && s.charCodeAt(1) <= 57) { + s = $substring(s, 2); + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = $substring(s, 1); + } + } + if (s.length >= 2 && ((s.charCodeAt(0) === 101) || (s.charCodeAt(0) === 69))) { + s = $substring(s, 1); + if ((s.charCodeAt(0) === 43) || (s.charCodeAt(0) === 45)) { + s = $substring(s, 1); + if (s === "") { + return false; + } + } + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = $substring(s, 1); + } + } + return s === ""; + }; + Marshal = function(v) { + var _r$3, _r$4, buf, e, err, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; buf = $f.buf; e = $f.e; err = $f.err; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = newEncodeState(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + e = _r$3; + _r$4 = e.marshal(v, new encOpts.ptr(false, true)); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + err = _r$4; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [sliceType$1.nil, err]; + } + buf = $appendSlice((sliceType$1.nil), e.Buffer.Bytes()); + e.Buffer.Reset(); + encodeStatePool.Put(e); + $s = -1; return [buf, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Marshal }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.buf = buf; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Marshal = Marshal; + HTMLEscape = function(dst, src) { + var _i, _ref, c, dst, i, src, start, x, x$1, x$2; + start = 0; + _ref = src; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if ((c === 60) || (c === 62) || (c === 38)) { + if (start < i) { + dst.Write($subslice(src, start, i)); + } + dst.WriteString("\\u00"); + dst.WriteByte(hex.charCodeAt((c >>> 4 << 24 >>> 24))); + dst.WriteByte(hex.charCodeAt(((c & 15) >>> 0))); + start = i + 1 >> 0; + } + if ((c === 226) && (i + 2 >> 0) < src.$length && ((x = i + 1 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) & ~1) << 24 >>> 24) === 168)) { + if (start < i) { + dst.Write($subslice(src, start, i)); + } + dst.WriteString("\\u202"); + dst.WriteByte(hex.charCodeAt((((x$2 = i + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) & 15) >>> 0))); + start = i + 3 >> 0; + } + _i++; + } + if (start < src.$length) { + dst.Write($subslice(src, start)); + } + }; + $pkg.HTMLEscape = HTMLEscape; + UnsupportedTypeError.ptr.prototype.Error = function() { + var _r$3, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r$3 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $s = -1; return "json: unsupported type: " + _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: UnsupportedTypeError.ptr.prototype.Error }; } $f._r$3 = _r$3; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + UnsupportedTypeError.prototype.Error = function() { return this.$val.Error(); }; + UnsupportedValueError.ptr.prototype.Error = function() { + var e; + e = this; + return "json: unsupported value: " + e.Str; + }; + UnsupportedValueError.prototype.Error = function() { return this.$val.Error(); }; + MarshalerError.ptr.prototype.Error = function() { + var _r$3, _r$4, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r$3 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = e.Err.Error(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return "json: error calling MarshalJSON for type " + _r$3 + ": " + _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: MarshalerError.ptr.prototype.Error }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + MarshalerError.prototype.Error = function() { return this.$val.Error(); }; + newEncodeState = function() { + var _r$3, e, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = encodeStatePool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + if (!($interfaceIsEqual(v, $ifaceNil))) { + e = $assertType(v, ptrType$7); + e.Buffer.Reset(); + $s = -1; return e; + } + $s = -1; return new encodeState.ptr(new bytes.Buffer.ptr(sliceType$1.nil, 0, 0), arrayType.zero()); + /* */ } return; } if ($f === undefined) { $f = { $blk: newEncodeState }; } $f._r$3 = _r$3; $f.e = e; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + encodeState.ptr.prototype.marshal = function(v, opts) { + var _r$3, e, err, opts, v, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; err = $f.err; opts = $f.opts; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + err = [err]; + err[0] = $ifaceNil; + e = this; + $deferred.push([(function(err) { return function() { + var _tuple, je, ok, r; + r = $recover(); + if (!($interfaceIsEqual(r, $ifaceNil))) { + _tuple = $assertType(r, jsonError, true); + je = $clone(_tuple[0], jsonError); + ok = _tuple[1]; + if (ok) { + err[0] = je.error; + } else { + $panic(r); + } + } + }; })(err), []]); + _r$3 = reflect.ValueOf(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $r = e.reflectValue($clone(_r$3, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + err[0] = $ifaceNil; + $s = -1; return err[0]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.marshal }; } $f._r$3 = _r$3; $f.e = e; $f.err = err; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + encodeState.prototype.marshal = function(v, opts) { return this.$val.marshal(v, opts); }; + encodeState.ptr.prototype.error = function(err) { + var e, err, x; + e = this; + $panic((x = new jsonError.ptr(err), new x.constructor.elem(x))); + }; + encodeState.prototype.error = function(err) { return this.$val.error(err); }; + isEmptyValue = function(v) { + var _1, v, x, x$1; + _1 = $clone(v, reflect.Value).Kind(); + if ((_1 === (17)) || (_1 === (21)) || (_1 === (23)) || (_1 === (24))) { + return $clone(v, reflect.Value).Len() === 0; + } else if (_1 === (1)) { + return !$clone(v, reflect.Value).Bool(); + } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + return (x = $clone(v, reflect.Value).Int(), (x.$high === 0 && x.$low === 0)); + } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { + return (x$1 = $clone(v, reflect.Value).Uint(), (x$1.$high === 0 && x$1.$low === 0)); + } else if ((_1 === (13)) || (_1 === (14))) { + return $clone(v, reflect.Value).Float() === 0; + } else if ((_1 === (20)) || (_1 === (22))) { + return $clone(v, reflect.Value).IsNil(); + } + return false; + }; + encodeState.ptr.prototype.reflectValue = function(v, opts) { + var _r$3, e, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r$3 = valueEncoder($clone(v, reflect.Value)); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $r = _r$3(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.reflectValue }; } $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + encodeState.prototype.reflectValue = function(v, opts) { return this.$val.reflectValue(v, opts); }; + valueEncoder = function(v) { + var _r$3, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (!$clone(v, reflect.Value).IsValid()) { + $s = -1; return invalidValueEncoder; + } + _r$3 = typeEncoder($clone(v, reflect.Value).Type()); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $s = -1; return _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: valueEncoder }; } $f._r$3 = _r$3; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + typeEncoder = function(t) { + var _r$3, _tuple, _tuple$1, f, fi, fi$1, loaded, ok, t, wg, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; fi = $f.fi; fi$1 = $f.fi$1; loaded = $f.loaded; ok = $f.ok; t = $f.t; wg = $f.wg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = [f]; + wg = [wg]; + _tuple = encoderCache.Load(t); + fi = _tuple[0]; + ok = _tuple[1]; + if (ok) { + $s = -1; return $assertType(fi, encoderFunc); + } + wg[0] = new nosync.WaitGroup.ptr(0); + f[0] = $throwNilPointerError; + wg[0].Add(1); + _tuple$1 = encoderCache.LoadOrStore(t, new encoderFunc(((function(f, wg) { return function $b(e, v, opts) { + var e, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + wg[0].Wait(); + $r = f[0](e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; })(f, wg)))); + fi$1 = _tuple$1[0]; + loaded = _tuple$1[1]; + if (loaded) { + $s = -1; return $assertType(fi$1, encoderFunc); + } + _r$3 = newTypeEncoder(t, true); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + f[0] = _r$3; + wg[0].Done(); + encoderCache.Store(t, new encoderFunc(f[0])); + $s = -1; return f[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeEncoder }; } $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.fi = fi; $f.fi$1 = fi$1; $f.loaded = loaded; $f.ok = ok; $f.t = t; $f.wg = wg; $f.$s = $s; $f.$r = $r; return $f; + }; + newTypeEncoder = function(t, allowAddr) { + var _1, _arg, _arg$1, _arg$2, _arg$3, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, allowAddr, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; allowAddr = $f.allowAddr; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = t.Implements(marshalerType); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r$3) { */ case 1: + $s = -1; return marshalerEncoder; + /* } */ case 2: + _r$4 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!((_r$4 === 22)) && allowAddr) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!((_r$4 === 22)) && allowAddr) { */ case 4: + _r$5 = reflect.PtrTo(t).Implements(marshalerType); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (_r$5) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_r$5) { */ case 7: + _arg = addrMarshalerEncoder; + _r$6 = newTypeEncoder(t, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$1 = _r$6; + _r$7 = newCondAddrEncoder(_arg, _arg$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return _r$7; + /* } */ case 8: + /* } */ case 5: + _r$8 = t.Implements(textMarshalerType); /* */ $s = 14; case 14: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + /* */ if (_r$8) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_r$8) { */ case 12: + $s = -1; return textMarshalerEncoder; + /* } */ case 13: + _r$9 = t.Kind(); /* */ $s = 17; case 17: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + /* */ if (!((_r$9 === 22)) && allowAddr) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (!((_r$9 === 22)) && allowAddr) { */ case 15: + _r$10 = reflect.PtrTo(t).Implements(textMarshalerType); /* */ $s = 20; case 20: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + /* */ if (_r$10) { $s = 18; continue; } + /* */ $s = 19; continue; + /* if (_r$10) { */ case 18: + _arg$2 = addrTextMarshalerEncoder; + _r$11 = newTypeEncoder(t, false); /* */ $s = 21; case 21: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _arg$3 = _r$11; + _r$12 = newCondAddrEncoder(_arg$2, _arg$3); /* */ $s = 22; case 22: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + $s = -1; return _r$12; + /* } */ case 19: + /* } */ case 16: + _r$13 = t.Kind(); /* */ $s = 24; case 24: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _1 = _r$13; + /* */ if (_1 === (1)) { $s = 25; continue; } + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 26; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 27; continue; } + /* */ if (_1 === (13)) { $s = 28; continue; } + /* */ if (_1 === (14)) { $s = 29; continue; } + /* */ if (_1 === (24)) { $s = 30; continue; } + /* */ if (_1 === (20)) { $s = 31; continue; } + /* */ if (_1 === (25)) { $s = 32; continue; } + /* */ if (_1 === (21)) { $s = 33; continue; } + /* */ if (_1 === (23)) { $s = 34; continue; } + /* */ if (_1 === (17)) { $s = 35; continue; } + /* */ if (_1 === (22)) { $s = 36; continue; } + /* */ $s = 37; continue; + /* if (_1 === (1)) { */ case 25: + $s = -1; return boolEncoder; + /* } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 26: + $s = -1; return intEncoder; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 27: + $s = -1; return uintEncoder; + /* } else if (_1 === (13)) { */ case 28: + $s = -1; return float32Encoder; + /* } else if (_1 === (14)) { */ case 29: + $s = -1; return float64Encoder; + /* } else if (_1 === (24)) { */ case 30: + $s = -1; return stringEncoder; + /* } else if (_1 === (20)) { */ case 31: + $s = -1; return interfaceEncoder; + /* } else if (_1 === (25)) { */ case 32: + _r$14 = newStructEncoder(t); /* */ $s = 39; case 39: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + $s = -1; return _r$14; + /* } else if (_1 === (21)) { */ case 33: + _r$15 = newMapEncoder(t); /* */ $s = 40; case 40: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + $s = -1; return _r$15; + /* } else if (_1 === (23)) { */ case 34: + _r$16 = newSliceEncoder(t); /* */ $s = 41; case 41: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + $s = -1; return _r$16; + /* } else if (_1 === (17)) { */ case 35: + _r$17 = newArrayEncoder(t); /* */ $s = 42; case 42: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + $s = -1; return _r$17; + /* } else if (_1 === (22)) { */ case 36: + _r$18 = newPtrEncoder(t); /* */ $s = 43; case 43: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + $s = -1; return _r$18; + /* } else { */ case 37: + $s = -1; return unsupportedTypeEncoder; + /* } */ case 38: + case 23: + $s = -1; return $throwNilPointerError; + /* */ } return; } if ($f === undefined) { $f = { $blk: newTypeEncoder }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.allowAddr = allowAddr; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + invalidValueEncoder = function(e, v, param) { + var e, param, v; + e.Buffer.WriteString("null"); + }; + marshalerEncoder = function(e, v, opts) { + var _r$3, _r$4, _r$5, _tuple, _tuple$1, b, e, err, m, ok, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; e = $f.e; err = $f.err; m = $f.m; ok = $f.ok; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(v, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = $assertType(_r$3, Marshaler, true); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$4 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + b = _tuple$1[0]; + err = _tuple$1[1]; + /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: + _r$5 = compact(e.Buffer, b, opts.escapeHTML); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + err = _r$5; + /* } */ case 4: + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: marshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.ok = ok; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + addrMarshalerEncoder = function(e, v, param) { + var _r$3, _r$4, _r$5, _tuple, b, e, err, m, param, v, va, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; param = $f.param; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + va = $clone(v, reflect.Value).Addr(); + if ($clone(va, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(va, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + m = $assertType(_r$3, Marshaler); + _r$4 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = _r$4; + b = _tuple[0]; + err = _tuple[1]; + /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: + _r$5 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + err = _r$5; + /* } */ case 4: + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: addrMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.param = param; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; + }; + textMarshalerEncoder = function(e, v, opts) { + var _r$3, _r$4, _tuple, b, e, err, m, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(v, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + m = $assertType(_r$3, encoding.TextMarshaler); + _r$4 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = _r$4; + b = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); + } + e.stringBytes(b, opts.escapeHTML); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: textMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + addrTextMarshalerEncoder = function(e, v, opts) { + var _r$3, _r$4, _tuple, b, e, err, m, opts, v, va, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; opts = $f.opts; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + va = $clone(v, reflect.Value).Addr(); + if ($clone(va, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(va, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + m = $assertType(_r$3, encoding.TextMarshaler); + _r$4 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = _r$4; + b = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); + } + e.stringBytes(b, opts.escapeHTML); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: addrTextMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.opts = opts; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; + }; + boolEncoder = function(e, v, opts) { + var e, opts, v; + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + if ($clone(v, reflect.Value).Bool()) { + e.Buffer.WriteString("true"); + } else { + e.Buffer.WriteString("false"); + } + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + }; + intEncoder = function(e, v, opts) { + var b, e, opts, v; + b = strconv.AppendInt($subslice(new sliceType$1(e.scratch), 0, 0), $clone(v, reflect.Value).Int(), 10); + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + }; + uintEncoder = function(e, v, opts) { + var b, e, opts, v; + b = strconv.AppendUint($subslice(new sliceType$1(e.scratch), 0, 0), $clone(v, reflect.Value).Uint(), 10); + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + }; + floatEncoder.prototype.encode = function(e, v, opts) { + var abs, b, bits, e, f, fmt$1, n, opts, v, x, x$1, x$2, x$3, x$4; + bits = this.$val; + f = $clone(v, reflect.Value).Float(); + if (math.IsInf(f, 0) || math.IsNaN(f)) { + e.error(new UnsupportedValueError.ptr($clone(v, reflect.Value), strconv.FormatFloat(f, 103, -1, ((bits >> 0))))); + } + b = $subslice(new sliceType$1(e.scratch), 0, 0); + abs = math.Abs(f); + fmt$1 = 102; + if (!((abs === 0))) { + if ((bits === 64) && (abs < 1e-06 || abs >= 1e+21) || (bits === 32) && (($fround(abs)) < 9.999999974752427e-07 || ($fround(abs)) >= 1.0000000200408773e+21)) { + fmt$1 = 101; + } + } + b = strconv.AppendFloat(b, f, fmt$1, -1, ((bits >> 0))); + if (fmt$1 === 101) { + n = b.$length; + if (n >= 4 && ((x = n - 4 >> 0, ((x < 0 || x >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x])) === 101) && ((x$1 = n - 3 >> 0, ((x$1 < 0 || x$1 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$1])) === 45) && ((x$2 = n - 2 >> 0, ((x$2 < 0 || x$2 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$2])) === 48)) { + (x$4 = n - 2 >> 0, ((x$4 < 0 || x$4 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$4] = (x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$3])))); + b = $subslice(b, 0, (n - 1 >> 0)); + } + } + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (opts.quoted) { + e.Buffer.WriteByte(34); + } + }; + $ptrType(floatEncoder).prototype.encode = function(e, v, opts) { return new floatEncoder(this.$get()).encode(e, v, opts); }; + stringEncoder = function(e, v, opts) { + var _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, e, err, numStr, opts, sb, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; e = $f.e; err = $f.err; numStr = $f.numStr; opts = $f.opts; sb = $f.sb; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if ($interfaceIsEqual($clone(v, reflect.Value).Type(), numberType)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($interfaceIsEqual($clone(v, reflect.Value).Type(), numberType)) { */ case 1: + _r$3 = $clone(v, reflect.Value).String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + numStr = _r$3; + if (numStr === "") { + numStr = "0"; + } + /* */ if (!isValidNumber(numStr)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!isValidNumber(numStr)) { */ case 4: + _r$4 = fmt.Errorf("json: invalid number literal %q", new sliceType([new $String(numStr)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $r = e.error(_r$4); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + e.Buffer.WriteString(numStr); + $s = -1; return; + /* } */ case 2: + /* */ if (opts.quoted) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (opts.quoted) { */ case 8: + _r$5 = $clone(v, reflect.Value).String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = Marshal(new $String(_r$5)); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple = _r$6; + sb = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(err); + } + e.string(($bytesToString(sb)), opts.escapeHTML); + $s = 10; continue; + /* } else { */ case 9: + _r$7 = $clone(v, reflect.Value).String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $r = e.string(_r$7, opts.escapeHTML); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: stringEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.numStr = numStr; $f.opts = opts; $f.sb = sb; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + interfaceEncoder = function(e, v, opts) { + var _r$3, e, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(v, reflect.Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $r = e.reflectValue($clone(_r$3, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: interfaceEncoder }; } $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + unsupportedTypeEncoder = function(e, v, param) { + var e, param, v; + e.error(new UnsupportedTypeError.ptr($clone(v, reflect.Value).Type())); + }; + structEncoder.ptr.prototype.encode = function(e, v, opts) { + var _i, _i$1, _r$3, _r$4, _ref, _ref$1, e, f, fv, i, i$1, next, opts, se, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; e = $f.e; f = $f.f; fv = $f.fv; i = $f.i; i$1 = $f.i$1; next = $f.next; opts = $f.opts; se = $f.se; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + se = this; + next = 123; + _ref = se.fields; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + f = (x = se.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + fv = v; + _ref$1 = f.index; + _i$1 = 0; + /* while (true) { */ case 3: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 4; continue; } + i$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + /* */ if ($clone(fv, reflect.Value).Kind() === 22) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ($clone(fv, reflect.Value).Kind() === 22) { */ case 5: + /* */ if ($clone(fv, reflect.Value).IsNil()) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ($clone(fv, reflect.Value).IsNil()) { */ case 7: + _i++; + /* continue FieldLoop; */ $s = 1; continue s; + /* } */ case 8: + _r$3 = $clone(fv, reflect.Value).Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + fv = _r$3; + /* } */ case 6: + _r$4 = $clone(fv, reflect.Value).Field(i$1); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + fv = _r$4; + _i$1++; + /* } */ $s = 3; continue; case 4: + /* */ if (f.omitEmpty && isEmptyValue($clone(fv, reflect.Value))) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (f.omitEmpty && isEmptyValue($clone(fv, reflect.Value))) { */ case 11: + _i++; + /* continue; */ $s = 1; continue; + /* } */ case 12: + e.Buffer.WriteByte(next); + next = 44; + if (opts.escapeHTML) { + e.Buffer.WriteString(f.nameEscHTML); + } else { + e.Buffer.WriteString(f.nameNonEsc); + } + opts.quoted = f.quoted; + $r = f.encoder(e, $clone(fv, reflect.Value), $clone(opts, encOpts)); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 1; continue; case 2: + if (next === 123) { + e.Buffer.WriteString("{}"); + } else { + e.Buffer.WriteByte(125); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: structEncoder.ptr.prototype.encode }; } $f._i = _i; $f._i$1 = _i$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f.e = e; $f.f = f; $f.fv = fv; $f.i = i; $f.i$1 = i$1; $f.next = next; $f.opts = opts; $f.se = se; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newStructEncoder = function(t) { + var _r$3, se, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; se = $f.se; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = cachedTypeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + se = new structEncoder.ptr(_r$3); + $s = -1; return $methodVal($clone(se, structEncoder), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newStructEncoder }; } $f._r$3 = _r$3; $f.se = se; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + mapEncoder.ptr.prototype.encode = function(e, v, opts) { + var _arg, _arg$1, _arg$2, _i, _i$1, _r$3, _r$4, _r$5, _ref, _ref$1, e, err, i, i$1, keys, kv, me, opts, sv, v, v$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _i$1 = $f._i$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; e = $f.e; err = $f.err; i = $f.i; i$1 = $f.i$1; keys = $f.keys; kv = $f.kv; me = $f.me; opts = $f.opts; sv = $f.sv; v = $f.v; v$1 = $f.v$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + sv = [sv]; + me = this; + if ($clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + e.Buffer.WriteByte(123); + _r$3 = $clone(v, reflect.Value).MapKeys(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + keys = _r$3; + sv[0] = $makeSlice(sliceType$4, keys.$length); + _ref = keys; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + i = _i; + v$1 = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i]).v = v$1; + _r$4 = ((i < 0 || i >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i]).resolve(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + err = _r$4; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr($clone(v$1, reflect.Value).Type(), err)); + } + _i++; + /* } */ $s = 2; continue; case 3: + $r = sort.Slice(sv[0], (function(sv) { return function(i$1, j) { + var i$1, j; + return ((i$1 < 0 || i$1 >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i$1]).s < ((j < 0 || j >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + j]).s; + }; })(sv)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _ref$1 = sv[0]; + _i$1 = 0; + /* while (true) { */ case 6: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 7; continue; } + i$1 = _i$1; + kv = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), reflectWithString); + if (i$1 > 0) { + e.Buffer.WriteByte(44); + } + e.string(kv.s, opts.escapeHTML); + e.Buffer.WriteByte(58); + _arg = e; + _r$5 = $clone(v, reflect.Value).MapIndex($clone(kv.v, reflect.Value)); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = $clone(_r$5, reflect.Value); + _arg$2 = $clone(opts, encOpts); + $r = me.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i$1++; + /* } */ $s = 6; continue; case 7: + e.Buffer.WriteByte(125); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: mapEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._i$1 = _i$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f.e = e; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.keys = keys; $f.kv = kv; $f.me = me; $f.opts = opts; $f.sv = sv; $f.v = v; $f.v$1 = v$1; $f.$s = $s; $f.$r = $r; return $f; + }; + mapEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newMapEncoder = function(t) { + var _1, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, me, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; me = $f.me; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = t.Key(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = _r$3.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _1 = _r$4; + /* */ if ((_1 === (24)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 4; continue; } + _r$5 = t.Key(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = _r$5.Implements(textMarshalerType); /* */ $s = 8; case 8: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ if (!_r$6) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((_1 === (24)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 4: + $s = 6; continue; + /* } else if (!_r$6) { */ case 5: + $s = -1; return unsupportedTypeEncoder; + /* } */ case 6: + case 1: + _r$7 = t.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$8 = typeEncoder(_r$7); /* */ $s = 10; case 10: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + me = new mapEncoder.ptr(_r$8); + $s = -1; return $methodVal($clone(me, mapEncoder), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newMapEncoder }; } $f._1 = _1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f.me = me; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + encodeByteSlice = function(e, v, param) { + var _r$3, _r$4, _r$5, dst, dst$1, e, enc, encodedLen, param, s, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; dst = $f.dst; dst$1 = $f.dst$1; e = $f.e; enc = $f.enc; encodedLen = $f.encodedLen; param = $f.param; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _r$3 = $clone(v, reflect.Value).Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + s = _r$3; + e.Buffer.WriteByte(34); + encodedLen = base64.StdEncoding.EncodedLen(s.$length); + /* */ if (encodedLen <= 64) { $s = 2; continue; } + /* */ if (encodedLen <= 1024) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (encodedLen <= 64) { */ case 2: + dst = $subslice(new sliceType$1(e.scratch), 0, encodedLen); + base64.StdEncoding.Encode(dst, s); + e.Buffer.Write(dst); + $s = 5; continue; + /* } else if (encodedLen <= 1024) { */ case 3: + dst$1 = $makeSlice(sliceType$1, encodedLen); + base64.StdEncoding.Encode(dst$1, s); + e.Buffer.Write(dst$1); + $s = 5; continue; + /* } else { */ case 4: + enc = base64.NewEncoder(base64.StdEncoding, e); + _r$4 = enc.Write(s); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + _r$5 = enc.Close(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + /* } */ case 5: + e.Buffer.WriteByte(34); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: encodeByteSlice }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.dst = dst; $f.dst$1 = dst$1; $f.e = e; $f.enc = enc; $f.encodedLen = encodedLen; $f.param = param; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + sliceEncoder.ptr.prototype.encode = function(e, v, opts) { + var e, opts, se, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; opts = $f.opts; se = $f.se; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + se = this; + if ($clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + $r = se.arrayEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: sliceEncoder.ptr.prototype.encode }; } $f.e = e; $f.opts = opts; $f.se = se; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + sliceEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newSliceEncoder = function(t) { + var _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _v, enc, p, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _v = $f._v; enc = $f.enc; p = $f.p; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = t.Elem(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = _r$3.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4 === 8) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r$4 === 8) { */ case 1: + _r$5 = t.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = reflect.PtrTo(_r$5); /* */ $s = 6; case 6: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + p = _r$6; + _r$7 = p.Implements(marshalerType); /* */ $s = 10; case 10: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + if (!(!_r$7)) { _v = false; $s = 9; continue s; } + _r$8 = p.Implements(textMarshalerType); /* */ $s = 11; case 11: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _v = !_r$8; case 9: + /* */ if (_v) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_v) { */ case 7: + $s = -1; return encodeByteSlice; + /* } */ case 8: + /* } */ case 2: + _r$9 = newArrayEncoder(t); /* */ $s = 12; case 12: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + enc = new sliceEncoder.ptr(_r$9); + $s = -1; return $methodVal($clone(enc, sliceEncoder), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newSliceEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._v = _v; $f.enc = enc; $f.p = p; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + arrayEncoder.ptr.prototype.encode = function(e, v, opts) { + var _arg, _arg$1, _arg$2, _r$3, ae, e, i, n, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$3 = $f._r$3; ae = $f.ae; e = $f.e; i = $f.i; n = $f.n; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ae = this; + e.Buffer.WriteByte(91); + n = $clone(v, reflect.Value).Len(); + i = 0; + /* while (true) { */ case 1: + /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } + if (i > 0) { + e.Buffer.WriteByte(44); + } + _arg = e; + _r$3 = $clone(v, reflect.Value).Index(i); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _arg$1 = $clone(_r$3, reflect.Value); + _arg$2 = $clone(opts, encOpts); + $r = ae.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + e.Buffer.WriteByte(93); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: arrayEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$3 = _r$3; $f.ae = ae; $f.e = e; $f.i = i; $f.n = n; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + arrayEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newArrayEncoder = function(t) { + var _r$3, _r$4, enc, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = typeEncoder(_r$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + enc = new arrayEncoder.ptr(_r$4); + $s = -1; return $methodVal($clone(enc, arrayEncoder), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newArrayEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrEncoder.ptr.prototype.encode = function(e, v, opts) { + var _arg, _arg$1, _arg$2, _r$3, e, opts, pe, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; pe = $f.pe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + pe = this; + if ($clone(v, reflect.Value).IsNil()) { + e.Buffer.WriteString("null"); + $s = -1; return; + } + _arg = e; + _r$3 = $clone(v, reflect.Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _arg$1 = $clone(_r$3, reflect.Value); + _arg$2 = $clone(opts, encOpts); + $r = pe.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: ptrEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.pe = pe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newPtrEncoder = function(t) { + var _r$3, _r$4, enc, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$3 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = typeEncoder(_r$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + enc = new ptrEncoder.ptr(_r$4); + $s = -1; return $methodVal($clone(enc, ptrEncoder), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newPtrEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + condAddrEncoder.ptr.prototype.encode = function(e, v, opts) { + var ce, e, opts, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; ce = $f.ce; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ce = this; + /* */ if ($clone(v, reflect.Value).CanAddr()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(v, reflect.Value).CanAddr()) { */ case 1: + $r = ce.canAddrEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 3; continue; + /* } else { */ case 2: + $r = ce.elseEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: condAddrEncoder.ptr.prototype.encode }; } $f.ce = ce; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + condAddrEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; + newCondAddrEncoder = function(canAddrEnc, elseEnc) { + var canAddrEnc, elseEnc, enc; + enc = new condAddrEncoder.ptr(canAddrEnc, elseEnc); + return $methodVal($clone(enc, condAddrEncoder), "encode"); + }; + isValidTag = function(s) { + var _i, _ref, _rune, c, s; + if (s === "") { + return false; + } + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + c = _rune[0]; + if (strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c)) { + } else if (!unicode.IsLetter(c) && !unicode.IsDigit(c)) { + return false; + } + _i += _rune[1]; + } + return true; + }; + typeByIndex = function(t, index) { + var _i, _r$3, _r$4, _r$5, _ref, i, index, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; i = $f.i; index = $f.index; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _ref = index; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + _r$3 = t.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 22) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_r$3 === 22) { */ case 3: + _r$4 = t.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + t = _r$4; + /* } */ case 4: + _r$5 = t.Field(i); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + t = _r$5.Type; + _i++; + /* } */ $s = 1; continue; case 2: + $s = -1; return t; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeByIndex }; } $f._i = _i; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.i = i; $f.index = index; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + reflectWithString.ptr.prototype.resolve = function() { + var _1, _r$3, _r$4, _r$5, _tuple, _tuple$1, buf, err, ok, tm, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; err = $f.err; ok = $f.ok; tm = $f.tm; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + w = this; + /* */ if ($clone(w.v, reflect.Value).Kind() === 24) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(w.v, reflect.Value).Kind() === 24) { */ case 1: + _r$3 = $clone(w.v, reflect.Value).String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + w.s = _r$3; + $s = -1; return $ifaceNil; + /* } */ case 2: + _r$4 = $clone(w.v, reflect.Value).Interface(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = $assertType(_r$4, encoding.TextMarshaler, true); + tm = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (ok) { */ case 5: + _r$5 = tm.MarshalText(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$1 = _r$5; + buf = _tuple$1[0]; + err = _tuple$1[1]; + w.s = ($bytesToString(buf)); + $s = -1; return err; + /* } */ case 6: + _1 = $clone(w.v, reflect.Value).Kind(); + if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + w.s = strconv.FormatInt($clone(w.v, reflect.Value).Int(), 10); + $s = -1; return $ifaceNil; + } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { + w.s = strconv.FormatUint($clone(w.v, reflect.Value).Uint(), 10); + $s = -1; return $ifaceNil; + } + $panic(new $String("unexpected map key type")); + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: reflectWithString.ptr.prototype.resolve }; } $f._1 = _1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.err = err; $f.ok = ok; $f.tm = tm; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + reflectWithString.prototype.resolve = function() { return this.$val.resolve(); }; + encodeState.ptr.prototype.string = function(s, escapeHTML) { + var _1, _tuple, b, c, e, escapeHTML, i, s, size, start; + e = this; + e.Buffer.WriteByte(34); + start = 0; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + b = s.charCodeAt(i); + if (b < 128) { + if (((b < 0 || b >= htmlSafeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : htmlSafeSet[b]) || (!escapeHTML && ((b < 0 || b >= safeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : safeSet[b]))) { + i = i + (1) >> 0; + continue; + } + if (start < i) { + e.Buffer.WriteString($substring(s, start, i)); + } + e.Buffer.WriteByte(92); + _1 = b; + if ((_1 === (92)) || (_1 === (34))) { + e.Buffer.WriteByte(b); + } else if (_1 === (10)) { + e.Buffer.WriteByte(110); + } else if (_1 === (13)) { + e.Buffer.WriteByte(114); + } else if (_1 === (9)) { + e.Buffer.WriteByte(116); + } else { + e.Buffer.WriteString("u00"); + e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24))); + e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0))); + } + i = i + (1) >> 0; + start = i; + continue; + } + _tuple = utf8.DecodeRuneInString($substring(s, i)); + c = _tuple[0]; + size = _tuple[1]; + if ((c === 65533) && (size === 1)) { + if (start < i) { + e.Buffer.WriteString($substring(s, start, i)); + } + e.Buffer.WriteString("\\ufffd"); + i = i + (size) >> 0; + start = i; + continue; + } + if ((c === 8232) || (c === 8233)) { + if (start < i) { + e.Buffer.WriteString($substring(s, start, i)); + } + e.Buffer.WriteString("\\u202"); + e.Buffer.WriteByte(hex.charCodeAt((c & 15))); + i = i + (size) >> 0; + start = i; + continue; + } + i = i + (size) >> 0; + } + if (start < s.length) { + e.Buffer.WriteString($substring(s, start)); + } + e.Buffer.WriteByte(34); + }; + encodeState.prototype.string = function(s, escapeHTML) { return this.$val.string(s, escapeHTML); }; + encodeState.ptr.prototype.stringBytes = function(s, escapeHTML) { + var _1, _tuple, b, c, e, escapeHTML, i, s, size, start; + e = this; + e.Buffer.WriteByte(34); + start = 0; + i = 0; + while (true) { + if (!(i < s.$length)) { break; } + b = ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]); + if (b < 128) { + if (((b < 0 || b >= htmlSafeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : htmlSafeSet[b]) || (!escapeHTML && ((b < 0 || b >= safeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : safeSet[b]))) { + i = i + (1) >> 0; + continue; + } + if (start < i) { + e.Buffer.Write($subslice(s, start, i)); + } + e.Buffer.WriteByte(92); + _1 = b; + if ((_1 === (92)) || (_1 === (34))) { + e.Buffer.WriteByte(b); + } else if (_1 === (10)) { + e.Buffer.WriteByte(110); + } else if (_1 === (13)) { + e.Buffer.WriteByte(114); + } else if (_1 === (9)) { + e.Buffer.WriteByte(116); + } else { + e.Buffer.WriteString("u00"); + e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24))); + e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0))); + } + i = i + (1) >> 0; + start = i; + continue; + } + _tuple = utf8.DecodeRune($subslice(s, i)); + c = _tuple[0]; + size = _tuple[1]; + if ((c === 65533) && (size === 1)) { + if (start < i) { + e.Buffer.Write($subslice(s, start, i)); + } + e.Buffer.WriteString("\\ufffd"); + i = i + (size) >> 0; + start = i; + continue; + } + if ((c === 8232) || (c === 8233)) { + if (start < i) { + e.Buffer.Write($subslice(s, start, i)); + } + e.Buffer.WriteString("\\u202"); + e.Buffer.WriteByte(hex.charCodeAt((c & 15))); + i = i + (size) >> 0; + start = i; + continue; + } + i = i + (size) >> 0; + } + if (start < s.$length) { + e.Buffer.Write($subslice(s, start)); + } + e.Buffer.WriteByte(34); + }; + encodeState.prototype.stringBytes = function(s, escapeHTML) { return this.$val.stringBytes(s, escapeHTML); }; + byIndex.prototype.Len = function() { + var x; + x = this; + return x.$length; + }; + $ptrType(byIndex).prototype.Len = function() { return this.$get().Len(); }; + byIndex.prototype.Swap = function(i, j) { + var _tmp, _tmp$1, i, j, x; + x = this; + _tmp = $clone(((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]), field); + _tmp$1 = $clone(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), field); + field.copy(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), _tmp); + field.copy(((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]), _tmp$1); + }; + $ptrType(byIndex).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + byIndex.prototype.Less = function(i, j) { + var _i, _ref, i, j, k, x, x$1, x$2, xik; + x = this; + _ref = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]).index; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + k = _i; + xik = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (k >= ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index.$length) { + return false; + } + if (!((xik === (x$1 = ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + k]))))) { + return xik < (x$2 = ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + k])); + } + _i++; + } + return ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index.$length; + }; + $ptrType(byIndex).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + typeFields = function(t) { + var _1, _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _v, _v$1, _v$2, advance, count, current, dominant, f, f$1, fi, field$1, fields, fj, ft, i, i$1, i$2, index, isUnexported, name, name$1, nameEscBuf, next, nextCount, ok, opts, out, quoted, sf, t, t$1, tag, tagged, visited, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; advance = $f.advance; count = $f.count; current = $f.current; dominant = $f.dominant; f = $f.f; f$1 = $f.f$1; fi = $f.fi; field$1 = $f.field$1; fields = $f.fields; fj = $f.fj; ft = $f.ft; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; index = $f.index; isUnexported = $f.isUnexported; name = $f.name; name$1 = $f.name$1; nameEscBuf = $f.nameEscBuf; next = $f.next; nextCount = $f.nextCount; ok = $f.ok; opts = $f.opts; out = $f.out; quoted = $f.quoted; sf = $f.sf; t = $f.t; t$1 = $f.t$1; tag = $f.tag; tagged = $f.tagged; visited = $f.visited; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fields = [fields]; + nameEscBuf = [nameEscBuf]; + current = new sliceType$3([]); + next = new sliceType$3([new field.ptr("", sliceType$1.nil, $throwNilPointerError, "", "", false, sliceType$2.nil, t, false, false, $throwNilPointerError)]); + count = $makeMap(reflect.Type.keyFor, []); + nextCount = $makeMap(reflect.Type.keyFor, []); + visited = $makeMap(reflect.Type.keyFor, []); + fields[0] = sliceType$3.nil; + nameEscBuf[0] = new bytes.Buffer.ptr(sliceType$1.nil, 0, 0); + /* while (true) { */ case 1: + /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; } + _tmp = next; + _tmp$1 = $subslice(current, 0, 0); + current = _tmp; + next = _tmp$1; + _tmp$2 = nextCount; + _tmp$3 = $makeMap(reflect.Type.keyFor, []); + count = _tmp$2; + nextCount = _tmp$3; + _ref = current; + _i = 0; + /* while (true) { */ case 3: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } + f = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), field); + /* */ if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { */ case 5: + _i++; + /* continue; */ $s = 3; continue; + /* } */ case 6: + _key = f.typ; (visited || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key)] = { k: _key, v: true }; + i = 0; + /* while (true) { */ case 7: + _r$3 = f.typ.NumField(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* if (!(i < _r$3)) { break; } */ if(!(i < _r$3)) { $s = 8; continue; } + _r$4 = f.typ.Field(i); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + sf = $clone(_r$4, reflect.StructField); + isUnexported = !(sf.PkgPath === ""); + /* */ if (sf.Anonymous) { $s = 11; continue; } + /* */ if (isUnexported) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (sf.Anonymous) { */ case 11: + t$1 = sf.Type; + _r$5 = t$1.Kind(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (_r$5 === 22) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (_r$5 === 22) { */ case 14: + _r$6 = t$1.Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + t$1 = _r$6; + /* } */ case 15: + if (!(isUnexported)) { _v = false; $s = 20; continue s; } + _r$7 = t$1.Kind(); /* */ $s = 21; case 21: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v = !((_r$7 === 25)); case 20: + /* */ if (_v) { $s = 18; continue; } + /* */ $s = 19; continue; + /* if (_v) { */ case 18: + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 19: + $s = 13; continue; + /* } else if (isUnexported) { */ case 12: + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 13: + tag = new reflect.StructTag(sf.Tag).Get("json"); + /* */ if (tag === "-") { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (tag === "-") { */ case 22: + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 23: + _tuple = parseTag(tag); + name = _tuple[0]; + opts = _tuple[1]; + if (!isValidTag(name)) { + name = ""; + } + index = $makeSlice(sliceType$2, (f.index.$length + 1 >> 0)); + $copySlice(index, f.index); + (x = f.index.$length, ((x < 0 || x >= index.$length) ? ($throwRuntimeError("index out of range"), undefined) : index.$array[index.$offset + x] = i)); + ft = sf.Type; + _r$8 = ft.Name(); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + if (!(_r$8 === "")) { _v$1 = false; $s = 26; continue s; } + _r$9 = ft.Kind(); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _v$1 = _r$9 === 22; case 26: + /* */ if (_v$1) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (_v$1) { */ case 24: + _r$10 = ft.Elem(); /* */ $s = 29; case 29: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + ft = _r$10; + /* } */ case 25: + quoted = false; + /* */ if (new tagOptions(opts).Contains("string")) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if (new tagOptions(opts).Contains("string")) { */ case 30: + _r$11 = ft.Kind(); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _1 = _r$11; + if ((_1 === (1)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12)) || (_1 === (13)) || (_1 === (14)) || (_1 === (24))) { + quoted = true; + } + case 32: + /* } */ case 31: + if (!(name === "") || !sf.Anonymous) { _v$2 = true; $s = 36; continue s; } + _r$12 = ft.Kind(); /* */ $s = 37; case 37: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _v$2 = !((_r$12 === 25)); case 36: + /* */ if (_v$2) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if (_v$2) { */ case 34: + tagged = !(name === ""); + if (name === "") { + name = sf.Name; + } + field$1 = new field.ptr(name, sliceType$1.nil, $throwNilPointerError, "", "", tagged, index, ft, new tagOptions(opts).Contains("omitempty"), quoted, $throwNilPointerError); + field$1.nameBytes = (new sliceType$1($stringToBytes(field$1.name))); + field$1.equalFold = foldFunc(field$1.nameBytes); + nameEscBuf[0].Reset(); + nameEscBuf[0].WriteString("\""); + HTMLEscape(nameEscBuf[0], field$1.nameBytes); + nameEscBuf[0].WriteString("\":"); + field$1.nameEscHTML = nameEscBuf[0].String(); + field$1.nameNonEsc = "\"" + field$1.name + "\":"; + fields[0] = $append(fields[0], field$1); + if ((_entry$1 = count[reflect.Type.keyFor(f.typ)], _entry$1 !== undefined ? _entry$1.v : 0) > 1) { + fields[0] = $append(fields[0], (x$1 = fields[0].$length - 1 >> 0, ((x$1 < 0 || x$1 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + x$1]))); + } + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 35: + _key$1 = ft; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$1)] = { k: _key$1, v: (_entry$2 = nextCount[reflect.Type.keyFor(ft)], _entry$2 !== undefined ? _entry$2.v : 0) + (1) >> 0 }; + /* */ if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { $s = 38; continue; } + /* */ $s = 39; continue; + /* if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { */ case 38: + _r$13 = ft.Name(); /* */ $s = 40; case 40: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + next = $append(next, new field.ptr(_r$13, sliceType$1.nil, $throwNilPointerError, "", "", false, index, ft, false, false, $throwNilPointerError)); + /* } */ case 39: + i = i + (1) >> 0; + /* } */ $s = 7; continue; case 8: + _i++; + /* } */ $s = 3; continue; case 4: + /* } */ $s = 1; continue; case 2: + $r = sort.Slice(fields[0], (function(fields, nameEscBuf) { return function(i$1, j) { + var i$1, j, x$2; + x$2 = fields[0]; + if (!(((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).name === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).name)) { + return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).name < ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).name; + } + if (!((((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).index.$length === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).index.$length))) { + return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).index.$length < ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).index.$length; + } + if (!(((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).tag === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).tag)) { + return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).tag; + } + return ($subslice(new byIndex(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)).Less(i$1, j); + }; })(fields, nameEscBuf)); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + out = $subslice(fields[0], 0, 0); + _tmp$4 = 0; + _tmp$5 = 0; + advance = _tmp$4; + i$1 = _tmp$5; + /* while (true) { */ case 42: + /* if (!(i$1 < fields[0].$length)) { break; } */ if(!(i$1 < fields[0].$length)) { $s = 43; continue; } + fi = $clone(((i$1 < 0 || i$1 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + i$1]), field); + name$1 = fi.name; + advance = 1; + while (true) { + if (!((i$1 + advance >> 0) < fields[0].$length)) { break; } + fj = $clone((x$2 = i$1 + advance >> 0, ((x$2 < 0 || x$2 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + x$2])), field); + if (!(fj.name === name$1)) { + break; + } + advance = advance + (1) >> 0; + } + if (advance === 1) { + out = $append(out, fi); + i$1 = i$1 + (advance) >> 0; + /* continue; */ $s = 42; continue; + } + _tuple$1 = dominantField($subslice(fields[0], i$1, (i$1 + advance >> 0))); + dominant = $clone(_tuple$1[0], field); + ok = _tuple$1[1]; + if (ok) { + out = $append(out, dominant); + } + i$1 = i$1 + (advance) >> 0; + /* } */ $s = 42; continue; case 43: + fields[0] = out; + $r = sort.Sort(($subslice(new byIndex(fields[0].$array), fields[0].$offset, fields[0].$offset + fields[0].$length))); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _ref$1 = fields[0]; + _i$1 = 0; + /* while (true) { */ case 45: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 46; continue; } + i$2 = _i$1; + f$1 = ((i$2 < 0 || i$2 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + i$2]); + _r$14 = typeByIndex(t, f$1.index); /* */ $s = 47; case 47: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + _r$15 = typeEncoder(_r$14); /* */ $s = 48; case 48: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + f$1.encoder = _r$15; + _i$1++; + /* } */ $s = 45; continue; case 46: + $s = -1; return fields[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeFields }; } $f._1 = _1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.advance = advance; $f.count = count; $f.current = current; $f.dominant = dominant; $f.f = f; $f.f$1 = f$1; $f.fi = fi; $f.field$1 = field$1; $f.fields = fields; $f.fj = fj; $f.ft = ft; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.index = index; $f.isUnexported = isUnexported; $f.name = name; $f.name$1 = name$1; $f.nameEscBuf = nameEscBuf; $f.next = next; $f.nextCount = nextCount; $f.ok = ok; $f.opts = opts; $f.out = out; $f.quoted = quoted; $f.sf = sf; $f.t = t; $f.t$1 = t$1; $f.tag = tag; $f.tagged = tagged; $f.visited = visited; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + dominantField = function(fields) { + var fields; + if (fields.$length > 1 && ((0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]).index.$length === (1 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 1]).index.$length) && (0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]).tag === (1 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 1]).tag) { + return [new field.ptr("", sliceType$1.nil, $throwNilPointerError, "", "", false, sliceType$2.nil, $ifaceNil, false, false, $throwNilPointerError), false]; + } + return [(0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]), true]; + }; + cachedTypeFields = function(t) { + var _arg, _arg$1, _r$3, _r$4, _tuple, _tuple$1, f, f$1, ok, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; f$1 = $f.f$1; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tuple = fieldCache.Load(t); + f = _tuple[0]; + ok = _tuple[1]; + if (ok) { + $s = -1; return $assertType(f, sliceType$3); + } + _arg = t; + _r$3 = typeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _arg$1 = _r$3; + _r$4 = fieldCache.LoadOrStore(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + f$1 = _tuple$1[0]; + $s = -1; return $assertType(f$1, sliceType$3); + /* */ } return; } if ($f === undefined) { $f = { $blk: cachedTypeFields }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.f$1 = f$1; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + foldFunc = function(s) { + var _i, _ref, b, nonLetter, s, special, upper; + nonLetter = false; + special = false; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b >= 128) { + return bytes.EqualFold; + } + upper = (b & 223) >>> 0; + if (upper < 65 || upper > 90) { + nonLetter = true; + } else if ((upper === 75) || (upper === 83)) { + special = true; + } + _i++; + } + if (special) { + return equalFoldRight; + } + if (nonLetter) { + return asciiEqualFold; + } + return simpleLetterEqualFold; + }; + equalFoldRight = function(s, t) { + var _1, _i, _ref, _tuple, s, sb, sbUpper, size, t, tb, tr; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + sb = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (t.$length === 0) { + return false; + } + tb = (0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]); + if (tb < 128) { + if (!((sb === tb))) { + sbUpper = (sb & 223) >>> 0; + if (65 <= sbUpper && sbUpper <= 90) { + if (!((sbUpper === ((tb & 223) >>> 0)))) { + return false; + } + } else { + return false; + } + } + t = $subslice(t, 1); + _i++; + continue; + } + _tuple = utf8.DecodeRune(t); + tr = _tuple[0]; + size = _tuple[1]; + _1 = sb; + if ((_1 === (115)) || (_1 === (83))) { + if (!((tr === 383))) { + return false; + } + } else if ((_1 === (107)) || (_1 === (75))) { + if (!((tr === 8490))) { + return false; + } + } else { + return false; + } + t = $subslice(t, size); + _i++; + } + if (t.$length > 0) { + return false; + } + return true; + }; + asciiEqualFold = function(s, t) { + var _i, _ref, i, s, sb, t, tb; + if (!((s.$length === t.$length))) { + return false; + } + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + sb = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + tb = ((i < 0 || i >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + i]); + if (sb === tb) { + _i++; + continue; + } + if ((97 <= sb && sb <= 122) || (65 <= sb && sb <= 90)) { + if (!((((sb & 223) >>> 0) === ((tb & 223) >>> 0)))) { + return false; + } + } else { + return false; + } + _i++; + } + return true; + }; + simpleLetterEqualFold = function(s, t) { + var _i, _ref, b, i, s, t; + if (!((s.$length === t.$length))) { + return false; + } + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((((b & 223) >>> 0) === ((((i < 0 || i >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + i]) & 223) >>> 0)))) { + return false; + } + _i++; + } + return true; + }; + compact = function(dst, src, escape) { + var _i, _r$3, _r$4, _ref, c, dst, escape, i, origLen, scan, src, start, v, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; c = $f.c; dst = $f.dst; escape = $f.escape; i = $f.i; origLen = $f.origLen; scan = $f.scan; src = $f.src; start = $f.start; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + scan = [scan]; + origLen = dst.Len(); + scan[0] = new scanner.ptr($throwNilPointerError, false, sliceType$2.nil, $ifaceNil, new $Int64(0, 0)); + scan[0].reset(); + start = 0; + _ref = src; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (escape && ((c === 60) || (c === 62) || (c === 38))) { + if (start < i) { + dst.Write($subslice(src, start, i)); + } + dst.WriteString("\\u00"); + dst.WriteByte(hex.charCodeAt((c >>> 4 << 24 >>> 24))); + dst.WriteByte(hex.charCodeAt(((c & 15) >>> 0))); + start = i + 1 >> 0; + } + if ((c === 226) && (i + 2 >> 0) < src.$length && ((x = i + 1 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) & ~1) << 24 >>> 24) === 168)) { + if (start < i) { + dst.Write($subslice(src, start, i)); + } + dst.WriteString("\\u202"); + dst.WriteByte(hex.charCodeAt((((x$2 = i + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) & 15) >>> 0))); + start = i + 3 >> 0; + } + _r$3 = scan[0].step(scan[0], c); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + if (v >= 9) { + if (v === 11) { + /* break; */ $s = 2; continue; + } + if (start < i) { + dst.Write($subslice(src, start, i)); + } + start = i + 1 >> 0; + } + _i++; + /* } */ $s = 1; continue; case 2: + _r$4 = scan[0].eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4 === 11) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$4 === 11) { */ case 4: + dst.Truncate(origLen); + $s = -1; return scan[0].err; + /* } */ case 5: + if (start < src.$length) { + dst.Write($subslice(src, start)); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: compact }; } $f._i = _i; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.c = c; $f.dst = dst; $f.escape = escape; $f.i = i; $f.origLen = origLen; $f.scan = scan; $f.src = src; $f.start = start; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + SyntaxError.ptr.prototype.Error = function() { + var e; + e = this; + return e.msg; + }; + SyntaxError.prototype.Error = function() { return this.$val.Error(); }; + scanner.ptr.prototype.reset = function() { + var s; + s = this; + s.step = stateBeginValue; + s.parseState = $subslice(s.parseState, 0, 0); + s.err = $ifaceNil; + s.endTop = false; + }; + scanner.prototype.reset = function() { return this.$val.reset(); }; + scanner.ptr.prototype.eof = function() { + var _r$3, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + if (!($interfaceIsEqual(s.err, $ifaceNil))) { + $s = -1; return 11; + } + if (s.endTop) { + $s = -1; return 10; + } + _r$3 = s.step(s, 32); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + if (s.endTop) { + $s = -1; return 10; + } + if ($interfaceIsEqual(s.err, $ifaceNil)) { + s.err = new SyntaxError.ptr("unexpected end of JSON input", s.bytes); + } + $s = -1; return 11; + /* */ } return; } if ($f === undefined) { $f = { $blk: scanner.ptr.prototype.eof }; } $f._r$3 = _r$3; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + scanner.prototype.eof = function() { return this.$val.eof(); }; + scanner.ptr.prototype.pushParseState = function(p) { + var p, s; + s = this; + s.parseState = $append(s.parseState, p); + }; + scanner.prototype.pushParseState = function(p) { return this.$val.pushParseState(p); }; + scanner.ptr.prototype.popParseState = function() { + var n, s; + s = this; + n = s.parseState.$length - 1 >> 0; + s.parseState = $subslice(s.parseState, 0, n); + if (n === 0) { + s.step = stateEndTop; + s.endTop = true; + } else { + s.step = stateEndValue; + } + }; + scanner.prototype.popParseState = function() { return this.$val.popParseState(); }; + isSpace = function(c) { + var c; + return (c === 32) || (c === 9) || (c === 13) || (c === 10); + }; + stateBeginValueOrEmpty = function(s, c) { + var c, s; + if (c <= 32 && isSpace(c)) { + return 9; + } + if (c === 93) { + return stateEndValue(s, c); + } + return stateBeginValue(s, c); + }; + stateBeginValue = function(s, c) { + var _1, c, s; + if (c <= 32 && isSpace(c)) { + return 9; + } + _1 = c; + if (_1 === (123)) { + s.step = stateBeginStringOrEmpty; + s.pushParseState(0); + return 2; + } else if (_1 === (91)) { + s.step = stateBeginValueOrEmpty; + s.pushParseState(2); + return 6; + } else if (_1 === (34)) { + s.step = stateInString; + return 1; + } else if (_1 === (45)) { + s.step = stateNeg; + return 1; + } else if (_1 === (48)) { + s.step = state0; + return 1; + } else if (_1 === (116)) { + s.step = stateT; + return 1; + } else if (_1 === (102)) { + s.step = stateF; + return 1; + } else if (_1 === (110)) { + s.step = stateN; + return 1; + } + if (49 <= c && c <= 57) { + s.step = state1; + return 1; + } + return s.error(c, "looking for beginning of value"); + }; + stateBeginStringOrEmpty = function(s, c) { + var c, n, s, x, x$1; + if (c <= 32 && isSpace(c)) { + return 9; + } + if (c === 125) { + n = s.parseState.$length; + (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1] = 1)); + return stateEndValue(s, c); + } + return stateBeginString(s, c); + }; + stateBeginString = function(s, c) { + var c, s; + if (c <= 32 && isSpace(c)) { + return 9; + } + if (c === 34) { + s.step = stateInString; + return 1; + } + return s.error(c, "looking for beginning of object key string"); + }; + stateEndValue = function(s, c) { + var _1, c, n, ps, s, x, x$1, x$2, x$3, x$4, x$5; + n = s.parseState.$length; + if (n === 0) { + s.step = stateEndTop; + s.endTop = true; + return stateEndTop(s, c); + } + if (c <= 32 && isSpace(c)) { + s.step = stateEndValue; + return 9; + } + ps = (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + _1 = ps; + if (_1 === (0)) { + if (c === 58) { + (x$2 = s.parseState, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3] = 1)); + s.step = stateBeginValue; + return 3; + } + return s.error(c, "after object key"); + } else if (_1 === (1)) { + if (c === 44) { + (x$4 = s.parseState, x$5 = n - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5] = 0)); + s.step = stateBeginString; + return 4; + } + if (c === 125) { + s.popParseState(); + return 5; + } + return s.error(c, "after object key:value pair"); + } else if (_1 === (2)) { + if (c === 44) { + s.step = stateBeginValue; + return 7; + } + if (c === 93) { + s.popParseState(); + return 8; + } + return s.error(c, "after array element"); + } + return s.error(c, ""); + }; + stateEndTop = function(s, c) { + var c, s; + if (!isSpace(c)) { + s.error(c, "after top-level value"); + } + return 10; + }; + stateInString = function(s, c) { + var c, s; + if (c === 34) { + s.step = stateEndValue; + return 0; + } + if (c === 92) { + s.step = stateInStringEsc; + return 0; + } + if (c < 32) { + return s.error(c, "in string literal"); + } + return 0; + }; + stateInStringEsc = function(s, c) { + var _1, c, s; + _1 = c; + if ((_1 === (98)) || (_1 === (102)) || (_1 === (110)) || (_1 === (114)) || (_1 === (116)) || (_1 === (92)) || (_1 === (47)) || (_1 === (34))) { + s.step = stateInString; + return 0; + } else if (_1 === (117)) { + s.step = stateInStringEscU; + return 0; + } + return s.error(c, "in string escape code"); + }; + stateInStringEscU = function(s, c) { + var c, s; + if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { + s.step = stateInStringEscU1; + return 0; + } + return s.error(c, "in \\u hexadecimal character escape"); + }; + stateInStringEscU1 = function(s, c) { + var c, s; + if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { + s.step = stateInStringEscU12; + return 0; + } + return s.error(c, "in \\u hexadecimal character escape"); + }; + stateInStringEscU12 = function(s, c) { + var c, s; + if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { + s.step = stateInStringEscU123; + return 0; + } + return s.error(c, "in \\u hexadecimal character escape"); + }; + stateInStringEscU123 = function(s, c) { + var c, s; + if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { + s.step = stateInString; + return 0; + } + return s.error(c, "in \\u hexadecimal character escape"); + }; + stateNeg = function(s, c) { + var c, s; + if (c === 48) { + s.step = state0; + return 0; + } + if (49 <= c && c <= 57) { + s.step = state1; + return 0; + } + return s.error(c, "in numeric literal"); + }; + state1 = function(s, c) { + var c, s; + if (48 <= c && c <= 57) { + s.step = state1; + return 0; + } + return state0(s, c); + }; + state0 = function(s, c) { + var c, s; + if (c === 46) { + s.step = stateDot; + return 0; + } + if ((c === 101) || (c === 69)) { + s.step = stateE; + return 0; + } + return stateEndValue(s, c); + }; + stateDot = function(s, c) { + var c, s; + if (48 <= c && c <= 57) { + s.step = stateDot0; + return 0; + } + return s.error(c, "after decimal point in numeric literal"); + }; + stateDot0 = function(s, c) { + var c, s; + if (48 <= c && c <= 57) { + return 0; + } + if ((c === 101) || (c === 69)) { + s.step = stateE; + return 0; + } + return stateEndValue(s, c); + }; + stateE = function(s, c) { + var c, s; + if ((c === 43) || (c === 45)) { + s.step = stateESign; + return 0; + } + return stateESign(s, c); + }; + stateESign = function(s, c) { + var c, s; + if (48 <= c && c <= 57) { + s.step = stateE0; + return 0; + } + return s.error(c, "in exponent of numeric literal"); + }; + stateE0 = function(s, c) { + var c, s; + if (48 <= c && c <= 57) { + return 0; + } + return stateEndValue(s, c); + }; + stateT = function(s, c) { + var c, s; + if (c === 114) { + s.step = stateTr; + return 0; + } + return s.error(c, "in literal true (expecting 'r')"); + }; + stateTr = function(s, c) { + var c, s; + if (c === 117) { + s.step = stateTru; + return 0; + } + return s.error(c, "in literal true (expecting 'u')"); + }; + stateTru = function(s, c) { + var c, s; + if (c === 101) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal true (expecting 'e')"); + }; + stateF = function(s, c) { + var c, s; + if (c === 97) { + s.step = stateFa; + return 0; + } + return s.error(c, "in literal false (expecting 'a')"); + }; + stateFa = function(s, c) { + var c, s; + if (c === 108) { + s.step = stateFal; + return 0; + } + return s.error(c, "in literal false (expecting 'l')"); + }; + stateFal = function(s, c) { + var c, s; + if (c === 115) { + s.step = stateFals; + return 0; + } + return s.error(c, "in literal false (expecting 's')"); + }; + stateFals = function(s, c) { + var c, s; + if (c === 101) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal false (expecting 'e')"); + }; + stateN = function(s, c) { + var c, s; + if (c === 117) { + s.step = stateNu; + return 0; + } + return s.error(c, "in literal null (expecting 'u')"); + }; + stateNu = function(s, c) { + var c, s; + if (c === 108) { + s.step = stateNul; + return 0; + } + return s.error(c, "in literal null (expecting 'l')"); + }; + stateNul = function(s, c) { + var c, s; + if (c === 108) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal null (expecting 'l')"); + }; + stateError = function(s, c) { + var c, s; + return 11; + }; + scanner.ptr.prototype.error = function(c, context) { + var c, context, s; + s = this; + s.step = stateError; + s.err = new SyntaxError.ptr("invalid character " + quoteChar(c) + " " + context, s.bytes); + return 11; + }; + scanner.prototype.error = function(c, context) { return this.$val.error(c, context); }; + quoteChar = function(c) { + var c, s; + if (c === 39) { + return "'\\''"; + } + if (c === 34) { + return "'\"'"; + } + s = strconv.Quote(($encodeRune(c))); + return "'" + $substring(s, 1, (s.length - 1 >> 0)) + "'"; + }; + parseTag = function(tag) { + var idx, tag; + idx = strings.Index(tag, ","); + if (!((idx === -1))) { + return [$substring(tag, 0, idx), ($substring(tag, (idx + 1 >> 0)))]; + } + return [tag, ""]; + }; + tagOptions.prototype.Contains = function(optionName) { + var _tmp, _tmp$1, i, next, o, optionName, s; + o = this.$val; + if (o.length === 0) { + return false; + } + s = (o); + while (true) { + if (!(!(s === ""))) { break; } + next = ""; + i = strings.Index(s, ","); + if (i >= 0) { + _tmp = $substring(s, 0, i); + _tmp$1 = $substring(s, (i + 1 >> 0)); + s = _tmp; + next = _tmp$1; + } + if (s === optionName) { + return true; + } + s = next; + } + return false; + }; + $ptrType(tagOptions).prototype.Contains = function(optionName) { return new tagOptions(this.$get()).Contains(optionName); }; + Number.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $error], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64, $error], false)}]; + ptrType$14.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$15.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$17.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$7.methods = [{prop: "marshal", name: "marshal", pkg: "encoding/json", typ: $funcType([$emptyInterface, encOpts], [$error], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "reflectValue", name: "reflectValue", pkg: "encoding/json", typ: $funcType([reflect.Value, encOpts], [], false)}, {prop: "string", name: "string", pkg: "encoding/json", typ: $funcType([$String, $Bool], [], false)}, {prop: "stringBytes", name: "stringBytes", pkg: "encoding/json", typ: $funcType([sliceType$1, $Bool], [], false)}]; + floatEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + structEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + mapEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + sliceEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + arrayEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + ptrEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + condAddrEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; + ptrType$18.methods = [{prop: "resolve", name: "resolve", pkg: "encoding/json", typ: $funcType([], [$error], false)}]; + byIndex.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}]; + ptrType$19.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$20.methods = [{prop: "reset", name: "reset", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "eof", name: "eof", pkg: "encoding/json", typ: $funcType([], [$Int], false)}, {prop: "pushParseState", name: "pushParseState", pkg: "encoding/json", typ: $funcType([$Int], [], false)}, {prop: "popParseState", name: "popParseState", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$Uint8, $String], [$Int], false)}]; + tagOptions.methods = [{prop: "Contains", name: "Contains", pkg: "", typ: $funcType([$String], [$Bool], false)}]; + Marshaler.init([{prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}]); + UnsupportedTypeError.init("", [{prop: "Type", name: "Type", embedded: false, exported: true, typ: reflect.Type, tag: ""}]); + UnsupportedValueError.init("", [{prop: "Value", name: "Value", embedded: false, exported: true, typ: reflect.Value, tag: ""}, {prop: "Str", name: "Str", embedded: false, exported: true, typ: $String, tag: ""}]); + MarshalerError.init("", [{prop: "Type", name: "Type", embedded: false, exported: true, typ: reflect.Type, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); + encodeState.init("encoding/json", [{prop: "Buffer", name: "Buffer", embedded: true, exported: true, typ: bytes.Buffer, tag: ""}, {prop: "scratch", name: "scratch", embedded: false, exported: false, typ: arrayType, tag: ""}]); + jsonError.init("encoding/json", [{prop: "error", name: "error", embedded: true, exported: false, typ: $error, tag: ""}]); + encOpts.init("encoding/json", [{prop: "quoted", name: "quoted", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "escapeHTML", name: "escapeHTML", embedded: false, exported: false, typ: $Bool, tag: ""}]); + encoderFunc.init([ptrType$7, reflect.Value, encOpts], [], false); + structEncoder.init("encoding/json", [{prop: "fields", name: "fields", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); + mapEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + sliceEncoder.init("encoding/json", [{prop: "arrayEnc", name: "arrayEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + arrayEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + ptrEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + condAddrEncoder.init("encoding/json", [{prop: "canAddrEnc", name: "canAddrEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}, {prop: "elseEnc", name: "elseEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + reflectWithString.init("encoding/json", [{prop: "v", name: "v", embedded: false, exported: false, typ: reflect.Value, tag: ""}, {prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}]); + field.init("encoding/json", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "nameBytes", name: "nameBytes", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "equalFold", name: "equalFold", embedded: false, exported: false, typ: funcType, tag: ""}, {prop: "nameNonEsc", name: "nameNonEsc", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "nameEscHTML", name: "nameEscHTML", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tag", name: "tag", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: reflect.Type, tag: ""}, {prop: "omitEmpty", name: "omitEmpty", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "quoted", name: "quoted", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "encoder", name: "encoder", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); + byIndex.init(field); + SyntaxError.init("encoding/json", [{prop: "msg", name: "msg", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "Offset", name: "Offset", embedded: false, exported: true, typ: $Int64, tag: ""}]); + scanner.init("encoding/json", [{prop: "step", name: "step", embedded: false, exported: false, typ: funcType$1, tag: ""}, {prop: "endTop", name: "endTop", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "parseState", name: "parseState", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}, {prop: "bytes", name: "bytes", embedded: false, exported: false, typ: $Int64, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = encoding.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = base64.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = errors.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf16.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + encodeStatePool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); + encoderCache = new nosync.Map.ptr(false); + fieldCache = new nosync.Map.ptr(false); + _r = reflect.TypeOf((ptrType.nil)).Elem(); /* */ $s = 16; case 16: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + textUnmarshalerType = _r; + numberType = reflect.TypeOf(new Number("")); + hex = "0123456789abcdef"; + _r$1 = reflect.TypeOf((ptrType$1.nil)).Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + marshalerType = _r$1; + _r$2 = reflect.TypeOf((ptrType$2.nil)).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + textMarshalerType = _r$2; + float32Encoder = $methodVal(new floatEncoder(32), "encode"); + float64Encoder = $methodVal(new floatEncoder(64), "encode"); + safeSet = $toNativeArray($kindBool, [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]); + htmlSafeSet = $toNativeArray($kindBool, [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["log"] = (function() { + var $pkg = {}, $init, fmt, nosync, io, os, runtime, time, Logger, sliceType, arrayType, ptrType, sliceType$1, ptrType$1, std, New, itoa, Printf, Println; + fmt = $packages["fmt"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + io = $packages["io"]; + os = $packages["os"]; + runtime = $packages["runtime"]; + time = $packages["time"]; + Logger = $pkg.Logger = $newType(0, $kindStruct, "log.Logger", true, "log", true, function(mu_, prefix_, flag_, out_, buf_) { + this.$val = this; + if (arguments.length === 0) { + this.mu = new nosync.Mutex.ptr(false); + this.prefix = ""; + this.flag = 0; + this.out = $ifaceNil; + this.buf = sliceType.nil; + return; + } + this.mu = mu_; + this.prefix = prefix_; + this.flag = flag_; + this.out = out_; + this.buf = buf_; + }); + sliceType = $sliceType($Uint8); + arrayType = $arrayType($Uint8, 20); + ptrType = $ptrType(sliceType); + sliceType$1 = $sliceType($emptyInterface); + ptrType$1 = $ptrType(Logger); + New = function(out, prefix, flag) { + var flag, out, prefix; + return new Logger.ptr(new nosync.Mutex.ptr(false), prefix, flag, out, sliceType.nil); + }; + $pkg.New = New; + Logger.ptr.prototype.SetOutput = function(w) { + var l, w, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + l.out = w; + /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.SetOutput = function(w) { return this.$val.SetOutput(w); }; + itoa = function(buf, i, wid) { + var _q, b, bp, buf, i, q, wid; + b = arrayType.zero(); + bp = 19; + while (true) { + if (!(i >= 10 || wid > 1)) { break; } + wid = wid - (1) >> 0; + q = (_q = i / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + ((bp < 0 || bp >= b.length) ? ($throwRuntimeError("index out of range"), undefined) : b[bp] = ((((48 + i >> 0) - ($imul(q, 10)) >> 0) << 24 >>> 24))); + bp = bp - (1) >> 0; + i = q; + } + ((bp < 0 || bp >= b.length) ? ($throwRuntimeError("index out of range"), undefined) : b[bp] = (((48 + i >> 0) << 24 >>> 24))); + buf.$set($appendSlice(buf.$get(), $subslice(new sliceType(b), bp))); + }; + Logger.ptr.prototype.formatHeader = function(buf, t, file, line) { + var _q, _r, _r$1, _tuple, _tuple$1, buf, day, file, hour, i, l, line, min, month, sec, short$1, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; day = $f.day; file = $f.file; hour = $f.hour; i = $f.i; l = $f.l; line = $f.line; min = $f.min; month = $f.month; sec = $f.sec; short$1 = $f.short$1; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + buf.$set($appendSlice(buf.$get(), l.prefix)); + /* */ if (!(((l.flag & 7) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(((l.flag & 7) === 0))) { */ case 1: + if (!(((l.flag & 32) === 0))) { + time.Time.copy(t, $clone(t, time.Time).UTC()); + } + /* */ if (!(((l.flag & 1) === 0))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(((l.flag & 1) === 0))) { */ case 3: + _r = $clone(t, time.Time).Date(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + itoa(buf, year, 4); + buf.$set($append(buf.$get(), 47)); + itoa(buf, ((month >> 0)), 2); + buf.$set($append(buf.$get(), 47)); + itoa(buf, day, 2); + buf.$set($append(buf.$get(), 32)); + /* } */ case 4: + /* */ if (!(((l.flag & 6) === 0))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (!(((l.flag & 6) === 0))) { */ case 6: + _r$1 = $clone(t, time.Time).Clock(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + hour = _tuple$1[0]; + min = _tuple$1[1]; + sec = _tuple$1[2]; + itoa(buf, hour, 2); + buf.$set($append(buf.$get(), 58)); + itoa(buf, min, 2); + buf.$set($append(buf.$get(), 58)); + itoa(buf, sec, 2); + if (!(((l.flag & 4) === 0))) { + buf.$set($append(buf.$get(), 46)); + itoa(buf, (_q = $clone(t, time.Time).Nanosecond() / 1000, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), 6); + } + buf.$set($append(buf.$get(), 32)); + /* } */ case 7: + /* } */ case 2: + if (!(((l.flag & 24) === 0))) { + if (!(((l.flag & 16) === 0))) { + short$1 = file; + i = file.length - 1 >> 0; + while (true) { + if (!(i > 0)) { break; } + if (file.charCodeAt(i) === 47) { + short$1 = $substring(file, (i + 1 >> 0)); + break; + } + i = i - (1) >> 0; + } + file = short$1; + } + buf.$set($appendSlice(buf.$get(), file)); + buf.$set($append(buf.$get(), 58)); + itoa(buf, line, -1); + buf.$set($appendSlice(buf.$get(), ": ")); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.formatHeader }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.day = day; $f.file = file; $f.hour = hour; $f.i = i; $f.l = l; $f.line = line; $f.min = min; $f.month = month; $f.sec = sec; $f.short$1 = short$1; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.formatHeader = function(buf, t, file, line) { return this.$val.formatHeader(buf, t, file, line); }; + Logger.ptr.prototype.Output = function(calldepth, s) { + var _r, _tuple, _tuple$1, calldepth, err, file, l, line, now, ok, s, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; calldepth = $f.calldepth; err = $f.err; file = $f.file; l = $f.l; line = $f.line; now = $f.now; ok = $f.ok; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + now = $clone(time.Now(), time.Time); + file = ""; + line = 0; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + if (!(((l.flag & 24) === 0))) { + l.mu.Unlock(); + ok = false; + _tuple = runtime.Caller(calldepth); + file = _tuple[1]; + line = _tuple[2]; + ok = _tuple[3]; + if (!ok) { + file = "???"; + line = 0; + } + l.mu.Lock(); + } + l.buf = $subslice(l.buf, 0, 0); + $r = l.formatHeader((l.$ptr_buf || (l.$ptr_buf = new ptrType(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, l))), $clone(now, time.Time), file, line); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + l.buf = $appendSlice(l.buf, s); + if ((s.length === 0) || !((s.charCodeAt((s.length - 1 >> 0)) === 10))) { + l.buf = $append(l.buf, 10); + } + _r = l.out.Write(l.buf); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + err = _tuple$1[1]; + $s = -1; return err; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Output }; } $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.calldepth = calldepth; $f.err = err; $f.file = file; $f.l = l; $f.line = line; $f.now = now; $f.ok = ok; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + Logger.prototype.Output = function(calldepth, s) { return this.$val.Output(calldepth, s); }; + Logger.ptr.prototype.Printf = function(format, v) { + var _arg, _r, _r$1, format, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Printf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Printf = function(format, v) { return this.$val.Printf(format, v); }; + Logger.ptr.prototype.Print = function(v) { + var _arg, _r, _r$1, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Print }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Print = function(v) { return this.$val.Print(v); }; + Logger.ptr.prototype.Println = function(v) { + var _arg, _r, _r$1, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Println }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Println = function(v) { return this.$val.Println(v); }; + Logger.ptr.prototype.Fatal = function(v) { + var _arg, _r, _r$1, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + os.Exit(1); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatal }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Fatal = function(v) { return this.$val.Fatal(v); }; + Logger.ptr.prototype.Fatalf = function(format, v) { + var _arg, _r, _r$1, format, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + os.Exit(1); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatalf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Fatalf = function(format, v) { return this.$val.Fatalf(format, v); }; + Logger.ptr.prototype.Fatalln = function(v) { + var _arg, _r, _r$1, l, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + os.Exit(1); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatalln }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Fatalln = function(v) { return this.$val.Fatalln(v); }; + Logger.ptr.prototype.Panic = function(v) { + var _r, _r$1, l, s, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $panic(new $String(s)); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panic }; } $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Panic = function(v) { return this.$val.Panic(v); }; + Logger.ptr.prototype.Panicf = function(format, v) { + var _r, _r$1, format, l, s, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $panic(new $String(s)); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panicf }; } $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Panicf = function(format, v) { return this.$val.Panicf(format, v); }; + Logger.ptr.prototype.Panicln = function(v) { + var _r, _r$1, l, s, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $panic(new $String(s)); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panicln }; } $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Logger.prototype.Panicln = function(v) { return this.$val.Panicln(v); }; + Logger.ptr.prototype.Flags = function() { + var l, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + return l.flag; + /* */ } catch(err) { $err = err; return 0; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.Flags = function() { return this.$val.Flags(); }; + Logger.ptr.prototype.SetFlags = function(flag) { + var flag, l, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + l.flag = flag; + /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.SetFlags = function(flag) { return this.$val.SetFlags(flag); }; + Logger.ptr.prototype.Prefix = function() { + var l, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + return l.prefix; + /* */ } catch(err) { $err = err; return ""; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.Prefix = function() { return this.$val.Prefix(); }; + Logger.ptr.prototype.SetPrefix = function(prefix) { + var l, prefix, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + l.prefix = prefix; + /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.SetPrefix = function(prefix) { return this.$val.SetPrefix(prefix); }; + Logger.ptr.prototype.Writer = function() { + var l, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + l = this; + l.mu.Lock(); + $deferred.push([$methodVal(l.mu, "Unlock"), []]); + return l.out; + /* */ } catch(err) { $err = err; return $ifaceNil; } finally { $callDeferred($deferred, $err); } + }; + Logger.prototype.Writer = function() { return this.$val.Writer(); }; + Printf = function(format, v) { + var _arg, _r, _r$1, format, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = std.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Printf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Printf = Printf; + Println = function(v) { + var _arg, _r, _r$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg = _r; + _r$1 = std.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Println }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Println = Println; + ptrType$1.methods = [{prop: "SetOutput", name: "SetOutput", pkg: "", typ: $funcType([io.Writer], [], false)}, {prop: "formatHeader", name: "formatHeader", pkg: "log", typ: $funcType([ptrType, time.Time, $String, $Int], [], false)}, {prop: "Output", name: "Output", pkg: "", typ: $funcType([$Int, $String], [$error], false)}, {prop: "Printf", name: "Printf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Print", name: "Print", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Println", name: "Println", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Fatal", name: "Fatal", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Fatalf", name: "Fatalf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Fatalln", name: "Fatalln", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Panic", name: "Panic", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Panicf", name: "Panicf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Panicln", name: "Panicln", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Flags", name: "Flags", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetFlags", name: "SetFlags", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Prefix", name: "Prefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetPrefix", name: "SetPrefix", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Writer", name: "Writer", pkg: "", typ: $funcType([], [io.Writer], false)}]; + Logger.init("log", [{prop: "mu", name: "mu", embedded: false, exported: false, typ: nosync.Mutex, tag: ""}, {prop: "prefix", name: "prefix", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "flag", name: "flag", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = fmt.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + std = New(os.Stderr, "", 3); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["math/rand"] = (function() { + var $pkg = {}, $init, nosync, math, Source, Source64, Rand, lockedSource, rngSource, arrayType, ptrType, ptrType$1, sliceType, ptrType$2, ptrType$3, funcType, sliceType$1, ptrType$5, ke, we, fe, kn, wn, fn, globalRand, rngCooked, absInt32, NewSource, New, read, seedrand; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + math = $packages["math"]; + Source = $pkg.Source = $newType(8, $kindInterface, "rand.Source", true, "math/rand", true, null); + Source64 = $pkg.Source64 = $newType(8, $kindInterface, "rand.Source64", true, "math/rand", true, null); + Rand = $pkg.Rand = $newType(0, $kindStruct, "rand.Rand", true, "math/rand", true, function(src_, s64_, readVal_, readPos_) { + this.$val = this; + if (arguments.length === 0) { + this.src = $ifaceNil; + this.s64 = $ifaceNil; + this.readVal = new $Int64(0, 0); + this.readPos = 0; + return; + } + this.src = src_; + this.s64 = s64_; + this.readVal = readVal_; + this.readPos = readPos_; + }); + lockedSource = $pkg.lockedSource = $newType(0, $kindStruct, "rand.lockedSource", true, "math/rand", false, function(lk_, src_) { + this.$val = this; + if (arguments.length === 0) { + this.lk = new nosync.Mutex.ptr(false); + this.src = $ifaceNil; + return; + } + this.lk = lk_; + this.src = src_; + }); + rngSource = $pkg.rngSource = $newType(0, $kindStruct, "rand.rngSource", true, "math/rand", false, function(tap_, feed_, vec_) { + this.$val = this; + if (arguments.length === 0) { + this.tap = 0; + this.feed = 0; + this.vec = arrayType.zero(); + return; + } + this.tap = tap_; + this.feed = feed_; + this.vec = vec_; + }); + arrayType = $arrayType($Int64, 607); + ptrType = $ptrType(lockedSource); + ptrType$1 = $ptrType($Int8); + sliceType = $sliceType($Int); + ptrType$2 = $ptrType($Int64); + ptrType$3 = $ptrType(Rand); + funcType = $funcType([$Int, $Int], [], false); + sliceType$1 = $sliceType($Uint8); + ptrType$5 = $ptrType(rngSource); + Rand.ptr.prototype.ExpFloat64 = function() { + var _r, _r$1, _r$2, _r$3, i, j, r, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + /* while (true) { */ case 1: + _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + j = _r; + i = (j & 255) >>> 0; + x = (j) * (((i < 0 || i >= we.length) ? ($throwRuntimeError("index out of range"), undefined) : we[i])); + if (j < ((i < 0 || i >= ke.length) ? ($throwRuntimeError("index out of range"), undefined) : ke[i])) { + $s = -1; return x; + } + /* */ if (i === 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (i === 0) { */ case 4: + _r$1 = r.Float64(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = math.Log(_r$1); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return 7.69711747013105 - _r$2; + /* } */ case 5: + _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if ($fround(((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]) + $fround(($fround(_r$3)) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[x$1])) - ((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]))))) < ($fround(math.Exp(-x)))) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if ($fround(((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]) + $fround(($fround(_r$3)) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[x$1])) - ((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]))))) < ($fround(math.Exp(-x)))) { */ case 8: + $s = -1; return x; + /* } */ case 9: + /* } */ $s = 1; continue; case 2: + $s = -1; return 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.ExpFloat64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.ExpFloat64 = function() { return this.$val.ExpFloat64(); }; + absInt32 = function(i) { + var i; + if (i < 0) { + return ((-i >>> 0)); + } + return ((i >>> 0)); + }; + Rand.ptr.prototype.NormFloat64 = function() { + var _r, _r$1, _r$2, _r$3, _r$4, _r$5, i, j, r, x, x$1, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + /* while (true) { */ case 1: + _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + j = ((_r >> 0)); + i = j & 127; + x = (j) * (((i < 0 || i >= wn.length) ? ($throwRuntimeError("index out of range"), undefined) : wn[i])); + if (absInt32(j) < ((i < 0 || i >= kn.length) ? ($throwRuntimeError("index out of range"), undefined) : kn[i])) { + $s = -1; return x; + } + /* */ if (i === 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (i === 0) { */ case 4: + /* while (true) { */ case 6: + _r$1 = r.Float64(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = math.Log(_r$1); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = -_r$2 * 0.29047645161474317; + _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = math.Log(_r$3); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + y = -_r$4; + if (y + y >= x * x) { + /* break; */ $s = 7; continue; + } + /* } */ $s = 6; continue; case 7: + if (j > 0) { + $s = -1; return 3.442619855899 + x; + } + $s = -1; return -3.442619855899 - x; + /* } */ case 5: + _r$5 = r.Float64(); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if ($fround(((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]) + $fround(($fround(_r$5)) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[x$1])) - ((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]))))) < ($fround(math.Exp(-0.5 * x * x)))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ($fround(((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]) + $fround(($fround(_r$5)) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[x$1])) - ((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]))))) < ($fround(math.Exp(-0.5 * x * x)))) { */ case 12: + $s = -1; return x; + /* } */ case 13: + /* } */ $s = 1; continue; case 2: + $s = -1; return 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.NormFloat64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.NormFloat64 = function() { return this.$val.NormFloat64(); }; + NewSource = function(seed) { + var rng, seed; + rng = new rngSource.ptr(0, 0, arrayType.zero()); + rng.Seed(seed); + return rng; + }; + $pkg.NewSource = NewSource; + New = function(src) { + var _tuple, s64, src; + _tuple = $assertType(src, Source64, true); + s64 = _tuple[0]; + return new Rand.ptr(src, s64, new $Int64(0, 0), 0); + }; + $pkg.New = New; + Rand.ptr.prototype.Seed = function(seed) { + var _tuple, lk, ok, r, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; lk = $f.lk; ok = $f.ok; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _tuple = $assertType(r.src, ptrType, true); + lk = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + $r = lk.seedPos(seed, (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 2: + $r = r.src.Seed(seed); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + r.readPos = 0; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Seed }; } $f._tuple = _tuple; $f.lk = lk; $f.ok = ok; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; + Rand.ptr.prototype.Int63 = function() { + var _r, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63 }; } $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Int63 = function() { return this.$val.Int63(); }; + Rand.ptr.prototype.Uint32 = function() { + var _r, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (($shiftRightInt64(_r, 31).$low >>> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Uint32 }; } $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Uint32 = function() { return this.$val.Uint32(); }; + Rand.ptr.prototype.Uint64 = function() { + var _r, _r$1, _r$2, r, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; r = $f.r; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + /* */ if (!($interfaceIsEqual(r.s64, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(r.s64, $ifaceNil))) { */ case 1: + _r = r.s64.Uint64(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + _r$1 = r.Int63(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = r.Int63(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return (x = $shiftRightUint64(((x$1 = _r$1, new $Uint64(x$1.$high, x$1.$low))), 31), x$2 = $shiftLeft64(((x$3 = _r$2, new $Uint64(x$3.$high, x$3.$low))), 32), new $Uint64(x.$high | x$2.$high, (x.$low | x$2.$low) >>> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Uint64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Rand.ptr.prototype.Int31 = function() { + var _r, r, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (((x = $shiftRightInt64(_r, 32), x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31 }; } $f._r = _r; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Int31 = function() { return this.$val.Int31(); }; + Rand.ptr.prototype.Int = function() { + var _r, r, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + u = ((_r.$low >>> 0)); + $s = -1; return ((((u << 1 >>> 0) >>> 1 >>> 0) >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int }; } $f._r = _r; $f.r = r; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Int = function() { return this.$val.Int(); }; + Rand.ptr.prototype.Int63n = function(n) { + var _r, _r$1, _r$2, max, n, r, v, x, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; max = $f.max; n = $f.n; r = $f.r; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + if ((n.$high < 0 || (n.$high === 0 && n.$low <= 0))) { + $panic(new $String("invalid argument to Int63n")); + } + /* */ if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { */ case 1: + _r = r.Int63(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (x$2 = _r, x$3 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); + /* } */ case 2: + max = ((x$4 = (x$5 = $div64(new $Uint64(2147483648, 0), (new $Uint64(n.$high, n.$low)), true), new $Uint64(2147483647 - x$5.$high, 4294967295 - x$5.$low)), new $Int64(x$4.$high, x$4.$low))); + _r$1 = r.Int63(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v = _r$1; + /* while (true) { */ case 5: + /* if (!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { break; } */ if(!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { $s = 6; continue; } + _r$2 = r.Int63(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* } */ $s = 5; continue; case 6: + $s = -1; return $div64(v, n, true); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Int63n = function(n) { return this.$val.Int63n(n); }; + Rand.ptr.prototype.Int31n = function(n) { + var _r, _r$1, _r$2, _r$3, _r$4, max, n, r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; max = $f.max; n = $f.n; r = $f.r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + if (n <= 0) { + $panic(new $String("invalid argument to Int31n")); + } + /* */ if ((n & ((n - 1 >> 0))) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((n & ((n - 1 >> 0))) === 0) { */ case 1: + _r = r.Int31(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r & ((n - 1 >> 0)); + /* } */ case 2: + max = (((2147483647 - (_r$1 = 2147483648 % ((n >>> 0)), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0) >> 0)); + _r$2 = r.Int31(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* while (true) { */ case 5: + /* if (!(v > max)) { break; } */ if(!(v > max)) { $s = 6; continue; } + _r$3 = r.Int31(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + /* } */ $s = 5; continue; case 6: + $s = -1; return (_r$4 = v % n, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Int31n = function(n) { return this.$val.Int31n(n); }; + Rand.ptr.prototype.int31n = function(n) { + var _r, _r$1, _r$2, low, n, prod, r, thresh, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; low = $f.low; n = $f.n; prod = $f.prod; r = $f.r; thresh = $f.thresh; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r = r.Uint32(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + prod = $mul64((new $Uint64(0, v)), (new $Uint64(0, n))); + low = ((prod.$low >>> 0)); + /* */ if (low < ((n >>> 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (low < ((n >>> 0))) { */ case 2: + thresh = (_r$1 = ((-n >>> 0)) % ((n >>> 0)), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); + /* while (true) { */ case 4: + /* if (!(low < thresh)) { break; } */ if(!(low < thresh)) { $s = 5; continue; } + _r$2 = r.Uint32(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + prod = $mul64((new $Uint64(0, v)), (new $Uint64(0, n))); + low = ((prod.$low >>> 0)); + /* } */ $s = 4; continue; case 5: + /* } */ case 3: + $s = -1; return (($shiftRightUint64(prod, 32).$low >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.int31n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.low = low; $f.n = n; $f.prod = prod; $f.r = r; $f.thresh = thresh; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.int31n = function(n) { return this.$val.int31n(n); }; + Rand.ptr.prototype.Intn = function(n) { + var _r, _r$1, n, r, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; n = $f.n; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + if (n <= 0) { + $panic(new $String("invalid argument to Intn")); + } + /* */ if (n <= 2147483647) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (n <= 2147483647) { */ case 1: + _r = r.Int31n(((n >> 0))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return ((_r >> 0)); + /* } */ case 2: + _r$1 = r.Int63n((new $Int64(0, n))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return (((x = _r$1, x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Intn }; } $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Intn = function(n) { return this.$val.Intn(n); }; + Rand.ptr.prototype.Float64 = function() { + var _r, f, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + /* again: */ case 1: + _r = r.Int63(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + f = ($flatten64(_r)) / 9.223372036854776e+18; + /* */ if (f === 1) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (f === 1) { */ case 3: + /* goto again */ $s = 1; continue; + /* } */ case 4: + $s = -1; return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float64 }; } $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Float64 = function() { return this.$val.Float64(); }; + Rand.ptr.prototype.Float32 = function() { + var _r, f, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + /* again: */ case 1: + _r = r.Float64(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + f = ($fround(_r)); + /* */ if (f === 1) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (f === 1) { */ case 3: + /* goto again */ $s = 1; continue; + /* } */ case 4: + $s = -1; return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float32 }; } $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Float32 = function() { return this.$val.Float32(); }; + Rand.ptr.prototype.Perm = function(n) { + var _r, i, j, m, n, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; j = $f.j; m = $f.m; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + m = $makeSlice(sliceType, n); + i = 0; + /* while (true) { */ case 1: + /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } + _r = r.Intn(i + 1 >> 0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + j = _r; + ((i < 0 || i >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + i] = ((j < 0 || j >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + j])); + ((j < 0 || j >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + j] = i); + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return m; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Perm }; } $f._r = _r; $f.i = i; $f.j = j; $f.m = m; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Perm = function(n) { return this.$val.Perm(n); }; + Rand.ptr.prototype.Shuffle = function(n, swap) { + var _r, _r$1, i, j, j$1, n, r, swap, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; j = $f.j; j$1 = $f.j$1; n = $f.n; r = $f.r; swap = $f.swap; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + if (n < 0) { + $panic(new $String("invalid argument to Shuffle")); + } + i = n - 1 >> 0; + /* while (true) { */ case 1: + /* if (!(i > 2147483646)) { break; } */ if(!(i > 2147483646)) { $s = 2; continue; } + _r = r.Int63n((new $Int64(0, (i + 1 >> 0)))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + j = (((x = _r, x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + $r = swap(i, j); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i - (1) >> 0; + /* } */ $s = 1; continue; case 2: + /* while (true) { */ case 5: + /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 6; continue; } + _r$1 = r.int31n((((i + 1 >> 0) >> 0))); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + j$1 = ((_r$1 >> 0)); + $r = swap(i, j$1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i - (1) >> 0; + /* } */ $s = 5; continue; case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Shuffle }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.j = j; $f.j$1 = j$1; $f.n = n; $f.r = r; $f.swap = swap; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Shuffle = function(n, swap) { return this.$val.Shuffle(n, swap); }; + Rand.ptr.prototype.Read = function(p) { + var _r, _r$1, _tuple, _tuple$1, _tuple$2, err, lk, n, ok, p, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; lk = $f.lk; n = $f.n; ok = $f.ok; p = $f.p; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + r = this; + _tuple = $assertType(r.src, ptrType, true); + lk = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + _r = lk.read(p, (r.$ptr_readVal || (r.$ptr_readVal = new ptrType$2(function() { return this.$target.readVal; }, function($v) { this.$target.readVal = $v; }, r))), (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + n = _tuple$1[0]; + err = _tuple$1[1]; + $s = -1; return [n, err]; + /* } */ case 2: + _r$1 = read(p, $methodVal(r, "Int63"), (r.$ptr_readVal || (r.$ptr_readVal = new ptrType$2(function() { return this.$target.readVal; }, function($v) { this.$target.readVal = $v; }, r))), (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$2 = _r$1; + n = _tuple$2[0]; + err = _tuple$2[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Read }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.lk = lk; $f.n = n; $f.ok = ok; $f.p = p; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rand.prototype.Read = function(p) { return this.$val.Read(p); }; + read = function(p, int63, readVal, readPos) { + var _r, err, int63, n, p, pos, readPos, readVal, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; int63 = $f.int63; n = $f.n; p = $f.p; pos = $f.pos; readPos = $f.readPos; readVal = $f.readVal; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + pos = readPos.$get(); + val = readVal.$get(); + n = 0; + /* while (true) { */ case 1: + /* if (!(n < p.$length)) { break; } */ if(!(n < p.$length)) { $s = 2; continue; } + /* */ if (pos === 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (pos === 0) { */ case 3: + _r = int63(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + val = _r; + pos = 7; + /* } */ case 4: + ((n < 0 || n >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + n] = ((val.$low << 24 >>> 24))); + val = $shiftRightInt64(val, (8)); + pos = pos - (1) << 24 >> 24; + n = n + (1) >> 0; + /* } */ $s = 1; continue; case 2: + readPos.$set(pos); + readVal.$set(val); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: read }; } $f._r = _r; $f.err = err; $f.int63 = int63; $f.n = n; $f.p = p; $f.pos = pos; $f.readPos = readPos; $f.readVal = readVal; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.ptr.prototype.Int63 = function() { + var _r, n, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Int64(0, 0); + r = this; + r.lk.Lock(); + _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + n = _r; + r.lk.Unlock(); + $s = -1; return n; + /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Int63 }; } $f._r = _r; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.prototype.Int63 = function() { return this.$val.Int63(); }; + lockedSource.ptr.prototype.Uint64 = function() { + var _r, n, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = new $Uint64(0, 0); + r = this; + r.lk.Lock(); + _r = r.src.Uint64(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + n = _r; + r.lk.Unlock(); + $s = -1; return n; + /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Uint64 }; } $f._r = _r; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.prototype.Uint64 = function() { return this.$val.Uint64(); }; + lockedSource.ptr.prototype.Seed = function(seed) { + var r, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + r.lk.Lock(); + $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + r.lk.Unlock(); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Seed }; } $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; + lockedSource.ptr.prototype.seedPos = function(seed, readPos) { + var r, readPos, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; readPos = $f.readPos; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + r.lk.Lock(); + $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + readPos.$set(0); + r.lk.Unlock(); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.seedPos }; } $f.r = r; $f.readPos = readPos; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.prototype.seedPos = function(seed, readPos) { return this.$val.seedPos(seed, readPos); }; + lockedSource.ptr.prototype.read = function(p, readVal, readPos) { + var _r, _tuple, err, n, p, r, readPos, readVal, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; n = $f.n; p = $f.p; r = $f.r; readPos = $f.readPos; readVal = $f.readVal; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + r = this; + r.lk.Lock(); + _r = read(p, $methodVal(r.src, "Int63"), readVal, readPos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + r.lk.Unlock(); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.read }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.n = n; $f.p = p; $f.r = r; $f.readPos = readPos; $f.readVal = readVal; $f.$s = $s; $f.$r = $r; return $f; + }; + lockedSource.prototype.read = function(p, readVal, readPos) { return this.$val.read(p, readVal, readPos); }; + seedrand = function(x) { + var _q, _r, hi, lo, x; + hi = (_q = x / 44488, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + lo = (_r = x % 44488, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); + x = ($imul(48271, lo)) - ($imul(3399, hi)) >> 0; + if (x < 0) { + x = x + (2147483647) >> 0; + } + return x; + }; + rngSource.ptr.prototype.Seed = function(seed) { + var i, rng, seed, u, x, x$1, x$2, x$3, x$4, x$5; + rng = this; + rng.tap = 0; + rng.feed = 334; + seed = $div64(seed, new $Int64(0, 2147483647), true); + if ((seed.$high < 0 || (seed.$high === 0 && seed.$low < 0))) { + seed = (x = new $Int64(0, 2147483647), new $Int64(seed.$high + x.$high, seed.$low + x.$low)); + } + if ((seed.$high === 0 && seed.$low === 0)) { + seed = new $Int64(0, 89482311); + } + x$1 = (((seed.$low + ((seed.$high >> 31) * 4294967296)) >> 0)); + i = -20; + while (true) { + if (!(i < 607)) { break; } + x$1 = seedrand(x$1); + if (i >= 0) { + u = new $Int64(0, 0); + u = $shiftLeft64((new $Int64(0, x$1)), 40); + x$1 = seedrand(x$1); + u = (x$2 = $shiftLeft64((new $Int64(0, x$1)), 20), new $Int64(u.$high ^ x$2.$high, (u.$low ^ x$2.$low) >>> 0)); + x$1 = seedrand(x$1); + u = (x$3 = (new $Int64(0, x$1)), new $Int64(u.$high ^ x$3.$high, (u.$low ^ x$3.$low) >>> 0)); + u = (x$4 = ((i < 0 || i >= rngCooked.length) ? ($throwRuntimeError("index out of range"), undefined) : rngCooked[i]), new $Int64(u.$high ^ x$4.$high, (u.$low ^ x$4.$low) >>> 0)); + (x$5 = rng.vec, ((i < 0 || i >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i] = u)); + } + i = i + (1) >> 0; + } + }; + rngSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; + rngSource.ptr.prototype.Int63 = function() { + var rng, x, x$1; + rng = this; + return ((x = (x$1 = rng.Uint64(), new $Uint64(x$1.$high & 2147483647, (x$1.$low & 4294967295) >>> 0)), new $Int64(x.$high, x.$low))); + }; + rngSource.prototype.Int63 = function() { return this.$val.Int63(); }; + rngSource.ptr.prototype.Uint64 = function() { + var rng, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; + rng = this; + rng.tap = rng.tap - (1) >> 0; + if (rng.tap < 0) { + rng.tap = rng.tap + (607) >> 0; + } + rng.feed = rng.feed - (1) >> 0; + if (rng.feed < 0) { + rng.feed = rng.feed + (607) >> 0; + } + x$6 = (x = (x$1 = rng.vec, x$2 = rng.feed, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2])), x$3 = (x$4 = rng.vec, x$5 = rng.tap, ((x$5 < 0 || x$5 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[x$5])), new $Int64(x.$high + x$3.$high, x.$low + x$3.$low)); + (x$7 = rng.vec, x$8 = rng.feed, ((x$8 < 0 || x$8 >= x$7.length) ? ($throwRuntimeError("index out of range"), undefined) : x$7[x$8] = x$6)); + return (new $Uint64(x$6.$high, x$6.$low)); + }; + rngSource.prototype.Uint64 = function() { return this.$val.Uint64(); }; + ptrType$3.methods = [{prop: "ExpFloat64", name: "ExpFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "NormFloat64", name: "NormFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([], [$Uint32], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Int31", name: "Int31", pkg: "", typ: $funcType([], [$Int32], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int63n", name: "Int63n", pkg: "", typ: $funcType([$Int64], [$Int64], false)}, {prop: "Int31n", name: "Int31n", pkg: "", typ: $funcType([$Int32], [$Int32], false)}, {prop: "int31n", name: "int31n", pkg: "math/rand", typ: $funcType([$Int32], [$Int32], false)}, {prop: "Intn", name: "Intn", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([$Int], [sliceType], false)}, {prop: "Shuffle", name: "Shuffle", pkg: "", typ: $funcType([$Int, funcType], [], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}]; + ptrType.methods = [{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "seedPos", name: "seedPos", pkg: "math/rand", typ: $funcType([$Int64, ptrType$1], [], false)}, {prop: "read", name: "read", pkg: "math/rand", typ: $funcType([sliceType$1, ptrType$2, ptrType$1], [$Int, $error], false)}]; + ptrType$5.methods = [{prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}]; + Source.init([{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}]); + Source64.init([{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}]); + Rand.init("math/rand", [{prop: "src", name: "src", embedded: false, exported: false, typ: Source, tag: ""}, {prop: "s64", name: "s64", embedded: false, exported: false, typ: Source64, tag: ""}, {prop: "readVal", name: "readVal", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "readPos", name: "readPos", embedded: false, exported: false, typ: $Int8, tag: ""}]); + lockedSource.init("math/rand", [{prop: "lk", name: "lk", embedded: false, exported: false, typ: nosync.Mutex, tag: ""}, {prop: "src", name: "src", embedded: false, exported: false, typ: Source64, tag: ""}]); + rngSource.init("math/rand", [{prop: "tap", name: "tap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "feed", name: "feed", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "vec", name: "vec", embedded: false, exported: false, typ: arrayType, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = nosync.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ke = $toNativeArray($kindUint32, [3801129273, 0, 2615860924, 3279400049, 3571300752, 3733536696, 3836274812, 3906990442, 3958562475, 3997804264, 4028649213, 4053523342, 4074002619, 4091154507, 4105727352, 4118261130, 4129155133, 4138710916, 4147160435, 4154685009, 4161428406, 4167506077, 4173011791, 4178022498, 4182601930, 4186803325, 4190671498, 4194244443, 4197554582, 4200629752, 4203493986, 4206168142, 4208670408, 4211016720, 4213221098, 4215295924, 4217252177, 4219099625, 4220846988, 4222502074, 4224071896, 4225562770, 4226980400, 4228329951, 4229616109, 4230843138, 4232014925, 4233135020, 4234206673, 4235232866, 4236216336, 4237159604, 4238064994, 4238934652, 4239770563, 4240574564, 4241348362, 4242093539, 4242811568, 4243503822, 4244171579, 4244816032, 4245438297, 4246039419, 4246620374, 4247182079, 4247725394, 4248251127, 4248760037, 4249252839, 4249730206, 4250192773, 4250641138, 4251075867, 4251497493, 4251906522, 4252303431, 4252688672, 4253062674, 4253425844, 4253778565, 4254121205, 4254454110, 4254777611, 4255092022, 4255397640, 4255694750, 4255983622, 4256264513, 4256537670, 4256803325, 4257061702, 4257313014, 4257557464, 4257795244, 4258026541, 4258251531, 4258470383, 4258683258, 4258890309, 4259091685, 4259287526, 4259477966, 4259663135, 4259843154, 4260018142, 4260188212, 4260353470, 4260514019, 4260669958, 4260821380, 4260968374, 4261111028, 4261249421, 4261383632, 4261513736, 4261639802, 4261761900, 4261880092, 4261994441, 4262105003, 4262211835, 4262314988, 4262414513, 4262510454, 4262602857, 4262691764, 4262777212, 4262859239, 4262937878, 4263013162, 4263085118, 4263153776, 4263219158, 4263281289, 4263340187, 4263395872, 4263448358, 4263497660, 4263543789, 4263586755, 4263626565, 4263663224, 4263696735, 4263727099, 4263754314, 4263778377, 4263799282, 4263817020, 4263831582, 4263842955, 4263851124, 4263856071, 4263857776, 4263856218, 4263851370, 4263843206, 4263831695, 4263816804, 4263798497, 4263776735, 4263751476, 4263722676, 4263690284, 4263654251, 4263614520, 4263571032, 4263523724, 4263472530, 4263417377, 4263358192, 4263294892, 4263227394, 4263155608, 4263079437, 4262998781, 4262913534, 4262823581, 4262728804, 4262629075, 4262524261, 4262414220, 4262298801, 4262177846, 4262051187, 4261918645, 4261780032, 4261635148, 4261483780, 4261325704, 4261160681, 4260988457, 4260808763, 4260621313, 4260425802, 4260221905, 4260009277, 4259787550, 4259556329, 4259315195, 4259063697, 4258801357, 4258527656, 4258242044, 4257943926, 4257632664, 4257307571, 4256967906, 4256612870, 4256241598, 4255853155, 4255446525, 4255020608, 4254574202, 4254106002, 4253614578, 4253098370, 4252555662, 4251984571, 4251383021, 4250748722, 4250079132, 4249371435, 4248622490, 4247828790, 4246986404, 4246090910, 4245137315, 4244119963, 4243032411, 4241867296, 4240616155, 4239269214, 4237815118, 4236240596, 4234530035, 4232664930, 4230623176, 4228378137, 4225897409, 4223141146, 4220059768, 4216590757, 4212654085, 4208145538, 4202926710, 4196809522, 4189531420, 4180713890, 4169789475, 4155865042, 4137444620, 4111806704, 4073393724, 4008685917, 3873074895]); + we = $toNativeArray($kindFloat32, [2.0249555365836613e-09, 1.4866739783681027e-11, 2.4409616689036184e-11, 3.1968806074589295e-11, 3.844677007314168e-11, 4.42282044321729e-11, 4.951644302919611e-11, 5.443358958023836e-11, 5.905943789574764e-11, 6.34494193296753e-11, 6.764381416113352e-11, 7.167294535648239e-11, 7.556032188826833e-11, 7.932458162551725e-11, 8.298078890689453e-11, 8.654132271912474e-11, 9.001651507523079e-11, 9.341507428706208e-11, 9.674443190998971e-11, 1.0001099254308699e-10, 1.0322031424037093e-10, 1.0637725422757427e-10, 1.0948611461891744e-10, 1.1255067711157807e-10, 1.1557434870246297e-10, 1.1856014781042035e-10, 1.2151082917633005e-10, 1.2442885610752796e-10, 1.2731647680563896e-10, 1.3017574518325858e-10, 1.330085347417409e-10, 1.3581656632677408e-10, 1.386014220061682e-10, 1.413645728254309e-10, 1.4410737880776736e-10, 1.4683107507629245e-10, 1.4953686899854546e-10, 1.522258291641876e-10, 1.5489899640730442e-10, 1.575573282952547e-10, 1.6020171300645814e-10, 1.628330109637588e-10, 1.6545202707884954e-10, 1.68059510752272e-10, 1.7065616975120435e-10, 1.73242697965037e-10, 1.758197337720091e-10, 1.783878739169964e-10, 1.8094774290045024e-10, 1.834998542005195e-10, 1.8604476292871652e-10, 1.8858298256319017e-10, 1.9111498494872592e-10, 1.9364125580789704e-10, 1.9616222535212557e-10, 1.9867835154840918e-10, 2.011900368525943e-10, 2.0369768372052732e-10, 2.062016807302669e-10, 2.0870240258208383e-10, 2.1120022397624894e-10, 2.136955057352452e-10, 2.1618855317040442e-10, 2.1867974098199738e-10, 2.2116936060356807e-10, 2.2365774510202385e-10, 2.2614519978869652e-10, 2.2863201609713002e-10, 2.3111849933865614e-10, 2.3360494094681883e-10, 2.3609159072179864e-10, 2.3857874009713953e-10, 2.4106666662859766e-10, 2.4355562011635357e-10, 2.460458781161634e-10, 2.485376904282077e-10, 2.5103127909709144e-10, 2.5352694943414633e-10, 2.560248957284017e-10, 2.585253955356137e-10, 2.610286709003873e-10, 2.6353494386732734e-10, 2.6604446423661443e-10, 2.6855745405285347e-10, 2.71074163116225e-10, 2.7359478571575835e-10, 2.7611959940720965e-10, 2.786487707240326e-10, 2.8118254946640775e-10, 2.8372118543451563e-10, 2.8626484516180994e-10, 2.8881380620404684e-10, 2.9136826285025563e-10, 2.9392840938946563e-10, 2.96494523377433e-10, 2.990667713476114e-10, 3.016454031001814e-10, 3.042306406797479e-10, 3.068226783753403e-10, 3.09421765987139e-10, 3.12028125559749e-10, 3.1464195138219964e-10, 3.17263521010247e-10, 3.1989300097734485e-10, 3.225306410836737e-10, 3.2517669112941405e-10, 3.2783134540359526e-10, 3.3049485370639786e-10, 3.3316743808242677e-10, 3.3584937608743815e-10, 3.385408342548857e-10, 3.4124211789610115e-10, 3.4395342130011386e-10, 3.4667499426710435e-10, 3.494071143528288e-10, 3.521500313574677e-10, 3.54903967325626e-10, 3.576691720574843e-10, 3.6044595086437425e-10, 3.632345535464765e-10, 3.660352021483959e-10, 3.688482297370399e-10, 3.716738583570134e-10, 3.7451239331964814e-10, 3.773641121807003e-10, 3.802292924959261e-10, 3.831082673322328e-10, 3.8600128648980103e-10, 3.8890865527996255e-10, 3.9183070676962473e-10, 3.9476774627011935e-10, 3.977200790927782e-10, 4.006880383045086e-10, 4.0367195697221803e-10, 4.066721681628138e-10, 4.0968900494320337e-10, 4.127228558914453e-10, 4.15774054074447e-10, 4.188429603146915e-10, 4.2192993543466173e-10, 4.25035395767992e-10, 4.2815970213716525e-10, 4.313032986313914e-10, 4.3446651831757777e-10, 4.376498607960855e-10, 4.408536868893975e-10, 4.4407846844229937e-10, 4.4732464954400086e-10, 4.5059267428371186e-10, 4.538830145062178e-10, 4.5719619756745544e-10, 4.605326675566346e-10, 4.638929240741163e-10, 4.672775499869886e-10, 4.706869893844612e-10, 4.74121908400349e-10, 4.775827511238617e-10, 4.810701836888143e-10, 4.845848167178701e-10, 4.881271498113904e-10, 4.916979601254923e-10, 4.952977472605369e-10, 4.989272883726414e-10, 5.025872495956207e-10, 5.062783525744408e-10, 5.100013189540675e-10, 5.13756870379467e-10, 5.175458395179078e-10, 5.21369003525507e-10, 5.252272505806843e-10, 5.29121357839557e-10, 5.330522134805449e-10, 5.3702081670437e-10, 5.41028055689452e-10, 5.450749851476644e-10, 5.491624932574268e-10, 5.532918012640664e-10, 5.574638528571541e-10, 5.616799247931681e-10, 5.659410717839819e-10, 5.702485705860738e-10, 5.746036979559221e-10, 5.790077306500052e-10, 5.83462111958255e-10, 5.879682296594524e-10, 5.925275825546805e-10, 5.971417249561739e-10, 6.01812211176167e-10, 6.065408175714992e-10, 6.113292094767075e-10, 6.16179329782085e-10, 6.21092954844471e-10, 6.260721940876124e-10, 6.311191569352559e-10, 6.362359528111483e-10, 6.414249686947926e-10, 6.466885360545405e-10, 6.520292639144998e-10, 6.574497612987784e-10, 6.629528592760892e-10, 6.685415554485985e-10, 6.742187919073217e-10, 6.799880103436351e-10, 6.858525969377638e-10, 6.918161599145378e-10, 6.978825850545434e-10, 7.040559801829716e-10, 7.103406751696184e-10, 7.167412219288849e-10, 7.232625609532306e-10, 7.2990985477972e-10, 7.366885990123251e-10, 7.436047333442275e-10, 7.506645305355164e-10, 7.57874762946642e-10, 7.652426470272644e-10, 7.727759543385559e-10, 7.804830115532013e-10, 7.883728114777e-10, 7.964550685635174e-10, 8.047402189070851e-10, 8.132396422944055e-10, 8.219657177122031e-10, 8.309318788590758e-10, 8.401527806789488e-10, 8.496445214056791e-10, 8.594246980742071e-10, 8.695127395874636e-10, 8.799300732498239e-10, 8.90700457834015e-10, 9.01850316648023e-10, 9.134091816243028e-10, 9.254100818978372e-10, 9.37890431984556e-10, 9.508922538259412e-10, 9.64463842123564e-10, 9.78660263939446e-10, 9.935448019859905e-10, 1.0091912860943353e-09, 1.0256859805934937e-09, 1.0431305819125214e-09, 1.0616465484503124e-09, 1.0813799855569073e-09, 1.1025096391392708e-09, 1.1252564435793033e-09, 1.149898620766976e-09, 1.176793218427008e-09, 1.2064089727203964e-09, 1.2393785997488749e-09, 1.2765849488616254e-09, 1.319313880365769e-09, 1.36954347862428e-09, 1.4305497897382224e-09, 1.5083649884672923e-09, 1.6160853766322703e-09, 1.7921247819074893e-09]); + fe = $toNativeArray($kindFloat32, [1, 0.9381436705589294, 0.900469958782196, 0.8717043399810791, 0.847785472869873, 0.8269932866096497, 0.8084216713905334, 0.7915276288986206, 0.7759568691253662, 0.7614634037017822, 0.7478685975074768, 0.7350381016731262, 0.7228676676750183, 0.7112747430801392, 0.7001926302909851, 0.6895664930343628, 0.6793505549430847, 0.669506311416626, 0.6600008606910706, 0.6508058309555054, 0.6418967247009277, 0.633251965045929, 0.62485271692276, 0.6166821718215942, 0.608725368976593, 0.6009689569473267, 0.5934008955955505, 0.5860103368759155, 0.5787873864173889, 0.5717230439186096, 0.5648092031478882, 0.5580382943153381, 0.5514034032821655, 0.5448982119560242, 0.5385168790817261, 0.5322538614273071, 0.526104211807251, 0.5200631618499756, 0.5141264200210571, 0.5082897543907166, 0.5025495290756226, 0.4969019889831543, 0.4913438558578491, 0.4858720004558563, 0.48048335313796997, 0.4751752018928528, 0.4699448347091675, 0.4647897481918335, 0.4597076177597046, 0.4546961486339569, 0.4497532546520233, 0.44487687945365906, 0.4400651156902313, 0.4353161156177521, 0.4306281507015228, 0.42599955201148987, 0.42142874002456665, 0.4169141948223114, 0.4124544560909271, 0.40804818272590637, 0.4036940038204193, 0.39939069747924805, 0.3951369822025299, 0.39093172550201416, 0.38677382469177246, 0.38266217708587646, 0.378595769405365, 0.37457355856895447, 0.37059465050697327, 0.366658091545105, 0.362762987613678, 0.358908474445343, 0.35509374737739563, 0.35131800174713135, 0.3475804924964905, 0.34388044476509094, 0.34021714329719543, 0.33658990263938904, 0.3329980671405792, 0.3294409513473511, 0.32591795921325684, 0.32242849469184875, 0.3189719021320343, 0.3155476748943329, 0.31215524673461914, 0.3087940812110901, 0.30546361207962036, 0.30216339230537415, 0.29889291524887085, 0.29565170407295227, 0.2924392819404602, 0.2892552316188812, 0.28609907627105713, 0.2829704284667969, 0.27986884117126465, 0.2767939269542694, 0.2737452983856201, 0.2707225978374481, 0.26772540807724, 0.26475343108177185, 0.2618062496185303, 0.258883535861969, 0.2559850215911865, 0.25311028957366943, 0.25025907158851624, 0.24743106961250305, 0.2446259707212448, 0.24184346199035645, 0.23908329010009766, 0.23634515702724457, 0.2336287796497345, 0.23093391954898834, 0.22826029360294342, 0.22560766339302063, 0.22297576069831848, 0.22036437690258026, 0.21777324378490448, 0.21520215272903442, 0.212650865316391, 0.21011915802955627, 0.20760682225227356, 0.20511364936828613, 0.20263944566249847, 0.20018397271633148, 0.19774706661701202, 0.1953285187482834, 0.19292815029621124, 0.19054576754570007, 0.18818120658397675, 0.18583425879478455, 0.18350479006767273, 0.18119260668754578, 0.17889754474163055, 0.17661945521831512, 0.17435817420482635, 0.1721135377883911, 0.16988539695739746, 0.16767361760139465, 0.16547803580760956, 0.16329853236675262, 0.16113494336605072, 0.1589871346950531, 0.15685498714447021, 0.15473836660385132, 0.15263713896274567, 0.1505511850118637, 0.1484803706407547, 0.14642459154129028, 0.1443837285041809, 0.14235764741897583, 0.1403462439775467, 0.13834942877292633, 0.136367067694664, 0.13439907133579254, 0.1324453204870224, 0.1305057406425476, 0.12858019769191742, 0.12666863203048706, 0.12477091699838638, 0.12288697808980942, 0.1210167184472084, 0.11916005611419678, 0.11731690168380737, 0.11548716574907303, 0.11367076635360718, 0.11186762899160385, 0.11007767915725708, 0.1083008274435997, 0.10653700679540634, 0.10478614270687103, 0.1030481606721878, 0.10132300108671188, 0.0996105819940567, 0.09791085124015808, 0.09622374176979065, 0.09454918652772903, 0.09288713335990906, 0.09123751521110535, 0.08960027992725372, 0.08797537535429001, 0.08636274188756943, 0.0847623273730278, 0.08317409455776215, 0.08159798383712769, 0.08003395050764084, 0.07848194986581802, 0.07694194465875626, 0.07541389018297195, 0.07389774918556213, 0.07239348441362381, 0.070901058614254, 0.06942043453454971, 0.06795158982276917, 0.06649449467658997, 0.06504911929368973, 0.06361543387174606, 0.06219341605901718, 0.06078304722905159, 0.0593843050301075, 0.05799717456102371, 0.05662164092063904, 0.05525768920779228, 0.05390531197190285, 0.05256449431180954, 0.05123523622751236, 0.04991753399372101, 0.04861138388514519, 0.047316793352365494, 0.04603376239538193, 0.044762298464775085, 0.04350241273641586, 0.04225412383675575, 0.04101744294166565, 0.039792392402887344, 0.03857899457216263, 0.03737728297710419, 0.03618728369474411, 0.03500903770327568, 0.03384258225560188, 0.0326879620552063, 0.031545232981443405, 0.030414443463087082, 0.0292956605553627, 0.028188949450850487, 0.027094384655356407, 0.02601204626262188, 0.024942025542259216, 0.023884421214461327, 0.022839335724711418, 0.021806888282299042, 0.020787203684449196, 0.019780423492193222, 0.018786700442433357, 0.017806200310587883, 0.016839107498526573, 0.015885621309280396, 0.014945968054234982, 0.01402039173990488, 0.013109165243804455, 0.012212592177093029, 0.011331013403832912, 0.010464809834957123, 0.009614413604140282, 0.008780314587056637, 0.007963077165186405, 0.007163353264331818, 0.0063819061033427715, 0.005619642324745655, 0.004877655766904354, 0.004157294984906912, 0.003460264764726162, 0.0027887988835573196, 0.0021459676790982485, 0.001536299823783338, 0.0009672692976891994, 0.0004541343660093844]); + kn = $toNativeArray($kindUint32, [1991057938, 0, 1611602771, 1826899878, 1918584482, 1969227037, 2001281515, 2023368125, 2039498179, 2051788381, 2061460127, 2069267110, 2075699398, 2081089314, 2085670119, 2089610331, 2093034710, 2096037586, 2098691595, 2101053571, 2103168620, 2105072996, 2106796166, 2108362327, 2109791536, 2111100552, 2112303493, 2113412330, 2114437283, 2115387130, 2116269447, 2117090813, 2117856962, 2118572919, 2119243101, 2119871411, 2120461303, 2121015852, 2121537798, 2122029592, 2122493434, 2122931299, 2123344971, 2123736059, 2124106020, 2124456175, 2124787725, 2125101763, 2125399283, 2125681194, 2125948325, 2126201433, 2126441213, 2126668298, 2126883268, 2127086657, 2127278949, 2127460589, 2127631985, 2127793506, 2127945490, 2128088244, 2128222044, 2128347141, 2128463758, 2128572095, 2128672327, 2128764606, 2128849065, 2128925811, 2128994934, 2129056501, 2129110560, 2129157136, 2129196237, 2129227847, 2129251929, 2129268426, 2129277255, 2129278312, 2129271467, 2129256561, 2129233410, 2129201800, 2129161480, 2129112170, 2129053545, 2128985244, 2128906855, 2128817916, 2128717911, 2128606255, 2128482298, 2128345305, 2128194452, 2128028813, 2127847342, 2127648860, 2127432031, 2127195339, 2126937058, 2126655214, 2126347546, 2126011445, 2125643893, 2125241376, 2124799783, 2124314271, 2123779094, 2123187386, 2122530867, 2121799464, 2120980787, 2120059418, 2119015917, 2117825402, 2116455471, 2114863093, 2112989789, 2110753906, 2108037662, 2104664315, 2100355223, 2094642347, 2086670106, 2074676188, 2054300022, 2010539237]); + wn = $toNativeArray($kindFloat32, [1.7290404663583558e-09, 1.2680928529462676e-10, 1.689751810696194e-10, 1.9862687883343e-10, 2.223243117382978e-10, 2.4244936613904144e-10, 2.601613091623989e-10, 2.761198769629658e-10, 2.9073962681813725e-10, 3.042996965518796e-10, 3.169979556627567e-10, 3.289802041894774e-10, 3.4035738116777736e-10, 3.5121602848242617e-10, 3.61625090983253e-10, 3.7164057942185025e-10, 3.813085680537398e-10, 3.906675816178762e-10, 3.997501218933053e-10, 4.0858399996679395e-10, 4.1719308563337165e-10, 4.255982233303257e-10, 4.3381759295968436e-10, 4.4186720948857783e-10, 4.497613115272969e-10, 4.57512583373898e-10, 4.6513240481438345e-10, 4.726310454117311e-10, 4.800177477726209e-10, 4.873009773476156e-10, 4.944885056978876e-10, 5.015873272284921e-10, 5.086040477664255e-10, 5.155446070048697e-10, 5.224146670812502e-10, 5.292193350214802e-10, 5.359634958068682e-10, 5.426517013518151e-10, 5.492881705038144e-10, 5.558769555769061e-10, 5.624218868405251e-10, 5.689264614971989e-10, 5.75394121238304e-10, 5.818281967329142e-10, 5.882316855831959e-10, 5.946076964136182e-10, 6.009590047817426e-10, 6.072883862451306e-10, 6.135985053390414e-10, 6.19892026598734e-10, 6.261713370037114e-10, 6.324390455780815e-10, 6.386973727678935e-10, 6.449488165749528e-10, 6.511955974453087e-10, 6.574400468473129e-10, 6.636843297158634e-10, 6.699307220081607e-10, 6.761814441702541e-10, 6.824387166481927e-10, 6.887046488657234e-10, 6.949815167800466e-10, 7.012714853260604e-10, 7.075767749498141e-10, 7.13899661608508e-10, 7.202424212593428e-10, 7.266072743483676e-10, 7.329966078550854e-10, 7.394128087589991e-10, 7.458582640396116e-10, 7.523354716987285e-10, 7.588469852493063e-10, 7.653954137154528e-10, 7.719834771435785e-10, 7.786139510912449e-10, 7.852897221383159e-10, 7.920137878869582e-10, 7.987892014504894e-10, 8.056192379868321e-10, 8.125072836762115e-10, 8.194568912323064e-10, 8.264716688799467e-10, 8.3355555791087e-10, 8.407127216614185e-10, 8.479473234679347e-10, 8.552640262671218e-10, 8.626675485068347e-10, 8.701631637464402e-10, 8.777562010564566e-10, 8.854524335966119e-10, 8.932581896381464e-10, 9.011799639857543e-10, 9.092249730890956e-10, 9.174008219758889e-10, 9.25715837318819e-10, 9.341788453909317e-10, 9.42799727177146e-10, 9.515889187738935e-10, 9.605578554783278e-10, 9.697193048552322e-10, 9.790869226478094e-10, 9.886760299337993e-10, 9.985036131254788e-10, 1.008588212947359e-09, 1.0189509236369076e-09, 1.0296150598776421e-09, 1.040606933955246e-09, 1.0519566329136865e-09, 1.0636980185552147e-09, 1.0758701707302976e-09, 1.0885182755160372e-09, 1.101694735439196e-09, 1.115461056855338e-09, 1.1298901814171813e-09, 1.1450695946990663e-09, 1.1611052119775422e-09, 1.178127595480305e-09, 1.1962995039027646e-09, 1.2158286599728285e-09, 1.2369856250415978e-09, 1.2601323318151003e-09, 1.2857697129220469e-09, 1.3146201904845611e-09, 1.3477839955200466e-09, 1.3870635751089821e-09, 1.43574030442295e-09, 1.5008658760251592e-09, 1.6030947680434338e-09]); + fn = $toNativeArray($kindFloat32, [1, 0.963599681854248, 0.9362826943397522, 0.9130436182022095, 0.8922816514968872, 0.8732430338859558, 0.8555005788803101, 0.8387836217880249, 0.8229072093963623, 0.8077383041381836, 0.7931770086288452, 0.7791460752487183, 0.7655841708183289, 0.7524415850639343, 0.7396772503852844, 0.7272568941116333, 0.7151514887809753, 0.7033361196517944, 0.6917891502380371, 0.6804918646812439, 0.6694276928901672, 0.6585819721221924, 0.6479418277740479, 0.6374954581260681, 0.6272324919700623, 0.6171433925628662, 0.6072195172309875, 0.5974531769752502, 0.5878370404243469, 0.5783646702766418, 0.5690299868583679, 0.5598273873329163, 0.550751805305481, 0.5417983531951904, 0.5329626798629761, 0.5242405533790588, 0.5156282186508179, 0.5071220397949219, 0.49871864914894104, 0.4904148280620575, 0.48220765590667725, 0.47409430146217346, 0.466072142124176, 0.45813870429992676, 0.45029163360595703, 0.44252872467041016, 0.4348478317260742, 0.42724698781967163, 0.41972434520721436, 0.41227802634239197, 0.40490642189979553, 0.39760786294937134, 0.3903807997703552, 0.3832238018512726, 0.3761354684829712, 0.3691144585609436, 0.36215949058532715, 0.3552693724632263, 0.3484429717063904, 0.3416791558265686, 0.33497685194015503, 0.32833510637283325, 0.3217529058456421, 0.3152293860912323, 0.30876362323760986, 0.3023548424243927, 0.2960021495819092, 0.2897048592567444, 0.28346219658851624, 0.2772735059261322, 0.271138072013855, 0.2650552988052368, 0.25902456045150757, 0.25304529070854187, 0.24711695313453674, 0.24123899638652802, 0.23541094362735748, 0.22963231801986694, 0.22390270233154297, 0.21822164952754974, 0.21258877217769623, 0.20700371265411377, 0.20146611332893372, 0.1959756463766098, 0.19053204357624054, 0.18513499200344086, 0.17978426814079285, 0.1744796335697174, 0.16922089457511902, 0.16400785744190216, 0.1588403731584549, 0.15371830761432648, 0.14864157140254974, 0.14361007511615753, 0.13862377405166626, 0.13368265330791473, 0.12878671288490295, 0.12393598258495331, 0.11913054436445236, 0.11437050998210907, 0.10965602099895477, 0.1049872562289238, 0.10036443918943405, 0.09578784555196762, 0.09125780314207077, 0.08677466958761215, 0.08233889937400818, 0.07795098423957825, 0.07361150532960892, 0.06932111829519272, 0.06508058309555054, 0.06089077144861221, 0.05675266310572624, 0.05266740173101425, 0.048636294901371, 0.044660862535238266, 0.040742866694927216, 0.03688438981771469, 0.03308788686990738, 0.029356317594647408, 0.025693291798233986, 0.02210330404341221, 0.018592102453112602, 0.015167297795414925, 0.011839478276669979, 0.0086244847625494, 0.005548994988203049, 0.0026696291752159595]); + rngCooked = $toNativeArray($kindInt64, [new $Int64(-973649357, 3952672746), new $Int64(-1065661887, 3130416987), new $Int64(324977939, 3414273807), new $Int64(1241840476, 2806224363), new $Int64(-1477934308, 1997590414), new $Int64(2103305448, 2402795971), new $Int64(1663160183, 1140819369), new $Int64(1120601685, 1788868961), new $Int64(1848035537, 1089001426), new $Int64(1235702047, 873593504), new $Int64(1911387977, 581324885), new $Int64(-1654874170, 1609182556), new $Int64(1069394745, 1241596776), new $Int64(1895445337, 1771189259), new $Int64(-1374618802, 3467012610), new $Int64(-140526423, 2344407434), new $Int64(-1745367887, 782467244), new $Int64(26335124, 3404933915), new $Int64(1063924276, 618867887), new $Int64(-968700782, 520164395), new $Int64(-1591572833, 1341358184), new $Int64(-1515085039, 665794848), new $Int64(1527227641, 3183648150), new $Int64(1781176124, 696329606), new $Int64(1789146075, 4151988961), new $Int64(-2087444114, 998951326), new $Int64(-612324923, 1364957564), new $Int64(63173359, 4090230633), new $Int64(-1498029007, 4009697548), new $Int64(248009524, 2569622517), new $Int64(778703922, 3742421481), new $Int64(-1109106023, 1506914633), new $Int64(1738099768, 1983412561), new $Int64(236311649, 1436266083), new $Int64(-1111517500, 3922894967), new $Int64(-1336974714, 1792680179), new $Int64(563141142, 1188796351), new $Int64(1349617468, 405968250), new $Int64(1044074554, 433754187), new $Int64(870549669, 4073162024), new $Int64(-1094251604, 433121399), new $Int64(2451824, 4162580594), new $Int64(-137262572, 4132415622), new $Int64(-1536231048, 3033822028), new $Int64(2016407895, 824682382), new $Int64(2366218, 3583765414), new $Int64(-624604839, 535386927), new $Int64(1637219058, 2286693689), new $Int64(1453075389, 2968466525), new $Int64(193683513, 1351410206), new $Int64(-283806096, 1412813499), new $Int64(492736522, 4126267639), new $Int64(512765208, 2105529399), new $Int64(2132966268, 2413882233), new $Int64(947457634, 32226200), new $Int64(1149341356, 2032329073), new $Int64(106485445, 1356518208), new $Int64(-2067810156, 3430061722), new $Int64(-1484435135, 3820169661), new $Int64(-1665985194, 2981816134), new $Int64(1017155588, 4184371017), new $Int64(206574701, 2119206761), new $Int64(-852109057, 2472200560), new $Int64(-560457548, 2853524696), new $Int64(1307803389, 1681119904), new $Int64(-174986835, 95608918), new $Int64(392686347, 3690479145), new $Int64(-1205570926, 1397922290), new $Int64(-1159314025, 1516129515), new $Int64(-320178155, 1547420459), new $Int64(1311333971, 1470949486), new $Int64(-1953469798, 1336785672), new $Int64(-45086614, 4131677129), new $Int64(-1392278100, 4246329084), new $Int64(-1142500187, 3788585631), new $Int64(-66478285, 3080389532), new $Int64(-646438364, 2215402037), new $Int64(391002300, 1171593935), new $Int64(1408774047, 1423855166), new $Int64(-519177718, 2276716302), new $Int64(-368453140, 2068027241), new $Int64(1369359303, 3427553297), new $Int64(189241615, 3289637845), new $Int64(1057480830, 3486407650), new $Int64(-1512910664, 3071877822), new $Int64(1159653919, 3363620705), new $Int64(-934256930, 4159821533), new $Int64(-76621938, 1894661), new $Int64(-674493898, 1156868282), new $Int64(348271067, 776219088), new $Int64(-501428838, 2425634259), new $Int64(1716021749, 680510161), new $Int64(-574263456, 1310101429), new $Int64(1095885995, 2964454134), new $Int64(-325695512, 3467098407), new $Int64(1990672920, 2109628894), new $Int64(-2139648704, 1232604732), new $Int64(-1838070714, 3261916179), new $Int64(1699175360, 434597899), new $Int64(235436061, 1624796439), new $Int64(-1626402839, 3589632480), new $Int64(1198416575, 864579159), new $Int64(-1938748161, 1380889830), new $Int64(619206309, 2654509477), new $Int64(1419738251, 1468209306), new $Int64(-1744284772, 100794388), new $Int64(-1191421458, 2991674471), new $Int64(-208666741, 2224662036), new $Int64(-173659161, 977097250), new $Int64(1351320195, 726419512), new $Int64(-183459897, 1747974366), new $Int64(-753095183, 1556430604), new $Int64(-1049492215, 1080776742), new $Int64(-385846958, 280794874), new $Int64(117767733, 919835643), new $Int64(-967009426, 3434019658), new $Int64(-1951414480, 2461941785), new $Int64(133215641, 3615001066), new $Int64(417204809, 3103414427), new $Int64(790056561, 3380809712), new $Int64(-1267681408, 2724693469), new $Int64(547796833, 598827710), new $Int64(-1846559452, 3452273442), new $Int64(-75778224, 649274915), new $Int64(-801301329, 2585724112), new $Int64(-1510934263, 3165579553), new $Int64(1185578221, 2635894283), new $Int64(-52910178, 2053289721), new $Int64(985976581, 3169337108), new $Int64(1170569632, 144717764), new $Int64(1079216270, 1383666384), new $Int64(-124804942, 681540375), new $Int64(1375448925, 537050586), new $Int64(-1964768344, 315246468), new $Int64(226402871, 849323088), new $Int64(-885062465, 45543944), new $Int64(-946445250, 2319052083), new $Int64(-40708194, 3613090841), new $Int64(560472520, 2992171180), new $Int64(-381863169, 2068244785), new $Int64(917538188, 4239862634), new $Int64(-1369555809, 3892253031), new $Int64(720683925, 958186149), new $Int64(-423297785, 1877702262), new $Int64(1357886971, 837674867), new $Int64(1837048883, 1507589294), new $Int64(1905518400, 873336795), new $Int64(-1879761037, 2764496274), new $Int64(-1806480530, 4196182374), new $Int64(-1066765755, 550964545), new $Int64(818747069, 420611474), new $Int64(-1924830376, 204265180), new $Int64(1549974541, 1787046383), new $Int64(1215581865, 3102292318), new $Int64(418321538, 1552199393), new $Int64(1243493047, 980542004), new $Int64(267284263, 3293718720), new $Int64(1179528763, 3771917473), new $Int64(599484404, 2195808264), new $Int64(252818753, 3894702887), new $Int64(-1367475956, 2099949527), new $Int64(1424094358, 338442522), new $Int64(490737398, 637158004), new $Int64(-1727621530, 281976339), new $Int64(574970164, 3619802330), new $Int64(-431930823, 3084554784), new $Int64(-1264611183, 4129772886), new $Int64(-2104399043, 1680378557), new $Int64(-1621962591, 3339087776), new $Int64(1680500332, 4220317857), new $Int64(-1935828963, 2959322499), new $Int64(1675600481, 1488354890), new $Int64(-834863562, 3958162143), new $Int64(-1226511573, 2773705983), new $Int64(1876039582, 225908689), new $Int64(-1183735113, 908216283), new $Int64(-605696219, 3574646075), new $Int64(-1827723091, 1936937569), new $Int64(1519770881, 75492235), new $Int64(816689472, 1935193178), new $Int64(2142521206, 2018250883), new $Int64(455141620, 3943126022), new $Int64(-601399488, 3066544345), new $Int64(1932392669, 2793082663), new $Int64(-1239009361, 3297036421), new $Int64(1640597065, 2206987825), new $Int64(-553246738, 807894872), new $Int64(-1781325307, 766252117), new $Int64(2060649606, 3833114345), new $Int64(845619743, 1255067973), new $Int64(1201145605, 741697208), new $Int64(-1476242608, 2810093753), new $Int64(1109032642, 4229340371), new $Int64(1462188720, 1361684224), new $Int64(-1159399429, 1906263026), new $Int64(475781207, 3904421704), new $Int64(-623537128, 1769075545), new $Int64(1062308525, 2621599764), new $Int64(1279509432, 3431891480), new $Int64(-1742751146, 1871896503), new $Int64(128756421, 1412808876), new $Int64(1605404688, 952876175), new $Int64(-230443691, 1824438899), new $Int64(1662295856, 1005035476), new $Int64(-156574141, 527508597), new $Int64(1288873303, 3066806859), new $Int64(565995893, 3244940914), new $Int64(-889746188, 209092916), new $Int64(-247669406, 1242699167), new $Int64(-713830396, 456723774), new $Int64(1776978905, 1001252870), new $Int64(1468772157, 2026725874), new $Int64(857254202, 2137562569), new $Int64(765939740, 3183366709), new $Int64(1533887628, 2612072960), new $Int64(56977098, 1727148468), new $Int64(-1197583895, 3803658212), new $Int64(1883670356, 479946959), new $Int64(685713571, 1562982345), new $Int64(-1946242443, 1766109365), new $Int64(700596547, 3257093788), new $Int64(-184714929, 2365720207), new $Int64(93384808, 3742754173), new $Int64(-458385235, 2878193673), new $Int64(1096135042, 2174002182), new $Int64(-834260953, 3573511231), new $Int64(-754572527, 1760299077), new $Int64(-1375627191, 2260779833), new $Int64(-866019274, 1452805722), new $Int64(-1229671918, 2940011802), new $Int64(1890251082, 1886183802), new $Int64(893897673, 2514369088), new $Int64(1644345561, 3924317791), new $Int64(-1974867432, 500935732), new $Int64(1403501753, 676580929), new $Int64(-1565912283, 1184984890), new $Int64(-691968413, 1271474274), new $Int64(-1828754738, 3163791473), new $Int64(2051027584, 2842487377), new $Int64(1511537551, 2170968612), new $Int64(573262976, 3535856740), new $Int64(-2053227187, 1488599718), new $Int64(-1180531831, 3408913763), new $Int64(-2086531912, 2501050084), new $Int64(-875130448, 1639124157), new $Int64(-2009482504, 4088176393), new $Int64(1574896563, 3989947576), new $Int64(-165243708, 3414355209), new $Int64(-792329287, 2275136352), new $Int64(-2057774345, 2151835223), new $Int64(-931144933, 1654534827), new $Int64(-679921451, 377892833), new $Int64(-482716010, 660204544), new $Int64(85706799, 390828249), new $Int64(-1422172693, 3402783878), new $Int64(-1468634160, 3717936603), new $Int64(1113532086, 2211058823), new $Int64(1564224320, 2692150867), new $Int64(1952770442, 1928910388), new $Int64(788716862, 3931011137), new $Int64(1083670504, 1112701047), new $Int64(-68150572, 2452299106), new $Int64(-896164822, 2337204777), new $Int64(1774877857, 273889282), new $Int64(1798719843, 1462008793), new $Int64(2138834788, 1554494002), new $Int64(-1194967131, 182675323), new $Int64(-1598554764, 1882802136), new $Int64(589279648, 3700220025), new $Int64(381039426, 3083431543), new $Int64(-851859191, 3622207527), new $Int64(338126939, 432729309), new $Int64(-1667470126, 2391914317), new $Int64(-1849558151, 235747924), new $Int64(2120733629, 3088823825), new $Int64(-745079795, 2314658321), new $Int64(1165929723, 2957634338), new $Int64(501323675, 4117056981), new $Int64(1564699815, 1482500298), new $Int64(-740826490, 840489337), new $Int64(799522364, 3483178565), new $Int64(532129761, 2074004656), new $Int64(724246478, 3643392642), new $Int64(-665153481, 1583624461), new $Int64(-885822954, 287473085), new $Int64(1667835381, 3136843981), new $Int64(1138806821, 1266970974), new $Int64(135185781, 1998688839), new $Int64(392094735, 1492900209), new $Int64(1031326774, 1538112737), new $Int64(-2070568842, 2207265429), new $Int64(-1886797613, 963263315), new $Int64(1671145500, 2295892134), new $Int64(1068469660, 2002560897), new $Int64(-356250305, 1369254035), new $Int64(33436120, 3353312708), new $Int64(57507843, 947771099), new $Int64(-1945755145, 1747061399), new $Int64(1507240140, 2047354631), new $Int64(720000810, 4165367136), new $Int64(479265078, 3388864963), new $Int64(-952181250, 286492130), new $Int64(2045622690, 2795735007), new $Int64(-715730566, 3703961339), new $Int64(-148436487, 1797825479), new $Int64(1429039600, 1116589674), new $Int64(-1665420098, 2593309206), new $Int64(1329049334, 3404995677), new $Int64(-750579440, 3453462936), new $Int64(1014767077, 3016498634), new $Int64(75698599, 1650371545), new $Int64(1592007860, 212344364), new $Int64(1127766888, 3843932156), new $Int64(-748019856, 3573129983), new $Int64(-890581831, 665897820), new $Int64(1071492673, 1675628772), new $Int64(243225682, 2831752928), new $Int64(2120298836, 1486294219), new $Int64(-1954407413, 268782709), new $Int64(-1002123503, 4186179080), new $Int64(624342951, 1613720397), new $Int64(857179861, 2703686015), new $Int64(-911618704, 2205342611), new $Int64(-672703993, 1411666394), new $Int64(-1528454899, 677744900), new $Int64(-1876628533, 4172867247), new $Int64(135494707, 2163418403), new $Int64(849547544, 2841526879), new $Int64(-1117516959, 1082141470), new $Int64(-1770111792, 4046134367), new $Int64(51415528, 2142943655), new $Int64(-249824333, 3124627521), new $Int64(998228909, 219992939), new $Int64(-1078790951, 1756846531), new $Int64(1283749206, 1225118210), new $Int64(-525858006, 1647770243), new $Int64(-2035959705, 444807907), new $Int64(2036369448, 3952076173), new $Int64(53201823, 1461839639), new $Int64(315761893, 3699250910), new $Int64(702974850, 1373688981), new $Int64(734022261, 147523747), new $Int64(-2047330906, 1211276581), new $Int64(1294440951, 2548832680), new $Int64(1144696256, 1995631888), new $Int64(-1992983070, 2011457303), new $Int64(-1351022674, 3057425772), new $Int64(667839456, 81484597), new $Int64(-1681980888, 3646681560), new $Int64(-1372462725, 635548515), new $Int64(602489502, 2508044581), new $Int64(-1794220117, 1014917157), new $Int64(719992433, 3214891315), new $Int64(-1294799037, 959582252), new $Int64(226415134, 3347040449), new $Int64(-362868096, 4102971975), new $Int64(397887437, 4078022210), new $Int64(-536803826, 2851767182), new $Int64(-1398321012, 1540160644), new $Int64(-1549098876, 1057290595), new $Int64(-112592988, 3907769253), new $Int64(579300318, 4248952684), new $Int64(-1054576049, 132554364), new $Int64(-1085862414, 1029351092), new $Int64(697840928, 2583007416), new $Int64(298619124, 1486185789), new $Int64(55905697, 2871589073), new $Int64(2017643612, 723203291), new $Int64(146250550, 2494333952), new $Int64(-1082993397, 2230939180), new $Int64(-1804568072, 3943232912), new $Int64(1768732449, 2181367922), new $Int64(-729261111, 2889274791), new $Int64(1824032949, 2046728161), new $Int64(1653899792, 1376052477), new $Int64(1022327048, 381236993), new $Int64(-1113097690, 3188942166), new $Int64(-74480109, 350070824), new $Int64(144881592, 61758415), new $Int64(-741824226, 3492950336), new $Int64(-2030042720, 3093818430), new $Int64(-453590535, 2962480613), new $Int64(-1912050708, 3154871160), new $Int64(-1636478569, 3228564679), new $Int64(610731502, 888276216), new $Int64(-946702974, 3574998604), new $Int64(-1277068380, 1967526716), new $Int64(-1556147941, 1554691298), new $Int64(-1573024234, 339944798), new $Int64(1223764147, 1154515356), new $Int64(1825645307, 967516237), new $Int64(1546195135, 596588202), new $Int64(-1867600880, 3764362170), new $Int64(-1655392592, 266611402), new $Int64(-393255880, 2047856075), new $Int64(-1000726433, 21444105), new $Int64(-949424754, 3065563181), new $Int64(-232418803, 1140663212), new $Int64(633187674, 2323741028), new $Int64(2126290159, 3103873707), new $Int64(1008658319, 2766828349), new $Int64(-485587503, 1970872996), new $Int64(1628585413, 3766615585), new $Int64(-595148528, 2036813414), new $Int64(-1994877121, 3105536507), new $Int64(13954645, 3396176938), new $Int64(-721402003, 1377154485), new $Int64(-61839181, 3807014186), new $Int64(543009040, 3710110597), new $Int64(-1751425519, 916420443), new $Int64(734556788, 2103831255), new $Int64(-1766161494, 717331943), new $Int64(-1574598896, 3550505941), new $Int64(45939673, 378749927), new $Int64(-1997615719, 611017331), new $Int64(592130075, 758907650), new $Int64(1012992349, 154266815), new $Int64(-1040454942, 1407468696), new $Int64(-1678191250, 970098704), new $Int64(-285057486, 1971660656), new $Int64(998365243, 3332747885), new $Int64(1947089649, 1935189867), new $Int64(1510248801, 203520055), new $Int64(-1305165746, 3916463034), new $Int64(-388598655, 3474113316), new $Int64(1036101639, 316544223), new $Int64(-1773744891, 1650844677), new $Int64(-907191419, 4267565603), new $Int64(-1070275024, 2501167616), new $Int64(-1520651863, 3929401789), new $Int64(-2091360852, 337170252), new $Int64(-960502090, 2061966842), new $Int64(-304190848, 2508461464), new $Int64(-1941471116, 2791377107), new $Int64(1240791848, 1227227588), new $Int64(1813978778, 1709681848), new $Int64(1153692192, 3768820575), new $Int64(-1002297449, 2887126398), new $Int64(-1447111334, 296561685), new $Int64(700300844, 3729960077), new $Int64(-1572311344, 372833036), new $Int64(2078875613, 2409779288), new $Int64(1829161290, 555274064), new $Int64(-1105595719, 4239804901), new $Int64(1839403216, 3723486978), new $Int64(-1649093095, 2145871984), new $Int64(-1582765715, 3565480803), new $Int64(-1568653827, 2197313814), new $Int64(974785092, 3613674566), new $Int64(438638731, 3042093666), new $Int64(-96556264, 3324034321), new $Int64(869420878, 3708873369), new $Int64(946682149, 1698090092), new $Int64(1618900382, 4213940712), new $Int64(-1843479747, 2087477361), new $Int64(-1766167800, 2407950639), new $Int64(-1296225558, 3942568569), new $Int64(-1223900450, 4088074412), new $Int64(723260036, 2964773675), new $Int64(-673921829, 1539178386), new $Int64(1062961552, 2694849566), new $Int64(460977733, 2120273838), new $Int64(-1604570740, 2484608657), new $Int64(880846449, 2956190677), new $Int64(1970902366, 4223313749), new $Int64(662161910, 3502682327), new $Int64(705634754, 4133891139), new $Int64(-1031359300, 1166449596), new $Int64(1038247601, 3362705993), new $Int64(93734798, 3892921029), new $Int64(1876124043, 786869787), new $Int64(1057490746, 1046342263), new $Int64(242763728, 493777327), new $Int64(-853573201, 3304827646), new $Int64(616460742, 125356352), new $Int64(499300063, 74094113), new $Int64(-795586925, 2500816079), new $Int64(-490248444, 514015239), new $Int64(1377565129, 543520454), new $Int64(-2039776725, 3614531153), new $Int64(2056746300, 2356753985), new $Int64(1390062617, 2018141668), new $Int64(131272971, 2087974891), new $Int64(-1502927041, 3166972343), new $Int64(372256200, 1517638666), new $Int64(-935275664, 173466846), new $Int64(-695774461, 4241513471), new $Int64(-1413550842, 2783126920), new $Int64(1972004134, 4167264826), new $Int64(29260506, 3907395640), new $Int64(-910901561, 1539634186), new $Int64(-595957298, 178241987), new $Int64(-113277636, 182168164), new $Int64(-1102530459, 2386154934), new $Int64(1379126408, 4077374341), new $Int64(-2114679722, 1732699140), new $Int64(-421057745, 1041306002), new $Int64(1860414813, 2068001749), new $Int64(1005320202, 3208962910), new $Int64(844054010, 697710380), new $Int64(-1509359403, 2228431183), new $Int64(-810313977, 3554678728), new $Int64(-750989047, 173470263), new $Int64(-85886265, 3848297795), new $Int64(-926936977, 246236185), new $Int64(-1984190461, 2066374846), new $Int64(1771673660, 312890749), new $Int64(703378057, 3573310289), new $Int64(-598851901, 143166754), new $Int64(613554316, 2081511079), new $Int64(1197802104, 486038032), new $Int64(-1906483789, 2982218564), new $Int64(364901986, 1000939191), new $Int64(1902782651, 2750454885), new $Int64(-671844857, 3375313137), new $Int64(-1643868040, 881302957), new $Int64(-1508784745, 2514186393), new $Int64(-1703622845, 360024739), new $Int64(1399671872, 292500025), new $Int64(1381210821, 2276300752), new $Int64(521803381, 4069087683), new $Int64(-1938982667, 1637778212), new $Int64(720490469, 1676670893), new $Int64(1067262482, 3855174429), new $Int64(2114075974, 2067248671), new $Int64(-89426259, 2884561259), new $Int64(-805741095, 2456511185), new $Int64(983726246, 561175414), new $Int64(-1719489563, 432588903), new $Int64(885133709, 4059399550), new $Int64(-93096266, 1075014784), new $Int64(-1733832628, 2728058415), new $Int64(1839142064, 1299703678), new $Int64(1262333188, 2347583393), new $Int64(1285481956, 2468164145), new $Int64(-1158354011, 1140014346), new $Int64(2033889184, 1936972070), new $Int64(-1737578993, 3870530098), new $Int64(-484494257, 1717789158), new $Int64(-232997156, 1153452491), new $Int64(-990424416, 3948827651), new $Int64(-1357145630, 2101413152), new $Int64(1495744672, 3854091229), new $Int64(83644069, 4215565463), new $Int64(-1385277313, 1202710438), new $Int64(-564909037, 2072216740), new $Int64(705690639, 2066751068), new $Int64(-2113583312, 173902580), new $Int64(-741983806, 142459001), new $Int64(172391592, 1889151926), new $Int64(-498943125, 3034199774), new $Int64(1618587731, 516490102), new $Int64(93114264, 3692577783), new $Int64(-2078821353, 2953948865), new $Int64(-320938673, 4041040923), new $Int64(-1942517976, 592046130), new $Int64(-705643640, 384297211), new $Int64(-2051649464, 265863924), new $Int64(2101717619, 1333136237), new $Int64(1499611781, 1406273556), new $Int64(1074670496, 426305476), new $Int64(125704633, 2750898176), new $Int64(488068495, 1633944332), new $Int64(2037723464, 3236349343), new $Int64(-1703423246, 4013676611), new $Int64(1718532237, 2265047407), new $Int64(1433593806, 875071080), new $Int64(-343047503, 1418843655), new $Int64(2009228711, 451657300), new $Int64(1229446621, 1866374663), new $Int64(1653472867, 1551455622), new $Int64(577191481, 3560962459), new $Int64(1669204077, 3347903778), new $Int64(-298327194, 2675874918), new $Int64(-1831355577, 2762991672), new $Int64(530492383, 3689068477), new $Int64(844089962, 4071997905), new $Int64(1508155730, 1381702441), new $Int64(2089931018, 2373284878), new $Int64(-864267462, 2143983064), new $Int64(308739063, 1938207195), new $Int64(1754949306, 1188152253), new $Int64(1272345009, 615870490), new $Int64(742653194, 2662252621), new $Int64(1477718295, 3839976789), new $Int64(-2091334213, 306752547), new $Int64(-1426688067, 2162363077), new $Int64(-57052633, 2767224719), new $Int64(-1471624099, 2628837712), new $Int64(1678405918, 2967771969), new $Int64(1694285728, 499792248), new $Int64(-1744131281, 4285253508), new $Int64(962357072, 2856511070), new $Int64(679471692, 2526409716), new $Int64(-1793706473, 1240875658), new $Int64(-914893422, 2577342868), new $Int64(-1001298215, 4136853496), new $Int64(-1477114974, 2403540137), new $Int64(1372824515, 1371410668), new $Int64(-176562048, 371758825), new $Int64(-441063112, 1528834084), new $Int64(-71688630, 1504757260), new $Int64(-1461820072, 699052551), new $Int64(-505543539, 3347789870), new $Int64(1951619734, 3430604759), new $Int64(2119672219, 1935601723), new $Int64(966789690, 834676166)]); + globalRand = New(new lockedSource.ptr(new nosync.Mutex.ptr(false), $assertType(NewSource(new $Int64(0, 1)), Source64))); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["math/big"] = (function() { + var $pkg = {}, $init, bytes, binary, errors, fmt, nosync, io, math, bits, rand, strconv, strings, Word, decimal, Float, ErrNaN, form, RoundingMode, Accuracy, Int, byteReader, nat, divisor, Rat, sliceType, arrayType, structType, sliceType$1, ptrType, sliceType$2, ptrType$1, ptrType$2, ptrType$3, ptrType$4, arrayType$1, sliceType$3, ptrType$5, ptrType$6, _Accuracy_index, pow5tab, intOne, natOne, natTwo, natTen, karatsubaThreshold, basicSqrThreshold, karatsubaSqrThreshold, natPool, leafSize, cacheBase10, _RoundingMode_index, three, _r, addWW_g, subWW_g, mulWW_g, mulAddWWW_g, nlz, divWW_g, addVV_g, subVV_g, addVW_g, subVW_g, shlVU_g, shrVU_g, mulAddVWW_g, addMulVVW_g, divWVW_g, mulWW, divWW, addVV, subVV, addVW, subVW, shlVU, shrVU, mulAddVWW, addMulVVW, divWVW, shr, appendZeros, shouldRoundUp, trim, NewFloat, makeAcc, fnorm, msb32, msb64, validateBinaryOperands, umax32, roundShortest, fmtE, fmtF, min, NewInt, low32, low64, lehmerSimulate, lehmerUpdate, euclidUpdate, Jacobi, writeMultiple, scanSign, basicMul, karatsubaAdd, karatsubaSub, karatsuba, alias, addAt, max, karatsubaLen, basicSqr, karatsubaSqr, getNat, putNat, same, greaterThan, bigEndianWord, maxPow, pow, divisors, quotToFloat32, quotToFloat64, mulDenom, scaleDenom, ratTok, scanExponent, newFloat; + bytes = $packages["bytes"]; + binary = $packages["encoding/binary"]; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + io = $packages["io"]; + math = $packages["math"]; + bits = $packages["math/bits"]; + rand = $packages["math/rand"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + Word = $pkg.Word = $newType(4, $kindUintptr, "big.Word", true, "math/big", true, null); + decimal = $pkg.decimal = $newType(0, $kindStruct, "big.decimal", true, "math/big", false, function(mant_, exp_) { + this.$val = this; + if (arguments.length === 0) { + this.mant = sliceType$1.nil; + this.exp = 0; + return; + } + this.mant = mant_; + this.exp = exp_; + }); + Float = $pkg.Float = $newType(0, $kindStruct, "big.Float", true, "math/big", true, function(prec_, mode_, acc_, form_, neg_, mant_, exp_) { + this.$val = this; + if (arguments.length === 0) { + this.prec = 0; + this.mode = 0; + this.acc = 0; + this.form = 0; + this.neg = false; + this.mant = nat.nil; + this.exp = 0; + return; + } + this.prec = prec_; + this.mode = mode_; + this.acc = acc_; + this.form = form_; + this.neg = neg_; + this.mant = mant_; + this.exp = exp_; + }); + ErrNaN = $pkg.ErrNaN = $newType(0, $kindStruct, "big.ErrNaN", true, "math/big", true, function(msg_) { + this.$val = this; + if (arguments.length === 0) { + this.msg = ""; + return; + } + this.msg = msg_; + }); + form = $pkg.form = $newType(1, $kindUint8, "big.form", true, "math/big", false, null); + RoundingMode = $pkg.RoundingMode = $newType(1, $kindUint8, "big.RoundingMode", true, "math/big", true, null); + Accuracy = $pkg.Accuracy = $newType(1, $kindInt8, "big.Accuracy", true, "math/big", true, null); + Int = $pkg.Int = $newType(0, $kindStruct, "big.Int", true, "math/big", true, function(neg_, abs_) { + this.$val = this; + if (arguments.length === 0) { + this.neg = false; + this.abs = nat.nil; + return; + } + this.neg = neg_; + this.abs = abs_; + }); + byteReader = $pkg.byteReader = $newType(0, $kindStruct, "big.byteReader", true, "math/big", false, function(ScanState_) { + this.$val = this; + if (arguments.length === 0) { + this.ScanState = $ifaceNil; + return; + } + this.ScanState = ScanState_; + }); + nat = $pkg.nat = $newType(12, $kindSlice, "big.nat", true, "math/big", false, null); + divisor = $pkg.divisor = $newType(0, $kindStruct, "big.divisor", true, "math/big", false, function(bbb_, nbits_, ndigits_) { + this.$val = this; + if (arguments.length === 0) { + this.bbb = nat.nil; + this.nbits = 0; + this.ndigits = 0; + return; + } + this.bbb = bbb_; + this.nbits = nbits_; + this.ndigits = ndigits_; + }); + Rat = $pkg.Rat = $newType(0, $kindStruct, "big.Rat", true, "math/big", true, function(a_, b_) { + this.$val = this; + if (arguments.length === 0) { + this.a = new Int.ptr(false, nat.nil); + this.b = new Int.ptr(false, nat.nil); + return; + } + this.a = a_; + this.b = b_; + }); + sliceType = $sliceType($emptyInterface); + arrayType = $arrayType(divisor, 64); + structType = $structType("math/big", [{prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: nosync.Mutex, tag: ""}, {prop: "table", name: "table", embedded: false, exported: false, typ: arrayType, tag: ""}]); + sliceType$1 = $sliceType($Uint8); + ptrType = $ptrType(Float); + sliceType$2 = $sliceType(Word); + ptrType$1 = $ptrType(Int); + ptrType$2 = $ptrType(Rat); + ptrType$3 = $ptrType(Word); + ptrType$4 = $ptrType(nat); + arrayType$1 = $arrayType(nat, 16); + sliceType$3 = $sliceType(divisor); + ptrType$5 = $ptrType(decimal); + ptrType$6 = $ptrType(rand.Rand); + Accuracy.prototype.String = function() { + var i, x; + i = this.$val; + i = i - (-1) << 24 >> 24; + if (i < 0 || i >= 3) { + return "Accuracy(" + strconv.FormatInt((new $Int64(0, (i + -1 << 24 >> 24))), 10) + ")"; + } + return $substring("BelowExactAbove", ((i < 0 || i >= _Accuracy_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _Accuracy_index[i]), (x = i + 1 << 24 >> 24, ((x < 0 || x >= _Accuracy_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _Accuracy_index[x]))); + }; + $ptrType(Accuracy).prototype.String = function() { return new Accuracy(this.$get()).String(); }; + addWW_g = function(x, y, c) { + var c, x, y, yc, z0, z1; + z1 = 0; + z0 = 0; + yc = y + c >>> 0; + z0 = x + yc >>> 0; + if (z0 < x || yc < y) { + z1 = 1; + } + return [z1, z0]; + }; + subWW_g = function(x, y, c) { + var c, x, y, yc, z0, z1; + z1 = 0; + z0 = 0; + yc = y + c >>> 0; + z0 = x - yc >>> 0; + if (z0 > x || yc < y) { + z1 = 1; + } + return [z1, z0]; + }; + mulWW_g = function(x, y) { + var t, w0, w1, w2, x, x0, x1, y, y0, y1, z0, z1; + z1 = 0; + z0 = 0; + x0 = (x & 65535) >>> 0; + x1 = x >>> 16 >>> 0; + y0 = (y & 65535) >>> 0; + y1 = y >>> 16 >>> 0; + w0 = $imul(x0, y0) >>> 0; + t = ($imul(x1, y0) >>> 0) + (w0 >>> 16 >>> 0) >>> 0; + w1 = (t & 65535) >>> 0; + w2 = t >>> 16 >>> 0; + w1 = w1 + (($imul(x0, y1) >>> 0)) >>> 0; + z1 = (($imul(x1, y1) >>> 0) + w2 >>> 0) + (w1 >>> 16 >>> 0) >>> 0; + z0 = $imul(x, y) >>> 0; + return [z1, z0]; + }; + mulAddWWW_g = function(x, y, c) { + var _tuple, c, x, y, z0, z1, zz0; + z1 = 0; + z0 = 0; + _tuple = mulWW_g(x, y); + z1 = _tuple[0]; + zz0 = _tuple[1]; + z0 = zz0 + c >>> 0; + if (z0 < zz0) { + z1 = z1 + (1) >>> 0; + } + return [z1, z0]; + }; + nlz = function(x) { + var x; + return ((bits.LeadingZeros(((x >>> 0))) >>> 0)); + }; + divWW_g = function(u1, u0, v) { + var _q, _q$1, _tmp, _tmp$1, _tmp$2, _tmp$3, q, q0, q1, r, rhat, s, u0, u1, un0, un1, un10, un21, un32, v, vn0, vn1, y, y$1, y$2, y$3, y$4; + q = 0; + r = 0; + if (u1 >= v) { + _tmp = 4294967295; + _tmp$1 = 4294967295; + q = _tmp; + r = _tmp$1; + return [q, r]; + } + s = nlz(v); + v = (y = (s), y < 32 ? (v << y) : 0) >>> 0; + vn1 = v >>> 16 >>> 0; + vn0 = (v & 65535) >>> 0; + un32 = (((y$1 = s, y$1 < 32 ? (u1 << y$1) : 0) >>> 0) | ((y$2 = ((32 - s >>> 0)), y$2 < 32 ? (u0 >>> y$2) : 0) >>> 0)) >>> 0; + un10 = (y$3 = s, y$3 < 32 ? (u0 << y$3) : 0) >>> 0; + un1 = un10 >>> 16 >>> 0; + un0 = (un10 & 65535) >>> 0; + q1 = (_q = un32 / vn1, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + rhat = un32 - ($imul(q1, vn1) >>> 0) >>> 0; + while (true) { + if (!(q1 >= 65536 || ($imul(q1, vn0) >>> 0) > (($imul(65536, rhat) >>> 0) + un1 >>> 0))) { break; } + q1 = q1 - (1) >>> 0; + rhat = rhat + (vn1) >>> 0; + if (rhat >= 65536) { + break; + } + } + un21 = (($imul(un32, 65536) >>> 0) + un1 >>> 0) - ($imul(q1, v) >>> 0) >>> 0; + q0 = (_q$1 = un21 / vn1, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + rhat = un21 - ($imul(q0, vn1) >>> 0) >>> 0; + while (true) { + if (!(q0 >= 65536 || ($imul(q0, vn0) >>> 0) > (($imul(65536, rhat) >>> 0) + un0 >>> 0))) { break; } + q0 = q0 - (1) >>> 0; + rhat = rhat + (vn1) >>> 0; + if (rhat >= 65536) { + break; + } + } + _tmp$2 = ($imul(q1, 65536) >>> 0) + q0 >>> 0; + _tmp$3 = (y$4 = s, y$4 < 32 ? ((((($imul(un21, 65536) >>> 0) + un0 >>> 0) - ($imul(q0, v) >>> 0) >>> 0)) >>> y$4) : 0) >>> 0; + q = _tmp$2; + r = _tmp$3; + return [q, r]; + }; + addVV_g = function(z, x, y) { + var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, yi, z, zi; + c = 0; + if (false) { + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = addWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]), c); + c = _tuple[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); + _i++; + } + return c; + } + _ref$1 = $subslice(x, 0, z.$length); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); + zi = (xi + yi >>> 0) + c >>> 0; + ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); + c = (((((xi & yi) >>> 0) | (((((xi | yi) >>> 0)) & ~zi) >>> 0)) >>> 0)) >>> 31 >>> 0; + _i$1++; + } + return c; + }; + subVV_g = function(z, x, y) { + var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, yi, z, zi; + c = 0; + if (false) { + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = subWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]), c); + c = _tuple[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); + _i++; + } + return c; + } + _ref$1 = $subslice(x, 0, z.$length); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); + zi = (xi - yi >>> 0) - c >>> 0; + ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); + c = (((((yi & ~xi) >>> 0) | (((((yi | (~xi >>> 0)) >>> 0)) & zi) >>> 0)) >>> 0)) >>> 31 >>> 0; + _i$1++; + } + return c; + }; + addVW_g = function(z, x, y) { + var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, z, zi; + c = 0; + if (false) { + c = y; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = addWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), c, 0); + c = _tuple[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); + _i++; + } + return c; + } + c = y; + _ref$1 = $subslice(x, 0, z.$length); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + zi = xi + c >>> 0; + ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); + c = ((xi & ~zi) >>> 0) >>> 31 >>> 0; + _i$1++; + } + return c; + }; + subVW_g = function(z, x, y) { + var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, z, zi; + c = 0; + if (false) { + c = y; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = subWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), c, 0); + c = _tuple[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); + _i++; + } + return c; + } + c = y; + _ref$1 = $subslice(x, 0, z.$length); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + zi = xi - c >>> 0; + ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); + c = (((zi & ~xi) >>> 0)) >>> 31 >>> 0; + _i$1++; + } + return c; + }; + shlVU_g = function(z, x, s) { + var $C5$9D, c, i, n, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z; + c = 0; + n = z.$length; + if (n > 0) { + $C5$9D = 32 - s >>> 0; + w1 = (x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + c = (y = $C5$9D, y < 32 ? (w1 >>> y) : 0) >>> 0; + i = n - 1 >> 0; + while (true) { + if (!(i > 0)) { break; } + w = w1; + w1 = (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$2])); + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((y$1 = s, y$1 < 32 ? (w << y$1) : 0) >>> 0) | ((y$2 = $C5$9D, y$2 < 32 ? (w1 >>> y$2) : 0) >>> 0)) >>> 0)); + i = i - (1) >> 0; + } + (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = ((y$3 = s, y$3 < 32 ? (w1 << y$3) : 0) >>> 0)); + } + return c; + }; + shrVU_g = function(z, x, s) { + var $C5$9D, c, i, n, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z; + c = 0; + n = z.$length; + if (n > 0) { + $C5$9D = 32 - s >>> 0; + w1 = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); + c = (y = $C5$9D, y < 32 ? (w1 << y) : 0) >>> 0; + i = 0; + while (true) { + if (!(i < (n - 1 >> 0))) { break; } + w = w1; + w1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((y$1 = s, y$1 < 32 ? (w >>> y$1) : 0) >>> 0) | ((y$2 = $C5$9D, y$2 < 32 ? (w1 << y$2) : 0) >>> 0)) >>> 0)); + i = i + (1) >> 0; + } + (x$2 = n - 1 >> 0, ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = ((y$3 = s, y$3 < 32 ? (w1 >>> y$3) : 0) >>> 0))); + } + return c; + }; + mulAddVWW_g = function(z, x, y, r) { + var _i, _ref, _tuple, c, i, r, x, y, z; + c = 0; + c = r; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y, c); + c = _tuple[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); + _i++; + } + return c; + }; + addMulVVW_g = function(z, x, y) { + var _i, _ref, _tuple, _tuple$1, c, i, x, y, z, z0, z1; + c = 0; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y, ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i])); + z1 = _tuple[0]; + z0 = _tuple[1]; + _tuple$1 = addWW_g(z0, c, 0); + c = _tuple$1[0]; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple$1[1]); + c = c + (z1) >>> 0; + _i++; + } + return c; + }; + divWVW_g = function(z, xn, x, y) { + var _tuple, i, r, x, xn, y, z; + r = 0; + r = xn; + i = z.$length - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + _tuple = divWW_g(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y); + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[0]); + r = _tuple[1]; + i = i - (1) >> 0; + } + return r; + }; + mulWW = function(x, y) { + var _tuple, x, y, z0, z1; + z1 = 0; + z0 = 0; + _tuple = mulWW_g(x, y); + z1 = _tuple[0]; + z0 = _tuple[1]; + return [z1, z0]; + }; + divWW = function(x1, x0, y) { + var _tuple, q, r, x0, x1, y; + q = 0; + r = 0; + _tuple = divWW_g(x1, x0, y); + q = _tuple[0]; + r = _tuple[1]; + return [q, r]; + }; + addVV = function(z, x, y) { + var c, x, y, z; + c = 0; + c = addVV_g(z, x, y); + return c; + }; + subVV = function(z, x, y) { + var c, x, y, z; + c = 0; + c = subVV_g(z, x, y); + return c; + }; + addVW = function(z, x, y) { + var c, x, y, z; + c = 0; + c = addVW_g(z, x, y); + return c; + }; + subVW = function(z, x, y) { + var c, x, y, z; + c = 0; + c = subVW_g(z, x, y); + return c; + }; + shlVU = function(z, x, s) { + var c, s, x, z; + c = 0; + c = shlVU_g(z, x, s); + return c; + }; + shrVU = function(z, x, s) { + var c, s, x, z; + c = 0; + c = shrVU_g(z, x, s); + return c; + }; + mulAddVWW = function(z, x, y, r) { + var c, r, x, y, z; + c = 0; + c = mulAddVWW_g(z, x, y, r); + return c; + }; + addMulVVW = function(z, x, y) { + var c, x, y, z; + c = 0; + c = addMulVVW_g(z, x, y); + return c; + }; + divWVW = function(z, xn, x, y) { + var r, x, xn, y, z; + r = 0; + r = divWVW_g(z, xn, x, y); + return r; + }; + decimal.ptr.prototype.at = function(i) { + var d, i, x; + d = this; + if (0 <= i && i < d.mant.$length) { + return (x = d.mant, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + } + return 48; + }; + decimal.prototype.at = function(i) { return this.$val.at(i); }; + decimal.ptr.prototype.init = function(m, shift) { + var _r$1, m, n, ntz, s, s$1, shift, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; m = $f.m; n = $f.n; ntz = $f.ntz; s = $f.s; s$1 = $f.s$1; shift = $f.shift; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (m.$length === 0) { + x.mant = $subslice(x.mant, 0, 0); + x.exp = 0; + $s = -1; return; + } + if (shift < 0) { + ntz = m.trailingZeroBits(); + s = ((-shift >>> 0)); + if (s >= ntz) { + s = ntz; + } + m = (nat.nil).shr(m, s); + shift = shift + (((s >> 0))) >> 0; + } + if (shift > 0) { + m = (nat.nil).shl(m, ((shift >>> 0))); + shift = 0; + } + _r$1 = m.utoa(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + s$1 = _r$1; + n = s$1.$length; + x.exp = n; + while (true) { + if (!(n > 0 && ((x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= s$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : s$1.$array[s$1.$offset + x$1])) === 48))) { break; } + n = n - (1) >> 0; + } + x.mant = $appendSlice($subslice(x.mant, 0, 0), $subslice(s$1, 0, n)); + if (shift < 0) { + while (true) { + if (!(shift < -28)) { break; } + shr(x, 28); + shift = shift + (28) >> 0; + } + shr(x, ((-shift >>> 0))); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: decimal.ptr.prototype.init }; } $f._r$1 = _r$1; $f.m = m; $f.n = n; $f.ntz = ntz; $f.s = s; $f.s$1 = s$1; $f.shift = shift; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + decimal.prototype.init = function(m, shift) { return this.$val.init(m, shift); }; + shr = function(x, s) { + var ch, ch$1, d, d$1, d$2, mask, n, r, s, w, x, x$1, x$2, x$3, x$4, y, y$1, y$2, y$3, y$4, y$5; + r = 0; + n = 0; + while (true) { + if (!((((y = s, y < 32 ? (n >>> y) : 0) >>> 0) === 0) && r < x.mant.$length)) { break; } + ch = (((x$1 = x.mant, ((r < 0 || r >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + r])) >>> 0)); + r = r + (1) >> 0; + n = (($imul(n, 10) >>> 0) + ch >>> 0) - 48 >>> 0; + } + if (n === 0) { + x.mant = $subslice(x.mant, 0, 0); + return; + } + while (true) { + if (!(((y$1 = s, y$1 < 32 ? (n >>> y$1) : 0) >>> 0) === 0)) { break; } + r = r + (1) >> 0; + n = $imul(n, (10)) >>> 0; + } + x.exp = x.exp + ((1 - r >> 0)) >> 0; + w = 0; + mask = ((y$2 = s, y$2 < 32 ? (1 << y$2) : 0) >>> 0) - 1 >>> 0; + while (true) { + if (!(r < x.mant.$length)) { break; } + ch$1 = (((x$2 = x.mant, ((r < 0 || r >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + r])) >>> 0)); + r = r + (1) >> 0; + d = (y$3 = s, y$3 < 32 ? (n >>> y$3) : 0) >>> 0; + n = (n & (mask)) >>> 0; + (x$3 = x.mant, ((w < 0 || w >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + w] = (((d + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + n = (($imul(n, 10) >>> 0) + ch$1 >>> 0) - 48 >>> 0; + } + while (true) { + if (!(n > 0 && w < x.mant.$length)) { break; } + d$1 = (y$4 = s, y$4 < 32 ? (n >>> y$4) : 0) >>> 0; + n = (n & (mask)) >>> 0; + (x$4 = x.mant, ((w < 0 || w >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + w] = (((d$1 + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + n = $imul(n, 10) >>> 0; + } + x.mant = $subslice(x.mant, 0, w); + while (true) { + if (!(n > 0)) { break; } + d$2 = (y$5 = s, y$5 < 32 ? (n >>> y$5) : 0) >>> 0; + n = (n & (mask)) >>> 0; + x.mant = $append(x.mant, (((d$2 + 48 >>> 0) << 24 >>> 24))); + n = $imul(n, 10) >>> 0; + } + trim(x); + }; + decimal.ptr.prototype.String = function() { + var buf, x; + x = this; + if (x.mant.$length === 0) { + return "0"; + } + buf = sliceType$1.nil; + if (x.exp <= 0) { + buf = $appendSlice(buf, "0."); + buf = appendZeros(buf, -x.exp); + buf = $appendSlice(buf, x.mant); + } else if (x.exp < x.mant.$length) { + buf = $appendSlice(buf, $subslice(x.mant, 0, x.exp)); + buf = $append(buf, 46); + buf = $appendSlice(buf, $subslice(x.mant, x.exp)); + } else { + buf = $appendSlice(buf, x.mant); + buf = appendZeros(buf, x.exp - x.mant.$length >> 0); + } + return ($bytesToString(buf)); + }; + decimal.prototype.String = function() { return this.$val.String(); }; + appendZeros = function(buf, n) { + var buf, n; + while (true) { + if (!(n > 0)) { break; } + buf = $append(buf, 48); + n = n - (1) >> 0; + } + return buf; + }; + shouldRoundUp = function(x, n) { + var n, x, x$1, x$2, x$3, x$4; + if (((x$1 = x.mant, ((n < 0 || n >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + n])) === 53) && ((n + 1 >> 0) === x.mant.$length)) { + return n > 0 && !(((((((x$2 = x.mant, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])) - 48 << 24 >>> 24)) & 1) >>> 0) === 0)); + } + return (x$4 = x.mant, ((n < 0 || n >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + n])) >= 53; + }; + decimal.ptr.prototype.round = function(n) { + var n, x; + x = this; + if (n < 0 || n >= x.mant.$length) { + return; + } + if (shouldRoundUp(x, n)) { + x.roundUp(n); + } else { + x.roundDown(n); + } + }; + decimal.prototype.round = function(n) { return this.$val.round(n); }; + decimal.ptr.prototype.roundUp = function(n) { + var _index, n, x, x$1, x$2, x$3, x$4, x$5; + x = this; + if (n < 0 || n >= x.mant.$length) { + return; + } + while (true) { + if (!(n > 0 && (x$1 = x.mant, x$2 = n - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) >= 57)) { break; } + n = n - (1) >> 0; + } + if (n === 0) { + (x$3 = x.mant, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = 49)); + x.mant = $subslice(x.mant, 0, 1); + x.exp = x.exp + (1) >> 0; + return; + } + _index = n - 1 >> 0; + (x$5 = x.mant, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index] = ((x$4 = x.mant, ((_index < 0 || _index >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + _index])) + (1) << 24 >>> 24))); + x.mant = $subslice(x.mant, 0, n); + }; + decimal.prototype.roundUp = function(n) { return this.$val.roundUp(n); }; + decimal.ptr.prototype.roundDown = function(n) { + var n, x; + x = this; + if (n < 0 || n >= x.mant.$length) { + return; + } + x.mant = $subslice(x.mant, 0, n); + trim(x); + }; + decimal.prototype.roundDown = function(n) { return this.$val.roundDown(n); }; + trim = function(x) { + var i, x, x$1, x$2; + i = x.mant.$length; + while (true) { + if (!(i > 0 && ((x$1 = x.mant, x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === 48))) { break; } + i = i - (1) >> 0; + } + x.mant = $subslice(x.mant, 0, i); + if (i === 0) { + x.exp = 0; + } + }; + ErrNaN.ptr.prototype.Error = function() { + var err; + err = this; + return err.msg; + }; + ErrNaN.prototype.Error = function() { return this.$val.Error(); }; + NewFloat = function(x) { + var _r$1, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (math.IsNaN(x)) { + $panic((x$1 = new ErrNaN.ptr("NewFloat(NaN)"), new x$1.constructor.elem(x$1))); + } + _r$1 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetFloat64(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewFloat }; } $f._r$1 = _r$1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewFloat = NewFloat; + Float.ptr.prototype.SetPrec = function(prec) { + var old, prec, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; old = $f.old; prec = $f.prec; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + z.acc = 0; + if (prec === 0) { + z.prec = 0; + if (z.form === 1) { + z.acc = makeAcc(z.neg); + z.form = 0; + } + $s = -1; return z; + } + if (prec > 4294967295) { + prec = 4294967295; + } + old = z.prec; + z.prec = ((prec >>> 0)); + /* */ if (z.prec < old) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (z.prec < old) { */ case 1: + $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetPrec }; } $f.old = old; $f.prec = prec; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetPrec = function(prec) { return this.$val.SetPrec(prec); }; + makeAcc = function(above) { + var above; + if (above) { + return 1; + } + return -1; + }; + Float.ptr.prototype.SetMode = function(mode) { + var mode, z; + z = this; + z.mode = mode; + z.acc = 0; + return z; + }; + Float.prototype.SetMode = function(mode) { return this.$val.SetMode(mode); }; + Float.ptr.prototype.Prec = function() { + var x; + x = this; + return ((x.prec >>> 0)); + }; + Float.prototype.Prec = function() { return this.$val.Prec(); }; + Float.ptr.prototype.MinPrec = function() { + var x; + x = this; + if (!((x.form === 1))) { + return 0; + } + return (((x.mant.$length >>> 0)) * 32 >>> 0) - x.mant.trailingZeroBits() >>> 0; + }; + Float.prototype.MinPrec = function() { return this.$val.MinPrec(); }; + Float.ptr.prototype.Mode = function() { + var x; + x = this; + return x.mode; + }; + Float.prototype.Mode = function() { return this.$val.Mode(); }; + Float.ptr.prototype.Acc = function() { + var x; + x = this; + return x.acc; + }; + Float.prototype.Acc = function() { return this.$val.Acc(); }; + Float.ptr.prototype.Sign = function() { + var x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (x.form === 0) { + $s = -1; return 0; + } + if (x.neg) { + $s = -1; return -1; + } + $s = -1; return 1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sign }; } $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Sign = function() { return this.$val.Sign(); }; + Float.ptr.prototype.MantExp = function(mant) { + var _r$1, exp, mant, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; exp = $f.exp; mant = $f.mant; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + exp = 0; + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (x.form === 1) { + exp = ((x.exp >> 0)); + } + /* */ if (!(mant === ptrType.nil)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(mant === ptrType.nil)) { */ case 4: + _r$1 = mant.Copy(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + if (mant.form === 1) { + mant.exp = 0; + } + /* } */ case 5: + $s = -1; return exp; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.MantExp }; } $f._r$1 = _r$1; $f.exp = exp; $f.mant = mant; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.MantExp = function(mant) { return this.$val.MantExp(mant); }; + Float.ptr.prototype.setExpAndRound = function(exp, sbit) { + var exp, sbit, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; exp = $f.exp; sbit = $f.sbit; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if ((exp.$high < -1 || (exp.$high === -1 && exp.$low < 2147483648))) { + z.acc = makeAcc(z.neg); + z.form = 0; + $s = -1; return; + } + if ((exp.$high > 0 || (exp.$high === 0 && exp.$low > 2147483647))) { + z.acc = makeAcc(!z.neg); + z.form = 2; + $s = -1; return; + } + z.form = 1; + z.exp = (((exp.$low + ((exp.$high >> 31) * 4294967296)) >> 0)); + $r = z.round(sbit); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.setExpAndRound }; } $f.exp = exp; $f.sbit = sbit; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.setExpAndRound = function(exp, sbit) { return this.$val.setExpAndRound(exp, sbit); }; + Float.ptr.prototype.SetMantExp = function(mant, exp) { + var _r$1, exp, mant, x, x$1, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; exp = $f.exp; mant = $f.mant; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = z.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = mant.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _r$1 = z.Copy(mant); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + if (!((z.form === 1))) { + $s = -1; return z; + } + $r = z.setExpAndRound((x = (new $Int64(0, z.exp)), x$1 = (new $Int64(0, exp)), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)), 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetMantExp }; } $f._r$1 = _r$1; $f.exp = exp; $f.mant = mant; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetMantExp = function(mant, exp) { return this.$val.SetMantExp(mant, exp); }; + Float.ptr.prototype.Signbit = function() { + var x; + x = this; + return x.neg; + }; + Float.prototype.Signbit = function() { return this.$val.Signbit(); }; + Float.ptr.prototype.IsInf = function() { + var x; + x = this; + return x.form === 2; + }; + Float.prototype.IsInf = function() { return this.$val.IsInf(); }; + Float.ptr.prototype.IsInt = function() { + var x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (!((x.form === 1))) { + $s = -1; return x.form === 0; + } + if (x.exp <= 0) { + $s = -1; return false; + } + $s = -1; return x.prec <= ((x.exp >>> 0)) || x.MinPrec() <= ((x.exp >>> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.IsInt }; } $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.IsInt = function() { return this.$val.IsInt(); }; + Float.ptr.prototype.validate = function() { + var _arg, _arg$1, _r$1, _r$2, m, x, x$1, x$2, x$3, x$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; m = $f.m; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (true) { + $panic(new $String("validate called but debugFloat is not set")); + } + if (!((x.form === 1))) { + $s = -1; return; + } + m = x.mant.$length; + if (m === 0) { + $panic(new $String("nonzero finite number with empty mantissa")); + } + /* */ if ((((x$1 = x.mant, x$2 = m - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) & 2147483648) >>> 0) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((((x$1 = x.mant, x$2 = m - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) & 2147483648) >>> 0) === 0) { */ case 1: + _arg = new Word((x$3 = x.mant, x$4 = m - 1 >> 0, ((x$4 < 0 || x$4 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + x$4]))); + _r$1 = x.Text(112, 0); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$1 = new $String(_r$1); + _r$2 = fmt.Sprintf("msb not set in last word %#x of %s", new sliceType([_arg, _arg$1])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $panic(new $String(_r$2)); + /* } */ case 2: + if (x.prec === 0) { + $panic(new $String("zero precision finite number")); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.validate }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.m = m; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.validate = function() { return this.$val.validate(); }; + Float.ptr.prototype.round = function(sbit) { + var _1, _index, _q, bits$1, inc, lsb, m, n, ntz, r, rbit, sbit, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _index = $f._index; _q = $f._q; bits$1 = $f.bits$1; inc = $f.inc; lsb = $f.lsb; m = $f.m; n = $f.n; ntz = $f.ntz; r = $f.r; rbit = $f.rbit; sbit = $f.sbit; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = z.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + z.acc = 0; + if (!((z.form === 1))) { + $s = -1; return; + } + m = ((z.mant.$length >>> 0)); + bits$1 = $imul(m, 32) >>> 0; + if (bits$1 <= z.prec) { + $s = -1; return; + } + r = ((((bits$1 - z.prec >>> 0) - 1 >>> 0) >>> 0)); + rbit = (z.mant.bit(r) & 1) >>> 0; + if ((sbit === 0) && ((rbit === 0) || (z.mode === 0))) { + sbit = z.mant.sticky(r); + } + sbit = (sbit & (1)) >>> 0; + n = (_q = ((z.prec + 31 >>> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + if (m > n) { + $copySlice(z.mant, $subslice(z.mant, (m - n >>> 0))); + z.mant = $subslice(z.mant, 0, n); + } + ntz = ($imul(n, 32) >>> 0) - z.prec >>> 0; + lsb = (y = ntz, y < 32 ? (1 << y) : 0) >>> 0; + if (!((((rbit | sbit) >>> 0) === 0))) { + inc = false; + _1 = z.mode; + if (_1 === (4)) { + inc = z.neg; + } else if (_1 === (2)) { + } else if (_1 === (0)) { + inc = !((rbit === 0)) && (!((sbit === 0)) || !(((((x = z.mant, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) & lsb) >>> 0) === 0))); + } else if (_1 === (1)) { + inc = !((rbit === 0)); + } else if (_1 === (3)) { + inc = true; + } else if (_1 === (5)) { + inc = !z.neg; + } else { + $panic(new $String("unreachable")); + } + z.acc = makeAcc(!(inc === z.neg)); + if (inc) { + if (!((addVW((x$1 = z.mant, $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (x$2 = z.mant, $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), lsb) === 0))) { + if (z.exp >= 2147483647) { + z.form = 2; + $s = -1; return; + } + z.exp = z.exp + (1) >> 0; + shrVU((x$3 = z.mant, $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = z.mant, $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), 1); + _index = n - 1 >>> 0; + (x$6 = z.mant, ((_index < 0 || _index >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + _index] = (((x$5 = z.mant, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index])) | (2147483648)) >>> 0))); + } + } + } + (x$8 = z.mant, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0] = (((x$7 = z.mant, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])) & ~((lsb - 1 >>> 0))) >>> 0))); + /* */ if (false) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (false) { */ case 4: + $r = z.validate(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.round }; } $f._1 = _1; $f._index = _index; $f._q = _q; $f.bits$1 = bits$1; $f.inc = inc; $f.lsb = lsb; $f.m = m; $f.n = n; $f.ntz = ntz; $f.r = r; $f.rbit = rbit; $f.sbit = sbit; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.round = function(sbit) { return this.$val.round(sbit); }; + Float.ptr.prototype.setBits64 = function(neg, x) { + var neg, s, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; neg = $f.neg; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (z.prec === 0) { + z.prec = 64; + } + z.acc = 0; + z.neg = neg; + if ((x.$high === 0 && x.$low === 0)) { + z.form = 0; + $s = -1; return z; + } + z.form = 1; + s = bits.LeadingZeros64(x); + z.mant = z.mant.setUint64($shiftLeft64(x, ((s >>> 0)))); + z.exp = (((64 - s >> 0) >> 0)); + /* */ if (z.prec < 64) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (z.prec < 64) { */ case 1: + $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.setBits64 }; } $f.neg = neg; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.setBits64 = function(neg, x) { return this.$val.setBits64(neg, x); }; + Float.ptr.prototype.SetUint64 = function(x) { + var _r$1, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.setBits64(false, x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetUint64 }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetUint64 = function(x) { return this.$val.SetUint64(x); }; + Float.ptr.prototype.SetInt64 = function(x) { + var _r$1, u, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; u = $f.u; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + u = x; + if ((u.$high < 0 || (u.$high === 0 && u.$low < 0))) { + u = new $Int64(-u.$high, -u.$low); + } + _r$1 = z.setBits64((x.$high < 0 || (x.$high === 0 && x.$low < 0)), (new $Uint64(u.$high, u.$low))); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetInt64 }; } $f._r$1 = _r$1; $f.u = u; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; + Float.ptr.prototype.SetFloat64 = function(x) { + var _tuple, exp, fmant, x, x$1, x$2, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; exp = $f.exp; fmant = $f.fmant; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (z.prec === 0) { + z.prec = 53; + } + if (math.IsNaN(x)) { + $panic((x$1 = new ErrNaN.ptr("Float.SetFloat64(NaN)"), new x$1.constructor.elem(x$1))); + } + z.acc = 0; + z.neg = math.Signbit(x); + if (x === 0) { + z.form = 0; + $s = -1; return z; + } + if (math.IsInf(x, 0)) { + z.form = 2; + $s = -1; return z; + } + z.form = 1; + _tuple = math.Frexp(x); + fmant = _tuple[0]; + exp = _tuple[1]; + z.mant = z.mant.setUint64((x$2 = $shiftLeft64(math.Float64bits(fmant), 11), new $Uint64(2147483648 | x$2.$high, (0 | x$2.$low) >>> 0))); + z.exp = ((exp >> 0)); + /* */ if (z.prec < 53) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (z.prec < 53) { */ case 1: + $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetFloat64 }; } $f._tuple = _tuple; $f.exp = exp; $f.fmant = fmant; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetFloat64 = function(x) { return this.$val.SetFloat64(x); }; + fnorm = function(m) { + var c, m, s, x, x$1; + if (false && ((m.$length === 0) || ((x = m.$length - 1 >> 0, ((x < 0 || x >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x])) === 0))) { + $panic(new $String("msw of mantissa is 0")); + } + s = nlz((x$1 = m.$length - 1 >> 0, ((x$1 < 0 || x$1 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$1]))); + if (s > 0) { + c = shlVU($subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), s); + if (false && !((c === 0))) { + $panic(new $String("nlz or shlVU incorrect")); + } + } + return (new $Int64(0, s)); + }; + Float.ptr.prototype.SetInt = function(x) { + var bits$1, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; bits$1 = $f.bits$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + bits$1 = ((x.BitLen() >>> 0)); + if (z.prec === 0) { + z.prec = umax32(bits$1, 64); + } + z.acc = 0; + z.neg = x.neg; + if (x.abs.$length === 0) { + z.form = 0; + $s = -1; return z; + } + z.mant = z.mant.set(x.abs); + fnorm(z.mant); + $r = z.setExpAndRound((new $Int64(0, bits$1)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetInt }; } $f.bits$1 = bits$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; + Float.ptr.prototype.SetRat = function(x) { + var _r$1, _r$2, _r$3, _r$4, _tmp, _tmp$1, a, b, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + b = [b]; + z = this; + /* */ if (x.IsInt()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (x.IsInt()) { */ case 1: + _r$1 = z.SetInt(x.Num()); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + _tmp = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + _tmp$1 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + a[0] = $clone(_tmp, Float); + b[0] = $clone(_tmp$1, Float); + _r$2 = a[0].SetInt(x.Num()); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + _r$3 = b[0].SetInt(x.Denom()); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + if (z.prec === 0) { + z.prec = umax32(a[0].prec, b[0].prec); + } + _r$4 = z.Quo(a[0], b[0]); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetRat }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetRat = function(x) { return this.$val.SetRat(x); }; + Float.ptr.prototype.SetInf = function(signbit) { + var signbit, z; + z = this; + z.acc = 0; + z.form = 2; + z.neg = signbit; + return z; + }; + Float.prototype.SetInf = function(signbit) { return this.$val.SetInf(signbit); }; + Float.ptr.prototype.Set = function(x) { + var x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + z.acc = 0; + /* */ if (!(z === x)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(z === x)) { */ case 4: + z.form = x.form; + z.neg = x.neg; + if (x.form === 1) { + z.exp = x.exp; + z.mant = z.mant.set(x.mant); + } + /* */ if (z.prec === 0) { $s = 6; continue; } + /* */ if (z.prec < x.prec) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (z.prec === 0) { */ case 6: + z.prec = x.prec; + $s = 8; continue; + /* } else if (z.prec < x.prec) { */ case 7: + $r = z.round(0); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + /* } */ case 5: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Set }; } $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Set = function(x) { return this.$val.Set(x); }; + Float.ptr.prototype.Copy = function(x) { + var x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (!(z === x)) { + z.prec = x.prec; + z.mode = x.mode; + z.acc = x.acc; + z.form = x.form; + z.neg = x.neg; + if (z.form === 1) { + z.mant = z.mant.set(x.mant); + z.exp = x.exp; + } + } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Copy }; } $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Copy = function(x) { return this.$val.Copy(x); }; + msb32 = function(x) { + var _1, i, x; + i = x.$length - 1 >> 0; + if (i < 0) { + return 0; + } + if (false && (((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & 2147483648) >>> 0) === 0)) { + $panic(new $String("x not normalized")); + } + _1 = 32; + if (_1 === (32)) { + return ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0)); + } else if (_1 === (64)) { + return ((0 >>> 0)); + } + $panic(new $String("unreachable")); + }; + msb64 = function(x) { + var _1, i, v, x, x$1, x$2, x$3, x$4, x$5; + i = x.$length - 1 >> 0; + if (i < 0) { + return new $Uint64(0, 0); + } + if (false && (((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & 2147483648) >>> 0) === 0)) { + $panic(new $String("x not normalized")); + } + _1 = 32; + if (_1 === (32)) { + v = $shiftLeft64(((x$1 = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), new $Uint64(0, x$1.constructor === Number ? x$1 : 1))), 32); + if (i > 0) { + v = (x$2 = ((x$3 = (x$4 = i - 1 >> 0, ((x$4 < 0 || x$4 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$4])), new $Uint64(0, x$3.constructor === Number ? x$3 : 1))), new $Uint64(v.$high | x$2.$high, (v.$low | x$2.$low) >>> 0)); + } + return v; + } else if (_1 === (64)) { + return ((x$5 = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), new $Uint64(0, x$5.constructor === Number ? x$5 : 1))); + } + $panic(new $String("unreachable")); + }; + Float.ptr.prototype.Uint64 = function() { + var _1, u, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; u = $f.u; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _1 = x.form; + if (_1 === (1)) { + if (x.neg) { + $s = -1; return [new $Uint64(0, 0), 1]; + } + if (x.exp <= 0) { + $s = -1; return [new $Uint64(0, 0), -1]; + } + if (x.exp <= 64) { + u = $shiftRightUint64(msb64(x.mant), ((64 - ((x.exp >>> 0)) >>> 0))); + if (x.MinPrec() <= 64) { + $s = -1; return [u, 0]; + } + $s = -1; return [u, -1]; + } + $s = -1; return [new $Uint64(4294967295, 4294967295), -1]; + } else if (_1 === (0)) { + $s = -1; return [new $Uint64(0, 0), 0]; + } else if (_1 === (2)) { + if (x.neg) { + $s = -1; return [new $Uint64(0, 0), 1]; + } + $s = -1; return [new $Uint64(4294967295, 4294967295), -1]; + } + $panic(new $String("unreachable")); + $s = -1; return [new $Uint64(0, 0), 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Uint64 }; } $f._1 = _1; $f.u = u; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Float.ptr.prototype.Int64 = function() { + var _1, acc, i, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; acc = $f.acc; i = $f.i; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _1 = x.form; + if (_1 === (1)) { + acc = makeAcc(x.neg); + if (x.exp <= 0) { + $s = -1; return [new $Int64(0, 0), acc]; + } + if (x.exp <= 63) { + i = ((x$1 = $shiftRightUint64(msb64(x.mant), ((64 - ((x.exp >>> 0)) >>> 0))), new $Int64(x$1.$high, x$1.$low))); + if (x.neg) { + i = new $Int64(-i.$high, -i.$low); + } + if (x.MinPrec() <= ((x.exp >>> 0))) { + $s = -1; return [i, 0]; + } + $s = -1; return [i, acc]; + } + if (x.neg) { + if ((x.exp === 64) && (x.MinPrec() === 1)) { + acc = 0; + } + $s = -1; return [new $Int64(-2147483648, 0), acc]; + } + $s = -1; return [new $Int64(2147483647, 4294967295), -1]; + } else if (_1 === (0)) { + $s = -1; return [new $Int64(0, 0), 0]; + } else if (_1 === (2)) { + if (x.neg) { + $s = -1; return [new $Int64(-2147483648, 0), 1]; + } + $s = -1; return [new $Int64(2147483647, 4294967295), -1]; + } + $panic(new $String("unreachable")); + $s = -1; return [new $Int64(0, 0), 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Int64 }; } $f._1 = _1; $f.acc = acc; $f.i = i; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Int64 = function() { return this.$val.Int64(); }; + Float.ptr.prototype.Float32 = function() { + var _1, _r$1, _tmp, _tmp$1, _tmp$2, bexp, e, mant, p, r, sign, x, y, z, z$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; bexp = $f.bexp; e = $f.e; mant = $f.mant; p = $f.p; r = $f.r; sign = $f.sign; x = $f.x; y = $f.y; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _1 = x.form; + /* */ if (_1 === (1)) { $s = 5; continue; } + /* */ if (_1 === (0)) { $s = 6; continue; } + /* */ if (_1 === (2)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_1 === (1)) { */ case 5: + e = x.exp - 1 >> 0; + p = 24; + if (e < -126) { + p = 150 + ((e >> 0)) >> 0; + if (p < 0 || (p === 0) && (x.mant.sticky((((x.mant.$length >>> 0)) * 32 >>> 0) - 1 >>> 0) === 0)) { + if (x.neg) { + z = 0; + $s = -1; return [-z, 1]; + } + $s = -1; return [0, -1]; + } + if (p === 0) { + if (x.neg) { + $s = -1; return [-1.401298464324817e-45, -1]; + } + $s = -1; return [1.401298464324817e-45, 1]; + } + } + r = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + r.prec = ((p >>> 0)); + _r$1 = r.Set(x); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + e = r.exp - 1 >> 0; + if ((r.form === 2) || e > 127) { + if (x.neg) { + $s = -1; return [($fround(math.Inf(-1))), -1]; + } + $s = -1; return [($fround(math.Inf(1))), 1]; + } + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = 0; + sign = _tmp; + bexp = _tmp$1; + mant = _tmp$2; + if (x.neg) { + sign = 2147483648; + } + if (e < -126) { + p = 150 + ((e >> 0)) >> 0; + mant = (y = (((32 - p >> 0) >>> 0)), y < 32 ? (msb32(r.mant) >>> y) : 0) >>> 0; + } else { + bexp = (((e + 127 >> 0) >>> 0)) << 23 >>> 0; + mant = ((msb32(r.mant) >>> 8 >>> 0) & 8388607) >>> 0; + } + $s = -1; return [math.Float32frombits((((sign | bexp) >>> 0) | mant) >>> 0), r.acc]; + /* } else if (_1 === (0)) { */ case 6: + if (x.neg) { + z$1 = 0; + $s = -1; return [-z$1, 0]; + } + $s = -1; return [0, 0]; + /* } else if (_1 === (2)) { */ case 7: + if (x.neg) { + $s = -1; return [($fround(math.Inf(-1))), 0]; + } + $s = -1; return [($fround(math.Inf(1))), 0]; + /* } */ case 8: + case 4: + $panic(new $String("unreachable")); + $s = -1; return [0, 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Float32 }; } $f._1 = _1; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.bexp = bexp; $f.e = e; $f.mant = mant; $f.p = p; $f.r = r; $f.sign = sign; $f.x = x; $f.y = y; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Float32 = function() { return this.$val.Float32(); }; + Float.ptr.prototype.Float64 = function() { + var _1, _r$1, _tmp, _tmp$1, _tmp$2, bexp, e, mant, p, r, sign, x, x$1, x$2, z, z$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; bexp = $f.bexp; e = $f.e; mant = $f.mant; p = $f.p; r = $f.r; sign = $f.sign; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _1 = x.form; + /* */ if (_1 === (1)) { $s = 5; continue; } + /* */ if (_1 === (0)) { $s = 6; continue; } + /* */ if (_1 === (2)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_1 === (1)) { */ case 5: + e = x.exp - 1 >> 0; + p = 53; + if (e < -1022) { + p = 1075 + ((e >> 0)) >> 0; + if (p < 0 || (p === 0) && (x.mant.sticky((((x.mant.$length >>> 0)) * 32 >>> 0) - 1 >>> 0) === 0)) { + if (x.neg) { + z = 0; + $s = -1; return [-z, 1]; + } + $s = -1; return [0, -1]; + } + if (p === 0) { + if (x.neg) { + $s = -1; return [-5e-324, -1]; + } + $s = -1; return [5e-324, 1]; + } + } + r = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + r.prec = ((p >>> 0)); + _r$1 = r.Set(x); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + e = r.exp - 1 >> 0; + if ((r.form === 2) || e > 1023) { + if (x.neg) { + $s = -1; return [math.Inf(-1), -1]; + } + $s = -1; return [math.Inf(1), 1]; + } + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + _tmp$2 = new $Uint64(0, 0); + sign = _tmp; + bexp = _tmp$1; + mant = _tmp$2; + if (x.neg) { + sign = new $Uint64(2147483648, 0); + } + if (e < -1022) { + p = 1075 + ((e >> 0)) >> 0; + mant = $shiftRightUint64(msb64(r.mant), (((64 - p >> 0) >>> 0))); + } else { + bexp = $shiftLeft64((new $Uint64(0, (e + 1023 >> 0))), 52); + mant = (x$1 = $shiftRightUint64(msb64(r.mant), 11), new $Uint64(x$1.$high & 1048575, (x$1.$low & 4294967295) >>> 0)); + } + $s = -1; return [math.Float64frombits((x$2 = new $Uint64(sign.$high | bexp.$high, (sign.$low | bexp.$low) >>> 0), new $Uint64(x$2.$high | mant.$high, (x$2.$low | mant.$low) >>> 0))), r.acc]; + /* } else if (_1 === (0)) { */ case 6: + if (x.neg) { + z$1 = 0; + $s = -1; return [-z$1, 0]; + } + $s = -1; return [0, 0]; + /* } else if (_1 === (2)) { */ case 7: + if (x.neg) { + $s = -1; return [math.Inf(-1), 0]; + } + $s = -1; return [math.Inf(1), 0]; + /* } */ case 8: + case 4: + $panic(new $String("unreachable")); + $s = -1; return [0, 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Float64 }; } $f._1 = _1; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.bexp = bexp; $f.e = e; $f.mant = mant; $f.p = p; $f.r = r; $f.sign = sign; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Float64 = function() { return this.$val.Float64(); }; + Float.ptr.prototype.Int = function(z) { + var _1, acc, allBits, exp, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; acc = $f.acc; allBits = $f.allBits; exp = $f.exp; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z === ptrType$1.nil && x.form <= 1) { + z = new Int.ptr(false, nat.nil); + } + _1 = x.form; + if (_1 === (1)) { + acc = makeAcc(x.neg); + if (x.exp <= 0) { + $s = -1; return [z.SetInt64(new $Int64(0, 0)), acc]; + } + allBits = ((x.mant.$length >>> 0)) * 32 >>> 0; + exp = ((x.exp >>> 0)); + if (x.MinPrec() <= exp) { + acc = 0; + } + if (z === ptrType$1.nil) { + z = new Int.ptr(false, nat.nil); + } + z.neg = x.neg; + if (exp > allBits) { + z.abs = z.abs.shl(x.mant, exp - allBits >>> 0); + } else if (exp < allBits) { + z.abs = z.abs.shr(x.mant, allBits - exp >>> 0); + } else { + z.abs = z.abs.set(x.mant); + } + $s = -1; return [z, acc]; + } else if (_1 === (0)) { + $s = -1; return [z.SetInt64(new $Int64(0, 0)), 0]; + } else if (_1 === (2)) { + $s = -1; return [ptrType$1.nil, makeAcc(x.neg)]; + } + $panic(new $String("unreachable")); + $s = -1; return [ptrType$1.nil, 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Int }; } $f._1 = _1; $f.acc = acc; $f.allBits = allBits; $f.exp = exp; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Int = function(z) { return this.$val.Int(z); }; + Float.ptr.prototype.Rat = function(z) { + var _1, _r$1, allBits, t, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; allBits = $f.allBits; t = $f.t; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z === ptrType$2.nil && x.form <= 1) { + z = new Rat.ptr(new Int.ptr(false, nat.nil), new Int.ptr(false, nat.nil)); + } + _1 = x.form; + /* */ if (_1 === (1)) { $s = 5; continue; } + /* */ if (_1 === (0)) { $s = 6; continue; } + /* */ if (_1 === (2)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_1 === (1)) { */ case 5: + allBits = $imul(((x.mant.$length >> 0)), 32); + z.a.neg = x.neg; + /* */ if (x.exp > allBits) { $s = 10; continue; } + /* */ if (x.exp < allBits) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (x.exp > allBits) { */ case 10: + z.a.abs = z.a.abs.shl(x.mant, (((x.exp - allBits >> 0) >>> 0))); + z.b.abs = $subslice(z.b.abs, 0, 0); + $s = 13; continue; + /* } else if (x.exp < allBits) { */ case 11: + z.a.abs = z.a.abs.set(x.mant); + t = z.b.abs.setUint64(new $Uint64(0, 1)); + z.b.abs = t.shl(t, (((allBits - x.exp >> 0) >>> 0))); + _r$1 = z.norm(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = 13; continue; + /* } else { */ case 12: + z.a.abs = z.a.abs.set(x.mant); + z.b.abs = $subslice(z.b.abs, 0, 0); + /* } */ case 13: + case 9: + $s = -1; return [z, 0]; + /* } else if (_1 === (0)) { */ case 6: + $s = -1; return [z.SetInt64(new $Int64(0, 0)), 0]; + /* } else if (_1 === (2)) { */ case 7: + $s = -1; return [ptrType$2.nil, makeAcc(x.neg)]; + /* } */ case 8: + case 4: + $panic(new $String("unreachable")); + $s = -1; return [ptrType$2.nil, 0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Rat }; } $f._1 = _1; $f._r$1 = _r$1; $f.allBits = allBits; $f.t = t; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Rat = function(z) { return this.$val.Rat(z); }; + Float.ptr.prototype.Abs = function(x) { + var _r$1, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.Set(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + z.neg = false; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Abs }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Abs = function(x) { return this.$val.Abs(x); }; + Float.ptr.prototype.Neg = function(x) { + var _r$1, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.Set(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + z.neg = !z.neg; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Neg }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Neg = function(x) { return this.$val.Neg(x); }; + validateBinaryOperands = function(x, y) { + var x, y; + if (true) { + $panic(new $String("validateBinaryOperands called but debugFloat is not set")); + } + if (x.mant.$length === 0) { + $panic(new $String("empty mantissa for x")); + } + if (y.mant.$length === 0) { + $panic(new $String("empty mantissa for y")); + } + }; + Float.ptr.prototype.uadd = function(x, y) { + var al, ex, ey, t, t$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; al = $f.al; ex = $f.ex; ey = $f.ey; t = $f.t; t$1 = $f.t$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (false) { + validateBinaryOperands(x, y); + } + ex = (x$1 = (new $Int64(0, x.exp)), x$2 = $mul64((new $Int64(0, x.mant.$length)), new $Int64(0, 32)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + ey = (x$3 = (new $Int64(0, y.exp)), x$4 = $mul64((new $Int64(0, y.mant.$length)), new $Int64(0, 32)), new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)); + al = alias(z.mant, x.mant) || alias(z.mant, y.mant); + if ((ex.$high < ey.$high || (ex.$high === ey.$high && ex.$low < ey.$low))) { + if (al) { + t = (nat.nil).shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); + z.mant = z.mant.add(x.mant, t); + } else { + z.mant = z.mant.shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); + z.mant = z.mant.add(x.mant, z.mant); + } + } else if ((ex.$high > ey.$high || (ex.$high === ey.$high && ex.$low > ey.$low))) { + if (al) { + t$1 = (nat.nil).shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); + z.mant = z.mant.add(t$1, y.mant); + } else { + z.mant = z.mant.shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); + z.mant = z.mant.add(z.mant, y.mant); + } + ex = ey; + } else { + z.mant = z.mant.add(x.mant, y.mant); + } + $r = z.setExpAndRound((x$5 = (x$6 = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), new $Int64(ex.$high + x$6.$high, ex.$low + x$6.$low)), x$7 = fnorm(z.mant), new $Int64(x$5.$high - x$7.$high, x$5.$low - x$7.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.uadd }; } $f.al = al; $f.ex = ex; $f.ey = ey; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.uadd = function(x, y) { return this.$val.uadd(x, y); }; + Float.ptr.prototype.usub = function(x, y) { + var al, ex, ey, t, t$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; al = $f.al; ex = $f.ex; ey = $f.ey; t = $f.t; t$1 = $f.t$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (false) { + validateBinaryOperands(x, y); + } + ex = (x$1 = (new $Int64(0, x.exp)), x$2 = $mul64((new $Int64(0, x.mant.$length)), new $Int64(0, 32)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + ey = (x$3 = (new $Int64(0, y.exp)), x$4 = $mul64((new $Int64(0, y.mant.$length)), new $Int64(0, 32)), new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)); + al = alias(z.mant, x.mant) || alias(z.mant, y.mant); + if ((ex.$high < ey.$high || (ex.$high === ey.$high && ex.$low < ey.$low))) { + if (al) { + t = (nat.nil).shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); + z.mant = t.sub(x.mant, t); + } else { + z.mant = z.mant.shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); + z.mant = z.mant.sub(x.mant, z.mant); + } + } else if ((ex.$high > ey.$high || (ex.$high === ey.$high && ex.$low > ey.$low))) { + if (al) { + t$1 = (nat.nil).shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); + z.mant = t$1.sub(t$1, y.mant); + } else { + z.mant = z.mant.shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); + z.mant = z.mant.sub(z.mant, y.mant); + } + ex = ey; + } else { + z.mant = z.mant.sub(x.mant, y.mant); + } + if (z.mant.$length === 0) { + z.acc = 0; + z.form = 0; + z.neg = false; + $s = -1; return; + } + $r = z.setExpAndRound((x$5 = (x$6 = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), new $Int64(ex.$high + x$6.$high, ex.$low + x$6.$low)), x$7 = fnorm(z.mant), new $Int64(x$5.$high - x$7.$high, x$5.$low - x$7.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.usub }; } $f.al = al; $f.ex = ex; $f.ey = ey; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.usub = function(x, y) { return this.$val.usub(x, y); }; + Float.ptr.prototype.umul = function(x, y) { + var e, x, x$1, x$2, x$3, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (false) { + validateBinaryOperands(x, y); + } + e = (x$1 = (new $Int64(0, x.exp)), x$2 = (new $Int64(0, y.exp)), new $Int64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)); + if (x === y) { + z.mant = z.mant.sqr(x.mant); + } else { + z.mant = z.mant.mul(x.mant, y.mant); + } + $r = z.setExpAndRound((x$3 = fnorm(z.mant), new $Int64(e.$high - x$3.$high, e.$low - x$3.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.umul }; } $f.e = e; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.umul = function(x, y) { return this.$val.umul(x, y); }; + Float.ptr.prototype.uquo = function(x, y) { + var _q, _r$1, _tuple, d, d$1, e, n, r, sbit, x, x$1, x$2, x$3, x$4, x$5, xadj, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _tuple = $f._tuple; d = $f.d; d$1 = $f.d$1; e = $f.e; n = $f.n; r = $f.r; sbit = $f.sbit; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; xadj = $f.xadj; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (false) { + validateBinaryOperands(x, y); + } + n = (((_q = z.prec / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) + 1 >> 0; + xadj = x.mant; + d = (n - x.mant.$length >> 0) + y.mant.$length >> 0; + if (d > 0) { + xadj = $makeSlice(nat, (x.mant.$length + d >> 0)); + $copySlice($subslice(xadj, d), x.mant); + } + d$1 = xadj.$length - y.mant.$length >> 0; + r = nat.nil; + _r$1 = z.mant.div(nat.nil, xadj, y.mant); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z.mant = _tuple[0]; + r = _tuple[1]; + e = (x$1 = (x$2 = (new $Int64(0, x.exp)), x$3 = (new $Int64(0, y.exp)), new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low)), x$4 = $mul64((new $Int64(0, (d$1 - z.mant.$length >> 0))), new $Int64(0, 32)), new $Int64(x$1.$high - x$4.$high, x$1.$low - x$4.$low)); + sbit = 0; + if (r.$length > 0) { + sbit = 1; + } + $r = z.setExpAndRound((x$5 = fnorm(z.mant), new $Int64(e.$high - x$5.$high, e.$low - x$5.$low)), sbit); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.uquo }; } $f._q = _q; $f._r$1 = _r$1; $f._tuple = _tuple; $f.d = d; $f.d$1 = d$1; $f.e = e; $f.n = n; $f.r = r; $f.sbit = sbit; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.xadj = xadj; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.uquo = function(x, y) { return this.$val.uquo(x, y); }; + Float.ptr.prototype.ucmp = function(y) { + var _tmp, _tmp$1, i, j, x, x$1, x$2, xm, y, ym; + x = this; + if (false) { + validateBinaryOperands(x, y); + } + if (x.exp < y.exp) { + return -1; + } else if (x.exp > y.exp) { + return 1; + } + i = x.mant.$length; + j = y.mant.$length; + while (true) { + if (!(i > 0 || j > 0)) { break; } + _tmp = 0; + _tmp$1 = 0; + xm = _tmp; + ym = _tmp$1; + if (i > 0) { + i = i - (1) >> 0; + xm = (x$1 = x.mant, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); + } + if (j > 0) { + j = j - (1) >> 0; + ym = (x$2 = y.mant, ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j])); + } + if (xm < ym) { + return -1; + } else if (xm > ym) { + return 1; + } + } + return 0; + }; + Float.prototype.ucmp = function(y) { return this.$val.ucmp(y); }; + Float.ptr.prototype.Add = function(x, y) { + var _r$1, _r$2, x, x$1, y, yneg, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; x$1 = $f.x$1; y = $f.y; yneg = $f.yneg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z.prec === 0) { + z.prec = umax32(x.prec, y.prec); + } + /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((x.form === 1) && (y.form === 1)) { */ case 5: + yneg = y.neg; + z.neg = x.neg; + /* */ if (x.neg === yneg) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (x.neg === yneg) { */ case 7: + $r = z.uadd(x, y); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 9; continue; + /* } else { */ case 8: + /* */ if (x.ucmp(y) > 0) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (x.ucmp(y) > 0) { */ case 11: + $r = z.usub(x, y); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 13; continue; + /* } else { */ case 12: + z.neg = !z.neg; + $r = z.usub(y, x); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 13: + /* } */ case 9: + if ((z.form === 0) && (z.mode === 4) && (z.acc === 0)) { + z.neg = true; + } + $s = -1; return z; + /* } */ case 6: + if ((x.form === 2) && (y.form === 2) && !(x.neg === y.neg)) { + z.acc = 0; + z.form = 0; + z.neg = false; + $panic((x$1 = new ErrNaN.ptr("addition of infinities with opposite signs"), new x$1.constructor.elem(x$1))); + } + if ((x.form === 0) && (y.form === 0)) { + z.acc = 0; + z.form = 0; + z.neg = x.neg && y.neg; + $s = -1; return z; + } + /* */ if ((x.form === 2) || (y.form === 0)) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if ((x.form === 2) || (y.form === 0)) { */ case 16: + _r$1 = z.Set(x); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 17: + _r$2 = z.Set(y); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Add }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.yneg = yneg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; + Float.ptr.prototype.Sub = function(x, y) { + var _r$1, _r$2, x, x$1, y, yneg, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; x$1 = $f.x$1; y = $f.y; yneg = $f.yneg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z.prec === 0) { + z.prec = umax32(x.prec, y.prec); + } + /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((x.form === 1) && (y.form === 1)) { */ case 5: + yneg = y.neg; + z.neg = x.neg; + /* */ if (!(x.neg === yneg)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!(x.neg === yneg)) { */ case 7: + $r = z.uadd(x, y); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 9; continue; + /* } else { */ case 8: + /* */ if (x.ucmp(y) > 0) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (x.ucmp(y) > 0) { */ case 11: + $r = z.usub(x, y); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 13; continue; + /* } else { */ case 12: + z.neg = !z.neg; + $r = z.usub(y, x); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 13: + /* } */ case 9: + if ((z.form === 0) && (z.mode === 4) && (z.acc === 0)) { + z.neg = true; + } + $s = -1; return z; + /* } */ case 6: + if ((x.form === 2) && (y.form === 2) && x.neg === y.neg) { + z.acc = 0; + z.form = 0; + z.neg = false; + $panic((x$1 = new ErrNaN.ptr("subtraction of infinities with equal signs"), new x$1.constructor.elem(x$1))); + } + if ((x.form === 0) && (y.form === 0)) { + z.acc = 0; + z.form = 0; + z.neg = x.neg && !y.neg; + $s = -1; return z; + } + /* */ if ((x.form === 2) || (y.form === 0)) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if ((x.form === 2) || (y.form === 0)) { */ case 16: + _r$1 = z.Set(x); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 17: + _r$2 = z.Neg(y); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sub }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.yneg = yneg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; + Float.ptr.prototype.Mul = function(x, y) { + var x, x$1, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z.prec === 0) { + z.prec = umax32(x.prec, y.prec); + } + z.neg = !(x.neg === y.neg); + /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((x.form === 1) && (y.form === 1)) { */ case 5: + $r = z.umul(x, y); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return z; + /* } */ case 6: + z.acc = 0; + if ((x.form === 0) && (y.form === 2) || (x.form === 2) && (y.form === 0)) { + z.form = 0; + z.neg = false; + $panic((x$1 = new ErrNaN.ptr("multiplication of zero with infinity"), new x$1.constructor.elem(x$1))); + } + if ((x.form === 2) || (y.form === 2)) { + z.form = 2; + $s = -1; return z; + } + z.form = 0; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Mul }; } $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; + Float.ptr.prototype.Quo = function(x, y) { + var x, x$1, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z.prec === 0) { + z.prec = umax32(x.prec, y.prec); + } + z.neg = !(x.neg === y.neg); + /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((x.form === 1) && (y.form === 1)) { */ case 5: + $r = z.uquo(x, y); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return z; + /* } */ case 6: + z.acc = 0; + if ((x.form === 0) && (y.form === 0) || (x.form === 2) && (y.form === 2)) { + z.form = 0; + z.neg = false; + $panic((x$1 = new ErrNaN.ptr("division of zero by zero or infinity by infinity"), new x$1.constructor.elem(x$1))); + } + if ((x.form === 0) || (y.form === 2)) { + z.form = 0; + $s = -1; return z; + } + z.form = 2; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Quo }; } $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; + Float.ptr.prototype.Cmp = function(y) { + var _1, mx, my, x, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; mx = $f.mx; my = $f.my; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + mx = x.ord(); + my = y.ord(); + if (mx < my) { + $s = -1; return -1; + } else if (mx > my) { + $s = -1; return 1; + } + _1 = mx; + if (_1 === (-1)) { + $s = -1; return y.ucmp(x); + } else if (_1 === (1)) { + $s = -1; return x.ucmp(y); + } + $s = -1; return 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Cmp }; } $f._1 = _1; $f.mx = mx; $f.my = my; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; + Float.ptr.prototype.ord = function() { + var _1, m, x; + x = this; + m = 0; + _1 = x.form; + if (_1 === (1)) { + m = 1; + } else if (_1 === (0)) { + return 0; + } else if (_1 === (2)) { + m = 2; + } + if (x.neg) { + m = -m; + } + return m; + }; + Float.prototype.ord = function() { return this.$val.ord(); }; + umax32 = function(x, y) { + var x, y; + if (x > y) { + return x; + } + return y; + }; + Float.ptr.prototype.SetString = function(s) { + var _r$1, _tuple, err, f, s, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; f = $f.f; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.Parse(s, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + f = _tuple[0]; + err = _tuple[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + $s = -1; return [f, true]; + } + $s = -1; return [ptrType.nil, false]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.SetString = function(s) { return this.$val.SetString(s); }; + Float.ptr.prototype.scan = function(r, base) { + var _1, _2, _arg, _arg$1, _arg$2, _arg$3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _tuple$2, b, base, d, ebase, err, exp, exp2, exp5, f, fcount, p, prec, r, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; b = $f.b; base = $f.base; d = $f.d; ebase = $f.ebase; err = $f.err; exp = $f.exp; exp2 = $f.exp2; exp5 = $f.exp5; f = $f.f; fcount = $f.fcount; p = $f.p; prec = $f.prec; r = $f.r; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = ptrType.nil; + b = 0; + err = $ifaceNil; + z = this; + prec = z.prec; + if (prec === 0) { + prec = 64; + } + z.form = 0; + _r$1 = scanSign(r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z.neg = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [f, b, err]; + } + fcount = 0; + _r$2 = z.mant.scan(r, base, true); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + z.mant = _tuple$1[0]; + b = _tuple$1[1]; + fcount = _tuple$1[2]; + err = _tuple$1[3]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [f, b, err]; + } + exp = new $Int64(0, 0); + ebase = 0; + _r$3 = scanExponent(r, true); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$2 = _r$3; + exp = _tuple$2[0]; + ebase = _tuple$2[1]; + err = _tuple$2[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [f, b, err]; + } + if (z.mant.$length === 0) { + z.prec = prec; + z.acc = 0; + z.form = 0; + f = z; + $s = -1; return [f, b, err]; + } + exp2 = (x = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), x$1 = fnorm(z.mant), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low)); + exp5 = new $Int64(0, 0); + if (fcount < 0) { + d = (new $Int64(0, fcount)); + _1 = b; + if (_1 === (10)) { + exp5 = d; + exp2 = (x$2 = d, new $Int64(exp2.$high + x$2.$high, exp2.$low + x$2.$low)); + } else if (_1 === (2)) { + exp2 = (x$3 = d, new $Int64(exp2.$high + x$3.$high, exp2.$low + x$3.$low)); + } else if (_1 === (16)) { + exp2 = (x$4 = $mul64(d, new $Int64(0, 4)), new $Int64(exp2.$high + x$4.$high, exp2.$low + x$4.$low)); + } else { + $panic(new $String("unexpected mantissa base")); + } + } + _2 = ebase; + if (_2 === (10)) { + exp5 = (x$5 = exp, new $Int64(exp5.$high + x$5.$high, exp5.$low + x$5.$low)); + exp2 = (x$6 = exp, new $Int64(exp2.$high + x$6.$high, exp2.$low + x$6.$low)); + } else if (_2 === (2)) { + exp2 = (x$7 = exp, new $Int64(exp2.$high + x$7.$high, exp2.$low + x$7.$low)); + } else { + $panic(new $String("unexpected exponent base")); + } + /* */ if ((-1 < exp2.$high || (-1 === exp2.$high && 2147483648 <= exp2.$low)) && (exp2.$high < 0 || (exp2.$high === 0 && exp2.$low <= 2147483647))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((-1 < exp2.$high || (-1 === exp2.$high && 2147483648 <= exp2.$low)) && (exp2.$high < 0 || (exp2.$high === 0 && exp2.$low <= 2147483647))) { */ case 4: + z.prec = prec; + z.form = 1; + z.exp = (((exp2.$low + ((exp2.$high >> 31) * 4294967296)) >> 0)); + f = z; + $s = 6; continue; + /* } else { */ case 5: + _r$4 = fmt.Errorf("exponent overflow", new sliceType([])); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + err = _r$4; + $s = -1; return [f, b, err]; + /* } */ case 6: + /* */ if ((exp5.$high === 0 && exp5.$low === 0)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if ((exp5.$high === 0 && exp5.$low === 0)) { */ case 8: + $r = z.round(0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return [f, b, err]; + /* } */ case 9: + _r$5 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetPrec(z.Prec() + 64 >>> 0); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + p = _r$5; + /* */ if ((exp5.$high < 0 || (exp5.$high === 0 && exp5.$low < 0))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((exp5.$high < 0 || (exp5.$high === 0 && exp5.$low < 0))) { */ case 12: + _arg = z; + _r$6 = p.pow5(((x$8 = new $Int64(-exp5.$high, -exp5.$low), new $Uint64(x$8.$high, x$8.$low)))); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$1 = _r$6; + _r$7 = z.Quo(_arg, _arg$1); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + $s = 14; continue; + /* } else { */ case 13: + _arg$2 = z; + _r$8 = p.pow5((new $Uint64(exp5.$high, exp5.$low))); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _arg$3 = _r$8; + _r$9 = z.Mul(_arg$2, _arg$3); /* */ $s = 18; case 18: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$9; + /* } */ case 14: + $s = -1; return [f, b, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.scan }; } $f._1 = _1; $f._2 = _2; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.b = b; $f.base = base; $f.d = d; $f.ebase = ebase; $f.err = err; $f.exp = exp; $f.exp2 = exp2; $f.exp5 = exp5; $f.f = f; $f.fcount = fcount; $f.p = p; $f.prec = prec; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.scan = function(r, base) { return this.$val.scan(r, base); }; + Float.ptr.prototype.pow5 = function(n) { + var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, f, n, x, x$1, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; f = $f.f; n = $f.n; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if ((n.$high < 0 || (n.$high === 0 && n.$low <= 27))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((n.$high < 0 || (n.$high === 0 && n.$low <= 27))) { */ case 1: + _r$1 = z.SetUint64((($flatten64(n) < 0 || $flatten64(n) >= pow5tab.length) ? ($throwRuntimeError("index out of range"), undefined) : pow5tab[$flatten64(n)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + _r$2 = z.SetUint64(pow5tab[27]); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + n = (x = new $Uint64(0, 27), new $Uint64(n.$high - x.$high, n.$low - x.$low)); + _r$3 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetPrec(z.Prec() + 64 >>> 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = _r$3.SetUint64(new $Uint64(0, 5)); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + f = _r$4; + /* while (true) { */ case 7: + /* if (!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { break; } */ if(!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { $s = 8; continue; } + /* */ if (!((x$1 = new $Uint64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 0)))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!((x$1 = new $Uint64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 0)))) { */ case 9: + _r$5 = z.Mul(z, f); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + /* } */ case 10: + _r$6 = f.Mul(f, f); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + n = $shiftRightUint64(n, (1)); + /* } */ $s = 7; continue; case 8: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.pow5 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.f = f; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.pow5 = function(n) { return this.$val.pow5(n); }; + Float.ptr.prototype.Parse = function(s, base) { + var _r$1, _r$2, _tuple, _tuple$1, b, base, ch, err, err2, f, r, s, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; base = $f.base; ch = $f.ch; err = $f.err; err2 = $f.err2; f = $f.f; r = $f.r; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = ptrType.nil; + b = 0; + err = $ifaceNil; + z = this; + if ((s.length === 3) && (s === "Inf" || s === "inf")) { + f = z.SetInf(false); + $s = -1; return [f, b, err]; + } + if ((s.length === 4) && ((s.charCodeAt(0) === 43) || (s.charCodeAt(0) === 45)) && ($substring(s, 1) === "Inf" || $substring(s, 1) === "inf")) { + f = z.SetInf(s.charCodeAt(0) === 45); + $s = -1; return [f, b, err]; + } + r = strings.NewReader(s); + _r$1 = z.scan(r, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + f = _tuple[0]; + b = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [f, b, err]; + } + _tuple$1 = r.ReadByte(); + ch = _tuple$1[0]; + err2 = _tuple$1[1]; + /* */ if ($interfaceIsEqual(err2, $ifaceNil)) { $s = 2; continue; } + /* */ if (!($interfaceIsEqual(err2, io.EOF))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($interfaceIsEqual(err2, $ifaceNil)) { */ case 2: + _r$2 = fmt.Errorf("expected end of string, found %q", new sliceType([new $Uint8(ch)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + err = _r$2; + $s = 4; continue; + /* } else if (!($interfaceIsEqual(err2, io.EOF))) { */ case 3: + err = err2; + /* } */ case 4: + $s = -1; return [f, b, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Parse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.base = base; $f.ch = ch; $f.err = err; $f.err2 = err2; $f.f = f; $f.r = r; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Parse = function(s, base) { return this.$val.Parse(s, base); }; + Float.ptr.prototype.Scan = function(s, ch) { + var _r$1, _tuple, ch, err, s, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; ch = $f.ch; err = $f.err; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + $r = s.SkipSpace(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$1 = z.scan((x = new byteReader.ptr(s), new x.constructor.elem(x)), 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + err = _tuple[2]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Scan }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; + Float.ptr.prototype.GobEncode = function() { + var _q, b, buf, n, sz, x; + x = this; + if (x === ptrType.nil) { + return [sliceType$1.nil, $ifaceNil]; + } + sz = 6; + n = 0; + if (x.form === 1) { + n = (((_q = ((x.prec + 31 >>> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + if (x.mant.$length < n) { + n = x.mant.$length; + } + sz = sz + ((4 + ($imul(n, 4)) >> 0)) >> 0; + } + buf = $makeSlice(sliceType$1, sz); + (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0] = 1); + b = ((((((((x.mode & 7) >>> 0) << 24 >>> 24)) << 5 << 24 >>> 24) | ((((((x.acc + 1 << 24 >> 24)) & 3) << 24 >>> 24)) << 3 << 24 >>> 24)) >>> 0) | (((((x.form & 3) >>> 0) << 24 >>> 24)) << 1 << 24 >>> 24)) >>> 0; + if (x.neg) { + b = (b | (1)) >>> 0; + } + (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1] = b); + $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, 2), x.prec); + if (x.form === 1) { + $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, 6), ((x.exp >>> 0))); + $subslice(x.mant, (x.mant.$length - n >> 0)).bytes($subslice(buf, 10)); + } + return [buf, $ifaceNil]; + }; + Float.prototype.GobEncode = function() { return this.$val.GobEncode(); }; + Float.ptr.prototype.GobDecode = function(buf) { + var _r$1, _r$2, b, buf, oldMode, oldPrec, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; b = $f.b; buf = $f.buf; oldMode = $f.oldMode; oldPrec = $f.oldPrec; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (buf.$length === 0) { + Float.copy(z, new Float.ptr(0, 0, 0, 0, false, nat.nil, 0)); + $s = -1; return $ifaceNil; + } + /* */ if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { */ case 1: + _r$1 = fmt.Errorf("Float.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + oldPrec = z.prec; + oldMode = z.mode; + b = (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]); + z.mode = ((((((b >>> 5 << 24 >>> 24)) & 7) >>> 0) << 24 >>> 24)); + z.acc = ((((((b >>> 3 << 24 >>> 24)) & 3) >>> 0) << 24 >> 24)) - 1 << 24 >> 24; + z.form = ((((((b >>> 1 << 24 >>> 24)) & 3) >>> 0) << 24 >>> 24)); + z.neg = !((((b & 1) >>> 0) === 0)); + z.prec = $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 2)); + if (z.form === 1) { + z.exp = (($clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 6)) >> 0)); + z.mant = z.mant.setBytes($subslice(buf, 10)); + } + /* */ if (!((oldPrec === 0))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!((oldPrec === 0))) { */ case 4: + z.mode = oldMode; + _r$2 = z.SetPrec(((oldPrec >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* } */ case 5: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.b = b; $f.buf = buf; $f.oldMode = oldMode; $f.oldPrec = oldPrec; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; + Float.ptr.prototype.MarshalText = function() { + var _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, buf, err, text, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; buf = $f.buf; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + text = sliceType$1.nil; + err = $ifaceNil; + x = this; + if (x === ptrType.nil) { + _tmp = (new sliceType$1($stringToBytes(""))); + _tmp$1 = $ifaceNil; + text = _tmp; + err = _tmp$1; + $s = -1; return [text, err]; + } + buf = sliceType$1.nil; + _r$1 = x.Append(buf, 103, -1); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tmp$2 = _r$1; + _tmp$3 = $ifaceNil; + text = _tmp$2; + err = _tmp$3; + $s = -1; return [text, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.buf = buf; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.MarshalText = function() { return this.$val.MarshalText(); }; + Float.ptr.prototype.UnmarshalText = function(text) { + var _r$1, _r$2, _tuple, err, text, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; err = $f.err; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.Parse(($bytesToString(text)), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + err = _tuple[2]; + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2: + _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", new sliceType([text, err])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + err = _r$2; + /* } */ case 3: + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.err = err; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; + Float.ptr.prototype.Text = function(format, prec) { + var _r$1, cap, format, prec, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; cap = $f.cap; format = $f.format; prec = $f.prec; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + cap = 10; + if (prec > 0) { + cap = cap + (prec) >> 0; + } + _r$1 = x.Append($makeSlice(sliceType$1, 0, cap), format, prec); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return ($bytesToString(_r$1)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Text }; } $f._r$1 = _r$1; $f.cap = cap; $f.format = format; $f.prec = prec; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Text = function(format, prec) { return this.$val.Text(format, prec); }; + Float.ptr.prototype.String = function() { + var _r$1, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = x.Text(103, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.String = function() { return this.$val.String(); }; + Float.ptr.prototype.Append = function(buf, fmt$1, prec) { + var _1, _2, _3, _4, _r$1, _r$2, buf, d, eprec, exp, fmt$1, prec, shortest, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; d = $f.d; eprec = $f.eprec; exp = $f.exp; fmt$1 = $f.fmt$1; prec = $f.prec; shortest = $f.shortest; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + d = [d]; + x = this; + if (x.neg) { + buf = $append(buf, 45); + } + if (x.form === 2) { + if (!x.neg) { + buf = $append(buf, 43); + } + $s = -1; return $appendSlice(buf, "Inf"); + } + _1 = fmt$1; + /* */ if (_1 === (98)) { $s = 2; continue; } + /* */ if (_1 === (112)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_1 === (98)) { */ case 2: + _r$1 = x.fmtB(buf); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } else if (_1 === (112)) { */ case 3: + _r$2 = x.fmtP(buf); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* } */ case 4: + case 1: + d[0] = new decimal.ptr(sliceType$1.nil, 0); + /* */ if (x.form === 1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (x.form === 1) { */ case 7: + $r = d[0].init(x.mant, ((x.exp >> 0)) - x.mant.bitLen() >> 0); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + shortest = false; + /* */ if (prec < 0) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (prec < 0) { */ case 10: + shortest = true; + $r = roundShortest(d[0], x); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _2 = fmt$1; + if ((_2 === (101)) || (_2 === (69))) { + prec = d[0].mant.$length - 1 >> 0; + } else if (_2 === (102)) { + prec = max(d[0].mant.$length - d[0].exp >> 0, 0); + } else if ((_2 === (103)) || (_2 === (71))) { + prec = d[0].mant.$length; + } + $s = 12; continue; + /* } else { */ case 11: + _3 = fmt$1; + if ((_3 === (101)) || (_3 === (69))) { + d[0].round(1 + prec >> 0); + } else if (_3 === (102)) { + d[0].round(d[0].exp + prec >> 0); + } else if ((_3 === (103)) || (_3 === (71))) { + if (prec === 0) { + prec = 1; + } + d[0].round(prec); + } + /* } */ case 12: + _4 = fmt$1; + if ((_4 === (101)) || (_4 === (69))) { + $s = -1; return fmtE(buf, fmt$1, prec, $clone(d[0], decimal)); + } else if (_4 === (102)) { + $s = -1; return fmtF(buf, prec, $clone(d[0], decimal)); + } else if ((_4 === (103)) || (_4 === (71))) { + eprec = prec; + if (eprec > d[0].mant.$length && d[0].mant.$length >= d[0].exp) { + eprec = d[0].mant.$length; + } + if (shortest) { + eprec = 6; + } + exp = d[0].exp - 1 >> 0; + if (exp < -4 || exp >= eprec) { + if (prec > d[0].mant.$length) { + prec = d[0].mant.$length; + } + $s = -1; return fmtE(buf, (fmt$1 + 101 << 24 >>> 24) - 103 << 24 >>> 24, prec - 1 >> 0, $clone(d[0], decimal)); + } + if (prec > d[0].exp) { + prec = d[0].mant.$length; + } + $s = -1; return fmtF(buf, max(prec - d[0].exp >> 0, 0), $clone(d[0], decimal)); + } + if (x.neg) { + buf = $subslice(buf, 0, (buf.$length - 1 >> 0)); + } + $s = -1; return $append(buf, 37, fmt$1); + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Append }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.d = d; $f.eprec = eprec; $f.exp = exp; $f.fmt$1 = fmt$1; $f.prec = prec; $f.shortest = shortest; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Append = function(buf, fmt$1, prec) { return this.$val.Append(buf, fmt$1, prec); }; + roundShortest = function(d, x) { + var _i, _ref, d, exp, i, inclusive, l, lower, m, mant, okdown, okup, s, tmp, u, upper, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _ref = $f._ref; d = $f.d; exp = $f.exp; i = $f.i; inclusive = $f.inclusive; l = $f.l; lower = $f.lower; m = $f.m; mant = $f.mant; okdown = $f.okdown; okup = $f.okup; s = $f.s; tmp = $f.tmp; u = $f.u; upper = $f.upper; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (d.mant.$length === 0) { + $s = -1; return; + } + mant = (nat.nil).set(x.mant); + exp = ((x.exp >> 0)) - mant.bitLen() >> 0; + s = mant.bitLen() - (((x.prec + 1 >>> 0) >> 0)) >> 0; + if (s < 0) { + mant = mant.shl(mant, ((-s >>> 0))); + } else if (s > 0) { + mant = mant.shr(mant, ((s >>> 0))); + } + exp = exp + (s) >> 0; + lower = new decimal.ptr(sliceType$1.nil, 0); + tmp = nat.nil; + $r = lower.init(tmp.sub(mant, natOne), exp); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + upper = new decimal.ptr(sliceType$1.nil, 0); + $r = upper.init(tmp.add(mant, natOne), exp); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + inclusive = (((0 >= mant.$length ? ($throwRuntimeError("index out of range"), undefined) : mant.$array[mant.$offset + 0]) & 2) >>> 0) === 0; + _ref = d.mant; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + m = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + l = lower.at(i); + u = upper.at(i); + okdown = !((l === m)) || inclusive && ((i + 1 >> 0) === lower.mant.$length); + okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.mant.$length); + if (okdown && okup) { + d.round(i + 1 >> 0); + $s = -1; return; + } else if (okdown) { + d.roundDown(i + 1 >> 0); + $s = -1; return; + } else if (okup) { + d.roundUp(i + 1 >> 0); + $s = -1; return; + } + _i++; + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: roundShortest }; } $f._i = _i; $f._ref = _ref; $f.d = d; $f.exp = exp; $f.i = i; $f.inclusive = inclusive; $f.l = l; $f.lower = lower; $f.m = m; $f.mant = mant; $f.okdown = okdown; $f.okup = okup; $f.s = s; $f.tmp = tmp; $f.u = u; $f.upper = upper; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + fmtE = function(buf, fmt$1, prec, d) { + var buf, ch, d, exp, fmt$1, i, m, prec, x, x$1; + ch = 48; + if (d.mant.$length > 0) { + ch = (x = d.mant, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + } + buf = $append(buf, ch); + if (prec > 0) { + buf = $append(buf, 46); + i = 1; + m = min(d.mant.$length, prec + 1 >> 0); + if (i < m) { + buf = $appendSlice(buf, $subslice(d.mant, i, m)); + i = m; + } + while (true) { + if (!(i <= prec)) { break; } + buf = $append(buf, 48); + i = i + (1) >> 0; + } + } + buf = $append(buf, fmt$1); + exp = new $Int64(0, 0); + if (d.mant.$length > 0) { + exp = (x$1 = (new $Int64(0, d.exp)), new $Int64(x$1.$high - 0, x$1.$low - 1)); + } + if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { + ch = 45; + exp = new $Int64(-exp.$high, -exp.$low); + } else { + ch = 43; + } + buf = $append(buf, ch); + if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 10))) { + buf = $append(buf, 48); + } + return strconv.AppendInt(buf, exp, 10); + }; + fmtF = function(buf, prec, d) { + var buf, d, i, m, prec; + if (d.exp > 0) { + m = min(d.mant.$length, d.exp); + buf = $appendSlice(buf, $subslice(d.mant, 0, m)); + while (true) { + if (!(m < d.exp)) { break; } + buf = $append(buf, 48); + m = m + (1) >> 0; + } + } else { + buf = $append(buf, 48); + } + if (prec > 0) { + buf = $append(buf, 46); + i = 0; + while (true) { + if (!(i < prec)) { break; } + buf = $append(buf, d.at(d.exp + i >> 0)); + i = i + (1) >> 0; + } + } + return buf; + }; + Float.ptr.prototype.fmtB = function(buf) { + var _arg, _arg$1, _r$1, buf, e, m, w, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; buf = $f.buf; e = $f.e; m = $f.m; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (x.form === 0) { + $s = -1; return $append(buf, 48); + } + if (false && !((x.form === 1))) { + $panic(new $String("non-finite float")); + } + m = x.mant; + w = $imul(((x.mant.$length >>> 0)), 32) >>> 0; + if (w < x.prec) { + m = (nat.nil).shl(m, (((x.prec - w >>> 0) >>> 0))); + } else if (w > x.prec) { + m = (nat.nil).shr(m, (((w - x.prec >>> 0) >>> 0))); + } + _arg = buf; + _r$1 = m.utoa(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$1 = _r$1; + buf = $appendSlice(_arg, _arg$1); + buf = $append(buf, 112); + e = (x$1 = (new $Int64(0, x.exp)), x$2 = (new $Int64(0, x.prec)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + if ((e.$high > 0 || (e.$high === 0 && e.$low >= 0))) { + buf = $append(buf, 43); + } + $s = -1; return strconv.AppendInt(buf, e, 10); + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.fmtB }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f.buf = buf; $f.e = e; $f.m = m; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.fmtB = function(buf) { return this.$val.fmtB(buf); }; + Float.ptr.prototype.fmtP = function(buf) { + var _arg, _arg$1, _r$1, _r$2, buf, i, m, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; i = $f.i; m = $f.m; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (x.form === 0) { + $s = -1; return $append(buf, 48); + } + if (false && !((x.form === 1))) { + $panic(new $String("non-finite float")); + } + m = x.mant; + i = 0; + while (true) { + if (!(i < m.$length && (((i < 0 || i >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + i]) === 0))) { break; } + i = i + (1) >> 0; + } + m = $subslice(m, i); + buf = $appendSlice(buf, "0x."); + _arg = buf; + _r$1 = m.utoa(16); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = bytes.TrimRight(_r$1, "0"); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _arg$1 = _r$2; + buf = $appendSlice(_arg, _arg$1); + buf = $append(buf, 112); + if (x.exp >= 0) { + buf = $append(buf, 43); + } + $s = -1; return strconv.AppendInt(buf, (new $Int64(0, x.exp)), 10); + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.fmtP }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.i = i; $f.m = m; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.fmtP = function(buf) { return this.$val.fmtP(buf); }; + min = function(x, y) { + var x, y; + if (x < y) { + return x; + } + return y; + }; + Float.ptr.prototype.Format = function(s, format) { + var _1, _arg, _arg$1, _arg$2, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, buf, format, hasPrec, hasWidth, padding, prec, s, sign, width, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; format = $f.format; hasPrec = $f.hasPrec; hasWidth = $f.hasWidth; padding = $f.padding; prec = $f.prec; s = $f.s; sign = $f.sign; width = $f.width; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = s.Precision(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + prec = _tuple[0]; + hasPrec = _tuple[1]; + if (!hasPrec) { + prec = 6; + } + _1 = format; + /* */ if ((_1 === (101)) || (_1 === (69)) || (_1 === (102)) || (_1 === (98)) || (_1 === (112))) { $s = 3; continue; } + /* */ if (_1 === (70)) { $s = 4; continue; } + /* */ if (_1 === (118)) { $s = 5; continue; } + /* */ if ((_1 === (103)) || (_1 === (71))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((_1 === (101)) || (_1 === (69)) || (_1 === (102)) || (_1 === (98)) || (_1 === (112))) { */ case 3: + $s = 8; continue; + /* } else if (_1 === (70)) { */ case 4: + format = 102; + $s = 8; continue; + /* } else if (_1 === (118)) { */ case 5: + format = 103; + if (!hasPrec) { + prec = -1; + } + $s = 8; continue; + /* } else if ((_1 === (103)) || (_1 === (71))) { */ case 6: + if (!hasPrec) { + prec = -1; + } + $s = 8; continue; + /* } else { */ case 7: + _arg = s; + _arg$1 = new $Int32(format); + _r$2 = x.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _arg$2 = new $String(_r$2); + _r$3 = fmt.Fprintf(_arg, "%%!%c(*big.Float=%s)", new sliceType([_arg$1, _arg$2])); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + $s = -1; return; + /* } */ case 8: + case 2: + buf = sliceType$1.nil; + _r$4 = x.Append(buf, ((format << 24 >>> 24)), prec); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + buf = _r$4; + if (buf.$length === 0) { + buf = (new sliceType$1($stringToBytes("?"))); + } + sign = ""; + /* */ if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 45)) { $s = 13; continue; } + /* */ if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 43)) { $s = 14; continue; } + _r$5 = s.Flag(43); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (_r$5) { $s = 15; continue; } + _r$6 = s.Flag(32); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ if (_r$6) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 45)) { */ case 13: + sign = "-"; + buf = $subslice(buf, 1); + $s = 17; continue; + /* } else if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 43)) { */ case 14: + sign = "+"; + _r$7 = s.Flag(32); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + /* */ if (_r$7) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (_r$7) { */ case 20: + sign = " "; + /* } */ case 21: + buf = $subslice(buf, 1); + $s = 17; continue; + /* } else if (_r$5) { */ case 15: + sign = "+"; + $s = 17; continue; + /* } else if (_r$6) { */ case 16: + sign = " "; + /* } */ case 17: + case 12: + padding = 0; + _r$8 = s.Width(); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _tuple$1 = _r$8; + width = _tuple$1[0]; + hasWidth = _tuple$1[1]; + if (hasWidth && width > (sign.length + buf.$length >> 0)) { + padding = (width - sign.length >> 0) - buf.$length >> 0; + } + _r$9 = s.Flag(48); /* */ $s = 29; case 29: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + /* */ if (_r$9 && !x.IsInf()) { $s = 25; continue; } + _r$10 = s.Flag(45); /* */ $s = 30; case 30: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + /* */ if (_r$10) { $s = 26; continue; } + /* */ $s = 27; continue; + /* if (_r$9 && !x.IsInf()) { */ case 25: + $r = writeMultiple(s, sign, 1); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = writeMultiple(s, "0", padding); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$11 = s.Write(buf); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _r$11; + $s = 28; continue; + /* } else if (_r$10) { */ case 26: + $r = writeMultiple(s, sign, 1); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$12 = s.Write(buf); /* */ $s = 35; case 35: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _r$12; + $r = writeMultiple(s, " ", padding); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 28; continue; + /* } else { */ case 27: + $r = writeMultiple(s, " ", padding); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = writeMultiple(s, sign, 1); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$13 = s.Write(buf); /* */ $s = 39; case 39: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _r$13; + /* } */ case 28: + case 24: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Format }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.format = format; $f.hasPrec = hasPrec; $f.hasWidth = hasWidth; $f.padding = padding; $f.prec = prec; $f.s = s; $f.sign = sign; $f.width = width; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Format = function(s, format) { return this.$val.Format(s, format); }; + Int.ptr.prototype.Sign = function() { + var x; + x = this; + if (x.abs.$length === 0) { + return 0; + } + if (x.neg) { + return -1; + } + return 1; + }; + Int.prototype.Sign = function() { return this.$val.Sign(); }; + Int.ptr.prototype.SetInt64 = function(x) { + var neg, x, z; + z = this; + neg = false; + if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) { + neg = true; + x = new $Int64(-x.$high, -x.$low); + } + z.abs = z.abs.setUint64((new $Uint64(x.$high, x.$low))); + z.neg = neg; + return z; + }; + Int.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; + Int.ptr.prototype.SetUint64 = function(x) { + var x, z; + z = this; + z.abs = z.abs.setUint64(x); + z.neg = false; + return z; + }; + Int.prototype.SetUint64 = function(x) { return this.$val.SetUint64(x); }; + NewInt = function(x) { + var x; + return new Int.ptr(false, nat.nil).SetInt64(x); + }; + $pkg.NewInt = NewInt; + Int.ptr.prototype.Set = function(x) { + var x, z; + z = this; + if (!(z === x)) { + z.abs = z.abs.set(x.abs); + z.neg = x.neg; + } + return z; + }; + Int.prototype.Set = function(x) { return this.$val.Set(x); }; + Int.ptr.prototype.Bits = function() { + var x, x$1; + x = this; + return (x$1 = x.abs, $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)); + }; + Int.prototype.Bits = function() { return this.$val.Bits(); }; + Int.ptr.prototype.SetBits = function(abs) { + var abs, z; + z = this; + z.abs = ($subslice(new nat(abs.$array), abs.$offset, abs.$offset + abs.$length)).norm(); + z.neg = false; + return z; + }; + Int.prototype.SetBits = function(abs) { return this.$val.SetBits(abs); }; + Int.ptr.prototype.Abs = function(x) { + var x, z; + z = this; + z.Set(x); + z.neg = false; + return z; + }; + Int.prototype.Abs = function(x) { return this.$val.Abs(x); }; + Int.ptr.prototype.Neg = function(x) { + var x, z; + z = this; + z.Set(x); + z.neg = z.abs.$length > 0 && !z.neg; + return z; + }; + Int.prototype.Neg = function(x) { return this.$val.Neg(x); }; + Int.ptr.prototype.Add = function(x, y) { + var neg, x, y, z; + z = this; + neg = x.neg; + if (x.neg === y.neg) { + z.abs = z.abs.add(x.abs, y.abs); + } else { + if (x.abs.cmp(y.abs) >= 0) { + z.abs = z.abs.sub(x.abs, y.abs); + } else { + neg = !neg; + z.abs = z.abs.sub(y.abs, x.abs); + } + } + z.neg = z.abs.$length > 0 && neg; + return z; + }; + Int.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; + Int.ptr.prototype.Sub = function(x, y) { + var neg, x, y, z; + z = this; + neg = x.neg; + if (!(x.neg === y.neg)) { + z.abs = z.abs.add(x.abs, y.abs); + } else { + if (x.abs.cmp(y.abs) >= 0) { + z.abs = z.abs.sub(x.abs, y.abs); + } else { + neg = !neg; + z.abs = z.abs.sub(y.abs, x.abs); + } + } + z.neg = z.abs.$length > 0 && neg; + return z; + }; + Int.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; + Int.ptr.prototype.Mul = function(x, y) { + var x, y, z; + z = this; + if (x === y) { + z.abs = z.abs.sqr(x.abs); + z.neg = false; + return z; + } + z.abs = z.abs.mul(x.abs, y.abs); + z.neg = z.abs.$length > 0 && !(x.neg === y.neg); + return z; + }; + Int.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; + Int.ptr.prototype.MulRange = function(a, b) { + var _tmp, _tmp$1, a, b, neg, x, x$1, z; + z = this; + if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { + return z.SetInt64(new $Int64(0, 1)); + } else if ((a.$high < 0 || (a.$high === 0 && a.$low <= 0)) && (b.$high > 0 || (b.$high === 0 && b.$low >= 0))) { + return z.SetInt64(new $Int64(0, 0)); + } + neg = false; + if ((a.$high < 0 || (a.$high === 0 && a.$low < 0))) { + neg = (x = (x$1 = new $Int64(b.$high - a.$high, b.$low - a.$low), new $Int64(x$1.$high & 0, (x$1.$low & 1) >>> 0)), (x.$high === 0 && x.$low === 0)); + _tmp = new $Int64(-b.$high, -b.$low); + _tmp$1 = new $Int64(-a.$high, -a.$low); + a = _tmp; + b = _tmp$1; + } + z.abs = z.abs.mulRange((new $Uint64(a.$high, a.$low)), (new $Uint64(b.$high, b.$low))); + z.neg = neg; + return z; + }; + Int.prototype.MulRange = function(a, b) { return this.$val.MulRange(a, b); }; + Int.ptr.prototype.Binomial = function(n, k) { + var _r$1, _tmp, _tmp$1, a, b, k, n, x, x$1, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; k = $f.k; n = $f.n; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + b = [b]; + z = this; + if ((x = $div64(n, new $Int64(0, 2), false), (x.$high < k.$high || (x.$high === k.$high && x.$low < k.$low))) && (k.$high < n.$high || (k.$high === n.$high && k.$low <= n.$low))) { + k = new $Int64(n.$high - k.$high, n.$low - k.$low); + } + _tmp = new Int.ptr(false, nat.nil); + _tmp$1 = new Int.ptr(false, nat.nil); + a[0] = $clone(_tmp, Int); + b[0] = $clone(_tmp$1, Int); + a[0].MulRange((x$1 = new $Int64(n.$high - k.$high, n.$low - k.$low), new $Int64(x$1.$high + 0, x$1.$low + 1)), n); + b[0].MulRange(new $Int64(0, 1), k); + _r$1 = z.Quo(a[0], b[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Binomial }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.k = k; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Binomial = function(n, k) { return this.$val.Binomial(n, k); }; + Int.ptr.prototype.Quo = function(x, y) { + var _r$1, _tuple, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.abs.div(nat.nil, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z.abs = _tuple[0]; + z.neg = z.abs.$length > 0 && !(x.neg === y.neg); + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Quo }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; + Int.ptr.prototype.Rem = function(x, y) { + var _r$1, _tuple, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = (nat.nil).div(z.abs, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z.abs = _tuple[1]; + z.neg = z.abs.$length > 0 && x.neg; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Rem }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Rem = function(x, y) { return this.$val.Rem(x, y); }; + Int.ptr.prototype.QuoRem = function(x, y, r) { + var _r$1, _tmp, _tmp$1, _tuple, r, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; r = $f.r; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.abs.div(r.abs, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z.abs = _tuple[0]; + r.abs = _tuple[1]; + _tmp = z.abs.$length > 0 && !(x.neg === y.neg); + _tmp$1 = r.abs.$length > 0 && x.neg; + z.neg = _tmp; + r.neg = _tmp$1; + $s = -1; return [z, r]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.QuoRem }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.r = r; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.QuoRem = function(x, y, r) { return this.$val.QuoRem(x, y, r); }; + Int.ptr.prototype.Div = function(x, y) { + var _r$1, r, x, y, y_neg, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; r = $f.r; x = $f.x; y = $f.y; y_neg = $f.y_neg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = [r]; + z = this; + y_neg = y.neg; + r[0] = new Int.ptr(false, nat.nil); + _r$1 = z.QuoRem(x, y, r[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + if (r[0].neg) { + if (y_neg) { + z.Add(z, intOne); + } else { + z.Sub(z, intOne); + } + } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Div }; } $f._r$1 = _r$1; $f.r = r; $f.x = x; $f.y = y; $f.y_neg = y_neg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Div = function(x, y) { return this.$val.Div(x, y); }; + Int.ptr.prototype.Mod = function(x, y) { + var _r$1, q, x, y, y0, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; q = $f.q; x = $f.x; y = $f.y; y0 = $f.y0; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + y0 = y; + if (z === y || alias(z.abs, y.abs)) { + y0 = new Int.ptr(false, nat.nil).Set(y); + } + q = new Int.ptr(false, nat.nil); + _r$1 = q.QuoRem(x, y, z); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + if (z.neg) { + if (y0.neg) { + z.Sub(z, y0); + } else { + z.Add(z, y0); + } + } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Mod }; } $f._r$1 = _r$1; $f.q = q; $f.x = x; $f.y = y; $f.y0 = y0; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Mod = function(x, y) { return this.$val.Mod(x, y); }; + Int.ptr.prototype.DivMod = function(x, y, m) { + var _r$1, m, x, y, y0, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; m = $f.m; x = $f.x; y = $f.y; y0 = $f.y0; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + y0 = y; + if (z === y || alias(z.abs, y.abs)) { + y0 = new Int.ptr(false, nat.nil).Set(y); + } + _r$1 = z.QuoRem(x, y, m); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + if (m.neg) { + if (y0.neg) { + z.Add(z, intOne); + m.Sub(m, y0); + } else { + z.Sub(z, intOne); + m.Add(m, y0); + } + } + $s = -1; return [z, m]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.DivMod }; } $f._r$1 = _r$1; $f.m = m; $f.x = x; $f.y = y; $f.y0 = y0; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.DivMod = function(x, y, m) { return this.$val.DivMod(x, y, m); }; + Int.ptr.prototype.Cmp = function(y) { + var r, x, y; + r = 0; + x = this; + if (x.neg === y.neg) { + r = x.abs.cmp(y.abs); + if (x.neg) { + r = -r; + } + } else if (x.neg) { + r = -1; + } else { + r = 1; + } + return r; + }; + Int.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; + Int.ptr.prototype.CmpAbs = function(y) { + var x, y; + x = this; + return x.abs.cmp(y.abs); + }; + Int.prototype.CmpAbs = function(y) { return this.$val.CmpAbs(y); }; + low32 = function(x) { + var x; + if (x.$length === 0) { + return 0; + } + return (((0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]) >>> 0)); + }; + low64 = function(x) { + var v, x, x$1, x$2, x$3; + if (x.$length === 0) { + return new $Uint64(0, 0); + } + v = ((x$1 = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]), new $Uint64(0, x$1.constructor === Number ? x$1 : 1))); + if (true && x.$length > 1) { + return (x$2 = $shiftLeft64(((x$3 = (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1]), new $Uint64(0, x$3.constructor === Number ? x$3 : 1))), 32), new $Uint64(x$2.$high | v.$high, (x$2.$low | v.$low) >>> 0)); + } + return v; + }; + Int.ptr.prototype.Int64 = function() { + var v, x, x$1; + x = this; + v = ((x$1 = low64(x.abs), new $Int64(x$1.$high, x$1.$low))); + if (x.neg) { + v = new $Int64(-v.$high, -v.$low); + } + return v; + }; + Int.prototype.Int64 = function() { return this.$val.Int64(); }; + Int.ptr.prototype.Uint64 = function() { + var x; + x = this; + return low64(x.abs); + }; + Int.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Int.ptr.prototype.IsInt64 = function() { + var w, x, x$1, x$2; + x = this; + if (x.abs.$length <= 2) { + w = ((x$1 = low64(x.abs), new $Int64(x$1.$high, x$1.$low))); + return (w.$high > 0 || (w.$high === 0 && w.$low >= 0)) || x.neg && (x$2 = new $Int64(-w.$high, -w.$low), (w.$high === x$2.$high && w.$low === x$2.$low)); + } + return false; + }; + Int.prototype.IsInt64 = function() { return this.$val.IsInt64(); }; + Int.ptr.prototype.IsUint64 = function() { + var x; + x = this; + return !x.neg && x.abs.$length <= 2; + }; + Int.prototype.IsUint64 = function() { return this.$val.IsUint64(); }; + Int.ptr.prototype.SetString = function(s, base) { + var _r$1, base, s, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.setFromScanner(strings.NewReader(s), base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f.base = base; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.SetString = function(s, base) { return this.$val.SetString(s, base); }; + Int.ptr.prototype.setFromScanner = function(r, base) { + var _r$1, _r$2, _tuple, _tuple$1, base, err, err$1, r, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; err = $f.err; err$1 = $f.err$1; r = $f.r; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.scan(r, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, false]; + } + _r$2 = r.ReadByte(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + err$1 = _tuple$1[1]; + if (!($interfaceIsEqual(err$1, io.EOF))) { + $s = -1; return [ptrType$1.nil, false]; + } + $s = -1; return [z, true]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.setFromScanner }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.err = err; $f.err$1 = err$1; $f.r = r; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.setFromScanner = function(r, base) { return this.$val.setFromScanner(r, base); }; + Int.ptr.prototype.SetBytes = function(buf) { + var buf, z; + z = this; + z.abs = z.abs.setBytes(buf); + z.neg = false; + return z; + }; + Int.prototype.SetBytes = function(buf) { return this.$val.SetBytes(buf); }; + Int.ptr.prototype.Bytes = function() { + var buf, x; + x = this; + buf = $makeSlice(sliceType$1, ($imul(x.abs.$length, 4))); + return $subslice(buf, x.abs.bytes(buf)); + }; + Int.prototype.Bytes = function() { return this.$val.Bytes(); }; + Int.ptr.prototype.BitLen = function() { + var x; + x = this; + return x.abs.bitLen(); + }; + Int.prototype.BitLen = function() { return this.$val.BitLen(); }; + Int.ptr.prototype.Exp = function(x, y, m) { + var _r$1, _r$2, m, mWords, x, xWords, y, yWords, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; m = $f.m; mWords = $f.mWords; x = $f.x; xWords = $f.xWords; y = $f.y; yWords = $f.yWords; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + xWords = x.abs; + /* */ if (y.neg) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (y.neg) { */ case 1: + if (m === ptrType$1.nil || (m.abs.$length === 0)) { + $s = -1; return z.SetInt64(new $Int64(0, 1)); + } + _r$1 = new Int.ptr(false, nat.nil).ModInverse(x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + xWords = _r$1.abs; + /* } */ case 2: + yWords = y.abs; + mWords = nat.nil; + if (!(m === ptrType$1.nil)) { + mWords = m.abs; + } + _r$2 = z.abs.expNN(xWords, yWords, mWords); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + z.abs = _r$2; + z.neg = z.abs.$length > 0 && x.neg && yWords.$length > 0 && ((((0 >= yWords.$length ? ($throwRuntimeError("index out of range"), undefined) : yWords.$array[yWords.$offset + 0]) & 1) >>> 0) === 1); + if (z.neg && mWords.$length > 0) { + z.abs = z.abs.sub(mWords, z.abs); + z.neg = false; + } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Exp }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.m = m; $f.mWords = mWords; $f.x = x; $f.xWords = xWords; $f.y = y; $f.yWords = yWords; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Exp = function(x, y, m) { return this.$val.Exp(x, y, m); }; + Int.ptr.prototype.GCD = function(x, y, a, b) { + var _r$1, a, b, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (a.Sign() <= 0 || b.Sign() <= 0) { + z.SetInt64(new $Int64(0, 0)); + if (!(x === ptrType$1.nil)) { + x.SetInt64(new $Int64(0, 0)); + } + if (!(y === ptrType$1.nil)) { + y.SetInt64(new $Int64(0, 0)); + } + $s = -1; return z; + } + _r$1 = z.lehmerGCD(x, y, a, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.GCD }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.GCD = function(x, y, a, b) { return this.$val.GCD(x, y, a, b); }; + lehmerSimulate = function(A, B) { + var A, B, _q, _r$1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, a1, a2, even, h, m, n, q, r, u0, u1, u2, v0, v1, v2, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2, y$3, y$4; + u0 = 0; + u1 = 0; + v0 = 0; + v1 = 0; + even = false; + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = 0; + _tmp$3 = 0; + a1 = _tmp; + a2 = _tmp$1; + u2 = _tmp$2; + v2 = _tmp$3; + m = B.abs.$length; + n = A.abs.$length; + h = nlz((x = A.abs, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); + a1 = (((y = h, y < 32 ? ((x$2 = A.abs, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])) << y) : 0) >>> 0) | ((y$1 = ((32 - h >>> 0)), y$1 < 32 ? ((x$4 = A.abs, x$5 = n - 2 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) >>> y$1) : 0) >>> 0)) >>> 0; + if ((n === m)) { + a2 = (((y$2 = h, y$2 < 32 ? ((x$6 = B.abs, x$7 = n - 1 >> 0, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])) << y$2) : 0) >>> 0) | ((y$3 = ((32 - h >>> 0)), y$3 < 32 ? ((x$8 = B.abs, x$9 = n - 2 >> 0, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])) >>> y$3) : 0) >>> 0)) >>> 0; + } else if ((n === (m + 1 >> 0))) { + a2 = (y$4 = ((32 - h >>> 0)), y$4 < 32 ? ((x$10 = B.abs, x$11 = n - 2 >> 0, ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11])) >>> y$4) : 0) >>> 0; + } else { + a2 = 0; + } + even = false; + _tmp$4 = 0; + _tmp$5 = 1; + _tmp$6 = 0; + u0 = _tmp$4; + u1 = _tmp$5; + u2 = _tmp$6; + _tmp$7 = 0; + _tmp$8 = 0; + _tmp$9 = 1; + v0 = _tmp$7; + v1 = _tmp$8; + v2 = _tmp$9; + while (true) { + if (!(a2 >= v2 && (a1 - a2 >>> 0) >= (v1 + v2 >>> 0))) { break; } + _tmp$10 = (_q = a1 / a2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + _tmp$11 = (_r$1 = a1 % a2, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); + q = _tmp$10; + r = _tmp$11; + _tmp$12 = a2; + _tmp$13 = r; + a1 = _tmp$12; + a2 = _tmp$13; + _tmp$14 = u1; + _tmp$15 = u2; + _tmp$16 = u1 + ($imul(q, u2) >>> 0) >>> 0; + u0 = _tmp$14; + u1 = _tmp$15; + u2 = _tmp$16; + _tmp$17 = v1; + _tmp$18 = v2; + _tmp$19 = v1 + ($imul(q, v2) >>> 0) >>> 0; + v0 = _tmp$17; + v1 = _tmp$18; + v2 = _tmp$19; + even = !even; + } + return [u0, u1, v0, v1, even]; + }; + lehmerUpdate = function(A, B, q, r, s, t, u0, u1, v0, v1, even) { + var A, B, even, q, r, s, t, u0, u1, v0, v1; + t.abs = t.abs.setWord(u0); + s.abs = s.abs.setWord(v0); + t.neg = !even; + s.neg = even; + t.Mul(A, t); + s.Mul(B, s); + r.abs = r.abs.setWord(u1); + q.abs = q.abs.setWord(v1); + r.neg = even; + q.neg = !even; + r.Mul(A, r); + q.Mul(B, q); + A.Add(t, s); + B.Add(r, q); + }; + euclidUpdate = function(A, B, Ua, Ub, q, r, s, t, extended) { + var A, B, Ua, Ub, _r$1, _tmp, _tmp$1, _tmp$2, _tuple, extended, q, r, s, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; Ua = $f.Ua; Ub = $f.Ub; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; extended = $f.extended; q = $f.q; r = $f.r; s = $f.s; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$1 = q.QuoRem(A, B, r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + q = _tuple[0]; + r = _tuple[1]; + _tmp = $clone(B, Int); + _tmp$1 = $clone(r, Int); + _tmp$2 = $clone(A, Int); + Int.copy(A, _tmp); + Int.copy(B, _tmp$1); + Int.copy(r, _tmp$2); + if (extended) { + t.Set(Ub); + s.Mul(Ub, q); + Ub.Sub(Ua, s); + Ua.Set(t); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: euclidUpdate }; } $f.A = A; $f.B = B; $f.Ua = Ua; $f.Ub = Ub; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.extended = extended; $f.q = q; $f.r = r; $f.s = s; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.ptr.prototype.lehmerGCD = function(x, y, a, b) { + var A, B, Ua, Ub, _q, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, a, aWord, b, bWord, even, even$1, extended, q, q$1, r, r$1, s, t, u0, u1, ua, ub, v0, v1, va, vb, x, x$1, x$2, x$3, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; Ua = $f.Ua; Ub = $f.Ub; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; a = $f.a; aWord = $f.aWord; b = $f.b; bWord = $f.bWord; even = $f.even; even$1 = $f.even$1; extended = $f.extended; q = $f.q; q$1 = $f.q$1; r = $f.r; r$1 = $f.r$1; s = $f.s; t = $f.t; u0 = $f.u0; u1 = $f.u1; ua = $f.ua; ub = $f.ub; v0 = $f.v0; v1 = $f.v1; va = $f.va; vb = $f.vb; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _tmp = ptrType$1.nil; + _tmp$1 = ptrType$1.nil; + _tmp$2 = ptrType$1.nil; + _tmp$3 = ptrType$1.nil; + A = _tmp; + B = _tmp$1; + Ua = _tmp$2; + Ub = _tmp$3; + A = new Int.ptr(false, nat.nil).Set(a); + B = new Int.ptr(false, nat.nil).Set(b); + extended = !(x === ptrType$1.nil) || !(y === ptrType$1.nil); + if (extended) { + Ua = new Int.ptr(false, nat.nil).SetInt64(new $Int64(0, 1)); + Ub = new Int.ptr(false, nat.nil); + } + q = new Int.ptr(false, nat.nil); + r = new Int.ptr(false, nat.nil); + s = new Int.ptr(false, nat.nil); + t = new Int.ptr(false, nat.nil); + if (A.abs.cmp(B.abs) < 0) { + _tmp$4 = B; + _tmp$5 = A; + A = _tmp$4; + B = _tmp$5; + _tmp$6 = Ua; + _tmp$7 = Ub; + Ub = _tmp$6; + Ua = _tmp$7; + } + /* while (true) { */ case 1: + /* if (!(B.abs.$length > 1)) { break; } */ if(!(B.abs.$length > 1)) { $s = 2; continue; } + _tuple = lehmerSimulate(A, B); + u0 = _tuple[0]; + u1 = _tuple[1]; + v0 = _tuple[2]; + v1 = _tuple[3]; + even = _tuple[4]; + /* */ if (!((v0 === 0))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!((v0 === 0))) { */ case 3: + lehmerUpdate(A, B, q, r, s, t, u0, u1, v0, v1, even); + if (extended) { + lehmerUpdate(Ua, Ub, q, r, s, t, u0, u1, v0, v1, even); + } + $s = 5; continue; + /* } else { */ case 4: + $r = euclidUpdate(A, B, Ua, Ub, q, r, s, t, extended); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + /* } */ $s = 1; continue; case 2: + /* */ if (B.abs.$length > 0) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (B.abs.$length > 0) { */ case 7: + /* */ if (A.abs.$length > 1) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (A.abs.$length > 1) { */ case 9: + $r = euclidUpdate(A, B, Ua, Ub, q, r, s, t, extended); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + if (B.abs.$length > 0) { + _tmp$8 = (x$1 = A.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); + _tmp$9 = (x$2 = B.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])); + aWord = _tmp$8; + bWord = _tmp$9; + if (extended) { + _tmp$10 = 0; + _tmp$11 = 0; + _tmp$12 = 0; + _tmp$13 = 0; + ua = _tmp$10; + ub = _tmp$11; + va = _tmp$12; + vb = _tmp$13; + _tmp$14 = 1; + _tmp$15 = 0; + ua = _tmp$14; + ub = _tmp$15; + _tmp$16 = 0; + _tmp$17 = 1; + va = _tmp$16; + vb = _tmp$17; + even$1 = true; + while (true) { + if (!(!((bWord === 0)))) { break; } + _tmp$18 = (_q = aWord / bWord, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + _tmp$19 = (_r$1 = aWord % bWord, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); + q$1 = _tmp$18; + r$1 = _tmp$19; + _tmp$20 = bWord; + _tmp$21 = r$1; + aWord = _tmp$20; + bWord = _tmp$21; + _tmp$22 = ub; + _tmp$23 = ua + ($imul(q$1, ub) >>> 0) >>> 0; + ua = _tmp$22; + ub = _tmp$23; + _tmp$24 = vb; + _tmp$25 = va + ($imul(q$1, vb) >>> 0) >>> 0; + va = _tmp$24; + vb = _tmp$25; + even$1 = !even$1; + } + t.abs = t.abs.setWord(ua); + s.abs = s.abs.setWord(va); + t.neg = !even$1; + s.neg = even$1; + t.Mul(Ua, t); + s.Mul(Ub, s); + Ua.Add(t, s); + } else { + while (true) { + if (!(!((bWord === 0)))) { break; } + _tmp$26 = bWord; + _tmp$27 = (_r$2 = aWord % bWord, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")); + aWord = _tmp$26; + bWord = _tmp$27; + } + } + (x$3 = A.abs, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = aWord)); + } + /* } */ case 8: + if (!(x === ptrType$1.nil)) { + Int.copy(x, Ua); + } + /* */ if (!(y === ptrType$1.nil)) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (!(y === ptrType$1.nil)) { */ case 12: + y.Mul(a, Ua); + y.Sub(A, y); + _r$3 = y.Div(y, b); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + /* } */ case 13: + Int.copy(z, A); + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.lehmerGCD }; } $f.A = A; $f.B = B; $f.Ua = Ua; $f.Ub = Ub; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f.a = a; $f.aWord = aWord; $f.b = b; $f.bWord = bWord; $f.even = even; $f.even$1 = even$1; $f.extended = extended; $f.q = q; $f.q$1 = q$1; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.t = t; $f.u0 = u0; $f.u1 = u1; $f.ua = ua; $f.ub = ub; $f.v0 = v0; $f.v1 = v1; $f.va = va; $f.vb = vb; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.lehmerGCD = function(x, y, a, b) { return this.$val.lehmerGCD(x, y, a, b); }; + Int.ptr.prototype.Rand = function(rnd, n) { + var _r$1, n, rnd, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; n = $f.n; rnd = $f.rnd; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + z.neg = false; + if (n.neg || (n.abs.$length === 0)) { + z.abs = nat.nil; + $s = -1; return z; + } + _r$1 = z.abs.random(rnd, n.abs, n.abs.bitLen()); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + z.abs = _r$1; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Rand }; } $f._r$1 = _r$1; $f.n = n; $f.rnd = rnd; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Rand = function(rnd, n) { return this.$val.Rand(rnd, n); }; + Int.ptr.prototype.ModInverse = function(g, n) { + var _r$1, _r$2, _tmp, _tmp$1, d, g, g2, n, n2, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; d = $f.d; g = $f.g; g2 = $f.g2; n = $f.n; n2 = $f.n2; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = [x]; + z = this; + if (n.neg) { + n2 = new Int.ptr(false, nat.nil); + n = n2.Neg(n); + } + /* */ if (g.neg) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (g.neg) { */ case 1: + g2 = new Int.ptr(false, nat.nil); + _r$1 = g2.Mod(g, n); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + g = _r$1; + /* } */ case 2: + _tmp = new Int.ptr(false, nat.nil); + _tmp$1 = new Int.ptr(false, nat.nil); + d = $clone(_tmp, Int); + x[0] = $clone(_tmp$1, Int); + _r$2 = d.GCD(x[0], ptrType$1.nil, g, n); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + if (!((d.Cmp(intOne) === 0))) { + $s = -1; return ptrType$1.nil; + } + if (x[0].neg) { + z.Add(x[0], n); + } else { + z.Set(x[0]); + } + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ModInverse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.d = d; $f.g = g; $f.g2 = g2; $f.n = n; $f.n2 = n2; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.ModInverse = function(g, n) { return this.$val.ModInverse(g, n); }; + Jacobi = function(x, y) { + var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, a, b, bmod8, c, j, s, x, x$1, x$2, x$3, x$4, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; a = $f.a; b = $f.b; bmod8 = $f.bmod8; c = $f.c; j = $f.j; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + b = [b]; + c = [c]; + /* */ if ((y.abs.$length === 0) || ((((x$1 = y.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) === 0)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((y.abs.$length === 0) || ((((x$1 = y.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) === 0)) { */ case 1: + _r$1 = fmt.Sprintf("big: invalid 2nd argument to Int.Jacobi: need odd integer but got %s", new sliceType([y])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $panic(new $String(_r$1)); + /* } */ case 2: + _tmp = new Int.ptr(false, nat.nil); + _tmp$1 = new Int.ptr(false, nat.nil); + _tmp$2 = new Int.ptr(false, nat.nil); + a[0] = $clone(_tmp, Int); + b[0] = $clone(_tmp$1, Int); + c[0] = $clone(_tmp$2, Int); + a[0].Set(x); + b[0].Set(y); + j = 1; + if (b[0].neg) { + if (a[0].neg) { + j = -1; + } + b[0].neg = false; + } + /* while (true) { */ case 4: + if (b[0].Cmp(intOne) === 0) { + $s = -1; return j; + } + if (a[0].abs.$length === 0) { + $s = -1; return 0; + } + _r$2 = a[0].Mod(a[0], b[0]); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + if (a[0].abs.$length === 0) { + $s = -1; return 0; + } + s = a[0].abs.trailingZeroBits(); + if (!((((s & 1) >>> 0) === 0))) { + bmod8 = ((x$2 = b[0].abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) & 7) >>> 0; + if ((bmod8 === 3) || (bmod8 === 5)) { + j = -j; + } + } + c[0].Rsh(a[0], s); + if (((((x$3 = b[0].abs, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])) & 3) >>> 0) === 3) && ((((x$4 = c[0].abs, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])) & 3) >>> 0) === 3)) { + j = -j; + } + a[0].Set(b[0]); + b[0].Set(c[0]); + /* } */ $s = 4; continue; case 5: + $s = -1; return 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Jacobi }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.a = a; $f.b = b; $f.bmod8 = bmod8; $f.c = c; $f.j = j; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Jacobi = Jacobi; + Int.ptr.prototype.modSqrt3Mod4Prime = function(x, p) { + var _r$1, e, p, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; e = $f.e; p = $f.p; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + e = new Int.ptr(false, nat.nil).Add(p, intOne); + e.Rsh(e, 2); + _r$1 = z.Exp(x, e, p); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrt3Mod4Prime }; } $f._r$1 = _r$1; $f.e = e; $f.p = p; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.modSqrt3Mod4Prime = function(x, p) { return this.$val.modSqrt3Mod4Prime(x, p); }; + Int.ptr.prototype.modSqrt5Mod8Prime = function(x, p) { + var _r$1, _r$2, _r$3, _r$4, _r$5, alpha, beta, e, p, tx, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; alpha = $f.alpha; beta = $f.beta; e = $f.e; p = $f.p; tx = $f.tx; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + e = new Int.ptr(false, nat.nil).Rsh(p, 3); + tx = new Int.ptr(false, nat.nil).Lsh(x, 1); + _r$1 = new Int.ptr(false, nat.nil).Exp(tx, e, p); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + alpha = _r$1; + beta = new Int.ptr(false, nat.nil).Mul(alpha, alpha); + _r$2 = beta.Mod(beta, p); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + beta.Mul(beta, tx); + _r$3 = beta.Mod(beta, p); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + beta.Sub(beta, intOne); + beta.Mul(beta, x); + _r$4 = beta.Mod(beta, p); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + beta.Mul(beta, alpha); + _r$5 = z.Mod(beta, p); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrt5Mod8Prime }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.alpha = alpha; $f.beta = beta; $f.e = e; $f.p = p; $f.tx = tx; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.modSqrt5Mod8Prime = function(x, p) { return this.$val.modSqrt5Mod8Prime(x, p); }; + Int.ptr.prototype.modSqrtTonelliShanks = function(x, p) { + var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tmp$2, _tmp$3, b, e, g, m, n, p, r, s, t, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; b = $f.b; e = $f.e; g = $f.g; m = $f.m; n = $f.n; p = $f.p; r = $f.r; s = $f.s; t = $f.t; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + b = [b]; + g = [g]; + n = [n]; + s = [s]; + t = [t]; + y = [y]; + z = this; + s[0] = new Int.ptr(false, nat.nil); + s[0].Sub(p, intOne); + e = s[0].abs.trailingZeroBits(); + s[0].Rsh(s[0], e); + n[0] = new Int.ptr(false, nat.nil); + n[0].SetInt64(new $Int64(0, 2)); + /* while (true) { */ case 1: + _r$1 = Jacobi(n[0], p); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* if (!(!((_r$1 === -1)))) { break; } */ if(!(!((_r$1 === -1)))) { $s = 2; continue; } + n[0].Add(n[0], intOne); + /* } */ $s = 1; continue; case 2: + _tmp = new Int.ptr(false, nat.nil); + _tmp$1 = new Int.ptr(false, nat.nil); + _tmp$2 = new Int.ptr(false, nat.nil); + _tmp$3 = new Int.ptr(false, nat.nil); + y[0] = $clone(_tmp, Int); + b[0] = $clone(_tmp$1, Int); + g[0] = $clone(_tmp$2, Int); + t[0] = $clone(_tmp$3, Int); + y[0].Add(s[0], intOne); + y[0].Rsh(y[0], 1); + _r$2 = y[0].Exp(x, y[0], p); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + _r$3 = b[0].Exp(x, s[0], p); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + _r$4 = g[0].Exp(n[0], s[0], p); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + r = e; + /* while (true) { */ case 7: + m = 0; + t[0].Set(b[0]); + /* while (true) { */ case 9: + /* if (!(!((t[0].Cmp(intOne) === 0)))) { break; } */ if(!(!((t[0].Cmp(intOne) === 0)))) { $s = 10; continue; } + _r$5 = t[0].Mul(t[0], t[0]).Mod(t[0], p); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + m = m + (1) >>> 0; + /* } */ $s = 9; continue; case 10: + if (m === 0) { + $s = -1; return z.Set(y[0]); + } + _r$6 = t[0].SetInt64(new $Int64(0, 0)).SetBit(t[0], ((((r - m >>> 0) - 1 >>> 0) >> 0)), 1).Exp(g[0], t[0], p); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + _r$7 = g[0].Mul(t[0], t[0]).Mod(g[0], p); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + _r$8 = y[0].Mul(y[0], t[0]).Mod(y[0], p); /* */ $s = 14; case 14: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _r$8; + _r$9 = b[0].Mul(b[0], g[0]).Mod(b[0], p); /* */ $s = 15; case 15: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$9; + r = m; + /* } */ $s = 7; continue; case 8: + $s = -1; return ptrType$1.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrtTonelliShanks }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.b = b; $f.e = e; $f.g = g; $f.m = m; $f.n = n; $f.p = p; $f.r = r; $f.s = s; $f.t = t; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.modSqrtTonelliShanks = function(x, p) { return this.$val.modSqrtTonelliShanks(x, p); }; + Int.ptr.prototype.ModSqrt = function(x, p) { + var _1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, p, x, x$1, x$2, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = Jacobi(x, p); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _1 = _r$1; + if (_1 === (-1)) { + $s = -1; return ptrType$1.nil; + } else if (_1 === (0)) { + $s = -1; return z.SetInt64(new $Int64(0, 0)); + } else if (_1 === (1)) { + /* break; */ $s = 1; continue; + } + case 1: + /* */ if (x.neg || x.Cmp(p) >= 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (x.neg || x.Cmp(p) >= 0) { */ case 3: + _r$2 = new Int.ptr(false, nat.nil).Mod(x, p); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + /* } */ case 4: + /* */ if (((_r$3 = (x$1 = p.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) % 4, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 3)) { $s = 7; continue; } + /* */ if (((_r$4 = (x$2 = p.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) % 8, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 5)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (((_r$3 = (x$1 = p.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) % 4, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 3)) { */ case 7: + _r$5 = z.modSqrt3Mod4Prime(x, p); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return _r$5; + /* } else if (((_r$4 = (x$2 = p.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) % 8, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 5)) { */ case 8: + _r$6 = z.modSqrt5Mod8Prime(x, p); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + $s = -1; return _r$6; + /* } else { */ case 9: + _r$7 = z.modSqrtTonelliShanks(x, p); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return _r$7; + /* } */ case 10: + case 6: + $s = -1; return ptrType$1.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ModSqrt }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.ModSqrt = function(x, p) { return this.$val.ModSqrt(x, p); }; + Int.ptr.prototype.Lsh = function(x, n) { + var n, x, z; + z = this; + z.abs = z.abs.shl(x.abs, n); + z.neg = x.neg; + return z; + }; + Int.prototype.Lsh = function(x, n) { return this.$val.Lsh(x, n); }; + Int.ptr.prototype.Rsh = function(x, n) { + var n, t, x, z; + z = this; + if (x.neg) { + t = z.abs.sub(x.abs, natOne); + t = t.shr(t, n); + z.abs = t.add(t, natOne); + z.neg = true; + return z; + } + z.abs = z.abs.shr(x.abs, n); + z.neg = false; + return z; + }; + Int.prototype.Rsh = function(x, n) { return this.$val.Rsh(x, n); }; + Int.ptr.prototype.Bit = function(i) { + var i, t, x, x$1; + x = this; + if (i === 0) { + if (x.abs.$length > 0) { + return (((((x$1 = x.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) >>> 0)); + } + return 0; + } + if (i < 0) { + $panic(new $String("negative bit index")); + } + if (x.neg) { + t = (nat.nil).sub(x.abs, natOne); + return (t.bit(((i >>> 0))) ^ 1) >>> 0; + } + return x.abs.bit(((i >>> 0))); + }; + Int.prototype.Bit = function(i) { return this.$val.Bit(i); }; + Int.ptr.prototype.SetBit = function(x, i, b) { + var b, i, t, x, z; + z = this; + if (i < 0) { + $panic(new $String("negative bit index")); + } + if (x.neg) { + t = z.abs.sub(x.abs, natOne); + t = t.setBit(t, ((i >>> 0)), (b ^ 1) >>> 0); + z.abs = t.add(t, natOne); + z.neg = z.abs.$length > 0; + return z; + } + z.abs = z.abs.setBit(x.abs, ((i >>> 0)), b); + z.neg = false; + return z; + }; + Int.prototype.SetBit = function(x, i, b) { return this.$val.SetBit(x, i, b); }; + Int.ptr.prototype.And = function(x, y) { + var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; + z = this; + if (x.neg === y.neg) { + if (x.neg) { + x1 = (nat.nil).sub(x.abs, natOne); + y1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.add(z.abs.or(x1, y1), natOne); + z.neg = true; + return z; + } + z.abs = z.abs.and(x.abs, y.abs); + z.neg = false; + return z; + } + if (x.neg) { + _tmp = y; + _tmp$1 = x; + x = _tmp; + y = _tmp$1; + } + y1$1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.andNot(x.abs, y1$1); + z.neg = false; + return z; + }; + Int.prototype.And = function(x, y) { return this.$val.And(x, y); }; + Int.ptr.prototype.AndNot = function(x, y) { + var x, x1, x1$1, y, y1, y1$1, z; + z = this; + if (x.neg === y.neg) { + if (x.neg) { + x1 = (nat.nil).sub(x.abs, natOne); + y1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.andNot(y1, x1); + z.neg = false; + return z; + } + z.abs = z.abs.andNot(x.abs, y.abs); + z.neg = false; + return z; + } + if (x.neg) { + x1$1 = (nat.nil).sub(x.abs, natOne); + z.abs = z.abs.add(z.abs.or(x1$1, y.abs), natOne); + z.neg = true; + return z; + } + y1$1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.and(x.abs, y1$1); + z.neg = false; + return z; + }; + Int.prototype.AndNot = function(x, y) { return this.$val.AndNot(x, y); }; + Int.ptr.prototype.Or = function(x, y) { + var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; + z = this; + if (x.neg === y.neg) { + if (x.neg) { + x1 = (nat.nil).sub(x.abs, natOne); + y1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.add(z.abs.and(x1, y1), natOne); + z.neg = true; + return z; + } + z.abs = z.abs.or(x.abs, y.abs); + z.neg = false; + return z; + } + if (x.neg) { + _tmp = y; + _tmp$1 = x; + x = _tmp; + y = _tmp$1; + } + y1$1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.add(z.abs.andNot(y1$1, x.abs), natOne); + z.neg = true; + return z; + }; + Int.prototype.Or = function(x, y) { return this.$val.Or(x, y); }; + Int.ptr.prototype.Xor = function(x, y) { + var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; + z = this; + if (x.neg === y.neg) { + if (x.neg) { + x1 = (nat.nil).sub(x.abs, natOne); + y1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.xor(x1, y1); + z.neg = false; + return z; + } + z.abs = z.abs.xor(x.abs, y.abs); + z.neg = false; + return z; + } + if (x.neg) { + _tmp = y; + _tmp$1 = x; + x = _tmp; + y = _tmp$1; + } + y1$1 = (nat.nil).sub(y.abs, natOne); + z.abs = z.abs.add(z.abs.xor(x.abs, y1$1), natOne); + z.neg = true; + return z; + }; + Int.prototype.Xor = function(x, y) { return this.$val.Xor(x, y); }; + Int.ptr.prototype.Not = function(x) { + var x, z; + z = this; + if (x.neg) { + z.abs = z.abs.sub(x.abs, natOne); + z.neg = false; + return z; + } + z.abs = z.abs.add(x.abs, natOne); + z.neg = true; + return z; + }; + Int.prototype.Not = function(x) { return this.$val.Not(x); }; + Int.ptr.prototype.Sqrt = function(x) { + var _r$1, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (x.neg) { + $panic(new $String("square root of negative number")); + } + z.neg = false; + _r$1 = z.abs.sqrt(x.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + z.abs = _r$1; + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Sqrt }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Sqrt = function(x) { return this.$val.Sqrt(x); }; + Int.ptr.prototype.Text = function(base) { + var _r$1, base, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (x === ptrType$1.nil) { + $s = -1; return ""; + } + _r$1 = x.abs.itoa(x.neg, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return ($bytesToString(_r$1)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Text }; } $f._r$1 = _r$1; $f.base = base; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Text = function(base) { return this.$val.Text(base); }; + Int.ptr.prototype.Append = function(buf, base) { + var _arg, _arg$1, _r$1, base, buf, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; base = $f.base; buf = $f.buf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (x === ptrType$1.nil) { + $s = -1; return $appendSlice(buf, ""); + } + _arg = buf; + _r$1 = x.abs.itoa(x.neg, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$1 = _r$1; + $s = -1; return $appendSlice(_arg, _arg$1); + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Append }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f.base = base; $f.buf = buf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Append = function(buf, base) { return this.$val.Append(buf, base); }; + Int.ptr.prototype.String = function() { + var _r$1, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = x.Text(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.String = function() { return this.$val.String(); }; + writeMultiple = function(s, text, count) { + var _r$1, b, count, s, text, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; count = $f.count; s = $f.s; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (text.length > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (text.length > 0) { */ case 1: + b = (new sliceType$1($stringToBytes(text))); + /* while (true) { */ case 3: + /* if (!(count > 0)) { break; } */ if(!(count > 0)) { $s = 4; continue; } + _r$1 = s.Write(b); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + count = count - (1) >> 0; + /* } */ $s = 3; continue; case 4: + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: writeMultiple }; } $f._r$1 = _r$1; $f.b = b; $f.count = count; $f.s = s; $f.text = text; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.ptr.prototype.Format = function(s, ch) { + var _1, _2, _arg, _arg$1, _arg$2, _i, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, base, ch, d, d$1, digits, i, left, length, precision, precisionSet, prefix, right, s, sign, width, widthSet, x, zeros, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; ch = $f.ch; d = $f.d; d$1 = $f.d$1; digits = $f.digits; i = $f.i; left = $f.left; length = $f.length; precision = $f.precision; precisionSet = $f.precisionSet; prefix = $f.prefix; right = $f.right; s = $f.s; sign = $f.sign; width = $f.width; widthSet = $f.widthSet; x = $f.x; zeros = $f.zeros; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + base = 0; + _1 = ch; + /* */ if (_1 === (98)) { $s = 2; continue; } + /* */ if (_1 === (111)) { $s = 3; continue; } + /* */ if ((_1 === (100)) || (_1 === (115)) || (_1 === (118))) { $s = 4; continue; } + /* */ if ((_1 === (120)) || (_1 === (88))) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_1 === (98)) { */ case 2: + base = 2; + $s = 7; continue; + /* } else if (_1 === (111)) { */ case 3: + base = 8; + $s = 7; continue; + /* } else if ((_1 === (100)) || (_1 === (115)) || (_1 === (118))) { */ case 4: + base = 10; + $s = 7; continue; + /* } else if ((_1 === (120)) || (_1 === (88))) { */ case 5: + base = 16; + $s = 7; continue; + /* } else { */ case 6: + _arg = s; + _arg$1 = new $Int32(ch); + _r$1 = x.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$2 = new $String(_r$1); + _r$2 = fmt.Fprintf(_arg, "%%!%c(big.Int=%s)", new sliceType([_arg$1, _arg$2])); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + $s = -1; return; + /* } */ case 7: + case 1: + /* */ if (x === ptrType$1.nil) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (x === ptrType$1.nil) { */ case 10: + _r$3 = fmt.Fprint(s, new sliceType([new $String("")])); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + $s = -1; return; + /* } */ case 11: + sign = ""; + /* */ if (x.neg) { $s = 14; continue; } + _r$4 = s.Flag(43); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4) { $s = 15; continue; } + _r$5 = s.Flag(32); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (_r$5) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (x.neg) { */ case 14: + sign = "-"; + $s = 17; continue; + /* } else if (_r$4) { */ case 15: + sign = "+"; + $s = 17; continue; + /* } else if (_r$5) { */ case 16: + sign = " "; + /* } */ case 17: + case 13: + prefix = ""; + _r$6 = s.Flag(35); /* */ $s = 22; case 22: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ if (_r$6) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (_r$6) { */ case 20: + _2 = ch; + if (_2 === (111)) { + prefix = "0"; + } else if (_2 === (120)) { + prefix = "0x"; + } else if (_2 === (88)) { + prefix = "0X"; + } + /* } */ case 21: + _r$7 = x.abs.utoa(base); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + digits = _r$7; + if (ch === 88) { + _ref = digits; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (97 <= d && d <= 122) { + ((i < 0 || i >= digits.$length) ? ($throwRuntimeError("index out of range"), undefined) : digits.$array[digits.$offset + i] = (65 + ((d - 97 << 24 >>> 24)) << 24 >>> 24)); + } + _i++; + } + } + left = 0; + zeros = 0; + right = 0; + _r$8 = s.Precision(); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _tuple = _r$8; + precision = _tuple[0]; + precisionSet = _tuple[1]; + if (precisionSet) { + if (digits.$length < precision) { + zeros = precision - digits.$length >> 0; + } else if ((digits.$length === 1) && ((0 >= digits.$length ? ($throwRuntimeError("index out of range"), undefined) : digits.$array[digits.$offset + 0]) === 48) && (precision === 0)) { + $s = -1; return; + } + } + length = ((sign.length + prefix.length >> 0) + zeros >> 0) + digits.$length >> 0; + _r$9 = s.Width(); /* */ $s = 25; case 25: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _tuple$1 = _r$9; + width = _tuple$1[0]; + widthSet = _tuple$1[1]; + /* */ if (widthSet && length < width) { $s = 26; continue; } + /* */ $s = 27; continue; + /* if (widthSet && length < width) { */ case 26: + d$1 = width - length >> 0; + _r$10 = s.Flag(45); /* */ $s = 33; case 33: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + /* */ if (_r$10) { $s = 29; continue; } + _r$11 = s.Flag(48); /* */ $s = 34; case 34: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + /* */ if (_r$11 && !precisionSet) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if (_r$10) { */ case 29: + right = d$1; + $s = 32; continue; + /* } else if (_r$11 && !precisionSet) { */ case 30: + zeros = d$1; + $s = 32; continue; + /* } else { */ case 31: + left = d$1; + /* } */ case 32: + case 28: + /* } */ case 27: + $r = writeMultiple(s, " ", left); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = writeMultiple(s, sign, 1); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = writeMultiple(s, prefix, 1); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = writeMultiple(s, "0", zeros); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$12 = s.Write(digits); /* */ $s = 39; case 39: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _r$12; + $r = writeMultiple(s, " ", right); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Format }; } $f._1 = _1; $f._2 = _2; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.ch = ch; $f.d = d; $f.d$1 = d$1; $f.digits = digits; $f.i = i; $f.left = left; $f.length = length; $f.precision = precision; $f.precisionSet = precisionSet; $f.prefix = prefix; $f.right = right; $f.s = s; $f.sign = sign; $f.width = width; $f.widthSet = widthSet; $f.x = x; $f.zeros = zeros; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Format = function(s, ch) { return this.$val.Format(s, ch); }; + Int.ptr.prototype.scan = function(r, base) { + var _r$1, _r$2, _tuple, _tuple$1, base, err, neg, r, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; err = $f.err; neg = $f.neg; r = $f.r; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = scanSign(r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + neg = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, 0, err]; + } + _r$2 = z.abs.scan(r, base, false); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + z.abs = _tuple$1[0]; + base = _tuple$1[1]; + err = _tuple$1[3]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, base, err]; + } + z.neg = z.abs.$length > 0 && neg; + $s = -1; return [z, base, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.scan }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.err = err; $f.neg = neg; $f.r = r; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.scan = function(r, base) { return this.$val.scan(r, base); }; + scanSign = function(r) { + var _1, _r$1, _r$2, _tmp, _tmp$1, _tuple, ch, err, neg, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; ch = $f.ch; err = $f.err; neg = $f.neg; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + neg = false; + err = $ifaceNil; + ch = 0; + _r$1 = r.ReadByte(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ch = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp = false; + _tmp$1 = err; + neg = _tmp; + err = _tmp$1; + $s = -1; return [neg, err]; + } + _1 = ch; + /* */ if (_1 === (45)) { $s = 3; continue; } + /* */ if (_1 === (43)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_1 === (45)) { */ case 3: + neg = true; + $s = 6; continue; + /* } else if (_1 === (43)) { */ case 4: + $s = 6; continue; + /* } else { */ case 5: + _r$2 = r.UnreadByte(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* } */ case 6: + case 2: + $s = -1; return [neg, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: scanSign }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.neg = neg; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + byteReader.ptr.prototype.ReadByte = function() { + var _r$1, _r$2, _tuple, ch, err, r, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ch = $f.ch; err = $f.err; r = $f.r; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r$1 = r.ScanState.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ch = _tuple[0]; + size = _tuple[1]; + err = _tuple[2]; + /* */ if (!((size === 1)) && $interfaceIsEqual(err, $ifaceNil)) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((size === 1)) && $interfaceIsEqual(err, $ifaceNil)) { */ case 2: + _r$2 = fmt.Errorf("invalid rune %#U", new sliceType([new $Int32(ch)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + err = _r$2; + /* } */ case 3: + $s = -1; return [((ch << 24 >>> 24)), err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: byteReader.ptr.prototype.ReadByte }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.r = r; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + byteReader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; + byteReader.ptr.prototype.UnreadByte = function() { + var _r$1, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _r$1 = r.ScanState.UnreadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: byteReader.ptr.prototype.UnreadByte }; } $f._r$1 = _r$1; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + byteReader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; + Int.ptr.prototype.Scan = function(s, ch) { + var _1, _r$1, _tuple, base, ch, err, s, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tuple = $f._tuple; base = $f.base; ch = $f.ch; err = $f.err; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + $r = s.SkipSpace(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + base = 0; + _1 = ch; + if (_1 === (98)) { + base = 2; + } else if (_1 === (111)) { + base = 8; + } else if (_1 === (100)) { + base = 10; + } else if ((_1 === (120)) || (_1 === (88))) { + base = 16; + } else if ((_1 === (115)) || (_1 === (118))) { + } else { + $s = -1; return errors.New("Int.Scan: invalid verb"); + } + _r$1 = z.scan((x = new byteReader.ptr(s), new x.constructor.elem(x)), base); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + err = _tuple[2]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Scan }; } $f._1 = _1; $f._r$1 = _r$1; $f._tuple = _tuple; $f.base = base; $f.ch = ch; $f.err = err; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; + Int.ptr.prototype.GobEncode = function() { + var b, buf, i, x; + x = this; + if (x === ptrType$1.nil) { + return [sliceType$1.nil, $ifaceNil]; + } + buf = $makeSlice(sliceType$1, (1 + ($imul(x.abs.$length, 4)) >> 0)); + i = x.abs.bytes(buf) - 1 >> 0; + b = 2; + if (x.neg) { + b = (b | (1)) >>> 0; + } + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = b); + return [$subslice(buf, i), $ifaceNil]; + }; + Int.prototype.GobEncode = function() { return this.$val.GobEncode(); }; + Int.ptr.prototype.GobDecode = function(buf) { + var _r$1, b, buf, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (buf.$length === 0) { + Int.copy(z, new Int.ptr(false, nat.nil)); + $s = -1; return $ifaceNil; + } + b = (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]); + /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1: + _r$1 = fmt.Errorf("Int.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + z.neg = !((((b & 1) >>> 0) === 0)); + z.abs = z.abs.setBytes($subslice(buf, 1)); + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; + Int.ptr.prototype.MarshalText = function() { + var _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, err, text, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + text = sliceType$1.nil; + err = $ifaceNil; + x = this; + if (x === ptrType$1.nil) { + _tmp = (new sliceType$1($stringToBytes(""))); + _tmp$1 = $ifaceNil; + text = _tmp; + err = _tmp$1; + $s = -1; return [text, err]; + } + _r$1 = x.abs.itoa(x.neg, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tmp$2 = _r$1; + _tmp$3 = $ifaceNil; + text = _tmp$2; + err = _tmp$3; + $s = -1; return [text, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.MarshalText = function() { return this.$val.MarshalText(); }; + Int.ptr.prototype.UnmarshalText = function(text) { + var _r$1, _r$2, _tuple, ok, text, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.setFromScanner(bytes.NewReader(text), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ok = _tuple[1]; + /* */ if (!ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!ok) { */ case 2: + _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", new sliceType([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* } */ case 3: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; + Int.ptr.prototype.MarshalJSON = function() { + var _r$1, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = x.MarshalText(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.MarshalJSON }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); }; + Int.ptr.prototype.UnmarshalJSON = function(text) { + var _r$1, text, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (($bytesToString(text)) === "null") { + $s = -1; return $ifaceNil; + } + _r$1 = z.UnmarshalText(text); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalJSON }; } $f._r$1 = _r$1; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.UnmarshalJSON = function(text) { return this.$val.UnmarshalJSON(text); }; + nat.prototype.clear = function() { + var _i, _ref, i, z; + z = this; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = 0); + _i++; + } + }; + $ptrType(nat).prototype.clear = function() { return this.$get().clear(); }; + nat.prototype.norm = function() { + var i, x, z; + z = this; + i = z.$length; + while (true) { + if (!(i > 0 && ((x = i - 1 >> 0, ((x < 0 || x >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x])) === 0))) { break; } + i = i - (1) >> 0; + } + return $subslice(z, 0, i); + }; + $ptrType(nat).prototype.norm = function() { return this.$get().norm(); }; + nat.prototype.make = function(n) { + var n, z; + z = this; + if (n <= z.$capacity) { + return $subslice(z, 0, n); + } + if (n === 1) { + return $makeSlice(nat, 1); + } + return $makeSlice(nat, n, (n + 4 >> 0)); + }; + $ptrType(nat).prototype.make = function(n) { return this.$get().make(n); }; + nat.prototype.setWord = function(x) { + var x, z; + z = this; + if (x === 0) { + return $subslice(z, 0, 0); + } + z = z.make(1); + (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = x); + return z; + }; + $ptrType(nat).prototype.setWord = function(x) { return this.$get().setWord(x); }; + nat.prototype.setUint64 = function(x) { + var w, x, x$1, z; + z = this; + w = ((x.$low >>> 0)); + if ((x$1 = (new $Uint64(0, w.constructor === Number ? w : 1)), (x$1.$high === x.$high && x$1.$low === x.$low))) { + return z.setWord(w); + } + z = z.make(2); + (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = (($shiftRightUint64(x, 32).$low >>> 0))); + (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = ((x.$low >>> 0))); + return z; + }; + $ptrType(nat).prototype.setUint64 = function(x) { return this.$get().setUint64(x); }; + nat.prototype.set = function(x) { + var x, z; + z = this; + z = z.make(x.$length); + $copySlice(z, x); + return z; + }; + $ptrType(nat).prototype.set = function(x) { return this.$get().set(x); }; + nat.prototype.add = function(x, y) { + var c, m, n, x, x$1, x$2, x$3, y, z; + z = this; + m = x.$length; + n = y.$length; + if (m < n) { + return z.add(y, x); + } else if ((m === 0)) { + return $subslice(z, 0, 0); + } else if ((n === 0)) { + return z.set(x); + } + z = z.make(m + 1 >> 0); + c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$2(y.$array), y.$offset, y.$offset + y.$length)); + if (m > n) { + c = addVW((x$2 = $subslice(z, n, m), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); + } + ((m < 0 || m >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + m] = c); + return z.norm(); + }; + $ptrType(nat).prototype.add = function(x, y) { return this.$get().add(x, y); }; + nat.prototype.sub = function(x, y) { + var c, m, n, x, x$1, x$2, x$3, y, z; + z = this; + m = x.$length; + n = y.$length; + if (m < n) { + $panic(new $String("underflow")); + } else if ((m === 0)) { + return $subslice(z, 0, 0); + } else if ((n === 0)) { + return z.set(x); + } + z = z.make(m); + c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$2(y.$array), y.$offset, y.$offset + y.$length)); + if (m > n) { + c = subVW((x$2 = $subslice(z, n), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); + } + if (!((c === 0))) { + $panic(new $String("underflow")); + } + return z.norm(); + }; + $ptrType(nat).prototype.sub = function(x, y) { return this.$get().sub(x, y); }; + nat.prototype.cmp = function(y) { + var i, m, n, r, x, y; + r = 0; + x = this; + m = x.$length; + n = y.$length; + if (!((m === n)) || (m === 0)) { + if (m < n) { + r = -1; + } else if (m > n) { + r = 1; + } + return r; + } + i = m - 1 >> 0; + while (true) { + if (!(i > 0 && (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) === ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])))) { break; } + i = i - (1) >> 0; + } + if (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) < ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) { + r = -1; + } else if (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) > ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) { + r = 1; + } + return r; + }; + $ptrType(nat).prototype.cmp = function(y) { return this.$get().cmp(y); }; + nat.prototype.mulAddWW = function(x, y, r) { + var m, r, x, x$1, y, z; + z = this; + m = x.$length; + if ((m === 0) || (y === 0)) { + return z.setWord(r); + } + z = z.make(m + 1 >> 0); + ((m < 0 || m >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + m] = mulAddVWW((x$1 = $subslice(z, 0, m), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), y, r)); + return z.norm(); + }; + $ptrType(nat).prototype.mulAddWW = function(x, y, r) { return this.$get().mulAddWW(x, y, r); }; + basicMul = function(z, x, y) { + var _i, _ref, d, i, x, x$1, x$2, y, z; + $subslice(z, 0, (x.$length + y.$length >> 0)).clear(); + _ref = y; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((d === 0))) { + (x$2 = x.$length + i >> 0, ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = addMulVVW((x$1 = $subslice(z, i, (i + x.$length >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d))); + } + _i++; + } + }; + nat.prototype.montgomery = function(x, y, m, k, n) { + var c, c2, c3, cx, cy, d, i, k, m, n, t, x, x$1, x$2, x$3, x$4, x$5, y, z; + z = this; + if (!((x.$length === n)) || !((y.$length === n)) || !((m.$length === n))) { + $panic(new $String("math/big: mismatched montgomery number lengths")); + } + z = z.make($imul(n, 2)); + z.clear(); + c = 0; + i = 0; + while (true) { + if (!(i < n)) { break; } + d = ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]); + c2 = addMulVVW((x$1 = $subslice(z, i, (n + i >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d); + t = $imul(((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i]), k) >>> 0; + c3 = addMulVVW((x$2 = $subslice(z, i, (n + i >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), t); + cx = c + c2 >>> 0; + cy = cx + c3 >>> 0; + (x$3 = n + i >> 0, ((x$3 < 0 || x$3 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$3] = cy)); + if (cx < c2 || cy < c3) { + c = 1; + } else { + c = 0; + } + i = i + (1) >> 0; + } + if (!((c === 0))) { + subVV((x$4 = $subslice(z, 0, n), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), (x$5 = $subslice(z, n), $subslice(new sliceType$2(x$5.$array), x$5.$offset, x$5.$offset + x$5.$length)), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length)); + } else { + $copySlice($subslice(z, 0, n), $subslice(z, n)); + } + return $subslice(z, 0, n); + }; + $ptrType(nat).prototype.montgomery = function(x, y, m, k, n) { return this.$get().montgomery(x, y, m, k, n); }; + karatsubaAdd = function(z, x, n) { + var c, n, x, x$1, x$2, x$3, z; + c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); + if (!((c === 0))) { + addVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); + } + }; + karatsubaSub = function(z, x, n) { + var c, n, x, x$1, x$2, x$3, z; + c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); + if (!((c === 0))) { + subVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); + } + }; + karatsuba = function(z, x, y) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, n, n2, p, r, s, x, x0, x1, xd, y, y0, y1, yd, z; + n = y.$length; + if (!(((n & 1) === 0)) || n < karatsubaThreshold || n < 2) { + basicMul(z, x, y); + return; + } + n2 = n >> 1 >> 0; + _tmp = $subslice(x, n2); + _tmp$1 = $subslice(x, 0, n2); + x1 = _tmp; + x0 = _tmp$1; + _tmp$2 = $subslice(y, n2); + _tmp$3 = $subslice(y, 0, n2); + y1 = _tmp$2; + y0 = _tmp$3; + karatsuba(z, x0, y0); + karatsuba($subslice(z, n), x1, y1); + s = 1; + xd = $subslice(z, ($imul(2, n)), (($imul(2, n)) + n2 >> 0)); + if (!((subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length)) === 0))) { + s = -s; + subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length)); + } + yd = $subslice(z, (($imul(2, n)) + n2 >> 0), ($imul(3, n))); + if (!((subVV($subslice(new sliceType$2(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$2(y0.$array), y0.$offset, y0.$offset + y0.$length), $subslice(new sliceType$2(y1.$array), y1.$offset, y1.$offset + y1.$length)) === 0))) { + s = -s; + subVV($subslice(new sliceType$2(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$2(y1.$array), y1.$offset, y1.$offset + y1.$length), $subslice(new sliceType$2(y0.$array), y0.$offset, y0.$offset + y0.$length)); + } + p = $subslice(z, ($imul(n, 3))); + karatsuba(p, xd, yd); + r = $subslice(z, ($imul(n, 4))); + $copySlice(r, $subslice(z, 0, ($imul(n, 2)))); + karatsubaAdd($subslice(z, n2), r, n); + karatsubaAdd($subslice(z, n2), $subslice(r, n), n); + if (s > 0) { + karatsubaAdd($subslice(z, n2), p, n); + } else { + karatsubaSub($subslice(z, n2), p, n); + } + }; + alias = function(x, y) { + var x, x$1, x$2, y; + return x.$capacity > 0 && y.$capacity > 0 && (x$1 = $subslice(x, 0, x.$capacity), $indexPtr(x$1.$array, x$1.$offset + (x.$capacity - 1 >> 0), ptrType$3)) === (x$2 = $subslice(y, 0, y.$capacity), $indexPtr(x$2.$array, x$2.$offset + (y.$capacity - 1 >> 0), ptrType$3)); + }; + addAt = function(z, x, i) { + var c, i, j, n, x, x$1, x$2, x$3, x$4, z; + n = x.$length; + if (n > 0) { + c = addVV((x$1 = $subslice(z, i, (i + n >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (x$2 = $subslice(z, i), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); + if (!((c === 0))) { + j = i + n >> 0; + if (j < z.$length) { + addVW((x$3 = $subslice(z, j), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = $subslice(z, j), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), c); + } + } + } + }; + max = function(x, y) { + var x, y; + if (x > y) { + return x; + } + return y; + }; + karatsubaLen = function(n, threshold) { + var i, n, threshold, y; + i = 0; + while (true) { + if (!(n > threshold)) { break; } + n = (n >> $min((1), 31)) >> 0; + i = i + (1) >>> 0; + } + return (y = i, y < 32 ? (n << y) : 0) >> 0; + }; + nat.prototype.mul = function(x, y) { + var i, k, m, n, t, x, x0, x0$1, xi, y, y0, y0$1, y1, z; + z = this; + m = x.$length; + n = y.$length; + if (m < n) { + return z.mul(y, x); + } else if ((m === 0) || (n === 0)) { + return $subslice(z, 0, 0); + } else if ((n === 1)) { + return z.mulAddWW(x, (0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]), 0); + } + if (alias(z, x) || alias(z, y)) { + z = nat.nil; + } + if (n < karatsubaThreshold) { + z = z.make(m + n >> 0); + basicMul(z, x, y); + return z.norm(); + } + k = karatsubaLen(n, karatsubaThreshold); + x0 = $subslice(x, 0, k); + y0 = $subslice(y, 0, k); + z = z.make(max($imul(6, k), m + n >> 0)); + karatsuba(z, x0, y0); + z = $subslice(z, 0, (m + n >> 0)); + $subslice(z, ($imul(2, k))).clear(); + if (k < n || !((m === n))) { + t = nat.nil; + x0$1 = x0.norm(); + y1 = $subslice(y, k); + t = t.mul(x0$1, y1); + addAt(z, t, k); + y0$1 = y0.norm(); + i = k; + while (true) { + if (!(i < x.$length)) { break; } + xi = $subslice(x, i); + if (xi.$length > k) { + xi = $subslice(xi, 0, k); + } + xi = xi.norm(); + t = t.mul(xi, y0$1); + addAt(z, t, i); + t = t.mul(xi, y1); + addAt(z, t, i + k >> 0); + i = i + (k) >> 0; + } + } + return z.norm(); + }; + $ptrType(nat).prototype.mul = function(x, y) { return this.$get().mul(x, y); }; + basicSqr = function(z, x) { + var _tuple, _tuple$1, d, i, n, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, z; + n = x.$length; + t = $makeSlice(nat, ($imul(2, n))); + _tuple = mulWW((0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]), (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = _tuple[0]); + (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = _tuple[1]); + i = 1; + while (true) { + if (!(i < n)) { break; } + d = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]); + _tuple$1 = mulWW(d, d); + (x$1 = ($imul(2, i)) + 1 >> 0, ((x$1 < 0 || x$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$1] = _tuple$1[0])); + (x$2 = $imul(2, i), ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = _tuple$1[1])); + (x$5 = $imul(2, i), ((x$5 < 0 || x$5 >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + x$5] = addMulVVW((x$3 = $subslice(t, i, ($imul(2, i))), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = $subslice(x, 0, i), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), d))); + i = i + (1) >> 0; + } + (x$8 = ($imul(2, n)) - 1 >> 0, ((x$8 < 0 || x$8 >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + x$8] = shlVU((x$6 = $subslice(t, 1, (($imul(2, n)) - 1 >> 0)), $subslice(new sliceType$2(x$6.$array), x$6.$offset, x$6.$offset + x$6.$length)), (x$7 = $subslice(t, 1, (($imul(2, n)) - 1 >> 0)), $subslice(new sliceType$2(x$7.$array), x$7.$offset, x$7.$offset + x$7.$length)), 1))); + addVV($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(t.$array), t.$offset, t.$offset + t.$length)); + }; + karatsubaSqr = function(z, x) { + var _tmp, _tmp$1, n, n2, p, r, x, x0, x1, xd, z; + n = x.$length; + if (!(((n & 1) === 0)) || n < karatsubaSqrThreshold || n < 2) { + basicSqr($subslice(z, 0, ($imul(2, n))), x); + return; + } + n2 = n >> 1 >> 0; + _tmp = $subslice(x, n2); + _tmp$1 = $subslice(x, 0, n2); + x1 = _tmp; + x0 = _tmp$1; + karatsubaSqr(z, x0); + karatsubaSqr($subslice(z, n), x1); + xd = $subslice(z, ($imul(2, n)), (($imul(2, n)) + n2 >> 0)); + if (!((subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length)) === 0))) { + subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length)); + } + p = $subslice(z, ($imul(n, 3))); + karatsubaSqr(p, xd); + r = $subslice(z, ($imul(n, 4))); + $copySlice(r, $subslice(z, 0, ($imul(n, 2)))); + karatsubaAdd($subslice(z, n2), r, n); + karatsubaAdd($subslice(z, n2), $subslice(r, n), n); + karatsubaSub($subslice(z, n2), p, n); + }; + nat.prototype.sqr = function(x) { + var _tuple, d, k, n, t, x, x0, x0$1, x1, z; + z = this; + n = x.$length; + if ((n === 0)) { + return $subslice(z, 0, 0); + } else if ((n === 1)) { + d = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); + z = z.make(2); + _tuple = mulWW(d, d); + (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = _tuple[0]); + (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = _tuple[1]); + return z.norm(); + } + if (alias(z, x)) { + z = nat.nil; + } + if (n < basicSqrThreshold) { + z = z.make($imul(2, n)); + basicMul(z, x, x); + return z.norm(); + } + if (n < karatsubaSqrThreshold) { + z = z.make($imul(2, n)); + basicSqr(z, x); + return z.norm(); + } + k = karatsubaLen(n, karatsubaSqrThreshold); + x0 = $subslice(x, 0, k); + z = z.make(max($imul(6, k), $imul(2, n))); + karatsubaSqr(z, x0); + z = $subslice(z, 0, ($imul(2, n))); + $subslice(z, ($imul(2, k))).clear(); + if (k < n) { + t = nat.nil; + x0$1 = x0.norm(); + x1 = $subslice(x, k); + t = t.mul(x0$1, x1); + addAt(z, t, k); + addAt(z, t, k); + t = t.sqr(x1); + addAt(z, t, $imul(2, k)); + } + return z.norm(); + }; + $ptrType(nat).prototype.sqr = function(x) { return this.$get().sqr(x); }; + nat.prototype.mulRange = function(a, b) { + var a, b, m, x, z; + z = this; + if ((a.$high === 0 && a.$low === 0)) { + return z.setUint64(new $Uint64(0, 0)); + } else if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { + return z.setUint64(new $Uint64(0, 1)); + } else if ((a.$high === b.$high && a.$low === b.$low)) { + return z.setUint64(a); + } else if ((x = new $Uint64(a.$high + 0, a.$low + 1), (x.$high === b.$high && x.$low === b.$low))) { + return z.mul((nat.nil).setUint64(a), (nat.nil).setUint64(b)); + } + m = $div64((new $Uint64(a.$high + b.$high, a.$low + b.$low)), new $Uint64(0, 2), false); + return z.mul((nat.nil).mulRange(a, m), (nat.nil).mulRange(new $Uint64(m.$high + 0, m.$low + 1), b)); + }; + $ptrType(nat).prototype.mulRange = function(a, b) { return this.$get().mulRange(a, b); }; + nat.prototype.divW = function(x, y) { + var m, q, r, x, y, z; + q = nat.nil; + r = 0; + z = this; + m = x.$length; + if ((y === 0)) { + $panic(new $String("division by zero")); + } else if ((y === 1)) { + q = z.set(x); + return [q, r]; + } else if ((m === 0)) { + q = $subslice(z, 0, 0); + return [q, r]; + } + z = z.make(m); + r = divWVW($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), 0, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), y); + q = z.norm(); + return [q, r]; + }; + $ptrType(nat).prototype.divW = function(x, y) { return this.$get().divW(x, y); }; + nat.prototype.div = function(z2, u, v) { + var _r$1, _tuple, _tuple$1, q, r, r2, u, v, z, z2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; q = $f.q; r = $f.r; r2 = $f.r2; u = $f.u; v = $f.v; z = $f.z; z2 = $f.z2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + q = nat.nil; + r = nat.nil; + z = this; + if (v.$length === 0) { + $panic(new $String("division by zero")); + } + if (u.cmp(v) < 0) { + q = $subslice(z, 0, 0); + r = z2.set(u); + $s = -1; return [q, r]; + } + if (v.$length === 1) { + r2 = 0; + _tuple = z.divW(u, (0 >= v.$length ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + 0])); + q = _tuple[0]; + r2 = _tuple[1]; + r = z2.setWord(r2); + $s = -1; return [q, r]; + } + _r$1 = z.divLarge(z2, u, v); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + q = _tuple$1[0]; + r = _tuple$1[1]; + $s = -1; return [q, r]; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.div }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.q = q; $f.r = r; $f.r2 = r2; $f.u = u; $f.v = v; $f.z = z; $f.z2 = z2; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.div = function(z2, u, v) { return this.$get().div(z2, u, v); }; + getNat = function(n) { + var _r$1, n, v, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; n = $f.n; v = $f.v; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = ptrType$4.nil; + _r$1 = natPool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v = _r$1; + if (!($interfaceIsEqual(v, $ifaceNil))) { + z = $assertType(v, ptrType$4); + } + if (z === ptrType$4.nil) { + z = $newDataPointer(nat.nil, ptrType$4); + } + z.$set(z.make(n)); + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: getNat }; } $f._r$1 = _r$1; $f.n = n; $f.v = v; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + putNat = function(x) { + var x; + natPool.Put(x); + }; + nat.prototype.divLarge = function(u, uIn, vIn) { + var _index, _r$1, _r$2, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, c, c$1, j, m, n, prevRhat, q, qhat, qhatv, qhatvp, r, rhat, shift, u, uIn, ujn, ujn2, v, vIn, vn1, vn2, vp, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, x1, x2, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _index = $f._index; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; c = $f.c; c$1 = $f.c$1; j = $f.j; m = $f.m; n = $f.n; prevRhat = $f.prevRhat; q = $f.q; qhat = $f.qhat; qhatv = $f.qhatv; qhatvp = $f.qhatvp; r = $f.r; rhat = $f.rhat; shift = $f.shift; u = $f.u; uIn = $f.uIn; ujn = $f.ujn; ujn2 = $f.ujn2; v = $f.v; vIn = $f.vIn; vn1 = $f.vn1; vn2 = $f.vn2; vp = $f.vp; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; x1 = $f.x1; x2 = $f.x2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + q = nat.nil; + r = nat.nil; + z = this; + n = vIn.$length; + m = uIn.$length - n >> 0; + shift = nlz((x = n - 1 >> 0, ((x < 0 || x >= vIn.$length) ? ($throwRuntimeError("index out of range"), undefined) : vIn.$array[vIn.$offset + x]))); + _r$1 = getNat(n); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + vp = _r$1; + v = vp.$get(); + shlVU($subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length), $subslice(new sliceType$2(vIn.$array), vIn.$offset, vIn.$offset + vIn.$length), shift); + u = u.make(uIn.$length + 1 >> 0); + (x$2 = uIn.$length, ((x$2 < 0 || x$2 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$2] = shlVU((x$1 = $subslice(u, 0, uIn.$length), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(uIn.$array), uIn.$offset, uIn.$offset + uIn.$length), shift))); + if (alias(z, u)) { + z = nat.nil; + } + q = z.make(m + 1 >> 0); + _r$2 = getNat(n + 1 >> 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + qhatvp = _r$2; + qhatv = qhatvp.$get(); + vn1 = (x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= v.$length) ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + x$3])); + j = m; + while (true) { + if (!(j >= 0)) { break; } + qhat = 4294967295; + ujn = (x$4 = j + n >> 0, ((x$4 < 0 || x$4 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$4])); + if (!((ujn === vn1))) { + rhat = 0; + _tuple = divWW(ujn, (x$5 = (j + n >> 0) - 1 >> 0, ((x$5 < 0 || x$5 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$5])), vn1); + qhat = _tuple[0]; + rhat = _tuple[1]; + vn2 = (x$6 = n - 2 >> 0, ((x$6 < 0 || x$6 >= v.$length) ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + x$6])); + _tuple$1 = mulWW(qhat, vn2); + x1 = _tuple$1[0]; + x2 = _tuple$1[1]; + ujn2 = (x$7 = (j + n >> 0) - 2 >> 0, ((x$7 < 0 || x$7 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$7])); + while (true) { + if (!(greaterThan(x1, x2, rhat, ujn2))) { break; } + qhat = qhat - (1) >>> 0; + prevRhat = rhat; + rhat = rhat + (vn1) >>> 0; + if (rhat < prevRhat) { + break; + } + _tuple$2 = mulWW(qhat, vn2); + x1 = _tuple$2[0]; + x2 = _tuple$2[1]; + } + } + ((n < 0 || n >= qhatv.$length) ? ($throwRuntimeError("index out of range"), undefined) : qhatv.$array[qhatv.$offset + n] = mulAddVWW((x$8 = $subslice(qhatv, 0, n), $subslice(new sliceType$2(x$8.$array), x$8.$offset, x$8.$offset + x$8.$length)), $subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length), qhat, 0)); + c = subVV((x$9 = $subslice(u, j, (j + qhatv.$length >> 0)), $subslice(new sliceType$2(x$9.$array), x$9.$offset, x$9.$offset + x$9.$length)), (x$10 = $subslice(u, j), $subslice(new sliceType$2(x$10.$array), x$10.$offset, x$10.$offset + x$10.$length)), $subslice(new sliceType$2(qhatv.$array), qhatv.$offset, qhatv.$offset + qhatv.$length)); + if (!((c === 0))) { + c$1 = addVV((x$11 = $subslice(u, j, (j + n >> 0)), $subslice(new sliceType$2(x$11.$array), x$11.$offset, x$11.$offset + x$11.$length)), (x$12 = $subslice(u, j), $subslice(new sliceType$2(x$12.$array), x$12.$offset, x$12.$offset + x$12.$length)), $subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length)); + _index = j + n >> 0; + ((_index < 0 || _index >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + _index] = (((_index < 0 || _index >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + _index]) + (c$1) >>> 0)); + qhat = qhat - (1) >>> 0; + } + ((j < 0 || j >= q.$length) ? ($throwRuntimeError("index out of range"), undefined) : q.$array[q.$offset + j] = qhat); + j = j - (1) >> 0; + } + putNat(vp); + putNat(qhatvp); + q = q.norm(); + shrVU($subslice(new sliceType$2(u.$array), u.$offset, u.$offset + u.$length), $subslice(new sliceType$2(u.$array), u.$offset, u.$offset + u.$length), shift); + r = u.norm(); + _tmp = q; + _tmp$1 = r; + q = _tmp; + r = _tmp$1; + $s = -1; return [q, r]; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.divLarge }; } $f._index = _index; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.c = c; $f.c$1 = c$1; $f.j = j; $f.m = m; $f.n = n; $f.prevRhat = prevRhat; $f.q = q; $f.qhat = qhat; $f.qhatv = qhatv; $f.qhatvp = qhatvp; $f.r = r; $f.rhat = rhat; $f.shift = shift; $f.u = u; $f.uIn = uIn; $f.ujn = ujn; $f.ujn2 = ujn2; $f.v = v; $f.vIn = vIn; $f.vn1 = vn1; $f.vn2 = vn2; $f.vp = vp; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.x1 = x1; $f.x2 = x2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.divLarge = function(u, uIn, vIn) { return this.$get().divLarge(u, uIn, vIn); }; + nat.prototype.bitLen = function() { + var i, x; + x = this; + i = x.$length - 1 >> 0; + if (i >= 0) { + return ($imul(i, 32)) + bits.Len(((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0))) >> 0; + } + return 0; + }; + $ptrType(nat).prototype.bitLen = function() { return this.$get().bitLen(); }; + nat.prototype.trailingZeroBits = function() { + var i, x; + x = this; + if (x.$length === 0) { + return 0; + } + i = 0; + while (true) { + if (!(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) === 0)) { break; } + i = i + (1) >>> 0; + } + return (i * 32 >>> 0) + ((bits.TrailingZeros(((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0))) >>> 0)) >>> 0; + }; + $ptrType(nat).prototype.trailingZeroBits = function() { return this.$get().trailingZeroBits(); }; + same = function(x, y) { + var x, y; + return (x.$length === y.$length) && x.$length > 0 && $indexPtr(x.$array, x.$offset + 0, ptrType$3) === $indexPtr(y.$array, y.$offset + 0, ptrType$3); + }; + nat.prototype.shl = function(x, s) { + var _q, _r$1, m, n, s, x, x$1, z; + z = this; + if (s === 0) { + if (same(z, x)) { + return z; + } + if (!alias(z, x)) { + return z.set(x); + } + } + m = x.$length; + if (m === 0) { + return $subslice(z, 0, 0); + } + n = m + (((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) >> 0; + z = z.make(n + 1 >> 0); + ((n < 0 || n >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + n] = shlVU((x$1 = $subslice(z, (n - m >> 0), n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), (_r$1 = s % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")))); + $subslice(z, 0, (n - m >> 0)).clear(); + return z.norm(); + }; + $ptrType(nat).prototype.shl = function(x, s) { return this.$get().shl(x, s); }; + nat.prototype.shr = function(x, s) { + var _q, _r$1, m, n, s, x, x$1, z; + z = this; + if (s === 0) { + if (same(z, x)) { + return z; + } + if (!alias(z, x)) { + return z.set(x); + } + } + m = x.$length; + n = m - (((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) >> 0; + if (n <= 0) { + return $subslice(z, 0, 0); + } + z = z.make(n); + shrVU($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), (x$1 = $subslice(x, (m - n >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (_r$1 = s % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))); + return z.norm(); + }; + $ptrType(nat).prototype.shr = function(x, s) { return this.$get().shr(x, s); }; + nat.prototype.setBit = function(x, i, b) { + var _1, _q, _r$1, b, i, j, m, n, x, y, z; + z = this; + j = (((_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + m = (y = ((_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (1 << y) : 0) >>> 0; + n = x.$length; + _1 = b; + if (_1 === (0)) { + z = z.make(n); + $copySlice(z, x); + if (j >= n) { + return z; + } + ((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j] = ((((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j]) & ~(m)) >>> 0)); + return z.norm(); + } else if (_1 === (1)) { + if (j >= n) { + z = z.make(j + 1 >> 0); + $subslice(z, n).clear(); + } else { + z = z.make(n); + } + $copySlice(z, x); + ((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j] = ((((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j]) | (m)) >>> 0)); + return z; + } + $panic(new $String("set bit is not 0 or 1")); + }; + $ptrType(nat).prototype.setBit = function(x, i, b) { return this.$get().setBit(x, i, b); }; + nat.prototype.bit = function(i) { + var _q, _r$1, i, j, x, y; + x = this; + j = (_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + if (j >= ((x.$length >>> 0))) { + return 0; + } + return ((((((y = ((_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]) >>> y) : 0) >>> 0) & 1) >>> 0) >>> 0)); + }; + $ptrType(nat).prototype.bit = function(i) { return this.$get().bit(i); }; + nat.prototype.sticky = function(i) { + var _i, _q, _r$1, _ref, i, j, x, x$1, y; + x = this; + j = (_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + if (j >= ((x.$length >>> 0))) { + if (x.$length === 0) { + return 0; + } + return 1; + } + _ref = $subslice(x, 0, j); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + x$1 = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((x$1 === 0))) { + return 1; + } + _i++; + } + if (!((((y = ((32 - (_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)), y < 32 ? (((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]) << y) : 0) >>> 0) === 0))) { + return 1; + } + return 0; + }; + $ptrType(nat).prototype.sticky = function(i) { return this.$get().sticky(i); }; + nat.prototype.and = function(x, y) { + var i, m, n, x, y, z; + z = this; + m = x.$length; + n = y.$length; + if (m > n) { + m = n; + } + z = z.make(m); + i = 0; + while (true) { + if (!(i < m)) { break; } + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); + i = i + (1) >> 0; + } + return z.norm(); + }; + $ptrType(nat).prototype.and = function(x, y) { return this.$get().and(x, y); }; + nat.prototype.andNot = function(x, y) { + var i, m, n, x, y, z; + z = this; + m = x.$length; + n = y.$length; + if (n > m) { + n = m; + } + z = z.make(m); + i = 0; + while (true) { + if (!(i < n)) { break; } + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & ~((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); + i = i + (1) >> 0; + } + $copySlice($subslice(z, n, m), $subslice(x, n, m)); + return z.norm(); + }; + $ptrType(nat).prototype.andNot = function(x, y) { return this.$get().andNot(x, y); }; + nat.prototype.or = function(x, y) { + var _tmp, _tmp$1, i, m, n, s, x, y, z; + z = this; + m = x.$length; + n = y.$length; + s = x; + if (m < n) { + _tmp = m; + _tmp$1 = n; + n = _tmp; + m = _tmp$1; + s = y; + } + z = z.make(m); + i = 0; + while (true) { + if (!(i < n)) { break; } + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) | ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); + i = i + (1) >> 0; + } + $copySlice($subslice(z, n, m), $subslice(s, n, m)); + return z.norm(); + }; + $ptrType(nat).prototype.or = function(x, y) { return this.$get().or(x, y); }; + nat.prototype.xor = function(x, y) { + var _tmp, _tmp$1, i, m, n, s, x, y, z; + z = this; + m = x.$length; + n = y.$length; + s = x; + if (m < n) { + _tmp = m; + _tmp$1 = n; + n = _tmp; + m = _tmp$1; + s = y; + } + z = z.make(m); + i = 0; + while (true) { + if (!(i < n)) { break; } + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) ^ ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); + i = i + (1) >> 0; + } + $copySlice($subslice(z, n, m), $subslice(s, n, m)); + return z.norm(); + }; + $ptrType(nat).prototype.xor = function(x, y) { return this.$get().xor(x, y); }; + greaterThan = function(x1, x2, y1, y2) { + var x1, x2, y1, y2; + return x1 > y1 || (x1 === y1) && x2 > y2; + }; + nat.prototype.modW = function(d) { + var d, q, r, x; + r = 0; + x = this; + q = nat.nil; + q = q.make(x.$length); + r = divWVW($subslice(new sliceType$2(q.$array), q.$offset, q.$offset + q.$length), 0, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d); + return r; + }; + $ptrType(nat).prototype.modW = function(d) { return this.$get().modW(d); }; + nat.prototype.random = function(rand$1, limit, n) { + var _1, _i, _i$1, _index, _r$1, _r$2, _r$3, _ref, _ref$1, bitLengthOfMSW, i, i$1, limit, mask, n, rand$1, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _index = $f._index; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; bitLengthOfMSW = $f.bitLengthOfMSW; i = $f.i; i$1 = $f.i$1; limit = $f.limit; mask = $f.mask; n = $f.n; rand$1 = $f.rand$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (alias(z, limit)) { + z = nat.nil; + } + z = z.make(limit.$length); + bitLengthOfMSW = (((_r$1 = n % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)); + if (bitLengthOfMSW === 0) { + bitLengthOfMSW = 32; + } + mask = (((((y = bitLengthOfMSW, y < 32 ? (1 << y) : 0) >>> 0)) - 1 >>> 0)); + /* while (true) { */ case 1: + _1 = 32; + /* */ if (_1 === (32)) { $s = 4; continue; } + /* */ if (_1 === (64)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_1 === (32)) { */ case 4: + _ref = z; + _i = 0; + /* while (true) { */ case 8: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 9; continue; } + i = _i; + _r$2 = rand$1.Uint32(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((_r$2 >>> 0))); + _i++; + /* } */ $s = 8; continue; case 9: + $s = 7; continue; + /* } else if (_1 === (64)) { */ case 5: + _ref$1 = z; + _i$1 = 0; + /* while (true) { */ case 11: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 12; continue; } + i$1 = _i$1; + _r$3 = rand$1.Uint32(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = ((((_r$3 >>> 0)) | 0) >>> 0)); + _i$1++; + /* } */ $s = 11; continue; case 12: + $s = 7; continue; + /* } else { */ case 6: + $panic(new $String("unknown word size")); + /* } */ case 7: + case 3: + _index = limit.$length - 1 >> 0; + ((_index < 0 || _index >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + _index] = ((((_index < 0 || _index >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + _index]) & (mask)) >>> 0)); + if (z.cmp(limit) < 0) { + /* break; */ $s = 2; continue; + } + /* } */ $s = 1; continue; case 2: + $s = -1; return z.norm(); + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.random }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._index = _index; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.bitLengthOfMSW = bitLengthOfMSW; $f.i = i; $f.i$1 = i$1; $f.limit = limit; $f.mask = mask; $f.n = n; $f.rand$1 = rand$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.random = function(rand$1, limit, n) { return this.$get().random(rand$1, limit, n); }; + nat.prototype.expNN = function(x, y, m) { + var _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, i, j, j$1, m, q, r, shift, v, w, x, x$1, y, y$1, y$2, y$3, z, zz, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; i = $f.i; j = $f.j; j$1 = $f.j$1; m = $f.m; q = $f.q; r = $f.r; shift = $f.shift; v = $f.v; w = $f.w; x = $f.x; x$1 = $f.x$1; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (alias(z, x) || alias(z, y)) { + z = nat.nil; + } + if ((m.$length === 1) && ((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) === 1)) { + $s = -1; return z.setWord(0); + } + if (y.$length === 0) { + $s = -1; return z.setWord(1); + } + /* */ if ((y.$length === 1) && ((0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]) === 1) && !((m.$length === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((y.$length === 1) && ((0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]) === 1) && !((m.$length === 0))) { */ case 1: + _r$1 = (nat.nil).div(z, x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z = _tuple[1]; + $s = -1; return z; + /* } */ case 2: + if (!((m.$length === 0))) { + z = z.make(m.$length); + } + z = z.set(x); + /* */ if (x.cmp(natOne) > 0 && y.$length > 1 && m.$length > 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (x.cmp(natOne) > 0 && y.$length > 1 && m.$length > 0) { */ case 4: + /* */ if ((((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) & 1) >>> 0) === 1) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) & 1) >>> 0) === 1) { */ case 6: + _r$2 = z.expNNMontgomery(x, y, m); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* } */ case 7: + _r$3 = z.expNNWindowed(x, y, m); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $s = -1; return _r$3; + /* } */ case 5: + v = (x$1 = y.$length - 1 >> 0, ((x$1 < 0 || x$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + x$1])); + shift = nlz(v) + 1 >>> 0; + v = (y$1 = (shift), y$1 < 32 ? (v << y$1) : 0) >>> 0; + q = nat.nil; + w = 32 - ((shift >> 0)) >> 0; + _tmp = nat.nil; + _tmp$1 = nat.nil; + zz = _tmp; + r = _tmp$1; + j = 0; + /* while (true) { */ case 10: + /* if (!(j < w)) { break; } */ if(!(j < w)) { $s = 11; continue; } + zz = zz.sqr(z); + _tmp$2 = z; + _tmp$3 = zz; + zz = _tmp$2; + z = _tmp$3; + if (!((((v & 2147483648) >>> 0) === 0))) { + zz = zz.mul(z, x); + _tmp$4 = z; + _tmp$5 = zz; + zz = _tmp$4; + z = _tmp$5; + } + /* */ if (!((m.$length === 0))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (!((m.$length === 0))) { */ case 12: + _r$4 = zz.div(r, z, m); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + zz = _tuple$1[0]; + r = _tuple$1[1]; + _tmp$6 = q; + _tmp$7 = z; + _tmp$8 = zz; + _tmp$9 = r; + zz = _tmp$6; + r = _tmp$7; + q = _tmp$8; + z = _tmp$9; + /* } */ case 13: + v = (y$2 = (1), y$2 < 32 ? (v << y$2) : 0) >>> 0; + j = j + (1) >> 0; + /* } */ $s = 10; continue; case 11: + i = y.$length - 2 >> 0; + /* while (true) { */ case 15: + /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 16; continue; } + v = ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]); + j$1 = 0; + /* while (true) { */ case 17: + /* if (!(j$1 < 32)) { break; } */ if(!(j$1 < 32)) { $s = 18; continue; } + zz = zz.sqr(z); + _tmp$10 = z; + _tmp$11 = zz; + zz = _tmp$10; + z = _tmp$11; + if (!((((v & 2147483648) >>> 0) === 0))) { + zz = zz.mul(z, x); + _tmp$12 = z; + _tmp$13 = zz; + zz = _tmp$12; + z = _tmp$13; + } + /* */ if (!((m.$length === 0))) { $s = 19; continue; } + /* */ $s = 20; continue; + /* if (!((m.$length === 0))) { */ case 19: + _r$5 = zz.div(r, z, m); /* */ $s = 21; case 21: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$2 = _r$5; + zz = _tuple$2[0]; + r = _tuple$2[1]; + _tmp$14 = q; + _tmp$15 = z; + _tmp$16 = zz; + _tmp$17 = r; + zz = _tmp$14; + r = _tmp$15; + q = _tmp$16; + z = _tmp$17; + /* } */ case 20: + v = (y$3 = (1), y$3 < 32 ? (v << y$3) : 0) >>> 0; + j$1 = j$1 + (1) >> 0; + /* } */ $s = 17; continue; case 18: + i = i - (1) >> 0; + /* } */ $s = 15; continue; case 16: + $s = -1; return z.norm(); + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNN }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.i = i; $f.j = j; $f.j$1 = j$1; $f.m = m; $f.q = q; $f.r = r; $f.shift = shift; $f.v = v; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.expNN = function(x, y, m) { return this.$get().expNN(x, y, m); }; + nat.prototype.expNNWindowed = function(x, y, m) { + var _q, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, i, i$1, j, m, p, p1, p2, powers, r, x, x$1, y, y$1, yi, z, zz, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; i = $f.i; i$1 = $f.i$1; j = $f.j; m = $f.m; p = $f.p; p1 = $f.p1; p2 = $f.p2; powers = $f.powers; r = $f.r; x = $f.x; x$1 = $f.x$1; y = $f.y; y$1 = $f.y$1; yi = $f.yi; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _tmp = nat.nil; + _tmp$1 = nat.nil; + zz = _tmp; + r = _tmp$1; + powers = arrayType$1.zero(); + powers[0] = natOne; + powers[1] = x; + i = 2; + /* while (true) { */ case 1: + /* if (!(i < 16)) { break; } */ if(!(i < 16)) { $s = 2; continue; } + _tmp$2 = $indexPtr(powers, (_q = i / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), ptrType$4); + _tmp$3 = $indexPtr(powers, i, ptrType$4); + _tmp$4 = $indexPtr(powers, (i + 1 >> 0), ptrType$4); + p2 = _tmp$2; + p = _tmp$3; + p1 = _tmp$4; + p.$set(p.sqr(p2.$get())); + _r$1 = zz.div(r, p.$get(), m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + zz = _tuple[0]; + r = _tuple[1]; + _tmp$5 = r; + _tmp$6 = p.$get(); + p.$set(_tmp$5); + r = _tmp$6; + p1.$set(p1.mul(p.$get(), x)); + _r$2 = zz.div(r, p1.$get(), m); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + zz = _tuple$1[0]; + r = _tuple$1[1]; + _tmp$7 = r; + _tmp$8 = p1.$get(); + p1.$set(_tmp$7); + r = _tmp$8; + i = i + (2) >> 0; + /* } */ $s = 1; continue; case 2: + z = z.setWord(1); + i$1 = y.$length - 1 >> 0; + /* while (true) { */ case 5: + /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 6; continue; } + yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); + j = 0; + /* while (true) { */ case 7: + /* if (!(j < 32)) { break; } */ if(!(j < 32)) { $s = 8; continue; } + /* */ if (!((i$1 === (y.$length - 1 >> 0))) || !((j === 0))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!((i$1 === (y.$length - 1 >> 0))) || !((j === 0))) { */ case 9: + zz = zz.sqr(z); + _tmp$9 = z; + _tmp$10 = zz; + zz = _tmp$9; + z = _tmp$10; + _r$3 = zz.div(r, z, m); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$2 = _r$3; + zz = _tuple$2[0]; + r = _tuple$2[1]; + _tmp$11 = r; + _tmp$12 = z; + z = _tmp$11; + r = _tmp$12; + zz = zz.sqr(z); + _tmp$13 = z; + _tmp$14 = zz; + zz = _tmp$13; + z = _tmp$14; + _r$4 = zz.div(r, z, m); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$3 = _r$4; + zz = _tuple$3[0]; + r = _tuple$3[1]; + _tmp$15 = r; + _tmp$16 = z; + z = _tmp$15; + r = _tmp$16; + zz = zz.sqr(z); + _tmp$17 = z; + _tmp$18 = zz; + zz = _tmp$17; + z = _tmp$18; + _r$5 = zz.div(r, z, m); /* */ $s = 13; case 13: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$4 = _r$5; + zz = _tuple$4[0]; + r = _tuple$4[1]; + _tmp$19 = r; + _tmp$20 = z; + z = _tmp$19; + r = _tmp$20; + zz = zz.sqr(z); + _tmp$21 = z; + _tmp$22 = zz; + zz = _tmp$21; + z = _tmp$22; + _r$6 = zz.div(r, z, m); /* */ $s = 14; case 14: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple$5 = _r$6; + zz = _tuple$5[0]; + r = _tuple$5[1]; + _tmp$23 = r; + _tmp$24 = z; + z = _tmp$23; + r = _tmp$24; + /* } */ case 10: + zz = zz.mul(z, (x$1 = yi >>> 28 >>> 0, ((x$1 < 0 || x$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$1]))); + _tmp$25 = z; + _tmp$26 = zz; + zz = _tmp$25; + z = _tmp$26; + _r$7 = zz.div(r, z, m); /* */ $s = 15; case 15: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _tuple$6 = _r$7; + zz = _tuple$6[0]; + r = _tuple$6[1]; + _tmp$27 = r; + _tmp$28 = z; + z = _tmp$27; + r = _tmp$28; + yi = (y$1 = (4), y$1 < 32 ? (yi << y$1) : 0) >>> 0; + j = j + (4) >> 0; + /* } */ $s = 7; continue; case 8: + i$1 = i$1 - (1) >> 0; + /* } */ $s = 5; continue; case 6: + $s = -1; return z.norm(); + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNNWindowed }; } $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.i = i; $f.i$1 = i$1; $f.j = j; $f.m = m; $f.p = p; $f.p1 = p1; $f.p2 = p2; $f.powers = powers; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.y$1 = y$1; $f.yi = yi; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.expNNWindowed = function(x, y, m) { return this.$get().expNNWindowed(x, y, m); }; + nat.prototype.expNNMontgomery = function(x, y, m) { + var RR, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, i, i$1, i$2, j, k0, m, numWords, one, powers, rr, t, x, x$1, x$2, y, y$1, y$2, yi, z, zz, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; RR = $f.RR; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; j = $f.j; k0 = $f.k0; m = $f.m; numWords = $f.numWords; one = $f.one; powers = $f.powers; rr = $f.rr; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; yi = $f.yi; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + numWords = m.$length; + /* */ if (x.$length > numWords) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (x.$length > numWords) { */ case 1: + _r$1 = (nat.nil).div(nat.nil, x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + x = _tuple[1]; + /* } */ case 2: + if (x.$length < numWords) { + rr = $makeSlice(nat, numWords); + $copySlice(rr, x); + x = rr; + } + k0 = 2 - (0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) >>> 0; + t = (0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) - 1 >>> 0; + i = 1; + while (true) { + if (!(i < 32)) { break; } + t = $imul(t, (t)) >>> 0; + k0 = $imul(k0, (((t + 1 >>> 0)))) >>> 0; + i = (y$1 = (1), y$1 < 32 ? (i << y$1) : 0) >> 0; + } + k0 = -k0 >>> 0; + RR = (nat.nil).setWord(1); + zz = (nat.nil).shl(RR, ((($imul(($imul(2, numWords)), 32)) >>> 0))); + _r$2 = (nat.nil).div(RR, zz, m); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + RR = _tuple$1[1]; + if (RR.$length < numWords) { + zz = zz.make(numWords); + $copySlice(zz, RR); + RR = zz; + } + one = $makeSlice(nat, numWords); + (0 >= one.$length ? ($throwRuntimeError("index out of range"), undefined) : one.$array[one.$offset + 0] = 1); + powers = arrayType$1.zero(); + powers[0] = powers[0].montgomery(one, RR, m, k0, numWords); + powers[1] = powers[1].montgomery(x, RR, m, k0, numWords); + i$1 = 2; + while (true) { + if (!(i$1 < 16)) { break; } + ((i$1 < 0 || i$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[i$1] = ((i$1 < 0 || i$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[i$1]).montgomery((x$1 = i$1 - 1 >> 0, ((x$1 < 0 || x$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$1])), powers[1], m, k0, numWords)); + i$1 = i$1 + (1) >> 0; + } + z = z.make(numWords); + $copySlice(z, powers[0]); + zz = zz.make(numWords); + i$2 = y.$length - 1 >> 0; + while (true) { + if (!(i$2 >= 0)) { break; } + yi = ((i$2 < 0 || i$2 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$2]); + j = 0; + while (true) { + if (!(j < 32)) { break; } + if (!((i$2 === (y.$length - 1 >> 0))) || !((j === 0))) { + zz = zz.montgomery(z, z, m, k0, numWords); + z = z.montgomery(zz, zz, m, k0, numWords); + zz = zz.montgomery(z, z, m, k0, numWords); + z = z.montgomery(zz, zz, m, k0, numWords); + } + zz = zz.montgomery(z, (x$2 = yi >>> 28 >>> 0, ((x$2 < 0 || x$2 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$2])), m, k0, numWords); + _tmp = zz; + _tmp$1 = z; + z = _tmp; + zz = _tmp$1; + yi = (y$2 = (4), y$2 < 32 ? (yi << y$2) : 0) >>> 0; + j = j + (4) >> 0; + } + i$2 = i$2 - (1) >> 0; + } + zz = zz.montgomery(z, one, m, k0, numWords); + /* */ if (zz.cmp(m) >= 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (zz.cmp(m) >= 0) { */ case 5: + zz = zz.sub(zz, m); + /* */ if (zz.cmp(m) >= 0) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (zz.cmp(m) >= 0) { */ case 7: + _r$3 = (nat.nil).div(nat.nil, zz, m); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$2 = _r$3; + zz = _tuple$2[1]; + /* } */ case 8: + /* } */ case 6: + $s = -1; return zz.norm(); + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNNMontgomery }; } $f.RR = RR; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.j = j; $f.k0 = k0; $f.m = m; $f.numWords = numWords; $f.one = one; $f.powers = powers; $f.rr = rr; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.yi = yi; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.expNNMontgomery = function(x, y, m) { return this.$get().expNNMontgomery(x, y, m); }; + nat.prototype.bytes = function(buf) { + var _i, _ref, buf, d, i, j, y, z; + i = 0; + z = this; + i = buf.$length; + _ref = z; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + j = 0; + while (true) { + if (!(j < 4)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = ((d << 24 >>> 24))); + d = (y = (8), y < 32 ? (d >>> y) : 0) >>> 0; + j = j + (1) >> 0; + } + _i++; + } + while (true) { + if (!(i < buf.$length && (((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i]) === 0))) { break; } + i = i + (1) >> 0; + } + return i; + }; + $ptrType(nat).prototype.bytes = function(buf) { return this.$get().bytes(buf); }; + bigEndianWord = function(buf) { + var buf; + if (false) { + return (($clone(binary.BigEndian, binary.bigEndian).Uint64(buf).$low >>> 0)); + } + return (($clone(binary.BigEndian, binary.bigEndian).Uint32(buf) >>> 0)); + }; + nat.prototype.setBytes = function(buf) { + var _q, buf, d, i, k, s, x, x$1, y, z; + z = this; + z = z.make((_q = (((buf.$length + 4 >> 0) - 1 >> 0)) / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); + i = buf.$length; + k = 0; + while (true) { + if (!(i >= 4)) { break; } + ((k < 0 || k >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + k] = bigEndianWord($subslice(buf, (i - 4 >> 0), i))); + i = i - (4) >> 0; + k = k + (1) >> 0; + } + if (i > 0) { + d = 0; + s = 0; + while (true) { + if (!(i > 0)) { break; } + d = (d | (((y = s, y < 32 ? ((((x = i - 1 >> 0, ((x < 0 || x >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + x])) >>> 0)) << y) : 0) >>> 0))) >>> 0; + i = i - (1) >> 0; + s = s + (8) >>> 0; + } + (x$1 = z.$length - 1 >> 0, ((x$1 < 0 || x$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$1] = d)); + } + return z.norm(); + }; + $ptrType(nat).prototype.setBytes = function(buf) { return this.$get().setBytes(buf); }; + nat.prototype.sqrt = function(x) { + var _q, _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, n, x, z, z1, z2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; n = $f.n; x = $f.x; z = $f.z; z1 = $f.z1; z2 = $f.z2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (x.cmp(natOne) <= 0) { + $s = -1; return z.set(x); + } + if (alias(z, x)) { + z = nat.nil; + } + _tmp = nat.nil; + _tmp$1 = nat.nil; + z1 = _tmp; + z2 = _tmp$1; + z1 = z; + z1 = z1.setUint64(new $Uint64(0, 1)); + z1 = z1.shl(z1, ((((_q = x.bitLen() / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0) >>> 0))); + n = 0; + /* while (true) { */ case 1: + _r$1 = z2.div(nat.nil, x, z1); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + z2 = _tuple[0]; + z2 = z2.add(z2, z1); + z2 = z2.shr(z2, 1); + if (z2.cmp(z1) >= 0) { + if ((n & 1) === 0) { + $s = -1; return z1; + } + $s = -1; return z.set(z1); + } + _tmp$2 = z2; + _tmp$3 = z1; + z1 = _tmp$2; + z2 = _tmp$3; + n = n + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return nat.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.sqrt }; } $f._q = _q; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.n = n; $f.x = x; $f.z = z; $f.z1 = z1; $f.z2 = z2; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.sqrt = function(x) { return this.$get().sqrt(x); }; + maxPow = function(b) { + var _q, _tmp, _tmp$1, b, max$1, n, p; + p = 0; + n = 0; + _tmp = b; + _tmp$1 = 1; + p = _tmp; + n = _tmp$1; + max$1 = (_q = 4294967295 / b, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + while (true) { + if (!(p <= max$1)) { break; } + p = $imul(p, (b)) >>> 0; + n = n + (1) >> 0; + } + return [p, n]; + }; + pow = function(x, n) { + var n, p, x; + p = 0; + p = 1; + while (true) { + if (!(n > 0)) { break; } + if (!(((n & 1) === 0))) { + p = $imul(p, (x)) >>> 0; + } + x = $imul(x, (x)) >>> 0; + n = (n >> $min((1), 31)) >> 0; + } + return p; + }; + nat.prototype.scan = function(r, base, fracOk) { + var _1, _2, _3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, b, b1, base, baseOk, bn, ch, count, d1, di, dp, err, fracOk, i, n, r, res, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; b = $f.b; b1 = $f.b1; base = $f.base; baseOk = $f.baseOk; bn = $f.bn; ch = $f.ch; count = $f.count; d1 = $f.d1; di = $f.di; dp = $f.dp; err = $f.err; fracOk = $f.fracOk; i = $f.i; n = $f.n; r = $f.r; res = $f.res; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + res = nat.nil; + b = 0; + count = 0; + err = $ifaceNil; + z = this; + baseOk = (base === 0) || !fracOk && 2 <= base && base <= 62 || fracOk && ((base === 2) || (base === 10) || (base === 16)); + /* */ if (!baseOk) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!baseOk) { */ case 1: + _r$1 = fmt.Sprintf("illegal number base %d", new sliceType([new $Int(base)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $panic(new $String(_r$1)); + /* } */ case 2: + _r$2 = r.ReadByte(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + ch = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [res, b, count, err]; + } + b = base; + /* */ if (base === 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (base === 0) { */ case 5: + b = 10; + /* */ if (ch === 48) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (ch === 48) { */ case 7: + count = 1; + _r$3 = r.ReadByte(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$1 = _r$3; + ch = _tuple$1[0]; + err = _tuple$1[1]; + _1 = err; + /* */ if ($interfaceIsEqual(_1, $ifaceNil)) { $s = 11; continue; } + /* */ if ($interfaceIsEqual(_1, (io.EOF))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ($interfaceIsEqual(_1, $ifaceNil)) { */ case 11: + if (!fracOk) { + b = 8; + } + _2 = ch; + if ((_2 === (120)) || (_2 === (88))) { + b = 16; + } else if ((_2 === (98)) || (_2 === (66))) { + b = 2; + } + _3 = b; + /* */ if ((_3 === (16)) || (_3 === (2))) { $s = 16; continue; } + /* */ if (_3 === (8)) { $s = 17; continue; } + /* */ $s = 18; continue; + /* if ((_3 === (16)) || (_3 === (2))) { */ case 16: + count = 0; + _r$4 = r.ReadByte(); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$2 = _r$4; + ch = _tuple$2[0]; + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [res, b, count, err]; + } + $s = 18; continue; + /* } else if (_3 === (8)) { */ case 17: + count = 0; + /* } */ case 18: + case 15: + $s = 14; continue; + /* } else if ($interfaceIsEqual(_1, (io.EOF))) { */ case 12: + res = $subslice(z, 0, 0); + err = $ifaceNil; + $s = -1; return [res, b, count, err]; + /* } else { */ case 13: + $s = -1; return [res, b, count, err]; + /* } */ case 14: + case 9: + /* } */ case 8: + /* } */ case 6: + z = $subslice(z, 0, 0); + b1 = ((b >>> 0)); + _tuple$3 = maxPow(b1); + bn = _tuple$3[0]; + n = _tuple$3[1]; + di = 0; + i = 0; + dp = -1; + /* while (true) { */ case 20: + /* */ if (fracOk && (ch === 46)) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (fracOk && (ch === 46)) { */ case 22: + fracOk = false; + dp = count; + _r$5 = r.ReadByte(); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$4 = _r$5; + ch = _tuple$4[0]; + err = _tuple$4[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + err = $ifaceNil; + /* break; */ $s = 21; continue; + } + $s = -1; return [res, b, count, err]; + } + /* } */ case 23: + d1 = 0; + if (48 <= ch && ch <= 57) { + d1 = (((ch - 48 << 24 >>> 24) >>> 0)); + } else if (97 <= ch && ch <= 122) { + d1 = ((((ch - 97 << 24 >>> 24) + 10 << 24 >>> 24) >>> 0)); + } else if (65 <= ch && ch <= 90) { + if (b <= 36) { + d1 = ((((ch - 65 << 24 >>> 24) + 10 << 24 >>> 24) >>> 0)); + } else { + d1 = ((((ch - 65 << 24 >>> 24) + 36 << 24 >>> 24) >>> 0)); + } + } else { + d1 = 63; + } + /* */ if (d1 >= b1) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (d1 >= b1) { */ case 25: + _r$6 = r.UnreadByte(); /* */ $s = 27; case 27: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + /* break; */ $s = 21; continue; + /* } */ case 26: + count = count + (1) >> 0; + di = ($imul(di, b1) >>> 0) + d1 >>> 0; + i = i + (1) >> 0; + if (i === n) { + z = z.mulAddWW(z, bn, di); + di = 0; + i = 0; + } + _r$7 = r.ReadByte(); /* */ $s = 28; case 28: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _tuple$5 = _r$7; + ch = _tuple$5[0]; + err = _tuple$5[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + err = $ifaceNil; + /* break; */ $s = 21; continue; + } + $s = -1; return [res, b, count, err]; + } + /* } */ $s = 20; continue; case 21: + if (count === 0) { + if ((base === 0) && (b === 8)) { + count = 1; + b = 10; + } else if (!((base === 0)) || !((b === 8))) { + err = errors.New("syntax error scanning number"); + } + $s = -1; return [res, b, count, err]; + } + if (i > 0) { + z = z.mulAddWW(z, pow(b1, i), di); + } + res = z.norm(); + if (dp >= 0) { + count = dp - count >> 0; + } + $s = -1; return [res, b, count, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.scan }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.b = b; $f.b1 = b1; $f.base = base; $f.baseOk = baseOk; $f.bn = bn; $f.ch = ch; $f.count = count; $f.d1 = d1; $f.di = di; $f.dp = dp; $f.err = err; $f.fracOk = fracOk; $f.i = i; $f.n = n; $f.r = r; $f.res = res; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.scan = function(r, base, fracOk) { return this.$get().scan(r, base, fracOk); }; + nat.prototype.utoa = function(base) { + var _r$1, base, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = x.itoa(false, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.utoa }; } $f._r$1 = _r$1; $f.base = base; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.utoa = function(base) { return this.$get().utoa(base); }; + nat.prototype.itoa = function(neg, base) { + var _r$1, _tuple, b, base, bb, i, k, mask, nbits, ndigits, neg, q, s, shift, table, w, x, y, y$1, y$2, y$3, y$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; base = $f.base; bb = $f.bb; i = $f.i; k = $f.k; mask = $f.mask; nbits = $f.nbits; ndigits = $f.ndigits; neg = $f.neg; q = $f.q; s = $f.s; shift = $f.shift; table = $f.table; w = $f.w; x = $f.x; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (base < 2 || base > 62) { + $panic(new $String("invalid base")); + } + if (x.$length === 0) { + $s = -1; return (new sliceType$1($stringToBytes("0"))); + } + i = (((x.bitLen()) / math.Log2((base)) >> 0)) + 1 >> 0; + if (neg) { + i = i + (1) >> 0; + } + s = $makeSlice(sliceType$1, i); + b = ((base >>> 0)); + /* */ if (b === ((b & (-b >>> 0)) >>> 0)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (b === ((b & (-b >>> 0)) >>> 0)) { */ case 1: + shift = ((bits.TrailingZeros(((b >>> 0))) >>> 0)); + mask = ((((y = shift, y < 32 ? (1 << y) : 0) >>> 0) - 1 >>> 0)); + w = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); + nbits = 32; + k = 1; + while (true) { + if (!(k < x.$length)) { break; } + while (true) { + if (!(nbits >= shift)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); + w = (y$1 = (shift), y$1 < 32 ? (w >>> y$1) : 0) >>> 0; + nbits = nbits - (shift) >>> 0; + } + if (nbits === 0) { + w = ((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]); + nbits = 32; + } else { + w = (w | (((y$2 = nbits, y$2 < 32 ? (((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]) << y$2) : 0) >>> 0))) >>> 0; + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); + w = (y$3 = ((shift - nbits >>> 0)), y$3 < 32 ? (((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]) >>> y$3) : 0) >>> 0; + nbits = 32 - ((shift - nbits >>> 0)) >>> 0; + } + k = k + (1) >> 0; + } + while (true) { + if (!(!((w === 0)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); + w = (y$4 = (shift), y$4 < 32 ? (w >>> y$4) : 0) >>> 0; + } + $s = 3; continue; + /* } else { */ case 2: + _tuple = maxPow(b); + bb = _tuple[0]; + ndigits = _tuple[1]; + _r$1 = divisors(x.$length, b, ndigits, bb); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + table = _r$1; + q = (nat.nil).set(x); + $r = q.convertWords(s, b, ndigits, bb, table); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = 0; + while (true) { + if (!(((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) === 48)) { break; } + i = i + (1) >> 0; + } + /* } */ case 3: + if (neg) { + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = 45); + } + $s = -1; return $subslice(s, i); + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.itoa }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.base = base; $f.bb = bb; $f.i = i; $f.k = k; $f.mask = mask; $f.nbits = nbits; $f.ndigits = ndigits; $f.neg = neg; $f.q = q; $f.s = s; $f.shift = shift; $f.table = table; $f.w = w; $f.x = x; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.itoa = function(neg, base) { return this.$get().itoa(neg, base); }; + nat.prototype.convertWords = function(s, b, ndigits, bb, table) { + var _q, _q$1, _r$1, _r$2, _tuple, _tuple$1, _tuple$2, b, bb, h, i, index, j, j$1, maxLength, minLength, ndigits, q, r, r$1, s, t, table, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; b = $f.b; bb = $f.bb; h = $f.h; i = $f.i; index = $f.index; j = $f.j; j$1 = $f.j$1; maxLength = $f.maxLength; minLength = $f.minLength; ndigits = $f.ndigits; q = $f.q; r = $f.r; r$1 = $f.r$1; s = $f.s; t = $f.t; table = $f.table; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + q = this; + /* */ if (!(table === sliceType$3.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(table === sliceType$3.nil)) { */ case 1: + r = nat.nil; + index = table.$length - 1 >> 0; + /* while (true) { */ case 3: + /* if (!(q.$length > leafSize)) { break; } */ if(!(q.$length > leafSize)) { $s = 4; continue; } + maxLength = q.bitLen(); + minLength = maxLength >> 1 >> 0; + while (true) { + if (!(index > 0 && (x = index - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).nbits > minLength)) { break; } + index = index - (1) >> 0; + } + if (((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).nbits >= maxLength && ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).bbb.cmp(q) >= 0) { + index = index - (1) >> 0; + if (index < 0) { + $panic(new $String("internal inconsistency")); + } + } + _r$1 = q.div(r, q, ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).bbb); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + q = _tuple[0]; + r = _tuple[1]; + h = s.$length - ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).ndigits >> 0; + $r = r.convertWords($subslice(s, h), b, ndigits, bb, $subslice(table, 0, index)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + s = $subslice(s, 0, h); + /* } */ $s = 3; continue; case 4: + /* } */ case 2: + i = s.$length; + r$1 = 0; + if (b === 10) { + while (true) { + if (!(q.$length > 0)) { break; } + _tuple$1 = q.divW(q, bb); + q = _tuple$1[0]; + r$1 = _tuple$1[1]; + j = 0; + while (true) { + if (!(j < ndigits && i > 0)) { break; } + i = i - (1) >> 0; + t = (_q = r$1 / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = (48 + (((r$1 - ($imul(t, 10) >>> 0) >>> 0) << 24 >>> 24)) << 24 >>> 24)); + r$1 = t; + j = j + (1) >> 0; + } + } + } else { + while (true) { + if (!(q.$length > 0)) { break; } + _tuple$2 = q.divW(q, bb); + q = _tuple$2[0]; + r$1 = _tuple$2[1]; + j$1 = 0; + while (true) { + if (!(j$1 < ndigits && i > 0)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt((_r$2 = r$1 % b, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")))); + r$1 = (_q$1 = r$1 / (b), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + j$1 = j$1 + (1) >> 0; + } + } + } + while (true) { + if (!(i > 0)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = 48); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.convertWords }; } $f._q = _q; $f._q$1 = _q$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.b = b; $f.bb = bb; $f.h = h; $f.i = i; $f.index = index; $f.j = j; $f.j$1 = j$1; $f.maxLength = maxLength; $f.minLength = minLength; $f.ndigits = ndigits; $f.q = q; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.t = t; $f.table = table; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.convertWords = function(s, b, ndigits, bb, table) { return this.$get().convertWords(s, b, ndigits, bb, table); }; + nat.prototype.expWW = function(x, y) { + var _r$1, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.expNN((nat.nil).setWord(x), (nat.nil).setWord(y), nat.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expWW }; } $f._r$1 = _r$1; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.expWW = function(x, y) { return this.$get().expWW(x, y); }; + divisors = function(m, b, ndigits, bb) { + var _r$1, b, bb, i, k, larger, m, ndigits, table, words, x, x$1, x$2, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; bb = $f.bb; i = $f.i; k = $f.k; larger = $f.larger; m = $f.m; ndigits = $f.ndigits; table = $f.table; words = $f.words; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ((leafSize === 0) || m <= leafSize) { + $s = -1; return sliceType$3.nil; + } + k = 1; + words = leafSize; + while (true) { + if (!(words < (m >> 1 >> 0) && k < 64)) { break; } + k = k + (1) >> 0; + words = (y = (1), y < 32 ? (words << y) : 0) >> 0; + } + table = sliceType$3.nil; + if (b === 10) { + cacheBase10.Mutex.Lock(); + table = $subslice(new sliceType$3(cacheBase10.table), 0, k); + } else { + table = $makeSlice(sliceType$3, k); + } + /* */ if ((x = k - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).ndigits === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((x = k - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).ndigits === 0) { */ case 1: + larger = nat.nil; + i = 0; + /* while (true) { */ case 3: + /* if (!(i < k)) { break; } */ if(!(i < k)) { $s = 4; continue; } + /* */ if (((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits === 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits === 0) { */ case 5: + /* */ if (i === 0) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (i === 0) { */ case 7: + _r$1 = (nat.nil).expWW(bb, ((leafSize >>> 0))); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + (0 >= table.$length ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + 0]).bbb = _r$1; + (0 >= table.$length ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + 0]).ndigits = $imul(ndigits, leafSize); + $s = 9; continue; + /* } else { */ case 8: + ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb = (nat.nil).sqr((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x$1])).bbb); + ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits = $imul(2, (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x$2])).ndigits); + /* } */ case 9: + larger = (nat.nil).set(((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb); + while (true) { + if (!(mulAddVWW($subslice(new sliceType$2(larger.$array), larger.$offset, larger.$offset + larger.$length), $subslice(new sliceType$2(larger.$array), larger.$offset, larger.$offset + larger.$length), b, 0) === 0)) { break; } + ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb.set(larger); + ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits + (1) >> 0; + } + ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).nbits = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb.bitLen(); + /* } */ case 6: + i = i + (1) >> 0; + /* } */ $s = 3; continue; case 4: + /* } */ case 2: + if (b === 10) { + cacheBase10.Mutex.Unlock(); + } + $s = -1; return table; + /* */ } return; } if ($f === undefined) { $f = { $blk: divisors }; } $f._r$1 = _r$1; $f.b = b; $f.bb = bb; $f.i = i; $f.k = k; $f.larger = larger; $f.m = m; $f.ndigits = ndigits; $f.table = table; $f.words = words; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.ptr.prototype.ProbablyPrime = function(n) { + var _1, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _v, n, r, rA, rB, w, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _v = $f._v; n = $f.n; r = $f.r; rA = $f.rA; rB = $f.rB; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + if (n < 0) { + $panic(new $String("negative n for ProbablyPrime")); + } + if (x.neg || (x.abs.$length === 0)) { + $s = -1; return false; + } + w = (x$1 = x.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); + if ((x.abs.$length === 1) && w < 64) { + $s = -1; return !((x$2 = (x$3 = $shiftLeft64(new $Uint64(0, 1), w), new $Uint64(673221152 & x$3.$high, (2693408940 & x$3.$low) >>> 0)), (x$2.$high === 0 && x$2.$low === 0))); + } + if (((w & 1) >>> 0) === 0) { + $s = -1; return false; + } + _tmp = 0; + _tmp$1 = 0; + rA = _tmp; + rB = _tmp$1; + _1 = 32; + if (_1 === (32)) { + rA = ((x.abs.modW(4127218095) >>> 0)); + rB = ((x.abs.modW(3948078067) >>> 0)); + } else if (_1 === (64)) { + r = x.abs.modW(820596253); + rA = (((_r$1 = r % 4127218095, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)); + rB = (((_r$2 = r % 3948078067, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) >>> 0)); + } else { + $panic(new $String("math/big: invalid word size")); + } + if (((_r$3 = rA % 3, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$4 = rA % 5, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$5 = rA % 7, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$6 = rA % 11, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$7 = rA % 13, _r$7 === _r$7 ? _r$7 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$8 = rA % 17, _r$8 === _r$8 ? _r$8 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$9 = rA % 19, _r$9 === _r$9 ? _r$9 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$10 = rA % 23, _r$10 === _r$10 ? _r$10 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$11 = rA % 37, _r$11 === _r$11 ? _r$11 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$12 = rB % 29, _r$12 === _r$12 ? _r$12 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$13 = rB % 31, _r$13 === _r$13 ? _r$13 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$14 = rB % 41, _r$14 === _r$14 ? _r$14 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$15 = rB % 43, _r$15 === _r$15 ? _r$15 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$16 = rB % 47, _r$16 === _r$16 ? _r$16 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$17 = rB % 53, _r$17 === _r$17 ? _r$17 : $throwRuntimeError("integer divide by zero")) === 0)) { + $s = -1; return false; + } + _r$18 = x.abs.probablyPrimeMillerRabin(n + 1 >> 0, true); /* */ $s = 2; case 2: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + if (!(_r$18)) { _v = false; $s = 1; continue s; } + _r$19 = x.abs.probablyPrimeLucas(); /* */ $s = 3; case 3: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } + _v = _r$19; case 1: + $s = -1; return _v; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ProbablyPrime }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._v = _v; $f.n = n; $f.r = r; $f.rA = rA; $f.rB = rB; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Int.prototype.ProbablyPrime = function(n) { return this.$val.ProbablyPrime(n); }; + nat.prototype.probablyPrimeMillerRabin = function(reps, force2) { + var _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tuple, force2, i, j, k, n, nm1, nm3, nm3Len, q, quotient, rand$1, reps, x, x$1, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; force2 = $f.force2; i = $f.i; j = $f.j; k = $f.k; n = $f.n; nm1 = $f.nm1; nm3 = $f.nm3; nm3Len = $f.nm3Len; q = $f.q; quotient = $f.quotient; rand$1 = $f.rand$1; reps = $f.reps; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = this; + nm1 = (nat.nil).sub(n, natOne); + k = nm1.trailingZeroBits(); + q = (nat.nil).shr(nm1, k); + nm3 = (nat.nil).sub(nm1, natTwo); + rand$1 = rand.New(rand.NewSource(((x = (0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]), new $Int64(0, x.constructor === Number ? x : 1))))); + _tmp = nat.nil; + _tmp$1 = nat.nil; + _tmp$2 = nat.nil; + x$1 = _tmp; + y = _tmp$1; + quotient = _tmp$2; + nm3Len = nm3.bitLen(); + i = 0; + /* while (true) { */ case 1: + /* if (!(i < reps)) { break; } */ if(!(i < reps)) { $s = 2; continue; } + /* */ if ((i === (reps - 1 >> 0)) && force2) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((i === (reps - 1 >> 0)) && force2) { */ case 3: + x$1 = x$1.set(natTwo); + $s = 5; continue; + /* } else { */ case 4: + _r$1 = x$1.random(rand$1, nm3, nm3Len); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + x$1 = _r$1; + x$1 = x$1.add(x$1, natTwo); + /* } */ case 5: + _r$2 = y.expNN(x$1, q, n); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + y = _r$2; + /* */ if ((y.cmp(natOne) === 0) || (y.cmp(nm1) === 0)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if ((y.cmp(natOne) === 0) || (y.cmp(nm1) === 0)) { */ case 8: + i = i + (1) >> 0; + /* continue; */ $s = 1; continue; + /* } */ case 9: + j = 1; + /* while (true) { */ case 10: + /* if (!(j < k)) { break; } */ if(!(j < k)) { $s = 11; continue; } + y = y.sqr(y); + _r$3 = quotient.div(y, y, n); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + quotient = _tuple[0]; + y = _tuple[1]; + if (y.cmp(nm1) === 0) { + i = i + (1) >> 0; + /* continue NextRandom; */ $s = 1; continue s; + } + if (y.cmp(natOne) === 0) { + $s = -1; return false; + } + j = j + (1) >>> 0; + /* } */ $s = 10; continue; case 11: + $s = -1; return false; + /* } */ $s = 1; continue; case 2: + $s = -1; return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.probablyPrimeMillerRabin }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.force2 = force2; $f.i = i; $f.j = j; $f.k = k; $f.n = n; $f.nm1 = nm1; $f.nm3 = nm3; $f.nm3Len = nm3Len; $f.q = q; $f.quotient = quotient; $f.rand$1 = rand$1; $f.reps = reps; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.probablyPrimeMillerRabin = function(reps, force2) { return this.$get().probablyPrimeMillerRabin(reps, force2); }; + nat.prototype.probablyPrimeLucas = function() { + var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, d, i, intD, intN, j, n, natP, nm2, p, r, s, t, t1, t1$1, t2, t2$1, t3, vk, vk1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; d = $f.d; i = $f.i; intD = $f.intD; intN = $f.intN; j = $f.j; n = $f.n; natP = $f.natP; nm2 = $f.nm2; p = $f.p; r = $f.r; s = $f.s; t = $f.t; t1 = $f.t1; t1$1 = $f.t1$1; t2 = $f.t2; t2$1 = $f.t2$1; t3 = $f.t3; vk = $f.vk; vk1 = $f.vk1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = this; + if ((n.$length === 0) || (n.cmp(natOne) === 0)) { + $s = -1; return false; + } + if ((((0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]) & 1) >>> 0) === 0) { + $s = -1; return n.cmp(natTwo) === 0; + } + p = 3; + d = new nat([1]); + t1 = (nat.nil); + intD = new Int.ptr(false, d); + intN = new Int.ptr(false, n); + /* while (true) { */ case 1: + /* */ if (p > 10000) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (p > 10000) { */ case 3: + _r$1 = intN.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $panic(new $String("math/big: internal error: cannot find (D/n) = -1 for " + _r$1)); + /* } */ case 4: + (0 >= d.$length ? ($throwRuntimeError("index out of range"), undefined) : d.$array[d.$offset + 0] = (($imul(p, p) >>> 0) - 4 >>> 0)); + _r$2 = Jacobi(intD, intN); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + j = _r$2; + if (j === -1) { + /* break; */ $s = 2; continue; + } + if (j === 0) { + $s = -1; return (n.$length === 1) && ((0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]) === (p + 2 >>> 0)); + } + /* */ if (p === 40) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (p === 40) { */ case 7: + _r$3 = t1.sqrt(n); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + t1 = _r$3; + t1 = t1.sqr(t1); + if (t1.cmp(n) === 0) { + $s = -1; return false; + } + /* } */ case 8: + p = p + (1) >>> 0; + /* } */ $s = 1; continue; case 2: + s = (nat.nil).add(n, natOne); + r = ((s.trailingZeroBits() >> 0)); + s = s.shr(s, ((r >>> 0))); + nm2 = (nat.nil).sub(n, natTwo); + natP = (nat.nil).setWord(p); + vk = (nat.nil).setWord(2); + vk1 = (nat.nil).setWord(p); + t2 = (nat.nil); + i = (s.bitLen()); + /* while (true) { */ case 10: + /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 11; continue; } + /* */ if (!((s.bit(((i >>> 0))) === 0))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (!((s.bit(((i >>> 0))) === 0))) { */ case 12: + t1 = t1.mul(vk, vk1); + t1 = t1.add(t1, n); + t1 = t1.sub(t1, natP); + _r$4 = t2.div(vk, t1, n); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = _r$4; + t2 = _tuple[0]; + vk = _tuple[1]; + t1 = t1.sqr(vk1); + t1 = t1.add(t1, nm2); + _r$5 = t2.div(vk1, t1, n); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$1 = _r$5; + t2 = _tuple$1[0]; + vk1 = _tuple$1[1]; + $s = 14; continue; + /* } else { */ case 13: + t1 = t1.mul(vk, vk1); + t1 = t1.add(t1, n); + t1 = t1.sub(t1, natP); + _r$6 = t2.div(vk1, t1, n); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple$2 = _r$6; + t2 = _tuple$2[0]; + vk1 = _tuple$2[1]; + t1 = t1.sqr(vk); + t1 = t1.add(t1, nm2); + _r$7 = t2.div(vk, t1, n); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _tuple$3 = _r$7; + t2 = _tuple$3[0]; + vk = _tuple$3[1]; + /* } */ case 14: + i = i - (1) >> 0; + /* } */ $s = 10; continue; case 11: + /* */ if ((vk.cmp(natTwo) === 0) || (vk.cmp(nm2) === 0)) { $s = 19; continue; } + /* */ $s = 20; continue; + /* if ((vk.cmp(natTwo) === 0) || (vk.cmp(nm2) === 0)) { */ case 19: + t1$1 = t1.mul(vk, natP); + t2$1 = t2.shl(vk1, 1); + if (t1$1.cmp(t2$1) < 0) { + _tmp = t2$1; + _tmp$1 = t1$1; + t1$1 = _tmp; + t2$1 = _tmp$1; + } + t1$1 = t1$1.sub(t1$1, t2$1); + t3 = vk1; + vk1 = nat.nil; + $unused(vk1); + _r$8 = t2$1.div(t3, t1$1, n); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _tuple$4 = _r$8; + t2$1 = _tuple$4[0]; + t3 = _tuple$4[1]; + if (t3.$length === 0) { + $s = -1; return true; + } + /* } */ case 20: + t = 0; + /* while (true) { */ case 22: + /* if (!(t < (r - 1 >> 0))) { break; } */ if(!(t < (r - 1 >> 0))) { $s = 23; continue; } + if (vk.$length === 0) { + $s = -1; return true; + } + if ((vk.$length === 1) && ((0 >= vk.$length ? ($throwRuntimeError("index out of range"), undefined) : vk.$array[vk.$offset + 0]) === 2)) { + $s = -1; return false; + } + t1 = t1.sqr(vk); + t1 = t1.sub(t1, natTwo); + _r$9 = t2.div(vk, t1, n); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _tuple$5 = _r$9; + t2 = _tuple$5[0]; + vk = _tuple$5[1]; + t = t + (1) >> 0; + /* } */ $s = 22; continue; case 23: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.probablyPrimeLucas }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.d = d; $f.i = i; $f.intD = intD; $f.intN = intN; $f.j = j; $f.n = n; $f.natP = natP; $f.nm2 = nm2; $f.p = p; $f.r = r; $f.s = s; $f.t = t; $f.t1 = t1; $f.t1$1 = t1$1; $f.t2 = t2; $f.t2$1 = t2$1; $f.t3 = t3; $f.vk = vk; $f.vk1 = vk1; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(nat).prototype.probablyPrimeLucas = function() { return this.$get().probablyPrimeLucas(); }; + Rat.ptr.prototype.SetFloat64 = function(f) { + var _1, _r$1, bits$1, exp, f, mantissa, shift, x, x$1, x$2, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; bits$1 = $f.bits$1; exp = $f.exp; f = $f.f; mantissa = $f.mantissa; shift = $f.shift; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + bits$1 = math.Float64bits(f); + mantissa = new $Uint64(bits$1.$high & 1048575, (bits$1.$low & 4294967295) >>> 0); + exp = (((x = $shiftRightUint64(bits$1, 52), new $Uint64(x.$high & 0, (x.$low & 2047) >>> 0)).$low >> 0)); + _1 = exp; + if (_1 === (2047)) { + $s = -1; return ptrType$2.nil; + } else if (_1 === (0)) { + exp = exp - (1022) >> 0; + } else { + mantissa = (x$1 = new $Uint64(1048576, 0), new $Uint64(mantissa.$high | x$1.$high, (mantissa.$low | x$1.$low) >>> 0)); + exp = exp - (1023) >> 0; + } + shift = 52 - exp >> 0; + while (true) { + if (!((x$2 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$2.$high === 0 && x$2.$low === 0)) && shift > 0)) { break; } + mantissa = $shiftRightUint64(mantissa, (1)); + shift = shift - (1) >> 0; + } + z.a.SetUint64(mantissa); + z.a.neg = f < 0; + z.b.Set(intOne); + if (shift > 0) { + z.b.Lsh(z.b, ((shift >>> 0))); + } else { + z.a.Lsh(z.a, ((-shift >>> 0))); + } + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFloat64 }; } $f._1 = _1; $f._r$1 = _r$1; $f.bits$1 = bits$1; $f.exp = exp; $f.f = f; $f.mantissa = mantissa; $f.shift = shift; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.SetFloat64 = function(f) { return this.$val.SetFloat64(f); }; + quotToFloat32 = function(a, b) { + var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, y, y$1, y$2, y$3, y$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = 0; + exact = false; + alen = a.bitLen(); + if (alen === 0) { + _tmp = 0; + _tmp$1 = true; + f = _tmp; + exact = _tmp$1; + $s = -1; return [f, exact]; + } + blen = b.bitLen(); + if (blen === 0) { + $panic(new $String("division by zero")); + } + exp = alen - blen >> 0; + _tmp$2 = nat.nil; + _tmp$3 = nat.nil; + a2 = _tmp$2; + b2 = _tmp$3; + a2 = a2.set(a); + b2 = b2.set(b); + shift = 25 - exp >> 0; + if (shift > 0) { + a2 = a2.shl(a2, ((shift >>> 0))); + } else if (shift < 0) { + b2 = b2.shl(b2, ((-shift >>> 0))); + } + q = nat.nil; + _r$1 = q.div(a2, a2, b2); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + q = _tuple[0]; + r = _tuple[1]; + mantissa = low32(q); + haveRem = r.$length > 0; + if ((mantissa >>> 25 >>> 0) === 1) { + if (((mantissa & 1) >>> 0) === 1) { + haveRem = true; + } + mantissa = (y = (1), y < 32 ? (mantissa >>> y) : 0) >>> 0; + exp = exp + (1) >> 0; + } + /* */ if (!(((mantissa >>> 24 >>> 0) === 1))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!(((mantissa >>> 24 >>> 0) === 1))) { */ case 2: + _r$2 = fmt.Sprintf("expected exactly %d bits of result", new sliceType([new $Int(25)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $panic(new $String(_r$2)); + /* } */ case 3: + if (-149 <= exp && exp <= -126) { + shift$1 = (((-126 - ((exp - 1 >> 0)) >> 0) >>> 0)); + lostbits = (mantissa & ((((y$1 = shift$1, y$1 < 32 ? (1 << y$1) : 0) >>> 0) - 1 >>> 0))) >>> 0; + haveRem = haveRem || !((lostbits === 0)); + mantissa = (y$2 = (shift$1), y$2 < 32 ? (mantissa >>> y$2) : 0) >>> 0; + exp = -125; + } + exact = !haveRem; + if (!((((mantissa & 1) >>> 0) === 0))) { + exact = false; + if (haveRem || !((((mantissa & 2) >>> 0) === 0))) { + mantissa = mantissa + (1) >>> 0; + if (mantissa >= 33554432) { + mantissa = (y$3 = (1), y$3 < 32 ? (mantissa >>> y$3) : 0) >>> 0; + exp = exp + (1) >> 0; + } + } + } + mantissa = (y$4 = (1), y$4 < 32 ? (mantissa >>> y$4) : 0) >>> 0; + f = ($fround(math.Ldexp((mantissa), exp - 24 >> 0))); + if (math.IsInf((f), 0)) { + exact = false; + } + $s = -1; return [f, exact]; + /* */ } return; } if ($f === undefined) { $f = { $blk: quotToFloat32 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f; + }; + quotToFloat64 = function(a, b) { + var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = 0; + exact = false; + alen = a.bitLen(); + if (alen === 0) { + _tmp = 0; + _tmp$1 = true; + f = _tmp; + exact = _tmp$1; + $s = -1; return [f, exact]; + } + blen = b.bitLen(); + if (blen === 0) { + $panic(new $String("division by zero")); + } + exp = alen - blen >> 0; + _tmp$2 = nat.nil; + _tmp$3 = nat.nil; + a2 = _tmp$2; + b2 = _tmp$3; + a2 = a2.set(a); + b2 = b2.set(b); + shift = 54 - exp >> 0; + if (shift > 0) { + a2 = a2.shl(a2, ((shift >>> 0))); + } else if (shift < 0) { + b2 = b2.shl(b2, ((-shift >>> 0))); + } + q = nat.nil; + _r$1 = q.div(a2, a2, b2); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + q = _tuple[0]; + r = _tuple[1]; + mantissa = low64(q); + haveRem = r.$length > 0; + if ((x = $shiftRightUint64(mantissa, 54), (x.$high === 0 && x.$low === 1))) { + if ((x$1 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { + haveRem = true; + } + mantissa = $shiftRightUint64(mantissa, (1)); + exp = exp + (1) >> 0; + } + /* */ if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { */ case 2: + _r$2 = fmt.Sprintf("expected exactly %d bits of result", new sliceType([new $Int(54)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $panic(new $String(_r$2)); + /* } */ case 3: + if (-1074 <= exp && exp <= -1022) { + shift$1 = (((-1022 - ((exp - 1 >> 0)) >> 0) >>> 0)); + lostbits = (x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), shift$1), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(mantissa.$high & x$3.$high, (mantissa.$low & x$3.$low) >>> 0)); + haveRem = haveRem || !((lostbits.$high === 0 && lostbits.$low === 0)); + mantissa = $shiftRightUint64(mantissa, (shift$1)); + exp = -1021; + } + exact = !haveRem; + if (!((x$5 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { + exact = false; + if (haveRem || !((x$6 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 2) >>> 0), (x$6.$high === 0 && x$6.$low === 0)))) { + mantissa = (x$7 = new $Uint64(0, 1), new $Uint64(mantissa.$high + x$7.$high, mantissa.$low + x$7.$low)); + if ((mantissa.$high > 4194304 || (mantissa.$high === 4194304 && mantissa.$low >= 0))) { + mantissa = $shiftRightUint64(mantissa, (1)); + exp = exp + (1) >> 0; + } + } + } + mantissa = $shiftRightUint64(mantissa, (1)); + f = math.Ldexp(($flatten64(mantissa)), exp - 53 >> 0); + if (math.IsInf(f, 0)) { + exact = false; + } + $s = -1; return [f, exact]; + /* */ } return; } if ($f === undefined) { $f = { $blk: quotToFloat64 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.ptr.prototype.Float32 = function() { + var _r$1, _tuple, b, exact, f, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = 0; + exact = false; + x = this; + b = x.b.abs; + if (b.$length === 0) { + b = b.set(natOne); + } + _r$1 = quotToFloat32(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + f = _tuple[0]; + exact = _tuple[1]; + if (x.a.neg) { + f = -f; + } + $s = -1; return [f, exact]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float32 }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Float32 = function() { return this.$val.Float32(); }; + Rat.ptr.prototype.Float64 = function() { + var _r$1, _tuple, b, exact, f, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = 0; + exact = false; + x = this; + b = x.b.abs; + if (b.$length === 0) { + b = b.set(natOne); + } + _r$1 = quotToFloat64(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + f = _tuple[0]; + exact = _tuple[1]; + if (x.a.neg) { + f = -f; + } + $s = -1; return [f, exact]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float64 }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Float64 = function() { return this.$val.Float64(); }; + Rat.ptr.prototype.SetFrac = function(a, b) { + var _r$1, a, b, babs, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; babs = $f.babs; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + z.a.neg = !(a.neg === b.neg); + babs = b.abs; + if (babs.$length === 0) { + $panic(new $String("division by zero")); + } + if (z.a === b || alias(z.a.abs, babs)) { + babs = (nat.nil).set(babs); + } + z.a.abs = z.a.abs.set(a.abs); + z.b.abs = z.b.abs.set(babs); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFrac }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.babs = babs; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.SetFrac = function(a, b) { return this.$val.SetFrac(a, b); }; + Rat.ptr.prototype.SetFrac64 = function(a, b) { + var _r$1, a, b, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + z.a.SetInt64(a); + if ((b.$high === 0 && b.$low === 0)) { + $panic(new $String("division by zero")); + } + if ((b.$high < 0 || (b.$high === 0 && b.$low < 0))) { + b = new $Int64(-b.$high, -b.$low); + z.a.neg = !z.a.neg; + } + z.b.abs = z.b.abs.setUint64((new $Uint64(b.$high, b.$low))); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFrac64 }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.SetFrac64 = function(a, b) { return this.$val.SetFrac64(a, b); }; + Rat.ptr.prototype.SetInt = function(x) { + var x, z; + z = this; + z.a.Set(x); + z.b.abs = $subslice(z.b.abs, 0, 0); + return z; + }; + Rat.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; + Rat.ptr.prototype.SetInt64 = function(x) { + var x, z; + z = this; + z.a.SetInt64(x); + z.b.abs = $subslice(z.b.abs, 0, 0); + return z; + }; + Rat.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; + Rat.ptr.prototype.Set = function(x) { + var x, z; + z = this; + if (!(z === x)) { + z.a.Set(x.a); + z.b.Set(x.b); + } + return z; + }; + Rat.prototype.Set = function(x) { return this.$val.Set(x); }; + Rat.ptr.prototype.Abs = function(x) { + var x, z; + z = this; + z.Set(x); + z.a.neg = false; + return z; + }; + Rat.prototype.Abs = function(x) { return this.$val.Abs(x); }; + Rat.ptr.prototype.Neg = function(x) { + var x, z; + z = this; + z.Set(x); + z.a.neg = z.a.abs.$length > 0 && !z.a.neg; + return z; + }; + Rat.prototype.Neg = function(x) { return this.$val.Neg(x); }; + Rat.ptr.prototype.Inv = function(x) { + var _tmp, _tmp$1, a, b, x, z; + z = this; + if (x.a.abs.$length === 0) { + $panic(new $String("division by zero")); + } + z.Set(x); + a = z.b.abs; + if (a.$length === 0) { + a = a.set(natOne); + } + b = z.a.abs; + if (b.cmp(natOne) === 0) { + b = $subslice(b, 0, 0); + } + _tmp = a; + _tmp$1 = b; + z.a.abs = _tmp; + z.b.abs = _tmp$1; + return z; + }; + Rat.prototype.Inv = function(x) { return this.$val.Inv(x); }; + Rat.ptr.prototype.Sign = function() { + var x; + x = this; + return x.a.Sign(); + }; + Rat.prototype.Sign = function() { return this.$val.Sign(); }; + Rat.ptr.prototype.IsInt = function() { + var x; + x = this; + return (x.b.abs.$length === 0) || (x.b.abs.cmp(natOne) === 0); + }; + Rat.prototype.IsInt = function() { return this.$val.IsInt(); }; + Rat.ptr.prototype.Num = function() { + var x; + x = this; + return x.a; + }; + Rat.prototype.Num = function() { return this.$val.Num(); }; + Rat.ptr.prototype.Denom = function() { + var x; + x = this; + x.b.neg = false; + if (x.b.abs.$length === 0) { + x.b.abs = x.b.abs.set(natOne); + } + return x.b; + }; + Rat.prototype.Denom = function() { return this.$val.Denom(); }; + Rat.ptr.prototype.norm = function() { + var _r$1, _r$2, _r$3, _tuple, _tuple$1, f, neg, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; neg = $f.neg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if ((z.a.abs.$length === 0)) { $s = 2; continue; } + /* */ if ((z.b.abs.$length === 0)) { $s = 3; continue; } + /* */ if ((z.b.abs.cmp(natOne) === 0)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((z.a.abs.$length === 0)) { */ case 2: + z.a.neg = false; + z.b.abs = $subslice(z.b.abs, 0, 0); + $s = 6; continue; + /* } else if ((z.b.abs.$length === 0)) { */ case 3: + $s = 6; continue; + /* } else if ((z.b.abs.cmp(natOne) === 0)) { */ case 4: + z.b.abs = $subslice(z.b.abs, 0, 0); + $s = 6; continue; + /* } else { */ case 5: + neg = z.a.neg; + z.a.neg = false; + z.b.neg = false; + _r$1 = NewInt(new $Int64(0, 0)).lehmerGCD(ptrType$1.nil, ptrType$1.nil, z.a, z.b); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + f = _r$1; + /* */ if (!((f.Cmp(intOne) === 0))) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!((f.Cmp(intOne) === 0))) { */ case 8: + _r$2 = z.a.abs.div(nat.nil, z.a.abs, f.abs); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + z.a.abs = _tuple[0]; + _r$3 = z.b.abs.div(nat.nil, z.b.abs, f.abs); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$1 = _r$3; + z.b.abs = _tuple$1[0]; + if (z.b.abs.cmp(natOne) === 0) { + z.b.abs = $subslice(z.b.abs, 0, 0); + } + /* } */ case 9: + z.a.neg = neg; + /* } */ case 6: + case 1: + $s = -1; return z; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.norm }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.neg = neg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.norm = function() { return this.$val.norm(); }; + mulDenom = function(z, x, y) { + var x, y, z; + if ((x.$length === 0)) { + return z.set(y); + } else if ((y.$length === 0)) { + return z.set(x); + } + return z.mul(x, y); + }; + scaleDenom = function(x, f) { + var f, x, z; + z = new Int.ptr(false, nat.nil); + if (f.$length === 0) { + return z.Set(x); + } + z.abs = z.abs.mul(x.abs, f); + z.neg = x.neg; + return z; + }; + Rat.ptr.prototype.Cmp = function(y) { + var x, y; + x = this; + return scaleDenom(x.a, y.b.abs).Cmp(scaleDenom(y.a, x.b.abs)); + }; + Rat.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; + Rat.ptr.prototype.Add = function(x, y) { + var _r$1, a1, a2, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a1 = $f.a1; a2 = $f.a2; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + a1 = scaleDenom(x.a, y.b.abs); + a2 = scaleDenom(y.a, x.b.abs); + z.a.Add(a1, a2); + z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Add }; } $f._r$1 = _r$1; $f.a1 = a1; $f.a2 = a2; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; + Rat.ptr.prototype.Sub = function(x, y) { + var _r$1, a1, a2, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a1 = $f.a1; a2 = $f.a2; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + a1 = scaleDenom(x.a, y.b.abs); + a2 = scaleDenom(y.a, x.b.abs); + z.a.Sub(a1, a2); + z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Sub }; } $f._r$1 = _r$1; $f.a1 = a1; $f.a2 = a2; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; + Rat.ptr.prototype.Mul = function(x, y) { + var _r$1, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (x === y) { + z.a.neg = false; + z.a.abs = z.a.abs.sqr(x.a.abs); + z.b.abs = z.b.abs.sqr(x.b.abs); + $s = -1; return z; + } + z.a.Mul(x.a, y.a); + z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Mul }; } $f._r$1 = _r$1; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; + Rat.ptr.prototype.Quo = function(x, y) { + var _r$1, a, b, x, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (y.a.abs.$length === 0) { + $panic(new $String("division by zero")); + } + a = scaleDenom(x.a, y.b.abs); + b = scaleDenom(y.a, x.b.abs); + z.a.abs = a.abs; + z.b.abs = b.abs; + z.a.neg = !(a.neg === b.neg); + _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Quo }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; + ratTok = function(ch) { + var ch; + return strings.ContainsRune("+-/0123456789.eE", ch); + }; + Rat.ptr.prototype.Scan = function(s, ch) { + var _r$1, _r$2, _tuple, _tuple$1, ch, err, ok, s, tok, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ch = $f.ch; err = $f.err; ok = $f.ok; s = $f.s; tok = $f.tok; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = s.Token(true, ratTok); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + tok = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + if (!strings.ContainsRune("efgEFGv", ch)) { + $s = -1; return errors.New("Rat.Scan: invalid verb"); + } + _r$2 = z.SetString(($bytesToString(tok))); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + ok = _tuple$1[1]; + if (!ok) { + $s = -1; return errors.New("Rat.Scan: invalid syntax"); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Scan }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ch = ch; $f.err = err; $f.ok = ok; $f.s = s; $f.tok = tok; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; + Rat.ptr.prototype.SetString = function(s) { + var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, ecorr, err, err$1, exp, expabs, neg, ok, powTen, r, r$1, s, sep, x, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; ecorr = $f.ecorr; err = $f.err; err$1 = $f.err$1; exp = $f.exp; expabs = $f.expabs; neg = $f.neg; ok = $f.ok; powTen = $f.powTen; r = $f.r; r$1 = $f.r$1; s = $f.s; sep = $f.sep; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (s.length === 0) { + $s = -1; return [ptrType$2.nil, false]; + } + sep = strings.Index(s, "/"); + /* */ if (sep >= 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (sep >= 0) { */ case 1: + _r$1 = z.a.SetString($substring(s, 0, sep), 0); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ok = _tuple[1]; + if (!ok) { + $s = -1; return [ptrType$2.nil, false]; + } + r = strings.NewReader($substring(s, (sep + 1 >> 0))); + err = $ifaceNil; + _r$2 = z.b.abs.scan(r, 0, false); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + z.b.abs = _tuple$1[0]; + err = _tuple$1[3]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$2.nil, false]; + } + _tuple$2 = r.ReadByte(); + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, io.EOF))) { + $s = -1; return [ptrType$2.nil, false]; + } + if (z.b.abs.$length === 0) { + $s = -1; return [ptrType$2.nil, false]; + } + _r$3 = z.norm(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $s = -1; return [_r$3, true]; + /* } */ case 2: + r$1 = strings.NewReader(s); + _r$4 = scanSign(r$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$3 = _r$4; + neg = _tuple$3[0]; + err$1 = _tuple$3[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$2.nil, false]; + } + ecorr = 0; + _r$5 = z.a.abs.scan(r$1, 10, true); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$4 = _r$5; + z.a.abs = _tuple$4[0]; + ecorr = _tuple$4[2]; + err$1 = _tuple$4[3]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$2.nil, false]; + } + exp = new $Int64(0, 0); + _r$6 = scanExponent(r$1, false); /* */ $s = 8; case 8: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple$5 = _r$6; + exp = _tuple$5[0]; + err$1 = _tuple$5[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$2.nil, false]; + } + _tuple$6 = r$1.ReadByte(); + err$1 = _tuple$6[1]; + if (!($interfaceIsEqual(err$1, io.EOF))) { + $s = -1; return [ptrType$2.nil, false]; + } + if (z.a.abs.$length === 0) { + $s = -1; return [z, true]; + } + if (ecorr < 0) { + exp = (x = (new $Int64(0, ecorr)), new $Int64(exp.$high + x.$high, exp.$low + x.$low)); + } + expabs = exp; + if ((expabs.$high < 0 || (expabs.$high === 0 && expabs.$low < 0))) { + expabs = new $Int64(-expabs.$high, -expabs.$low); + } + _r$7 = (nat.nil).expNN(natTen, (nat.nil).setWord(((expabs.$low >>> 0))), nat.nil); /* */ $s = 9; case 9: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + powTen = _r$7; + /* */ if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { */ case 10: + z.b.abs = powTen; + _r$8 = z.norm(); /* */ $s = 13; case 13: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _r$8; + $s = 12; continue; + /* } else { */ case 11: + z.a.abs = z.a.abs.mul(z.a.abs, powTen); + z.b.abs = $subslice(z.b.abs, 0, 0); + /* } */ case 12: + z.a.neg = neg && z.a.abs.$length > 0; + $s = -1; return [z, true]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.ecorr = ecorr; $f.err = err; $f.err$1 = err$1; $f.exp = exp; $f.expabs = expabs; $f.neg = neg; $f.ok = ok; $f.powTen = powTen; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.sep = sep; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.SetString = function(s) { return this.$val.SetString(s); }; + scanExponent = function(r, binExpOk) { + var _1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, _tuple$1, _tuple$2, _tuple$3, base, binExpOk, ch, digits, err, exp, i, neg, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; base = $f.base; binExpOk = $f.binExpOk; ch = $f.ch; digits = $f.digits; err = $f.err; exp = $f.exp; i = $f.i; neg = $f.neg; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + exp = new $Int64(0, 0); + base = 0; + err = $ifaceNil; + base = 10; + ch = 0; + _r$1 = r.ReadByte(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ch = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + err = $ifaceNil; + } + $s = -1; return [exp, base, err]; + } + _1 = ch; + /* */ if ((_1 === (101)) || (_1 === (69))) { $s = 3; continue; } + /* */ if (_1 === (112)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_1 === (101)) || (_1 === (69))) { */ case 3: + $s = 6; continue; + /* } else if (_1 === (112)) { */ case 4: + if (binExpOk) { + base = 2; + /* break; */ $s = 2; continue; + } + _r$2 = r.UnreadByte(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + $s = -1; return [exp, base, err]; + /* } else { */ case 5: + _r$3 = r.UnreadByte(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + $s = -1; return [exp, base, err]; + /* } */ case 6: + case 2: + neg = false; + _r$4 = scanSign(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + neg = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [exp, base, err]; + } + digits = sliceType$1.nil; + if (neg) { + digits = $append(digits, 45); + } + i = 0; + /* while (true) { */ case 10: + _r$5 = r.ReadByte(); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$2 = _r$5; + ch = _tuple$2[0]; + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if (!($interfaceIsEqual(err, io.EOF)) || (i === 0)) { + $s = -1; return [exp, base, err]; + } + err = $ifaceNil; + /* break; */ $s = 11; continue; + } + /* */ if (ch < 48 || 57 < ch) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (ch < 48 || 57 < ch) { */ case 13: + /* */ if (i === 0) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (i === 0) { */ case 15: + _r$6 = r.UnreadByte(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + _r$7 = fmt.Errorf("invalid exponent (missing digits)", new sliceType([])); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + err = _r$7; + $s = -1; return [exp, base, err]; + /* } */ case 16: + /* break; */ $s = 11; continue; + /* } */ case 14: + digits = $append(digits, ch); + i = i + (1) >> 0; + /* } */ $s = 10; continue; case 11: + _tuple$3 = strconv.ParseInt(($bytesToString(digits)), 10, 64); + exp = _tuple$3[0]; + err = _tuple$3[1]; + $s = -1; return [exp, base, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: scanExponent }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.base = base; $f.binExpOk = binExpOk; $f.ch = ch; $f.digits = digits; $f.err = err; $f.exp = exp; $f.i = i; $f.neg = neg; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.ptr.prototype.String = function() { + var _r$1, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + _r$1 = x.marshal(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return ($bytesToString(_r$1)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.String = function() { return this.$val.String(); }; + Rat.ptr.prototype.marshal = function() { + var _r$1, _r$2, buf, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + buf = sliceType$1.nil; + _r$1 = x.a.Append(buf, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + buf = _r$1; + buf = $append(buf, 47); + /* */ if (!((x.b.abs.$length === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((x.b.abs.$length === 0))) { */ case 2: + _r$2 = x.b.Append(buf, 10); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + buf = _r$2; + $s = 4; continue; + /* } else { */ case 3: + buf = $append(buf, 49); + /* } */ case 4: + $s = -1; return buf; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.marshal }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.marshal = function() { return this.$val.marshal(); }; + Rat.ptr.prototype.RatString = function() { + var _r$1, _r$2, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + /* */ if (x.IsInt()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (x.IsInt()) { */ case 1: + _r$1 = x.a.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + _r$2 = x.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.RatString }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.RatString = function() { return this.$val.RatString(); }; + Rat.ptr.prototype.FloatString = function(prec) { + var _arg, _arg$1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, buf, i, i$1, p, prec, q, r, r2, rs, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; i = $f.i; i$1 = $f.i$1; p = $f.p; prec = $f.prec; q = $f.q; r = $f.r; r2 = $f.r2; rs = $f.rs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = this; + buf = sliceType$1.nil; + /* */ if (x.IsInt()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (x.IsInt()) { */ case 1: + _r$1 = x.a.Append(buf, 10); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + buf = _r$1; + if (prec > 0) { + buf = $append(buf, 46); + i = prec; + while (true) { + if (!(i > 0)) { break; } + buf = $append(buf, 48); + i = i - (1) >> 0; + } + } + $s = -1; return ($bytesToString(buf)); + /* } */ case 2: + _r$2 = (nat.nil).div((nat.nil), x.a.abs, x.b.abs); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + q = _tuple[0]; + r = _tuple[1]; + p = natOne; + /* */ if (prec > 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (prec > 0) { */ case 5: + _r$3 = (nat.nil).expNN(natTen, (nat.nil).setUint64((new $Uint64(0, prec))), nat.nil); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + p = _r$3; + /* } */ case 6: + r = r.mul(r, p); + _r$4 = r.div((nat.nil), r, x.b.abs); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + r = _tuple$1[0]; + r2 = _tuple$1[1]; + r2 = r2.add(r2, r2); + if (x.b.abs.cmp(r2) <= 0) { + r = r.add(r, natOne); + if (r.cmp(p) >= 0) { + q = (nat.nil).add(q, natOne); + r = (nat.nil).sub(r, p); + } + } + if (x.a.neg) { + buf = $append(buf, 45); + } + _arg = buf; + _r$5 = q.utoa(10); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + buf = $appendSlice(_arg, _arg$1); + /* */ if (prec > 0) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (prec > 0) { */ case 10: + buf = $append(buf, 46); + _r$6 = r.utoa(10); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + rs = _r$6; + i$1 = prec - rs.$length >> 0; + while (true) { + if (!(i$1 > 0)) { break; } + buf = $append(buf, 48); + i$1 = i$1 - (1) >> 0; + } + buf = $appendSlice(buf, rs); + /* } */ case 11: + $s = -1; return ($bytesToString(buf)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.FloatString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.i = i; $f.i$1 = i$1; $f.p = p; $f.prec = prec; $f.q = q; $f.r = r; $f.r2 = r2; $f.rs = rs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.FloatString = function(prec) { return this.$val.FloatString(prec); }; + Rat.ptr.prototype.GobEncode = function() { + var b, buf, i, j, n, x; + x = this; + if (x === ptrType$2.nil) { + return [sliceType$1.nil, $ifaceNil]; + } + buf = $makeSlice(sliceType$1, (5 + ($imul(((x.a.abs.$length + x.b.abs.$length >> 0)), 4)) >> 0)); + i = x.b.abs.bytes(buf); + j = x.a.abs.bytes($subslice(buf, 0, i)); + n = i - j >> 0; + if (!((((((n >>> 0)) >> 0)) === n))) { + return [sliceType$1.nil, errors.New("Rat.GobEncode: numerator too large")]; + } + $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, (j - 4 >> 0), j), ((n >>> 0))); + j = j - (5) >> 0; + b = 2; + if (x.a.neg) { + b = (b | (1)) >>> 0; + } + ((j < 0 || j >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + j] = b); + return [$subslice(buf, j), $ifaceNil]; + }; + Rat.prototype.GobEncode = function() { return this.$val.GobEncode(); }; + Rat.ptr.prototype.GobDecode = function(buf) { + var _r$1, b, buf, i, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; i = $f.i; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + if (buf.$length === 0) { + Rat.copy(z, new Rat.ptr(new Int.ptr(false, nat.nil), new Int.ptr(false, nat.nil))); + $s = -1; return $ifaceNil; + } + b = (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]); + /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1: + _r$1 = fmt.Errorf("Rat.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 2: + i = 5 + $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 1, 5)) >>> 0; + z.a.neg = !((((b & 1) >>> 0) === 0)); + z.a.abs = z.a.abs.setBytes($subslice(buf, 5, i)); + z.b.abs = z.b.abs.setBytes($subslice(buf, i)); + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.i = i; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; + Rat.ptr.prototype.MarshalText = function() { + var _r$1, _r$2, _tmp, _tmp$1, _tuple, err, text, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + text = sliceType$1.nil; + err = $ifaceNil; + x = this; + /* */ if (x.IsInt()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (x.IsInt()) { */ case 1: + _r$1 = x.a.MarshalText(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + text = _tuple[0]; + err = _tuple[1]; + $s = -1; return [text, err]; + /* } */ case 2: + _r$2 = x.marshal(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tmp = _r$2; + _tmp$1 = $ifaceNil; + text = _tmp; + err = _tmp$1; + $s = -1; return [text, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.MarshalText = function() { return this.$val.MarshalText(); }; + Rat.ptr.prototype.UnmarshalText = function(text) { + var _r$1, _r$2, _tuple, ok, text, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + _r$1 = z.SetString(($bytesToString(text))); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + ok = _tuple[1]; + /* */ if (!ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!ok) { */ case 2: + _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", new sliceType([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* } */ case 3: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Rat.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; + RoundingMode.prototype.String = function() { + var i, x; + i = this.$val; + if (i >= 6) { + return "RoundingMode(" + strconv.FormatInt((new $Int64(0, i)), 10) + ")"; + } + return $substring("ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegativeInfToPositiveInf", ((i < 0 || i >= _RoundingMode_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _RoundingMode_index[i]), (x = i + 1 << 24 >>> 24, ((x < 0 || x >= _RoundingMode_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _RoundingMode_index[x]))); + }; + $ptrType(RoundingMode).prototype.String = function() { return new RoundingMode(this.$get()).String(); }; + Float.ptr.prototype.Sqrt = function(x) { + var _1, _q, _r$1, _r$2, _r$3, _r$4, b, prec, x, x$1, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; b = $f.b; prec = $f.prec; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = this; + /* */ if (false) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (false) { */ case 1: + $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (z.prec === 0) { + z.prec = x.prec; + } + _r$1 = x.Sign(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1 === -1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1 === -1) { */ case 4: + $panic((x$1 = new ErrNaN.ptr("square root of negative operand"), new x$1.constructor.elem(x$1))); + /* } */ case 5: + if (!((x.form === 1))) { + z.acc = 0; + z.form = x.form; + z.neg = x.neg; + $s = -1; return z; + } + prec = z.prec; + _r$2 = x.MantExp(z); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + b = _r$2; + z.prec = prec; + _1 = (_r$3 = b % 2, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (_1 === (0)) { + } else if (_1 === (1)) { + z.exp = z.exp + (1) >> 0; + } else if (_1 === (-1)) { + z.exp = z.exp - (1) >> 0; + } + /* */ if (z.prec <= 128) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (z.prec <= 128) { */ case 8: + $r = z.sqrtDirect(z); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 10; continue; + /* } else { */ case 9: + $r = z.sqrtInverse(z); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + _r$4 = z.SetMantExp(z, (_q = b / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sqrt }; } $f._1 = _1; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.b = b; $f.prec = prec; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.Sqrt = function(x) { return this.$val.Sqrt(x); }; + Float.ptr.prototype.sqrtDirect = function(x) { + var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, ng, sq, u, x, xf, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; ng = $f.ng; sq = $f.sq; u = $f.u; x = $f.x; xf = $f.xf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + u = [u]; + x = [x]; + z = this; + u[0] = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + ng = (function(u, x) { return function $b(t) { + var _r$1, _r$2, _r$3, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + u[0].prec = t.prec; + _r$1 = u[0].Mul(t, t); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + _r$2 = u[0].Add(u[0], x[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + u[0].exp = u[0].exp - (1) >> 0; + _r$3 = t.Quo(u[0], t); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $s = -1; return _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; })(u, x); + _r$1 = x[0].Float64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + xf = _tuple[0]; + _r$2 = NewFloat(math.Sqrt(xf)); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + sq = _r$2; + /* */ if (z.prec > 128) { $s = 4; continue; } + /* */ if (z.prec > 64) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (z.prec > 128) { */ case 4: + $panic(new $String("sqrtDirect: only for z.prec <= 128")); + $s = 7; continue; + /* } else if (z.prec > 64) { */ case 5: + sq.prec = $imul(sq.prec, (2)) >>> 0; + _r$3 = ng(sq); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + sq = _r$3; + sq.prec = $imul(sq.prec, (2)) >>> 0; + _r$4 = ng(sq); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + sq = _r$4; + $s = 7; continue; + /* } else { */ case 6: + sq.prec = $imul(sq.prec, (2)) >>> 0; + _r$5 = ng(sq); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + sq = _r$5; + /* } */ case 7: + case 3: + _r$6 = z.Set(sq); /* */ $s = 11; case 11: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.sqrtDirect }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f.ng = ng; $f.sq = sq; $f.u = u; $f.x = x; $f.xf = xf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.sqrtDirect = function(x) { return this.$val.sqrtDirect(x); }; + Float.ptr.prototype.sqrtInverse = function(x) { + var _r$1, _r$2, _r$3, _r$4, _tuple, ng, prec, sqi, u, v, x, xf, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; ng = $f.ng; prec = $f.prec; sqi = $f.sqi; u = $f.u; v = $f.v; x = $f.x; xf = $f.xf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + u = [u]; + v = [v]; + x = [x]; + z = this; + u[0] = newFloat(z.prec); + v[0] = newFloat(z.prec); + ng = (function(u, v, x) { return function $b(t) { + var _r$1, _r$2, _r$3, _r$4, _r$5, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + u[0].prec = t.prec; + v[0].prec = t.prec; + _r$1 = u[0].Mul(t, t); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + _r$2 = u[0].Mul(x[0], u[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + _r$3 = v[0].Sub(three, u[0]); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + _r$4 = u[0].Mul(t, v[0]); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + u[0].exp = u[0].exp - (1) >> 0; + _r$5 = t.Set(u[0]); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return _r$5; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; })(u, v, x); + _r$1 = x[0].Float64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + xf = _tuple[0]; + sqi = newFloat(z.prec); + _r$2 = sqi.SetFloat64(1 / math.Sqrt(xf)); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + prec = z.prec + 32 >>> 0; + /* while (true) { */ case 3: + /* if (!(sqi.prec < prec)) { break; } */ if(!(sqi.prec < prec)) { $s = 4; continue; } + sqi.prec = $imul(sqi.prec, (2)) >>> 0; + _r$3 = ng(sqi); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + sqi = _r$3; + /* } */ $s = 3; continue; case 4: + _r$4 = z.Mul(x[0], sqi); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.sqrtInverse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.ng = ng; $f.prec = prec; $f.sqi = sqi; $f.u = u; $f.v = v; $f.x = x; $f.xf = xf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + Float.prototype.sqrtInverse = function(x) { return this.$val.sqrtInverse(x); }; + newFloat = function(prec2) { + var _q, prec2, z; + z = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); + z.mant = z.mant.make($imul((((_q = prec2 / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)), 2)); + return z; + }; + ptrType$5.methods = [{prop: "at", name: "at", pkg: "math/big", typ: $funcType([$Int], [$Uint8], false)}, {prop: "init", name: "init", pkg: "math/big", typ: $funcType([nat, $Int], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "round", name: "round", pkg: "math/big", typ: $funcType([$Int], [], false)}, {prop: "roundUp", name: "roundUp", pkg: "math/big", typ: $funcType([$Int], [], false)}, {prop: "roundDown", name: "roundDown", pkg: "math/big", typ: $funcType([$Int], [], false)}]; + ptrType.methods = [{prop: "SetPrec", name: "SetPrec", pkg: "", typ: $funcType([$Uint], [ptrType], false)}, {prop: "SetMode", name: "SetMode", pkg: "", typ: $funcType([RoundingMode], [ptrType], false)}, {prop: "Prec", name: "Prec", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "MinPrec", name: "MinPrec", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [RoundingMode], false)}, {prop: "Acc", name: "Acc", pkg: "", typ: $funcType([], [Accuracy], false)}, {prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MantExp", name: "MantExp", pkg: "", typ: $funcType([ptrType], [$Int], false)}, {prop: "setExpAndRound", name: "setExpAndRound", pkg: "math/big", typ: $funcType([$Int64, $Uint], [], false)}, {prop: "SetMantExp", name: "SetMantExp", pkg: "", typ: $funcType([ptrType, $Int], [ptrType], false)}, {prop: "Signbit", name: "Signbit", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsInf", name: "IsInf", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsInt", name: "IsInt", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "validate", name: "validate", pkg: "math/big", typ: $funcType([], [], false)}, {prop: "round", name: "round", pkg: "math/big", typ: $funcType([$Uint], [], false)}, {prop: "setBits64", name: "setBits64", pkg: "math/big", typ: $funcType([$Bool, $Uint64], [ptrType], false)}, {prop: "SetUint64", name: "SetUint64", pkg: "", typ: $funcType([$Uint64], [ptrType], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType], false)}, {prop: "SetFloat64", name: "SetFloat64", pkg: "", typ: $funcType([$Float64], [ptrType], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([ptrType$1], [ptrType], false)}, {prop: "SetRat", name: "SetRat", pkg: "", typ: $funcType([ptrType$2], [ptrType], false)}, {prop: "SetInf", name: "SetInf", pkg: "", typ: $funcType([$Bool], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Copy", name: "Copy", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64, Accuracy], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64, Accuracy], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32, Accuracy], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, Accuracy], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([ptrType$1], [ptrType$1, Accuracy], false)}, {prop: "Rat", name: "Rat", pkg: "", typ: $funcType([ptrType$2], [ptrType$2, Accuracy], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "uadd", name: "uadd", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "usub", name: "usub", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "umul", name: "umul", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "uquo", name: "uquo", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "ucmp", name: "ucmp", pkg: "math/big", typ: $funcType([ptrType], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType], [$Int], false)}, {prop: "ord", name: "ord", pkg: "math/big", typ: $funcType([], [$Int], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [ptrType, $Bool], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType, $Int, $error], false)}, {prop: "pow5", name: "pow5", pkg: "math/big", typ: $funcType([$Uint64], [ptrType], false)}, {prop: "Parse", name: "Parse", pkg: "", typ: $funcType([$String, $Int], [ptrType, $Int, $error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "Text", name: "Text", pkg: "", typ: $funcType([$Uint8, $Int], [$String], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$1, $Uint8, $Int], [sliceType$1], false)}, {prop: "fmtB", name: "fmtB", pkg: "math/big", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "fmtP", name: "fmtP", pkg: "math/big", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([fmt.State, $Int32], [], false)}, {prop: "Sqrt", name: "Sqrt", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "sqrtDirect", name: "sqrtDirect", pkg: "math/big", typ: $funcType([ptrType], [], false)}, {prop: "sqrtInverse", name: "sqrtInverse", pkg: "math/big", typ: $funcType([ptrType], [], false)}]; + ErrNaN.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + RoundingMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + Accuracy.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType$1], false)}, {prop: "SetUint64", name: "SetUint64", pkg: "", typ: $funcType([$Uint64], [ptrType$1], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "SetBits", name: "SetBits", pkg: "", typ: $funcType([sliceType$2], [ptrType$1], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "MulRange", name: "MulRange", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$1], false)}, {prop: "Binomial", name: "Binomial", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$1], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Rem", name: "Rem", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "QuoRem", name: "QuoRem", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1, ptrType$1], false)}, {prop: "Div", name: "Div", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Mod", name: "Mod", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "DivMod", name: "DivMod", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1, ptrType$1], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType$1], [$Int], false)}, {prop: "CmpAbs", name: "CmpAbs", pkg: "", typ: $funcType([ptrType$1], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "IsInt64", name: "IsInt64", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsUint64", name: "IsUint64", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String, $Int], [ptrType$1, $Bool], false)}, {prop: "setFromScanner", name: "setFromScanner", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType$1, $Bool], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$1], [ptrType$1], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "BitLen", name: "BitLen", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Exp", name: "Exp", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "GCD", name: "GCD", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "lehmerGCD", name: "lehmerGCD", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Rand", name: "Rand", pkg: "", typ: $funcType([ptrType$6, ptrType$1], [ptrType$1], false)}, {prop: "ModInverse", name: "ModInverse", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrt3Mod4Prime", name: "modSqrt3Mod4Prime", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrt5Mod8Prime", name: "modSqrt5Mod8Prime", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrtTonelliShanks", name: "modSqrtTonelliShanks", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "ModSqrt", name: "ModSqrt", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Lsh", name: "Lsh", pkg: "", typ: $funcType([ptrType$1, $Uint], [ptrType$1], false)}, {prop: "Rsh", name: "Rsh", pkg: "", typ: $funcType([ptrType$1, $Uint], [ptrType$1], false)}, {prop: "Bit", name: "Bit", pkg: "", typ: $funcType([$Int], [$Uint], false)}, {prop: "SetBit", name: "SetBit", pkg: "", typ: $funcType([ptrType$1, $Int, $Uint], [ptrType$1], false)}, {prop: "And", name: "And", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "AndNot", name: "AndNot", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Or", name: "Or", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Xor", name: "Xor", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Not", name: "Not", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Sqrt", name: "Sqrt", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Text", name: "Text", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$1, $Int], [sliceType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([fmt.State, $Int32], [], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType$1, $Int, $error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "ProbablyPrime", name: "ProbablyPrime", pkg: "", typ: $funcType([$Int], [$Bool], false)}]; + byteReader.methods = [{prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}]; + nat.methods = [{prop: "clear", name: "clear", pkg: "math/big", typ: $funcType([], [], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [nat], false)}, {prop: "make", name: "make", pkg: "math/big", typ: $funcType([$Int], [nat], false)}, {prop: "setWord", name: "setWord", pkg: "math/big", typ: $funcType([Word], [nat], false)}, {prop: "setUint64", name: "setUint64", pkg: "math/big", typ: $funcType([$Uint64], [nat], false)}, {prop: "set", name: "set", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "add", name: "add", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "sub", name: "sub", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "cmp", name: "cmp", pkg: "math/big", typ: $funcType([nat], [$Int], false)}, {prop: "mulAddWW", name: "mulAddWW", pkg: "math/big", typ: $funcType([nat, Word, Word], [nat], false)}, {prop: "montgomery", name: "montgomery", pkg: "math/big", typ: $funcType([nat, nat, nat, Word, $Int], [nat], false)}, {prop: "mul", name: "mul", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "sqr", name: "sqr", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "mulRange", name: "mulRange", pkg: "math/big", typ: $funcType([$Uint64, $Uint64], [nat], false)}, {prop: "divW", name: "divW", pkg: "math/big", typ: $funcType([nat, Word], [nat, Word], false)}, {prop: "div", name: "div", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "divLarge", name: "divLarge", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "bitLen", name: "bitLen", pkg: "math/big", typ: $funcType([], [$Int], false)}, {prop: "trailingZeroBits", name: "trailingZeroBits", pkg: "math/big", typ: $funcType([], [$Uint], false)}, {prop: "shl", name: "shl", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "shr", name: "shr", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "setBit", name: "setBit", pkg: "math/big", typ: $funcType([nat, $Uint, $Uint], [nat], false)}, {prop: "bit", name: "bit", pkg: "math/big", typ: $funcType([$Uint], [$Uint], false)}, {prop: "sticky", name: "sticky", pkg: "math/big", typ: $funcType([$Uint], [$Uint], false)}, {prop: "and", name: "and", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "andNot", name: "andNot", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "or", name: "or", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "xor", name: "xor", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "modW", name: "modW", pkg: "math/big", typ: $funcType([Word], [Word], false)}, {prop: "random", name: "random", pkg: "math/big", typ: $funcType([ptrType$6, nat, $Int], [nat], false)}, {prop: "expNN", name: "expNN", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "expNNWindowed", name: "expNNWindowed", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "expNNMontgomery", name: "expNNMontgomery", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "bytes", name: "bytes", pkg: "math/big", typ: $funcType([sliceType$1], [$Int], false)}, {prop: "setBytes", name: "setBytes", pkg: "math/big", typ: $funcType([sliceType$1], [nat], false)}, {prop: "sqrt", name: "sqrt", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int, $Bool], [nat, $Int, $Int, $error], false)}, {prop: "utoa", name: "utoa", pkg: "math/big", typ: $funcType([$Int], [sliceType$1], false)}, {prop: "itoa", name: "itoa", pkg: "math/big", typ: $funcType([$Bool, $Int], [sliceType$1], false)}, {prop: "convertWords", name: "convertWords", pkg: "math/big", typ: $funcType([sliceType$1, Word, $Int, Word, sliceType$3], [], false)}, {prop: "expWW", name: "expWW", pkg: "math/big", typ: $funcType([Word, Word], [nat], false)}, {prop: "probablyPrimeMillerRabin", name: "probablyPrimeMillerRabin", pkg: "math/big", typ: $funcType([$Int, $Bool], [$Bool], false)}, {prop: "probablyPrimeLucas", name: "probablyPrimeLucas", pkg: "math/big", typ: $funcType([], [$Bool], false)}]; + ptrType$2.methods = [{prop: "SetFloat64", name: "SetFloat64", pkg: "", typ: $funcType([$Float64], [ptrType$2], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32, $Bool], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $Bool], false)}, {prop: "SetFrac", name: "SetFrac", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$2], false)}, {prop: "SetFrac64", name: "SetFrac64", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$2], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([ptrType$1], [ptrType$2], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType$2], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Inv", name: "Inv", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "IsInt", name: "IsInt", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Num", name: "Num", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Denom", name: "Denom", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [ptrType$2], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType$2], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [ptrType$2, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "marshal", name: "marshal", pkg: "math/big", typ: $funcType([], [sliceType$1], false)}, {prop: "RatString", name: "RatString", pkg: "", typ: $funcType([], [$String], false)}, {prop: "FloatString", name: "FloatString", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}]; + decimal.init("math/big", [{prop: "mant", name: "mant", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int, tag: ""}]); + Float.init("math/big", [{prop: "prec", name: "prec", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "mode", name: "mode", embedded: false, exported: false, typ: RoundingMode, tag: ""}, {prop: "acc", name: "acc", embedded: false, exported: false, typ: Accuracy, tag: ""}, {prop: "form", name: "form", embedded: false, exported: false, typ: form, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "mant", name: "mant", embedded: false, exported: false, typ: nat, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int32, tag: ""}]); + ErrNaN.init("math/big", [{prop: "msg", name: "msg", embedded: false, exported: false, typ: $String, tag: ""}]); + Int.init("math/big", [{prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "abs", name: "abs", embedded: false, exported: false, typ: nat, tag: ""}]); + byteReader.init("", [{prop: "ScanState", name: "ScanState", embedded: true, exported: true, typ: fmt.ScanState, tag: ""}]); + nat.init(Word); + divisor.init("math/big", [{prop: "bbb", name: "bbb", embedded: false, exported: false, typ: nat, tag: ""}, {prop: "nbits", name: "nbits", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "ndigits", name: "ndigits", embedded: false, exported: false, typ: $Int, tag: ""}]); + Rat.init("math/big", [{prop: "a", name: "a", embedded: false, exported: false, typ: Int, tag: ""}, {prop: "b", name: "b", embedded: false, exported: false, typ: Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = binary.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = errors.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = bits.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = rand.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + natPool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); + cacheBase10 = new structType.ptr(new nosync.Mutex.ptr(false), arrayType.zero()); + _Accuracy_index = $toNativeArray($kindUint8, [0, 5, 10, 15]); + pow5tab = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 5), new $Uint64(0, 25), new $Uint64(0, 125), new $Uint64(0, 625), new $Uint64(0, 3125), new $Uint64(0, 15625), new $Uint64(0, 78125), new $Uint64(0, 390625), new $Uint64(0, 1953125), new $Uint64(0, 9765625), new $Uint64(0, 48828125), new $Uint64(0, 244140625), new $Uint64(0, 1220703125), new $Uint64(1, 1808548329), new $Uint64(7, 452807053), new $Uint64(35, 2264035265), new $Uint64(177, 2730241733), new $Uint64(888, 766306777), new $Uint64(4440, 3831533885), new $Uint64(22204, 1977800241), new $Uint64(111022, 1299066613), new $Uint64(555111, 2200365769), new $Uint64(2775557, 2411894253), new $Uint64(13877787, 3469536673), new $Uint64(69388939, 167814181), new $Uint64(346944695, 839070905), new $Uint64(1734723475, 4195354525)]); + natOne = new nat([1]); + intOne = new Int.ptr(false, natOne); + natTwo = new nat([2]); + natTen = new nat([10]); + karatsubaThreshold = 40; + basicSqrThreshold = 20; + karatsubaSqrThreshold = 260; + leafSize = 8; + _RoundingMode_index = $toNativeArray($kindUint8, [0, 13, 26, 32, 44, 57, 70]); + _r = NewFloat(3); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + three = _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["regexp/syntax"] = (function() { + var $pkg = {}, $init, sort, strconv, strings, unicode, utf8, patchList, frag, compiler, Error, ErrorCode, Flags, parser, charGroup, ranges, Prog, InstOp, EmptyOp, Inst, Regexp, Op, sliceType, sliceType$1, sliceType$2, sliceType$3, ptrType, sliceType$4, ptrType$1, sliceType$5, arrayType, arrayType$1, ptrType$2, ptrType$3, ptrType$4, sliceType$6, ptrType$5, ptrType$6, ptrType$7, ptrType$8, anyRuneNotNL, anyRune, _Op_index_0, anyTable, code1, code2, code3, perlGroup, code4, code5, code6, code7, code8, code9, code10, code11, code12, code13, code14, code15, code16, code17, posixGroup, instOpNames, Compile, minFoldRune, repeatIsValid, cleanAlt, literalRegexp, Parse, isValidCaptureName, isCharClass, matchRune, mergeCharClass, unicodeTable, cleanClass, appendLiteral, appendRange, appendFoldedRange, appendClass, appendFoldedClass, appendNegatedClass, appendTable, appendNegatedTable, negateClass, checkUTF8, nextRune, isalnum, unhex, IsWordChar, bw, dumpProg, u32, dumpInst, writeRegexp, escape, simplify1; + sort = $packages["sort"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + patchList = $pkg.patchList = $newType(4, $kindUint32, "syntax.patchList", true, "regexp/syntax", false, null); + frag = $pkg.frag = $newType(0, $kindStruct, "syntax.frag", true, "regexp/syntax", false, function(i_, out_) { + this.$val = this; + if (arguments.length === 0) { + this.i = 0; + this.out = 0; + return; + } + this.i = i_; + this.out = out_; + }); + compiler = $pkg.compiler = $newType(0, $kindStruct, "syntax.compiler", true, "regexp/syntax", false, function(p_) { + this.$val = this; + if (arguments.length === 0) { + this.p = ptrType.nil; + return; + } + this.p = p_; + }); + Error = $pkg.Error = $newType(0, $kindStruct, "syntax.Error", true, "regexp/syntax", true, function(Code_, Expr_) { + this.$val = this; + if (arguments.length === 0) { + this.Code = ""; + this.Expr = ""; + return; + } + this.Code = Code_; + this.Expr = Expr_; + }); + ErrorCode = $pkg.ErrorCode = $newType(8, $kindString, "syntax.ErrorCode", true, "regexp/syntax", true, null); + Flags = $pkg.Flags = $newType(2, $kindUint16, "syntax.Flags", true, "regexp/syntax", true, null); + parser = $pkg.parser = $newType(0, $kindStruct, "syntax.parser", true, "regexp/syntax", false, function(flags_, stack_, free_, numCap_, wholeRegexp_, tmpClass_) { + this.$val = this; + if (arguments.length === 0) { + this.flags = 0; + this.stack = sliceType$5.nil; + this.free = ptrType$1.nil; + this.numCap = 0; + this.wholeRegexp = ""; + this.tmpClass = sliceType.nil; + return; + } + this.flags = flags_; + this.stack = stack_; + this.free = free_; + this.numCap = numCap_; + this.wholeRegexp = wholeRegexp_; + this.tmpClass = tmpClass_; + }); + charGroup = $pkg.charGroup = $newType(0, $kindStruct, "syntax.charGroup", true, "regexp/syntax", false, function(sign_, class$1_) { + this.$val = this; + if (arguments.length === 0) { + this.sign = 0; + this.class$1 = sliceType.nil; + return; + } + this.sign = sign_; + this.class$1 = class$1_; + }); + ranges = $pkg.ranges = $newType(0, $kindStruct, "syntax.ranges", true, "regexp/syntax", false, function(p_) { + this.$val = this; + if (arguments.length === 0) { + this.p = ptrType$2.nil; + return; + } + this.p = p_; + }); + Prog = $pkg.Prog = $newType(0, $kindStruct, "syntax.Prog", true, "regexp/syntax", true, function(Inst_, Start_, NumCap_) { + this.$val = this; + if (arguments.length === 0) { + this.Inst = sliceType$4.nil; + this.Start = 0; + this.NumCap = 0; + return; + } + this.Inst = Inst_; + this.Start = Start_; + this.NumCap = NumCap_; + }); + InstOp = $pkg.InstOp = $newType(1, $kindUint8, "syntax.InstOp", true, "regexp/syntax", true, null); + EmptyOp = $pkg.EmptyOp = $newType(1, $kindUint8, "syntax.EmptyOp", true, "regexp/syntax", true, null); + Inst = $pkg.Inst = $newType(0, $kindStruct, "syntax.Inst", true, "regexp/syntax", true, function(Op_, Out_, Arg_, Rune_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = 0; + this.Out = 0; + this.Arg = 0; + this.Rune = sliceType.nil; + return; + } + this.Op = Op_; + this.Out = Out_; + this.Arg = Arg_; + this.Rune = Rune_; + }); + Regexp = $pkg.Regexp = $newType(0, $kindStruct, "syntax.Regexp", true, "regexp/syntax", true, function(Op_, Flags_, Sub_, Sub0_, Rune_, Rune0_, Min_, Max_, Cap_, Name_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = 0; + this.Flags = 0; + this.Sub = sliceType$5.nil; + this.Sub0 = arrayType.zero(); + this.Rune = sliceType.nil; + this.Rune0 = arrayType$1.zero(); + this.Min = 0; + this.Max = 0; + this.Cap = 0; + this.Name = ""; + return; + } + this.Op = Op_; + this.Flags = Flags_; + this.Sub = Sub_; + this.Sub0 = Sub0_; + this.Rune = Rune_; + this.Rune0 = Rune0_; + this.Min = Min_; + this.Max = Max_; + this.Cap = Cap_; + this.Name = Name_; + }); + Op = $pkg.Op = $newType(1, $kindUint8, "syntax.Op", true, "regexp/syntax", true, null); + sliceType = $sliceType($Int32); + sliceType$1 = $sliceType(unicode.Range16); + sliceType$2 = $sliceType(unicode.Range32); + sliceType$3 = $sliceType($String); + ptrType = $ptrType(Prog); + sliceType$4 = $sliceType(Inst); + ptrType$1 = $ptrType(Regexp); + sliceType$5 = $sliceType(ptrType$1); + arrayType = $arrayType(ptrType$1, 1); + arrayType$1 = $arrayType($Int32, 2); + ptrType$2 = $ptrType(sliceType); + ptrType$3 = $ptrType(unicode.RangeTable); + ptrType$4 = $ptrType(strings.Builder); + sliceType$6 = $sliceType($Uint8); + ptrType$5 = $ptrType(compiler); + ptrType$6 = $ptrType(Error); + ptrType$7 = $ptrType(parser); + ptrType$8 = $ptrType(Inst); + patchList.prototype.next = function(p) { + var i, l, p, x, x$1; + l = this.$val; + i = (x = p.Inst, x$1 = l >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (((l & 1) >>> 0) === 0) { + return ((i.Out >>> 0)); + } + return ((i.Arg >>> 0)); + }; + $ptrType(patchList).prototype.next = function(p) { return new patchList(this.$get()).next(p); }; + patchList.prototype.patch = function(p, val) { + var i, l, p, val, x, x$1; + l = this.$val; + while (true) { + if (!(!((l === 0)))) { break; } + i = (x = p.Inst, x$1 = l >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (((l & 1) >>> 0) === 0) { + l = ((i.Out >>> 0)); + i.Out = val; + } else { + l = ((i.Arg >>> 0)); + i.Arg = val; + } + } + }; + $ptrType(patchList).prototype.patch = function(p, val) { return new patchList(this.$get()).patch(p, val); }; + patchList.prototype.append = function(p, l2) { + var i, l1, l2, last, next, p, x, x$1; + l1 = this.$val; + if (l1 === 0) { + return l2; + } + if (l2 === 0) { + return l1; + } + last = l1; + while (true) { + next = new patchList(last).next(p); + if (next === 0) { + break; + } + last = next; + } + i = (x = p.Inst, x$1 = last >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (((last & 1) >>> 0) === 0) { + i.Out = ((l2 >>> 0)); + } else { + i.Arg = ((l2 >>> 0)); + } + return l1; + }; + $ptrType(patchList).prototype.append = function(p, l2) { return new patchList(this.$get()).append(p, l2); }; + Compile = function(re) { + var c, f, re; + c = new compiler.ptr(ptrType.nil); + c.init(); + f = $clone(c.compile(re), frag); + new patchList(f.out).patch(c.p, c.inst(4).i); + c.p.Start = ((f.i >> 0)); + return [c.p, $ifaceNil]; + }; + $pkg.Compile = Compile; + compiler.ptr.prototype.init = function() { + var c; + c = this; + c.p = new Prog.ptr(sliceType$4.nil, 0, 0); + c.p.NumCap = 2; + c.inst(5); + }; + compiler.prototype.init = function() { return this.$val.init(); }; + compiler.ptr.prototype.compile = function(re) { + var _1, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, bra, c, f, f$1, f$2, f1, i, j, ket, re, sub, sub$1, sub$2, x, x$1, x$2, x$3; + c = this; + _1 = re.Op; + if (_1 === (1)) { + return c.fail(); + } else if (_1 === (2)) { + return c.nop(); + } else if (_1 === (3)) { + if (re.Rune.$length === 0) { + return c.nop(); + } + f = new frag.ptr(0, 0); + _ref = re.Rune; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + j = _i; + f1 = $clone(c.rune($subslice(re.Rune, j, (j + 1 >> 0)), re.Flags), frag); + if (j === 0) { + frag.copy(f, f1); + } else { + frag.copy(f, c.cat($clone(f, frag), $clone(f1, frag))); + } + _i++; + } + return f; + } else if (_1 === (4)) { + return c.rune(re.Rune, re.Flags); + } else if (_1 === (5)) { + return c.rune(anyRuneNotNL, 0); + } else if (_1 === (6)) { + return c.rune(anyRune, 0); + } else if (_1 === (7)) { + return c.empty(1); + } else if (_1 === (8)) { + return c.empty(2); + } else if (_1 === (9)) { + return c.empty(4); + } else if (_1 === (10)) { + return c.empty(8); + } else if (_1 === (11)) { + return c.empty(16); + } else if (_1 === (12)) { + return c.empty(32); + } else if (_1 === (13)) { + bra = $clone(c.cap((((re.Cap << 1 >> 0) >>> 0))), frag); + sub = $clone(c.compile((x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))), frag); + ket = $clone(c.cap(((((re.Cap << 1 >> 0) | 1) >>> 0))), frag); + return c.cat($clone(c.cat($clone(bra, frag), $clone(sub, frag)), frag), $clone(ket, frag)); + } else if (_1 === (14)) { + return c.star($clone(c.compile((x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); + } else if (_1 === (15)) { + return c.plus($clone(c.compile((x$2 = re.Sub, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); + } else if (_1 === (16)) { + return c.quest($clone(c.compile((x$3 = re.Sub, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); + } else if (_1 === (18)) { + if (re.Sub.$length === 0) { + return c.nop(); + } + f$1 = new frag.ptr(0, 0); + _ref$1 = re.Sub; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i = _i$1; + sub$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + if (i === 0) { + frag.copy(f$1, c.compile(sub$1)); + } else { + frag.copy(f$1, c.cat($clone(f$1, frag), $clone(c.compile(sub$1), frag))); + } + _i$1++; + } + return f$1; + } else if (_1 === (19)) { + f$2 = new frag.ptr(0, 0); + _ref$2 = re.Sub; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + sub$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$2.$array[_ref$2.$offset + _i$2]); + frag.copy(f$2, c.alt($clone(f$2, frag), $clone(c.compile(sub$2), frag))); + _i$2++; + } + return f$2; + } + $panic(new $String("regexp: unhandled case in compile")); + }; + compiler.prototype.compile = function(re) { return this.$val.compile(re); }; + compiler.ptr.prototype.inst = function(op) { + var c, f, op; + c = this; + f = new frag.ptr(((c.p.Inst.$length >>> 0)), 0); + c.p.Inst = $append(c.p.Inst, new Inst.ptr(op, 0, 0, sliceType.nil)); + return f; + }; + compiler.prototype.inst = function(op) { return this.$val.inst(op); }; + compiler.ptr.prototype.nop = function() { + var c, f; + c = this; + f = $clone(c.inst(6), frag); + f.out = (((f.i << 1 >>> 0) >>> 0)); + return f; + }; + compiler.prototype.nop = function() { return this.$val.nop(); }; + compiler.ptr.prototype.fail = function() { + var c; + c = this; + return new frag.ptr(0, 0); + }; + compiler.prototype.fail = function() { return this.$val.fail(); }; + compiler.ptr.prototype.cap = function(arg) { + var arg, c, f, x, x$1; + c = this; + f = $clone(c.inst(2), frag); + f.out = (((f.i << 1 >>> 0) >>> 0)); + (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Arg = arg; + if (c.p.NumCap < (((arg >> 0)) + 1 >> 0)) { + c.p.NumCap = ((arg >> 0)) + 1 >> 0; + } + return f; + }; + compiler.prototype.cap = function(arg) { return this.$val.cap(arg); }; + compiler.ptr.prototype.cat = function(f1, f2) { + var c, f1, f2; + c = this; + if ((f1.i === 0) || (f2.i === 0)) { + return new frag.ptr(0, 0); + } + new patchList(f1.out).patch(c.p, f2.i); + return new frag.ptr(f1.i, f2.out); + }; + compiler.prototype.cat = function(f1, f2) { return this.$val.cat(f1, f2); }; + compiler.ptr.prototype.alt = function(f1, f2) { + var c, f, f1, f2, i, x, x$1; + c = this; + if (f1.i === 0) { + return f2; + } + if (f2.i === 0) { + return f1; + } + f = $clone(c.inst(0), frag); + i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + i.Out = f1.i; + i.Arg = f2.i; + f.out = new patchList(f1.out).append(c.p, f2.out); + return f; + }; + compiler.prototype.alt = function(f1, f2) { return this.$val.alt(f1, f2); }; + compiler.ptr.prototype.quest = function(f1, nongreedy) { + var c, f, f1, i, nongreedy, x, x$1; + c = this; + f = $clone(c.inst(0), frag); + i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (nongreedy) { + i.Arg = f1.i; + f.out = (((f.i << 1 >>> 0) >>> 0)); + } else { + i.Out = f1.i; + f.out = (((((f.i << 1 >>> 0) | 1) >>> 0) >>> 0)); + } + f.out = new patchList(f.out).append(c.p, f1.out); + return f; + }; + compiler.prototype.quest = function(f1, nongreedy) { return this.$val.quest(f1, nongreedy); }; + compiler.ptr.prototype.star = function(f1, nongreedy) { + var c, f, f1, i, nongreedy, x, x$1; + c = this; + f = $clone(c.inst(0), frag); + i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (nongreedy) { + i.Arg = f1.i; + f.out = (((f.i << 1 >>> 0) >>> 0)); + } else { + i.Out = f1.i; + f.out = (((((f.i << 1 >>> 0) | 1) >>> 0) >>> 0)); + } + new patchList(f1.out).patch(c.p, f.i); + return f; + }; + compiler.prototype.star = function(f1, nongreedy) { return this.$val.star(f1, nongreedy); }; + compiler.ptr.prototype.plus = function(f1, nongreedy) { + var c, f1, nongreedy; + c = this; + return new frag.ptr(f1.i, c.star($clone(f1, frag), nongreedy).out); + }; + compiler.prototype.plus = function(f1, nongreedy) { return this.$val.plus(f1, nongreedy); }; + compiler.ptr.prototype.empty = function(op) { + var c, f, op, x, x$1; + c = this; + f = $clone(c.inst(3), frag); + (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Arg = ((op >>> 0)); + f.out = (((f.i << 1 >>> 0) >>> 0)); + return f; + }; + compiler.prototype.empty = function(op) { return this.$val.empty(op); }; + compiler.ptr.prototype.rune = function(r, flags) { + var c, f, flags, i, r, x, x$1; + c = this; + f = $clone(c.inst(7), frag); + i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + i.Rune = r; + flags = (flags & (1)) >>> 0; + if (!((r.$length === 1)) || (unicode.SimpleFold((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0])) === (0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]))) { + flags = (flags & ~(1)) << 16 >>> 16; + } + i.Arg = ((flags >>> 0)); + f.out = (((f.i << 1 >>> 0) >>> 0)); + if ((((flags & 1) >>> 0) === 0) && ((r.$length === 1) || (r.$length === 2) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === (1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1])))) { + i.Op = 8; + } else if ((r.$length === 2) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === 0) && ((1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1]) === 1114111)) { + i.Op = 9; + } else if ((r.$length === 4) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === 0) && ((1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1]) === 9) && ((2 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 2]) === 11) && ((3 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 3]) === 1114111)) { + i.Op = 10; + } + return f; + }; + compiler.prototype.rune = function(r, flags) { return this.$val.rune(r, flags); }; + Op.prototype.String = function() { + var i, x; + i = this.$val; + if (1 <= i && i <= 19) { + i = i - (1) << 24 >>> 24; + return $substring("NoMatchEmptyMatchLiteralCharClassAnyCharNotNLAnyCharBeginLineEndLineBeginTextEndTextWordBoundaryNoWordBoundaryCaptureStarPlusQuestRepeatConcatAlternate", ((i < 0 || i >= _Op_index_0.length) ? ($throwRuntimeError("index out of range"), undefined) : _Op_index_0[i]), (x = i + 1 << 24 >>> 24, ((x < 0 || x >= _Op_index_0.length) ? ($throwRuntimeError("index out of range"), undefined) : _Op_index_0[x]))); + } else if ((i === 128)) { + return "opPseudo"; + } else { + return "Op(" + strconv.FormatInt((new $Int64(0, i)), 10) + ")"; + } + }; + $ptrType(Op).prototype.String = function() { return new Op(this.$get()).String(); }; + Error.ptr.prototype.Error = function() { + var e; + e = this; + return "error parsing regexp: " + new ErrorCode(e.Code).String() + ": `" + e.Expr + "`"; + }; + Error.prototype.Error = function() { return this.$val.Error(); }; + ErrorCode.prototype.String = function() { + var e; + e = this.$val; + return (e); + }; + $ptrType(ErrorCode).prototype.String = function() { return new ErrorCode(this.$get()).String(); }; + parser.ptr.prototype.newRegexp = function(op) { + var op, p, re; + p = this; + re = p.free; + if (!(re === ptrType$1.nil)) { + p.free = re.Sub0[0]; + Regexp.copy(re, new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, "")); + } else { + re = new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + } + re.Op = op; + return re; + }; + parser.prototype.newRegexp = function(op) { return this.$val.newRegexp(op); }; + parser.ptr.prototype.reuse = function(re) { + var p, re; + p = this; + re.Sub0[0] = p.free; + p.free = re; + }; + parser.prototype.reuse = function(re) { return this.$val.reuse(re); }; + parser.ptr.prototype.push = function(re) { + var p, re, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + p = this; + if ((re.Op === 4) && (re.Rune.$length === 2) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === (x$1 = re.Rune, (1 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 1])))) { + if (p.maybeConcat((x$16 = re.Rune, (0 >= x$16.$length ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + 0])), (p.flags & ~1) << 16 >>> 16)) { + return ptrType$1.nil; + } + re.Op = 3; + re.Rune = $subslice(re.Rune, 0, 1); + re.Flags = (p.flags & ~1) << 16 >>> 16; + } else if ((re.Op === 4) && (re.Rune.$length === 4) && ((x$2 = re.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) === (x$3 = re.Rune, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1]))) && ((x$4 = re.Rune, (2 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 2])) === (x$5 = re.Rune, (3 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 3]))) && (unicode.SimpleFold((x$6 = re.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))) === (x$7 = re.Rune, (2 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 2]))) && (unicode.SimpleFold((x$8 = re.Rune, (2 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 2]))) === (x$9 = re.Rune, (0 >= x$9.$length ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + 0]))) || (re.Op === 4) && (re.Rune.$length === 2) && (((x$10 = re.Rune, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0])) + 1 >> 0) === (x$11 = re.Rune, (1 >= x$11.$length ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + 1]))) && (unicode.SimpleFold((x$12 = re.Rune, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0]))) === (x$13 = re.Rune, (1 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 1]))) && (unicode.SimpleFold((x$14 = re.Rune, (1 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 1]))) === (x$15 = re.Rune, (0 >= x$15.$length ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + 0])))) { + if (p.maybeConcat((x$17 = re.Rune, (0 >= x$17.$length ? ($throwRuntimeError("index out of range"), undefined) : x$17.$array[x$17.$offset + 0])), (p.flags | 1) >>> 0)) { + return ptrType$1.nil; + } + re.Op = 3; + re.Rune = $subslice(re.Rune, 0, 1); + re.Flags = (p.flags | 1) >>> 0; + } else { + p.maybeConcat(-1, 0); + } + p.stack = $append(p.stack, re); + return re; + }; + parser.prototype.push = function(re) { return this.$val.push(re); }; + parser.ptr.prototype.maybeConcat = function(r, flags) { + var flags, n, p, r, re1, re2, x, x$1, x$2, x$3, x$4; + p = this; + n = p.stack.$length; + if (n < 2) { + return false; + } + re1 = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + re2 = (x$2 = p.stack, x$3 = n - 2 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])); + if (!((re1.Op === 3)) || !((re2.Op === 3)) || !((((re1.Flags & 1) >>> 0) === ((re2.Flags & 1) >>> 0)))) { + return false; + } + re2.Rune = $appendSlice(re2.Rune, re1.Rune); + if (r >= 0) { + re1.Rune = $subslice(new sliceType(re1.Rune0), 0, 1); + (x$4 = re1.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0] = r)); + re1.Flags = flags; + return true; + } + p.stack = $subslice(p.stack, 0, (n - 1 >> 0)); + p.reuse(re1); + return false; + }; + parser.prototype.maybeConcat = function(r, flags) { return this.$val.maybeConcat(r, flags); }; + parser.ptr.prototype.newLiteral = function(r, flags) { + var flags, p, r, re; + p = this; + re = p.newRegexp(3); + re.Flags = flags; + if (!((((flags & 1) >>> 0) === 0))) { + r = minFoldRune(r); + } + re.Rune0[0] = r; + re.Rune = $subslice(new sliceType(re.Rune0), 0, 1); + return re; + }; + parser.prototype.newLiteral = function(r, flags) { return this.$val.newLiteral(r, flags); }; + minFoldRune = function(r) { + var min, r, r0; + if (r < 65 || r > 125251) { + return r; + } + min = r; + r0 = r; + r = unicode.SimpleFold(r); + while (true) { + if (!(!((r === r0)))) { break; } + if (min > r) { + min = r; + } + r = unicode.SimpleFold(r); + } + return min; + }; + parser.ptr.prototype.literal = function(r) { + var p, r; + p = this; + p.push(p.newLiteral(r, p.flags)); + }; + parser.prototype.literal = function(r) { return this.$val.literal(r); }; + parser.ptr.prototype.op = function(op) { + var op, p, re; + p = this; + re = p.newRegexp(op); + re.Flags = p.flags; + return p.push(re); + }; + parser.prototype.op = function(op) { return this.$val.op(op); }; + parser.ptr.prototype.repeat = function(op, min, max, before, after, lastRepeat) { + var after, before, flags, lastRepeat, max, min, n, op, p, re, sub, x, x$1, x$2, x$3, x$4; + p = this; + flags = p.flags; + if (!((((p.flags & 64) >>> 0) === 0))) { + if (after.length > 0 && (after.charCodeAt(0) === 63)) { + after = $substring(after, 1); + flags = (flags ^ (32)) << 16 >>> 16; + } + if (!(lastRepeat === "")) { + return ["", new Error.ptr("invalid nested repetition operator", $substring(lastRepeat, 0, (lastRepeat.length - after.length >> 0)))]; + } + } + n = p.stack.$length; + if (n === 0) { + return ["", new Error.ptr("missing argument to repetition operator", $substring(before, 0, (before.length - after.length >> 0)))]; + } + sub = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (sub.Op >= 128) { + return ["", new Error.ptr("missing argument to repetition operator", $substring(before, 0, (before.length - after.length >> 0)))]; + } + re = p.newRegexp(op); + re.Min = min; + re.Max = max; + re.Flags = flags; + re.Sub = $subslice(new sliceType$5(re.Sub0), 0, 1); + (x$2 = re.Sub, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0] = sub)); + (x$3 = p.stack, x$4 = n - 1 >> 0, ((x$4 < 0 || x$4 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + x$4] = re)); + if ((op === 17) && (min >= 2 || max >= 2) && !repeatIsValid(re, 1000)) { + return ["", new Error.ptr("invalid repeat count", $substring(before, 0, (before.length - after.length >> 0)))]; + } + return [after, $ifaceNil]; + }; + parser.prototype.repeat = function(op, min, max, before, after, lastRepeat) { return this.$val.repeat(op, min, max, before, after, lastRepeat); }; + repeatIsValid = function(re, n) { + var _i, _q, _ref, m, n, re, sub; + if (re.Op === 17) { + m = re.Max; + if (m === 0) { + return true; + } + if (m < 0) { + m = re.Min; + } + if (m > n) { + return false; + } + if (m > 0) { + n = (_q = n / (m), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + } + } + _ref = re.Sub; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!repeatIsValid(sub, n)) { + return false; + } + _i++; + } + return true; + }; + parser.ptr.prototype.concat = function() { + var _r, _r$1, i, p, subs, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; p = $f.p; subs = $f.subs; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.maybeConcat(-1, 0); + i = p.stack.$length; + while (true) { + if (!(i > 0 && (x = p.stack, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op < 128)) { break; } + i = i - (1) >> 0; + } + subs = $subslice(p.stack, i); + p.stack = $subslice(p.stack, 0, i); + if (subs.$length === 0) { + $s = -1; return p.push(p.newRegexp(2)); + } + _r = p.collapse(subs, 18); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = p.push(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.concat }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.p = p; $f.subs = subs; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.concat = function() { return this.$val.concat(); }; + parser.ptr.prototype.alternate = function() { + var _r, _r$1, i, p, subs, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; p = $f.p; subs = $f.subs; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + i = p.stack.$length; + while (true) { + if (!(i > 0 && (x = p.stack, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op < 128)) { break; } + i = i - (1) >> 0; + } + subs = $subslice(p.stack, i); + p.stack = $subslice(p.stack, 0, i); + /* */ if (subs.$length > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (subs.$length > 0) { */ case 1: + $r = cleanAlt((x$2 = subs.$length - 1 >> 0, ((x$2 < 0 || x$2 >= subs.$length) ? ($throwRuntimeError("index out of range"), undefined) : subs.$array[subs.$offset + x$2]))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (subs.$length === 0) { + $s = -1; return p.push(p.newRegexp(1)); + } + _r = p.collapse(subs, 19); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = p.push(_r); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.alternate }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.p = p; $f.subs = subs; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.alternate = function() { return this.$val.alternate(); }; + cleanAlt = function(re) { + var _1, _r, re, x, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; re = $f.re; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _1 = re.Op; + /* */ if (_1 === (4)) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (_1 === (4)) { */ case 2: + _r = cleanClass((re.$ptr_Rune || (re.$ptr_Rune = new ptrType$2(function() { return this.$target.Rune; }, function($v) { this.$target.Rune = $v; }, re)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + re.Rune = _r; + if ((re.Rune.$length === 2) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === 0) && ((x$1 = re.Rune, (1 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 1])) === 1114111)) { + re.Rune = sliceType.nil; + re.Op = 6; + $s = -1; return; + } + if ((re.Rune.$length === 4) && ((x$2 = re.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) === 0) && ((x$3 = re.Rune, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1])) === 9) && ((x$4 = re.Rune, (2 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 2])) === 11) && ((x$5 = re.Rune, (3 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 3])) === 1114111)) { + re.Rune = sliceType.nil; + re.Op = 5; + $s = -1; return; + } + if ((re.Rune.$capacity - re.Rune.$length >> 0) > 100) { + re.Rune = $appendSlice($subslice(new sliceType(re.Rune0), 0, 0), re.Rune); + } + /* } */ case 3: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: cleanAlt }; } $f._1 = _1; $f._r = _r; $f.re = re; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.ptr.prototype.collapse = function(subs, op) { + var _i, _r, _ref, old, op, p, re, sub, subs, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; old = $f.old; op = $f.op; p = $f.p; re = $f.re; sub = $f.sub; subs = $f.subs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + if (subs.$length === 1) { + $s = -1; return (0 >= subs.$length ? ($throwRuntimeError("index out of range"), undefined) : subs.$array[subs.$offset + 0]); + } + re = p.newRegexp(op); + re.Sub = $subslice(new sliceType$5(re.Sub0), 0, 0); + _ref = subs; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (sub.Op === op) { + re.Sub = $appendSlice(re.Sub, sub.Sub); + p.reuse(sub); + } else { + re.Sub = $append(re.Sub, sub); + } + _i++; + } + /* */ if (op === 19) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (op === 19) { */ case 1: + _r = p.factor(re.Sub); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + re.Sub = _r; + if (re.Sub.$length === 1) { + old = re; + re = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + p.reuse(old); + } + /* } */ case 2: + $s = -1; return re; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.collapse }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.old = old; $f.op = op; $f.p = p; $f.re = re; $f.sub = sub; $f.subs = subs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.collapse = function(subs, op) { return this.$val.collapse(subs, op); }; + parser.ptr.prototype.factor = function(sub) { + var _i, _r, _r$1, _ref, _tmp, _tmp$1, _tuple, first, i, i$1, i$2, i$3, ifirst, iflags, istr, j, j$1, j$2, j$3, max, out, p, prefix, prefix$1, re, re$1, reuse, same, start, str, strflags, sub, suffix, suffix$1, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; first = $f.first; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; ifirst = $f.ifirst; iflags = $f.iflags; istr = $f.istr; j = $f.j; j$1 = $f.j$1; j$2 = $f.j$2; j$3 = $f.j$3; max = $f.max; out = $f.out; p = $f.p; prefix = $f.prefix; prefix$1 = $f.prefix$1; re = $f.re; re$1 = $f.re$1; reuse = $f.reuse; same = $f.same; start = $f.start; str = $f.str; strflags = $f.strflags; sub = $f.sub; suffix = $f.suffix; suffix$1 = $f.suffix$1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + if (sub.$length < 2) { + $s = -1; return sub; + } + str = sliceType.nil; + strflags = 0; + start = 0; + out = $subslice(sub, 0, 0); + i = 0; + /* while (true) { */ case 1: + /* if (!(i <= sub.$length)) { break; } */ if(!(i <= sub.$length)) { $s = 2; continue; } + istr = sliceType.nil; + iflags = 0; + /* */ if (i < sub.$length) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (i < sub.$length) { */ case 3: + _tuple = p.leadingString(((i < 0 || i >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i])); + istr = _tuple[0]; + iflags = _tuple[1]; + if (iflags === strflags) { + same = 0; + while (true) { + if (!(same < str.$length && same < istr.$length && (((same < 0 || same >= str.$length) ? ($throwRuntimeError("index out of range"), undefined) : str.$array[str.$offset + same]) === ((same < 0 || same >= istr.$length) ? ($throwRuntimeError("index out of range"), undefined) : istr.$array[istr.$offset + same])))) { break; } + same = same + (1) >> 0; + } + if (same > 0) { + str = $subslice(str, 0, same); + i = i + (1) >> 0; + /* continue; */ $s = 1; continue; + } + } + /* } */ case 4: + /* */ if (i === start) { $s = 5; continue; } + /* */ if (i === (start + 1 >> 0)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (i === start) { */ case 5: + $s = 8; continue; + /* } else if (i === (start + 1 >> 0)) { */ case 6: + out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); + $s = 8; continue; + /* } else { */ case 7: + prefix = p.newRegexp(3); + prefix.Flags = strflags; + prefix.Rune = $appendSlice($subslice(prefix.Rune, 0, 0), str); + j = start; + while (true) { + if (!(j < i)) { break; } + ((j < 0 || j >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j] = p.removeLeadingString(((j < 0 || j >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j]), str.$length)); + j = j + (1) >> 0; + } + _r = p.collapse($subslice(sub, start, i), 19); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + suffix = _r; + re = p.newRegexp(18); + re.Sub = $append($subslice(re.Sub, 0, 0), prefix, suffix); + out = $append(out, re); + /* } */ case 8: + start = i; + str = istr; + strflags = iflags; + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + sub = out; + start = 0; + out = $subslice(sub, 0, 0); + first = ptrType$1.nil; + i$1 = 0; + /* while (true) { */ case 10: + /* if (!(i$1 <= sub.$length)) { break; } */ if(!(i$1 <= sub.$length)) { $s = 11; continue; } + ifirst = ptrType$1.nil; + /* */ if (i$1 < sub.$length) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (i$1 < sub.$length) { */ case 12: + ifirst = p.leadingRegexp(((i$1 < 0 || i$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$1])); + if (!(first === ptrType$1.nil) && first.Equal(ifirst) && (isCharClass(first) || ((first.Op === 17) && (first.Min === first.Max) && isCharClass((x = first.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])))))) { + i$1 = i$1 + (1) >> 0; + /* continue; */ $s = 10; continue; + } + /* } */ case 13: + /* */ if (i$1 === start) { $s = 14; continue; } + /* */ if (i$1 === (start + 1 >> 0)) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (i$1 === start) { */ case 14: + $s = 17; continue; + /* } else if (i$1 === (start + 1 >> 0)) { */ case 15: + out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); + $s = 17; continue; + /* } else { */ case 16: + prefix$1 = first; + j$1 = start; + while (true) { + if (!(j$1 < i$1)) { break; } + reuse = !((j$1 === start)); + ((j$1 < 0 || j$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$1] = p.removeLeadingRegexp(((j$1 < 0 || j$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$1]), reuse)); + j$1 = j$1 + (1) >> 0; + } + _r$1 = p.collapse($subslice(sub, start, i$1), 19); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + suffix$1 = _r$1; + re$1 = p.newRegexp(18); + re$1.Sub = $append($subslice(re$1.Sub, 0, 0), prefix$1, suffix$1); + out = $append(out, re$1); + /* } */ case 17: + start = i$1; + first = ifirst; + i$1 = i$1 + (1) >> 0; + /* } */ $s = 10; continue; case 11: + sub = out; + start = 0; + out = $subslice(sub, 0, 0); + i$2 = 0; + /* while (true) { */ case 19: + /* if (!(i$2 <= sub.$length)) { break; } */ if(!(i$2 <= sub.$length)) { $s = 20; continue; } + /* */ if (i$2 < sub.$length && isCharClass(((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2]))) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (i$2 < sub.$length && isCharClass(((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2]))) { */ case 21: + i$2 = i$2 + (1) >> 0; + /* continue; */ $s = 19; continue; + /* } */ case 22: + /* */ if (i$2 === start) { $s = 23; continue; } + /* */ if (i$2 === (start + 1 >> 0)) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (i$2 === start) { */ case 23: + $s = 26; continue; + /* } else if (i$2 === (start + 1 >> 0)) { */ case 24: + out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); + $s = 26; continue; + /* } else { */ case 25: + max = start; + j$2 = start + 1 >> 0; + while (true) { + if (!(j$2 < i$2)) { break; } + if (((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Op < ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Op || (((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Op === ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Op) && ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Rune.$length < ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Rune.$length) { + max = j$2; + } + j$2 = j$2 + (1) >> 0; + } + _tmp = ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]); + _tmp$1 = ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start]); + ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start] = _tmp); + ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max] = _tmp$1); + j$3 = start + 1 >> 0; + while (true) { + if (!(j$3 < i$2)) { break; } + mergeCharClass(((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start]), ((j$3 < 0 || j$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$3])); + p.reuse(((j$3 < 0 || j$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$3])); + j$3 = j$3 + (1) >> 0; + } + $r = cleanAlt(((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); + /* } */ case 26: + if (i$2 < sub.$length) { + out = $append(out, ((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2])); + } + start = i$2 + 1 >> 0; + i$2 = i$2 + (1) >> 0; + /* } */ $s = 19; continue; case 20: + sub = out; + start = 0; + out = $subslice(sub, 0, 0); + _ref = sub; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i$3 = _i; + if ((i$3 + 1 >> 0) < sub.$length && (((i$3 < 0 || i$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$3]).Op === 2) && ((x$1 = i$3 + 1 >> 0, ((x$1 < 0 || x$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + x$1])).Op === 2)) { + _i++; + continue; + } + out = $append(out, ((i$3 < 0 || i$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$3])); + _i++; + } + sub = out; + $s = -1; return sub; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.factor }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.first = first; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.ifirst = ifirst; $f.iflags = iflags; $f.istr = istr; $f.j = j; $f.j$1 = j$1; $f.j$2 = j$2; $f.j$3 = j$3; $f.max = max; $f.out = out; $f.p = p; $f.prefix = prefix; $f.prefix$1 = prefix$1; $f.re = re; $f.re$1 = re$1; $f.reuse = reuse; $f.same = same; $f.start = start; $f.str = str; $f.strflags = strflags; $f.sub = sub; $f.suffix = suffix; $f.suffix$1 = suffix$1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.factor = function(sub) { return this.$val.factor(sub); }; + parser.ptr.prototype.leadingString = function(re) { + var p, re, x; + p = this; + if ((re.Op === 18) && re.Sub.$length > 0) { + re = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + } + if (!((re.Op === 3))) { + return [sliceType.nil, 0]; + } + return [re.Rune, (re.Flags & 1) >>> 0]; + }; + parser.prototype.leadingString = function(re) { return this.$val.leadingString(re); }; + parser.ptr.prototype.removeLeadingString = function(re, n) { + var _1, n, old, p, re, sub, x, x$1, x$2; + p = this; + if ((re.Op === 18) && re.Sub.$length > 0) { + sub = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + sub = p.removeLeadingString(sub, n); + (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = sub)); + if (sub.Op === 2) { + p.reuse(sub); + _1 = re.Sub.$length; + if ((_1 === (0)) || (_1 === (1))) { + re.Op = 2; + re.Sub = sliceType$5.nil; + } else if (_1 === (2)) { + old = re; + re = (x$2 = re.Sub, (1 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 1])); + p.reuse(old); + } else { + $copySlice(re.Sub, $subslice(re.Sub, 1)); + re.Sub = $subslice(re.Sub, 0, (re.Sub.$length - 1 >> 0)); + } + } + return re; + } + if (re.Op === 3) { + re.Rune = $subslice(re.Rune, 0, $copySlice(re.Rune, $subslice(re.Rune, n))); + if (re.Rune.$length === 0) { + re.Op = 2; + } + } + return re; + }; + parser.prototype.removeLeadingString = function(re, n) { return this.$val.removeLeadingString(re, n); }; + parser.ptr.prototype.leadingRegexp = function(re) { + var p, re, sub, x; + p = this; + if (re.Op === 2) { + return ptrType$1.nil; + } + if ((re.Op === 18) && re.Sub.$length > 0) { + sub = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + if (sub.Op === 2) { + return ptrType$1.nil; + } + return sub; + } + return re; + }; + parser.prototype.leadingRegexp = function(re) { return this.$val.leadingRegexp(re); }; + parser.ptr.prototype.removeLeadingRegexp = function(re, reuse) { + var _1, old, p, re, reuse, x, x$1; + p = this; + if ((re.Op === 18) && re.Sub.$length > 0) { + if (reuse) { + p.reuse((x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))); + } + re.Sub = $subslice(re.Sub, 0, $copySlice(re.Sub, $subslice(re.Sub, 1))); + _1 = re.Sub.$length; + if (_1 === (0)) { + re.Op = 2; + re.Sub = sliceType$5.nil; + } else if (_1 === (1)) { + old = re; + re = (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); + p.reuse(old); + } + return re; + } + if (reuse) { + p.reuse(re); + } + return p.newRegexp(2); + }; + parser.prototype.removeLeadingRegexp = function(re, reuse) { return this.$val.removeLeadingRegexp(re, reuse); }; + literalRegexp = function(s, flags) { + var _i, _ref, _rune, c, flags, re, s; + re = new Regexp.ptr(3, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + re.Flags = flags; + re.Rune = $subslice(new sliceType(re.Rune0), 0, 0); + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + c = _rune[0]; + if (re.Rune.$length >= re.Rune.$capacity) { + re.Rune = (new sliceType($stringToRunes(s))); + break; + } + re.Rune = $append(re.Rune, c); + _i += _rune[1]; + } + return re; + }; + Parse = function(s, flags) { + var _1, _2, _3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _struct, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, after, after$1, before, before$1, c, c$1, err, err$1, err$2, err$3, flags, i, lastRepeat, lit, max, min, n, ok, op, p, r, r$1, re, repeat, rest, rest$1, rest$2, s, t, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _struct = $f._struct; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; after = $f.after; after$1 = $f.after$1; before = $f.before; before$1 = $f.before$1; c = $f.c; c$1 = $f.c$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; flags = $f.flags; i = $f.i; lastRepeat = $f.lastRepeat; lit = $f.lit; max = $f.max; min = $f.min; n = $f.n; ok = $f.ok; op = $f.op; p = $f.p; r = $f.r; r$1 = $f.r$1; re = $f.re; repeat = $f.repeat; rest = $f.rest; rest$1 = $f.rest$1; rest$2 = $f.rest$2; s = $f.s; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (!((((flags & 2) >>> 0) === 0))) { + err = checkUTF8(s); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err]; + } + $s = -1; return [literalRegexp(s, flags), $ifaceNil]; + } + p = new parser.ptr(0, sliceType$5.nil, ptrType$1.nil, 0, "", sliceType.nil); + err$1 = $ifaceNil; + c = 0; + op = 0; + lastRepeat = ""; + p.flags = flags; + p.wholeRegexp = s; + t = s; + /* while (true) { */ case 1: + /* if (!(!(t === ""))) { break; } */ if(!(!(t === ""))) { $s = 2; continue; } + repeat = ""; + _1 = t.charCodeAt(0); + /* */ if (_1 === (40)) { $s = 4; continue; } + /* */ if (_1 === (124)) { $s = 5; continue; } + /* */ if (_1 === (41)) { $s = 6; continue; } + /* */ if (_1 === (94)) { $s = 7; continue; } + /* */ if (_1 === (36)) { $s = 8; continue; } + /* */ if (_1 === (46)) { $s = 9; continue; } + /* */ if (_1 === (91)) { $s = 10; continue; } + /* */ if ((_1 === (42)) || (_1 === (43)) || (_1 === (63))) { $s = 11; continue; } + /* */ if (_1 === (123)) { $s = 12; continue; } + /* */ if (_1 === (92)) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (_1 === (40)) { */ case 4: + if (!((((p.flags & 64) >>> 0) === 0)) && t.length >= 2 && (t.charCodeAt(1) === 63)) { + _tuple = p.parsePerlFlags(t); + t = _tuple[0]; + err$1 = _tuple[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + /* break; */ $s = 3; continue; + } + p.numCap = p.numCap + (1) >> 0; + p.op(128).Cap = p.numCap; + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (124)) { */ case 5: + _r = p.parseVerticalBar(); /* */ $s = 16; case 16: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err$1 = _r; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (41)) { */ case 6: + _r$1 = p.parseRightParen(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err$1 = _r$1; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (94)) { */ case 7: + if (!((((p.flags & 16) >>> 0) === 0))) { + p.op(9); + } else { + p.op(7); + } + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (36)) { */ case 8: + if (!((((p.flags & 16) >>> 0) === 0))) { + _struct = p.op(10); + _struct.Flags = (_struct.Flags | (256)) >>> 0; + } else { + p.op(8); + } + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (46)) { */ case 9: + if (!((((p.flags & 8) >>> 0) === 0))) { + p.op(6); + } else { + p.op(5); + } + t = $substring(t, 1); + $s = 15; continue; + /* } else if (_1 === (91)) { */ case 10: + _r$2 = p.parseClass(t); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + t = _tuple$1[0]; + err$1 = _tuple$1[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + $s = 15; continue; + /* } else if ((_1 === (42)) || (_1 === (43)) || (_1 === (63))) { */ case 11: + before = t; + _2 = t.charCodeAt(0); + if (_2 === (42)) { + op = 14; + } else if (_2 === (43)) { + op = 15; + } else if (_2 === (63)) { + op = 16; + } + after = $substring(t, 1); + _tuple$2 = p.repeat(op, 0, 0, before, after, lastRepeat); + after = _tuple$2[0]; + err$1 = _tuple$2[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + repeat = before; + t = after; + $s = 15; continue; + /* } else if (_1 === (123)) { */ case 12: + op = 17; + before$1 = t; + _tuple$3 = p.parseRepeat(t); + min = _tuple$3[0]; + max = _tuple$3[1]; + after$1 = _tuple$3[2]; + ok = _tuple$3[3]; + if (!ok) { + p.literal(123); + t = $substring(t, 1); + /* break; */ $s = 3; continue; + } + if (min < 0 || min > 1000 || max > 1000 || max >= 0 && min > max) { + $s = -1; return [ptrType$1.nil, new Error.ptr("invalid repeat count", $substring(before$1, 0, (before$1.length - after$1.length >> 0)))]; + } + _tuple$4 = p.repeat(op, min, max, before$1, after$1, lastRepeat); + after$1 = _tuple$4[0]; + err$1 = _tuple$4[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + repeat = before$1; + t = after$1; + $s = 15; continue; + /* } else if (_1 === (92)) { */ case 13: + if (!((((p.flags & 64) >>> 0) === 0)) && t.length >= 2) { + _3 = t.charCodeAt(1); + if (_3 === (65)) { + p.op(9); + t = $substring(t, 2); + /* break BigSwitch; */ $s = 3; continue s; + } else if (_3 === (98)) { + p.op(11); + t = $substring(t, 2); + /* break BigSwitch; */ $s = 3; continue s; + } else if (_3 === (66)) { + p.op(12); + t = $substring(t, 2); + /* break BigSwitch; */ $s = 3; continue s; + } else if (_3 === (67)) { + $s = -1; return [ptrType$1.nil, new Error.ptr("invalid escape sequence", $substring(t, 0, 2))]; + } else if (_3 === (81)) { + lit = ""; + i = strings.Index(t, "\\E"); + if (i < 0) { + lit = $substring(t, 2); + t = ""; + } else { + lit = $substring(t, 2, i); + t = $substring(t, (i + 2 >> 0)); + } + while (true) { + if (!(!(lit === ""))) { break; } + _tuple$5 = nextRune(lit); + c$1 = _tuple$5[0]; + rest = _tuple$5[1]; + err$2 = _tuple$5[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$2]; + } + p.literal(c$1); + lit = rest; + } + /* break BigSwitch; */ $s = 3; continue s; + } else if (_3 === (122)) { + p.op(10); + t = $substring(t, 2); + /* break BigSwitch; */ $s = 3; continue s; + } + } + re = p.newRegexp(4); + re.Flags = p.flags; + /* */ if (t.length >= 2 && ((t.charCodeAt(1) === 112) || (t.charCodeAt(1) === 80))) { $s = 19; continue; } + /* */ $s = 20; continue; + /* if (t.length >= 2 && ((t.charCodeAt(1) === 112) || (t.charCodeAt(1) === 80))) { */ case 19: + _r$3 = p.parseUnicodeClass(t, $subslice(new sliceType(re.Rune0), 0, 0)); /* */ $s = 21; case 21: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$6 = _r$3; + r = _tuple$6[0]; + rest$1 = _tuple$6[1]; + err$3 = _tuple$6[2]; + if (!($interfaceIsEqual(err$3, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$3]; + } + if (!(r === sliceType.nil)) { + re.Rune = r; + t = rest$1; + p.push(re); + /* break BigSwitch; */ $s = 3; continue s; + } + /* } */ case 20: + _r$4 = p.parsePerlClassEscape(t, $subslice(new sliceType(re.Rune0), 0, 0)); /* */ $s = 22; case 22: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$7 = _r$4; + r$1 = _tuple$7[0]; + rest$2 = _tuple$7[1]; + if (!(r$1 === sliceType.nil)) { + re.Rune = r$1; + t = rest$2; + p.push(re); + /* break BigSwitch; */ $s = 3; continue s; + } + p.reuse(re); + _tuple$8 = p.parseEscape(t); + c = _tuple$8[0]; + t = _tuple$8[1]; + err$1 = _tuple$8[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + p.literal(c); + $s = 15; continue; + /* } else { */ case 14: + _tuple$9 = nextRune(t); + c = _tuple$9[0]; + t = _tuple$9[1]; + err$1 = _tuple$9[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [ptrType$1.nil, err$1]; + } + p.literal(c); + /* } */ case 15: + case 3: + lastRepeat = repeat; + /* } */ $s = 1; continue; case 2: + _r$5 = p.concat(); /* */ $s = 23; case 23: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + _r$6 = p.swapVerticalBar(); /* */ $s = 26; case 26: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ if (_r$6) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (_r$6) { */ case 24: + p.stack = $subslice(p.stack, 0, (p.stack.$length - 1 >> 0)); + /* } */ case 25: + _r$7 = p.alternate(); /* */ $s = 27; case 27: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + n = p.stack.$length; + if (!((n === 1))) { + $s = -1; return [ptrType$1.nil, new Error.ptr("missing closing )", s)]; + } + $s = -1; return [(x = p.stack, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])), $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._struct = _struct; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.after = after; $f.after$1 = after$1; $f.before = before; $f.before$1 = before$1; $f.c = c; $f.c$1 = c$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.flags = flags; $f.i = i; $f.lastRepeat = lastRepeat; $f.lit = lit; $f.max = max; $f.min = min; $f.n = n; $f.ok = ok; $f.op = op; $f.p = p; $f.r = r; $f.r$1 = r$1; $f.re = re; $f.repeat = repeat; $f.rest = rest; $f.rest$1 = rest$1; $f.rest$2 = rest$2; $f.s = s; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Parse = Parse; + parser.ptr.prototype.parseRepeat = function(s) { + var _tuple, _tuple$1, max, min, ok, ok1, p, rest, s; + min = 0; + max = 0; + rest = ""; + ok = false; + p = this; + if (s === "" || !((s.charCodeAt(0) === 123))) { + return [min, max, rest, ok]; + } + s = $substring(s, 1); + ok1 = false; + _tuple = p.parseInt(s); + min = _tuple[0]; + s = _tuple[1]; + ok1 = _tuple[2]; + if (!ok1) { + return [min, max, rest, ok]; + } + if (s === "") { + return [min, max, rest, ok]; + } + if (!((s.charCodeAt(0) === 44))) { + max = min; + } else { + s = $substring(s, 1); + if (s === "") { + return [min, max, rest, ok]; + } + if (s.charCodeAt(0) === 125) { + max = -1; + } else { + _tuple$1 = p.parseInt(s); + max = _tuple$1[0]; + s = _tuple$1[1]; + ok1 = _tuple$1[2]; + if (!ok1) { + return [min, max, rest, ok]; + } else if (max < 0) { + min = -1; + } + } + } + if (s === "" || !((s.charCodeAt(0) === 125))) { + return [min, max, rest, ok]; + } + rest = $substring(s, 1); + ok = true; + return [min, max, rest, ok]; + }; + parser.prototype.parseRepeat = function(s) { return this.$val.parseRepeat(s); }; + parser.ptr.prototype.parsePerlFlags = function(s) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, c, capture, end, err, flags, name, p, re, rest, s, sawFlag, sign, t; + rest = ""; + err = $ifaceNil; + p = this; + t = s; + if (t.length > 4 && (t.charCodeAt(2) === 80) && (t.charCodeAt(3) === 60)) { + end = strings.IndexRune(t, 62); + if (end < 0) { + err = checkUTF8(t); + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp = ""; + _tmp$1 = err; + rest = _tmp; + err = _tmp$1; + return [rest, err]; + } + _tmp$2 = ""; + _tmp$3 = new Error.ptr("invalid named capture", s); + rest = _tmp$2; + err = _tmp$3; + return [rest, err]; + } + capture = $substring(t, 0, (end + 1 >> 0)); + name = $substring(t, 4, end); + err = checkUTF8(name); + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$4 = ""; + _tmp$5 = err; + rest = _tmp$4; + err = _tmp$5; + return [rest, err]; + } + if (!isValidCaptureName(name)) { + _tmp$6 = ""; + _tmp$7 = new Error.ptr("invalid named capture", capture); + rest = _tmp$6; + err = _tmp$7; + return [rest, err]; + } + p.numCap = p.numCap + (1) >> 0; + re = p.op(128); + re.Cap = p.numCap; + re.Name = name; + _tmp$8 = $substring(t, (end + 1 >> 0)); + _tmp$9 = $ifaceNil; + rest = _tmp$8; + err = _tmp$9; + return [rest, err]; + } + c = 0; + t = $substring(t, 2); + flags = p.flags; + sign = 1; + sawFlag = false; + Loop: + while (true) { + if (!(!(t === ""))) { break; } + _tuple = nextRune(t); + c = _tuple[0]; + t = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$10 = ""; + _tmp$11 = err; + rest = _tmp$10; + err = _tmp$11; + return [rest, err]; + } + _1 = c; + if (_1 === (105)) { + flags = (flags | (1)) >>> 0; + sawFlag = true; + } else if (_1 === (109)) { + flags = (flags & ~(16)) << 16 >>> 16; + sawFlag = true; + } else if (_1 === (115)) { + flags = (flags | (8)) >>> 0; + sawFlag = true; + } else if (_1 === (85)) { + flags = (flags | (32)) >>> 0; + sawFlag = true; + } else if (_1 === (45)) { + if (sign < 0) { + break Loop; + } + sign = -1; + flags = ~flags << 16 >>> 16; + sawFlag = false; + } else if ((_1 === (58)) || (_1 === (41))) { + if (sign < 0) { + if (!sawFlag) { + break Loop; + } + flags = ~flags << 16 >>> 16; + } + if (c === 58) { + p.op(128); + } + p.flags = flags; + _tmp$12 = t; + _tmp$13 = $ifaceNil; + rest = _tmp$12; + err = _tmp$13; + return [rest, err]; + } else { + break Loop; + } + } + _tmp$14 = ""; + _tmp$15 = new Error.ptr("invalid or unsupported Perl syntax", $substring(s, 0, (s.length - t.length >> 0))); + rest = _tmp$14; + err = _tmp$15; + return [rest, err]; + }; + parser.prototype.parsePerlFlags = function(s) { return this.$val.parsePerlFlags(s); }; + isValidCaptureName = function(name) { + var _i, _ref, _rune, c, name; + if (name === "") { + return false; + } + _ref = name; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + c = _rune[0]; + if (!((c === 95)) && !isalnum(c)) { + return false; + } + _i += _rune[1]; + } + return true; + }; + parser.ptr.prototype.parseInt = function(s) { + var i, n, ok, p, rest, s, t; + n = 0; + rest = ""; + ok = false; + p = this; + if (s === "" || s.charCodeAt(0) < 48 || 57 < s.charCodeAt(0)) { + return [n, rest, ok]; + } + if (s.length >= 2 && (s.charCodeAt(0) === 48) && 48 <= s.charCodeAt(1) && s.charCodeAt(1) <= 57) { + return [n, rest, ok]; + } + t = s; + while (true) { + if (!(!(s === "") && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = $substring(s, 1); + } + rest = s; + ok = true; + t = $substring(t, 0, (t.length - s.length >> 0)); + i = 0; + while (true) { + if (!(i < t.length)) { break; } + if (n >= 100000000) { + n = -1; + break; + } + n = (($imul(n, 10)) + ((t.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; + i = i + (1) >> 0; + } + return [n, rest, ok]; + }; + parser.prototype.parseInt = function(s) { return this.$val.parseInt(s); }; + isCharClass = function(re) { + var re; + return (re.Op === 3) && (re.Rune.$length === 1) || (re.Op === 4) || (re.Op === 5) || (re.Op === 6); + }; + matchRune = function(re, r) { + var _1, i, r, re, x, x$1, x$2, x$3; + _1 = re.Op; + if (_1 === (3)) { + return (re.Rune.$length === 1) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === r); + } else if (_1 === (4)) { + i = 0; + while (true) { + if (!(i < re.Rune.$length)) { break; } + if ((x$1 = re.Rune, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])) <= r && r <= (x$2 = re.Rune, x$3 = i + 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3]))) { + return true; + } + i = i + (2) >> 0; + } + return false; + } else if (_1 === (5)) { + return !((r === 10)); + } else if (_1 === (6)) { + return true; + } + return false; + }; + parser.ptr.prototype.parseVerticalBar = function() { + var _r, _r$1, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _r = p.concat(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + _r$1 = p.swapVerticalBar(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!_r$1) { */ case 2: + p.op(129); + /* } */ case 3: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseVerticalBar }; } $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parseVerticalBar = function() { return this.$val.parseVerticalBar(); }; + mergeCharClass = function(dst, src) { + var _1, dst, src, x, x$1, x$2, x$3, x$4; + switch (0) { default: + _1 = dst.Op; + if (_1 === (6)) { + } else if (_1 === (5)) { + if (matchRune(src, 10)) { + dst.Op = 6; + } + } else if (_1 === (4)) { + if (src.Op === 3) { + dst.Rune = appendLiteral(dst.Rune, (x = src.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])), src.Flags); + } else { + dst.Rune = appendClass(dst.Rune, src.Rune); + } + } else if (_1 === (3)) { + if (((x$1 = src.Rune, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) === (x$2 = dst.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))) && (src.Flags === dst.Flags)) { + break; + } + dst.Op = 4; + dst.Rune = appendLiteral($subslice(dst.Rune, 0, 0), (x$3 = dst.Rune, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])), dst.Flags); + dst.Rune = appendLiteral(dst.Rune, (x$4 = src.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])), src.Flags); + } + } + }; + parser.ptr.prototype.swapVerticalBar = function() { + var _tmp, _tmp$1, n, p, re1, re1$1, re2, re3, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; n = $f.n; p = $f.p; re1 = $f.re1; re1$1 = $f.re1$1; re2 = $f.re2; re3 = $f.re3; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$17 = $f.x$17; x$18 = $f.x$18; x$19 = $f.x$19; x$2 = $f.x$2; x$20 = $f.x$20; x$21 = $f.x$21; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + n = p.stack.$length; + if (n >= 3 && ((x = p.stack, x$1 = n - 2 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op === 129) && isCharClass((x$2 = p.stack, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3]))) && isCharClass((x$4 = p.stack, x$5 = n - 3 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])))) { + re1 = (x$6 = p.stack, x$7 = n - 1 >> 0, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])); + re3 = (x$8 = p.stack, x$9 = n - 3 >> 0, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])); + if (re1.Op > re3.Op) { + _tmp = re3; + _tmp$1 = re1; + re1 = _tmp; + re3 = _tmp$1; + (x$10 = p.stack, x$11 = n - 3 >> 0, ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11] = re3)); + } + mergeCharClass(re3, re1); + p.reuse(re1); + p.stack = $subslice(p.stack, 0, (n - 1 >> 0)); + $s = -1; return true; + } + /* */ if (n >= 2) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (n >= 2) { */ case 1: + re1$1 = (x$12 = p.stack, x$13 = n - 1 >> 0, ((x$13 < 0 || x$13 >= x$12.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + x$13])); + re2 = (x$14 = p.stack, x$15 = n - 2 >> 0, ((x$15 < 0 || x$15 >= x$14.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + x$15])); + /* */ if (re2.Op === 129) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (re2.Op === 129) { */ case 3: + /* */ if (n >= 3) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (n >= 3) { */ case 5: + $r = cleanAlt((x$16 = p.stack, x$17 = n - 3 >> 0, ((x$17 < 0 || x$17 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + x$17]))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + (x$18 = p.stack, x$19 = n - 2 >> 0, ((x$19 < 0 || x$19 >= x$18.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$18.$array[x$18.$offset + x$19] = re1$1)); + (x$20 = p.stack, x$21 = n - 1 >> 0, ((x$21 < 0 || x$21 >= x$20.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$20.$array[x$20.$offset + x$21] = re2)); + $s = -1; return true; + /* } */ case 4: + /* } */ case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.swapVerticalBar }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.n = n; $f.p = p; $f.re1 = re1; $f.re1$1 = re1$1; $f.re2 = re2; $f.re3 = re3; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$17 = x$17; $f.x$18 = x$18; $f.x$19 = x$19; $f.x$2 = x$2; $f.x$20 = x$20; $f.x$21 = x$21; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.swapVerticalBar = function() { return this.$val.swapVerticalBar(); }; + parser.ptr.prototype.parseRightParen = function() { + var _r, _r$1, _r$2, n, p, re1, re2, x, x$1, x$2, x$3, x$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; n = $f.n; p = $f.p; re1 = $f.re1; re2 = $f.re2; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _r = p.concat(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + _r$1 = p.swapVerticalBar(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (_r$1) { */ case 2: + p.stack = $subslice(p.stack, 0, (p.stack.$length - 1 >> 0)); + /* } */ case 3: + _r$2 = p.alternate(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + n = p.stack.$length; + if (n < 2) { + $s = -1; return new Error.ptr("unexpected )", p.wholeRegexp); + } + re1 = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + re2 = (x$2 = p.stack, x$3 = n - 2 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])); + p.stack = $subslice(p.stack, 0, (n - 2 >> 0)); + if (!((re2.Op === 128))) { + $s = -1; return new Error.ptr("unexpected )", p.wholeRegexp); + } + p.flags = re2.Flags; + if (re2.Cap === 0) { + p.push(re1); + } else { + re2.Op = 13; + re2.Sub = $subslice(new sliceType$5(re2.Sub0), 0, 1); + (x$4 = re2.Sub, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0] = re1)); + p.push(re2); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseRightParen }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.n = n; $f.p = p; $f.re1 = re1; $f.re2 = re2; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parseRightParen = function() { return this.$val.parseRightParen(); }; + parser.ptr.prototype.parseEscape = function(s) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, c, err, i, nhex, p, r, rest, s, t, v, x, y; + r = 0; + rest = ""; + err = $ifaceNil; + p = this; + t = $substring(s, 1); + if (t === "") { + _tmp = 0; + _tmp$1 = ""; + _tmp$2 = new Error.ptr("trailing backslash at end of expression", ""); + r = _tmp; + rest = _tmp$1; + err = _tmp$2; + return [r, rest, err]; + } + _tuple = nextRune(t); + c = _tuple[0]; + t = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$3 = 0; + _tmp$4 = ""; + _tmp$5 = err; + r = _tmp$3; + rest = _tmp$4; + err = _tmp$5; + return [r, rest, err]; + } + Switch: + switch (0) { default: + _1 = c; + if ((_1 === (49)) || (_1 === (50)) || (_1 === (51)) || (_1 === (52)) || (_1 === (53)) || (_1 === (54)) || (_1 === (55))) { + if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { + break; + } + r = c - 48 >> 0; + i = 1; + while (true) { + if (!(i < 3)) { break; } + if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { + break; + } + r = (($imul(r, 8)) + ((t.charCodeAt(0) >> 0)) >> 0) - 48 >> 0; + t = $substring(t, 1); + i = i + (1) >> 0; + } + _tmp$6 = r; + _tmp$7 = t; + _tmp$8 = $ifaceNil; + r = _tmp$6; + rest = _tmp$7; + err = _tmp$8; + return [r, rest, err]; + } else if (_1 === (48)) { + r = c - 48 >> 0; + i = 1; + while (true) { + if (!(i < 3)) { break; } + if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { + break; + } + r = (($imul(r, 8)) + ((t.charCodeAt(0) >> 0)) >> 0) - 48 >> 0; + t = $substring(t, 1); + i = i + (1) >> 0; + } + _tmp$9 = r; + _tmp$10 = t; + _tmp$11 = $ifaceNil; + r = _tmp$9; + rest = _tmp$10; + err = _tmp$11; + return [r, rest, err]; + } else if (_1 === (120)) { + if (t === "") { + break; + } + _tuple$1 = nextRune(t); + c = _tuple$1[0]; + t = _tuple$1[1]; + err = _tuple$1[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$12 = 0; + _tmp$13 = ""; + _tmp$14 = err; + r = _tmp$12; + rest = _tmp$13; + err = _tmp$14; + return [r, rest, err]; + } + if (c === 123) { + nhex = 0; + r = 0; + while (true) { + if (t === "") { + break Switch; + } + _tuple$2 = nextRune(t); + c = _tuple$2[0]; + t = _tuple$2[1]; + err = _tuple$2[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$15 = 0; + _tmp$16 = ""; + _tmp$17 = err; + r = _tmp$15; + rest = _tmp$16; + err = _tmp$17; + return [r, rest, err]; + } + if (c === 125) { + break; + } + v = unhex(c); + if (v < 0) { + break Switch; + } + r = ($imul(r, 16)) + v >> 0; + if (r > 1114111) { + break Switch; + } + nhex = nhex + (1) >> 0; + } + if (nhex === 0) { + break Switch; + } + _tmp$18 = r; + _tmp$19 = t; + _tmp$20 = $ifaceNil; + r = _tmp$18; + rest = _tmp$19; + err = _tmp$20; + return [r, rest, err]; + } + x = unhex(c); + _tuple$3 = nextRune(t); + c = _tuple$3[0]; + t = _tuple$3[1]; + err = _tuple$3[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$21 = 0; + _tmp$22 = ""; + _tmp$23 = err; + r = _tmp$21; + rest = _tmp$22; + err = _tmp$23; + return [r, rest, err]; + } + y = unhex(c); + if (x < 0 || y < 0) { + break; + } + _tmp$24 = ($imul(x, 16)) + y >> 0; + _tmp$25 = t; + _tmp$26 = $ifaceNil; + r = _tmp$24; + rest = _tmp$25; + err = _tmp$26; + return [r, rest, err]; + } else if (_1 === (97)) { + _tmp$27 = 7; + _tmp$28 = t; + _tmp$29 = err; + r = _tmp$27; + rest = _tmp$28; + err = _tmp$29; + return [r, rest, err]; + } else if (_1 === (102)) { + _tmp$30 = 12; + _tmp$31 = t; + _tmp$32 = err; + r = _tmp$30; + rest = _tmp$31; + err = _tmp$32; + return [r, rest, err]; + } else if (_1 === (110)) { + _tmp$33 = 10; + _tmp$34 = t; + _tmp$35 = err; + r = _tmp$33; + rest = _tmp$34; + err = _tmp$35; + return [r, rest, err]; + } else if (_1 === (114)) { + _tmp$36 = 13; + _tmp$37 = t; + _tmp$38 = err; + r = _tmp$36; + rest = _tmp$37; + err = _tmp$38; + return [r, rest, err]; + } else if (_1 === (116)) { + _tmp$39 = 9; + _tmp$40 = t; + _tmp$41 = err; + r = _tmp$39; + rest = _tmp$40; + err = _tmp$41; + return [r, rest, err]; + } else if (_1 === (118)) { + _tmp$42 = 11; + _tmp$43 = t; + _tmp$44 = err; + r = _tmp$42; + rest = _tmp$43; + err = _tmp$44; + return [r, rest, err]; + } else if (c < 128 && !isalnum(c)) { + _tmp$45 = c; + _tmp$46 = t; + _tmp$47 = $ifaceNil; + r = _tmp$45; + rest = _tmp$46; + err = _tmp$47; + return [r, rest, err]; + } + } + _tmp$48 = 0; + _tmp$49 = ""; + _tmp$50 = new Error.ptr("invalid escape sequence", $substring(s, 0, (s.length - t.length >> 0))); + r = _tmp$48; + rest = _tmp$49; + err = _tmp$50; + return [r, rest, err]; + }; + parser.prototype.parseEscape = function(s) { return this.$val.parseEscape(s); }; + parser.ptr.prototype.parseClassChar = function(s, wholeClass) { + var _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, err, p, r, rest, s, wholeClass; + r = 0; + rest = ""; + err = $ifaceNil; + p = this; + if (s === "") { + _tmp = 0; + _tmp$1 = ""; + _tmp$2 = new Error.ptr("missing closing ]", wholeClass); + r = _tmp; + rest = _tmp$1; + err = _tmp$2; + return [r, rest, err]; + } + if (s.charCodeAt(0) === 92) { + _tuple = p.parseEscape(s); + r = _tuple[0]; + rest = _tuple[1]; + err = _tuple[2]; + return [r, rest, err]; + } + _tuple$1 = nextRune(s); + r = _tuple$1[0]; + rest = _tuple$1[1]; + err = _tuple$1[2]; + return [r, rest, err]; + }; + parser.prototype.parseClassChar = function(s, wholeClass) { return this.$val.parseClassChar(s, wholeClass); }; + parser.ptr.prototype.parsePerlClassEscape = function(s, r) { + var _entry, _r, _tmp, _tmp$1, g, out, p, r, rest, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; g = $f.g; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + out = sliceType.nil; + rest = ""; + p = this; + if ((((p.flags & 64) >>> 0) === 0) || s.length < 2 || !((s.charCodeAt(0) === 92))) { + $s = -1; return [out, rest]; + } + g = $clone((_entry = perlGroup[$String.keyFor($substring(s, 0, 2))], _entry !== undefined ? _entry.v : new charGroup.ptr(0, sliceType.nil)), charGroup); + if (g.sign === 0) { + $s = -1; return [out, rest]; + } + _r = p.appendGroup(r, $clone(g, charGroup)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp = _r; + _tmp$1 = $substring(s, 2); + out = _tmp; + rest = _tmp$1; + $s = -1; return [out, rest]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parsePerlClassEscape }; } $f._entry = _entry; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.g = g; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parsePerlClassEscape = function(s, r) { return this.$val.parsePerlClassEscape(s, r); }; + parser.ptr.prototype.parseNamedClass = function(s, r) { + var _entry, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, err, g, i, name, out, p, r, rest, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; err = $f.err; g = $f.g; i = $f.i; name = $f.name; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + out = sliceType.nil; + rest = ""; + err = $ifaceNil; + p = this; + if (s.length < 2 || !((s.charCodeAt(0) === 91)) || !((s.charCodeAt(1) === 58))) { + $s = -1; return [out, rest, err]; + } + i = strings.Index($substring(s, 2), ":]"); + if (i < 0) { + $s = -1; return [out, rest, err]; + } + i = i + (2) >> 0; + _tmp = $substring(s, 0, (i + 2 >> 0)); + _tmp$1 = $substring(s, (i + 2 >> 0)); + name = _tmp; + s = _tmp$1; + g = $clone((_entry = posixGroup[$String.keyFor(name)], _entry !== undefined ? _entry.v : new charGroup.ptr(0, sliceType.nil)), charGroup); + if (g.sign === 0) { + _tmp$2 = sliceType.nil; + _tmp$3 = ""; + _tmp$4 = new Error.ptr("invalid character class range", name); + out = _tmp$2; + rest = _tmp$3; + err = _tmp$4; + $s = -1; return [out, rest, err]; + } + _r = p.appendGroup(r, $clone(g, charGroup)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp$5 = _r; + _tmp$6 = s; + _tmp$7 = $ifaceNil; + out = _tmp$5; + rest = _tmp$6; + err = _tmp$7; + $s = -1; return [out, rest, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseNamedClass }; } $f._entry = _entry; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f.err = err; $f.g = g; $f.i = i; $f.name = name; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parseNamedClass = function(s, r) { return this.$val.parseNamedClass(s, r); }; + parser.ptr.prototype.appendGroup = function(r, g) { + var _r, g, p, r, tmp, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; g = $f.g; p = $f.p; r = $f.r; tmp = $f.tmp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (((p.flags & 1) >>> 0) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (((p.flags & 1) >>> 0) === 0) { */ case 1: + if (g.sign < 0) { + r = appendNegatedClass(r, g.class$1); + } else { + r = appendClass(r, g.class$1); + } + $s = 3; continue; + /* } else { */ case 2: + tmp = $subslice(p.tmpClass, 0, 0); + tmp = appendFoldedClass(tmp, g.class$1); + p.tmpClass = tmp; + _r = cleanClass((p.$ptr_tmpClass || (p.$ptr_tmpClass = new ptrType$2(function() { return this.$target.tmpClass; }, function($v) { this.$target.tmpClass = $v; }, p)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + tmp = _r; + if (g.sign < 0) { + r = appendNegatedClass(r, tmp); + } else { + r = appendClass(r, tmp); + } + /* } */ case 3: + $s = -1; return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.appendGroup }; } $f._r = _r; $f.g = g; $f.p = p; $f.r = r; $f.tmp = tmp; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.appendGroup = function(r, g) { return this.$val.appendGroup(r, g); }; + unicodeTable = function(name) { + var _entry, _entry$1, _entry$2, _entry$3, name, t, t$1; + if (name === "Any") { + return [anyTable, anyTable]; + } + t = (_entry = unicode.Categories[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$3.nil); + if (!(t === ptrType$3.nil)) { + return [t, (_entry$1 = unicode.FoldCategory[$String.keyFor(name)], _entry$1 !== undefined ? _entry$1.v : ptrType$3.nil)]; + } + t$1 = (_entry$2 = unicode.Scripts[$String.keyFor(name)], _entry$2 !== undefined ? _entry$2.v : ptrType$3.nil); + if (!(t$1 === ptrType$3.nil)) { + return [t$1, (_entry$3 = unicode.FoldScript[$String.keyFor(name)], _entry$3 !== undefined ? _entry$3.v : ptrType$3.nil)]; + } + return [ptrType$3.nil, ptrType$3.nil]; + }; + parser.ptr.prototype.parseUnicodeClass = function(s, r) { + var _r, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, c, end, err, fold, name, out, p, r, rest, s, seq, sign, t, tab, tmp, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; c = $f.c; end = $f.end; err = $f.err; fold = $f.fold; name = $f.name; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; seq = $f.seq; sign = $f.sign; t = $f.t; tab = $f.tab; tmp = $f.tmp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + out = sliceType.nil; + rest = ""; + err = $ifaceNil; + p = this; + if ((((p.flags & 128) >>> 0) === 0) || s.length < 2 || !((s.charCodeAt(0) === 92)) || !((s.charCodeAt(1) === 112)) && !((s.charCodeAt(1) === 80))) { + $s = -1; return [out, rest, err]; + } + sign = 1; + if (s.charCodeAt(1) === 80) { + sign = -1; + } + t = $substring(s, 2); + _tuple = nextRune(t); + c = _tuple[0]; + t = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [out, rest, err]; + } + _tmp = ""; + _tmp$1 = ""; + seq = _tmp; + name = _tmp$1; + if (!((c === 123))) { + seq = $substring(s, 0, (s.length - t.length >> 0)); + name = $substring(seq, 2); + } else { + end = strings.IndexRune(s, 125); + if (end < 0) { + err = checkUTF8(s); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [out, rest, err]; + } + _tmp$2 = sliceType.nil; + _tmp$3 = ""; + _tmp$4 = new Error.ptr("invalid character class range", s); + out = _tmp$2; + rest = _tmp$3; + err = _tmp$4; + $s = -1; return [out, rest, err]; + } + _tmp$5 = $substring(s, 0, (end + 1 >> 0)); + _tmp$6 = $substring(s, (end + 1 >> 0)); + seq = _tmp$5; + t = _tmp$6; + name = $substring(s, 3, end); + err = checkUTF8(name); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [out, rest, err]; + } + } + if (!(name === "") && (name.charCodeAt(0) === 94)) { + sign = -sign; + name = $substring(name, 1); + } + _tuple$1 = unicodeTable(name); + tab = _tuple$1[0]; + fold = _tuple$1[1]; + if (tab === ptrType$3.nil) { + _tmp$7 = sliceType.nil; + _tmp$8 = ""; + _tmp$9 = new Error.ptr("invalid character class range", seq); + out = _tmp$7; + rest = _tmp$8; + err = _tmp$9; + $s = -1; return [out, rest, err]; + } + /* */ if ((((p.flags & 1) >>> 0) === 0) || fold === ptrType$3.nil) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((((p.flags & 1) >>> 0) === 0) || fold === ptrType$3.nil) { */ case 1: + if (sign > 0) { + r = appendTable(r, tab); + } else { + r = appendNegatedTable(r, tab); + } + $s = 3; continue; + /* } else { */ case 2: + tmp = $subslice(p.tmpClass, 0, 0); + tmp = appendTable(tmp, tab); + tmp = appendTable(tmp, fold); + p.tmpClass = tmp; + _r = cleanClass((p.$ptr_tmpClass || (p.$ptr_tmpClass = new ptrType$2(function() { return this.$target.tmpClass; }, function($v) { this.$target.tmpClass = $v; }, p)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + tmp = _r; + if (sign > 0) { + r = appendClass(r, tmp); + } else { + r = appendNegatedClass(r, tmp); + } + /* } */ case 3: + _tmp$10 = r; + _tmp$11 = t; + _tmp$12 = $ifaceNil; + out = _tmp$10; + rest = _tmp$11; + err = _tmp$12; + $s = -1; return [out, rest, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseUnicodeClass }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.c = c; $f.end = end; $f.err = err; $f.fold = fold; $f.name = name; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.seq = seq; $f.sign = sign; $f.t = t; $f.tab = tab; $f.tmp = tmp; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parseUnicodeClass = function(s, r) { return this.$val.parseUnicodeClass(s, r); }; + parser.ptr.prototype.parseClass = function(s) { + var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, class$1, err, err$1, err$2, first, hi, lo, nclass, nclass$1, nclass$2, nt, nt$1, nt$2, p, re, rest, rng, s, sign, size, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; class$1 = $f.class$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; first = $f.first; hi = $f.hi; lo = $f.lo; nclass = $f.nclass; nclass$1 = $f.nclass$1; nclass$2 = $f.nclass$2; nt = $f.nt; nt$1 = $f.nt$1; nt$2 = $f.nt$2; p = $f.p; re = $f.re; rest = $f.rest; rng = $f.rng; s = $f.s; sign = $f.sign; size = $f.size; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rest = ""; + err = $ifaceNil; + p = this; + t = $substring(s, 1); + re = p.newRegexp(4); + re.Flags = p.flags; + re.Rune = $subslice(new sliceType(re.Rune0), 0, 0); + sign = 1; + if (!(t === "") && (t.charCodeAt(0) === 94)) { + sign = -1; + t = $substring(t, 1); + if (((p.flags & 4) >>> 0) === 0) { + re.Rune = $append(re.Rune, 10, 10); + } + } + class$1 = re.Rune; + first = true; + /* while (true) { */ case 1: + /* if (!(t === "" || !((t.charCodeAt(0) === 93)) || first)) { break; } */ if(!(t === "" || !((t.charCodeAt(0) === 93)) || first)) { $s = 2; continue; } + if (!(t === "") && (t.charCodeAt(0) === 45) && (((p.flags & 64) >>> 0) === 0) && !first && ((t.length === 1) || !((t.charCodeAt(1) === 93)))) { + _tuple = utf8.DecodeRuneInString($substring(t, 1)); + size = _tuple[1]; + _tmp = ""; + _tmp$1 = new Error.ptr("invalid character class range", $substring(t, 0, (1 + size >> 0))); + rest = _tmp; + err = _tmp$1; + $s = -1; return [rest, err]; + } + first = false; + /* */ if (t.length > 2 && (t.charCodeAt(0) === 91) && (t.charCodeAt(1) === 58)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (t.length > 2 && (t.charCodeAt(0) === 91) && (t.charCodeAt(1) === 58)) { */ case 3: + _r = p.parseNamedClass(t, class$1); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + nclass = _tuple$1[0]; + nt = _tuple$1[1]; + err$1 = _tuple$1[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp$2 = ""; + _tmp$3 = err$1; + rest = _tmp$2; + err = _tmp$3; + $s = -1; return [rest, err]; + } + if (!(nclass === sliceType.nil)) { + _tmp$4 = nclass; + _tmp$5 = nt; + class$1 = _tmp$4; + t = _tmp$5; + /* continue; */ $s = 1; continue; + } + /* } */ case 4: + _r$1 = p.parseUnicodeClass(t, class$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$2 = _r$1; + nclass$1 = _tuple$2[0]; + nt$1 = _tuple$2[1]; + err$2 = _tuple$2[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + _tmp$6 = ""; + _tmp$7 = err$2; + rest = _tmp$6; + err = _tmp$7; + $s = -1; return [rest, err]; + } + /* */ if (!(nclass$1 === sliceType.nil)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!(nclass$1 === sliceType.nil)) { */ case 7: + _tmp$8 = nclass$1; + _tmp$9 = nt$1; + class$1 = _tmp$8; + t = _tmp$9; + /* continue; */ $s = 1; continue; + /* } */ case 8: + _r$2 = p.parsePerlClassEscape(t, class$1); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$3 = _r$2; + nclass$2 = _tuple$3[0]; + nt$2 = _tuple$3[1]; + if (!(nclass$2 === sliceType.nil)) { + _tmp$10 = nclass$2; + _tmp$11 = nt$2; + class$1 = _tmp$10; + t = _tmp$11; + /* continue; */ $s = 1; continue; + } + rng = t; + _tmp$12 = 0; + _tmp$13 = 0; + lo = _tmp$12; + hi = _tmp$13; + _tuple$4 = p.parseClassChar(t, s); + lo = _tuple$4[0]; + t = _tuple$4[1]; + err$2 = _tuple$4[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + _tmp$14 = ""; + _tmp$15 = err$2; + rest = _tmp$14; + err = _tmp$15; + $s = -1; return [rest, err]; + } + hi = lo; + if (t.length >= 2 && (t.charCodeAt(0) === 45) && !((t.charCodeAt(1) === 93))) { + t = $substring(t, 1); + _tuple$5 = p.parseClassChar(t, s); + hi = _tuple$5[0]; + t = _tuple$5[1]; + err$2 = _tuple$5[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + _tmp$16 = ""; + _tmp$17 = err$2; + rest = _tmp$16; + err = _tmp$17; + $s = -1; return [rest, err]; + } + if (hi < lo) { + rng = $substring(rng, 0, (rng.length - t.length >> 0)); + _tmp$18 = ""; + _tmp$19 = new Error.ptr("invalid character class range", rng); + rest = _tmp$18; + err = _tmp$19; + $s = -1; return [rest, err]; + } + } + if (((p.flags & 1) >>> 0) === 0) { + class$1 = appendRange(class$1, lo, hi); + } else { + class$1 = appendFoldedRange(class$1, lo, hi); + } + /* } */ $s = 1; continue; case 2: + t = $substring(t, 1); + re.Rune = class$1; + _r$3 = cleanClass((re.$ptr_Rune || (re.$ptr_Rune = new ptrType$2(function() { return this.$target.Rune; }, function($v) { this.$target.Rune = $v; }, re)))); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + class$1 = _r$3; + if (sign < 0) { + class$1 = negateClass(class$1); + } + re.Rune = class$1; + p.push(re); + _tmp$20 = t; + _tmp$21 = $ifaceNil; + rest = _tmp$20; + err = _tmp$21; + $s = -1; return [rest, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseClass }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.class$1 = class$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.first = first; $f.hi = hi; $f.lo = lo; $f.nclass = nclass; $f.nclass$1 = nclass$1; $f.nclass$2 = nclass$2; $f.nt = nt; $f.nt$1 = nt$1; $f.nt$2 = nt$2; $f.p = p; $f.re = re; $f.rest = rest; $f.rng = rng; $f.s = s; $f.sign = sign; $f.size = size; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + parser.prototype.parseClass = function(s) { return this.$val.parseClass(s); }; + cleanClass = function(rp) { + var _tmp, _tmp$1, hi, i, lo, r, rp, w, x, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; hi = $f.hi; i = $f.i; lo = $f.lo; r = $f.r; rp = $f.rp; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = sort.Sort((x = new ranges.ptr(rp), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + r = rp.$get(); + if (r.$length < 2) { + $s = -1; return r; + } + w = 2; + i = 2; + while (true) { + if (!(i < r.$length)) { break; } + _tmp = ((i < 0 || i >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + i]); + _tmp$1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1])); + lo = _tmp; + hi = _tmp$1; + if (lo <= ((x$2 = w - 1 >> 0, ((x$2 < 0 || x$2 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$2])) + 1 >> 0)) { + if (hi > (x$3 = w - 1 >> 0, ((x$3 < 0 || x$3 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$3]))) { + (x$4 = w - 1 >> 0, ((x$4 < 0 || x$4 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$4] = hi)); + } + i = i + (2) >> 0; + continue; + } + ((w < 0 || w >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + w] = lo); + (x$5 = w + 1 >> 0, ((x$5 < 0 || x$5 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$5] = hi)); + w = w + (2) >> 0; + i = i + (2) >> 0; + } + $s = -1; return $subslice(r, 0, w); + /* */ } return; } if ($f === undefined) { $f = { $blk: cleanClass }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.hi = hi; $f.i = i; $f.lo = lo; $f.r = r; $f.rp = rp; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + appendLiteral = function(r, x, flags) { + var flags, r, x; + if (!((((flags & 1) >>> 0) === 0))) { + return appendFoldedRange(r, x, x); + } + return appendRange(r, x, x); + }; + appendRange = function(r, lo, hi) { + var _tmp, _tmp$1, hi, i, lo, n, r, rhi, rlo, x, x$1, x$2, x$3; + n = r.$length; + i = 2; + while (true) { + if (!(i <= 4)) { break; } + if (n >= i) { + _tmp = (x = n - i >> 0, ((x < 0 || x >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x])); + _tmp$1 = (x$1 = (n - i >> 0) + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1])); + rlo = _tmp; + rhi = _tmp$1; + if (lo <= (rhi + 1 >> 0) && rlo <= (hi + 1 >> 0)) { + if (lo < rlo) { + (x$2 = n - i >> 0, ((x$2 < 0 || x$2 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$2] = lo)); + } + if (hi > rhi) { + (x$3 = (n - i >> 0) + 1 >> 0, ((x$3 < 0 || x$3 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$3] = hi)); + } + return r; + } + } + i = i + (2) >> 0; + } + return $append(r, lo, hi); + }; + appendFoldedRange = function(r, lo, hi) { + var c, f, hi, lo, r; + if (lo <= 65 && hi >= 125251) { + return appendRange(r, lo, hi); + } + if (hi < 65 || lo > 125251) { + return appendRange(r, lo, hi); + } + if (lo < 65) { + r = appendRange(r, lo, 64); + lo = 65; + } + if (hi > 125251) { + r = appendRange(r, 125252, hi); + hi = 125251; + } + c = lo; + while (true) { + if (!(c <= hi)) { break; } + r = appendRange(r, c, c); + f = unicode.SimpleFold(c); + while (true) { + if (!(!((f === c)))) { break; } + r = appendRange(r, f, f); + f = unicode.SimpleFold(f); + } + c = c + (1) >> 0; + } + return r; + }; + appendClass = function(r, x) { + var i, r, x, x$1; + i = 0; + while (true) { + if (!(i < x.$length)) { break; } + r = appendRange(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); + i = i + (2) >> 0; + } + return r; + }; + appendFoldedClass = function(r, x) { + var i, r, x, x$1; + i = 0; + while (true) { + if (!(i < x.$length)) { break; } + r = appendFoldedRange(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); + i = i + (2) >> 0; + } + return r; + }; + appendNegatedClass = function(r, x) { + var _tmp, _tmp$1, hi, i, lo, nextLo, r, x, x$1; + nextLo = 0; + i = 0; + while (true) { + if (!(i < x.$length)) { break; } + _tmp = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]); + _tmp$1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + lo = _tmp; + hi = _tmp$1; + if (nextLo <= (lo - 1 >> 0)) { + r = appendRange(r, nextLo, lo - 1 >> 0); + } + nextLo = hi + 1 >> 0; + i = i + (2) >> 0; + } + if (nextLo <= 1114111) { + r = appendRange(r, nextLo, 1114111); + } + return r; + }; + appendTable = function(r, x) { + var _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, c, c$1, hi, hi$1, lo, lo$1, r, stride, stride$1, x, xr, xr$1; + _ref = x.R16; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + xr = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), unicode.Range16); + _tmp = ((xr.Lo >> 0)); + _tmp$1 = ((xr.Hi >> 0)); + _tmp$2 = ((xr.Stride >> 0)); + lo = _tmp; + hi = _tmp$1; + stride = _tmp$2; + if (stride === 1) { + r = appendRange(r, lo, hi); + _i++; + continue; + } + c = lo; + while (true) { + if (!(c <= hi)) { break; } + r = appendRange(r, c, c); + c = c + (stride) >> 0; + } + _i++; + } + _ref$1 = x.R32; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + xr$1 = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), unicode.Range32); + _tmp$3 = ((xr$1.Lo >> 0)); + _tmp$4 = ((xr$1.Hi >> 0)); + _tmp$5 = ((xr$1.Stride >> 0)); + lo$1 = _tmp$3; + hi$1 = _tmp$4; + stride$1 = _tmp$5; + if (stride$1 === 1) { + r = appendRange(r, lo$1, hi$1); + _i$1++; + continue; + } + c$1 = lo$1; + while (true) { + if (!(c$1 <= hi$1)) { break; } + r = appendRange(r, c$1, c$1); + c$1 = c$1 + (stride$1) >> 0; + } + _i$1++; + } + return r; + }; + appendNegatedTable = function(r, x) { + var _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, c, c$1, hi, hi$1, lo, lo$1, nextLo, r, stride, stride$1, x, xr, xr$1; + nextLo = 0; + _ref = x.R16; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + xr = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), unicode.Range16); + _tmp = ((xr.Lo >> 0)); + _tmp$1 = ((xr.Hi >> 0)); + _tmp$2 = ((xr.Stride >> 0)); + lo = _tmp; + hi = _tmp$1; + stride = _tmp$2; + if (stride === 1) { + if (nextLo <= (lo - 1 >> 0)) { + r = appendRange(r, nextLo, lo - 1 >> 0); + } + nextLo = hi + 1 >> 0; + _i++; + continue; + } + c = lo; + while (true) { + if (!(c <= hi)) { break; } + if (nextLo <= (c - 1 >> 0)) { + r = appendRange(r, nextLo, c - 1 >> 0); + } + nextLo = c + 1 >> 0; + c = c + (stride) >> 0; + } + _i++; + } + _ref$1 = x.R32; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + xr$1 = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), unicode.Range32); + _tmp$3 = ((xr$1.Lo >> 0)); + _tmp$4 = ((xr$1.Hi >> 0)); + _tmp$5 = ((xr$1.Stride >> 0)); + lo$1 = _tmp$3; + hi$1 = _tmp$4; + stride$1 = _tmp$5; + if (stride$1 === 1) { + if (nextLo <= (lo$1 - 1 >> 0)) { + r = appendRange(r, nextLo, lo$1 - 1 >> 0); + } + nextLo = hi$1 + 1 >> 0; + _i$1++; + continue; + } + c$1 = lo$1; + while (true) { + if (!(c$1 <= hi$1)) { break; } + if (nextLo <= (c$1 - 1 >> 0)) { + r = appendRange(r, nextLo, c$1 - 1 >> 0); + } + nextLo = c$1 + 1 >> 0; + c$1 = c$1 + (stride$1) >> 0; + } + _i$1++; + } + if (nextLo <= 1114111) { + r = appendRange(r, nextLo, 1114111); + } + return r; + }; + negateClass = function(r) { + var _tmp, _tmp$1, hi, i, lo, nextLo, r, w, x, x$1; + nextLo = 0; + w = 0; + i = 0; + while (true) { + if (!(i < r.$length)) { break; } + _tmp = ((i < 0 || i >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + i]); + _tmp$1 = (x = i + 1 >> 0, ((x < 0 || x >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x])); + lo = _tmp; + hi = _tmp$1; + if (nextLo <= (lo - 1 >> 0)) { + ((w < 0 || w >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + w] = nextLo); + (x$1 = w + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1] = (lo - 1 >> 0))); + w = w + (2) >> 0; + } + nextLo = hi + 1 >> 0; + i = i + (2) >> 0; + } + r = $subslice(r, 0, w); + if (nextLo <= 1114111) { + r = $append(r, nextLo, 1114111); + } + return r; + }; + ranges.ptr.prototype.Less = function(i, j) { + var i, j, p, ra, x, x$1; + ra = this; + p = ra.p.$get(); + i = $imul(i, (2)); + j = $imul(j, (2)); + return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]) || (((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) === ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j])) && (x = i + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])) > (x$1 = j + 1 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])); + }; + ranges.prototype.Less = function(i, j) { return this.$val.Less(i, j); }; + ranges.ptr.prototype.Len = function() { + var _q, ra; + ra = this; + return (_q = ra.p.$get().$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + }; + ranges.prototype.Len = function() { return this.$val.Len(); }; + ranges.ptr.prototype.Swap = function(i, j) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, i, j, p, ra, x, x$1, x$2, x$3; + ra = this; + p = ra.p.$get(); + i = $imul(i, (2)); + j = $imul(j, (2)); + _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); + _tmp$1 = (x = j + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])); + _tmp$2 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); + _tmp$3 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])); + ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); + (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2] = _tmp$1)); + ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$2); + (x$3 = j + 1 >> 0, ((x$3 < 0 || x$3 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$3] = _tmp$3)); + }; + ranges.prototype.Swap = function(i, j) { return this.$val.Swap(i, j); }; + checkUTF8 = function(s) { + var _tuple, rune, s, size; + while (true) { + if (!(!(s === ""))) { break; } + _tuple = utf8.DecodeRuneInString(s); + rune = _tuple[0]; + size = _tuple[1]; + if ((rune === 65533) && (size === 1)) { + return new Error.ptr("invalid UTF-8", s); + } + s = $substring(s, size); + } + return $ifaceNil; + }; + nextRune = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, err, s, size, t; + c = 0; + t = ""; + err = $ifaceNil; + _tuple = utf8.DecodeRuneInString(s); + c = _tuple[0]; + size = _tuple[1]; + if ((c === 65533) && (size === 1)) { + _tmp = 0; + _tmp$1 = ""; + _tmp$2 = new Error.ptr("invalid UTF-8", s); + c = _tmp; + t = _tmp$1; + err = _tmp$2; + return [c, t, err]; + } + _tmp$3 = c; + _tmp$4 = $substring(s, size); + _tmp$5 = $ifaceNil; + c = _tmp$3; + t = _tmp$4; + err = _tmp$5; + return [c, t, err]; + }; + isalnum = function(c) { + var c; + return 48 <= c && c <= 57 || 65 <= c && c <= 90 || 97 <= c && c <= 122; + }; + unhex = function(c) { + var c; + if (48 <= c && c <= 57) { + return c - 48 >> 0; + } + if (97 <= c && c <= 102) { + return (c - 97 >> 0) + 10 >> 0; + } + if (65 <= c && c <= 70) { + return (c - 65 >> 0) + 10 >> 0; + } + return -1; + }; + InstOp.prototype.String = function() { + var i; + i = this.$val; + if (((i >>> 0)) >= ((instOpNames.$length >>> 0))) { + return ""; + } + return ((i < 0 || i >= instOpNames.$length) ? ($throwRuntimeError("index out of range"), undefined) : instOpNames.$array[instOpNames.$offset + i]); + }; + $ptrType(InstOp).prototype.String = function() { return new InstOp(this.$get()).String(); }; + IsWordChar = function(r) { + var r; + return 65 <= r && r <= 90 || 97 <= r && r <= 122 || 48 <= r && r <= 57 || (r === 95); + }; + $pkg.IsWordChar = IsWordChar; + Prog.ptr.prototype.String = function() { + var b, p; + p = this; + b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); + dumpProg(b, p); + return b.String(); + }; + Prog.prototype.String = function() { return this.$val.String(); }; + Prog.ptr.prototype.skipNop = function(pc) { + var i, p, pc, x, x$1, x$2; + p = this; + i = (x = p.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); + while (true) { + if (!((i.Op === 6) || (i.Op === 2))) { break; } + i = (x$1 = p.Inst, x$2 = i.Out, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])); + } + return i; + }; + Prog.prototype.skipNop = function(pc) { return this.$val.skipNop(pc); }; + Inst.ptr.prototype.op = function() { + var _1, i, op; + i = this; + op = i.Op; + _1 = op; + if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { + op = 7; + } + return op; + }; + Inst.prototype.op = function() { return this.$val.op(); }; + Prog.ptr.prototype.Prefix = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, buf, complete, i, p, prefix, x; + prefix = ""; + complete = false; + p = this; + i = p.skipNop(((p.Start >>> 0))); + if (!((i.op() === 7)) || !((i.Rune.$length === 1))) { + _tmp = ""; + _tmp$1 = i.Op === 4; + prefix = _tmp; + complete = _tmp$1; + return [prefix, complete]; + } + buf = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); + while (true) { + if (!((i.op() === 7) && (i.Rune.$length === 1) && (((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { break; } + buf.WriteRune((x = i.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))); + i = p.skipNop(i.Out); + } + _tmp$2 = buf.String(); + _tmp$3 = i.Op === 4; + prefix = _tmp$2; + complete = _tmp$3; + return [prefix, complete]; + }; + Prog.prototype.Prefix = function() { return this.$val.Prefix(); }; + Prog.ptr.prototype.StartCond = function() { + var _1, flag, i, p, pc, x, x$1; + p = this; + flag = 0; + pc = ((p.Start >>> 0)); + i = (x = p.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); + Loop: + while (true) { + _1 = i.Op; + if (_1 === (3)) { + flag = (flag | (((i.Arg << 24 >>> 24)))) >>> 0; + } else if (_1 === (5)) { + return 255; + } else if ((_1 === (2)) || (_1 === (6))) { + } else { + break Loop; + } + pc = i.Out; + i = (x$1 = p.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])); + } + return flag; + }; + Prog.prototype.StartCond = function() { return this.$val.StartCond(); }; + Inst.ptr.prototype.MatchRune = function(r) { + var i, r; + i = this; + return !((i.MatchRunePos(r) === -1)); + }; + Inst.prototype.MatchRune = function(r) { return this.$val.MatchRune(r); }; + Inst.ptr.prototype.MatchRunePos = function(r) { + var _1, _q, _q$1, _q$2, c, hi, i, j, lo, m, r, r0, r1, rune, x, x$1, x$2; + i = this; + rune = i.Rune; + _1 = rune.$length; + if (_1 === (0)) { + return -1; + } else if (_1 === (1)) { + r0 = (0 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 0]); + if (r === r0) { + return 0; + } + if (!((((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { + r1 = unicode.SimpleFold(r0); + while (true) { + if (!(!((r1 === r0)))) { break; } + if (r === r1) { + return 0; + } + r1 = unicode.SimpleFold(r1); + } + } + return -1; + } else if (_1 === (2)) { + if (r >= (0 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 0]) && r <= (1 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 1])) { + return 0; + } + return -1; + } else if ((_1 === (4)) || (_1 === (6)) || (_1 === (8))) { + j = 0; + while (true) { + if (!(j < rune.$length)) { break; } + if (r < ((j < 0 || j >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + j])) { + return -1; + } + if (r <= (x = j + 1 >> 0, ((x < 0 || x >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x]))) { + return (_q = j / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + } + j = j + (2) >> 0; + } + return -1; + } + lo = 0; + hi = (_q$1 = rune.$length / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + while (true) { + if (!(lo < hi)) { break; } + m = lo + (_q$2 = ((hi - lo >> 0)) / 2, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + c = (x$1 = $imul(2, m), ((x$1 < 0 || x$1 >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x$1])); + if (c <= r) { + if (r <= (x$2 = ($imul(2, m)) + 1 >> 0, ((x$2 < 0 || x$2 >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x$2]))) { + return m; + } + lo = m + 1 >> 0; + } else { + hi = m; + } + } + return -1; + }; + Inst.prototype.MatchRunePos = function(r) { return this.$val.MatchRunePos(r); }; + Inst.ptr.prototype.MatchEmptyWidth = function(before, after) { + var _1, after, before, i; + i = this; + _1 = ((i.Arg << 24 >>> 24)); + if (_1 === (1)) { + return (before === 10) || (before === -1); + } else if (_1 === (2)) { + return (after === 10) || (after === -1); + } else if (_1 === (4)) { + return before === -1; + } else if (_1 === (8)) { + return after === -1; + } else if (_1 === (16)) { + return !(IsWordChar(before) === IsWordChar(after)); + } else if (_1 === (32)) { + return IsWordChar(before) === IsWordChar(after); + } + $panic(new $String("unknown empty width arg")); + }; + Inst.prototype.MatchEmptyWidth = function(before, after) { return this.$val.MatchEmptyWidth(before, after); }; + Inst.ptr.prototype.String = function() { + var b, i; + i = this; + b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); + dumpInst(b, i); + return b.String(); + }; + Inst.prototype.String = function() { return this.$val.String(); }; + bw = function(b, args) { + var _i, _ref, args, b, s; + _ref = args; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + s = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + b.WriteString(s); + _i++; + } + }; + dumpProg = function(b, p) { + var _i, _ref, b, i, j, p, pc, x; + _ref = p.Inst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + j = _i; + i = (x = p.Inst, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); + pc = strconv.Itoa(j); + if (pc.length < 3) { + b.WriteString($substring(" ", pc.length)); + } + if (j === p.Start) { + pc = pc + ("*"); + } + bw(b, new sliceType$3([pc, "\t"])); + dumpInst(b, i); + bw(b, new sliceType$3(["\n"])); + _i++; + } + }; + u32 = function(i) { + var i; + return strconv.FormatUint((new $Uint64(0, i)), 10); + }; + dumpInst = function(b, i) { + var _1, b, i; + _1 = i.Op; + if (_1 === (0)) { + bw(b, new sliceType$3(["alt -> ", u32(i.Out), ", ", u32(i.Arg)])); + } else if (_1 === (1)) { + bw(b, new sliceType$3(["altmatch -> ", u32(i.Out), ", ", u32(i.Arg)])); + } else if (_1 === (2)) { + bw(b, new sliceType$3(["cap ", u32(i.Arg), " -> ", u32(i.Out)])); + } else if (_1 === (3)) { + bw(b, new sliceType$3(["empty ", u32(i.Arg), " -> ", u32(i.Out)])); + } else if (_1 === (4)) { + bw(b, new sliceType$3(["match"])); + } else if (_1 === (5)) { + bw(b, new sliceType$3(["fail"])); + } else if (_1 === (6)) { + bw(b, new sliceType$3(["nop -> ", u32(i.Out)])); + } else if (_1 === (7)) { + if (i.Rune === sliceType.nil) { + bw(b, new sliceType$3(["rune "])); + } + bw(b, new sliceType$3(["rune ", strconv.QuoteToASCII(($runesToString(i.Rune)))])); + if (!((((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { + bw(b, new sliceType$3(["/i"])); + } + bw(b, new sliceType$3([" -> ", u32(i.Out)])); + } else if (_1 === (8)) { + bw(b, new sliceType$3(["rune1 ", strconv.QuoteToASCII(($runesToString(i.Rune))), " -> ", u32(i.Out)])); + } else if (_1 === (9)) { + bw(b, new sliceType$3(["any -> ", u32(i.Out)])); + } else if (_1 === (10)) { + bw(b, new sliceType$3(["anynotnl -> ", u32(i.Out)])); + } + }; + Regexp.ptr.prototype.Equal = function(y) { + var _1, _i, _i$1, _ref, _ref$1, i, i$1, r, sub, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y; + x = this; + if (x === ptrType$1.nil || y === ptrType$1.nil) { + return x === y; + } + if (!((x.Op === y.Op))) { + return false; + } + _1 = x.Op; + if (_1 === (10)) { + if (!((((x.Flags & 256) >>> 0) === ((y.Flags & 256) >>> 0)))) { + return false; + } + } else if ((_1 === (3)) || (_1 === (4))) { + if (!((x.Rune.$length === y.Rune.$length))) { + return false; + } + _ref = x.Rune; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + r = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((r === (x$1 = y.Rune, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i]))))) { + return false; + } + _i++; + } + } else if ((_1 === (19)) || (_1 === (18))) { + if (!((x.Sub.$length === y.Sub.$length))) { + return false; + } + _ref$1 = x.Sub; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + sub = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + if (!sub.Equal((x$2 = y.Sub, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])))) { + return false; + } + _i$1++; + } + } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16))) { + if (!((((x.Flags & 32) >>> 0) === ((y.Flags & 32) >>> 0))) || !(x$3 = x.Sub, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).Equal((x$4 = y.Sub, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])))) { + return false; + } + } else if (_1 === (17)) { + if (!((((x.Flags & 32) >>> 0) === ((y.Flags & 32) >>> 0))) || !((x.Min === y.Min)) || !((x.Max === y.Max)) || !(x$5 = x.Sub, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0])).Equal((x$6 = y.Sub, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0])))) { + return false; + } + } else if (_1 === (13)) { + if (!((x.Cap === y.Cap)) || !(x.Name === y.Name) || !(x$7 = x.Sub, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])).Equal((x$8 = y.Sub, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0])))) { + return false; + } + } + return true; + }; + Regexp.prototype.Equal = function(y) { return this.$val.Equal(y); }; + writeRegexp = function(b, re) { + var _1, _2, _i, _i$1, _i$2, _r, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tmp$2, _tmp$3, b, hi, hi$1, i, i$1, i$2, lo, lo$1, r, re, sub, sub$1, sub$2, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + switch (0) { default: + _1 = re.Op; + if (_1 === (1)) { + b.WriteString("[^\\x00-\\x{10FFFF}]"); + } else if (_1 === (2)) { + b.WriteString("(?:)"); + } else if (_1 === (3)) { + if (!((((re.Flags & 1) >>> 0) === 0))) { + b.WriteString("(?i:"); + } + _ref = re.Rune; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + r = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + escape(b, r, false); + _i++; + } + if (!((((re.Flags & 1) >>> 0) === 0))) { + b.WriteString(")"); + } + } else if (_1 === (4)) { + if (!(((_r = re.Rune.$length % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0))) { + b.WriteString("[invalid char class]"); + break; + } + b.WriteRune(91); + if (re.Rune.$length === 0) { + b.WriteString("^\\x00-\\x{10FFFF}"); + } else if (((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === 0) && ((x$1 = re.Rune, x$2 = re.Rune.$length - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === 1114111)) { + b.WriteRune(94); + i = 1; + while (true) { + if (!(i < (re.Rune.$length - 1 >> 0))) { break; } + _tmp = (x$3 = re.Rune, ((i < 0 || i >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i])) + 1 >> 0; + _tmp$1 = (x$4 = re.Rune, x$5 = i + 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) - 1 >> 0; + lo = _tmp; + hi = _tmp$1; + escape(b, lo, lo === 45); + if (!((lo === hi))) { + b.WriteRune(45); + escape(b, hi, hi === 45); + } + i = i + (2) >> 0; + } + } else { + i$1 = 0; + while (true) { + if (!(i$1 < re.Rune.$length)) { break; } + _tmp$2 = (x$6 = re.Rune, ((i$1 < 0 || i$1 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i$1])); + _tmp$3 = (x$7 = re.Rune, x$8 = i$1 + 1 >> 0, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8])); + lo$1 = _tmp$2; + hi$1 = _tmp$3; + escape(b, lo$1, lo$1 === 45); + if (!((lo$1 === hi$1))) { + b.WriteRune(45); + escape(b, hi$1, hi$1 === 45); + } + i$1 = i$1 + (2) >> 0; + } + } + b.WriteRune(93); + } else if (_1 === (5)) { + b.WriteString("(?-s:.)"); + } else if (_1 === (6)) { + b.WriteString("(?s:.)"); + } else if (_1 === (7)) { + b.WriteString("(?m:^)"); + } else if (_1 === (8)) { + b.WriteString("(?m:$)"); + } else if (_1 === (9)) { + b.WriteString("\\A"); + } else if (_1 === (10)) { + if (!((((re.Flags & 256) >>> 0) === 0))) { + b.WriteString("(?-m:$)"); + } else { + b.WriteString("\\z"); + } + } else if (_1 === (11)) { + b.WriteString("\\b"); + } else if (_1 === (12)) { + b.WriteString("\\B"); + } else if (_1 === (13)) { + if (!(re.Name === "")) { + b.WriteString("(?P<"); + b.WriteString(re.Name); + b.WriteRune(62); + } else { + b.WriteRune(40); + } + if (!(((x$9 = re.Sub, (0 >= x$9.$length ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + 0])).Op === 2))) { + writeRegexp(b, (x$10 = re.Sub, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0]))); + } + b.WriteRune(41); + } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16)) || (_1 === (17))) { + sub = (x$11 = re.Sub, (0 >= x$11.$length ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + 0])); + if (sub.Op > 13 || (sub.Op === 3) && sub.Rune.$length > 1) { + b.WriteString("(?:"); + writeRegexp(b, sub); + b.WriteString(")"); + } else { + writeRegexp(b, sub); + } + _2 = re.Op; + if (_2 === (14)) { + b.WriteRune(42); + } else if (_2 === (15)) { + b.WriteRune(43); + } else if (_2 === (16)) { + b.WriteRune(63); + } else if (_2 === (17)) { + b.WriteRune(123); + b.WriteString(strconv.Itoa(re.Min)); + if (!((re.Max === re.Min))) { + b.WriteRune(44); + if (re.Max >= 0) { + b.WriteString(strconv.Itoa(re.Max)); + } + } + b.WriteRune(125); + } + if (!((((re.Flags & 32) >>> 0) === 0))) { + b.WriteRune(63); + } + } else if (_1 === (18)) { + _ref$1 = re.Sub; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + sub$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + if (sub$1.Op === 19) { + b.WriteString("(?:"); + writeRegexp(b, sub$1); + b.WriteString(")"); + } else { + writeRegexp(b, sub$1); + } + _i$1++; + } + } else if (_1 === (19)) { + _ref$2 = re.Sub; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + sub$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$2.$array[_ref$2.$offset + _i$2]); + if (i$2 > 0) { + b.WriteRune(124); + } + writeRegexp(b, sub$2); + _i$2++; + } + } else { + b.WriteString("> 0))) + ">"); + } + } + }; + Regexp.ptr.prototype.String = function() { + var b, re; + re = this; + b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); + writeRegexp(b, re); + return b.String(); + }; + Regexp.prototype.String = function() { return this.$val.String(); }; + escape = function(b, r, force) { + var _1, b, force, r, s; + if (unicode.IsPrint(r)) { + if (strings.ContainsRune("\\.+*?()|[]{}^$", r) || force) { + b.WriteRune(92); + } + b.WriteRune(r); + return; + } + switch (0) { default: + _1 = r; + if (_1 === (7)) { + b.WriteString("\\a"); + } else if (_1 === (12)) { + b.WriteString("\\f"); + } else if (_1 === (10)) { + b.WriteString("\\n"); + } else if (_1 === (13)) { + b.WriteString("\\r"); + } else if (_1 === (9)) { + b.WriteString("\\t"); + } else if (_1 === (11)) { + b.WriteString("\\v"); + } else { + if (r < 256) { + b.WriteString("\\x"); + s = strconv.FormatInt((new $Int64(0, r)), 16); + if (s.length === 1) { + b.WriteRune(48); + } + b.WriteString(s); + break; + } + b.WriteString("\\x{"); + b.WriteString(strconv.FormatInt((new $Int64(0, r)), 16)); + b.WriteString("}"); + } + } + }; + Regexp.ptr.prototype.MaxCap = function() { + var _i, _ref, m, n, re, sub; + re = this; + m = 0; + if (re.Op === 13) { + m = re.Cap; + } + _ref = re.Sub; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + n = sub.MaxCap(); + if (m < n) { + m = n; + } + _i++; + } + return m; + }; + Regexp.prototype.MaxCap = function() { return this.$val.MaxCap(); }; + Regexp.ptr.prototype.CapNames = function() { + var names, re; + re = this; + names = $makeSlice(sliceType$3, (re.MaxCap() + 1 >> 0)); + re.capNames(names); + return names; + }; + Regexp.prototype.CapNames = function() { return this.$val.CapNames(); }; + Regexp.ptr.prototype.capNames = function(names) { + var _i, _ref, names, re, sub, x; + re = this; + if (re.Op === 13) { + (x = re.Cap, ((x < 0 || x >= names.$length) ? ($throwRuntimeError("index out of range"), undefined) : names.$array[names.$offset + x] = re.Name)); + } + _ref = re.Sub; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + sub.capNames(names); + _i++; + } + }; + Regexp.prototype.capNames = function(names) { return this.$val.capNames(names); }; + Regexp.ptr.prototype.Simplify = function() { + var _1, _i, _ref, i, i$1, i$2, i$3, nre, nre$1, nre2, nsub, prefix, re, sub, sub$1, sub$2, suffix, x, x$1; + re = this; + if (re === ptrType$1.nil) { + return ptrType$1.nil; + } + _1 = re.Op; + if ((_1 === (13)) || (_1 === (18)) || (_1 === (19))) { + nre = re; + _ref = re.Sub; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + nsub = sub.Simplify(); + if (nre === re && !(nsub === sub)) { + nre = new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + Regexp.copy(nre, re); + nre.Rune = sliceType.nil; + nre.Sub = $appendSlice($subslice(new sliceType$5(nre.Sub0), 0, 0), $subslice(re.Sub, 0, i)); + } + if (!(nre === re)) { + nre.Sub = $append(nre.Sub, nsub); + } + _i++; + } + return nre; + } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16))) { + sub$1 = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])).Simplify(); + return simplify1(re.Op, re.Flags, sub$1, re); + } else if (_1 === (17)) { + if ((re.Min === 0) && (re.Max === 0)) { + return new Regexp.ptr(2, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + } + sub$2 = (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])).Simplify(); + if (re.Max === -1) { + if (re.Min === 0) { + return simplify1(14, re.Flags, sub$2, ptrType$1.nil); + } + if (re.Min === 1) { + return simplify1(15, re.Flags, sub$2, ptrType$1.nil); + } + nre$1 = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + nre$1.Sub = $subslice(new sliceType$5(nre$1.Sub0), 0, 0); + i$1 = 0; + while (true) { + if (!(i$1 < (re.Min - 1 >> 0))) { break; } + nre$1.Sub = $append(nre$1.Sub, sub$2); + i$1 = i$1 + (1) >> 0; + } + nre$1.Sub = $append(nre$1.Sub, simplify1(15, re.Flags, sub$2, ptrType$1.nil)); + return nre$1; + } + if ((re.Min === 1) && (re.Max === 1)) { + return sub$2; + } + prefix = ptrType$1.nil; + if (re.Min > 0) { + prefix = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + prefix.Sub = $subslice(new sliceType$5(prefix.Sub0), 0, 0); + i$2 = 0; + while (true) { + if (!(i$2 < re.Min)) { break; } + prefix.Sub = $append(prefix.Sub, sub$2); + i$2 = i$2 + (1) >> 0; + } + } + if (re.Max > re.Min) { + suffix = simplify1(16, re.Flags, sub$2, ptrType$1.nil); + i$3 = re.Min + 1 >> 0; + while (true) { + if (!(i$3 < re.Max)) { break; } + nre2 = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + nre2.Sub = $append($subslice(new sliceType$5(nre2.Sub0), 0, 0), sub$2, suffix); + suffix = simplify1(16, re.Flags, nre2, ptrType$1.nil); + i$3 = i$3 + (1) >> 0; + } + if (prefix === ptrType$1.nil) { + return suffix; + } + prefix.Sub = $append(prefix.Sub, suffix); + } + if (!(prefix === ptrType$1.nil)) { + return prefix; + } + return new Regexp.ptr(1, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + } + return re; + }; + Regexp.prototype.Simplify = function() { return this.$val.Simplify(); }; + simplify1 = function(op, flags, sub, re) { + var flags, op, re, sub, x; + if (sub.Op === 2) { + return sub; + } + if ((op === sub.Op) && (((flags & 32) >>> 0) === ((sub.Flags & 32) >>> 0))) { + return sub; + } + if (!(re === ptrType$1.nil) && (re.Op === op) && (((re.Flags & 32) >>> 0) === ((flags & 32) >>> 0)) && sub === (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))) { + return re; + } + re = new Regexp.ptr(op, flags, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); + re.Sub = $append($subslice(new sliceType$5(re.Sub0), 0, 0), sub); + return re; + }; + patchList.methods = [{prop: "next", name: "next", pkg: "regexp/syntax", typ: $funcType([ptrType], [patchList], false)}, {prop: "patch", name: "patch", pkg: "regexp/syntax", typ: $funcType([ptrType, $Uint32], [], false)}, {prop: "append", name: "append", pkg: "regexp/syntax", typ: $funcType([ptrType, patchList], [patchList], false)}]; + ptrType$5.methods = [{prop: "init", name: "init", pkg: "regexp/syntax", typ: $funcType([], [], false)}, {prop: "compile", name: "compile", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [frag], false)}, {prop: "inst", name: "inst", pkg: "regexp/syntax", typ: $funcType([InstOp], [frag], false)}, {prop: "nop", name: "nop", pkg: "regexp/syntax", typ: $funcType([], [frag], false)}, {prop: "fail", name: "fail", pkg: "regexp/syntax", typ: $funcType([], [frag], false)}, {prop: "cap", name: "cap", pkg: "regexp/syntax", typ: $funcType([$Uint32], [frag], false)}, {prop: "cat", name: "cat", pkg: "regexp/syntax", typ: $funcType([frag, frag], [frag], false)}, {prop: "alt", name: "alt", pkg: "regexp/syntax", typ: $funcType([frag, frag], [frag], false)}, {prop: "quest", name: "quest", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "star", name: "star", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "plus", name: "plus", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "empty", name: "empty", pkg: "regexp/syntax", typ: $funcType([EmptyOp], [frag], false)}, {prop: "rune", name: "rune", pkg: "regexp/syntax", typ: $funcType([sliceType, Flags], [frag], false)}]; + ptrType$6.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ErrorCode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$7.methods = [{prop: "newRegexp", name: "newRegexp", pkg: "regexp/syntax", typ: $funcType([Op], [ptrType$1], false)}, {prop: "reuse", name: "reuse", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [], false)}, {prop: "push", name: "push", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "maybeConcat", name: "maybeConcat", pkg: "regexp/syntax", typ: $funcType([$Int32, Flags], [$Bool], false)}, {prop: "newLiteral", name: "newLiteral", pkg: "regexp/syntax", typ: $funcType([$Int32, Flags], [ptrType$1], false)}, {prop: "literal", name: "literal", pkg: "regexp/syntax", typ: $funcType([$Int32], [], false)}, {prop: "op", name: "op", pkg: "regexp/syntax", typ: $funcType([Op], [ptrType$1], false)}, {prop: "repeat", name: "repeat", pkg: "regexp/syntax", typ: $funcType([Op, $Int, $Int, $String, $String, $String], [$String, $error], false)}, {prop: "concat", name: "concat", pkg: "regexp/syntax", typ: $funcType([], [ptrType$1], false)}, {prop: "alternate", name: "alternate", pkg: "regexp/syntax", typ: $funcType([], [ptrType$1], false)}, {prop: "collapse", name: "collapse", pkg: "regexp/syntax", typ: $funcType([sliceType$5, Op], [ptrType$1], false)}, {prop: "factor", name: "factor", pkg: "regexp/syntax", typ: $funcType([sliceType$5], [sliceType$5], false)}, {prop: "leadingString", name: "leadingString", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [sliceType, Flags], false)}, {prop: "removeLeadingString", name: "removeLeadingString", pkg: "regexp/syntax", typ: $funcType([ptrType$1, $Int], [ptrType$1], false)}, {prop: "leadingRegexp", name: "leadingRegexp", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "removeLeadingRegexp", name: "removeLeadingRegexp", pkg: "regexp/syntax", typ: $funcType([ptrType$1, $Bool], [ptrType$1], false)}, {prop: "parseRepeat", name: "parseRepeat", pkg: "regexp/syntax", typ: $funcType([$String], [$Int, $Int, $String, $Bool], false)}, {prop: "parsePerlFlags", name: "parsePerlFlags", pkg: "regexp/syntax", typ: $funcType([$String], [$String, $error], false)}, {prop: "parseInt", name: "parseInt", pkg: "regexp/syntax", typ: $funcType([$String], [$Int, $String, $Bool], false)}, {prop: "parseVerticalBar", name: "parseVerticalBar", pkg: "regexp/syntax", typ: $funcType([], [$error], false)}, {prop: "swapVerticalBar", name: "swapVerticalBar", pkg: "regexp/syntax", typ: $funcType([], [$Bool], false)}, {prop: "parseRightParen", name: "parseRightParen", pkg: "regexp/syntax", typ: $funcType([], [$error], false)}, {prop: "parseEscape", name: "parseEscape", pkg: "regexp/syntax", typ: $funcType([$String], [$Int32, $String, $error], false)}, {prop: "parseClassChar", name: "parseClassChar", pkg: "regexp/syntax", typ: $funcType([$String, $String], [$Int32, $String, $error], false)}, {prop: "parsePerlClassEscape", name: "parsePerlClassEscape", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String], false)}, {prop: "parseNamedClass", name: "parseNamedClass", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String, $error], false)}, {prop: "appendGroup", name: "appendGroup", pkg: "regexp/syntax", typ: $funcType([sliceType, charGroup], [sliceType], false)}, {prop: "parseUnicodeClass", name: "parseUnicodeClass", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String, $error], false)}, {prop: "parseClass", name: "parseClass", pkg: "regexp/syntax", typ: $funcType([$String], [$String, $error], false)}]; + ranges.methods = [{prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; + ptrType.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "skipNop", name: "skipNop", pkg: "regexp/syntax", typ: $funcType([$Uint32], [ptrType$8], false)}, {prop: "Prefix", name: "Prefix", pkg: "", typ: $funcType([], [$String, $Bool], false)}, {prop: "StartCond", name: "StartCond", pkg: "", typ: $funcType([], [EmptyOp], false)}]; + InstOp.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$8.methods = [{prop: "op", name: "op", pkg: "regexp/syntax", typ: $funcType([], [InstOp], false)}, {prop: "MatchRune", name: "MatchRune", pkg: "", typ: $funcType([$Int32], [$Bool], false)}, {prop: "MatchRunePos", name: "MatchRunePos", pkg: "", typ: $funcType([$Int32], [$Int], false)}, {prop: "MatchEmptyWidth", name: "MatchEmptyWidth", pkg: "", typ: $funcType([$Int32, $Int32], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "Equal", name: "Equal", pkg: "", typ: $funcType([ptrType$1], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "MaxCap", name: "MaxCap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "CapNames", name: "CapNames", pkg: "", typ: $funcType([], [sliceType$3], false)}, {prop: "capNames", name: "capNames", pkg: "regexp/syntax", typ: $funcType([sliceType$3], [], false)}, {prop: "Simplify", name: "Simplify", pkg: "", typ: $funcType([], [ptrType$1], false)}]; + Op.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + frag.init("regexp/syntax", [{prop: "i", name: "i", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: patchList, tag: ""}]); + compiler.init("regexp/syntax", [{prop: "p", name: "p", embedded: false, exported: false, typ: ptrType, tag: ""}]); + Error.init("", [{prop: "Code", name: "Code", embedded: false, exported: true, typ: ErrorCode, tag: ""}, {prop: "Expr", name: "Expr", embedded: false, exported: true, typ: $String, tag: ""}]); + parser.init("regexp/syntax", [{prop: "flags", name: "flags", embedded: false, exported: false, typ: Flags, tag: ""}, {prop: "stack", name: "stack", embedded: false, exported: false, typ: sliceType$5, tag: ""}, {prop: "free", name: "free", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "numCap", name: "numCap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "wholeRegexp", name: "wholeRegexp", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tmpClass", name: "tmpClass", embedded: false, exported: false, typ: sliceType, tag: ""}]); + charGroup.init("regexp/syntax", [{prop: "sign", name: "sign", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "class$1", name: "class", embedded: false, exported: false, typ: sliceType, tag: ""}]); + ranges.init("regexp/syntax", [{prop: "p", name: "p", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); + Prog.init("", [{prop: "Inst", name: "Inst", embedded: false, exported: true, typ: sliceType$4, tag: ""}, {prop: "Start", name: "Start", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "NumCap", name: "NumCap", embedded: false, exported: true, typ: $Int, tag: ""}]); + Inst.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: InstOp, tag: ""}, {prop: "Out", name: "Out", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Arg", name: "Arg", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Rune", name: "Rune", embedded: false, exported: true, typ: sliceType, tag: ""}]); + Regexp.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: Op, tag: ""}, {prop: "Flags", name: "Flags", embedded: false, exported: true, typ: Flags, tag: ""}, {prop: "Sub", name: "Sub", embedded: false, exported: true, typ: sliceType$5, tag: ""}, {prop: "Sub0", name: "Sub0", embedded: false, exported: true, typ: arrayType, tag: ""}, {prop: "Rune", name: "Rune", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "Rune0", name: "Rune0", embedded: false, exported: true, typ: arrayType$1, tag: ""}, {prop: "Min", name: "Min", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Max", name: "Max", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Cap", name: "Cap", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = sort.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + anyRuneNotNL = new sliceType([0, 9, 11, 1114111]); + anyRune = new sliceType([0, 1114111]); + _Op_index_0 = $toNativeArray($kindUint8, [0, 7, 17, 24, 33, 45, 52, 61, 68, 77, 84, 96, 110, 117, 121, 125, 130, 136, 142, 151]); + anyTable = new unicode.RangeTable.ptr(new sliceType$1([new unicode.Range16.ptr(0, 65535, 1)]), new sliceType$2([new unicode.Range32.ptr(65536, 1114111, 1)]), 0); + code1 = new sliceType([48, 57]); + code2 = new sliceType([9, 10, 12, 13, 32, 32]); + code3 = new sliceType([48, 57, 65, 90, 95, 95, 97, 122]); + perlGroup = $makeMap($String.keyFor, [{ k: "\\d", v: new charGroup.ptr(1, code1) }, { k: "\\D", v: new charGroup.ptr(-1, code1) }, { k: "\\s", v: new charGroup.ptr(1, code2) }, { k: "\\S", v: new charGroup.ptr(-1, code2) }, { k: "\\w", v: new charGroup.ptr(1, code3) }, { k: "\\W", v: new charGroup.ptr(-1, code3) }]); + code4 = new sliceType([48, 57, 65, 90, 97, 122]); + code5 = new sliceType([65, 90, 97, 122]); + code6 = new sliceType([0, 127]); + code7 = new sliceType([9, 9, 32, 32]); + code8 = new sliceType([0, 31, 127, 127]); + code9 = new sliceType([48, 57]); + code10 = new sliceType([33, 126]); + code11 = new sliceType([97, 122]); + code12 = new sliceType([32, 126]); + code13 = new sliceType([33, 47, 58, 64, 91, 96, 123, 126]); + code14 = new sliceType([9, 13, 32, 32]); + code15 = new sliceType([65, 90]); + code16 = new sliceType([48, 57, 65, 90, 95, 95, 97, 122]); + code17 = new sliceType([48, 57, 65, 70, 97, 102]); + posixGroup = $makeMap($String.keyFor, [{ k: "[:alnum:]", v: new charGroup.ptr(1, code4) }, { k: "[:^alnum:]", v: new charGroup.ptr(-1, code4) }, { k: "[:alpha:]", v: new charGroup.ptr(1, code5) }, { k: "[:^alpha:]", v: new charGroup.ptr(-1, code5) }, { k: "[:ascii:]", v: new charGroup.ptr(1, code6) }, { k: "[:^ascii:]", v: new charGroup.ptr(-1, code6) }, { k: "[:blank:]", v: new charGroup.ptr(1, code7) }, { k: "[:^blank:]", v: new charGroup.ptr(-1, code7) }, { k: "[:cntrl:]", v: new charGroup.ptr(1, code8) }, { k: "[:^cntrl:]", v: new charGroup.ptr(-1, code8) }, { k: "[:digit:]", v: new charGroup.ptr(1, code9) }, { k: "[:^digit:]", v: new charGroup.ptr(-1, code9) }, { k: "[:graph:]", v: new charGroup.ptr(1, code10) }, { k: "[:^graph:]", v: new charGroup.ptr(-1, code10) }, { k: "[:lower:]", v: new charGroup.ptr(1, code11) }, { k: "[:^lower:]", v: new charGroup.ptr(-1, code11) }, { k: "[:print:]", v: new charGroup.ptr(1, code12) }, { k: "[:^print:]", v: new charGroup.ptr(-1, code12) }, { k: "[:punct:]", v: new charGroup.ptr(1, code13) }, { k: "[:^punct:]", v: new charGroup.ptr(-1, code13) }, { k: "[:space:]", v: new charGroup.ptr(1, code14) }, { k: "[:^space:]", v: new charGroup.ptr(-1, code14) }, { k: "[:upper:]", v: new charGroup.ptr(1, code15) }, { k: "[:^upper:]", v: new charGroup.ptr(-1, code15) }, { k: "[:word:]", v: new charGroup.ptr(1, code16) }, { k: "[:^word:]", v: new charGroup.ptr(-1, code16) }, { k: "[:xdigit:]", v: new charGroup.ptr(1, code17) }, { k: "[:^xdigit:]", v: new charGroup.ptr(-1, code17) }]); + instOpNames = new sliceType$3(["InstAlt", "InstAltMatch", "InstCapture", "InstEmptyWidth", "InstMatch", "InstFail", "InstNop", "InstRune", "InstRune1", "InstRuneAny", "InstRuneAnyNotNL"]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["regexp"] = (function() { + var $pkg = {}, $init, bytes, nosync, io, syntax, sort, strconv, strings, unicode, utf8, job, bitState, queue, entry, thread, machine, inputs, lazyFlag, onePassMachine, onePassProg, onePassInst, queueOnePass, runeSlice, Regexp, input, inputString, inputBytes, inputReader, sliceType, arrayType, arrayType$1, arrayType$2, sliceType$1, sliceType$2, ptrType, sliceType$3, sliceType$4, sliceType$5, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, sliceType$6, ptrType$9, sliceType$7, ptrType$10, sliceType$8, ptrType$11, ptrType$12, sliceType$9, ptrType$13, sliceType$10, sliceType$11, arrayType$3, arrayType$4, sliceType$12, sliceType$13, sliceType$14, sliceType$15, ptrType$14, ptrType$15, funcType, funcType$1, funcType$2, funcType$3, ptrType$16, ptrType$17, ptrType$18, bitStatePool, onePassPool, arrayNoInts, noRune, noNext, anyRuneNotNL, anyRune, matchSize, matchPool, specialBytes, newBitState, freeBitState, maxBitStateLen, shouldBacktrack, newLazyFlag, newOnePassMachine, freeOnePassMachine, onePassPrefix, onePassNext, iop, newQueue, mergeRuneSets, cleanupOnePass, onePassCopy, makeOnePass, compileOnePass, Compile, compile, MustCompile, quote, init, extract; + bytes = $packages["bytes"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + io = $packages["io"]; + syntax = $packages["regexp/syntax"]; + sort = $packages["sort"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + job = $pkg.job = $newType(0, $kindStruct, "regexp.job", true, "regexp", false, function(pc_, arg_, pos_) { + this.$val = this; + if (arguments.length === 0) { + this.pc = 0; + this.arg = false; + this.pos = 0; + return; + } + this.pc = pc_; + this.arg = arg_; + this.pos = pos_; + }); + bitState = $pkg.bitState = $newType(0, $kindStruct, "regexp.bitState", true, "regexp", false, function(end_, cap_, matchcap_, jobs_, visited_, inputs_) { + this.$val = this; + if (arguments.length === 0) { + this.end = 0; + this.cap = sliceType$3.nil; + this.matchcap = sliceType$3.nil; + this.jobs = sliceType$4.nil; + this.visited = sliceType$2.nil; + this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); + return; + } + this.end = end_; + this.cap = cap_; + this.matchcap = matchcap_; + this.jobs = jobs_; + this.visited = visited_; + this.inputs = inputs_; + }); + queue = $pkg.queue = $newType(0, $kindStruct, "regexp.queue", true, "regexp", false, function(sparse_, dense_) { + this.$val = this; + if (arguments.length === 0) { + this.sparse = sliceType$2.nil; + this.dense = sliceType$10.nil; + return; + } + this.sparse = sparse_; + this.dense = dense_; + }); + entry = $pkg.entry = $newType(0, $kindStruct, "regexp.entry", true, "regexp", false, function(pc_, t_) { + this.$val = this; + if (arguments.length === 0) { + this.pc = 0; + this.t = ptrType$1.nil; + return; + } + this.pc = pc_; + this.t = t_; + }); + thread = $pkg.thread = $newType(0, $kindStruct, "regexp.thread", true, "regexp", false, function(inst_, cap_) { + this.$val = this; + if (arguments.length === 0) { + this.inst = ptrType$2.nil; + this.cap = sliceType$3.nil; + return; + } + this.inst = inst_; + this.cap = cap_; + }); + machine = $pkg.machine = $newType(0, $kindStruct, "regexp.machine", true, "regexp", false, function(re_, p_, q0_, q1_, pool_, matched_, matchcap_, inputs_) { + this.$val = this; + if (arguments.length === 0) { + this.re = ptrType$11.nil; + this.p = ptrType$12.nil; + this.q0 = new queue.ptr(sliceType$2.nil, sliceType$10.nil); + this.q1 = new queue.ptr(sliceType$2.nil, sliceType$10.nil); + this.pool = sliceType$11.nil; + this.matched = false; + this.matchcap = sliceType$3.nil; + this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); + return; + } + this.re = re_; + this.p = p_; + this.q0 = q0_; + this.q1 = q1_; + this.pool = pool_; + this.matched = matched_; + this.matchcap = matchcap_; + this.inputs = inputs_; + }); + inputs = $pkg.inputs = $newType(0, $kindStruct, "regexp.inputs", true, "regexp", false, function(bytes_, string_, reader_) { + this.$val = this; + if (arguments.length === 0) { + this.bytes = new inputBytes.ptr(sliceType$5.nil); + this.string = new inputString.ptr(""); + this.reader = new inputReader.ptr($ifaceNil, false, 0); + return; + } + this.bytes = bytes_; + this.string = string_; + this.reader = reader_; + }); + lazyFlag = $pkg.lazyFlag = $newType(8, $kindUint64, "regexp.lazyFlag", true, "regexp", false, null); + onePassMachine = $pkg.onePassMachine = $newType(0, $kindStruct, "regexp.onePassMachine", true, "regexp", false, function(inputs_, matchcap_) { + this.$val = this; + if (arguments.length === 0) { + this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); + this.matchcap = sliceType$3.nil; + return; + } + this.inputs = inputs_; + this.matchcap = matchcap_; + }); + onePassProg = $pkg.onePassProg = $newType(0, $kindStruct, "regexp.onePassProg", true, "regexp", false, function(Inst_, Start_, NumCap_) { + this.$val = this; + if (arguments.length === 0) { + this.Inst = sliceType$6.nil; + this.Start = 0; + this.NumCap = 0; + return; + } + this.Inst = Inst_; + this.Start = Start_; + this.NumCap = NumCap_; + }); + onePassInst = $pkg.onePassInst = $newType(0, $kindStruct, "regexp.onePassInst", true, "regexp", false, function(Inst_, Next_) { + this.$val = this; + if (arguments.length === 0) { + this.Inst = new syntax.Inst.ptr(0, 0, 0, sliceType$1.nil); + this.Next = sliceType$2.nil; + return; + } + this.Inst = Inst_; + this.Next = Next_; + }); + queueOnePass = $pkg.queueOnePass = $newType(0, $kindStruct, "regexp.queueOnePass", true, "regexp", false, function(sparse_, dense_, size_, nextIndex_) { + this.$val = this; + if (arguments.length === 0) { + this.sparse = sliceType$2.nil; + this.dense = sliceType$2.nil; + this.size = 0; + this.nextIndex = 0; + return; + } + this.sparse = sparse_; + this.dense = dense_; + this.size = size_; + this.nextIndex = nextIndex_; + }); + runeSlice = $pkg.runeSlice = $newType(12, $kindSlice, "regexp.runeSlice", true, "regexp", false, null); + Regexp = $pkg.Regexp = $newType(0, $kindStruct, "regexp.Regexp", true, "regexp", true, function(expr_, prog_, onepass_, numSubexp_, maxBitStateLen_, subexpNames_, prefix_, prefixBytes_, prefixRune_, prefixEnd_, mpool_, matchcap_, prefixComplete_, cond_, longest_) { + this.$val = this; + if (arguments.length === 0) { + this.expr = ""; + this.prog = ptrType$12.nil; + this.onepass = ptrType$6.nil; + this.numSubexp = 0; + this.maxBitStateLen = 0; + this.subexpNames = sliceType$9.nil; + this.prefix = ""; + this.prefixBytes = sliceType$5.nil; + this.prefixRune = 0; + this.prefixEnd = 0; + this.mpool = 0; + this.matchcap = 0; + this.prefixComplete = false; + this.cond = 0; + this.longest = false; + return; + } + this.expr = expr_; + this.prog = prog_; + this.onepass = onepass_; + this.numSubexp = numSubexp_; + this.maxBitStateLen = maxBitStateLen_; + this.subexpNames = subexpNames_; + this.prefix = prefix_; + this.prefixBytes = prefixBytes_; + this.prefixRune = prefixRune_; + this.prefixEnd = prefixEnd_; + this.mpool = mpool_; + this.matchcap = matchcap_; + this.prefixComplete = prefixComplete_; + this.cond = cond_; + this.longest = longest_; + }); + input = $pkg.input = $newType(8, $kindInterface, "regexp.input", true, "regexp", false, null); + inputString = $pkg.inputString = $newType(0, $kindStruct, "regexp.inputString", true, "regexp", false, function(str_) { + this.$val = this; + if (arguments.length === 0) { + this.str = ""; + return; + } + this.str = str_; + }); + inputBytes = $pkg.inputBytes = $newType(0, $kindStruct, "regexp.inputBytes", true, "regexp", false, function(str_) { + this.$val = this; + if (arguments.length === 0) { + this.str = sliceType$5.nil; + return; + } + this.str = str_; + }); + inputReader = $pkg.inputReader = $newType(0, $kindStruct, "regexp.inputReader", true, "regexp", false, function(r_, atEOT_, pos_) { + this.$val = this; + if (arguments.length === 0) { + this.r = $ifaceNil; + this.atEOT = false; + this.pos = 0; + return; + } + this.r = r_; + this.atEOT = atEOT_; + this.pos = pos_; + }); + sliceType = $sliceType($emptyInterface); + arrayType = $arrayType($Int, 0); + arrayType$1 = $arrayType(nosync.Pool, 5); + arrayType$2 = $arrayType($Uint8, 16); + sliceType$1 = $sliceType($Int32); + sliceType$2 = $sliceType($Uint32); + ptrType = $ptrType(bitState); + sliceType$3 = $sliceType($Int); + sliceType$4 = $sliceType(job); + sliceType$5 = $sliceType($Uint8); + ptrType$1 = $ptrType(thread); + ptrType$2 = $ptrType(syntax.Inst); + ptrType$3 = $ptrType(lazyFlag); + ptrType$4 = $ptrType($Int); + ptrType$5 = $ptrType(onePassMachine); + ptrType$6 = $ptrType(onePassProg); + ptrType$7 = $ptrType(strings.Builder); + ptrType$8 = $ptrType(queueOnePass); + sliceType$6 = $sliceType(onePassInst); + ptrType$9 = $ptrType($Uint32); + sliceType$7 = $sliceType(sliceType$1); + ptrType$10 = $ptrType(sliceType$1); + sliceType$8 = $sliceType($Bool); + ptrType$11 = $ptrType(Regexp); + ptrType$12 = $ptrType(syntax.Prog); + sliceType$9 = $sliceType($String); + ptrType$13 = $ptrType(machine); + sliceType$10 = $sliceType(entry); + sliceType$11 = $sliceType(ptrType$1); + arrayType$3 = $arrayType($Int, 2); + arrayType$4 = $arrayType($Int, 4); + sliceType$12 = $sliceType(sliceType$5); + sliceType$13 = $sliceType(sliceType$3); + sliceType$14 = $sliceType(sliceType$12); + sliceType$15 = $sliceType(sliceType$9); + ptrType$14 = $ptrType(queue); + ptrType$15 = $ptrType(inputs); + funcType = $funcType([$String], [$String], false); + funcType$1 = $funcType([sliceType$5, sliceType$3], [sliceType$5], false); + funcType$2 = $funcType([sliceType$5], [sliceType$5], false); + funcType$3 = $funcType([sliceType$3], [], false); + ptrType$16 = $ptrType(inputString); + ptrType$17 = $ptrType(inputBytes); + ptrType$18 = $ptrType(inputReader); + newBitState = function() { + var _r, _tuple, b, ok, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; b = $f.b; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = bitStatePool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = $assertType(_r, ptrType, true); + b = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + b = new bitState.ptr(0, sliceType$3.nil, sliceType$3.nil, sliceType$4.nil, sliceType$2.nil, new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0))); + } + $s = -1; return b; + /* */ } return; } if ($f === undefined) { $f = { $blk: newBitState }; } $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f; + }; + freeBitState = function(b) { + var b; + b.inputs.clear(); + bitStatePool.Put(b); + }; + maxBitStateLen = function(prog) { + var _q, prog; + if (!shouldBacktrack(prog)) { + return 0; + } + return (_q = 262144 / prog.Inst.$length, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + }; + shouldBacktrack = function(prog) { + var prog; + return prog.Inst.$length <= 500; + }; + bitState.ptr.prototype.reset = function(prog, end, ncap) { + var _i, _i$1, _i$2, _q, _ref, _ref$1, _ref$2, b, end, i, i$1, i$2, ncap, prog, visitedSize, x, x$1, x$2; + b = this; + b.end = end; + if (b.jobs.$capacity === 0) { + b.jobs = $makeSlice(sliceType$4, 0, 256); + } else { + b.jobs = $subslice(b.jobs, 0, 0); + } + visitedSize = (_q = (((($imul(prog.Inst.$length, ((end + 1 >> 0)))) + 32 >> 0) - 1 >> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + if (b.visited.$capacity < visitedSize) { + b.visited = $makeSlice(sliceType$2, visitedSize, 8192); + } else { + b.visited = $subslice(b.visited, 0, visitedSize); + _ref = b.visited; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + (x = b.visited, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i] = 0)); + _i++; + } + } + if (b.cap.$capacity < ncap) { + b.cap = $makeSlice(sliceType$3, ncap); + } else { + b.cap = $subslice(b.cap, 0, ncap); + } + _ref$1 = b.cap; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + (x$1 = b.cap, ((i$1 < 0 || i$1 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i$1] = -1)); + _i$1++; + } + if (b.matchcap.$capacity < ncap) { + b.matchcap = $makeSlice(sliceType$3, ncap); + } else { + b.matchcap = $subslice(b.matchcap, 0, ncap); + } + _ref$2 = b.matchcap; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + (x$2 = b.matchcap, ((i$2 < 0 || i$2 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$2] = -1)); + _i$2++; + } + }; + bitState.prototype.reset = function(prog, end, ncap) { return this.$val.reset(prog, end, ncap); }; + bitState.ptr.prototype.shouldVisit = function(pc, pos) { + var _index, _q, _q$1, b, n, pc, pos, x, x$1, x$2, x$3, y, y$1; + b = this; + n = (((($imul(((pc >> 0)), ((b.end + 1 >> 0)))) + pos >> 0) >>> 0)); + if (!(((((x = b.visited, x$1 = (_q = n / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")), ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) & (((y = (((n & 31) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) { + return false; + } + _index = (_q$1 = n / 32, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + (x$3 = b.visited, ((_index < 0 || _index >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + _index] = (((x$2 = b.visited, ((_index < 0 || _index >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + _index])) | (((y$1 = (((n & 31) >>> 0)), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0))); + return true; + }; + bitState.prototype.shouldVisit = function(pc, pos) { return this.$val.shouldVisit(pc, pos); }; + bitState.ptr.prototype.push = function(re, pc, pos, arg) { + var arg, b, pc, pos, re, x; + b = this; + if (!(((x = re.prog.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])).Op === 5)) && (arg || b.shouldVisit(pc, pos))) { + b.jobs = $append(b.jobs, new job.ptr(pc, arg, pos)); + } + }; + bitState.prototype.push = function(re, pc, pos, arg) { return this.$val.push(re, pc, pos, arg); }; + Regexp.ptr.prototype.tryBacktrack = function(b, i, pc, pos) { + var _1, _2, _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, _tuple$2, _tuple$3, arg, b, flag, i, inst, l, longest, old, pc, pc$1, pos, pos$1, r, r$1, r$2, r$3, re, width, width$1, width$2, width$3, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; arg = $f.arg; b = $f.b; flag = $f.flag; i = $f.i; inst = $f.inst; l = $f.l; longest = $f.longest; old = $f.old; pc = $f.pc; pc$1 = $f.pc$1; pos = $f.pos; pos$1 = $f.pos$1; r = $f.r; r$1 = $f.r$1; r$2 = $f.r$2; r$3 = $f.r$3; re = $f.re; width = $f.width; width$1 = $f.width$1; width$2 = $f.width$2; width$3 = $f.width$3; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + longest = re.longest; + b.push(re, pc, pos, false); + /* while (true) { */ case 1: + /* if (!(b.jobs.$length > 0)) { break; } */ if(!(b.jobs.$length > 0)) { $s = 2; continue; } + l = b.jobs.$length - 1 >> 0; + pc$1 = (x = b.jobs, ((l < 0 || l >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + l])).pc; + pos$1 = (x$1 = b.jobs, ((l < 0 || l >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + l])).pos; + arg = (x$2 = b.jobs, ((l < 0 || l >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + l])).arg; + b.jobs = $subslice(b.jobs, 0, l); + /* goto Skip */ $s = 3; continue; + /* CheckAndLoop: */ case 4: + if (!b.shouldVisit(pc$1, pos$1)) { + /* continue; */ $s = 1; continue; + } + /* Skip: */ case 3: + inst = $clone((x$3 = re.prog.Inst, ((pc$1 < 0 || pc$1 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc$1])), syntax.Inst); + _1 = inst.Op; + /* */ if (_1 === (5)) { $s = 6; continue; } + /* */ if (_1 === (0)) { $s = 7; continue; } + /* */ if (_1 === (1)) { $s = 8; continue; } + /* */ if (_1 === (7)) { $s = 9; continue; } + /* */ if (_1 === (8)) { $s = 10; continue; } + /* */ if (_1 === (10)) { $s = 11; continue; } + /* */ if (_1 === (9)) { $s = 12; continue; } + /* */ if (_1 === (2)) { $s = 13; continue; } + /* */ if (_1 === (3)) { $s = 14; continue; } + /* */ if (_1 === (6)) { $s = 15; continue; } + /* */ if (_1 === (4)) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (_1 === (5)) { */ case 6: + $panic(new $String("unexpected InstFail")); + $s = 18; continue; + /* } else if (_1 === (0)) { */ case 7: + /* */ if (arg) { $s = 19; continue; } + /* */ $s = 20; continue; + /* if (arg) { */ case 19: + arg = false; + pc$1 = inst.Arg; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 21; continue; + /* } else { */ case 20: + b.push(re, pc$1, pos$1, true); + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + /* } */ case 21: + $s = 18; continue; + /* } else if (_1 === (1)) { */ case 8: + _2 = (x$4 = re.prog.Inst, x$5 = inst.Out, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])).Op; + /* */ if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10))) { $s = 23; continue; } + /* */ $s = 24; continue; + /* if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10))) { */ case 23: + b.push(re, inst.Arg, pos$1, false); + pc$1 = inst.Arg; + pos$1 = b.end; + /* goto CheckAndLoop */ $s = 4; continue; + /* } */ case 24: + case 22: + b.push(re, inst.Out, b.end, false); + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (7)) { */ case 9: + _r = i.step(pos$1); /* */ $s = 25; case 25: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + width = _tuple[1]; + /* */ if (!inst.MatchRune(r)) { $s = 26; continue; } + /* */ $s = 27; continue; + /* if (!inst.MatchRune(r)) { */ case 26: + /* continue; */ $s = 1; continue; + /* } */ case 27: + pos$1 = pos$1 + (width) >> 0; + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (8)) { */ case 10: + _r$1 = i.step(pos$1); /* */ $s = 28; case 28: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + r$1 = _tuple$1[0]; + width$1 = _tuple$1[1]; + /* */ if (!((r$1 === (x$6 = inst.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))))) { $s = 29; continue; } + /* */ $s = 30; continue; + /* if (!((r$1 === (x$6 = inst.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))))) { */ case 29: + /* continue; */ $s = 1; continue; + /* } */ case 30: + pos$1 = pos$1 + (width$1) >> 0; + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (10)) { */ case 11: + _r$2 = i.step(pos$1); /* */ $s = 31; case 31: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$2 = _r$2; + r$2 = _tuple$2[0]; + width$2 = _tuple$2[1]; + /* */ if ((r$2 === 10) || (r$2 === -1)) { $s = 32; continue; } + /* */ $s = 33; continue; + /* if ((r$2 === 10) || (r$2 === -1)) { */ case 32: + /* continue; */ $s = 1; continue; + /* } */ case 33: + pos$1 = pos$1 + (width$2) >> 0; + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (9)) { */ case 12: + _r$3 = i.step(pos$1); /* */ $s = 34; case 34: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$3 = _r$3; + r$3 = _tuple$3[0]; + width$3 = _tuple$3[1]; + /* */ if (r$3 === -1) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (r$3 === -1) { */ case 35: + /* continue; */ $s = 1; continue; + /* } */ case 36: + pos$1 = pos$1 + (width$3) >> 0; + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (2)) { */ case 13: + /* */ if (arg) { $s = 37; continue; } + /* */ $s = 38; continue; + /* if (arg) { */ case 37: + (x$7 = b.cap, x$8 = inst.Arg, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8] = pos$1)); + /* continue; */ $s = 1; continue; + $s = 39; continue; + /* } else { */ case 38: + if (0 <= inst.Arg && inst.Arg < ((b.cap.$length >>> 0))) { + b.push(re, pc$1, (x$9 = b.cap, x$10 = inst.Arg, ((x$10 < 0 || x$10 >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + x$10])), true); + (x$11 = b.cap, x$12 = inst.Arg, ((x$12 < 0 || x$12 >= x$11.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + x$12] = pos$1)); + } + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + /* } */ case 39: + $s = 18; continue; + /* } else if (_1 === (3)) { */ case 14: + _r$4 = i.context(pos$1); /* */ $s = 40; case 40: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + flag = _r$4; + /* */ if (!flag.match(((inst.Arg << 24 >>> 24)))) { $s = 41; continue; } + /* */ $s = 42; continue; + /* if (!flag.match(((inst.Arg << 24 >>> 24)))) { */ case 41: + /* continue; */ $s = 1; continue; + /* } */ case 42: + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (6)) { */ case 15: + pc$1 = inst.Out; + /* goto CheckAndLoop */ $s = 4; continue; + $s = 18; continue; + /* } else if (_1 === (4)) { */ case 16: + if (b.cap.$length === 0) { + $s = -1; return true; + } + if (b.cap.$length > 1) { + (x$13 = b.cap, (1 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 1] = pos$1)); + } + old = (x$14 = b.matchcap, (1 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 1])); + if ((old === -1) || (longest && pos$1 > 0 && pos$1 > old)) { + $copySlice(b.matchcap, b.cap); + } + if (!longest) { + $s = -1; return true; + } + if (pos$1 === b.end) { + $s = -1; return true; + } + /* continue; */ $s = 1; continue; + $s = 18; continue; + /* } else { */ case 17: + $panic(new $String("bad inst")); + /* } */ case 18: + case 5: + /* } */ $s = 1; continue; case 2: + $s = -1; return longest && b.matchcap.$length > 1 && (x$15 = b.matchcap, (1 >= x$15.$length ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + 1])) >= 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.tryBacktrack }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.arg = arg; $f.b = b; $f.flag = flag; $f.i = i; $f.inst = inst; $f.l = l; $f.longest = longest; $f.old = old; $f.pc = pc; $f.pc$1 = pc$1; $f.pos = pos; $f.pos$1 = pos$1; $f.r = r; $f.r$1 = r$1; $f.r$2 = r$2; $f.r$3 = r$3; $f.re = re; $f.width = width; $f.width$1 = width$1; $f.width$2 = width$2; $f.width$3 = width$3; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.tryBacktrack = function(b, i, pc, pos) { return this.$val.tryBacktrack(b, i, pc, pos); }; + Regexp.ptr.prototype.backtrack = function(ib, is, pos, ncap, dstCap) { + var _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, advance, b, dstCap, end, i, ib, is, ncap, pos, re, startCond, width, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; advance = $f.advance; b = $f.b; dstCap = $f.dstCap; end = $f.end; i = $f.i; ib = $f.ib; is = $f.is; ncap = $f.ncap; pos = $f.pos; re = $f.re; startCond = $f.startCond; width = $f.width; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + startCond = re.cond; + if (startCond === 255) { + $s = -1; return sliceType$3.nil; + } + if (!((((startCond & 4) >>> 0) === 0)) && !((pos === 0))) { + $s = -1; return sliceType$3.nil; + } + _r = newBitState(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + _tuple = b.inputs.init($ifaceNil, ib, is); + i = _tuple[0]; + end = _tuple[1]; + b.reset(re.prog, end, ncap); + /* */ if (!((((startCond & 4) >>> 0) === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((((startCond & 4) >>> 0) === 0))) { */ case 2: + if (b.cap.$length > 0) { + (x = b.cap, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = pos)); + } + _r$1 = re.tryBacktrack(b, i, ((re.prog.Start >>> 0)), pos); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!_r$1) { */ case 5: + freeBitState(b); + $s = -1; return sliceType$3.nil; + /* } */ case 6: + $s = 4; continue; + /* } else { */ case 3: + width = -1; + /* while (true) { */ case 8: + /* if (!(pos <= end && !((width === 0)))) { break; } */ if(!(pos <= end && !((width === 0)))) { $s = 9; continue; } + /* */ if (re.prefix.length > 0) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (re.prefix.length > 0) { */ case 10: + _r$2 = i.index(re, pos); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + advance = _r$2; + if (advance < 0) { + freeBitState(b); + $s = -1; return sliceType$3.nil; + } + pos = pos + (advance) >> 0; + /* } */ case 11: + if (b.cap.$length > 0) { + (x$1 = b.cap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = pos)); + } + _r$3 = re.tryBacktrack(b, i, ((re.prog.Start >>> 0)), pos); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (_r$3) { */ case 13: + /* goto Match */ $s = 16; continue; + /* } */ case 14: + _r$4 = i.step(pos); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$1 = _r$4; + width = _tuple$1[1]; + pos = pos + (width) >> 0; + /* } */ $s = 8; continue; case 9: + freeBitState(b); + $s = -1; return sliceType$3.nil; + /* } */ case 4: + /* Match: */ case 16: + dstCap = $appendSlice(dstCap, b.matchcap); + freeBitState(b); + $s = -1; return dstCap; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.backtrack }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.advance = advance; $f.b = b; $f.dstCap = dstCap; $f.end = end; $f.i = i; $f.ib = ib; $f.is = is; $f.ncap = ncap; $f.pos = pos; $f.re = re; $f.startCond = startCond; $f.width = width; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.backtrack = function(ib, is, pos, ncap, dstCap) { return this.$val.backtrack(ib, is, pos, ncap, dstCap); }; + inputs.ptr.prototype.newBytes = function(b) { + var b, i; + i = this; + i.bytes.str = b; + return i.bytes; + }; + inputs.prototype.newBytes = function(b) { return this.$val.newBytes(b); }; + inputs.ptr.prototype.newString = function(s) { + var i, s; + i = this; + i.string.str = s; + return i.string; + }; + inputs.prototype.newString = function(s) { return this.$val.newString(s); }; + inputs.ptr.prototype.newReader = function(r) { + var i, r; + i = this; + i.reader.r = r; + i.reader.atEOT = false; + i.reader.pos = 0; + return i.reader; + }; + inputs.prototype.newReader = function(r) { return this.$val.newReader(r); }; + inputs.ptr.prototype.clear = function() { + var i; + i = this; + if (!(i.bytes.str === sliceType$5.nil)) { + i.bytes.str = sliceType$5.nil; + } else if (!($interfaceIsEqual(i.reader.r, $ifaceNil))) { + i.reader.r = $ifaceNil; + } else { + i.string.str = ""; + } + }; + inputs.prototype.clear = function() { return this.$val.clear(); }; + inputs.ptr.prototype.init = function(r, b, s) { + var b, i, r, s; + i = this; + if (!($interfaceIsEqual(r, $ifaceNil))) { + return [i.newReader(r), 0]; + } + if (!(b === sliceType$5.nil)) { + return [i.newBytes(b), b.$length]; + } + return [i.newString(s), s.length]; + }; + inputs.prototype.init = function(r, b, s) { return this.$val.init(r, b, s); }; + machine.ptr.prototype.init = function(ncap) { + var _i, _ref, m, ncap, t; + m = this; + _ref = m.pool; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + t = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + t.cap = $subslice(t.cap, 0, ncap); + _i++; + } + m.matchcap = $subslice(m.matchcap, 0, ncap); + }; + machine.prototype.init = function(ncap) { return this.$val.init(ncap); }; + machine.ptr.prototype.alloc = function(i) { + var i, m, n, t, x, x$1; + m = this; + t = ptrType$1.nil; + n = m.pool.$length; + if (n > 0) { + t = (x = m.pool, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + m.pool = $subslice(m.pool, 0, (n - 1 >> 0)); + } else { + t = new thread.ptr(ptrType$2.nil, sliceType$3.nil); + t.cap = $makeSlice(sliceType$3, m.matchcap.$length, m.matchcap.$capacity); + } + t.inst = i; + return t; + }; + machine.prototype.alloc = function(i) { return this.$val.alloc(i); }; + newLazyFlag = function(r1, r2) { + var r1, r2, x, x$1, x$2; + return ((x = (x$1 = $shiftLeft64((new $Uint64(0, r1)), 32), x$2 = (new $Uint64(0, ((r2 >>> 0)))), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0)), new lazyFlag(x.$high, x.$low))); + }; + lazyFlag.prototype.match = function(op) { + var f, op, r1, r2; + f = this; + if (op === 0) { + return true; + } + r1 = (($shiftRightUint64(f, 32).$low >> 0)); + if (!((((op & 1) >>> 0) === 0))) { + if (!((r1 === 10)) && r1 >= 0) { + return false; + } + op = (op & ~(1)) << 24 >>> 24; + } + if (!((((op & 4) >>> 0) === 0))) { + if (r1 >= 0) { + return false; + } + op = (op & ~(4)) << 24 >>> 24; + } + if (op === 0) { + return true; + } + r2 = ((f.$low >> 0)); + if (!((((op & 2) >>> 0) === 0))) { + if (!((r2 === 10)) && r2 >= 0) { + return false; + } + op = (op & ~(2)) << 24 >>> 24; + } + if (!((((op & 8) >>> 0) === 0))) { + if (r2 >= 0) { + return false; + } + op = (op & ~(8)) << 24 >>> 24; + } + if (op === 0) { + return true; + } + if (!(syntax.IsWordChar(r1) === syntax.IsWordChar(r2))) { + op = (op & ~(16)) << 24 >>> 24; + } else { + op = (op & ~(32)) << 24 >>> 24; + } + return op === 0; + }; + $ptrType(lazyFlag).prototype.match = function(op) { return this.$get().match(op); }; + machine.ptr.prototype.match = function(i, pos) { + var _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _v, advance, flag, i, i$1, m, nextq, pos, r, r1, runq, startCond, width, width1, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _v = $f._v; advance = $f.advance; flag = $f.flag; i = $f.i; i$1 = $f.i$1; m = $f.m; nextq = $f.nextq; pos = $f.pos; r = $f.r; r1 = $f.r1; runq = $f.runq; startCond = $f.startCond; width = $f.width; width1 = $f.width1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + flag = [flag]; + m = this; + startCond = m.re.cond; + if (startCond === 255) { + $s = -1; return false; + } + m.matched = false; + _ref = m.matchcap; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i$1 = _i; + (x = m.matchcap, ((i$1 < 0 || i$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i$1] = -1)); + _i++; + } + _tmp = m.q0; + _tmp$1 = m.q1; + runq = _tmp; + nextq = _tmp$1; + _tmp$2 = -1; + _tmp$3 = -1; + r = _tmp$2; + r1 = _tmp$3; + _tmp$4 = 0; + _tmp$5 = 0; + width = _tmp$4; + width1 = _tmp$5; + _r = i.step(pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + width = _tuple[1]; + /* */ if (!((r === -1))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((r === -1))) { */ case 2: + _r$1 = i.step(pos + width >> 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + r1 = _tuple$1[0]; + width1 = _tuple$1[1]; + /* } */ case 3: + flag[0] = new lazyFlag(0, 0); + /* */ if (pos === 0) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (pos === 0) { */ case 5: + flag[0] = newLazyFlag(-1, r); + $s = 7; continue; + /* } else { */ case 6: + _r$2 = i.context(pos); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + flag[0] = _r$2; + /* } */ case 7: + /* while (true) { */ case 9: + /* */ if (runq.dense.$length === 0) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (runq.dense.$length === 0) { */ case 11: + if (!((((startCond & 4) >>> 0) === 0)) && !((pos === 0))) { + /* break; */ $s = 10; continue; + } + if (m.matched) { + /* break; */ $s = 10; continue; + } + if (!(m.re.prefix.length > 0 && !((r1 === m.re.prefixRune)))) { _v = false; $s = 15; continue s; } + _r$3 = i.canCheckPrefix(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _v = _r$3; case 15: + /* */ if (_v) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (_v) { */ case 13: + _r$4 = i.index(m.re, pos); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + advance = _r$4; + if (advance < 0) { + /* break; */ $s = 10; continue; + } + pos = pos + (advance) >> 0; + _r$5 = i.step(pos); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$2 = _r$5; + r = _tuple$2[0]; + width = _tuple$2[1]; + _r$6 = i.step(pos + width >> 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple$3 = _r$6; + r1 = _tuple$3[0]; + width1 = _tuple$3[1]; + /* } */ case 14: + /* } */ case 12: + if (!m.matched) { + if (m.matchcap.$length > 0) { + (x$1 = m.matchcap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = pos)); + } + m.add(runq, ((m.p.Start >>> 0)), pos, m.matchcap, (flag.$ptr || (flag.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, flag))), ptrType$1.nil); + } + flag[0] = newLazyFlag(r, r1); + m.step(runq, nextq, pos, pos + width >> 0, r, (flag.$ptr || (flag.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, flag)))); + if (width === 0) { + /* break; */ $s = 10; continue; + } + if ((m.matchcap.$length === 0) && m.matched) { + /* break; */ $s = 10; continue; + } + pos = pos + (width) >> 0; + _tmp$6 = r1; + _tmp$7 = width1; + r = _tmp$6; + width = _tmp$7; + /* */ if (!((r === -1))) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (!((r === -1))) { */ case 20: + _r$7 = i.step(pos + width >> 0); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _tuple$4 = _r$7; + r1 = _tuple$4[0]; + width1 = _tuple$4[1]; + /* } */ case 21: + _tmp$8 = nextq; + _tmp$9 = runq; + runq = _tmp$8; + nextq = _tmp$9; + /* } */ $s = 9; continue; case 10: + m.clear(nextq); + $s = -1; return m.matched; + /* */ } return; } if ($f === undefined) { $f = { $blk: machine.ptr.prototype.match }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._v = _v; $f.advance = advance; $f.flag = flag; $f.i = i; $f.i$1 = i$1; $f.m = m; $f.nextq = nextq; $f.pos = pos; $f.r = r; $f.r1 = r1; $f.runq = runq; $f.startCond = startCond; $f.width = width; $f.width1 = width1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + machine.prototype.match = function(i, pos) { return this.$val.match(i, pos); }; + machine.ptr.prototype.clear = function(q) { + var _i, _ref, d, m, q; + m = this; + _ref = q.dense; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + d = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), entry); + if (!(d.t === ptrType$1.nil)) { + m.pool = $append(m.pool, d.t); + } + _i++; + } + q.dense = $subslice(q.dense, 0, 0); + }; + machine.prototype.clear = function(q) { return this.$val.clear(q); }; + machine.ptr.prototype.step = function(runq, nextq, pos, nextPos, c, nextCond) { + var _1, _i, _ref, add, c, d, d$1, i, j, longest, m, nextCond, nextPos, nextq, pos, runq, t, x, x$1, x$2, x$3, x$4, x$5; + m = this; + longest = m.re.longest; + j = 0; + while (true) { + if (!(j < runq.dense.$length)) { break; } + d = (x = runq.dense, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); + t = d.t; + if (t === ptrType$1.nil) { + j = j + (1) >> 0; + continue; + } + if (longest && m.matched && t.cap.$length > 0 && (x$1 = m.matchcap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) < (x$2 = t.cap, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))) { + m.pool = $append(m.pool, t); + j = j + (1) >> 0; + continue; + } + i = t.inst; + add = false; + _1 = i.Op; + if (_1 === (4)) { + if (t.cap.$length > 0 && (!longest || !m.matched || (x$3 = m.matchcap, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1])) < pos)) { + (x$4 = t.cap, (1 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 1] = pos)); + $copySlice(m.matchcap, t.cap); + } + if (!longest) { + _ref = $subslice(runq.dense, (j + 1 >> 0)); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + d$1 = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), entry); + if (!(d$1.t === ptrType$1.nil)) { + m.pool = $append(m.pool, d$1.t); + } + _i++; + } + runq.dense = $subslice(runq.dense, 0, 0); + } + m.matched = true; + } else if (_1 === (7)) { + add = i.MatchRune(c); + } else if (_1 === (8)) { + add = c === (x$5 = i.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0])); + } else if (_1 === (9)) { + add = true; + } else if (_1 === (10)) { + add = !((c === 10)); + } else { + $panic(new $String("bad inst")); + } + if (add) { + t = m.add(nextq, i.Out, nextPos, t.cap, nextCond, t); + } + if (!(t === ptrType$1.nil)) { + m.pool = $append(m.pool, t); + } + j = j + (1) >> 0; + } + runq.dense = $subslice(runq.dense, 0, 0); + }; + machine.prototype.step = function(runq, nextq, pos, nextPos, c, nextCond) { return this.$val.step(runq, nextq, pos, nextPos, c, nextCond); }; + machine.ptr.prototype.add = function(q, pc, pos, cap, cond, t) { + var _1, cap, cond, d, i, j, j$1, m, opos, pc, pos, q, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, $s; + /* */ $s = 0; s: while (true) { switch ($s) { case 0: + m = this; + /* Again: */ case 1: + if (pc === 0) { + $s = -1; return t; + } + j = (x = q.sparse, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); + if (j < ((q.dense.$length >>> 0)) && ((x$1 = q.dense, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])).pc === pc)) { + $s = -1; return t; + } + j$1 = q.dense.$length; + q.dense = $subslice(q.dense, 0, (j$1 + 1 >> 0)); + d = (x$2 = q.dense, ((j$1 < 0 || j$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j$1])); + d.t = ptrType$1.nil; + d.pc = pc; + (x$3 = q.sparse, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc] = ((j$1 >>> 0)))); + i = (x$4 = m.p.Inst, ((pc < 0 || pc >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + pc])); + _1 = i.Op; + /* */ if (_1 === (5)) { $s = 3; continue; } + /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 4; continue; } + /* */ if (_1 === (3)) { $s = 5; continue; } + /* */ if (_1 === (6)) { $s = 6; continue; } + /* */ if (_1 === (2)) { $s = 7; continue; } + /* */ if ((_1 === (4)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10))) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_1 === (5)) { */ case 3: + $s = 10; continue; + /* } else if ((_1 === (0)) || (_1 === (1))) { */ case 4: + t = m.add(q, i.Out, pos, cap, cond, t); + pc = i.Arg; + /* goto Again */ $s = 1; continue; + $s = 10; continue; + /* } else if (_1 === (3)) { */ case 5: + /* */ if (cond.match(((i.Arg << 24 >>> 24)))) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (cond.match(((i.Arg << 24 >>> 24)))) { */ case 11: + pc = i.Out; + /* goto Again */ $s = 1; continue; + /* } */ case 12: + $s = 10; continue; + /* } else if (_1 === (6)) { */ case 6: + pc = i.Out; + /* goto Again */ $s = 1; continue; + $s = 10; continue; + /* } else if (_1 === (2)) { */ case 7: + /* */ if (((i.Arg >> 0)) < cap.$length) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (((i.Arg >> 0)) < cap.$length) { */ case 13: + opos = (x$5 = i.Arg, ((x$5 < 0 || x$5 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$5])); + (x$6 = i.Arg, ((x$6 < 0 || x$6 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$6] = pos)); + m.add(q, i.Out, pos, cap, cond, ptrType$1.nil); + (x$7 = i.Arg, ((x$7 < 0 || x$7 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$7] = opos)); + $s = 15; continue; + /* } else { */ case 14: + pc = i.Out; + /* goto Again */ $s = 1; continue; + /* } */ case 15: + $s = 10; continue; + /* } else if ((_1 === (4)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10))) { */ case 8: + if (t === ptrType$1.nil) { + t = m.alloc(i); + } else { + t.inst = i; + } + if (cap.$length > 0 && !((x$8 = t.cap, $indexPtr(x$8.$array, x$8.$offset + 0, ptrType$4)) === $indexPtr(cap.$array, cap.$offset + 0, ptrType$4))) { + $copySlice(t.cap, cap); + } + d.t = t; + t = ptrType$1.nil; + $s = 10; continue; + /* } else { */ case 9: + $panic(new $String("unhandled")); + /* } */ case 10: + case 2: + $s = -1; return t; + /* */ } return; } + }; + machine.prototype.add = function(q, pc, pos, cap, cond, t) { return this.$val.add(q, pc, pos, cap, cond, t); }; + newOnePassMachine = function() { + var _r, _tuple, m, ok, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; m = $f.m; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = onePassPool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = $assertType(_r, ptrType$5, true); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = new onePassMachine.ptr(new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)), sliceType$3.nil); + } + $s = -1; return m; + /* */ } return; } if ($f === undefined) { $f = { $blk: newOnePassMachine }; } $f._r = _r; $f._tuple = _tuple; $f.m = m; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f; + }; + freeOnePassMachine = function(m) { + var m; + m.inputs.clear(); + onePassPool.Put(m); + }; + Regexp.ptr.prototype.doOnePass = function(ir, ib, is, pos, ncap, dstCap) { + var _1, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _v, dstCap, flag, i, i$1, ib, inst, ir, is, m, matched, ncap, pc, pos, r, r1, re, startCond, width, width1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _v = $f._v; dstCap = $f.dstCap; flag = $f.flag; i = $f.i; i$1 = $f.i$1; ib = $f.ib; inst = $f.inst; ir = $f.ir; is = $f.is; m = $f.m; matched = $f.matched; ncap = $f.ncap; pc = $f.pc; pos = $f.pos; r = $f.r; r1 = $f.r1; re = $f.re; startCond = $f.startCond; width = $f.width; width1 = $f.width1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + inst = [inst]; + re = this; + startCond = re.cond; + if (startCond === 255) { + $s = -1; return sliceType$3.nil; + } + _r = newOnePassMachine(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + m = _r; + if (m.matchcap.$capacity < ncap) { + m.matchcap = $makeSlice(sliceType$3, ncap); + } else { + m.matchcap = $subslice(m.matchcap, 0, ncap); + } + matched = false; + _ref = m.matchcap; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + (x = m.matchcap, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i] = -1)); + _i++; + } + _tuple = m.inputs.init(ir, ib, is); + i$1 = _tuple[0]; + _tmp = -1; + _tmp$1 = -1; + r = _tmp; + r1 = _tmp$1; + _tmp$2 = 0; + _tmp$3 = 0; + width = _tmp$2; + width1 = _tmp$3; + _r$1 = i$1.step(pos); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + r = _tuple$1[0]; + width = _tuple$1[1]; + /* */ if (!((r === -1))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!((r === -1))) { */ case 3: + _r$2 = i$1.step(pos + width >> 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$2 = _r$2; + r1 = _tuple$2[0]; + width1 = _tuple$2[1]; + /* } */ case 4: + flag = new lazyFlag(0, 0); + /* */ if (pos === 0) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (pos === 0) { */ case 6: + flag = newLazyFlag(-1, r); + $s = 8; continue; + /* } else { */ case 7: + _r$3 = i$1.context(pos); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + flag = _r$3; + /* } */ case 8: + pc = re.onepass.Start; + inst[0] = $clone((x$1 = re.onepass.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])), onePassInst); + if (!((pos === 0) && flag.match(((inst[0].Inst.Arg << 24 >>> 24))) && re.prefix.length > 0)) { _v = false; $s = 12; continue s; } + _r$4 = i$1.canCheckPrefix(); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _v = _r$4; case 12: + /* */ if (_v) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_v) { */ case 10: + _r$5 = i$1.hasPrefix(re); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ if (!_r$5) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (!_r$5) { */ case 14: + /* goto Return */ $s = 17; continue; + /* } */ case 15: + pos = pos + (re.prefix.length) >> 0; + _r$6 = i$1.step(pos); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _tuple$3 = _r$6; + r = _tuple$3[0]; + width = _tuple$3[1]; + _r$7 = i$1.step(pos + width >> 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _tuple$4 = _r$7; + r1 = _tuple$4[0]; + width1 = _tuple$4[1]; + _r$8 = i$1.context(pos); /* */ $s = 20; case 20: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + flag = _r$8; + pc = ((re.prefixEnd >> 0)); + /* } */ case 11: + /* while (true) { */ case 21: + onePassInst.copy(inst[0], (x$2 = re.onepass.Inst, ((pc < 0 || pc >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pc]))); + pc = ((inst[0].Inst.Out >> 0)); + _1 = inst[0].Inst.Op; + /* */ if (_1 === (4)) { $s = 24; continue; } + /* */ if (_1 === (7)) { $s = 25; continue; } + /* */ if (_1 === (8)) { $s = 26; continue; } + /* */ if (_1 === (9)) { $s = 27; continue; } + /* */ if (_1 === (10)) { $s = 28; continue; } + /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 29; continue; } + /* */ if (_1 === (5)) { $s = 30; continue; } + /* */ if (_1 === (6)) { $s = 31; continue; } + /* */ if (_1 === (3)) { $s = 32; continue; } + /* */ if (_1 === (2)) { $s = 33; continue; } + /* */ $s = 34; continue; + /* if (_1 === (4)) { */ case 24: + matched = true; + if (m.matchcap.$length > 0) { + (x$3 = m.matchcap, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = 0)); + (x$4 = m.matchcap, (1 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 1] = pos)); + } + /* goto Return */ $s = 17; continue; + $s = 35; continue; + /* } else if (_1 === (7)) { */ case 25: + /* */ if (!inst[0].Inst.MatchRune(r)) { $s = 36; continue; } + /* */ $s = 37; continue; + /* if (!inst[0].Inst.MatchRune(r)) { */ case 36: + /* goto Return */ $s = 17; continue; + /* } */ case 37: + $s = 35; continue; + /* } else if (_1 === (8)) { */ case 26: + /* */ if (!((r === (x$5 = inst[0].Inst.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0]))))) { $s = 38; continue; } + /* */ $s = 39; continue; + /* if (!((r === (x$5 = inst[0].Inst.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0]))))) { */ case 38: + /* goto Return */ $s = 17; continue; + /* } */ case 39: + $s = 35; continue; + /* } else if (_1 === (9)) { */ case 27: + $s = 35; continue; + /* } else if (_1 === (10)) { */ case 28: + /* */ if (r === 10) { $s = 40; continue; } + /* */ $s = 41; continue; + /* if (r === 10) { */ case 40: + /* goto Return */ $s = 17; continue; + /* } */ case 41: + $s = 35; continue; + /* } else if ((_1 === (0)) || (_1 === (1))) { */ case 29: + pc = ((onePassNext(inst[0], r) >> 0)); + /* continue; */ $s = 21; continue; + $s = 35; continue; + /* } else if (_1 === (5)) { */ case 30: + /* goto Return */ $s = 17; continue; + $s = 35; continue; + /* } else if (_1 === (6)) { */ case 31: + /* continue; */ $s = 21; continue; + $s = 35; continue; + /* } else if (_1 === (3)) { */ case 32: + /* */ if (!flag.match(((inst[0].Inst.Arg << 24 >>> 24)))) { $s = 42; continue; } + /* */ $s = 43; continue; + /* if (!flag.match(((inst[0].Inst.Arg << 24 >>> 24)))) { */ case 42: + /* goto Return */ $s = 17; continue; + /* } */ case 43: + /* continue; */ $s = 21; continue; + $s = 35; continue; + /* } else if (_1 === (2)) { */ case 33: + if (((inst[0].Inst.Arg >> 0)) < m.matchcap.$length) { + (x$6 = m.matchcap, x$7 = inst[0].Inst.Arg, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7] = pos)); + } + /* continue; */ $s = 21; continue; + $s = 35; continue; + /* } else { */ case 34: + $panic(new $String("bad inst")); + /* } */ case 35: + case 23: + if (width === 0) { + /* break; */ $s = 22; continue; + } + flag = newLazyFlag(r, r1); + pos = pos + (width) >> 0; + _tmp$4 = r1; + _tmp$5 = width1; + r = _tmp$4; + width = _tmp$5; + /* */ if (!((r === -1))) { $s = 44; continue; } + /* */ $s = 45; continue; + /* if (!((r === -1))) { */ case 44: + _r$9 = i$1.step(pos + width >> 0); /* */ $s = 46; case 46: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _tuple$5 = _r$9; + r1 = _tuple$5[0]; + width1 = _tuple$5[1]; + /* } */ case 45: + /* } */ $s = 21; continue; case 22: + /* Return: */ case 17: + if (!matched) { + freeOnePassMachine(m); + $s = -1; return sliceType$3.nil; + } + dstCap = $appendSlice(dstCap, m.matchcap); + freeOnePassMachine(m); + $s = -1; return dstCap; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doOnePass }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._v = _v; $f.dstCap = dstCap; $f.flag = flag; $f.i = i; $f.i$1 = i$1; $f.ib = ib; $f.inst = inst; $f.ir = ir; $f.is = is; $f.m = m; $f.matched = matched; $f.ncap = ncap; $f.pc = pc; $f.pos = pos; $f.r = r; $f.r1 = r1; $f.re = re; $f.startCond = startCond; $f.width = width; $f.width1 = width1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.doOnePass = function(ir, ib, is, pos, ncap, dstCap) { return this.$val.doOnePass(ir, ib, is, pos, ncap, dstCap); }; + Regexp.ptr.prototype.doMatch = function(r, b, s) { + var _r, b, r, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; r = $f.r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doExecute(r, b, s, 0, 0, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return !(_r === sliceType$3.nil); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doMatch }; } $f._r = _r; $f.b = b; $f.r = r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.doMatch = function(r, b, s) { return this.$val.doMatch(r, b, s); }; + Regexp.ptr.prototype.doExecute = function(r, b, s, pos, ncap, dstCap) { + var _r, _r$1, _r$2, _r$3, _tuple, b, dstCap, i, m, ncap, pos, r, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; b = $f.b; dstCap = $f.dstCap; i = $f.i; m = $f.m; ncap = $f.ncap; pos = $f.pos; r = $f.r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + if (dstCap === sliceType$3.nil) { + dstCap = $subslice(new sliceType$3(arrayNoInts), 0, 0, 0); + } + /* */ if (!(re.onepass === ptrType$6.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(re.onepass === ptrType$6.nil)) { */ case 1: + _r = re.doOnePass(r, b, s, pos, ncap, dstCap); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + /* */ if ($interfaceIsEqual(r, $ifaceNil) && (b.$length + s.length >> 0) < re.maxBitStateLen) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ($interfaceIsEqual(r, $ifaceNil) && (b.$length + s.length >> 0) < re.maxBitStateLen) { */ case 4: + _r$1 = re.backtrack(b, s, pos, ncap, dstCap); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 5: + _r$2 = re.get(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + m = _r$2; + _tuple = m.inputs.init(r, b, s); + i = _tuple[0]; + m.init(ncap); + _r$3 = m.match(i, pos); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!_r$3) { */ case 8: + re.put(m); + $s = -1; return sliceType$3.nil; + /* } */ case 9: + dstCap = $appendSlice(dstCap, m.matchcap); + re.put(m); + $s = -1; return dstCap; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doExecute }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.b = b; $f.dstCap = dstCap; $f.i = i; $f.m = m; $f.ncap = ncap; $f.pos = pos; $f.r = r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.doExecute = function(r, b, s, pos, ncap, dstCap) { return this.$val.doExecute(r, b, s, pos, ncap, dstCap); }; + onePassPrefix = function(p) { + var _tmp, _tmp$1, _tmp$10, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, buf, complete, i, p, pc, prefix, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; + prefix = ""; + complete = false; + pc = 0; + i = (x = p.Inst, x$1 = p.Start, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + if (!((i.Op === 3)) || ((((((i.Arg << 24 >>> 24))) & 4) >>> 0) === 0)) { + _tmp = ""; + _tmp$1 = i.Op === 4; + _tmp$2 = ((p.Start >>> 0)); + prefix = _tmp; + complete = _tmp$1; + pc = _tmp$2; + return [prefix, complete, pc]; + } + pc = i.Out; + i = (x$2 = p.Inst, ((pc < 0 || pc >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pc])); + while (true) { + if (!(i.Op === 6)) { break; } + pc = i.Out; + i = (x$3 = p.Inst, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc])); + } + if (!((iop(i) === 7)) || !((i.Rune.$length === 1))) { + _tmp$3 = ""; + _tmp$4 = i.Op === 4; + _tmp$5 = ((p.Start >>> 0)); + prefix = _tmp$3; + complete = _tmp$4; + pc = _tmp$5; + return [prefix, complete, pc]; + } + buf = new strings.Builder.ptr(ptrType$7.nil, sliceType$5.nil); + while (true) { + if (!((iop(i) === 7) && (i.Rune.$length === 1) && (((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { break; } + buf.WriteRune((x$4 = i.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0]))); + _tmp$6 = i.Out; + _tmp$7 = (x$5 = p.Inst, x$6 = i.Out, ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6])); + pc = _tmp$6; + i = _tmp$7; + } + if ((i.Op === 3) && !((((((i.Arg << 24 >>> 24)) & 8) >>> 0) === 0)) && ((x$7 = p.Inst, x$8 = i.Out, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8])).Op === 4)) { + complete = true; + } + _tmp$8 = buf.String(); + _tmp$9 = complete; + _tmp$10 = pc; + prefix = _tmp$8; + complete = _tmp$9; + pc = _tmp$10; + return [prefix, complete, pc]; + }; + onePassNext = function(i, r) { + var i, next, r, x; + next = i.Inst.MatchRunePos(r); + if (next >= 0) { + return (x = i.Next, ((next < 0 || next >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + next])); + } + if (i.Inst.Op === 1) { + return i.Inst.Out; + } + return 0; + }; + iop = function(i) { + var _1, i, op; + op = i.Op; + _1 = op; + if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { + op = 7; + } + return op; + }; + queueOnePass.ptr.prototype.empty = function() { + var q; + q = this; + return q.nextIndex >= q.size; + }; + queueOnePass.prototype.empty = function() { return this.$val.empty(); }; + queueOnePass.ptr.prototype.next = function() { + var n, q, x, x$1; + n = 0; + q = this; + n = (x = q.dense, x$1 = q.nextIndex, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + q.nextIndex = q.nextIndex + (1) >>> 0; + return n; + }; + queueOnePass.prototype.next = function() { return this.$val.next(); }; + queueOnePass.ptr.prototype.clear = function() { + var q; + q = this; + q.size = 0; + q.nextIndex = 0; + }; + queueOnePass.prototype.clear = function() { return this.$val.clear(); }; + queueOnePass.ptr.prototype.contains = function(u) { + var q, u, x, x$1, x$2, x$3; + q = this; + if (u >= ((q.sparse.$length >>> 0))) { + return false; + } + return (x = q.sparse, ((u < 0 || u >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + u])) < q.size && ((x$1 = q.dense, x$2 = (x$3 = q.sparse, ((u < 0 || u >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + u])), ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === u); + }; + queueOnePass.prototype.contains = function(u) { return this.$val.contains(u); }; + queueOnePass.ptr.prototype.insert = function(u) { + var q, u; + q = this; + if (!q.contains(u)) { + q.insertNew(u); + } + }; + queueOnePass.prototype.insert = function(u) { return this.$val.insert(u); }; + queueOnePass.ptr.prototype.insertNew = function(u) { + var q, u, x, x$1, x$2; + q = this; + if (u >= ((q.sparse.$length >>> 0))) { + return; + } + (x = q.sparse, ((u < 0 || u >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + u] = q.size)); + (x$1 = q.dense, x$2 = q.size, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2] = u)); + q.size = q.size + (1) >>> 0; + }; + queueOnePass.prototype.insertNew = function(u) { return this.$val.insertNew(u); }; + newQueue = function(size) { + var q, size; + q = ptrType$8.nil; + q = new queueOnePass.ptr($makeSlice(sliceType$2, size), $makeSlice(sliceType$2, size), 0, 0); + return q; + }; + mergeRuneSets = function(leftRunes, rightRunes, leftPC, rightPC) { + var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, extend, ix, leftLen, leftPC, leftRunes, lx, merged, next, ok, rightLen, rightPC, rightRunes, rx, x, x$1, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; extend = $f.extend; ix = $f.ix; leftLen = $f.leftLen; leftPC = $f.leftPC; leftRunes = $f.leftRunes; lx = $f.lx; merged = $f.merged; next = $f.next; ok = $f.ok; rightLen = $f.rightLen; rightPC = $f.rightPC; rightRunes = $f.rightRunes; rx = $f.rx; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + ix = [ix]; + lx = [lx]; + merged = [merged]; + next = [next]; + ok = [ok]; + rx = [rx]; + leftLen = leftRunes.$get().$length; + rightLen = rightRunes.$get().$length; + if (!(((leftLen & 1) === 0)) || !(((rightLen & 1) === 0))) { + $panic(new $String("mergeRuneSets odd length []rune")); + } + _tmp = 0; + _tmp$1 = 0; + lx[0] = _tmp; + rx[0] = _tmp$1; + merged[0] = $makeSlice(sliceType$1, 0); + next[0] = $makeSlice(sliceType$2, 0); + ok[0] = true; + $deferred.push([(function(ix, lx, merged, next, ok, rx) { return function() { + if (!ok[0]) { + merged[0] = sliceType$1.nil; + next[0] = sliceType$2.nil; + } + }; })(ix, lx, merged, next, ok, rx), []]); + ix[0] = -1; + extend = (function(ix, lx, merged, next, ok, rx) { return function(newLow, newArray, pc) { + var newArray, newLow, pc, x, x$1, x$2, x$3, x$4, x$5; + if (ix[0] > 0 && (x = newArray.$get(), x$1 = newLow.$get(), ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) <= ((ix[0] < 0 || ix[0] >= merged[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : merged[0].$array[merged[0].$offset + ix[0]])) { + return false; + } + merged[0] = $append(merged[0], (x$2 = newArray.$get(), x$3 = newLow.$get(), ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])), (x$4 = newArray.$get(), x$5 = newLow.$get() + 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5]))); + newLow.$set(newLow.$get() + (2) >> 0); + ix[0] = ix[0] + (2) >> 0; + next[0] = $append(next[0], pc); + return true; + }; })(ix, lx, merged, next, ok, rx); + /* while (true) { */ case 1: + /* if (!(lx[0] < leftLen || rx[0] < rightLen)) { break; } */ if(!(lx[0] < leftLen || rx[0] < rightLen)) { $s = 2; continue; } + /* */ if (rx[0] >= rightLen) { $s = 4; continue; } + /* */ if (lx[0] >= leftLen) { $s = 5; continue; } + /* */ if ((x = rightRunes.$get(), ((rx[0] < 0 || rx[0] >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + rx[0]])) < (x$1 = leftRunes.$get(), ((lx[0] < 0 || lx[0] >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + lx[0]]))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (rx[0] >= rightLen) { */ case 4: + _r = extend((lx.$ptr || (lx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, lx))), leftRunes, leftPC); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ok[0] = _r; + $s = 8; continue; + /* } else if (lx[0] >= leftLen) { */ case 5: + _r$1 = extend((rx.$ptr || (rx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, rx))), rightRunes, rightPC); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ok[0] = _r$1; + $s = 8; continue; + /* } else if ((x = rightRunes.$get(), ((rx[0] < 0 || rx[0] >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + rx[0]])) < (x$1 = leftRunes.$get(), ((lx[0] < 0 || lx[0] >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + lx[0]]))) { */ case 6: + _r$2 = extend((rx.$ptr || (rx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, rx))), rightRunes, rightPC); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + ok[0] = _r$2; + $s = 8; continue; + /* } else { */ case 7: + _r$3 = extend((lx.$ptr || (lx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, lx))), leftRunes, leftPC); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ok[0] = _r$3; + /* } */ case 8: + case 3: + if (!ok[0]) { + $s = -1; return [noRune, noNext]; + } + /* } */ $s = 1; continue; case 2: + $s = -1; return [merged[0], next[0]]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [sliceType$1.nil, sliceType$2.nil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mergeRuneSets }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.extend = extend; $f.ix = ix; $f.leftLen = leftLen; $f.leftPC = leftPC; $f.leftRunes = leftRunes; $f.lx = lx; $f.merged = merged; $f.next = next; $f.ok = ok; $f.rightLen = rightLen; $f.rightPC = rightPC; $f.rightRunes = rightRunes; $f.rx = rx; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + cleanupOnePass = function(prog, original) { + var _1, _i, _ref, instOriginal, ix, original, prog, x, x$1, x$2; + _ref = original.Inst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + ix = _i; + instOriginal = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); + _1 = instOriginal.Op; + if ((_1 === (0)) || (_1 === (1)) || (_1 === (7))) { + } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (6)) || (_1 === (4)) || (_1 === (5))) { + (x = prog.Inst, ((ix < 0 || ix >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + ix])).Next = sliceType$2.nil; + } else if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { + (x$1 = prog.Inst, ((ix < 0 || ix >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + ix])).Next = sliceType$2.nil; + onePassInst.copy((x$2 = prog.Inst, ((ix < 0 || ix >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + ix])), new onePassInst.ptr($clone(instOriginal, syntax.Inst), sliceType$2.nil)); + } + _i++; + } + }; + onePassCopy = function(prog) { + var _1, _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, i, inst, instAlt, instOther, p, p_A_Alt, p_A_Other, p_B_Alt, p_B_Other, patch, pc, prog, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + p = new onePassProg.ptr($makeSlice(sliceType$6, prog.Inst.$length), prog.Start, prog.NumCap); + _ref = prog.Inst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + inst = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); + onePassInst.copy((x = p.Inst, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])), new onePassInst.ptr($clone(inst, syntax.Inst), sliceType$2.nil)); + _i++; + } + _ref$1 = p.Inst; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + pc = _i$1; + _1 = (x$1 = p.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])).Inst.Op; + if ((_1 === (0)) || (_1 === (1))) { + p_A_Other = (x$2 = (x$3 = p.Inst, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc])), (x$2.$ptr_Out || (x$2.$ptr_Out = new ptrType$9(function() { return this.$target.Inst.Out; }, function($v) { this.$target.Inst.Out = $v; }, x$2)))); + p_A_Alt = (x$4 = (x$5 = p.Inst, ((pc < 0 || pc >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + pc])), (x$4.$ptr_Arg || (x$4.$ptr_Arg = new ptrType$9(function() { return this.$target.Inst.Arg; }, function($v) { this.$target.Inst.Arg = $v; }, x$4)))); + instAlt = $clone((x$6 = p.Inst, x$7 = p_A_Alt.$get(), ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])), onePassInst); + if (!((instAlt.Inst.Op === 0) || (instAlt.Inst.Op === 1))) { + _tmp = p_A_Other; + _tmp$1 = p_A_Alt; + p_A_Alt = _tmp; + p_A_Other = _tmp$1; + onePassInst.copy(instAlt, (x$8 = p.Inst, x$9 = p_A_Alt.$get(), ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9]))); + if (!((instAlt.Inst.Op === 0) || (instAlt.Inst.Op === 1))) { + _i$1++; + continue; + } + } + instOther = $clone((x$10 = p.Inst, x$11 = p_A_Other.$get(), ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11])), onePassInst); + if ((instOther.Inst.Op === 0) || (instOther.Inst.Op === 1)) { + _i$1++; + continue; + } + p_B_Alt = (x$12 = (x$13 = p.Inst, x$14 = p_A_Alt.$get(), ((x$14 < 0 || x$14 >= x$13.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + x$14])), (x$12.$ptr_Out || (x$12.$ptr_Out = new ptrType$9(function() { return this.$target.Inst.Out; }, function($v) { this.$target.Inst.Out = $v; }, x$12)))); + p_B_Other = (x$15 = (x$16 = p.Inst, x$17 = p_A_Alt.$get(), ((x$17 < 0 || x$17 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + x$17])), (x$15.$ptr_Arg || (x$15.$ptr_Arg = new ptrType$9(function() { return this.$target.Inst.Arg; }, function($v) { this.$target.Inst.Arg = $v; }, x$15)))); + patch = false; + if (instAlt.Inst.Out === ((pc >>> 0))) { + patch = true; + } else if (instAlt.Inst.Arg === ((pc >>> 0))) { + patch = true; + _tmp$2 = p_B_Other; + _tmp$3 = p_B_Alt; + p_B_Alt = _tmp$2; + p_B_Other = _tmp$3; + } + if (patch) { + p_B_Alt.$set(p_A_Other.$get()); + } + if (p_A_Other.$get() === p_B_Alt.$get()) { + p_A_Alt.$set(p_B_Other.$get()); + } + } else { + _i$1++; + continue; + } + _i$1++; + } + return p; + }; + runeSlice.prototype.Len = function() { + var p; + p = this; + return p.$length; + }; + $ptrType(runeSlice).prototype.Len = function() { return this.$get().Len(); }; + runeSlice.prototype.Less = function(i, j) { + var i, j, p; + p = this; + return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); + }; + $ptrType(runeSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + runeSlice.prototype.Swap = function(i, j) { + var _tmp, _tmp$1, i, j, p; + p = this; + _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); + _tmp$1 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); + ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); + ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$1); + }; + $ptrType(runeSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + makeOnePass = function(p) { + var _i, _r, _ref, check, i, instQueue, m, onePassRunes, p, pc, visitQueue, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; check = $f.check; i = $f.i; instQueue = $f.instQueue; m = $f.m; onePassRunes = $f.onePassRunes; p = $f.p; pc = $f.pc; visitQueue = $f.visitQueue; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + check = [check]; + instQueue = [instQueue]; + onePassRunes = [onePassRunes]; + p = [p]; + visitQueue = [visitQueue]; + if (p[0].Inst.$length >= 1000) { + $s = -1; return ptrType$6.nil; + } + instQueue[0] = newQueue(p[0].Inst.$length); + visitQueue[0] = newQueue(p[0].Inst.$length); + check[0] = $throwNilPointerError; + onePassRunes[0] = $makeSlice(sliceType$7, p[0].Inst.$length); + check[0] = (function(check, instQueue, onePassRunes, p, visitQueue) { return function $b(pc, m) { + var _1, _i, _i$1, _i$2, _i$3, _i$4, _q, _q$1, _q$2, _q$3, _q$4, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _v, i, i$1, i$2, i$3, i$4, inst, m, matchArg, matchOut, ok, pc, r0, r0$1, r1, r1$1, runes, runes$1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _q$4 = $f._q$4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _v = $f._v; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; inst = $f.inst; m = $f.m; matchArg = $f.matchArg; matchOut = $f.matchOut; ok = $f.ok; pc = $f.pc; r0 = $f.r0; r0$1 = $f.r0$1; r1 = $f.r1; r1$1 = $f.r1$1; runes = $f.runes; runes$1 = $f.runes$1; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ok = false; + ok = true; + inst = (x = p[0].Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); + if (visitQueue[0].contains(pc)) { + $s = -1; return ok; + } + visitQueue[0].insert(pc); + _1 = inst.Inst.Op; + /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 2; continue; } + /* */ if ((_1 === (2)) || (_1 === (6))) { $s = 3; continue; } + /* */ if (_1 === (3)) { $s = 4; continue; } + /* */ if ((_1 === (4)) || (_1 === (5))) { $s = 5; continue; } + /* */ if (_1 === (7)) { $s = 6; continue; } + /* */ if (_1 === (8)) { $s = 7; continue; } + /* */ if (_1 === (9)) { $s = 8; continue; } + /* */ if (_1 === (10)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if ((_1 === (0)) || (_1 === (1))) { */ case 2: + _r = check[0](inst.Inst.Out, m); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + if (!(_r)) { _v = false; $s = 11; continue s; } + _r$1 = check[0](inst.Inst.Arg, m); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = _r$1; case 11: + ok = _v; + matchOut = (x$1 = inst.Inst.Out, ((x$1 < 0 || x$1 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$1])); + matchArg = (x$2 = inst.Inst.Arg, ((x$2 < 0 || x$2 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$2])); + if (matchOut && matchArg) { + ok = false; + /* break; */ $s = 1; continue; + } + if (matchArg) { + _tmp = inst.Inst.Arg; + _tmp$1 = inst.Inst.Out; + inst.Inst.Out = _tmp; + inst.Inst.Arg = _tmp$1; + _tmp$2 = matchArg; + _tmp$3 = matchOut; + matchOut = _tmp$2; + matchArg = _tmp$3; + } + if (matchOut) { + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = true); + inst.Inst.Op = 1; + } + _r$2 = mergeRuneSets($indexPtr(onePassRunes[0].$array, onePassRunes[0].$offset + inst.Inst.Out, ptrType$10), $indexPtr(onePassRunes[0].$array, onePassRunes[0].$offset + inst.Inst.Arg, ptrType$10), inst.Inst.Out, inst.Inst.Arg); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = _tuple[0]); + inst.Next = _tuple[1]; + if (inst.Next.$length > 0 && ((x$3 = inst.Next, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])) === 4294967295)) { + ok = false; + /* break; */ $s = 1; continue; + } + $s = 10; continue; + /* } else if ((_1 === (2)) || (_1 === (6))) { */ case 3: + _r$3 = check[0](inst.Inst.Out, m); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ok = _r$3; + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (x$4 = inst.Inst.Out, ((x$4 < 0 || x$4 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$4]))); + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), (x$5 = inst.Inst.Out, ((x$5 < 0 || x$5 >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + x$5])))); + inst.Next = $makeSlice(sliceType$2, ((_q = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); + _ref = inst.Next; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + (x$6 = inst.Next, ((i < 0 || i >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i] = inst.Inst.Out)); + _i++; + } + $s = 10; continue; + /* } else if (_1 === (3)) { */ case 4: + _r$4 = check[0](inst.Inst.Out, m); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + ok = _r$4; + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (x$7 = inst.Inst.Out, ((x$7 < 0 || x$7 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$7]))); + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), (x$8 = inst.Inst.Out, ((x$8 < 0 || x$8 >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + x$8])))); + inst.Next = $makeSlice(sliceType$2, ((_q$1 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); + _ref$1 = inst.Next; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + (x$9 = inst.Next, ((i$1 < 0 || i$1 >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + i$1] = inst.Inst.Out)); + _i$1++; + } + $s = 10; continue; + /* } else if ((_1 === (4)) || (_1 === (5))) { */ case 5: + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (inst.Inst.Op === 4)); + $s = 10; continue; + /* } else if (_1 === (7)) { */ case 6: + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); + if (inst.Next.$length > 0) { + /* break; */ $s = 1; continue; + } + instQueue[0].insert(inst.Inst.Out); + if (inst.Inst.Rune.$length === 0) { + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = new sliceType$1([])); + inst.Next = new sliceType$2([inst.Inst.Out]); + /* break; */ $s = 1; continue; + } + runes = $makeSlice(sliceType$1, 0); + /* */ if ((inst.Inst.Rune.$length === 1) && !((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { $s = 17; continue; } + /* */ $s = 18; continue; + /* if ((inst.Inst.Rune.$length === 1) && !((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { */ case 17: + r0 = (x$10 = inst.Inst.Rune, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0])); + runes = $append(runes, r0, r0); + r1 = unicode.SimpleFold(r0); + while (true) { + if (!(!((r1 === r0)))) { break; } + runes = $append(runes, r1, r1); + r1 = unicode.SimpleFold(r1); + } + $r = sort.Sort(($subslice(new runeSlice(runes.$array), runes.$offset, runes.$offset + runes.$length))); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 19; continue; + /* } else { */ case 18: + runes = $appendSlice(runes, inst.Inst.Rune); + /* } */ case 19: + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = runes); + inst.Next = $makeSlice(sliceType$2, ((_q$2 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); + _ref$2 = inst.Next; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + (x$11 = inst.Next, ((i$2 < 0 || i$2 >= x$11.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + i$2] = inst.Inst.Out)); + _i$2++; + } + inst.Inst.Op = 7; + $s = 10; continue; + /* } else if (_1 === (8)) { */ case 7: + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); + if (inst.Next.$length > 0) { + /* break; */ $s = 1; continue; + } + instQueue[0].insert(inst.Inst.Out); + runes$1 = new sliceType$1([]); + /* */ if (!((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (!((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { */ case 21: + r0$1 = (x$12 = inst.Inst.Rune, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0])); + runes$1 = $append(runes$1, r0$1, r0$1); + r1$1 = unicode.SimpleFold(r0$1); + while (true) { + if (!(!((r1$1 === r0$1)))) { break; } + runes$1 = $append(runes$1, r1$1, r1$1); + r1$1 = unicode.SimpleFold(r1$1); + } + $r = sort.Sort(($subslice(new runeSlice(runes$1.$array), runes$1.$offset, runes$1.$offset + runes$1.$length))); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 23; continue; + /* } else { */ case 22: + runes$1 = $append(runes$1, (x$13 = inst.Inst.Rune, (0 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 0])), (x$14 = inst.Inst.Rune, (0 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 0]))); + /* } */ case 23: + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = runes$1); + inst.Next = $makeSlice(sliceType$2, ((_q$3 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); + _ref$3 = inst.Next; + _i$3 = 0; + while (true) { + if (!(_i$3 < _ref$3.$length)) { break; } + i$3 = _i$3; + (x$15 = inst.Next, ((i$3 < 0 || i$3 >= x$15.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + i$3] = inst.Inst.Out)); + _i$3++; + } + inst.Inst.Op = 7; + $s = 10; continue; + /* } else if (_1 === (9)) { */ case 8: + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); + if (inst.Next.$length > 0) { + /* break; */ $s = 1; continue; + } + instQueue[0].insert(inst.Inst.Out); + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), anyRune)); + inst.Next = new sliceType$2([inst.Inst.Out]); + $s = 10; continue; + /* } else if (_1 === (10)) { */ case 9: + ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); + if (inst.Next.$length > 0) { + /* break; */ $s = 1; continue; + } + instQueue[0].insert(inst.Inst.Out); + ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), anyRuneNotNL)); + inst.Next = $makeSlice(sliceType$2, ((_q$4 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$4 === _q$4 && _q$4 !== 1/0 && _q$4 !== -1/0) ? _q$4 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); + _ref$4 = inst.Next; + _i$4 = 0; + while (true) { + if (!(_i$4 < _ref$4.$length)) { break; } + i$4 = _i$4; + (x$16 = inst.Next, ((i$4 < 0 || i$4 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + i$4] = inst.Inst.Out)); + _i$4++; + } + /* } */ case 10: + case 1: + $s = -1; return ok; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._q$4 = _q$4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._v = _v; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.inst = inst; $f.m = m; $f.matchArg = matchArg; $f.matchOut = matchOut; $f.ok = ok; $f.pc = pc; $f.r0 = r0; $f.r0$1 = r0$1; $f.r1 = r1; $f.r1$1 = r1$1; $f.runes = runes; $f.runes$1 = runes$1; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; })(check, instQueue, onePassRunes, p, visitQueue); + instQueue[0].clear(); + instQueue[0].insert(((p[0].Start >>> 0))); + m = $makeSlice(sliceType$8, p[0].Inst.$length); + /* while (true) { */ case 1: + /* if (!(!instQueue[0].empty())) { break; } */ if(!(!instQueue[0].empty())) { $s = 2; continue; } + visitQueue[0].clear(); + pc = instQueue[0].next(); + _r = check[0](pc, m); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!_r) { */ case 3: + p[0] = ptrType$6.nil; + /* break; */ $s = 2; continue; + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + if (!(p[0] === ptrType$6.nil)) { + _ref = p[0].Inst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + (x = p[0].Inst, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])).Inst.Rune = ((i < 0 || i >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + i]); + _i++; + } + } + $s = -1; return p[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeOnePass }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.check = check; $f.i = i; $f.instQueue = instQueue; $f.m = m; $f.onePassRunes = onePassRunes; $f.p = p; $f.pc = pc; $f.visitQueue = visitQueue; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + compileOnePass = function(prog) { + var _1, _i, _r, _ref, inst, opOut, p, prog, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _ref = $f._ref; inst = $f.inst; opOut = $f.opOut; p = $f.p; prog = $f.prog; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = ptrType$6.nil; + if (prog.Start === 0) { + p = ptrType$6.nil; + $s = -1; return p; + } + if (!(((x = prog.Inst, x$1 = prog.Start, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op === 3)) || !(((((((x$2 = prog.Inst, x$3 = prog.Start, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])).Arg << 24 >>> 24)) & 4) >>> 0) === 4))) { + p = ptrType$6.nil; + $s = -1; return p; + } + _ref = prog.Inst; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + inst = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); + opOut = (x$4 = prog.Inst, x$5 = inst.Out, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])).Op; + _1 = inst.Op; + if ((_1 === (0)) || (_1 === (1))) { + if ((opOut === 4) || ((x$6 = prog.Inst, x$7 = inst.Arg, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])).Op === 4)) { + p = ptrType$6.nil; + $s = -1; return p; + } + } else if (_1 === (3)) { + if (opOut === 4) { + if (((((inst.Arg << 24 >>> 24)) & 8) >>> 0) === 8) { + _i++; + /* continue; */ $s = 1; continue; + } + p = ptrType$6.nil; + $s = -1; return p; + } + } else if (opOut === 4) { + p = ptrType$6.nil; + $s = -1; return p; + } + _i++; + /* } */ $s = 1; continue; case 2: + p = onePassCopy(prog); + _r = makeOnePass(p); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + if (!(p === ptrType$6.nil)) { + cleanupOnePass(p, prog); + } + p = p; + $s = -1; return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: compileOnePass }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.inst = inst; $f.opOut = opOut; $f.p = p; $f.prog = prog; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.ptr.prototype.String = function() { + var re; + re = this; + return re.expr; + }; + Regexp.prototype.String = function() { return this.$val.String(); }; + Regexp.ptr.prototype.Copy = function() { + var re, re2; + re = this; + re2 = $clone(re, Regexp); + return re2; + }; + Regexp.prototype.Copy = function() { return this.$val.Copy(); }; + Compile = function(expr) { + var _r, expr, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; expr = $f.expr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = compile(expr, 212, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Compile }; } $f._r = _r; $f.expr = expr; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Compile = Compile; + Regexp.ptr.prototype.Longest = function() { + var re; + re = this; + re.longest = true; + }; + Regexp.prototype.Longest = function() { return this.$val.Longest(); }; + compile = function(expr, mode, longest) { + var _r, _r$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, capNames, err, expr, i, longest, matchcap, maxCap, mode, n, prog, re, regexp, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; capNames = $f.capNames; err = $f.err; expr = $f.expr; i = $f.i; longest = $f.longest; matchcap = $f.matchcap; maxCap = $f.maxCap; mode = $f.mode; n = $f.n; prog = $f.prog; re = $f.re; regexp = $f.regexp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = syntax.Parse(expr, mode); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + re = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$11.nil, err]; + } + maxCap = re.MaxCap(); + capNames = re.CapNames(); + re = re.Simplify(); + _tuple$1 = syntax.Compile(re); + prog = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType$11.nil, err]; + } + matchcap = prog.NumCap; + if (matchcap < 2) { + matchcap = 2; + } + _r$1 = compileOnePass(prog); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + regexp = new Regexp.ptr(expr, prog, _r$1, maxCap, 0, capNames, "", sliceType$5.nil, 0, 0, 0, matchcap, false, prog.StartCond(), longest); + if (regexp.onepass === ptrType$6.nil) { + _tuple$2 = prog.Prefix(); + regexp.prefix = _tuple$2[0]; + regexp.prefixComplete = _tuple$2[1]; + regexp.maxBitStateLen = maxBitStateLen(prog); + } else { + _tuple$3 = onePassPrefix(prog); + regexp.prefix = _tuple$3[0]; + regexp.prefixComplete = _tuple$3[1]; + regexp.prefixEnd = _tuple$3[2]; + } + if (!(regexp.prefix === "")) { + regexp.prefixBytes = (new sliceType$5($stringToBytes(regexp.prefix))); + _tuple$4 = utf8.DecodeRuneInString(regexp.prefix); + regexp.prefixRune = _tuple$4[0]; + } + n = prog.Inst.$length; + i = 0; + while (true) { + if (!(!((((i < 0 || i >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[i]) === 0)) && ((i < 0 || i >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[i]) < n)) { break; } + i = i + (1) >> 0; + } + regexp.mpool = i; + $s = -1; return [regexp, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: compile }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.capNames = capNames; $f.err = err; $f.expr = expr; $f.i = i; $f.longest = longest; $f.matchcap = matchcap; $f.maxCap = maxCap; $f.mode = mode; $f.n = n; $f.prog = prog; $f.re = re; $f.regexp = regexp; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.ptr.prototype.get = function() { + var _i, _r, _ref, _tuple, m, n, ok, re, t, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; m = $f.m; n = $f.n; ok = $f.ok; re = $f.re; t = $f.t; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = (x = re.mpool, ((x < 0 || x >= matchPool.length) ? ($throwRuntimeError("index out of range"), undefined) : matchPool[x])).Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = $assertType(_r, ptrType$13, true); + m = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + m = new machine.ptr(ptrType$11.nil, ptrType$12.nil, new queue.ptr(sliceType$2.nil, sliceType$10.nil), new queue.ptr(sliceType$2.nil, sliceType$10.nil), sliceType$11.nil, false, sliceType$3.nil, new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0))); + } + m.re = re; + m.p = re.prog; + if (m.matchcap.$capacity < re.matchcap) { + m.matchcap = $makeSlice(sliceType$3, re.matchcap); + _ref = m.pool; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + t = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + t.cap = $makeSlice(sliceType$3, re.matchcap); + _i++; + } + } + n = (x$1 = re.mpool, ((x$1 < 0 || x$1 >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[x$1])); + if (n === 0) { + n = re.prog.Inst.$length; + } + if (m.q0.sparse.$length < n) { + queue.copy(m.q0, new queue.ptr($makeSlice(sliceType$2, n), $makeSlice(sliceType$10, 0, n))); + queue.copy(m.q1, new queue.ptr($makeSlice(sliceType$2, n), $makeSlice(sliceType$10, 0, n))); + } + $s = -1; return m; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.get }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.m = m; $f.n = n; $f.ok = ok; $f.re = re; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.get = function() { return this.$val.get(); }; + Regexp.ptr.prototype.put = function(m) { + var m, re, x; + re = this; + m.re = ptrType$11.nil; + m.p = ptrType$12.nil; + m.inputs.clear(); + (x = re.mpool, ((x < 0 || x >= matchPool.length) ? ($throwRuntimeError("index out of range"), undefined) : matchPool[x])).Put(m); + }; + Regexp.prototype.put = function(m) { return this.$val.put(m); }; + MustCompile = function(str) { + var _r, _r$1, _tuple, err, regexp, str, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; regexp = $f.regexp; str = $f.str; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = Compile(str); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + regexp = _tuple[0]; + err = _tuple[1]; + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2: + _r$1 = err.Error(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $panic(new $String("regexp: Compile(" + quote(str) + "): " + _r$1)); + /* } */ case 3: + $s = -1; return regexp; + /* */ } return; } if ($f === undefined) { $f = { $blk: MustCompile }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.regexp = regexp; $f.str = str; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.MustCompile = MustCompile; + quote = function(s) { + var s; + if (strconv.CanBackquote(s)) { + return "`" + s + "`"; + } + return strconv.Quote(s); + }; + Regexp.ptr.prototype.NumSubexp = function() { + var re; + re = this; + return re.numSubexp; + }; + Regexp.prototype.NumSubexp = function() { return this.$val.NumSubexp(); }; + Regexp.ptr.prototype.SubexpNames = function() { + var re; + re = this; + return re.subexpNames; + }; + Regexp.prototype.SubexpNames = function() { return this.$val.SubexpNames(); }; + inputString.ptr.prototype.step = function(pos) { + var c, i, pos; + i = this; + if (pos < i.str.length) { + c = i.str.charCodeAt(pos); + if (c < 128) { + return [((c >> 0)), 1]; + } + return utf8.DecodeRuneInString($substring(i.str, pos)); + } + return [-1, 0]; + }; + inputString.prototype.step = function(pos) { return this.$val.step(pos); }; + inputString.ptr.prototype.canCheckPrefix = function() { + var i; + i = this; + return true; + }; + inputString.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; + inputString.ptr.prototype.hasPrefix = function(re) { + var i, re; + i = this; + return strings.HasPrefix(i.str, re.prefix); + }; + inputString.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; + inputString.ptr.prototype.index = function(re, pos) { + var i, pos, re; + i = this; + return strings.Index($substring(i.str, pos), re.prefix); + }; + inputString.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; + inputString.ptr.prototype.context = function(pos) { + var _tmp, _tmp$1, _tuple, _tuple$1, i, pos, r1, r2; + i = this; + _tmp = -1; + _tmp$1 = -1; + r1 = _tmp; + r2 = _tmp$1; + if ((((pos - 1 >> 0) >>> 0)) < ((i.str.length >>> 0))) { + r1 = ((i.str.charCodeAt((pos - 1 >> 0)) >> 0)); + if (r1 >= 128) { + _tuple = utf8.DecodeLastRuneInString($substring(i.str, 0, pos)); + r1 = _tuple[0]; + } + } + if (((pos >>> 0)) < ((i.str.length >>> 0))) { + r2 = ((i.str.charCodeAt(pos) >> 0)); + if (r2 >= 128) { + _tuple$1 = utf8.DecodeRuneInString($substring(i.str, pos)); + r2 = _tuple$1[0]; + } + } + return newLazyFlag(r1, r2); + }; + inputString.prototype.context = function(pos) { return this.$val.context(pos); }; + inputBytes.ptr.prototype.step = function(pos) { + var c, i, pos, x; + i = this; + if (pos < i.str.$length) { + c = (x = i.str, ((pos < 0 || pos >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pos])); + if (c < 128) { + return [((c >> 0)), 1]; + } + return utf8.DecodeRune($subslice(i.str, pos)); + } + return [-1, 0]; + }; + inputBytes.prototype.step = function(pos) { return this.$val.step(pos); }; + inputBytes.ptr.prototype.canCheckPrefix = function() { + var i; + i = this; + return true; + }; + inputBytes.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; + inputBytes.ptr.prototype.hasPrefix = function(re) { + var i, re; + i = this; + return bytes.HasPrefix(i.str, re.prefixBytes); + }; + inputBytes.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; + inputBytes.ptr.prototype.index = function(re, pos) { + var i, pos, re; + i = this; + return bytes.Index($subslice(i.str, pos), re.prefixBytes); + }; + inputBytes.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; + inputBytes.ptr.prototype.context = function(pos) { + var _tmp, _tmp$1, _tuple, _tuple$1, i, pos, r1, r2, x, x$1, x$2; + i = this; + _tmp = -1; + _tmp$1 = -1; + r1 = _tmp; + r2 = _tmp$1; + if ((((pos - 1 >> 0) >>> 0)) < ((i.str.$length >>> 0))) { + r1 = (((x = i.str, x$1 = pos - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) >> 0)); + if (r1 >= 128) { + _tuple = utf8.DecodeLastRune($subslice(i.str, 0, pos)); + r1 = _tuple[0]; + } + } + if (((pos >>> 0)) < ((i.str.$length >>> 0))) { + r2 = (((x$2 = i.str, ((pos < 0 || pos >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pos])) >> 0)); + if (r2 >= 128) { + _tuple$1 = utf8.DecodeRune($subslice(i.str, pos)); + r2 = _tuple$1[0]; + } + } + return newLazyFlag(r1, r2); + }; + inputBytes.prototype.context = function(pos) { return this.$val.context(pos); }; + inputReader.ptr.prototype.step = function(pos) { + var _r, _tuple, err, i, pos, r, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; i = $f.i; pos = $f.pos; r = $f.r; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this; + if (!i.atEOT && !((pos === i.pos))) { + $s = -1; return [-1, 0]; + } + _r = i.r.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + w = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + i.atEOT = true; + $s = -1; return [-1, 0]; + } + i.pos = i.pos + (w) >> 0; + $s = -1; return [r, w]; + /* */ } return; } if ($f === undefined) { $f = { $blk: inputReader.ptr.prototype.step }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.i = i; $f.pos = pos; $f.r = r; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + inputReader.prototype.step = function(pos) { return this.$val.step(pos); }; + inputReader.ptr.prototype.canCheckPrefix = function() { + var i; + i = this; + return false; + }; + inputReader.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; + inputReader.ptr.prototype.hasPrefix = function(re) { + var i, re; + i = this; + return false; + }; + inputReader.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; + inputReader.ptr.prototype.index = function(re, pos) { + var i, pos, re; + i = this; + return -1; + }; + inputReader.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; + inputReader.ptr.prototype.context = function(pos) { + var i, pos; + i = this; + return new lazyFlag(0, 0); + }; + inputReader.prototype.context = function(pos) { return this.$val.context(pos); }; + Regexp.ptr.prototype.LiteralPrefix = function() { + var _tmp, _tmp$1, complete, prefix, re; + prefix = ""; + complete = false; + re = this; + _tmp = re.prefix; + _tmp$1 = re.prefixComplete; + prefix = _tmp; + complete = _tmp$1; + return [prefix, complete]; + }; + Regexp.prototype.LiteralPrefix = function() { return this.$val.LiteralPrefix(); }; + Regexp.ptr.prototype.MatchReader = function(r) { + var _r, r, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doMatch(r, sliceType$5.nil, ""); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.MatchReader }; } $f._r = _r; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.MatchReader = function(r) { return this.$val.MatchReader(r); }; + Regexp.ptr.prototype.MatchString = function(s) { + var _r, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doMatch($ifaceNil, sliceType$5.nil, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.MatchString }; } $f._r = _r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.MatchString = function(s) { return this.$val.MatchString(s); }; + Regexp.ptr.prototype.Match = function(b) { + var _r, b, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doMatch($ifaceNil, b, ""); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Match }; } $f._r = _r; $f.b = b; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.Match = function(b) { return this.$val.Match(b); }; + Regexp.ptr.prototype.ReplaceAllString = function(src, repl) { + var _r, b, n, re, repl, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; n = $f.n; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = [re]; + repl = [repl]; + src = [src]; + re[0] = this; + n = 2; + if (strings.Contains(repl[0], "$")) { + n = $imul(2, ((re[0].numSubexp + 1 >> 0))); + } + _r = re[0].replaceAll(sliceType$5.nil, src[0], n, (function(re, repl, src) { return function(dst, match) { + var dst, match; + return re[0].expand(dst, repl[0], sliceType$5.nil, src[0], match); + }; })(re, repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + $s = -1; return ($bytesToString(b)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllString }; } $f._r = _r; $f.b = b; $f.n = n; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAllString = function(src, repl) { return this.$val.ReplaceAllString(src, repl); }; + Regexp.ptr.prototype.ReplaceAllLiteralString = function(src, repl) { + var _r, re, repl, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + repl = [repl]; + re = this; + _r = re.replaceAll(sliceType$5.nil, src, 2, (function(repl) { return function(dst, match) { + var dst, match; + return $appendSlice(dst, repl[0]); + }; })(repl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return ($bytesToString(_r)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllLiteralString }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAllLiteralString = function(src, repl) { return this.$val.ReplaceAllLiteralString(src, repl); }; + Regexp.ptr.prototype.ReplaceAllStringFunc = function(src, repl) { + var _r, b, re, repl, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + repl = [repl]; + src = [src]; + re = this; + _r = re.replaceAll(sliceType$5.nil, src[0], 2, (function(repl, src) { return function $b(dst, match) { + var _arg, _arg$1, _r, dst, match, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; dst = $f.dst; match = $f.match; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = dst; + _r = repl[0]($substring(src[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = _r; + $s = -1; return $appendSlice(_arg, _arg$1); + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.dst = dst; $f.match = match; $f.$s = $s; $f.$r = $r; return $f; + }; })(repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + $s = -1; return ($bytesToString(b)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllStringFunc }; } $f._r = _r; $f.b = b; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAllStringFunc = function(src, repl) { return this.$val.ReplaceAllStringFunc(src, repl); }; + Regexp.ptr.prototype.replaceAll = function(bsrc, src, nmatch, repl) { + var _r, _r$1, _tuple, _tuple$1, a, bsrc, buf, dstCap, endPos, lastMatchEnd, nmatch, re, repl, searchPos, src, width, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; bsrc = $f.bsrc; buf = $f.buf; dstCap = $f.dstCap; endPos = $f.endPos; lastMatchEnd = $f.lastMatchEnd; nmatch = $f.nmatch; re = $f.re; repl = $f.repl; searchPos = $f.searchPos; src = $f.src; width = $f.width; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + lastMatchEnd = 0; + searchPos = 0; + buf = sliceType$5.nil; + endPos = 0; + if (!(bsrc === sliceType$5.nil)) { + endPos = bsrc.$length; + } else { + endPos = src.length; + } + if (nmatch > re.prog.NumCap) { + nmatch = re.prog.NumCap; + } + dstCap = arrayType$3.zero(); + /* while (true) { */ case 1: + /* if (!(searchPos <= endPos)) { break; } */ if(!(searchPos <= endPos)) { $s = 2; continue; } + _r = re.doExecute($ifaceNil, bsrc, src, searchPos, nmatch, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a.$length === 0) { + /* break; */ $s = 2; continue; + } + if (!(bsrc === sliceType$5.nil)) { + buf = $appendSlice(buf, $subslice(bsrc, lastMatchEnd, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]))); + } else { + buf = $appendSlice(buf, $substring(src, lastMatchEnd, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]))); + } + /* */ if ((1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]) > lastMatchEnd || ((0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) === 0)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]) > lastMatchEnd || ((0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) === 0)) { */ case 4: + _r$1 = repl(buf, a); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + buf = _r$1; + /* } */ case 5: + lastMatchEnd = (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]); + width = 0; + if (!(bsrc === sliceType$5.nil)) { + _tuple = utf8.DecodeRune($subslice(bsrc, searchPos)); + width = _tuple[1]; + } else { + _tuple$1 = utf8.DecodeRuneInString($substring(src, searchPos)); + width = _tuple$1[1]; + } + if ((searchPos + width >> 0) > (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])) { + searchPos = searchPos + (width) >> 0; + } else if ((searchPos + 1 >> 0) > (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])) { + searchPos = searchPos + (1) >> 0; + } else { + searchPos = (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]); + } + /* } */ $s = 1; continue; case 2: + if (!(bsrc === sliceType$5.nil)) { + buf = $appendSlice(buf, $subslice(bsrc, lastMatchEnd)); + } else { + buf = $appendSlice(buf, $substring(src, lastMatchEnd)); + } + $s = -1; return buf; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.replaceAll }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.bsrc = bsrc; $f.buf = buf; $f.dstCap = dstCap; $f.endPos = endPos; $f.lastMatchEnd = lastMatchEnd; $f.nmatch = nmatch; $f.re = re; $f.repl = repl; $f.searchPos = searchPos; $f.src = src; $f.width = width; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.replaceAll = function(bsrc, src, nmatch, repl) { return this.$val.replaceAll(bsrc, src, nmatch, repl); }; + Regexp.ptr.prototype.ReplaceAll = function(src, repl) { + var _r, b, n, re, repl, src, srepl, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; n = $f.n; re = $f.re; repl = $f.repl; src = $f.src; srepl = $f.srepl; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = [re]; + repl = [repl]; + src = [src]; + srepl = [srepl]; + re[0] = this; + n = 2; + if (bytes.IndexByte(repl[0], 36) >= 0) { + n = $imul(2, ((re[0].numSubexp + 1 >> 0))); + } + srepl[0] = ""; + _r = re[0].replaceAll(src[0], "", n, (function(re, repl, src, srepl) { return function(dst, match) { + var dst, match; + if (!((srepl[0].length === repl[0].$length))) { + srepl[0] = ($bytesToString(repl[0])); + } + return re[0].expand(dst, srepl[0], src[0], "", match); + }; })(re, repl, src, srepl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + $s = -1; return b; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAll }; } $f._r = _r; $f.b = b; $f.n = n; $f.re = re; $f.repl = repl; $f.src = src; $f.srepl = srepl; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAll = function(src, repl) { return this.$val.ReplaceAll(src, repl); }; + Regexp.ptr.prototype.ReplaceAllLiteral = function(src, repl) { + var _r, re, repl, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + repl = [repl]; + re = this; + _r = re.replaceAll(src, "", 2, (function(repl) { return function(dst, match) { + var dst, match; + return $appendSlice(dst, repl[0]); + }; })(repl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllLiteral }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAllLiteral = function(src, repl) { return this.$val.ReplaceAllLiteral(src, repl); }; + Regexp.ptr.prototype.ReplaceAllFunc = function(src, repl) { + var _r, re, repl, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + repl = [repl]; + src = [src]; + re = this; + _r = re.replaceAll(src[0], "", 2, (function(repl, src) { return function $b(dst, match) { + var _arg, _arg$1, _r, dst, match, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; dst = $f.dst; match = $f.match; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = dst; + _r = repl[0]($subslice(src[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = _r; + $s = -1; return $appendSlice(_arg, _arg$1); + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.dst = dst; $f.match = match; $f.$s = $s; $f.$r = $r; return $f; + }; })(repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllFunc }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.ReplaceAllFunc = function(src, repl) { return this.$val.ReplaceAllFunc(src, repl); }; + init = function() { + var _i, _index, _q, _r, _ref, b, y; + _ref = (new sliceType$5($stringToBytes("\\.+*?()|[]{}^$"))); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + _index = (_r = b % 16, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); + ((_index < 0 || _index >= specialBytes.length) ? ($throwRuntimeError("index out of range"), undefined) : specialBytes[_index] = ((((_index < 0 || _index >= specialBytes.length) ? ($throwRuntimeError("index out of range"), undefined) : specialBytes[_index]) | (((y = ((_q = b / 16, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (1 << y) : 0) << 24 >>> 24))) >>> 0)); + _i++; + } + }; + Regexp.ptr.prototype.pad = function(a) { + var a, n, re; + re = this; + if (a === sliceType$3.nil) { + return sliceType$3.nil; + } + n = $imul(((1 + re.numSubexp >> 0)), 2); + while (true) { + if (!(a.$length < n)) { break; } + a = $append(a, -1); + } + return a; + }; + Regexp.prototype.pad = function(a) { return this.$val.pad(a); }; + Regexp.ptr.prototype.allMatches = function(s, b, n, deliver) { + var _r, _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, accept, b, deliver, end, i, matches, n, pos, prevMatchEnd, re, s, width, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; accept = $f.accept; b = $f.b; deliver = $f.deliver; end = $f.end; i = $f.i; matches = $f.matches; n = $f.n; pos = $f.pos; prevMatchEnd = $f.prevMatchEnd; re = $f.re; s = $f.s; width = $f.width; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + end = 0; + if (b === sliceType$5.nil) { + end = s.length; + } else { + end = b.$length; + } + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = -1; + pos = _tmp; + i = _tmp$1; + prevMatchEnd = _tmp$2; + /* while (true) { */ case 1: + /* if (!(i < n && pos <= end)) { break; } */ if(!(i < n && pos <= end)) { $s = 2; continue; } + _r = re.doExecute($ifaceNil, b, s, pos, re.prog.NumCap, sliceType$3.nil); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + matches = _r; + if (matches.$length === 0) { + /* break; */ $s = 2; continue; + } + accept = true; + if ((1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]) === pos) { + if ((0 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 0]) === prevMatchEnd) { + accept = false; + } + width = 0; + if (b === sliceType$5.nil) { + _tuple = utf8.DecodeRuneInString($substring(s, pos, end)); + width = _tuple[1]; + } else { + _tuple$1 = utf8.DecodeRune($subslice(b, pos, end)); + width = _tuple$1[1]; + } + if (width > 0) { + pos = pos + (width) >> 0; + } else { + pos = end + 1 >> 0; + } + } else { + pos = (1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]); + } + prevMatchEnd = (1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]); + /* */ if (accept) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (accept) { */ case 4: + $r = deliver(re.pad(matches)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i = i + (1) >> 0; + /* } */ case 5: + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.allMatches }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.accept = accept; $f.b = b; $f.deliver = deliver; $f.end = end; $f.i = i; $f.matches = matches; $f.n = n; $f.pos = pos; $f.prevMatchEnd = prevMatchEnd; $f.re = re; $f.s = s; $f.width = width; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.allMatches = function(s, b, n, deliver) { return this.$val.allMatches(s, b, n, deliver); }; + Regexp.ptr.prototype.Find = function(b) { + var _r, a, b, dstCap, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; dstCap = $f.dstCap; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + dstCap = arrayType$3.zero(); + _r = re.doExecute($ifaceNil, b, "", 0, 2, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + $s = -1; return sliceType$5.nil; + } + $s = -1; return $subslice(b, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]), (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Find }; } $f._r = _r; $f.a = a; $f.b = b; $f.dstCap = dstCap; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.Find = function(b) { return this.$val.Find(b); }; + Regexp.ptr.prototype.FindIndex = function(b) { + var _r, a, b, loc, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; loc = $f.loc; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + loc = sliceType$3.nil; + re = this; + _r = re.doExecute($ifaceNil, b, "", 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + loc = sliceType$3.nil; + $s = -1; return loc; + } + loc = $subslice(a, 0, 2); + $s = -1; return loc; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindIndex }; } $f._r = _r; $f.a = a; $f.b = b; $f.loc = loc; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindIndex = function(b) { return this.$val.FindIndex(b); }; + Regexp.ptr.prototype.FindString = function(s) { + var _r, a, dstCap, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; dstCap = $f.dstCap; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + dstCap = arrayType$3.zero(); + _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, 2, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + $s = -1; return ""; + } + $s = -1; return $substring(s, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]), (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])); + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindString }; } $f._r = _r; $f.a = a; $f.dstCap = dstCap; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindString = function(s) { return this.$val.FindString(s); }; + Regexp.ptr.prototype.FindStringIndex = function(s) { + var _r, a, loc, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; loc = $f.loc; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + loc = sliceType$3.nil; + re = this; + _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + loc = sliceType$3.nil; + $s = -1; return loc; + } + loc = $subslice(a, 0, 2); + $s = -1; return loc; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringIndex }; } $f._r = _r; $f.a = a; $f.loc = loc; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindStringIndex = function(s) { return this.$val.FindStringIndex(s); }; + Regexp.ptr.prototype.FindReaderIndex = function(r) { + var _r, a, loc, r, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; loc = $f.loc; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + loc = sliceType$3.nil; + re = this; + _r = re.doExecute(r, sliceType$5.nil, "", 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + loc = sliceType$3.nil; + $s = -1; return loc; + } + loc = $subslice(a, 0, 2); + $s = -1; return loc; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindReaderIndex }; } $f._r = _r; $f.a = a; $f.loc = loc; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindReaderIndex = function(r) { return this.$val.FindReaderIndex(r); }; + Regexp.ptr.prototype.FindSubmatch = function(b) { + var _i, _r, _ref, a, b, dstCap, i, re, ret, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; a = $f.a; b = $f.b; dstCap = $f.dstCap; i = $f.i; re = $f.re; ret = $f.ret; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + dstCap = arrayType$4.zero(); + _r = re.doExecute($ifaceNil, b, "", 0, re.prog.NumCap, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + $s = -1; return sliceType$12.nil; + } + ret = $makeSlice(sliceType$12, (1 + re.numSubexp >> 0)); + _ref = ret; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + if (($imul(2, i)) < a.$length && (x = $imul(2, i), ((x < 0 || x >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x])) >= 0) { + ((i < 0 || i >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i] = $subslice(b, (x$1 = $imul(2, i), ((x$1 < 0 || x$1 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$1])), (x$2 = ($imul(2, i)) + 1 >> 0, ((x$2 < 0 || x$2 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$2])))); + } + _i++; + } + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindSubmatch }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.a = a; $f.b = b; $f.dstCap = dstCap; $f.i = i; $f.re = re; $f.ret = ret; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindSubmatch = function(b) { return this.$val.FindSubmatch(b); }; + Regexp.ptr.prototype.Expand = function(dst, template, src, match) { + var dst, match, re, src, template; + re = this; + return re.expand(dst, ($bytesToString(template)), src, "", match); + }; + Regexp.prototype.Expand = function(dst, template, src, match) { return this.$val.Expand(dst, template, src, match); }; + Regexp.ptr.prototype.ExpandString = function(dst, template, src, match) { + var dst, match, re, src, template; + re = this; + return re.expand(dst, template, sliceType$5.nil, src, match); + }; + Regexp.prototype.ExpandString = function(dst, template, src, match) { return this.$val.ExpandString(dst, template, src, match); }; + Regexp.ptr.prototype.expand = function(dst, template, bsrc, src, match) { + var _i, _ref, _tuple, bsrc, dst, i, i$1, match, name, namei, num, ok, re, rest, src, template, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + re = this; + while (true) { + if (!(template.length > 0)) { break; } + i = strings.Index(template, "$"); + if (i < 0) { + break; + } + dst = $appendSlice(dst, $substring(template, 0, i)); + template = $substring(template, i); + if (template.length > 1 && (template.charCodeAt(1) === 36)) { + dst = $append(dst, 36); + template = $substring(template, 2); + continue; + } + _tuple = extract(template); + name = _tuple[0]; + num = _tuple[1]; + rest = _tuple[2]; + ok = _tuple[3]; + if (!ok) { + dst = $append(dst, 36); + template = $substring(template, 1); + continue; + } + template = rest; + if (num >= 0) { + if ((($imul(2, num)) + 1 >> 0) < match.$length && (x = $imul(2, num), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { + if (!(bsrc === sliceType$5.nil)) { + dst = $appendSlice(dst, $subslice(bsrc, (x$1 = $imul(2, num), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, num)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); + } else { + dst = $appendSlice(dst, $substring(src, (x$3 = $imul(2, num), ((x$3 < 0 || x$3 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$3])), (x$4 = ($imul(2, num)) + 1 >> 0, ((x$4 < 0 || x$4 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$4])))); + } + } + } else { + _ref = re.subexpNames; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i$1 = _i; + namei = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (name === namei && (($imul(2, i$1)) + 1 >> 0) < match.$length && (x$5 = $imul(2, i$1), ((x$5 < 0 || x$5 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$5])) >= 0) { + if (!(bsrc === sliceType$5.nil)) { + dst = $appendSlice(dst, $subslice(bsrc, (x$6 = $imul(2, i$1), ((x$6 < 0 || x$6 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$6])), (x$7 = ($imul(2, i$1)) + 1 >> 0, ((x$7 < 0 || x$7 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$7])))); + } else { + dst = $appendSlice(dst, $substring(src, (x$8 = $imul(2, i$1), ((x$8 < 0 || x$8 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$8])), (x$9 = ($imul(2, i$1)) + 1 >> 0, ((x$9 < 0 || x$9 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$9])))); + } + break; + } + _i++; + } + } + } + dst = $appendSlice(dst, template); + return dst; + }; + Regexp.prototype.expand = function(dst, template, bsrc, src, match) { return this.$val.expand(dst, template, bsrc, src, match); }; + extract = function(str) { + var _tuple, brace, i, i$1, name, num, ok, rest, rune, size, str; + name = ""; + num = 0; + rest = ""; + ok = false; + if (str.length < 2 || !((str.charCodeAt(0) === 36))) { + return [name, num, rest, ok]; + } + brace = false; + if (str.charCodeAt(1) === 123) { + brace = true; + str = $substring(str, 2); + } else { + str = $substring(str, 1); + } + i = 0; + while (true) { + if (!(i < str.length)) { break; } + _tuple = utf8.DecodeRuneInString($substring(str, i)); + rune = _tuple[0]; + size = _tuple[1]; + if (!unicode.IsLetter(rune) && !unicode.IsDigit(rune) && !((rune === 95))) { + break; + } + i = i + (size) >> 0; + } + if (i === 0) { + return [name, num, rest, ok]; + } + name = $substring(str, 0, i); + if (brace) { + if (i >= str.length || !((str.charCodeAt(i) === 125))) { + return [name, num, rest, ok]; + } + i = i + (1) >> 0; + } + num = 0; + i$1 = 0; + while (true) { + if (!(i$1 < name.length)) { break; } + if (name.charCodeAt(i$1) < 48 || 57 < name.charCodeAt(i$1) || num >= 100000000) { + num = -1; + break; + } + num = (($imul(num, 10)) + ((name.charCodeAt(i$1) >> 0)) >> 0) - 48 >> 0; + i$1 = i$1 + (1) >> 0; + } + if ((name.charCodeAt(0) === 48) && name.length > 1) { + num = -1; + } + rest = $substring(str, i); + ok = true; + return [name, num, rest, ok]; + }; + Regexp.ptr.prototype.FindSubmatchIndex = function(b) { + var _r, _r$1, b, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doExecute($ifaceNil, b, "", 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindSubmatchIndex = function(b) { return this.$val.FindSubmatchIndex(b); }; + Regexp.ptr.prototype.FindStringSubmatch = function(s) { + var _i, _r, _ref, a, dstCap, i, re, ret, s, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; a = $f.a; dstCap = $f.dstCap; i = $f.i; re = $f.re; ret = $f.ret; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + dstCap = arrayType$4.zero(); + _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, re.prog.NumCap, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + a = _r; + if (a === sliceType$3.nil) { + $s = -1; return sliceType$9.nil; + } + ret = $makeSlice(sliceType$9, (1 + re.numSubexp >> 0)); + _ref = ret; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + if (($imul(2, i)) < a.$length && (x = $imul(2, i), ((x < 0 || x >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x])) >= 0) { + ((i < 0 || i >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i] = $substring(s, (x$1 = $imul(2, i), ((x$1 < 0 || x$1 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$1])), (x$2 = ($imul(2, i)) + 1 >> 0, ((x$2 < 0 || x$2 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$2])))); + } + _i++; + } + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringSubmatch }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.a = a; $f.dstCap = dstCap; $f.i = i; $f.re = re; $f.ret = ret; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindStringSubmatch = function(s) { return this.$val.FindStringSubmatch(s); }; + Regexp.ptr.prototype.FindStringSubmatchIndex = function(s) { + var _r, _r$1, re, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindStringSubmatchIndex = function(s) { return this.$val.FindStringSubmatchIndex(s); }; + Regexp.ptr.prototype.FindReaderSubmatchIndex = function(r) { + var _r, _r$1, r, re, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + _r = re.doExecute(r, sliceType$5.nil, "", 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindReaderSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindReaderSubmatchIndex = function(r) { return this.$val.FindReaderSubmatchIndex(r); }; + Regexp.ptr.prototype.FindAll = function(b, n) { + var b, n, re, result, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + b = [b]; + result = [result]; + re = this; + if (n < 0) { + n = b[0].$length + 1 >> 0; + } + result[0] = sliceType$12.nil; + $r = re.allMatches("", b[0], n, (function(b, result) { return function(match) { + var match; + if (result[0] === sliceType$12.nil) { + result[0] = $makeSlice(sliceType$12, 0, 10); + } + result[0] = $append(result[0], $subslice(b[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); + }; })(b, result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAll }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAll = function(b, n) { return this.$val.FindAll(b, n); }; + Regexp.ptr.prototype.FindAllIndex = function(b, n) { + var b, n, re, result, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + re = this; + if (n < 0) { + n = b.$length + 1 >> 0; + } + result[0] = sliceType$13.nil; + $r = re.allMatches("", b, n, (function(result) { return function(match) { + var match; + if (result[0] === sliceType$13.nil) { + result[0] = $makeSlice(sliceType$13, 0, 10); + } + result[0] = $append(result[0], $subslice(match, 0, 2)); + }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllIndex }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllIndex = function(b, n) { return this.$val.FindAllIndex(b, n); }; + Regexp.ptr.prototype.FindAllString = function(s, n) { + var n, re, result, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + s = [s]; + re = this; + if (n < 0) { + n = s[0].length + 1 >> 0; + } + result[0] = sliceType$9.nil; + $r = re.allMatches(s[0], sliceType$5.nil, n, (function(result, s) { return function(match) { + var match; + if (result[0] === sliceType$9.nil) { + result[0] = $makeSlice(sliceType$9, 0, 10); + } + result[0] = $append(result[0], $substring(s[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); + }; })(result, s)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllString }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllString = function(s, n) { return this.$val.FindAllString(s, n); }; + Regexp.ptr.prototype.FindAllStringIndex = function(s, n) { + var n, re, result, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + re = this; + if (n < 0) { + n = s.length + 1 >> 0; + } + result[0] = sliceType$13.nil; + $r = re.allMatches(s, sliceType$5.nil, n, (function(result) { return function(match) { + var match; + if (result[0] === sliceType$13.nil) { + result[0] = $makeSlice(sliceType$13, 0, 10); + } + result[0] = $append(result[0], $subslice(match, 0, 2)); + }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringIndex }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllStringIndex = function(s, n) { return this.$val.FindAllStringIndex(s, n); }; + Regexp.ptr.prototype.FindAllSubmatch = function(b, n) { + var b, n, re, result, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + b = [b]; + result = [result]; + re = this; + if (n < 0) { + n = b[0].$length + 1 >> 0; + } + result[0] = sliceType$14.nil; + $r = re.allMatches("", b[0], n, (function(b, result) { return function(match) { + var _i, _q, _ref, j, match, slice, x, x$1, x$2; + if (result[0] === sliceType$14.nil) { + result[0] = $makeSlice(sliceType$14, 0, 10); + } + slice = $makeSlice(sliceType$12, (_q = match.$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); + _ref = slice; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + j = _i; + if ((x = $imul(2, j), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { + ((j < 0 || j >= slice.$length) ? ($throwRuntimeError("index out of range"), undefined) : slice.$array[slice.$offset + j] = $subslice(b[0], (x$1 = $imul(2, j), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, j)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); + } + _i++; + } + result[0] = $append(result[0], slice); + }; })(b, result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllSubmatch }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllSubmatch = function(b, n) { return this.$val.FindAllSubmatch(b, n); }; + Regexp.ptr.prototype.FindAllSubmatchIndex = function(b, n) { + var b, n, re, result, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + re = this; + if (n < 0) { + n = b.$length + 1 >> 0; + } + result[0] = sliceType$13.nil; + $r = re.allMatches("", b, n, (function(result) { return function(match) { + var match; + if (result[0] === sliceType$13.nil) { + result[0] = $makeSlice(sliceType$13, 0, 10); + } + result[0] = $append(result[0], match); + }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllSubmatchIndex }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllSubmatchIndex = function(b, n) { return this.$val.FindAllSubmatchIndex(b, n); }; + Regexp.ptr.prototype.FindAllStringSubmatch = function(s, n) { + var n, re, result, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + s = [s]; + re = this; + if (n < 0) { + n = s[0].length + 1 >> 0; + } + result[0] = sliceType$15.nil; + $r = re.allMatches(s[0], sliceType$5.nil, n, (function(result, s) { return function(match) { + var _i, _q, _ref, j, match, slice, x, x$1, x$2; + if (result[0] === sliceType$15.nil) { + result[0] = $makeSlice(sliceType$15, 0, 10); + } + slice = $makeSlice(sliceType$9, (_q = match.$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); + _ref = slice; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + j = _i; + if ((x = $imul(2, j), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { + ((j < 0 || j >= slice.$length) ? ($throwRuntimeError("index out of range"), undefined) : slice.$array[slice.$offset + j] = $substring(s[0], (x$1 = $imul(2, j), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, j)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); + } + _i++; + } + result[0] = $append(result[0], slice); + }; })(result, s)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringSubmatch }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllStringSubmatch = function(s, n) { return this.$val.FindAllStringSubmatch(s, n); }; + Regexp.ptr.prototype.FindAllStringSubmatchIndex = function(s, n) { + var n, re, result, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = [result]; + re = this; + if (n < 0) { + n = s.length + 1 >> 0; + } + result[0] = sliceType$13.nil; + $r = re.allMatches(s, sliceType$5.nil, n, (function(result) { return function(match) { + var match; + if (result[0] === sliceType$13.nil) { + result[0] = $makeSlice(sliceType$13, 0, 10); + } + result[0] = $append(result[0], match); + }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return result[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringSubmatchIndex }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.FindAllStringSubmatchIndex = function(s, n) { return this.$val.FindAllStringSubmatchIndex(s, n); }; + Regexp.ptr.prototype.Split = function(s, n) { + var _i, _r, _ref, beg, end, match, matches, n, re, s, strings$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; beg = $f.beg; end = $f.end; match = $f.match; matches = $f.matches; n = $f.n; re = $f.re; s = $f.s; strings$1 = $f.strings$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + re = this; + if (n === 0) { + $s = -1; return sliceType$9.nil; + } + if (re.expr.length > 0 && (s.length === 0)) { + $s = -1; return new sliceType$9([""]); + } + _r = re.FindAllStringIndex(s, n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + matches = _r; + strings$1 = $makeSlice(sliceType$9, 0, matches.$length); + beg = 0; + end = 0; + _ref = matches; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + match = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (n > 0 && strings$1.$length >= (n - 1 >> 0)) { + break; + } + end = (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]); + if (!(((1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]) === 0))) { + strings$1 = $append(strings$1, $substring(s, beg, end)); + } + beg = (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]); + _i++; + } + if (!((end === s.length))) { + strings$1 = $append(strings$1, $substring(s, beg)); + } + $s = -1; return strings$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Split }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.beg = beg; $f.end = end; $f.match = match; $f.matches = matches; $f.n = n; $f.re = re; $f.s = s; $f.strings$1 = strings$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Regexp.prototype.Split = function(s, n) { return this.$val.Split(s, n); }; + ptrType.methods = [{prop: "reset", name: "reset", pkg: "regexp", typ: $funcType([ptrType$12, $Int, $Int], [], false)}, {prop: "shouldVisit", name: "shouldVisit", pkg: "regexp", typ: $funcType([$Uint32, $Int], [$Bool], false)}, {prop: "push", name: "push", pkg: "regexp", typ: $funcType([ptrType$11, $Uint32, $Int, $Bool], [], false)}]; + ptrType$13.methods = [{prop: "init", name: "init", pkg: "regexp", typ: $funcType([$Int], [], false)}, {prop: "alloc", name: "alloc", pkg: "regexp", typ: $funcType([ptrType$2], [ptrType$1], false)}, {prop: "match", name: "match", pkg: "regexp", typ: $funcType([input, $Int], [$Bool], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([ptrType$14], [], false)}, {prop: "step", name: "step", pkg: "regexp", typ: $funcType([ptrType$14, ptrType$14, $Int, $Int, $Int32, ptrType$3], [], false)}, {prop: "add", name: "add", pkg: "regexp", typ: $funcType([ptrType$14, $Uint32, $Int, sliceType$3, ptrType$3, ptrType$1], [ptrType$1], false)}]; + ptrType$15.methods = [{prop: "newBytes", name: "newBytes", pkg: "regexp", typ: $funcType([sliceType$5], [input], false)}, {prop: "newString", name: "newString", pkg: "regexp", typ: $funcType([$String], [input], false)}, {prop: "newReader", name: "newReader", pkg: "regexp", typ: $funcType([io.RuneReader], [input], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String], [input, $Int], false)}]; + lazyFlag.methods = [{prop: "match", name: "match", pkg: "regexp", typ: $funcType([syntax.EmptyOp], [$Bool], false)}]; + ptrType$8.methods = [{prop: "empty", name: "empty", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "next", name: "next", pkg: "regexp", typ: $funcType([], [$Uint32], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([], [], false)}, {prop: "contains", name: "contains", pkg: "regexp", typ: $funcType([$Uint32], [$Bool], false)}, {prop: "insert", name: "insert", pkg: "regexp", typ: $funcType([$Uint32], [], false)}, {prop: "insertNew", name: "insertNew", pkg: "regexp", typ: $funcType([$Uint32], [], false)}]; + runeSlice.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; + ptrType$11.methods = [{prop: "tryBacktrack", name: "tryBacktrack", pkg: "regexp", typ: $funcType([ptrType, input, $Uint32, $Int], [$Bool], false)}, {prop: "backtrack", name: "backtrack", pkg: "regexp", typ: $funcType([sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "doOnePass", name: "doOnePass", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "doMatch", name: "doMatch", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String], [$Bool], false)}, {prop: "doExecute", name: "doExecute", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Copy", name: "Copy", pkg: "", typ: $funcType([], [ptrType$11], false)}, {prop: "Longest", name: "Longest", pkg: "", typ: $funcType([], [], false)}, {prop: "get", name: "get", pkg: "regexp", typ: $funcType([], [ptrType$13], false)}, {prop: "put", name: "put", pkg: "regexp", typ: $funcType([ptrType$13], [], false)}, {prop: "NumSubexp", name: "NumSubexp", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SubexpNames", name: "SubexpNames", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "LiteralPrefix", name: "LiteralPrefix", pkg: "", typ: $funcType([], [$String, $Bool], false)}, {prop: "MatchReader", name: "MatchReader", pkg: "", typ: $funcType([io.RuneReader], [$Bool], false)}, {prop: "MatchString", name: "MatchString", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "Match", name: "Match", pkg: "", typ: $funcType([sliceType$5], [$Bool], false)}, {prop: "ReplaceAllString", name: "ReplaceAllString", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "ReplaceAllLiteralString", name: "ReplaceAllLiteralString", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "ReplaceAllStringFunc", name: "ReplaceAllStringFunc", pkg: "", typ: $funcType([$String, funcType], [$String], false)}, {prop: "replaceAll", name: "replaceAll", pkg: "regexp", typ: $funcType([sliceType$5, $String, $Int, funcType$1], [sliceType$5], false)}, {prop: "ReplaceAll", name: "ReplaceAll", pkg: "", typ: $funcType([sliceType$5, sliceType$5], [sliceType$5], false)}, {prop: "ReplaceAllLiteral", name: "ReplaceAllLiteral", pkg: "", typ: $funcType([sliceType$5, sliceType$5], [sliceType$5], false)}, {prop: "ReplaceAllFunc", name: "ReplaceAllFunc", pkg: "", typ: $funcType([sliceType$5, funcType$2], [sliceType$5], false)}, {prop: "pad", name: "pad", pkg: "regexp", typ: $funcType([sliceType$3], [sliceType$3], false)}, {prop: "allMatches", name: "allMatches", pkg: "regexp", typ: $funcType([$String, sliceType$5, $Int, funcType$3], [], false)}, {prop: "Find", name: "Find", pkg: "", typ: $funcType([sliceType$5], [sliceType$5], false)}, {prop: "FindIndex", name: "FindIndex", pkg: "", typ: $funcType([sliceType$5], [sliceType$3], false)}, {prop: "FindString", name: "FindString", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "FindStringIndex", name: "FindStringIndex", pkg: "", typ: $funcType([$String], [sliceType$3], false)}, {prop: "FindReaderIndex", name: "FindReaderIndex", pkg: "", typ: $funcType([io.RuneReader], [sliceType$3], false)}, {prop: "FindSubmatch", name: "FindSubmatch", pkg: "", typ: $funcType([sliceType$5], [sliceType$12], false)}, {prop: "Expand", name: "Expand", pkg: "", typ: $funcType([sliceType$5, sliceType$5, sliceType$5, sliceType$3], [sliceType$5], false)}, {prop: "ExpandString", name: "ExpandString", pkg: "", typ: $funcType([sliceType$5, $String, $String, sliceType$3], [sliceType$5], false)}, {prop: "expand", name: "expand", pkg: "regexp", typ: $funcType([sliceType$5, $String, sliceType$5, $String, sliceType$3], [sliceType$5], false)}, {prop: "FindSubmatchIndex", name: "FindSubmatchIndex", pkg: "", typ: $funcType([sliceType$5], [sliceType$3], false)}, {prop: "FindStringSubmatch", name: "FindStringSubmatch", pkg: "", typ: $funcType([$String], [sliceType$9], false)}, {prop: "FindStringSubmatchIndex", name: "FindStringSubmatchIndex", pkg: "", typ: $funcType([$String], [sliceType$3], false)}, {prop: "FindReaderSubmatchIndex", name: "FindReaderSubmatchIndex", pkg: "", typ: $funcType([io.RuneReader], [sliceType$3], false)}, {prop: "FindAll", name: "FindAll", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$12], false)}, {prop: "FindAllIndex", name: "FindAllIndex", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$13], false)}, {prop: "FindAllString", name: "FindAllString", pkg: "", typ: $funcType([$String, $Int], [sliceType$9], false)}, {prop: "FindAllStringIndex", name: "FindAllStringIndex", pkg: "", typ: $funcType([$String, $Int], [sliceType$13], false)}, {prop: "FindAllSubmatch", name: "FindAllSubmatch", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$14], false)}, {prop: "FindAllSubmatchIndex", name: "FindAllSubmatchIndex", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$13], false)}, {prop: "FindAllStringSubmatch", name: "FindAllStringSubmatch", pkg: "", typ: $funcType([$String, $Int], [sliceType$15], false)}, {prop: "FindAllStringSubmatchIndex", name: "FindAllStringSubmatchIndex", pkg: "", typ: $funcType([$String, $Int], [sliceType$13], false)}, {prop: "Split", name: "Split", pkg: "", typ: $funcType([$String, $Int], [sliceType$9], false)}]; + ptrType$16.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; + ptrType$17.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; + ptrType$18.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; + job.init("regexp", [{prop: "pc", name: "pc", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "arg", name: "arg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "pos", name: "pos", embedded: false, exported: false, typ: $Int, tag: ""}]); + bitState.init("regexp", [{prop: "end", name: "end", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "jobs", name: "jobs", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "visited", name: "visited", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}]); + queue.init("regexp", [{prop: "sparse", name: "sparse", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "dense", name: "dense", embedded: false, exported: false, typ: sliceType$10, tag: ""}]); + entry.init("regexp", [{prop: "pc", name: "pc", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "t", name: "t", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); + thread.init("regexp", [{prop: "inst", name: "inst", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); + machine.init("regexp", [{prop: "re", name: "re", embedded: false, exported: false, typ: ptrType$11, tag: ""}, {prop: "p", name: "p", embedded: false, exported: false, typ: ptrType$12, tag: ""}, {prop: "q0", name: "q0", embedded: false, exported: false, typ: queue, tag: ""}, {prop: "q1", name: "q1", embedded: false, exported: false, typ: queue, tag: ""}, {prop: "pool", name: "pool", embedded: false, exported: false, typ: sliceType$11, tag: ""}, {prop: "matched", name: "matched", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}]); + inputs.init("regexp", [{prop: "bytes", name: "bytes", embedded: false, exported: false, typ: inputBytes, tag: ""}, {prop: "string", name: "string", embedded: false, exported: false, typ: inputString, tag: ""}, {prop: "reader", name: "reader", embedded: false, exported: false, typ: inputReader, tag: ""}]); + onePassMachine.init("regexp", [{prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); + onePassProg.init("", [{prop: "Inst", name: "Inst", embedded: false, exported: true, typ: sliceType$6, tag: ""}, {prop: "Start", name: "Start", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "NumCap", name: "NumCap", embedded: false, exported: true, typ: $Int, tag: ""}]); + onePassInst.init("", [{prop: "Inst", name: "Inst", embedded: true, exported: true, typ: syntax.Inst, tag: ""}, {prop: "Next", name: "Next", embedded: false, exported: true, typ: sliceType$2, tag: ""}]); + queueOnePass.init("regexp", [{prop: "sparse", name: "sparse", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "dense", name: "dense", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "size", name: "size", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "nextIndex", name: "nextIndex", embedded: false, exported: false, typ: $Uint32, tag: ""}]); + runeSlice.init($Int32); + Regexp.init("regexp", [{prop: "expr", name: "expr", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "prog", name: "prog", embedded: false, exported: false, typ: ptrType$12, tag: ""}, {prop: "onepass", name: "onepass", embedded: false, exported: false, typ: ptrType$6, tag: ""}, {prop: "numSubexp", name: "numSubexp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "maxBitStateLen", name: "maxBitStateLen", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "subexpNames", name: "subexpNames", embedded: false, exported: false, typ: sliceType$9, tag: ""}, {prop: "prefix", name: "prefix", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "prefixBytes", name: "prefixBytes", embedded: false, exported: false, typ: sliceType$5, tag: ""}, {prop: "prefixRune", name: "prefixRune", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "prefixEnd", name: "prefixEnd", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "mpool", name: "mpool", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "prefixComplete", name: "prefixComplete", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "cond", name: "cond", embedded: false, exported: false, typ: syntax.EmptyOp, tag: ""}, {prop: "longest", name: "longest", embedded: false, exported: false, typ: $Bool, tag: ""}]); + input.init([{prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}]); + inputString.init("regexp", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); + inputBytes.init("regexp", [{prop: "str", name: "str", embedded: false, exported: false, typ: sliceType$5, tag: ""}]); + inputReader.init("regexp", [{prop: "r", name: "r", embedded: false, exported: false, typ: io.RuneReader, tag: ""}, {prop: "atEOT", name: "atEOT", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "pos", name: "pos", embedded: false, exported: false, typ: $Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syntax.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + bitStatePool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); + onePassPool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); + arrayNoInts = arrayType.zero(); + matchPool = arrayType$1.zero(); + specialBytes = arrayType$2.zero(); + noRune = new sliceType$1([]); + noNext = new sliceType$2([4294967295]); + anyRuneNotNL = new sliceType$1([0, 9, 11, 1114111]); + anyRune = new sliceType$1([0, 1114111]); + matchSize = $toNativeArray($kindInt, [128, 512, 2048, 16384, 0]); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/bonedaddy/vcaptcha/vdf"] = (function() { + var $pkg = {}, $init, bytes, sha256, binary, fmt, log, math, big, regexp, runtime, sort, time, ClassGroup, Pair, VDF, sliceType, sliceType$1, ptrType, ptrType$1, sliceType$2, arrayType, sliceType$3, sliceType$4, sliceType$5, arrayType$1, chanType, ptrType$2, residues, sieve_info, m, bigOne, CloneClassGroup, NewClassGroup, NewClassGroupFromAbDiscriminant, NewClassGroupFromBytesDiscriminant, IdentityForDiscriminant, EntropyFromSeed, CreateDiscriminant, floorDivision, decodeTwosComplement, encodeTwosComplement, signBitFill, extendedGCD, allInputValueGCD, SolveMod, primeLessThanN, checkArrayEqual, testIntLessThan, main, approximateParameters, iterateSquarings, GenerateVDF, GenerateVDFWithStopChan, VerifyVDF, hashPrime, getBlock, evalOptimized, generateProof, calculateVDF, verifyProof, timeTrack, New; + bytes = $packages["bytes"]; + sha256 = $packages["crypto/sha256"]; + binary = $packages["encoding/binary"]; + fmt = $packages["fmt"]; + log = $packages["log"]; + math = $packages["math"]; + big = $packages["math/big"]; + regexp = $packages["regexp"]; + runtime = $packages["runtime"]; + sort = $packages["sort"]; + time = $packages["time"]; + ClassGroup = $pkg.ClassGroup = $newType(0, $kindStruct, "vdf.ClassGroup", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(a_, b_, c_, d_) { + this.$val = this; + if (arguments.length === 0) { + this.a = ptrType.nil; + this.b = ptrType.nil; + this.c = ptrType.nil; + this.d = ptrType.nil; + return; + } + this.a = a_; + this.b = b_; + this.c = c_; + this.d = d_; + }); + Pair = $pkg.Pair = $newType(0, $kindStruct, "vdf.Pair", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(p_, q_) { + this.$val = this; + if (arguments.length === 0) { + this.p = new $Int64(0, 0); + this.q = new $Int64(0, 0); + return; + } + this.p = p_; + this.q = q_; + }); + VDF = $pkg.VDF = $newType(0, $kindStruct, "vdf.VDF", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(difficulty_, input_, output_, outputChan_, finished_) { + this.$val = this; + if (arguments.length === 0) { + this.difficulty = 0; + this.input = arrayType.zero(); + this.output = arrayType$1.zero(); + this.outputChan = $chanNil; + this.finished = false; + return; + } + this.difficulty = difficulty_; + this.input = input_; + this.output = output_; + this.outputChan = outputChan_; + this.finished = finished_; + }); + sliceType = $sliceType($Int); + sliceType$1 = $sliceType(Pair); + ptrType = $ptrType(big.Int); + ptrType$1 = $ptrType(ClassGroup); + sliceType$2 = $sliceType($Uint8); + arrayType = $arrayType($Uint8, 32); + sliceType$3 = $sliceType($Bool); + sliceType$4 = $sliceType($emptyInterface); + sliceType$5 = $sliceType(ptrType$1); + arrayType$1 = $arrayType($Uint8, 516); + chanType = $chanType(arrayType$1, false, false); + ptrType$2 = $ptrType(VDF); + CloneClassGroup = function(cg) { + var cg; + return new ClassGroup.ptr(cg.a, cg.b, cg.c, ptrType.nil); + }; + $pkg.CloneClassGroup = CloneClassGroup; + NewClassGroup = function(a, b, c) { + var a, b, c; + return new ClassGroup.ptr(a, b, c, ptrType.nil); + }; + $pkg.NewClassGroup = NewClassGroup; + NewClassGroupFromAbDiscriminant = function(a, b, discriminant) { + var _r, a, b, c, discriminant, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; c = $f.c; discriminant = $f.discriminant; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + z = new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(b, b), discriminant); + _r = floorDivision(z, new big.Int.ptr(false, big.nat.nil).Mul(a, big.NewInt(new $Int64(0, 4)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + c = _r; + $s = -1; return NewClassGroup(a, b, c); + /* */ } return; } if ($f === undefined) { $f = { $blk: NewClassGroupFromAbDiscriminant }; } $f._r = _r; $f.a = a; $f.b = b; $f.c = c; $f.discriminant = discriminant; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewClassGroupFromAbDiscriminant = NewClassGroupFromAbDiscriminant; + NewClassGroupFromBytesDiscriminant = function(buf, discriminant) { + var _r, a, b, buf, discriminant, int_size, int_size_bits, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; buf = $f.buf; discriminant = $f.discriminant; int_size = $f.int_size; int_size_bits = $f.int_size_bits; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + int_size_bits = discriminant.BitLen(); + int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; + if (!((buf.$length === ($imul(int_size, 2))))) { + $s = -1; return [ptrType$1.nil, false]; + } + a = decodeTwosComplement($subslice(buf, 0, int_size)); + b = decodeTwosComplement($subslice(buf, int_size)); + _r = NewClassGroupFromAbDiscriminant(a, b, discriminant); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return [_r, true]; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewClassGroupFromBytesDiscriminant }; } $f._r = _r; $f.a = a; $f.b = b; $f.buf = buf; $f.discriminant = discriminant; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewClassGroupFromBytesDiscriminant = NewClassGroupFromBytesDiscriminant; + IdentityForDiscriminant = function(d) { + var _r, d, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 1)), big.NewInt(new $Int64(0, 1)), d); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: IdentityForDiscriminant }; } $f._r = _r; $f.d = d; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.IdentityForDiscriminant = IdentityForDiscriminant; + ClassGroup.ptr.prototype.Normalized = function() { + var _r, a, b, c, group, oldB, r, t, x, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; c = $f.c; group = $f.group; oldB = $f.oldB; r = $f.r; t = $f.t; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + a = new big.Int.ptr(false, big.nat.nil).Set(group.a); + b = new big.Int.ptr(false, big.nat.nil).Set(group.b); + c = new big.Int.ptr(false, big.nat.nil).Set(group.c); + if (((b.Cmp(new big.Int.ptr(false, big.nat.nil).Neg(a)) === 1)) && (b.Cmp(a) < 1)) { + $s = -1; return group; + } + r = new big.Int.ptr(false, big.nat.nil).Sub(a, b); + _r = floorDivision(r, new big.Int.ptr(false, big.nat.nil).Mul(a, big.NewInt(new $Int64(0, 2)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + t = new big.Int.ptr(false, big.nat.nil).Mul(big.NewInt(new $Int64(0, 2)), r); + t.Mul(t, a); + oldB = new big.Int.ptr(false, big.nat.nil).Set(b); + b.Add(b, t); + x = new big.Int.ptr(false, big.nat.nil).Mul(a, r); + x.Mul(x, r); + y = new big.Int.ptr(false, big.nat.nil).Mul(oldB, r); + c.Add(c, x); + c.Add(c, y); + $s = -1; return NewClassGroup(a, b, c); + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Normalized }; } $f._r = _r; $f.a = a; $f.b = b; $f.c = c; $f.group = group; $f.oldB = oldB; $f.r = r; $f.t = t; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Normalized = function() { return this.$val.Normalized(); }; + ClassGroup.ptr.prototype.Reduced = function() { + var _r, _r$1, _r$2, a, b, c, g, group, oldA, oldB, s, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; a = $f.a; b = $f.b; c = $f.c; g = $f.g; group = $f.group; oldA = $f.oldA; oldB = $f.oldB; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = group.Normalized(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + g = _r; + a = new big.Int.ptr(false, big.nat.nil).Set(g.a); + b = new big.Int.ptr(false, big.nat.nil).Set(g.b); + c = new big.Int.ptr(false, big.nat.nil).Set(g.c); + /* while (true) { */ case 2: + /* if (!(((a.Cmp(c) === 1)) || (((a.Cmp(c) === 0)) && ((b.Sign() === -1))))) { break; } */ if(!(((a.Cmp(c) === 1)) || (((a.Cmp(c) === 0)) && ((b.Sign() === -1))))) { $s = 3; continue; } + s = new big.Int.ptr(false, big.nat.nil).Add(c, b); + _r$1 = floorDivision(s, new big.Int.ptr(false, big.nat.nil).Add(c, c)); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + s = _r$1; + oldA = new big.Int.ptr(false, big.nat.nil).Set(a); + oldB = new big.Int.ptr(false, big.nat.nil).Set(b); + a = new big.Int.ptr(false, big.nat.nil).Set(c); + b.Neg(b); + x = new big.Int.ptr(false, big.nat.nil).Mul(big.NewInt(new $Int64(0, 2)), s); + x.Mul(x, c); + b.Add(b, x); + c.Mul(c, s); + c.Mul(c, s); + oldB.Mul(oldB, s); + c.Sub(c, oldB); + c.Add(c, oldA); + /* } */ $s = 2; continue; case 3: + _r$2 = NewClassGroup(a, b, c).Normalized(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Reduced }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.a = a; $f.b = b; $f.c = c; $f.g = g; $f.group = group; $f.oldA = oldA; $f.oldB = oldB; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Reduced = function() { return this.$val.Reduced(); }; + ClassGroup.ptr.prototype.identity = function() { + var _r, group, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; group = $f.group; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 1)), big.NewInt(new $Int64(0, 1)), group.Discriminant()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.identity }; } $f._r = _r; $f.group = group; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.identity = function() { return this.$val.identity(); }; + ClassGroup.ptr.prototype.Discriminant = function() { + var a, d, group; + group = this; + if (group.d === ptrType.nil) { + d = new big.Int.ptr(false, big.nat.nil).Set(group.b); + d.Mul(d, d); + a = new big.Int.ptr(false, big.nat.nil).Set(group.a); + a.Mul(a, group.c); + a.Mul(a, big.NewInt(new $Int64(0, 4))); + d.Sub(d, a); + group.d = d; + } + return group.d; + }; + ClassGroup.prototype.Discriminant = function() { return this.$val.Discriminant(); }; + ClassGroup.ptr.prototype.Multiply = function(other) { + var _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, a3, b, b3, c3, constant_factor, g, group, h, hu, j, jm, ju, k, k_temp, kl, kt, l, ls, m$1, mr, n, other, r, ru, s, sc, solvable, st, t, tuk, u, w, w1, x, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a3 = $f.a3; b = $f.b; b3 = $f.b3; c3 = $f.c3; constant_factor = $f.constant_factor; g = $f.g; group = $f.group; h = $f.h; hu = $f.hu; j = $f.j; jm = $f.jm; ju = $f.ju; k = $f.k; k_temp = $f.k_temp; kl = $f.kl; kt = $f.kt; l = $f.l; ls = $f.ls; m$1 = $f.m$1; mr = $f.mr; n = $f.n; other = $f.other; r = $f.r; ru = $f.ru; s = $f.s; sc = $f.sc; solvable = $f.solvable; st = $f.st; t = $f.t; tuk = $f.tuk; u = $f.u; w = $f.w; w1 = $f.w1; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + _r$1 = other.Reduced(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + y = _r$1; + g = new big.Int.ptr(false, big.nat.nil).Add(x.b, y.b); + _r$2 = floorDivision(g, big.NewInt(new $Int64(0, 2))); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + g = _r$2; + h = new big.Int.ptr(false, big.nat.nil).Sub(y.b, x.b); + _r$3 = floorDivision(h, big.NewInt(new $Int64(0, 2))); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + h = _r$3; + _r$4 = allInputValueGCD(y.a, g); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + w1 = _r$4; + _r$5 = allInputValueGCD(x.a, w1); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + w = _r$5; + j = new big.Int.ptr(false, big.nat.nil).Set(w); + r = big.NewInt(new $Int64(0, 0)); + _r$6 = floorDivision(x.a, w); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + s = _r$6; + _r$7 = floorDivision(y.a, w); /* */ $s = 8; case 8: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + t = _r$7; + _r$8 = floorDivision(g, w); /* */ $s = 9; case 9: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + u = _r$8; + b = new big.Int.ptr(false, big.nat.nil).Mul(h, u); + sc = new big.Int.ptr(false, big.nat.nil).Mul(s, x.c); + b.Add(b, sc); + _r$9 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, u), b, new big.Int.ptr(false, big.nat.nil).Mul(s, t)); /* */ $s = 10; case 10: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _tuple = _r$9; + k_temp = _tuple[0]; + constant_factor = _tuple[1]; + solvable = _tuple[2]; + if (!solvable) { + $s = -1; return ptrType$1.nil; + } + _r$10 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, constant_factor), new big.Int.ptr(false, big.nat.nil).Sub(h, new big.Int.ptr(false, big.nat.nil).Mul(t, k_temp)), s); /* */ $s = 11; case 11: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _tuple$1 = _r$10; + n = _tuple$1[0]; + solvable = _tuple$1[2]; + if (!solvable) { + $s = -1; return ptrType$1.nil; + } + k = new big.Int.ptr(false, big.nat.nil).Add(k_temp, new big.Int.ptr(false, big.nat.nil).Mul(constant_factor, n)); + _r$11 = floorDivision(new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(t, k), h), s); /* */ $s = 12; case 12: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + l = _r$11; + tuk = new big.Int.ptr(false, big.nat.nil).Mul(t, u); + tuk.Mul(tuk, k); + hu = new big.Int.ptr(false, big.nat.nil).Mul(h, u); + tuk.Sub(tuk, hu); + tuk.Sub(tuk, sc); + st = new big.Int.ptr(false, big.nat.nil).Mul(s, t); + _r$12 = floorDivision(tuk, st); /* */ $s = 13; case 13: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + m$1 = _r$12; + ru = new big.Int.ptr(false, big.nat.nil).Mul(r, u); + a3 = st.Sub(st, ru); + ju = new big.Int.ptr(false, big.nat.nil).Mul(j, u); + mr = new big.Int.ptr(false, big.nat.nil).Mul(m$1, r); + ju = ju.Add(ju, mr); + kt = new big.Int.ptr(false, big.nat.nil).Mul(k, t); + ls = new big.Int.ptr(false, big.nat.nil).Mul(l, s); + kt = kt.Add(kt, ls); + b3 = ju.Sub(ju, kt); + kl = new big.Int.ptr(false, big.nat.nil).Mul(k, l); + jm = new big.Int.ptr(false, big.nat.nil).Mul(j, m$1); + c3 = kl.Sub(kl, jm); + _r$13 = NewClassGroup(a3, b3, c3).Reduced(); /* */ $s = 14; case 14: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + $s = -1; return _r$13; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Multiply }; } $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a3 = a3; $f.b = b; $f.b3 = b3; $f.c3 = c3; $f.constant_factor = constant_factor; $f.g = g; $f.group = group; $f.h = h; $f.hu = hu; $f.j = j; $f.jm = jm; $f.ju = ju; $f.k = k; $f.k_temp = k_temp; $f.kl = kl; $f.kt = kt; $f.l = l; $f.ls = ls; $f.m$1 = m$1; $f.mr = mr; $f.n = n; $f.other = other; $f.r = r; $f.ru = ru; $f.s = s; $f.sc = sc; $f.solvable = solvable; $f.st = st; $f.t = t; $f.tuk = tuk; $f.u = u; $f.w = w; $f.w1 = w1; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Multiply = function(other) { return this.$val.Multiply(other); }; + ClassGroup.ptr.prototype.Pow = function(n) { + var _r, _r$1, _r$2, group, items_prod, n, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; group = $f.group; items_prod = $f.items_prod; n = $f.n; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + x = CloneClassGroup(group); + _r = group.identity(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + items_prod = _r; + /* while (true) { */ case 2: + /* if (!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { break; } */ if(!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { $s = 3; continue; } + /* */ if ((x$1 = new $Int64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((x$1 = new $Int64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { */ case 4: + _r$1 = items_prod.Multiply(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + items_prod = _r$1; + if (items_prod === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + /* } */ case 5: + _r$2 = x.Square(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + if (x === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + n = $shiftRightInt64(n, (1)); + /* } */ $s = 2; continue; case 3: + $s = -1; return items_prod; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Pow }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.group = group; $f.items_prod = items_prod; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Pow = function(n) { return this.$val.Pow(n); }; + ClassGroup.ptr.prototype.BigPow = function(n) { + var _r, _r$1, _r$2, group, items_prod, n, p, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; group = $f.group; items_prod = $f.items_prod; n = $f.n; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + x = CloneClassGroup(group); + _r = group.identity(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + items_prod = _r; + p = new big.Int.ptr(false, big.nat.nil).Set(n); + /* while (true) { */ case 2: + /* if (!(p.Sign() > 0)) { break; } */ if(!(p.Sign() > 0)) { $s = 3; continue; } + /* */ if (p.Bit(0) === 1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (p.Bit(0) === 1) { */ case 4: + _r$1 = items_prod.Multiply(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + items_prod = _r$1; + if (items_prod === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + /* } */ case 5: + _r$2 = x.Square(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + if (x === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + p.Rsh(p, 1); + /* } */ $s = 2; continue; case 3: + $s = -1; return items_prod; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.BigPow }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.group = group; $f.items_prod = items_prod; $f.n = n; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.BigPow = function(n) { return this.$val.BigPow(n); }; + ClassGroup.ptr.prototype.Square = function() { + var A, B, C, _r, _r$1, _r$2, _tuple, au, group, m$1, solvable, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; C = $f.C; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; au = $f.au; group = $f.group; m$1 = $f.m$1; solvable = $f.solvable; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = SolveMod(group.b, group.c, group.a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + u = _tuple[0]; + solvable = _tuple[2]; + if (!solvable) { + $s = -1; return ptrType$1.nil; + } + A = new big.Int.ptr(false, big.nat.nil).Mul(group.a, group.a); + au = new big.Int.ptr(false, big.nat.nil).Mul(group.a, u); + B = new big.Int.ptr(false, big.nat.nil).Sub(group.b, new big.Int.ptr(false, big.nat.nil).Mul(au, big.NewInt(new $Int64(0, 2)))); + C = new big.Int.ptr(false, big.nat.nil).Mul(u, u); + m$1 = new big.Int.ptr(false, big.nat.nil).Mul(group.b, u); + m$1 = new big.Int.ptr(false, big.nat.nil).Sub(m$1, group.c); + _r$1 = floorDivision(m$1, group.a); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + m$1 = _r$1; + C = new big.Int.ptr(false, big.nat.nil).Sub(C, m$1); + _r$2 = NewClassGroup(A, B, C).Reduced(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Square }; } $f.A = A; $f.B = B; $f.C = C; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.au = au; $f.group = group; $f.m$1 = m$1; $f.solvable = solvable; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Square = function() { return this.$val.Square(); }; + ClassGroup.ptr.prototype.SquareUsingMultiply = function() { + var _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tuple, _tuple$1, a3, b, b3, c3, constant_factor, g, group, h, hu, j, jm, ju, k, k_temp, kl, kt, l, ls, m$1, mr, n, r, ru, s, sc, solvable, st, t, tuk, u, w, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a3 = $f.a3; b = $f.b; b3 = $f.b3; c3 = $f.c3; constant_factor = $f.constant_factor; g = $f.g; group = $f.group; h = $f.h; hu = $f.hu; j = $f.j; jm = $f.jm; ju = $f.ju; k = $f.k; k_temp = $f.k_temp; kl = $f.kl; kt = $f.kt; l = $f.l; ls = $f.ls; m$1 = $f.m$1; mr = $f.mr; n = $f.n; r = $f.r; ru = $f.ru; s = $f.s; sc = $f.sc; solvable = $f.solvable; st = $f.st; t = $f.t; tuk = $f.tuk; u = $f.u; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + g = x.b; + h = big.NewInt(new $Int64(0, 0)); + _r$1 = allInputValueGCD(x.a, g); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + w = _r$1; + j = new big.Int.ptr(false, big.nat.nil).Set(w); + r = big.NewInt(new $Int64(0, 0)); + _r$2 = floorDivision(x.a, w); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + s = _r$2; + t = s; + _r$3 = floorDivision(g, w); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + u = _r$3; + b = new big.Int.ptr(false, big.nat.nil).Mul(h, u); + sc = new big.Int.ptr(false, big.nat.nil).Mul(s, x.c); + b.Add(b, sc); + _r$4 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, u), b, new big.Int.ptr(false, big.nat.nil).Mul(s, t)); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple = _r$4; + k_temp = _tuple[0]; + constant_factor = _tuple[1]; + solvable = _tuple[2]; + if (!solvable) { + $s = -1; return ptrType$1.nil; + } + _r$5 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, constant_factor), new big.Int.ptr(false, big.nat.nil).Sub(h, new big.Int.ptr(false, big.nat.nil).Mul(t, k_temp)), s); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$1 = _r$5; + n = _tuple$1[0]; + solvable = _tuple$1[2]; + if (!solvable) { + $s = -1; return ptrType$1.nil; + } + k = new big.Int.ptr(false, big.nat.nil).Add(k_temp, new big.Int.ptr(false, big.nat.nil).Mul(constant_factor, n)); + _r$6 = floorDivision(new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(t, k), h), s); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + l = _r$6; + tuk = new big.Int.ptr(false, big.nat.nil).Mul(t, u); + tuk.Mul(tuk, k); + hu = new big.Int.ptr(false, big.nat.nil).Mul(h, u); + tuk.Sub(tuk, hu); + tuk.Sub(tuk, sc); + st = new big.Int.ptr(false, big.nat.nil).Mul(s, t); + _r$7 = floorDivision(tuk, st); /* */ $s = 8; case 8: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + m$1 = _r$7; + ru = new big.Int.ptr(false, big.nat.nil).Mul(r, u); + a3 = st.Sub(st, ru); + ju = new big.Int.ptr(false, big.nat.nil).Mul(j, u); + mr = new big.Int.ptr(false, big.nat.nil).Mul(m$1, r); + ju = ju.Add(ju, mr); + kt = new big.Int.ptr(false, big.nat.nil).Mul(k, t); + ls = new big.Int.ptr(false, big.nat.nil).Mul(l, s); + kt = kt.Add(kt, ls); + b3 = ju.Sub(ju, kt); + kl = new big.Int.ptr(false, big.nat.nil).Mul(k, l); + jm = new big.Int.ptr(false, big.nat.nil).Mul(j, m$1); + c3 = kl.Sub(kl, jm); + _r$8 = NewClassGroup(a3, b3, c3).Reduced(); /* */ $s = 9; case 9: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + $s = -1; return _r$8; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.SquareUsingMultiply }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a3 = a3; $f.b = b; $f.b3 = b3; $f.c3 = c3; $f.constant_factor = constant_factor; $f.g = g; $f.group = group; $f.h = h; $f.hu = hu; $f.j = j; $f.jm = jm; $f.ju = ju; $f.k = k; $f.k_temp = k_temp; $f.kl = kl; $f.kt = kt; $f.l = l; $f.ls = ls; $f.m$1 = m$1; $f.mr = mr; $f.n = n; $f.r = r; $f.ru = ru; $f.s = s; $f.sc = sc; $f.solvable = solvable; $f.st = st; $f.t = t; $f.tuk = tuk; $f.u = u; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.SquareUsingMultiply = function() { return this.$val.SquareUsingMultiply(); }; + ClassGroup.ptr.prototype.Serialize = function() { + var _r, buf, group, int_size, int_size_bits, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; buf = $f.buf; group = $f.group; int_size = $f.int_size; int_size_bits = $f.int_size_bits; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + int_size_bits = group.Discriminant().BitLen(); + int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; + buf = $makeSlice(sliceType$2, ($imul(int_size, 2))); + $copySlice($subslice(buf, 0, int_size), signBitFill(encodeTwosComplement(r.a), int_size)); + $copySlice($subslice(buf, int_size), signBitFill(encodeTwosComplement(r.b), int_size)); + $s = -1; return buf; + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Serialize }; } $f._r = _r; $f.buf = buf; $f.group = group; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Serialize = function() { return this.$val.Serialize(); }; + ClassGroup.ptr.prototype.Equal = function(other) { + var _r, _r$1, g, group, o, other, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; g = $f.g; group = $f.group; o = $f.o; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + group = this; + _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + g = _r; + _r$1 = other.Reduced(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + o = _r$1; + $s = -1; return (g.a.Cmp(o.a) === 0) && (g.b.Cmp(o.b) === 0) && (g.c.Cmp(o.c) === 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Equal }; } $f._r = _r; $f._r$1 = _r$1; $f.g = g; $f.group = group; $f.o = o; $f.other = other; $f.$s = $s; $f.$r = $r; return $f; + }; + ClassGroup.prototype.Equal = function(other) { return this.$val.Equal(other); }; + EntropyFromSeed = function(seed, byte_count) { + var _r, buffer, bufferSize, byte_count, bytes$1, extra, more_entropy, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; buffer = $f.buffer; bufferSize = $f.bufferSize; byte_count = $f.byte_count; bytes$1 = $f.bytes$1; extra = $f.extra; more_entropy = $f.more_entropy; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + buffer = new bytes.Buffer.ptr(sliceType$2.nil, 0, 0); + bufferSize = 0; + extra = 0; + bytes$1 = $makeSlice(sliceType$2, (seed.$length + 2 >> 0)); + $copySlice(bytes$1, seed); + /* while (true) { */ case 1: + /* if (!(bufferSize <= byte_count)) { break; } */ if(!(bufferSize <= byte_count)) { $s = 2; continue; } + $clone(binary.BigEndian, binary.bigEndian).PutUint16($subslice(bytes$1, seed.$length), extra); + _r = sha256.Sum256(bytes$1); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + more_entropy = $clone(_r, arrayType); + buffer.Write(new sliceType$2(more_entropy)); + bufferSize = bufferSize + (32) >> 0; + extra = extra + (1) << 16 >>> 16; + /* } */ $s = 1; continue; case 2: + $s = -1; return $subslice(buffer.Bytes(), 0, byte_count); + /* */ } return; } if ($f === undefined) { $f = { $blk: EntropyFromSeed }; } $f._r = _r; $f.buffer = buffer; $f.bufferSize = bufferSize; $f.byte_count = byte_count; $f.bytes$1 = bytes$1; $f.extra = extra; $f.more_entropy = more_entropy; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.EntropyFromSeed = EntropyFromSeed; + CreateDiscriminant = function(seed, length) { + var _arg, _arg$1, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _v, bigM, byte_count, entropy, extra, i, i$1, length, n, negN, seed, sieve, t, v, v$1, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; bigM = $f.bigM; byte_count = $f.byte_count; entropy = $f.entropy; extra = $f.extra; i = $f.i; i$1 = $f.i$1; length = $f.length; n = $f.n; negN = $f.negN; seed = $f.seed; sieve = $f.sieve; t = $f.t; v = $f.v; v$1 = $f.v$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + extra = (((length << 24 >>> 24)) & 7) >>> 0; + byte_count = ((((length + 7 >> 0)) >> 3 >> 0)) + 2 >> 0; + _r = EntropyFromSeed(seed, byte_count); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + entropy = _r; + n = new big.Int.ptr(false, big.nat.nil); + n.SetBytes($subslice(entropy, 0, (entropy.$length - 2 >> 0))); + n = new big.Int.ptr(false, big.nat.nil).Rsh(n, (((((((8 - extra << 24 >>> 24)) & 7) >>> 0)) >>> 0))); + n = new big.Int.ptr(false, big.nat.nil).SetBit(n, length - 1 >> 0, 1); + _arg = n; + _r$1 = new big.Int.ptr(false, big.nat.nil).Mod(n, big.NewInt((new $Int64(0, m)))); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _arg$1 = _r$1; + _r$2 = new big.Int.ptr(false, big.nat.nil).Sub(_arg, _arg$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + n = _r$2; + n = new big.Int.ptr(false, big.nat.nil).Add(n, big.NewInt((new $Int64(0, (x = (_r$3 = (($clone(binary.BigEndian, binary.bigEndian).Uint16($subslice(entropy, (entropy.$length - 2 >> 0), entropy.$length)) >> 0)) % residues.$length, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")), ((x < 0 || x >= residues.$length) ? ($throwRuntimeError("index out of range"), undefined) : residues.$array[residues.$offset + x])))))); + negN = new big.Int.ptr(false, big.nat.nil).Neg(n); + /* while (true) { */ case 4: + sieve = $makeSlice(sliceType$3, 65536); + _ref = sieve_info; + _i = 0; + /* while (true) { */ case 6: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 7; continue; } + v = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), Pair); + _r$4 = new big.Int.ptr(false, big.nat.nil).Mod(negN, big.NewInt(v.p)); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$5 = _r$4.Int64(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + i = $div64(($mul64(_r$5, v.q)), v.p, true); + while (true) { + if (!((x$1 = (new $Int64(0, sieve.$length)), (i.$high < x$1.$high || (i.$high === x$1.$high && i.$low < x$1.$low))))) { break; } + (($flatten64(i) < 0 || $flatten64(i) >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + $flatten64(i)] = true); + i = (x$2 = v.p, new $Int64(i.$high + x$2.$high, i.$low + x$2.$low)); + } + _i++; + /* } */ $s = 6; continue; case 7: + _ref$1 = sieve; + _i$1 = 0; + /* while (true) { */ case 10: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 11; continue; } + i$1 = _i$1; + v$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + t = new big.Int.ptr(false, big.nat.nil).Add(n, big.NewInt($mul64((new $Int64(0, m)), (new $Int64(0, i$1))))); + if (!(!v$1)) { _v = false; $s = 14; continue s; } + _r$6 = t.ProbablyPrime(1); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v = _r$6; case 14: + /* */ if (_v) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_v) { */ case 12: + $s = -1; return new big.Int.ptr(false, big.nat.nil).Neg(t); + /* } */ case 13: + _i$1++; + /* } */ $s = 10; continue; case 11: + bigM = big.NewInt((new $Int64(0, m))); + n = new big.Int.ptr(false, big.nat.nil).Add(n, bigM.Mul(bigM, big.NewInt(new $Int64(0, 65536)))); + /* } */ $s = 4; continue; case 5: + $s = -1; return ptrType.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: CreateDiscriminant }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f.bigM = bigM; $f.byte_count = byte_count; $f.entropy = entropy; $f.extra = extra; $f.i = i; $f.i$1 = i$1; $f.length = length; $f.n = n; $f.negN = negN; $f.seed = seed; $f.sieve = sieve; $f.t = t; $f.v = v; $f.v$1 = v$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.CreateDiscriminant = CreateDiscriminant; + floorDivision = function(x, y) { + var _r, _tuple, q, r, x, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; q = $f.q; r = $f.r; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = [r]; + r[0] = new big.Int.ptr(false, big.nat.nil); + _r = new big.Int.ptr(false, big.nat.nil).QuoRem(x, y, r[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + q = _tuple[0]; + if (((r[0].Sign() === 1) && (y.Sign() === -1)) || ((r[0].Sign() === -1) && (y.Sign() === 1))) { + q.Sub(q, big.NewInt(new $Int64(0, 1))); + } + $s = -1; return q; + /* */ } return; } if ($f === undefined) { $f = { $blk: floorDivision }; } $f._r = _r; $f._tuple = _tuple; $f.q = q; $f.r = r; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + decodeTwosComplement = function(bytes$1) { + var _i, _ref, bytes$1, i, n, setyb; + if ((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0) { + return new big.Int.ptr(false, big.nat.nil).SetBytes(bytes$1); + } + setyb = $makeSlice(sliceType$2, bytes$1.$length); + _ref = bytes$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= setyb.$length) ? ($throwRuntimeError("index out of range"), undefined) : setyb.$array[setyb.$offset + i] = ((((i < 0 || i >= bytes$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + i]) ^ 255) << 24 >>> 24)); + _i++; + } + n = new big.Int.ptr(false, big.nat.nil).SetBytes(setyb); + return n.Sub(n.Neg(n), bigOne); + }; + encodeTwosComplement = function(n) { + var _i, _ref, buf, buf$1, bytes$1, bytes$2, i, n, nMinus1; + if (n.Sign() > 0) { + bytes$1 = n.Bytes(); + if ((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0) { + return bytes$1; + } + buf = $makeSlice(sliceType$2, (bytes$1.$length + 1 >> 0)); + $copySlice($subslice(buf, 1), bytes$1); + return buf; + } + if (n.Sign() < 0) { + nMinus1 = new big.Int.ptr(false, big.nat.nil).Neg(n); + nMinus1.Sub(nMinus1, bigOne); + bytes$2 = nMinus1.Bytes(); + if (bytes$2.$length === 0) { + return new sliceType$2([255]); + } + _ref = bytes$2; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= bytes$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + i] = ((((i < 0 || i >= bytes$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + i]) ^ (255)) << 24 >>> 24)); + _i++; + } + if (!(((((0 >= bytes$2.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + 0]) & 128) >>> 0) === 0))) { + return bytes$2; + } + buf$1 = $makeSlice(sliceType$2, (bytes$2.$length + 1 >> 0)); + (0 >= buf$1.$length ? ($throwRuntimeError("index out of range"), undefined) : buf$1.$array[buf$1.$offset + 0] = 255); + $copySlice($subslice(buf$1, 1), bytes$2); + return buf$1; + } + return new sliceType$2([]); + }; + signBitFill = function(bytes$1, targetLen) { + var buf, bytes$1, i, offset, targetLen; + if (bytes$1.$length >= targetLen) { + return bytes$1; + } + buf = $makeSlice(sliceType$2, targetLen); + offset = targetLen - bytes$1.$length >> 0; + if (!(((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0))) { + i = 0; + while (true) { + if (!(i < offset)) { break; } + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 255); + i = i + (1) >> 0; + } + } + $copySlice($subslice(buf, offset), bytes$1); + return buf; + }; + extendedGCD = function(a, b) { + var _r, _tmp, _tmp$1, _tmp$2, _tuple, a, b, bb, oldR0, oldS0, oldS0$1, oldS1, oldT0, q, r, r$1, r0, r1, s, s0, s1, t, t0, t1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; a = $f.a; b = $f.b; bb = $f.bb; oldR0 = $f.oldR0; oldS0 = $f.oldS0; oldS0$1 = $f.oldS0$1; oldS1 = $f.oldS1; oldT0 = $f.oldT0; q = $f.q; r = $f.r; r$1 = $f.r$1; r0 = $f.r0; r1 = $f.r1; s = $f.s; s0 = $f.s0; s1 = $f.s1; t = $f.t; t0 = $f.t0; t1 = $f.t1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = ptrType.nil; + s = ptrType.nil; + t = ptrType.nil; + r0 = new big.Int.ptr(false, big.nat.nil).Set(a); + r1 = new big.Int.ptr(false, big.nat.nil).Set(b); + s0 = big.NewInt(new $Int64(0, 1)); + s1 = big.NewInt(new $Int64(0, 0)); + t0 = big.NewInt(new $Int64(0, 0)); + t1 = big.NewInt(new $Int64(0, 1)); + if (r0.Cmp(r1) === 1) { + oldR0 = new big.Int.ptr(false, big.nat.nil).Set(r0); + r0 = r1; + r1 = oldR0; + oldS0 = new big.Int.ptr(false, big.nat.nil).Set(s0); + s0 = t0; + oldS1 = new big.Int.ptr(false, big.nat.nil).Set(s1); + s1 = t1; + t0 = oldS0; + t1 = oldS1; + } + /* while (true) { */ case 1: + /* if (!(r1.Sign() === 1)) { break; } */ if(!(r1.Sign() === 1)) { $s = 2; continue; } + r$1 = big.NewInt(new $Int64(0, 1)); + bb = new big.Int.ptr(false, big.nat.nil).Set(b); + _r = bb.DivMod(r0, r1, r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + q = _tuple[0]; + r$1 = _tuple[1]; + r0 = r1; + r1 = r$1; + oldS0$1 = new big.Int.ptr(false, big.nat.nil).Set(s0); + s0 = s1; + s1 = new big.Int.ptr(false, big.nat.nil).Sub(oldS0$1, new big.Int.ptr(false, big.nat.nil).Mul(q, s1)); + oldT0 = new big.Int.ptr(false, big.nat.nil).Set(t0); + t0 = t1; + t1 = new big.Int.ptr(false, big.nat.nil).Sub(oldT0, new big.Int.ptr(false, big.nat.nil).Mul(q, t1)); + /* } */ $s = 1; continue; case 2: + _tmp = r0; + _tmp$1 = s0; + _tmp$2 = t0; + r = _tmp; + s = _tmp$1; + t = _tmp$2; + $s = -1; return [r, s, t]; + /* */ } return; } if ($f === undefined) { $f = { $blk: extendedGCD }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.bb = bb; $f.oldR0 = oldR0; $f.oldS0 = oldS0; $f.oldS0$1 = oldS0$1; $f.oldS1 = oldS1; $f.oldT0 = oldT0; $f.q = q; $f.r = r; $f.r$1 = r$1; $f.r0 = r0; $f.r1 = r1; $f.s = s; $f.s0 = s0; $f.s1 = s1; $f.t = t; $f.t0 = t0; $f.t1 = t1; $f.$s = $s; $f.$r = $r; return $f; + }; + allInputValueGCD = function(a, b) { + var _r, a, b, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = ptrType.nil; + if (a.Sign() === 0) { + r = new big.Int.ptr(false, big.nat.nil).Abs(b); + $s = -1; return r; + } + if (b.Sign() === 0) { + r = new big.Int.ptr(false, big.nat.nil).Abs(a); + $s = -1; return r; + } + _r = new big.Int.ptr(false, big.nat.nil).GCD(ptrType.nil, ptrType.nil, new big.Int.ptr(false, big.nat.nil).Abs(a), new big.Int.ptr(false, big.nat.nil).Abs(b)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + $s = -1; return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: allInputValueGCD }; } $f._r = _r; $f.a = a; $f.b = b; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + SolveMod = function(a, b, m$1) { + var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, a, b, bb, d, g, m$1, q, r, s, solvable, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; b = $f.b; bb = $f.bb; d = $f.d; g = $f.g; m$1 = $f.m$1; q = $f.q; r = $f.r; s = $f.s; solvable = $f.solvable; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = ptrType.nil; + t = ptrType.nil; + solvable = false; + _r = extendedGCD(a, m$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + g = _tuple[0]; + d = _tuple[1]; + r = big.NewInt(new $Int64(0, 1)); + bb = new big.Int.ptr(false, big.nat.nil).Set(b); + _r$1 = bb.DivMod(b, g, r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + q = _tuple$1[0]; + r = _tuple$1[1]; + if (!((r.Cmp(big.NewInt(new $Int64(0, 0))) === 0))) { + _tmp = ptrType.nil; + _tmp$1 = ptrType.nil; + _tmp$2 = false; + s = _tmp; + t = _tmp$1; + solvable = _tmp$2; + $s = -1; return [s, t, solvable]; + } + q.Mul(q, d); + _r$2 = q.Mod(q, m$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + s = _r$2; + _r$3 = floorDivision(m$1, g); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + t = _r$3; + _tmp$3 = s; + _tmp$4 = t; + _tmp$5 = true; + s = _tmp$3; + t = _tmp$4; + solvable = _tmp$5; + $s = -1; return [s, t, solvable]; + /* */ } return; } if ($f === undefined) { $f = { $blk: SolveMod }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.b = b; $f.bb = bb; $f.d = d; $f.g = g; $f.m$1 = m$1; $f.q = q; $f.r = r; $f.s = s; $f.solvable = solvable; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.SolveMod = SolveMod; + primeLessThanN = function(num) { + var i, i$1, j, num, primes, sieve; + sieve = $makeSlice(sliceType$3, (num + 1 >> 0)); + i = 3; + while (true) { + if (!(i <= ((math.Floor(math.Sqrt((num))) >> 0)))) { break; } + if (((i < 0 || i >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + i]) === false) { + j = $imul(i, 2); + while (true) { + if (!(j <= num)) { break; } + ((j < 0 || j >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + j] = true); + j = j + (i) >> 0; + } + } + i = i + (2) >> 0; + } + primes = $makeSlice(sliceType, 0, num); + i$1 = 3; + while (true) { + if (!(i$1 <= num)) { break; } + if (((i$1 < 0 || i$1 >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + i$1]) === false) { + primes = $append(primes, i$1); + } + i$1 = i$1 + (2) >> 0; + } + return primes; + }; + checkArrayEqual = function(a, b) { + var _i, _ref, a, b, i, v; + if (!((a.$length === b.$length))) { + return false; + } + _ref = a; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (!((v === ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i])))) { + return false; + } + _i++; + } + return true; + }; + testIntLessThan = function(num) { + var _r, i, num, primes, refPrimes, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; num = $f.num; primes = $f.primes; refPrimes = $f.refPrimes; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + refPrimes = $makeSlice(sliceType, 0, num); + i = 3; + /* while (true) { */ case 1: + /* if (!(i < num)) { break; } */ if(!(i < num)) { $s = 2; continue; } + _r = big.NewInt((new $Int64(0, i))).ProbablyPrime(1); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_r) { */ case 3: + refPrimes = $append(refPrimes, i); + /* } */ case 4: + i = i + (2) >> 0; + /* } */ $s = 1; continue; case 2: + primes = primeLessThanN(num); + $r = log.Printf("%v ", new sliceType$4([primes])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ if (checkArrayEqual(refPrimes, primes)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (checkArrayEqual(refPrimes, primes)) { */ case 7: + $r = log.Printf("OK", new sliceType$4([])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 9; continue; + /* } else { */ case 8: + $r = log.Printf("ERROR", new sliceType$4([])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 9: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: testIntLessThan }; } $f._r = _r; $f.i = i; $f.num = num; $f.primes = primes; $f.refPrimes = refPrimes; $f.$s = $s; $f.$r = $r; return $f; + }; + main = function() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = testIntLessThan(65536); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: main }; } $f.$s = $s; $f.$r = $r; return $f; + }; + approximateParameters = function(T) { + var L, T, intermediate, k, log_T, log_memory, w; + log_memory = math.Log(1e+07) / math.Log(2); + log_T = math.Log((T)) / math.Log(2); + L = 1; + if (log_T - log_memory > 0) { + L = ((math.Ceil(math.Pow(2, log_memory - 20)) >> 0)); + } + intermediate = (T) * math.Log(2) / (($imul(2, L))); + k = ((math.Max(math.Round(math.Log(intermediate) - math.Log(math.Log(intermediate)) + 0.25), 1) >> 0)); + w = ((math.Floor((T) / ((T) / (k) + (L) * math.Pow(2, ((k + 1 >> 0))))) - 2 >> 0)); + return [L, k, w]; + }; + iterateSquarings = function(x, powers_to_calculate, stop) { + var _i, _key, _r, _ref, _selection, currX, current_power, i, powers_calculated, powers_to_calculate, previous_power, stop, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _key = $f._key; _r = $f._r; _ref = $f._ref; _selection = $f._selection; currX = $f.currX; current_power = $f.current_power; i = $f.i; powers_calculated = $f.powers_calculated; powers_to_calculate = $f.powers_to_calculate; previous_power = $f.previous_power; stop = $f.stop; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + powers_calculated = {}; + previous_power = 0; + currX = CloneClassGroup(x); + $r = sort.Ints(powers_to_calculate); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _ref = powers_to_calculate; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + current_power = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + i = 0; + /* while (true) { */ case 4: + /* if (!(i < (current_power - previous_power >> 0))) { break; } */ if(!(i < (current_power - previous_power >> 0))) { $s = 5; continue; } + _r = currX.Pow(new $Int64(0, 2)); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + currX = _r; + if (currX === ptrType$1.nil) { + $s = -1; return false; + } + i = i + (1) >> 0; + /* } */ $s = 4; continue; case 5: + previous_power = current_power; + _key = current_power; (powers_calculated || $throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(_key)] = { k: _key, v: currX }; + _selection = $select([[stop], []]); + if (_selection[0] === 0) { + $s = -1; return false; + } else if (_selection[0] === 1) { + } + _i++; + /* } */ $s = 2; continue; case 3: + $s = -1; return powers_calculated; + /* */ } return; } if ($f === undefined) { $f = { $blk: iterateSquarings }; } $f._i = _i; $f._key = _key; $f._r = _r; $f._ref = _ref; $f._selection = _selection; $f.currX = currX; $f.current_power = current_power; $f.i = i; $f.powers_calculated = powers_calculated; $f.powers_to_calculate = powers_to_calculate; $f.previous_power = previous_power; $f.stop = stop; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + GenerateVDF = function(seed, iterations, int_size_bits) { + var _r, int_size_bits, iterations, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; int_size_bits = $f.int_size_bits; iterations = $f.iterations; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = GenerateVDFWithStopChan(seed, iterations, int_size_bits, $chanNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: GenerateVDF }; } $f._r = _r; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.GenerateVDF = GenerateVDF; + GenerateVDFWithStopChan = function(seed, iterations, int_size_bits, stop) { + var D, _r, _r$1, _r$2, _r$3, _r$4, _tuple, int_size_bits, iterations, proof, seed, stop, x, y, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; D = $f.D; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; int_size_bits = $f.int_size_bits; iterations = $f.iterations; proof = $f.proof; seed = $f.seed; stop = $f.stop; x = $f.x; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([timeTrack, [$clone(time.Now(), time.Time)]]); + _r = CreateDiscriminant(seed, int_size_bits); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + D = _r; + _r$1 = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 2)), big.NewInt(new $Int64(0, 1)), D); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + x = _r$1; + _r$2 = calculateVDF(D, x, iterations, int_size_bits, stop); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + y = _tuple[0]; + proof = _tuple[1]; + /* */ if ((y === ptrType$1.nil) || (proof === ptrType$1.nil)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((y === ptrType$1.nil) || (proof === ptrType$1.nil)) { */ case 4: + $s = -1; return [sliceType$2.nil, sliceType$2.nil]; + /* } else { */ case 5: + _r$3 = y.Serialize(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = proof.Serialize(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return [_r$3, _r$4]; + /* } */ case 6: + $s = -1; return [sliceType$2.nil, sliceType$2.nil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [sliceType$2.nil, sliceType$2.nil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: GenerateVDFWithStopChan }; } $f.D = D; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.proof = proof; $f.seed = seed; $f.stop = stop; $f.x = x; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + $pkg.GenerateVDFWithStopChan = GenerateVDFWithStopChan; + VerifyVDF = function(seed, proof_blob, iterations, int_size_bits) { + var D, _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, int_size, int_size_bits, iterations, proof, proof_blob, seed, x, y, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; D = $f.D; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; int_size = $f.int_size; int_size_bits = $f.int_size_bits; iterations = $f.iterations; proof = $f.proof; proof_blob = $f.proof_blob; seed = $f.seed; x = $f.x; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([timeTrack, [$clone(time.Now(), time.Time)]]); + int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; + _r = CreateDiscriminant(seed, int_size_bits); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + D = _r; + _r$1 = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 2)), big.NewInt(new $Int64(0, 1)), D); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + x = _r$1; + _r$2 = NewClassGroupFromBytesDiscriminant($subslice(proof_blob, 0, (($imul(2, int_size)))), D); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + y = _tuple[0]; + _r$3 = NewClassGroupFromBytesDiscriminant($subslice(proof_blob, ($imul(2, int_size))), D); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$1 = _r$3; + proof = _tuple$1[0]; + _r$4 = verifyProof(x, y, proof, iterations); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return _r$4; + /* */ } return; } } catch(err) { $err = err; $s = -1; return false; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: VerifyVDF }; } $f.D = D; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.proof = proof; $f.proof_blob = proof_blob; $f.seed = seed; $f.x = x; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + $pkg.VerifyVDF = VerifyVDF; + hashPrime = function(x, y) { + var _r, _r$1, checkSum, j, jBuf, s, x, x$1, y, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; checkSum = $f.checkSum; j = $f.j; jBuf = $f.jBuf; s = $f.s; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + j = new $Uint64(0, 0); + jBuf = $makeSlice(sliceType$2, 8); + z = new big.Int.ptr(false, big.nat.nil); + /* while (true) { */ case 1: + $clone(binary.BigEndian, binary.bigEndian).PutUint64(jBuf, j); + s = $appendSlice((new sliceType$2($stringToBytes("prime"))), jBuf); + s = $appendSlice(s, x); + s = $appendSlice(s, y); + _r = sha256.Sum256(s); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + checkSum = $clone(_r, arrayType); + z.SetBytes($subslice(new sliceType$2(checkSum), 0, 16)); + _r$1 = z.ProbablyPrime(1); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return z; + /* } */ case 5: + j = (x$1 = new $Uint64(0, 1), new $Uint64(j.$high + x$1.$high, j.$low + x$1.$low)); + /* } */ $s = 1; continue; case 2: + $s = -1; return ptrType.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: hashPrime }; } $f._r = _r; $f._r$1 = _r$1; $f.checkSum = checkSum; $f.j = j; $f.jBuf = jBuf; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + getBlock = function(i, k, T, B) { + var B, T, _r, _r$1, i, k, p1, p2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; i = $f.i; k = $f.k; p1 = $f.p1; p2 = $f.p2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p1 = big.NewInt((new $Int64(0, math.Pow(2, (k))))); + _r = new big.Int.ptr(false, big.nat.nil).Exp(big.NewInt(new $Int64(0, 2)), big.NewInt((new $Int64(0, (T - ($imul(k, ((i + 1 >> 0)))) >> 0)))), B); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p2 = _r; + _r$1 = floorDivision(new big.Int.ptr(false, big.nat.nil).Mul(p1, p2), B); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: getBlock }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.k = k; $f.p1 = p1; $f.p2 = p2; $f.$s = $s; $f.$r = $r; return $f; + }; + evalOptimized = function(identity, h, B, T, k, l, C) { + var B, C, T, _entry, _q, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, b, b$1, b0, b0$1, b1, b1$1, b_limit, c, d, h, i, identity, j, k, k0, k1, l, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, ys, z, z$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; C = $f.C; T = $f.T; _entry = $f._entry; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; b = $f.b; b$1 = $f.b$1; b0 = $f.b0; b0$1 = $f.b0$1; b1 = $f.b1; b1$1 = $f.b1$1; b_limit = $f.b_limit; c = $f.c; d = $f.d; h = $f.h; i = $f.i; identity = $f.identity; j = $f.j; k = $f.k; k0 = $f.k0; k1 = $f.k1; l = $f.l; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; ys = $f.ys; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + k1 = (_q = k / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + k0 = k - k1 >> 0; + x = CloneClassGroup(identity); + j = l - 1 >> 0; + /* while (true) { */ case 1: + /* if (!(j > -1)) { break; } */ if(!(j > -1)) { $s = 2; continue; } + b_limit = (new $Int64(0, math.Pow(2, (k)))); + _r = x.Pow(b_limit); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + if (x === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + ys = $makeSlice(sliceType$5, $flatten64(b_limit)); + b = new $Int64(0, 0); + while (true) { + if (!((b.$high < b_limit.$high || (b.$high === b_limit.$high && b.$low < b_limit.$low)))) { break; } + (($flatten64(b) < 0 || $flatten64(b) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b)] = identity); + b = (x$1 = new $Int64(0, 1), new $Int64(b.$high + x$1.$high, b.$low + x$1.$low)); + } + i = 0; + /* while (true) { */ case 4: + /* if (!(i < ((math.Ceil((T) / (($imul(k, l)))) >> 0)))) { break; } */ if(!(i < ((math.Ceil((T) / (($imul(k, l)))) >> 0)))) { $s = 5; continue; } + /* */ if ((T - ($imul(k, (((($imul(i, l)) + j >> 0) + 1 >> 0)))) >> 0) < 0) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((T - ($imul(k, (((($imul(i, l)) + j >> 0) + 1 >> 0)))) >> 0) < 0) { */ case 6: + i = i + (1) >> 0; + /* continue; */ $s = 4; continue; + /* } */ case 7: + _r$1 = getBlock(($imul(i, l)) + j >> 0, k, T, B); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.Int64(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + b$1 = _r$2; + _r$3 = (($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)]).Multiply((_entry = C[$Int.keyFor($imul(($imul(i, k)), l))], _entry !== undefined ? _entry.v : ptrType$1.nil)); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + (($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)] = _r$3); + if ((($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)]) === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + i = i + (1) >> 0; + /* } */ $s = 4; continue; case 5: + b1 = 0; + /* while (true) { */ case 11: + /* if (!(b1 < ((math.Pow(2, (k1)) >> 0)))) { break; } */ if(!(b1 < ((math.Pow(2, (k1)) >> 0)))) { $s = 12; continue; } + z = identity; + b0 = 0; + /* while (true) { */ case 13: + /* if (!(b0 < ((math.Pow(2, ((k0))) >> 0)))) { break; } */ if(!(b0 < ((math.Pow(2, ((k0))) >> 0)))) { $s = 14; continue; } + _r$4 = z.Multiply((x$2 = (x$3 = $mul64((new $Int64(0, b1)), (new $Int64(0, math.Pow(2, (k0))))), x$4 = (new $Int64(0, b0)), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), (($flatten64(x$2) < 0 || $flatten64(x$2) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(x$2)]))); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + z = _r$4; + if (z === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + b0 = b0 + (1) >> 0; + /* } */ $s = 13; continue; case 14: + _r$5 = z.Pow($mul64((new $Int64(0, b1)), (new $Int64(0, math.Pow(2, (k0)))))); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + c = _r$5; + if (c === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + _r$6 = x.Multiply(c); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + x = _r$6; + if (x === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + b1 = b1 + (1) >> 0; + /* } */ $s = 11; continue; case 12: + b0$1 = 0; + /* while (true) { */ case 18: + /* if (!(b0$1 < ((math.Pow(2, (k0)) >> 0)))) { break; } */ if(!(b0$1 < ((math.Pow(2, (k0)) >> 0)))) { $s = 19; continue; } + z$1 = identity; + b1$1 = 0; + /* while (true) { */ case 20: + /* if (!(b1$1 < ((math.Pow(2, (k1)) >> 0)))) { break; } */ if(!(b1$1 < ((math.Pow(2, (k1)) >> 0)))) { $s = 21; continue; } + _r$7 = z$1.Multiply((x$5 = (x$6 = $mul64((new $Int64(0, b1$1)), (new $Int64(0, math.Pow(2, (k0))))), x$7 = (new $Int64(0, b0$1)), new $Int64(x$6.$high + x$7.$high, x$6.$low + x$7.$low)), (($flatten64(x$5) < 0 || $flatten64(x$5) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(x$5)]))); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + z$1 = _r$7; + if (z$1 === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + b1$1 = b1$1 + (1) >> 0; + /* } */ $s = 20; continue; case 21: + _r$8 = z$1.Pow((new $Int64(0, b0$1))); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + d = _r$8; + if (d === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + _r$9 = x.Multiply(d); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + x = _r$9; + if (x === ptrType$1.nil) { + $s = -1; return ptrType$1.nil; + } + b0$1 = b0$1 + (1) >> 0; + /* } */ $s = 18; continue; case 19: + j = j - (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return x; + /* */ } return; } if ($f === undefined) { $f = { $blk: evalOptimized }; } $f.B = B; $f.C = C; $f.T = T; $f._entry = _entry; $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.b = b; $f.b$1 = b$1; $f.b0 = b0; $f.b0$1 = b0$1; $f.b1 = b1; $f.b1$1 = b1$1; $f.b_limit = b_limit; $f.c = c; $f.d = d; $f.h = h; $f.i = i; $f.identity = identity; $f.j = j; $f.k = k; $f.k0 = k0; $f.k1 = k1; $f.l = l; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.ys = ys; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; + }; + generateProof = function(identity, x, y, T, k, l, powers) { + var B, T, _r, _r$1, _r$2, _r$3, identity, k, l, powers, proof, x, x_s, y, y_s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; identity = $f.identity; k = $f.k; l = $f.l; powers = $f.powers; proof = $f.proof; x = $f.x; x_s = $f.x_s; y = $f.y; y_s = $f.y_s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = x.Serialize(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x_s = _r; + _r$1 = y.Serialize(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + y_s = _r$1; + _r$2 = hashPrime(x_s, y_s); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + B = _r$2; + _r$3 = evalOptimized(identity, x, B, T, k, l, powers); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + proof = _r$3; + $s = -1; return proof; + /* */ } return; } if ($f === undefined) { $f = { $blk: generateProof }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.identity = identity; $f.k = k; $f.l = l; $f.powers = powers; $f.proof = proof; $f.x = x; $f.x_s = x_s; $f.y = y; $f.y_s = y_s; $f.$s = $s; $f.$r = $r; return $f; + }; + calculateVDF = function(discriminant, x, iterations, int_size_bits, stop) { + var L, _entry, _r, _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, discriminant, i, identity, int_size_bits, iterations, k, loopCount, powers, powers_to_calculate, proof, stop, x, x$1, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; L = $f.L; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; discriminant = $f.discriminant; i = $f.i; identity = $f.identity; int_size_bits = $f.int_size_bits; iterations = $f.iterations; k = $f.k; loopCount = $f.loopCount; powers = $f.powers; powers_to_calculate = $f.powers_to_calculate; proof = $f.proof; stop = $f.stop; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + y = ptrType$1.nil; + proof = ptrType$1.nil; + _tuple = approximateParameters(iterations); + L = _tuple[0]; + k = _tuple[1]; + loopCount = ((math.Ceil((iterations) / (($imul(k, L)))) >> 0)); + powers_to_calculate = $makeSlice(sliceType, (loopCount + 2 >> 0)); + i = 0; + while (true) { + if (!(i < (loopCount + 1 >> 0))) { break; } + ((i < 0 || i >= powers_to_calculate.$length) ? ($throwRuntimeError("index out of range"), undefined) : powers_to_calculate.$array[powers_to_calculate.$offset + i] = ($imul(($imul(i, k)), L))); + i = i + (1) >> 0; + } + (x$1 = loopCount + 1 >> 0, ((x$1 < 0 || x$1 >= powers_to_calculate.$length) ? ($throwRuntimeError("index out of range"), undefined) : powers_to_calculate.$array[powers_to_calculate.$offset + x$1] = iterations)); + _r = iterateSquarings(x, powers_to_calculate, stop); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + powers = _r; + if (powers === false) { + _tmp = ptrType$1.nil; + _tmp$1 = ptrType$1.nil; + y = _tmp; + proof = _tmp$1; + $s = -1; return [y, proof]; + } + y = (_entry = powers[$Int.keyFor(iterations)], _entry !== undefined ? _entry.v : ptrType$1.nil); + _r$1 = IdentityForDiscriminant(discriminant); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + identity = _r$1; + _r$2 = generateProof(identity, x, y, iterations, k, L, powers); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + proof = _r$2; + _tmp$2 = y; + _tmp$3 = proof; + y = _tmp$2; + proof = _tmp$3; + $s = -1; return [y, proof]; + /* */ } return; } if ($f === undefined) { $f = { $blk: calculateVDF }; } $f.L = L; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.discriminant = discriminant; $f.i = i; $f.identity = identity; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.k = k; $f.loopCount = loopCount; $f.powers = powers; $f.powers_to_calculate = powers_to_calculate; $f.proof = proof; $f.stop = stop; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + verifyProof = function(x, y, proof, T) { + var B, T, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _v, piB, proof, r, x, xR, x_s, y, y_s, z, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _v = $f._v; piB = $f.piB; proof = $f.proof; r = $f.r; x = $f.x; xR = $f.xR; x_s = $f.x_s; y = $f.y; y_s = $f.y_s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = x.Serialize(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x_s = _r; + _r$1 = y.Serialize(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + y_s = _r$1; + _r$2 = hashPrime(x_s, y_s); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + B = _r$2; + _r$3 = new big.Int.ptr(false, big.nat.nil).Exp(big.NewInt(new $Int64(0, 2)), big.NewInt((new $Int64(0, T))), B); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + r = _r$3; + _r$4 = proof.BigPow(B); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + piB = _r$4; + if (piB === ptrType$1.nil) { + $s = -1; return false; + } + _r$5 = x.BigPow(r); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + xR = _r$5; + if (xR === ptrType$1.nil) { + $s = -1; return false; + } + _r$6 = piB.Multiply(xR); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + z = _r$6; + if (!(!(z === ptrType$1.nil))) { _v = false; $s = 11; continue s; } + _r$7 = z.Equal(y); /* */ $s = 12; case 12: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v = _r$7; case 11: + /* */ if (_v) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_v) { */ case 8: + $s = -1; return true; + /* } else { */ case 9: + $s = -1; return false; + /* } */ case 10: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: verifyProof }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._v = _v; $f.piB = piB; $f.proof = proof; $f.r = r; $f.x = x; $f.xR = xR; $f.x_s = x_s; $f.y = y; $f.y_s = y_s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; + }; + timeTrack = function(start) { + var _r, _r$1, _r$2, _tuple, elapsed, funcObj, name, pc, runtimeFunc, start, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; elapsed = $f.elapsed; funcObj = $f.funcObj; name = $f.name; pc = $f.pc; runtimeFunc = $f.runtimeFunc; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + elapsed = time.Since($clone(start, time.Time)); + _tuple = runtime.Caller(1); + pc = _tuple[0]; + funcObj = runtime.FuncForPC(pc); + _r = regexp.MustCompile("^.*\\.(.*)$"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + runtimeFunc = _r; + _r$1 = runtimeFunc.ReplaceAllString(funcObj.Name(), "$1"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + name = _r$1; + _r$2 = fmt.Sprintf("%s took %s", new sliceType$4([new $String(name), elapsed])); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = log.Println(new sliceType$4([new $String(_r$2)])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: timeTrack }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.elapsed = elapsed; $f.funcObj = funcObj; $f.name = name; $f.pc = pc; $f.runtimeFunc = runtimeFunc; $f.start = start; $f.$s = $s; $f.$r = $r; return $f; + }; + New = function(difficulty, input) { + var difficulty, input; + return new VDF.ptr(difficulty, $clone(input, arrayType), arrayType$1.zero(), new $Chan(arrayType$1, 0), false); + }; + $pkg.New = New; + VDF.ptr.prototype.GetOutputChannel = function() { + var vdf; + vdf = this; + return vdf.outputChan; + }; + VDF.prototype.GetOutputChannel = function() { return this.$val.GetOutputChannel(); }; + VDF.ptr.prototype.Execute = function() { + var _r, _tuple, proofBuf, vdf, yBuf, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; proofBuf = $f.proofBuf; vdf = $f.vdf; yBuf = $f.yBuf; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + vdf = [vdf]; + vdf[0] = this; + vdf[0].finished = false; + _r = GenerateVDF(new sliceType$2(vdf[0].input), vdf[0].difficulty, 2048); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + yBuf = _tuple[0]; + proofBuf = _tuple[1]; + $copySlice(new sliceType$2(vdf[0].output), yBuf); + $copySlice($subslice(new sliceType$2(vdf[0].output), 258), proofBuf); + $go((function(vdf) { return function $b() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = $send(vdf[0].outputChan, $clone($clone(vdf[0].output, arrayType$1), arrayType$1)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; + }; })(vdf), []); + vdf[0].finished = true; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: VDF.ptr.prototype.Execute }; } $f._r = _r; $f._tuple = _tuple; $f.proofBuf = proofBuf; $f.vdf = vdf; $f.yBuf = yBuf; $f.$s = $s; $f.$r = $r; return $f; + }; + VDF.prototype.Execute = function() { return this.$val.Execute(); }; + VDF.ptr.prototype.Verify = function(proof) { + var _r, proof, vdf, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; proof = $f.proof; vdf = $f.vdf; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + vdf = this; + _r = VerifyVDF(new sliceType$2(vdf.input), new sliceType$2(proof), vdf.difficulty, 2048); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: VDF.ptr.prototype.Verify }; } $f._r = _r; $f.proof = proof; $f.vdf = vdf; $f.$s = $s; $f.$r = $r; return $f; + }; + VDF.prototype.Verify = function(proof) { return this.$val.Verify(proof); }; + VDF.ptr.prototype.IsFinished = function() { + var vdf; + vdf = this; + return vdf.finished; + }; + VDF.prototype.IsFinished = function() { return this.$val.IsFinished(); }; + VDF.ptr.prototype.GetOutput = function() { + var vdf; + vdf = this; + return vdf.output; + }; + VDF.prototype.GetOutput = function() { return this.$val.GetOutput(); }; + ptrType$1.methods = [{prop: "Normalized", name: "Normalized", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Reduced", name: "Reduced", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "identity", name: "identity", pkg: "github.com/bonedaddy/vcaptcha/vdf", typ: $funcType([], [ptrType$1], false)}, {prop: "Discriminant", name: "Discriminant", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Pow", name: "Pow", pkg: "", typ: $funcType([$Int64], [ptrType$1], false)}, {prop: "BigPow", name: "BigPow", pkg: "", typ: $funcType([ptrType], [ptrType$1], false)}, {prop: "Square", name: "Square", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "SquareUsingMultiply", name: "SquareUsingMultiply", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Serialize", name: "Serialize", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([ptrType$1], [$Bool], false)}]; + ptrType$2.methods = [{prop: "GetOutputChannel", name: "GetOutputChannel", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Execute", name: "Execute", pkg: "", typ: $funcType([], [], false)}, {prop: "Verify", name: "Verify", pkg: "", typ: $funcType([arrayType$1], [$Bool], false)}, {prop: "IsFinished", name: "IsFinished", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "GetOutput", name: "GetOutput", pkg: "", typ: $funcType([], [arrayType$1], false)}]; + ClassGroup.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "a", name: "a", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "b", name: "b", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "c", name: "c", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "d", name: "d", embedded: false, exported: false, typ: ptrType, tag: ""}]); + Pair.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "p", name: "p", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "q", name: "q", embedded: false, exported: false, typ: $Int64, tag: ""}]); + VDF.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "difficulty", name: "difficulty", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "input", name: "input", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "output", name: "output", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "outputChan", name: "outputChan", embedded: false, exported: false, typ: chanType, tag: ""}, {prop: "finished", name: "finished", embedded: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sha256.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = binary.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = log.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = big.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = regexp.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + residues = new sliceType([23, 31, 47, 71, 79, 103, 127, 151, 167, 191, 199, 223, 239, 263, 271, 311, 359, 367, 383, 391, 431, 439, 463, 479, 487, 503, 527, 551, 599, 607, 631, 647, 703, 719, 727, 743, 751, 799, 823, 839, 863, 887, 911, 919, 943, 967, 983, 991, 1007, 1031, 1039, 1063, 1087, 1103, 1151, 1159, 1207, 1223, 1231, 1247, 1271, 1279, 1303, 1319, 1327, 1343, 1367, 1399, 1423, 1439, 1447, 1471, 1487, 1511, 1543, 1559, 1567, 1583, 1591, 1607, 1663, 1679, 1711, 1751, 1759, 1783, 1823, 1831, 1847, 1871, 1879, 1919, 1927, 1943, 1951, 1999, 2039, 2047, 2063, 2071, 2087, 2111, 2143, 2159, 2183, 2207, 2231, 2239, 2263, 2279, 2287, 2311, 2351, 2383, 2399, 2407, 2423, 2447, 2479, 2503, 2543, 2551, 2567, 2591, 2599, 2623, 2647, 2663, 2671, 2687, 2711, 2719, 2759, 2767, 2791, 2831, 2839, 2879, 2887, 2903, 2911, 2927, 2983, 2999, 3007, 3023, 3071, 3079, 3103, 3119, 3127, 3151, 3167, 3191, 3239, 3247, 3271, 3287, 3319, 3343, 3359, 3383, 3391, 3407, 3431, 3439, 3463, 3503, 3511, 3527, 3551, 3559, 3583, 3599, 3607, 3623, 3631, 3671, 3719, 3727, 3743, 3767, 3791, 3799, 3823, 3847, 3863, 3911, 3919, 3943, 3959, 3967, 4007, 4031, 4063, 4079, 4087, 4111, 4127, 4159, 4183, 4223, 4231, 4247, 4271, 4327, 4343, 4351, 4391, 4399, 4423, 4439, 4447, 4463, 4471, 4519, 4559, 4567, 4583, 4591, 4607, 4639, 4663, 4679, 4687, 4703, 4727, 4751, 4759, 4783, 4799, 4831, 4847, 4871, 4903, 4919, 4943, 4951, 4967, 4999, 5023, 5039, 5063, 5087, 5111, 5119, 5143, 5167, 5183, 5191, 5207, 5231, 5263, 5279, 5287, 5303, 5311, 5351, 5359, 5399, 5407, 5431, 5471, 5479, 5503, 5519, 5527, 5543, 5567, 5591, 5623, 5639, 5647, 5671, 5711, 5743, 5767, 5783, 5791, 5807, 5839, 5879, 5903, 5911, 5927, 5959, 5983, 6007, 6023, 6031, 6047, 6079, 6103, 6119, 6143, 6151, 6191, 6199, 6239, 6247, 6263, 6271, 6287, 6311, 6319, 6343, 6359, 6367, 6407, 6431, 6439, 6463, 6511, 6527, 6551, 6583, 6599, 6607, 6623, 6631, 6647, 6679, 6703, 6719, 6751, 6767, 6791, 6823, 6847, 6863, 6871, 6887, 6911, 6943, 6959, 6967, 6983, 6991, 7031, 7039, 7079, 7087, 7103, 7127, 7151, 7159, 7199, 7207, 7223, 7247, 7279, 7303, 7327, 7351, 7367, 7391, 7439, 7463, 7471, 7487, 7519, 7543, 7559, 7583, 7591, 7607, 7639, 7663, 7687, 7703, 7727, 7751, 7759, 7783, 7807, 7823, 7831, 7871, 7879, 7919, 7927, 7951, 7967, 7991, 7999, 8023, 8039, 8087, 8111, 8119, 8143, 8159, 8167, 8191, 8207, 8231, 8263, 8279, 8287, 8303, 8311, 8383, 8399, 8423, 8431, 8447, 8471, 8479, 8527, 8543, 8551, 8599, 8623, 8639, 8647, 8663, 8711, 8719, 8759, 8783, 8791, 8807, 8831, 8839, 8863, 8887, 8903, 8927, 8951, 8959, 8999, 9007, 9047, 9071, 9103, 9127, 9143, 9151, 9167, 9199, 9223, 9239, 9263, 9271, 9287, 9311, 9319, 9343, 9367, 9391, 9407, 9431, 9439, 9463, 9479, 9487, 9511, 9551, 9599, 9623, 9631, 9671, 9679, 9703, 9719, 9727, 9743, 9767, 9791, 9799, 9839, 9847, 9871, 9887, 9943, 9959, 9967, 9983, 9991, 10007, 10039, 10063, 10079, 10103, 10111, 10151, 10159, 10183, 10207, 10223, 10247, 10271, 10279, 10303, 10319, 10327, 10343, 10391, 10399, 10447, 10463, 10471, 10487, 10511, 10519, 10559, 10567, 10583, 10607, 10631, 10639, 10663, 10679, 10687, 10711, 10727, 10783, 10799, 10807, 10823, 10831, 10847, 10903, 10919, 10943, 10951, 10991, 10999, 11023, 11047, 11071, 11087, 11111, 11119, 11159, 11183, 11191, 11239, 11279, 11287, 11303, 11311, 11327, 11351, 11359, 11383, 11399, 11423, 11447, 11471, 11503, 11519, 11527, 11551, 11567, 11591, 11623, 11639, 11647, 11663, 11719, 11743, 11783, 11807, 11831, 11839, 11863, 11887, 11903, 11911, 11927, 11951, 11959, 11983, 12007, 12031, 12071, 12079, 12119, 12127, 12143, 12151, 12167, 12191, 12223, 12239, 12247, 12263, 12319, 12343, 12359, 12367, 12391, 12407, 12431, 12479, 12487, 12503, 12511, 12527, 12559, 12583, 12599, 12631, 12647, 12671, 12679, 12703, 12743, 12751, 12767, 12791, 12799, 12823, 12839, 12847, 12863, 12871, 12911, 12919, 12959, 12967, 12983, 13007, 13031, 13063, 13087, 13103, 13127, 13151, 13159, 13183, 13199, 13207, 13231, 13271, 13303, 13319, 13327, 13367, 13399, 13423, 13439, 13463, 13471, 13487, 13511, 13543, 13567, 13583, 13591, 13631, 13639, 13679, 13687, 13703, 13711, 13751, 13759, 13799, 13807, 13823, 13831, 13847, 13879, 13903, 13919, 13927, 13943, 13967, 13991, 13999, 14023, 14039, 14071, 14087, 14111, 14143, 14159, 14167, 14191, 14207, 14239, 14263, 14279, 14303, 14327, 14351, 14359, 14383, 14407, 14423, 14431, 14447, 14471, 14479, 14503, 14519, 14527, 14543, 14551, 14591, 14639, 14647, 14671, 14687, 14711, 14719, 14743, 14759, 14767, 14783, 14831, 14863, 14879, 14887, 14951, 14983, 14999, 15007, 15023, 15031, 15047, 15079, 15143, 15151, 15167, 15199, 15247, 15263, 15271, 15287, 15311, 15319, 15343, 15359, 15383, 15391, 15439, 15479, 15487, 15503, 15511, 15527, 15551, 15559, 15583, 15599, 15607, 15623, 15647, 15671, 15679, 15703, 15727, 15751, 15767, 15791, 15823, 15839, 15863, 15871, 15887, 15919, 15943, 15959, 15991, 16007, 16031, 16039, 16063, 16087, 16103, 16111, 16127, 16151, 16183, 16199, 16207, 16223, 16231, 16271, 16279, 16319, 16327, 16343, 16351, 16391, 16399, 16439, 16447, 16463, 16487, 16519, 16543, 16559, 16567, 16591, 16607, 16631, 16663, 16703, 16711, 16727, 16759, 16799, 16823, 16831, 16847, 16871, 16879, 16903, 16927, 16943, 16967, 16999, 17023, 17047, 17063, 17071, 17111, 17119, 17159, 17167, 17183, 17191, 17207, 17231, 17239, 17263, 17279, 17287, 17327, 17351, 17359, 17383, 17399, 17431, 17447, 17471, 17503, 17519, 17527, 17543, 17551, 17599, 17623, 17639, 17663, 17671, 17687, 17711, 17767, 17783, 17791, 17807, 17839, 17863, 17879, 17887, 17903, 17911, 17951, 17959, 17999, 18023, 18047, 18071, 18079, 18103, 18119, 18127, 18143, 18167, 18191, 18199, 18223, 18247, 18287, 18311, 18367, 18383, 18391, 18407, 18439, 18463, 18479, 18503, 18511, 18527, 18559, 18583, 18607, 18631, 18647, 18671, 18679, 18703, 18719, 18727, 18743, 18751, 18791, 18839, 18847, 18871, 18911, 18919, 18943, 18959, 18983, 19007, 19031, 19039, 19079, 19087, 19111, 19127, 19183, 19199, 19207, 19223, 19231, 19247, 19303, 19319, 19343, 19351, 19367, 19391, 19399, 19423, 19447, 19463, 19471, 19511, 19519, 19543, 19559, 19567, 19583, 19631, 19639, 19687, 19703, 19711, 19727, 19751, 19759, 19783, 19807, 19823, 19847, 19871, 19879, 19919, 19927, 19951, 19967, 19991, 20023, 20039, 20047, 20063, 20071, 20087, 20143, 20159, 20183, 20191, 20231, 20239, 20263, 20287, 20303, 20311, 20327, 20351, 20359, 20399, 20407, 20431, 20479, 20519, 20543, 20551, 20567, 20591, 20599, 20623, 20639, 20663, 20687, 20711, 20719, 20743, 20759, 20767, 20791, 20807, 20831, 20863, 20879, 20887, 20903, 20927, 20959, 20983, 21023, 21031, 21071, 21079, 21103, 21127, 21143, 21167, 21191, 21199, 21223, 21239, 21247, 21271, 21311, 21319, 21367, 21383, 21391, 21407, 21431, 21479, 21487, 21503, 21551, 21559, 21583, 21599, 21607, 21631, 21647, 21719, 21727, 21743, 21751, 21767, 21799, 21823, 21839, 21863, 21871, 21887, 21911, 21919, 21943, 21991, 22007, 22031, 22039, 22063, 22079, 22103, 22111, 22151, 22159, 22199, 22207, 22223, 22247, 22271, 22279, 22303, 22327, 22343, 22367, 22391, 22423, 22439, 22447, 22471, 22487, 22511, 22543, 22559, 22567, 22591, 22639, 22663, 22679, 22703, 22727, 22751, 22783, 22807, 22823, 22831, 22871, 22879, 22903, 22927, 22943, 22951, 22991, 22999, 23039, 23047, 23063, 23071, 23087, 23119, 23143, 23159, 23167, 23183, 23207, 23239, 23263, 23279, 23311, 23327, 23351, 23383, 23399, 23407, 23423, 23431, 23447, 23479, 23503, 23519, 23567, 23591, 23599, 23623, 23663, 23671, 23687, 23711, 23719, 23743, 23759, 23767, 23783, 23791, 23831, 23839, 23879, 23887, 23911, 23927, 23951, 23983, 23999, 24007, 24023, 24047, 24071, 24103, 24119, 24127, 24151, 24191, 24223, 24239, 24247, 24263, 24287, 24319, 24359, 24383, 24391, 24407, 24439, 24463, 24487, 24503, 24511, 24527, 24551, 24559, 24599, 24623, 24631, 24671, 24679, 24719, 24727, 24743, 24751, 24767, 24799, 24823, 24839, 24847, 24863, 24887, 24911, 24919, 24943, 24967, 24991, 25007, 25031, 25063, 25079, 25087, 25111, 25127, 25159, 25183, 25199, 25231, 25247, 25271, 25279, 25303, 25327, 25343, 25351, 25367, 25391, 25423, 25439, 25447, 25463, 25471, 25511, 25559, 25567, 25583, 25591, 25607, 25631, 25639, 25679, 25687, 25703, 25759, 25783, 25799, 25807, 25847, 25871, 25903, 25919, 25943, 25951, 25967, 25999, 26023, 26063, 26071, 26087, 26111, 26119, 26167, 26183, 26207, 26231, 26239, 26263, 26287, 26303, 26311, 26359, 26399, 26407, 26423, 26431, 26447, 26471, 26479, 26503, 26519, 26527, 26567, 26591, 26599, 26623, 26639, 26647, 26671, 26687, 26711, 26743, 26759, 26783, 26791, 26839, 26863, 26879, 26903, 26911, 26927, 26951, 26959, 27007, 27023, 27031, 27047, 27103, 27119, 27127, 27143, 27151, 27191, 27199, 27239, 27263, 27271, 27311, 27319, 27343, 27359, 27367, 27383, 27407, 27431, 27439, 27463, 27479, 27487, 27527, 27551, 27583, 27607, 27623, 27631, 27647, 27679, 27719, 27743, 27751, 27767, 27791, 27799, 27823, 27847, 27871, 27887, 27919, 27943, 27959, 27967, 27983, 27991, 28031, 28079, 28087, 28103, 28111, 28151, 28159, 28183, 28199, 28207, 28247, 28271, 28279, 28319, 28351, 28367, 28423, 28439, 28447, 28463, 28471, 28487, 28519, 28543, 28559, 28583, 28591, 28607, 28631, 28663, 28687, 28703, 28711, 28727, 28751, 28759, 28783, 28799, 28807, 28823, 28871, 28879, 28927, 28943, 28967, 28991, 28999, 29023, 29039, 29047, 29063, 29087, 29111, 29119, 29143, 29167, 29191, 29207, 29231, 29279, 29287, 29303, 29311, 29327, 29383, 29399, 29423, 29431, 29479, 29503, 29527, 29543, 29551, 29567, 29591, 29599, 29639, 29647, 29663, 29671, 29719, 29759, 29767, 29791, 29807, 29831, 29839, 29863, 29879, 29903, 29927, 29951, 29959, 29983, 29999, 30007, 30031, 30047, 30071, 30103, 30119, 30127, 30143, 30167, 30223, 30263, 30271, 30287, 30311, 30319, 30343, 30367, 30383, 30391, 30431, 30439, 30463, 30479, 30487, 30551, 30559, 30599, 30607, 30623, 30631, 30647, 30671, 30703, 30727, 30743, 30791, 30799, 30839, 30847, 30871, 30887, 30911, 30959, 30967, 30983, 30991, 31007, 31039, 31063, 31079, 31103, 31111, 31127, 31151, 31159, 31183, 31223, 31231, 31247, 31271, 31279, 31303, 31319, 31327, 31351, 31391, 31399, 31439, 31463, 31487, 31511, 31519, 31543, 31567, 31583, 31607, 31631, 31639, 31663, 31679, 31687, 31711, 31727, 31751, 31783, 31799, 31807, 31831, 31847, 31879, 31903, 31919, 31943, 31951, 31991, 32023, 32047, 32063, 32111, 32119, 32143, 32159, 32167, 32183, 32191, 32231, 32239, 32287, 32303, 32311, 32327, 32359, 32399, 32407, 32423, 32447, 32471, 32479, 32503, 32519, 32551, 32567, 32623, 32639, 32647, 32663, 32671, 32687, 32719, 32743, 32759, 32783, 32807, 32831, 32839, 32863, 32887, 32911, 32927, 32951, 32959, 32983, 32999, 33023, 33031, 33071, 33079, 33119, 33127, 33151, 33167, 33191, 33199, 33223, 33239, 33247, 33263, 33287, 33311, 33343, 33359, 33367, 33391, 33431, 33463, 33479, 33487, 33503, 33511, 33559, 33599, 33623, 33647, 33679, 33703, 33727, 33743, 33751, 33767, 33791, 33799, 33823, 33863, 33871, 33911, 33919, 33959, 33967, 33983, 33991, 34007, 34031, 34039, 34063, 34079, 34087, 34103, 34127, 34159, 34183, 34207, 34231, 34247, 34271, 34303, 34319, 34327, 34343, 34351, 34367, 34399, 34423, 34439, 34471, 34487, 34511, 34519, 34543, 34583, 34591, 34607, 34631, 34663, 34679, 34687, 34703, 34711, 34751, 34759, 34799, 34807, 34823, 34831, 34847, 34871, 34919, 34927, 34943, 34967, 34999, 35023, 35039, 35047, 35071, 35111, 35143, 35159, 35183, 35207, 35239, 35263, 35279, 35303, 35311, 35327, 35351, 35359, 35383, 35407, 35423, 35447, 35471, 35479, 35527, 35543, 35551, 35591, 35599, 35639, 35647, 35663, 35671, 35687, 35719, 35743, 35759, 35767, 35807, 35831, 35839, 35863, 35879, 35887, 35911, 35927, 35951, 35983, 35999, 36007, 36031, 36079, 36103, 36119, 36143, 36151, 36167, 36191, 36199, 36247, 36263, 36271, 36287, 36319, 36343, 36359, 36367, 36383, 36391, 36431, 36479, 36503, 36511, 36527, 36551, 36559, 36583, 36599, 36607, 36623, 36671, 36679, 36703, 36719, 36727, 36767, 36791, 36823, 36847, 36863, 36871, 36887, 36919, 36943, 36983, 36991, 37007, 37031, 37039, 37087, 37111, 37127, 37151, 37159, 37183, 37199, 37207, 37223, 37231, 37319, 37327, 37343, 37351, 37391, 37399, 37423, 37439, 37447, 37463, 37487, 37511, 37519, 37559, 37567, 37591, 37607, 37663, 37679, 37703, 37711, 37727, 37759, 37783, 37799, 37823, 37831, 37847, 37871, 37879, 37903, 37927, 37943, 37951, 37967, 37991, 38023, 38039, 38047, 38063, 38111, 38119, 38167, 38183, 38191, 38231, 38239, 38263, 38279, 38287, 38303, 38327, 38351, 38359, 38383, 38399, 38407, 38431, 38447, 38471, 38503, 38527, 38543, 38551, 38567, 38639, 38663, 38671, 38711, 38719, 38743, 38767, 38783, 38791, 38807, 38839, 38879, 38887, 38903, 38911, 38959, 38999, 39007, 39023, 39031, 39047, 39071, 39079, 39103, 39119, 39167, 39191, 39199, 39223, 39239, 39271, 39287, 39311, 39343, 39359, 39367, 39383, 39407, 39439, 39463, 39503, 39511, 39527, 39551, 39583, 39607, 39623, 39631, 39647, 39671, 39679, 39703, 39719, 39727, 39751, 39791, 39799, 39839, 39847, 39863, 39887, 39911, 39943, 39959, 39967, 39983, 40031, 40039, 40063, 40087, 40111, 40127, 40151, 40199, 40207, 40223, 40231, 40247, 40279, 40303, 40319, 40343, 40351, 40367, 40399, 40423, 40463, 40471, 40487, 40511, 40519, 40543, 40559, 40567, 40583, 40591, 40631, 40639, 40679, 40687, 40727, 40751, 40759, 40783, 40823, 40847, 40871, 40879, 40903, 40919, 40927, 40951, 40967, 40991, 41023, 41039, 41047, 41071, 41087, 41143, 41159, 41183, 41191, 41207, 41231, 41263, 41287, 41303, 41311, 41351, 41359, 41383, 41399, 41407, 41423, 41471, 41479, 41519, 41527, 41543, 41551, 41567, 41599, 41623, 41647, 41663, 41687, 41711, 41719, 41759, 41791, 41807, 41831, 41863, 41879, 41887, 41903, 41911, 41927, 41959, 41983, 41999, 42023, 42047, 42071, 42079, 42103, 42127, 42143, 42151, 42167, 42191, 42199, 42223, 42239, 42247, 42271, 42311, 42319, 42359, 42391, 42407, 42431, 42439, 42463, 42479, 42487, 42503, 42527, 42551, 42583, 42599, 42607, 42631, 42671, 42703, 42719, 42727, 42743, 42751, 42767, 42799, 42839, 42863, 42871, 42919, 42943, 42967, 42983, 43007, 43031, 43039, 43063, 43079, 43103, 43111, 43151, 43159, 43207, 43223, 43231, 43247, 43271, 43279, 43319, 43327, 43343, 43367, 43391, 43399, 43423, 43447, 43471, 43487, 43543, 43559, 43567, 43583, 43591, 43607, 43639, 43663, 43679, 43711, 43727, 43751, 43759, 43783, 43807, 43831, 43847, 43871, 43903, 43919, 43943, 43951, 43991, 43999, 44039, 44047, 44063, 44071, 44087, 44111, 44119, 44159, 44167, 44183, 44207, 44263, 44279, 44287, 44311, 44327, 44351, 44383, 44399, 44423, 44431, 44479, 44503, 44519, 44543, 44567, 44591, 44599, 44623, 44647, 44663, 44687, 44711, 44719, 44743, 44767, 44783, 44791, 44831, 44839, 44879, 44887, 44903, 44911, 44927, 44951, 44959, 44983, 44999, 45007, 45047, 45079, 45103, 45119, 45127, 45151, 45167, 45191, 45223, 45239, 45247, 45263, 45271, 45319, 45343, 45359, 45391, 45407, 45431, 45439, 45503, 45511, 45527, 45559, 45583, 45599, 45607, 45623, 45631, 45671, 45679, 45719, 45743, 45751, 45767, 45791, 45823, 45839, 45847, 45863, 45887, 45911, 45919, 45943, 45959, 45967, 46031, 46063, 46087, 46103, 46127, 46159, 46183, 46199, 46223, 46231, 46247, 46271, 46279, 46303, 46327, 46351, 46367, 46391, 46399, 46439, 46447, 46463, 46471, 46511, 46559, 46567, 46583, 46591, 46639, 46663, 46679, 46687, 46703, 46727, 46751, 46759, 46799, 46807, 46831, 46847, 46903, 46919, 46927, 46951, 46967, 46999, 47023, 47039, 47063, 47071, 47087, 47111, 47119, 47143, 47167, 47183, 47191, 47207, 47231, 47239, 47263, 47279, 47287, 47303, 47351, 47407, 47423, 47431, 47447, 47471, 47479, 47503, 47519, 47527, 47543, 47591, 47599, 47623, 47639, 47647, 47687, 47711, 47743, 47759, 47767, 47783, 47791, 47807, 47863, 47903, 47911, 47951, 47959, 48007, 48023, 48031, 48047, 48071, 48079, 48119, 48127, 48143, 48151, 48199, 48239, 48247, 48263, 48271, 48287, 48311, 48319, 48343, 48359, 48383, 48407, 48431, 48439, 48463, 48479, 48487, 48511, 48527, 48551, 48583, 48599, 48623, 48647, 48679, 48703, 48743, 48751, 48767, 48791, 48799, 48823, 48847, 48863, 48871, 48887, 48911, 48943, 48959, 48967, 48991, 49031, 49039, 49079, 49087, 49103, 49111, 49151, 49183, 49199, 49207, 49223, 49271, 49279, 49303, 49319, 49327, 49351, 49367, 49391, 49447, 49463, 49471, 49487, 49519, 49559, 49583, 49591, 49607, 49631, 49639, 49663, 49703, 49711, 49727, 49759, 49783, 49799, 49807, 49823, 49831, 49871, 49879, 49919, 49927, 49943, 49967, 49991, 49999, 50023, 50047, 50087, 50111, 50119, 50143, 50159, 50191, 50207, 50231, 50263, 50279, 50287, 50311, 50327, 50359, 50383, 50399, 50423, 50431, 50447, 50471, 50503, 50527, 50543, 50551, 50591, 50599, 50623, 50639, 50647, 50663, 50671, 50711, 50719, 50759, 50767, 50783, 50807, 50839, 50863, 50879, 50887, 50903, 50927, 50951, 50959, 50983, 51031, 51047, 51071, 51119, 51127, 51143, 51151, 51167, 51199, 51223, 51239, 51263, 51287, 51319, 51343, 51367, 51383, 51391, 51407, 51431, 51439, 51463, 51479, 51487, 51503, 51511, 51551, 51559, 51599, 51607, 51631, 51647, 51671, 51679, 51703, 51719, 51743, 51767, 51791, 51823, 51839, 51847, 51871, 51911, 51943, 51959, 51967, 51983, 51991, 52007, 52079, 52103, 52111, 52127, 52159, 52183, 52207, 52223, 52231, 52271, 52279, 52303, 52319, 52343, 52391, 52399, 52439, 52447, 52463, 52471, 52487, 52511, 52519, 52543, 52567, 52583, 52607, 52631, 52639, 52687, 52711, 52727, 52751, 52783, 52799, 52807, 52823, 52831, 52847, 52879, 52903, 52919, 52951, 52967, 52991, 52999, 53023, 53047, 53063, 53071, 53087, 53111, 53143, 53159, 53167, 53191, 53231, 53239, 53279, 53303, 53311, 53327, 53351, 53359, 53399, 53407, 53423, 53447, 53479, 53503, 53519, 53527, 53551, 53567, 53591, 53623, 53639, 53663, 53671, 53687, 53719, 53743, 53759, 53783, 53791, 53831, 53839, 53863, 53887, 53903, 53927, 53951, 53959, 53983, 54007, 54023, 54031, 54071, 54079, 54127, 54143, 54151, 54167, 54191, 54199, 54239, 54247, 54287, 54311, 54319, 54343, 54359, 54367, 54391, 54407, 54463, 54479, 54487, 54503, 54511, 54559, 54583, 54599, 54623, 54631, 54647, 54671, 54679, 54727, 54751, 54767, 54799, 54823, 54839, 54863, 54871, 54911, 54919, 54959, 54983, 54991, 55007, 55031, 55039, 55063, 55079, 55087, 55103, 55127, 55151, 55183, 55199, 55207, 55247, 55271, 55303, 55327, 55343, 55351, 55399, 55423, 55439, 55463, 55487, 55511, 55519, 55543, 55567, 55591, 55607, 55631, 55639, 55663, 55687, 55703, 55711, 55751, 55799, 55807, 55823, 55831, 55871, 55879, 55903, 55919, 55927, 55943, 55967, 55999, 56039, 56047, 56071, 56087, 56143, 56159, 56167, 56183, 56191, 56207, 56239, 56263, 56279, 56311, 56327, 56351, 56359, 56383, 56423, 56431, 56447, 56471, 56479, 56503, 56519, 56527, 56543, 56591, 56599, 56647, 56663, 56671, 56687, 56711, 56743, 56759, 56767, 56783, 56807, 56831, 56839, 56863, 56879, 56887, 56911, 56951, 56983, 56999, 57007, 57023, 57047, 57103, 57119, 57143, 57151, 57191, 57199, 57223, 57247, 57263, 57271, 57287, 57311, 57319, 57359, 57367, 57383, 57391, 57439, 57479, 57487, 57503, 57511, 57527, 57559, 57583, 57599, 57623, 57647, 57671, 57679, 57703, 57719, 57727, 57751, 57767, 57791, 57823, 57839, 57847, 57887, 57919, 57943, 57983, 57991, 58007, 58031, 58039, 58063, 58087, 58103, 58111, 58127, 58151, 58159, 58183, 58199, 58207, 58231, 58271, 58319, 58327, 58343, 58351, 58367, 58391, 58423, 58439, 58447, 58463, 58511, 58519, 58543, 58559, 58567, 58607, 58631, 58679, 58687, 58703, 58711, 58727, 58759, 58783, 58823, 58831, 58847, 58871, 58879, 58943, 58951, 58967, 58991, 58999, 59023, 59039, 59047, 59063, 59071, 59119, 59159, 59167, 59183, 59207, 59231, 59239, 59263, 59287, 59303, 59327, 59351, 59359, 59383, 59399, 59407, 59431, 59447, 59471, 59503, 59519, 59551, 59567, 59599, 59623, 59639, 59663, 59671, 59687, 59711, 59743, 59767, 59783, 59791, 59831, 59863, 59879, 59887, 59903, 59911, 59951, 59959, 59999, 60007, 60023, 60031, 60079, 60103, 60119, 60127, 60143, 60167, 60191, 60199, 60223, 60239, 60271, 60287, 60311, 60343, 60367, 60383, 60391, 60407, 60439, 60479, 60503, 60527, 60551, 60559, 60583, 60607, 60623, 60631, 60647, 60679, 60703, 60719, 60727, 60743, 60751, 60791, 60799, 60839, 60847, 60871, 60887, 60911, 60919, 60943, 60959, 60967, 61007, 61031, 61063, 61079, 61111, 61151, 61183, 61199, 61207, 61223, 61231, 61247, 61279, 61319, 61343, 61351, 61367, 61423, 61447, 61463, 61471, 61487, 61511, 61519, 61543, 61559, 61583, 61591, 61631, 61639, 61679, 61687, 61703, 61727, 61751, 61759, 61783, 61799, 61807, 61823, 61847, 61871, 61879, 61903, 61927, 61951, 61967, 61991, 62039, 62047, 62063, 62071, 62087, 62119, 62143, 62159, 62191, 62207, 62239, 62263, 62287, 62303, 62311, 62327, 62351, 62383, 62399, 62407, 62423, 62431, 62471, 62479, 62519, 62527, 62551, 62567, 62591, 62599, 62639, 62663, 62687, 62719, 62743, 62759, 62767, 62791, 62807, 62831, 62863, 62879, 62903, 62911, 62927, 62983, 62999, 63023, 63031, 63047, 63071, 63079, 63103, 63127, 63143, 63191, 63199, 63223, 63247, 63263, 63311, 63319, 63359, 63367, 63383, 63391, 63407, 63431, 63439, 63463, 63487, 63527, 63551, 63559, 63599, 63607, 63631, 63647, 63671, 63703, 63719, 63727, 63743, 63751, 63799, 63823, 63839, 63863, 63871, 63887, 63911, 63919, 63967, 63983, 63991, 64007, 64039, 64063, 64079, 64087, 64111, 64151, 64159, 64199, 64223, 64231, 64247, 64271, 64279, 64303, 64319, 64327, 64343, 64367, 64391, 64399, 64423, 64439, 64447, 64487, 64511, 64543, 64567, 64583, 64591, 64607, 64639, 64663, 64679, 64703, 64711, 64751, 64759, 64783, 64807, 64847, 64871, 64879, 64903, 64919, 64927, 64943, 64951, 64991, 65047, 65063, 65071, 65111, 65119, 65159, 65167, 65183, 65207, 65231, 65239, 65279, 65287, 65311, 65327, 65383, 65399, 65407, 65423, 65431, 65447, 65479, 65503, 65519, 65543, 65551, 65567, 65591, 65599, 65623, 65647, 65671, 65687, 65711, 65719, 65743, 65759, 65783, 65831, 65839, 65887, 65903, 65911, 65927, 65951, 65959, 65983, 65999, 66007, 66023, 66047, 66071, 66103, 66119, 66127, 66151, 66167, 66191, 66223, 66239, 66247, 66263, 66271, 66343, 66359, 66383, 66431, 66439, 66463, 66487, 66503, 66511, 66527, 66551, 66559, 66607, 66623, 66631, 66679, 66719, 66727, 66743, 66751, 66767, 66791, 66799, 66823, 66839, 66863, 66887, 66919, 66943, 66959, 66967, 66991, 67007, 67031, 67063, 67079, 67087, 67103, 67127, 67159, 67183, 67231, 67247, 67271, 67279, 67303, 67343, 67351, 67367, 67391, 67399, 67423, 67439, 67447, 67471, 67511, 67519, 67559, 67567, 67583, 67591, 67607, 67631, 67663, 67679, 67687, 67703, 67751, 67759, 67783, 67799, 67807, 67831, 67871, 67919, 67927, 67943, 67967, 67999, 68023, 68039, 68063, 68071, 68087, 68111, 68119, 68143, 68183, 68191, 68207, 68231, 68239, 68279, 68287, 68303, 68311, 68351, 68359, 68399, 68407, 68423, 68447, 68479, 68503, 68527, 68543, 68567, 68591, 68599, 68623, 68639, 68647, 68671, 68687, 68711, 68743, 68759, 68767, 68791, 68807, 68839, 68863, 68879, 68903, 68911, 68927, 68951, 68983, 69007, 69023, 69031, 69071, 69079, 69103, 69119, 69127, 69143, 69151, 69191, 69239, 69247, 69263, 69271, 69287, 69319, 69343, 69359, 69367, 69383, 69431, 69439, 69463, 69479, 69527, 69551, 69583, 69599, 69607, 69623, 69631, 69647, 69679, 69703, 69743, 69767, 69791, 69799, 69847, 69863, 69871, 69887, 69911, 69919, 69943, 69959, 69967, 69983, 69991, 70039, 70079, 70087, 70111, 70127, 70151, 70159, 70183, 70199, 70207, 70223, 70247, 70271, 70303, 70319, 70327, 70351, 70391, 70423, 70439, 70463, 70471, 70487, 70519, 70559, 70583, 70591, 70607, 70639, 70663, 70687, 70703, 70711, 70727, 70751, 70783, 70799, 70823, 70831, 70871, 70879, 70919, 70927, 70943, 70951, 70991, 70999, 71023, 71039, 71047, 71063, 71087, 71111, 71119, 71143, 71167, 71191, 71207, 71231, 71263, 71287, 71303, 71311, 71327, 71359, 71399, 71431, 71447, 71471, 71479, 71503, 71527, 71543, 71551, 71567, 71623, 71639, 71647, 71663, 71671, 71711, 71719, 71759, 71767, 71783, 71791, 71807, 71831, 71839, 71879, 71887, 71927, 71959, 71983, 71999, 72031, 72047, 72071, 72103, 72119, 72143, 72151, 72167, 72199, 72223, 72239, 72263, 72271, 72287, 72311, 72343, 72367, 72383, 72407, 72431, 72439, 72463, 72487, 72503, 72511, 72551, 72559, 72599, 72607, 72623, 72647, 72671, 72679, 72703, 72719, 72727, 72767, 72791, 72799, 72823, 72847, 72871, 72887, 72911, 72959, 72967, 72983, 72991, 73039, 73063, 73079, 73103, 73111, 73127, 73159, 73207, 73223, 73231, 73247, 73279, 73303, 73319, 73327, 73343, 73351, 73391, 73399, 73439, 73471, 73487, 73511, 73519, 73543, 73559, 73583, 73607, 73631, 73639, 73663, 73679, 73687, 73727, 73751, 73783, 73807, 73823, 73831, 73847, 73903, 73919, 73943, 73951, 73967, 73991, 73999, 74023, 74047, 74071, 74111, 74119, 74143, 74159, 74167, 74183, 74231, 74279, 74287, 74303, 74311, 74351, 74359, 74383, 74407, 74423, 74447, 74471, 74479, 74519, 74527, 74551, 74567, 74623, 74639, 74647, 74663, 74671, 74687, 74719, 74743, 74759, 74783, 74791, 74807, 74831, 74839, 74863, 74887, 74903, 74911, 74927, 74951, 74959, 74983, 74999, 75007, 75071, 75079, 75143, 75151, 75167, 75191, 75199, 75223, 75239, 75247, 75263, 75287, 75311, 75319, 75343, 75359, 75367, 75391, 75407, 75431, 75463, 75479, 75487, 75503, 75511, 75527, 75583, 75599, 75623, 75631, 75671, 75679, 75703, 75727, 75743, 75767, 75791, 75799, 75839, 75847, 75863, 75871, 75919, 75967, 75983, 75991, 76007, 76031, 76039, 76079, 76103, 76127, 76151, 76159, 76183, 76199, 76207, 76231, 76247, 76303, 76319, 76327, 76343, 76367, 76399, 76423, 76463, 76471, 76487, 76511, 76519, 76543, 76567, 76591, 76607, 76631, 76639, 76663, 76679, 76711, 76751, 76759, 76799, 76807, 76823, 76831, 76847, 76871, 76903, 76919, 76927, 76943, 76991, 77023, 77039, 77047, 77071, 77087, 77111, 77159, 77167, 77183, 77191, 77239, 77263, 77279, 77303, 77327, 77351, 77359, 77383, 77423, 77431, 77447, 77471, 77479, 77503, 77527, 77543, 77551, 77591, 77599, 77639, 77647, 77663, 77687, 77711, 77719, 77743, 77767, 77783, 77807, 77839, 77863, 77879, 77887, 77911, 77927, 77951, 77983, 77999, 78007, 78031, 78047, 78079, 78103, 78119, 78151, 78167, 78191, 78223, 78263, 78271, 78311, 78319, 78343, 78359, 78367, 78383, 78391, 78431, 78439, 78479, 78487, 78503, 78511, 78527, 78583, 78599, 78607, 78623, 78647, 78671, 78679, 78703, 78719, 78751, 78791, 78823, 78839, 78847, 78863, 78887, 78919, 78943, 78959, 78983, 79007, 79031, 79039, 79063, 79087, 79103, 79111, 79127, 79151, 79159, 79199, 79207, 79223, 79231, 79271, 79279, 79319, 79327, 79351, 79367, 79399, 79423, 79439, 79447, 79463, 79487, 79511, 79543, 79559, 79567, 79591, 79631, 79663, 79679, 79687, 79711, 79727, 79759, 79799, 79823, 79831, 79847, 79879, 79903, 79927, 79943, 79951, 79967, 79991, 79999, 80023, 80039, 80063, 80071, 80111, 80159, 80167, 80183, 80191, 80207, 80231, 80239, 80263, 80279, 80287, 80303, 80351, 80359, 80383, 80407, 80447, 80471, 80503, 80519, 80527, 80543, 80551, 80567, 80599, 80623, 80671, 80687, 80711, 80719, 80767, 80783, 80791, 80807, 80831, 80863, 80879, 80887, 80903, 80911, 80959, 80999, 81007, 81023, 81031, 81047, 81071, 81079, 81119, 81127, 81143, 81167, 81199, 81223, 81239, 81247, 81271, 81287, 81311, 81343, 81359, 81383, 81391, 81407, 81439, 81463, 81479, 81503, 81511, 81527, 81551, 81559, 81583, 81607, 81623, 81647, 81671, 81703, 81727, 81743, 81751, 81791, 81799, 81839, 81847, 81863, 81871, 81911, 81919, 81943, 81959, 81967, 82007, 82031, 82039, 82063, 82079, 82087, 82111, 82127, 82151, 82183, 82207, 82223, 82231, 82279, 82319, 82343, 82351, 82367, 82391, 82399, 82447, 82463, 82471, 82487, 82519, 82543, 82559, 82567, 82583, 82591, 82631, 82639, 82679, 82703, 82711, 82727, 82751, 82759, 82783, 82799, 82807, 82847, 82871, 82879, 82903, 82919, 82967, 82991, 83023, 83047, 83063, 83071, 83087, 83119, 83143, 83159, 83183, 83191, 83207, 83231, 83263, 83287, 83311, 83327, 83351, 83359, 83383, 83399, 83407, 83423, 83431, 83471, 83519, 83527, 83543, 83591, 83599, 83623, 83639, 83647, 83663, 83687, 83711, 83719, 83767, 83791, 83807, 83879, 83887, 83903, 83911, 83927, 83959, 83983, 83999, 84023, 84031, 84047, 84079, 84103, 84127, 84143, 84151, 84167, 84191, 84199, 84223, 84239, 84247, 84263, 84311, 84319, 84367, 84391, 84407, 84431, 84439, 84463, 84479, 84503, 84527, 84551, 84559, 84583, 84599, 84607, 84631, 84647, 84671, 84703, 84719, 84727, 84743, 84751, 84767, 84823, 84839, 84863, 84871, 84911, 84919, 84943, 84967, 84983, 84991, 85031, 85039, 85079, 85087, 85103, 85159, 85199, 85207, 85223, 85231, 85247, 85271, 85279, 85303, 85343, 85367, 85391, 85399, 85439, 85447, 85471, 85487, 85511, 85543, 85559, 85567, 85583, 85607, 85639, 85663, 85703, 85711, 85727, 85751, 85759, 85783, 85807, 85823, 85831, 85847, 85871, 85879, 85903, 85919, 85927, 85951, 85991, 85999, 86039, 86063, 86071, 86087, 86111, 86143, 86159, 86167, 86183, 86231, 86239, 86263, 86279, 86287, 86311, 86327, 86351, 86399, 86407, 86423, 86431, 86447, 86479, 86503, 86519, 86543, 86551, 86591, 86599, 86623, 86663, 86687, 86711, 86719, 86743, 86759, 86767, 86783, 86791, 86831, 86839, 86887, 86903, 86927, 86951, 86959, 87007, 87023, 87047, 87071, 87079, 87103, 87119, 87127, 87151, 87167, 87223, 87239, 87247, 87271, 87287, 87319, 87343, 87359, 87383, 87391, 87407, 87431, 87463, 87487, 87511, 87551, 87559, 87583, 87599, 87623, 87631, 87671, 87679, 87719, 87727, 87743, 87751, 87767, 87799, 87823, 87839, 87847, 87863, 87887, 87911, 87943, 87959, 87991, 88007, 88031, 88063, 88079, 88087, 88103, 88111, 88159, 88183, 88199, 88223, 88247, 88271, 88279, 88303, 88327, 88343, 88351, 88367, 88391, 88399, 88423, 88447, 88463, 88471, 88511, 88519, 88559, 88567, 88591, 88607, 88631, 88639, 88663, 88679, 88687, 88703, 88727, 88783, 88799, 88807, 88831, 88871, 88903, 88919, 88927, 88943, 88951, 88967, 88999, 89039, 89071, 89087, 89119, 89143, 89183, 89191, 89207, 89231, 89239, 89263, 89279, 89303, 89311, 89351, 89359, 89399, 89407, 89423, 89431, 89447, 89471, 89503, 89519, 89527, 89543, 89567, 89591, 89599, 89623, 89647, 89671, 89711, 89743, 89759, 89767, 89783, 89807, 89839, 89863, 89879, 89911, 89927, 89951, 89959, 89983, 90007, 90023, 90031, 90047, 90071, 90119, 90127, 90143, 90151, 90191, 90199, 90239, 90247, 90263, 90271, 90287, 90319, 90359, 90367, 90383, 90407, 90439, 90463, 90479, 90487, 90511, 90527, 90551, 90583, 90599, 90631, 90647, 90679, 90703, 90719, 90743, 90751, 90767, 90791, 90799, 90823, 90847, 90863, 90887, 90911, 90919, 90943, 90967, 90983, 90991, 91031, 91079, 91087, 91103, 91111, 91127, 91151, 91159, 91183, 91199, 91207, 91271, 91279, 91303, 91319, 91327, 91367, 91391, 91423, 91439, 91447, 91463, 91471, 91519, 91543, 91583, 91591, 91607, 91631, 91639, 91687, 91703, 91711, 91727, 91759, 91783, 91799, 91807, 91823, 91831, 91879, 91919, 91943, 91951, 91967, 91991, 91999, 92023, 92039, 92047, 92063, 92087, 92111, 92119, 92143, 92159, 92167, 92207, 92231, 92263, 92303, 92311, 92327, 92359, 92383, 92399, 92423, 92431, 92447, 92471, 92479, 92503, 92527, 92551, 92567, 92591, 92623, 92639, 92647, 92663, 92671, 92711, 92759, 92767, 92783, 92791, 92831, 92839, 92863, 92879, 92887, 92903, 92927, 92951, 92959, 92999, 93007, 93031, 93047, 93103, 93127, 93143, 93151, 93167, 93199, 93239, 93263, 93271, 93287, 93311, 93319, 93343, 93367, 93383, 93391, 93407, 93439, 93463, 93479, 93487, 93503, 93551, 93559, 93607, 93623, 93631, 93647, 93671, 93679, 93703, 93719, 93727, 93767, 93791, 93799, 93823, 93839, 93871, 93887, 93911, 93943, 93959, 93967, 93983, 93991, 94007, 94063, 94079, 94103, 94111, 94151, 94183, 94207, 94223, 94231, 94247, 94271, 94279, 94319, 94327, 94343, 94351, 94399, 94439, 94447, 94463, 94487, 94511, 94519, 94543, 94559, 94583, 94607, 94631, 94639, 94663, 94687, 94711, 94727, 94751, 94799, 94807, 94823, 94847, 94879, 94903, 94943, 94951, 94967, 94999, 95023, 95047, 95063, 95071, 95087, 95111, 95119, 95143, 95159, 95167, 95191, 95231, 95239, 95279, 95287, 95311, 95327, 95351, 95383, 95399, 95423, 95471, 95479, 95503, 95519, 95527, 95551, 95567, 95591, 95639, 95647, 95663, 95671, 95687, 95743, 95759, 95783, 95791, 95807, 95831, 95839, 95863, 95903, 95911, 95951, 95959, 95983, 95999, 96007, 96023, 96071, 96079, 96119, 96127, 96143, 96167, 96191, 96199, 96223, 96247, 96263, 96287, 96311, 96319, 96359, 96367, 96391, 96407, 96431, 96463, 96479, 96487, 96511, 96527, 96559, 96583, 96599, 96623, 96631, 96647, 96671, 96703, 96727, 96743, 96751, 96791, 96799, 96823, 96839, 96847, 96871, 96911, 96919, 96959, 96983, 96991, 97007, 97039, 97063, 97079, 97087, 97103, 97127, 97151, 97159, 97183, 97199, 97231, 97247, 97271, 97303, 97319, 97327, 97343, 97351, 97367, 97399, 97423, 97439, 97463, 97511, 97519, 97543, 97567, 97583, 97607, 97631, 97639, 97663, 97679, 97687, 97703, 97711, 97751, 97759, 97807, 97831, 97847, 97871, 97879, 97919, 97927, 97943, 97967, 97991, 98023, 98039, 98047, 98071, 98143, 98159, 98167, 98183, 98191, 98207, 98239, 98279, 98303, 98311, 98327, 98359, 98383, 98407, 98431, 98447, 98471, 98479, 98503, 98519, 98543, 98551, 98591, 98599, 98639, 98647, 98663, 98671, 98687, 98711, 98719, 98743, 98759, 98767, 98783, 98807, 98831, 98863, 98887, 98911, 98927, 98951, 98983, 98999, 99007, 99023, 99031, 99079, 99103, 99119, 99167, 99191, 99199, 99223, 99247, 99263, 99271, 99287, 99311, 99343, 99367, 99383, 99391, 99431, 99439, 99479, 99487, 99503, 99511, 99527, 99551, 99559, 99599, 99607, 99623, 99647, 99679, 99703, 99719, 99727, 99751, 99767, 99791, 99823, 99839, 99863, 99871, 99887, 99919, 99943, 99959, 99991, 100007, 100031, 100039, 100063, 100103, 100127, 100151, 100159, 100183, 100207, 100223, 100231, 100271, 100279, 100319, 100327, 100343, 100351, 100367, 100391, 100423, 100439, 100447, 100487, 100511, 100519, 100543, 100559, 100567, 100591, 100631, 100663, 100679, 100687, 100703, 100759, 100783, 100799, 100823, 100831, 100847, 100871, 100879, 100927, 100943, 100951, 100967, 100999, 101039, 101047, 101063, 101071, 101111, 101119, 101159, 101183, 101191, 101207, 101239, 101263, 101279, 101287, 101303, 101327, 101351, 101359, 101383, 101399, 101407, 101447, 101471, 101503, 101527, 101551, 101567, 101599, 101623, 101639, 101663, 101671, 101687, 101711, 101719, 101743, 101767, 101791, 101807, 101831, 101839, 101863, 101879, 101887, 101903, 101911, 101951, 101999, 102007, 102023, 102031, 102071, 102079, 102103, 102119, 102127, 102143, 102191, 102199, 102239, 102247, 102287, 102343, 102359, 102367, 102383, 102391, 102407, 102439, 102463, 102503, 102511, 102527, 102551, 102559, 102607, 102623, 102631, 102647, 102671, 102679, 102703, 102719, 102727, 102743, 102799, 102847, 102863, 102871, 102887, 102911, 102919, 102943, 102959, 102967, 102983, 103007, 103031, 103039, 103063, 103079, 103087, 103111, 103127, 103151, 103183, 103199, 103223, 103231, 103247, 103303, 103319, 103343, 103351, 103391, 103399, 103423, 103447, 103463, 103471, 103487, 103511, 103559, 103567, 103583, 103591, 103639, 103679, 103687, 103703, 103711, 103751, 103759, 103783, 103799, 103823, 103847, 103871, 103879, 103903, 103919, 103927, 103951, 103967, 103991, 104023, 104047, 104063, 104087, 104119, 104183, 104191, 104207, 104231, 104239, 104263, 104287, 104303, 104311, 104327, 104359, 104383, 104399, 104407, 104431, 104471, 104479, 104519, 104527, 104543, 104551, 104567, 104591, 104623, 104639, 104647, 104711, 104719, 104743, 104759, 104791, 104807, 104831, 104879, 104887, 104903, 104911, 104927, 104959, 104983, 104999, 105023, 105031, 105047, 105071, 105103, 105143, 105151, 105167, 105191, 105199, 105223, 105239, 105247, 105263, 105271, 105311, 105319, 105359, 105367, 105383, 105407, 105431, 105439, 105463, 105487, 105503, 105527, 105551, 105559, 105583, 105607, 105631, 105647, 105671, 105719, 105727, 105751, 105767, 105799, 105823, 105839, 105863, 105871, 105887, 105943, 105967, 105983, 105991, 106031, 106039, 106063, 106079, 106087, 106103, 106111, 106151, 106159, 106199, 106207, 106231, 106247, 106279, 106303, 106319, 106343, 106367, 106391, 106399, 106423, 106439, 106471, 106487, 106511, 106543, 106559, 106567, 106583, 106591, 106607, 106663, 106679, 106703, 106727, 106751, 106759, 106783, 106807, 106823, 106831, 106871, 106879, 106903, 106919, 106927, 106943, 106991, 106999, 107039, 107047, 107071, 107087, 107111, 107119, 107143, 107167, 107183, 107207, 107231, 107279, 107287, 107311, 107351, 107383, 107399, 107407, 107423, 107431, 107447, 107479, 107519, 107543, 107551, 107567, 107599, 107623, 107647, 107663, 107671, 107687, 107711, 107719, 107743, 107759, 107791, 107831, 107839, 107879, 107903, 107911, 107927, 107951, 107959, 107983, 107999, 108007, 108023, 108047, 108071, 108079, 108103, 108127, 108151, 108167, 108191, 108223, 108239, 108247, 108263, 108271, 108287, 108319, 108343, 108359, 108391, 108431, 108439, 108463, 108487, 108503, 108527, 108551, 108583, 108599, 108607, 108623, 108631, 108671, 108679, 108727, 108743, 108751, 108767, 108791, 108799, 108839, 108847, 108863, 108887, 108919, 108943, 108959, 108967, 108991, 109007, 109063, 109079, 109103, 109111, 109127, 109159, 109183, 109199, 109223, 109231, 109247, 109271, 109279, 109303, 109327, 109367, 109391, 109399, 109423, 109463, 109471, 109511, 109519, 109559, 109567, 109583, 109591, 109607, 109631, 109639, 109663, 109679, 109687, 109727, 109751, 109783, 109799, 109807, 109831, 109847, 109871, 109903, 109919, 109927, 109943, 109951, 109999, 110023, 110039, 110063, 110087, 110111, 110119, 110167, 110183, 110191, 110207, 110239, 110263, 110287, 110303, 110311, 110351, 110359, 110399, 110423, 110431, 110447, 110471, 110479, 110503, 110519, 110527, 110543, 110567, 110599, 110623, 110639, 110647, 110687, 110711, 110743, 110767, 110783, 110791, 110807, 110839, 110863, 110879, 110911, 110927, 110951, 110959, 110983, 111031, 111047, 111071, 111079, 111103, 111119, 111127, 111143, 111151, 111191, 111239, 111247, 111263, 111271, 111311, 111343, 111359, 111367, 111383, 111407, 111431, 111439, 111479, 111487, 111511, 111583, 111599, 111607, 111623, 111647, 111679, 111703, 111719, 111743, 111751, 111767, 111791, 111799, 111823, 111847, 111863, 111871, 111887, 111911, 111919, 111959, 111967, 111983, 112031, 112039, 112087, 112103, 112111, 112127, 112159, 112183, 112199, 112207, 112223, 112247, 112271, 112279, 112303, 112319, 112327, 112351, 112367, 112391, 112423, 112439, 112447, 112471, 112487, 112543, 112559, 112583, 112591, 112631, 112639, 112663, 112687, 112703, 112711, 112727, 112751, 112759, 112799, 112807, 112823, 112831, 112919, 112927, 112943, 112951, 112967, 112991, 112999, 113023, 113039, 113063, 113111, 113119, 113143, 113159, 113167, 113207, 113231, 113263, 113279, 113287, 113303, 113327, 113359, 113383, 113423, 113431, 113447, 113471, 113479, 113527, 113543, 113551, 113567, 113591, 113599, 113623, 113639, 113647, 113671, 113719, 113759, 113767, 113783, 113791, 113807, 113831, 113863, 113879, 113887, 113903, 113951, 113959, 113983, 113999, 114007, 114031, 114047, 114071, 114119, 114143, 114151, 114167, 114199, 114223, 114239, 114263, 114271, 114287, 114311, 114319, 114343, 114383, 114391, 114407, 114431, 114463, 114479, 114487, 114503, 114511, 114551, 114559, 114599, 114607, 114623, 114671, 114679, 114703, 114727, 114743, 114767, 114791, 114799, 114823, 114839, 114847, 114871, 114887, 114911, 114943, 114967, 114991, 115007, 115039, 115079, 115103, 115111, 115127, 115151, 115183, 115207, 115223, 115231, 115279, 115303, 115319, 115327, 115343, 115351, 115391, 115399, 115439, 115447, 115463, 115471, 115487, 115519, 115543, 115559, 115567, 115607, 115631, 115639, 115663, 115679, 115711, 115727, 115751, 115783, 115799, 115807, 115823, 115831, 115847, 115879, 115903, 115919, 115943, 115967, 115991, 116023, 116047, 116063, 116071, 116087, 116111, 116119, 116143, 116159, 116167, 116183, 116191, 116231, 116239, 116279, 116287, 116327, 116351, 116359, 116383, 116399, 116407, 116423, 116447, 116471, 116503, 116527, 116551, 116591, 116639, 116647, 116663, 116671, 116687, 116719, 116759, 116783, 116791, 116807, 116839, 116863, 116887, 116903, 116911, 116927, 116951, 116959, 116983, 116999, 117023, 117031, 117071, 117079, 117119, 117127, 117151, 117167, 117191, 117199, 117223, 117239, 117263, 117287, 117311, 117319, 117343, 117367, 117391, 117407, 117431, 117463, 117479, 117487, 117503, 117511, 117527, 117583, 117599, 117631, 117647, 117671, 117679, 117703, 117727, 117743, 117751, 117791, 117823, 117839, 117847, 117863, 117911, 117919, 117959, 117967, 117983, 117991, 118007, 118031, 118039, 118087, 118103, 118127, 118159, 118199, 118207, 118231, 118247, 118271, 118303, 118319, 118343, 118351, 118367, 118399, 118423, 118439, 118463, 118471, 118487, 118511, 118519, 118543, 118567, 118583, 118607, 118631, 118639, 118663, 118687, 118711, 118751, 118759, 118799, 118823, 118831, 118847, 118871, 118879, 118903, 118919, 118927, 118967, 118991, 118999, 119023, 119039, 119047, 119071, 119087, 119111, 119143, 119159, 119167, 119183, 119191, 119239, 119263, 119279, 119303, 119311, 119351, 119359, 119407, 119423, 119447, 119479, 119503, 119519, 119527, 119543, 119551, 119591, 119599, 119663, 119671, 119687, 119711, 119719, 119759, 119767, 119783, 119807, 119831, 119839, 119863, 119879, 119887, 119927, 119983, 120007, 120023, 120031, 120047, 120079, 120103, 120119]); + sieve_info = new sliceType$1([new Pair.ptr(new $Int64(0, 17), new $Int64(0, 8)), new Pair.ptr(new $Int64(0, 19), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 23), new $Int64(0, 5)), new Pair.ptr(new $Int64(0, 29), new $Int64(0, 15)), new Pair.ptr(new $Int64(0, 31), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 37), new $Int64(0, 35)), new Pair.ptr(new $Int64(0, 41), new $Int64(0, 4)), new Pair.ptr(new $Int64(0, 43), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 47), new $Int64(0, 43)), new Pair.ptr(new $Int64(0, 53), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 59), new $Int64(0, 44)), new Pair.ptr(new $Int64(0, 61), new $Int64(0, 50)), new Pair.ptr(new $Int64(0, 67), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 71), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 73), new $Int64(0, 48)), new Pair.ptr(new $Int64(0, 79), new $Int64(0, 2)), new Pair.ptr(new $Int64(0, 83), new $Int64(0, 35)), new Pair.ptr(new $Int64(0, 89), new $Int64(0, 86)), new Pair.ptr(new $Int64(0, 97), new $Int64(0, 20)), new Pair.ptr(new $Int64(0, 101), new $Int64(0, 88)), new Pair.ptr(new $Int64(0, 103), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 107), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 109), new $Int64(0, 55)), new Pair.ptr(new $Int64(0, 113), new $Int64(0, 1)), new Pair.ptr(new $Int64(0, 127), new $Int64(0, 75)), new Pair.ptr(new $Int64(0, 131), new $Int64(0, 56)), new Pair.ptr(new $Int64(0, 137), new $Int64(0, 85)), new Pair.ptr(new $Int64(0, 139), new $Int64(0, 29)), new Pair.ptr(new $Int64(0, 149), new $Int64(0, 86)), new Pair.ptr(new $Int64(0, 151), new $Int64(0, 149)), new Pair.ptr(new $Int64(0, 157), new $Int64(0, 21)), new Pair.ptr(new $Int64(0, 163), new $Int64(0, 74)), new Pair.ptr(new $Int64(0, 167), new $Int64(0, 32)), new Pair.ptr(new $Int64(0, 173), new $Int64(0, 3)), new Pair.ptr(new $Int64(0, 179), new $Int64(0, 114)), new Pair.ptr(new $Int64(0, 181), new $Int64(0, 82)), new Pair.ptr(new $Int64(0, 191), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 193), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 197), new $Int64(0, 130)), new Pair.ptr(new $Int64(0, 199), new $Int64(0, 144)), new Pair.ptr(new $Int64(0, 211), new $Int64(0, 128)), new Pair.ptr(new $Int64(0, 223), new $Int64(0, 139)), new Pair.ptr(new $Int64(0, 227), new $Int64(0, 135)), new Pair.ptr(new $Int64(0, 229), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 233), new $Int64(0, 192)), new Pair.ptr(new $Int64(0, 239), new $Int64(0, 170)), new Pair.ptr(new $Int64(0, 241), new $Int64(0, 26)), new Pair.ptr(new $Int64(0, 251), new $Int64(0, 175)), new Pair.ptr(new $Int64(0, 257), new $Int64(0, 28)), new Pair.ptr(new $Int64(0, 263), new $Int64(0, 100)), new Pair.ptr(new $Int64(0, 269), new $Int64(0, 234)), new Pair.ptr(new $Int64(0, 271), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 277), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 281), new $Int64(0, 131)), new Pair.ptr(new $Int64(0, 283), new $Int64(0, 241)), new Pair.ptr(new $Int64(0, 293), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 307), new $Int64(0, 37)), new Pair.ptr(new $Int64(0, 311), new $Int64(0, 290)), new Pair.ptr(new $Int64(0, 313), new $Int64(0, 213)), new Pair.ptr(new $Int64(0, 317), new $Int64(0, 124)), new Pair.ptr(new $Int64(0, 331), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 337), new $Int64(0, 189)), new Pair.ptr(new $Int64(0, 347), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 349), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 353), new $Int64(0, 293)), new Pair.ptr(new $Int64(0, 359), new $Int64(0, 307)), new Pair.ptr(new $Int64(0, 367), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 373), new $Int64(0, 80)), new Pair.ptr(new $Int64(0, 379), new $Int64(0, 346)), new Pair.ptr(new $Int64(0, 383), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 389), new $Int64(0, 24)), new Pair.ptr(new $Int64(0, 397), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 401), new $Int64(0, 225)), new Pair.ptr(new $Int64(0, 409), new $Int64(0, 198)), new Pair.ptr(new $Int64(0, 419), new $Int64(0, 63)), new Pair.ptr(new $Int64(0, 421), new $Int64(0, 184)), new Pair.ptr(new $Int64(0, 431), new $Int64(0, 147)), new Pair.ptr(new $Int64(0, 433), new $Int64(0, 254)), new Pair.ptr(new $Int64(0, 439), new $Int64(0, 119)), new Pair.ptr(new $Int64(0, 443), new $Int64(0, 324)), new Pair.ptr(new $Int64(0, 449), new $Int64(0, 36)), new Pair.ptr(new $Int64(0, 457), new $Int64(0, 354)), new Pair.ptr(new $Int64(0, 461), new $Int64(0, 211)), new Pair.ptr(new $Int64(0, 463), new $Int64(0, 333)), new Pair.ptr(new $Int64(0, 467), new $Int64(0, 37)), new Pair.ptr(new $Int64(0, 479), new $Int64(0, 312)), new Pair.ptr(new $Int64(0, 487), new $Int64(0, 219)), new Pair.ptr(new $Int64(0, 491), new $Int64(0, 101)), new Pair.ptr(new $Int64(0, 499), new $Int64(0, 140)), new Pair.ptr(new $Int64(0, 503), new $Int64(0, 140)), new Pair.ptr(new $Int64(0, 509), new $Int64(0, 127)), new Pair.ptr(new $Int64(0, 521), new $Int64(0, 106)), new Pair.ptr(new $Int64(0, 523), new $Int64(0, 483)), new Pair.ptr(new $Int64(0, 541), new $Int64(0, 511)), new Pair.ptr(new $Int64(0, 547), new $Int64(0, 455)), new Pair.ptr(new $Int64(0, 557), new $Int64(0, 293)), new Pair.ptr(new $Int64(0, 563), new $Int64(0, 549)), new Pair.ptr(new $Int64(0, 569), new $Int64(0, 28)), new Pair.ptr(new $Int64(0, 571), new $Int64(0, 242)), new Pair.ptr(new $Int64(0, 577), new $Int64(0, 172)), new Pair.ptr(new $Int64(0, 587), new $Int64(0, 172)), new Pair.ptr(new $Int64(0, 593), new $Int64(0, 87)), new Pair.ptr(new $Int64(0, 599), new $Int64(0, 526)), new Pair.ptr(new $Int64(0, 601), new $Int64(0, 308)), new Pair.ptr(new $Int64(0, 607), new $Int64(0, 561)), new Pair.ptr(new $Int64(0, 613), new $Int64(0, 197)), new Pair.ptr(new $Int64(0, 617), new $Int64(0, 405)), new Pair.ptr(new $Int64(0, 619), new $Int64(0, 528)), new Pair.ptr(new $Int64(0, 631), new $Int64(0, 107)), new Pair.ptr(new $Int64(0, 641), new $Int64(0, 603)), new Pair.ptr(new $Int64(0, 643), new $Int64(0, 457)), new Pair.ptr(new $Int64(0, 647), new $Int64(0, 102)), new Pair.ptr(new $Int64(0, 653), new $Int64(0, 102)), new Pair.ptr(new $Int64(0, 659), new $Int64(0, 554)), new Pair.ptr(new $Int64(0, 661), new $Int64(0, 69)), new Pair.ptr(new $Int64(0, 673), new $Int64(0, 64)), new Pair.ptr(new $Int64(0, 677), new $Int64(0, 114)), new Pair.ptr(new $Int64(0, 683), new $Int64(0, 520)), new Pair.ptr(new $Int64(0, 691), new $Int64(0, 297)), new Pair.ptr(new $Int64(0, 701), new $Int64(0, 442)), new Pair.ptr(new $Int64(0, 709), new $Int64(0, 396)), new Pair.ptr(new $Int64(0, 719), new $Int64(0, 153)), new Pair.ptr(new $Int64(0, 727), new $Int64(0, 141)), new Pair.ptr(new $Int64(0, 733), new $Int64(0, 486)), new Pair.ptr(new $Int64(0, 739), new $Int64(0, 307)), new Pair.ptr(new $Int64(0, 743), new $Int64(0, 595)), new Pair.ptr(new $Int64(0, 751), new $Int64(0, 582)), new Pair.ptr(new $Int64(0, 757), new $Int64(0, 676)), new Pair.ptr(new $Int64(0, 761), new $Int64(0, 316)), new Pair.ptr(new $Int64(0, 769), new $Int64(0, 350)), new Pair.ptr(new $Int64(0, 773), new $Int64(0, 147)), new Pair.ptr(new $Int64(0, 787), new $Int64(0, 668)), new Pair.ptr(new $Int64(0, 797), new $Int64(0, 639)), new Pair.ptr(new $Int64(0, 809), new $Int64(0, 98)), new Pair.ptr(new $Int64(0, 811), new $Int64(0, 573)), new Pair.ptr(new $Int64(0, 821), new $Int64(0, 320)), new Pair.ptr(new $Int64(0, 823), new $Int64(0, 758)), new Pair.ptr(new $Int64(0, 827), new $Int64(0, 472)), new Pair.ptr(new $Int64(0, 829), new $Int64(0, 39)), new Pair.ptr(new $Int64(0, 839), new $Int64(0, 751)), new Pair.ptr(new $Int64(0, 853), new $Int64(0, 223)), new Pair.ptr(new $Int64(0, 857), new $Int64(0, 655)), new Pair.ptr(new $Int64(0, 859), new $Int64(0, 362)), new Pair.ptr(new $Int64(0, 863), new $Int64(0, 773)), new Pair.ptr(new $Int64(0, 877), new $Int64(0, 756)), new Pair.ptr(new $Int64(0, 881), new $Int64(0, 739)), new Pair.ptr(new $Int64(0, 883), new $Int64(0, 138)), new Pair.ptr(new $Int64(0, 887), new $Int64(0, 123)), new Pair.ptr(new $Int64(0, 907), new $Int64(0, 836)), new Pair.ptr(new $Int64(0, 911), new $Int64(0, 490)), new Pair.ptr(new $Int64(0, 919), new $Int64(0, 878)), new Pair.ptr(new $Int64(0, 929), new $Int64(0, 313)), new Pair.ptr(new $Int64(0, 937), new $Int64(0, 606)), new Pair.ptr(new $Int64(0, 941), new $Int64(0, 175)), new Pair.ptr(new $Int64(0, 947), new $Int64(0, 286)), new Pair.ptr(new $Int64(0, 953), new $Int64(0, 295)), new Pair.ptr(new $Int64(0, 967), new $Int64(0, 260)), new Pair.ptr(new $Int64(0, 971), new $Int64(0, 612)), new Pair.ptr(new $Int64(0, 977), new $Int64(0, 613)), new Pair.ptr(new $Int64(0, 983), new $Int64(0, 907)), new Pair.ptr(new $Int64(0, 991), new $Int64(0, 569)), new Pair.ptr(new $Int64(0, 997), new $Int64(0, 970)), new Pair.ptr(new $Int64(0, 1009), new $Int64(0, 556)), new Pair.ptr(new $Int64(0, 1013), new $Int64(0, 223)), new Pair.ptr(new $Int64(0, 1019), new $Int64(0, 877)), new Pair.ptr(new $Int64(0, 1021), new $Int64(0, 77)), new Pair.ptr(new $Int64(0, 1031), new $Int64(0, 364)), new Pair.ptr(new $Int64(0, 1033), new $Int64(0, 704)), new Pair.ptr(new $Int64(0, 1039), new $Int64(0, 18)), new Pair.ptr(new $Int64(0, 1049), new $Int64(0, 497)), new Pair.ptr(new $Int64(0, 1051), new $Int64(0, 79)), new Pair.ptr(new $Int64(0, 1061), new $Int64(0, 846)), new Pair.ptr(new $Int64(0, 1063), new $Int64(0, 1)), new Pair.ptr(new $Int64(0, 1069), new $Int64(0, 30)), new Pair.ptr(new $Int64(0, 1087), new $Int64(0, 251)), new Pair.ptr(new $Int64(0, 1091), new $Int64(0, 486)), new Pair.ptr(new $Int64(0, 1093), new $Int64(0, 467)), new Pair.ptr(new $Int64(0, 1097), new $Int64(0, 365)), new Pair.ptr(new $Int64(0, 1103), new $Int64(0, 134)), new Pair.ptr(new $Int64(0, 1109), new $Int64(0, 290)), new Pair.ptr(new $Int64(0, 1117), new $Int64(0, 184)), new Pair.ptr(new $Int64(0, 1123), new $Int64(0, 493)), new Pair.ptr(new $Int64(0, 1129), new $Int64(0, 524)), new Pair.ptr(new $Int64(0, 1151), new $Int64(0, 534)), new Pair.ptr(new $Int64(0, 1153), new $Int64(0, 704)), new Pair.ptr(new $Int64(0, 1163), new $Int64(0, 1033)), new Pair.ptr(new $Int64(0, 1171), new $Int64(0, 19)), new Pair.ptr(new $Int64(0, 1181), new $Int64(0, 701)), new Pair.ptr(new $Int64(0, 1187), new $Int64(0, 917)), new Pair.ptr(new $Int64(0, 1193), new $Int64(0, 790)), new Pair.ptr(new $Int64(0, 1201), new $Int64(0, 1141)), new Pair.ptr(new $Int64(0, 1213), new $Int64(0, 1066)), new Pair.ptr(new $Int64(0, 1217), new $Int64(0, 580)), new Pair.ptr(new $Int64(0, 1223), new $Int64(0, 823)), new Pair.ptr(new $Int64(0, 1229), new $Int64(0, 729)), new Pair.ptr(new $Int64(0, 1231), new $Int64(0, 1029)), new Pair.ptr(new $Int64(0, 1237), new $Int64(0, 661)), new Pair.ptr(new $Int64(0, 1249), new $Int64(0, 133)), new Pair.ptr(new $Int64(0, 1259), new $Int64(0, 1237)), new Pair.ptr(new $Int64(0, 1277), new $Int64(0, 1168)), new Pair.ptr(new $Int64(0, 1279), new $Int64(0, 1098)), new Pair.ptr(new $Int64(0, 1283), new $Int64(0, 732)), new Pair.ptr(new $Int64(0, 1289), new $Int64(0, 1167)), new Pair.ptr(new $Int64(0, 1291), new $Int64(0, 453)), new Pair.ptr(new $Int64(0, 1297), new $Int64(0, 787)), new Pair.ptr(new $Int64(0, 1301), new $Int64(0, 459)), new Pair.ptr(new $Int64(0, 1303), new $Int64(0, 518)), new Pair.ptr(new $Int64(0, 1307), new $Int64(0, 917)), new Pair.ptr(new $Int64(0, 1319), new $Int64(0, 29)), new Pair.ptr(new $Int64(0, 1321), new $Int64(0, 450)), new Pair.ptr(new $Int64(0, 1327), new $Int64(0, 1302)), new Pair.ptr(new $Int64(0, 1361), new $Int64(0, 58)), new Pair.ptr(new $Int64(0, 1367), new $Int64(0, 800)), new Pair.ptr(new $Int64(0, 1373), new $Int64(0, 353)), new Pair.ptr(new $Int64(0, 1381), new $Int64(0, 358)), new Pair.ptr(new $Int64(0, 1399), new $Int64(0, 512)), new Pair.ptr(new $Int64(0, 1409), new $Int64(0, 897)), new Pair.ptr(new $Int64(0, 1423), new $Int64(0, 651)), new Pair.ptr(new $Int64(0, 1427), new $Int64(0, 957)), new Pair.ptr(new $Int64(0, 1429), new $Int64(0, 1412)), new Pair.ptr(new $Int64(0, 1433), new $Int64(0, 1052)), new Pair.ptr(new $Int64(0, 1439), new $Int64(0, 1163)), new Pair.ptr(new $Int64(0, 1447), new $Int64(0, 457)), new Pair.ptr(new $Int64(0, 1451), new $Int64(0, 700)), new Pair.ptr(new $Int64(0, 1453), new $Int64(0, 91)), new Pair.ptr(new $Int64(0, 1459), new $Int64(0, 112)), new Pair.ptr(new $Int64(0, 1471), new $Int64(0, 126)), new Pair.ptr(new $Int64(0, 1481), new $Int64(0, 1155)), new Pair.ptr(new $Int64(0, 1483), new $Int64(0, 494)), new Pair.ptr(new $Int64(0, 1487), new $Int64(0, 432)), new Pair.ptr(new $Int64(0, 1489), new $Int64(0, 880)), new Pair.ptr(new $Int64(0, 1493), new $Int64(0, 797)), new Pair.ptr(new $Int64(0, 1499), new $Int64(0, 757)), new Pair.ptr(new $Int64(0, 1511), new $Int64(0, 1175)), new Pair.ptr(new $Int64(0, 1523), new $Int64(0, 201)), new Pair.ptr(new $Int64(0, 1531), new $Int64(0, 1097)), new Pair.ptr(new $Int64(0, 1543), new $Int64(0, 877)), new Pair.ptr(new $Int64(0, 1549), new $Int64(0, 876)), new Pair.ptr(new $Int64(0, 1553), new $Int64(0, 1092)), new Pair.ptr(new $Int64(0, 1559), new $Int64(0, 81)), new Pair.ptr(new $Int64(0, 1567), new $Int64(0, 282)), new Pair.ptr(new $Int64(0, 1571), new $Int64(0, 1009)), new Pair.ptr(new $Int64(0, 1579), new $Int64(0, 667)), new Pair.ptr(new $Int64(0, 1583), new $Int64(0, 1002)), new Pair.ptr(new $Int64(0, 1597), new $Int64(0, 287)), new Pair.ptr(new $Int64(0, 1601), new $Int64(0, 676)), new Pair.ptr(new $Int64(0, 1607), new $Int64(0, 865)), new Pair.ptr(new $Int64(0, 1609), new $Int64(0, 316)), new Pair.ptr(new $Int64(0, 1613), new $Int64(0, 1164)), new Pair.ptr(new $Int64(0, 1619), new $Int64(0, 892)), new Pair.ptr(new $Int64(0, 1621), new $Int64(0, 1455)), new Pair.ptr(new $Int64(0, 1627), new $Int64(0, 357)), new Pair.ptr(new $Int64(0, 1637), new $Int64(0, 1198)), new Pair.ptr(new $Int64(0, 1657), new $Int64(0, 729)), new Pair.ptr(new $Int64(0, 1663), new $Int64(0, 1113)), new Pair.ptr(new $Int64(0, 1667), new $Int64(0, 1476)), new Pair.ptr(new $Int64(0, 1669), new $Int64(0, 452)), new Pair.ptr(new $Int64(0, 1693), new $Int64(0, 1591)), new Pair.ptr(new $Int64(0, 1697), new $Int64(0, 1119)), new Pair.ptr(new $Int64(0, 1699), new $Int64(0, 1215)), new Pair.ptr(new $Int64(0, 1709), new $Int64(0, 143)), new Pair.ptr(new $Int64(0, 1721), new $Int64(0, 890)), new Pair.ptr(new $Int64(0, 1723), new $Int64(0, 1185)), new Pair.ptr(new $Int64(0, 1733), new $Int64(0, 1583)), new Pair.ptr(new $Int64(0, 1741), new $Int64(0, 1354)), new Pair.ptr(new $Int64(0, 1747), new $Int64(0, 413)), new Pair.ptr(new $Int64(0, 1753), new $Int64(0, 932)), new Pair.ptr(new $Int64(0, 1759), new $Int64(0, 1250)), new Pair.ptr(new $Int64(0, 1777), new $Int64(0, 1025)), new Pair.ptr(new $Int64(0, 1783), new $Int64(0, 1204)), new Pair.ptr(new $Int64(0, 1787), new $Int64(0, 1202)), new Pair.ptr(new $Int64(0, 1789), new $Int64(0, 1253)), new Pair.ptr(new $Int64(0, 1801), new $Int64(0, 1317)), new Pair.ptr(new $Int64(0, 1811), new $Int64(0, 1686)), new Pair.ptr(new $Int64(0, 1823), new $Int64(0, 267)), new Pair.ptr(new $Int64(0, 1831), new $Int64(0, 744)), new Pair.ptr(new $Int64(0, 1847), new $Int64(0, 341)), new Pair.ptr(new $Int64(0, 1861), new $Int64(0, 1676)), new Pair.ptr(new $Int64(0, 1867), new $Int64(0, 322)), new Pair.ptr(new $Int64(0, 1871), new $Int64(0, 1040)), new Pair.ptr(new $Int64(0, 1873), new $Int64(0, 1080)), new Pair.ptr(new $Int64(0, 1877), new $Int64(0, 1173)), new Pair.ptr(new $Int64(0, 1879), new $Int64(0, 1202)), new Pair.ptr(new $Int64(0, 1889), new $Int64(0, 1463)), new Pair.ptr(new $Int64(0, 1901), new $Int64(0, 213)), new Pair.ptr(new $Int64(0, 1907), new $Int64(0, 454)), new Pair.ptr(new $Int64(0, 1913), new $Int64(0, 1563)), new Pair.ptr(new $Int64(0, 1931), new $Int64(0, 131)), new Pair.ptr(new $Int64(0, 1933), new $Int64(0, 515)), new Pair.ptr(new $Int64(0, 1949), new $Int64(0, 19)), new Pair.ptr(new $Int64(0, 1951), new $Int64(0, 95)), new Pair.ptr(new $Int64(0, 1973), new $Int64(0, 525)), new Pair.ptr(new $Int64(0, 1979), new $Int64(0, 1120)), new Pair.ptr(new $Int64(0, 1987), new $Int64(0, 170)), new Pair.ptr(new $Int64(0, 1993), new $Int64(0, 1635)), new Pair.ptr(new $Int64(0, 1997), new $Int64(0, 446)), new Pair.ptr(new $Int64(0, 1999), new $Int64(0, 1788)), new Pair.ptr(new $Int64(0, 2003), new $Int64(0, 1569)), new Pair.ptr(new $Int64(0, 2011), new $Int64(0, 1903)), new Pair.ptr(new $Int64(0, 2017), new $Int64(0, 567)), new Pair.ptr(new $Int64(0, 2027), new $Int64(0, 1977)), new Pair.ptr(new $Int64(0, 2029), new $Int64(0, 888)), new Pair.ptr(new $Int64(0, 2039), new $Int64(0, 1487)), new Pair.ptr(new $Int64(0, 2053), new $Int64(0, 1474)), new Pair.ptr(new $Int64(0, 2063), new $Int64(0, 1244)), new Pair.ptr(new $Int64(0, 2069), new $Int64(0, 1806)), new Pair.ptr(new $Int64(0, 2081), new $Int64(0, 18)), new Pair.ptr(new $Int64(0, 2083), new $Int64(0, 3)), new Pair.ptr(new $Int64(0, 2087), new $Int64(0, 746)), new Pair.ptr(new $Int64(0, 2089), new $Int64(0, 836)), new Pair.ptr(new $Int64(0, 2099), new $Int64(0, 2077)), new Pair.ptr(new $Int64(0, 2111), new $Int64(0, 1030)), new Pair.ptr(new $Int64(0, 2113), new $Int64(0, 678)), new Pair.ptr(new $Int64(0, 2129), new $Int64(0, 796)), new Pair.ptr(new $Int64(0, 2131), new $Int64(0, 405)), new Pair.ptr(new $Int64(0, 2137), new $Int64(0, 415)), new Pair.ptr(new $Int64(0, 2141), new $Int64(0, 411)), new Pair.ptr(new $Int64(0, 2143), new $Int64(0, 1856)), new Pair.ptr(new $Int64(0, 2153), new $Int64(0, 1658)), new Pair.ptr(new $Int64(0, 2161), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 2179), new $Int64(0, 1038)), new Pair.ptr(new $Int64(0, 2203), new $Int64(0, 78)), new Pair.ptr(new $Int64(0, 2207), new $Int64(0, 2125)), new Pair.ptr(new $Int64(0, 2213), new $Int64(0, 863)), new Pair.ptr(new $Int64(0, 2221), new $Int64(0, 203)), new Pair.ptr(new $Int64(0, 2237), new $Int64(0, 551)), new Pair.ptr(new $Int64(0, 2239), new $Int64(0, 1524)), new Pair.ptr(new $Int64(0, 2243), new $Int64(0, 1999)), new Pair.ptr(new $Int64(0, 2251), new $Int64(0, 529)), new Pair.ptr(new $Int64(0, 2267), new $Int64(0, 585)), new Pair.ptr(new $Int64(0, 2269), new $Int64(0, 2004)), new Pair.ptr(new $Int64(0, 2273), new $Int64(0, 254)), new Pair.ptr(new $Int64(0, 2281), new $Int64(0, 180)), new Pair.ptr(new $Int64(0, 2287), new $Int64(0, 1394)), new Pair.ptr(new $Int64(0, 2293), new $Int64(0, 1699)), new Pair.ptr(new $Int64(0, 2297), new $Int64(0, 1315)), new Pair.ptr(new $Int64(0, 2309), new $Int64(0, 2087)), new Pair.ptr(new $Int64(0, 2311), new $Int64(0, 1911)), new Pair.ptr(new $Int64(0, 2333), new $Int64(0, 1898)), new Pair.ptr(new $Int64(0, 2339), new $Int64(0, 805)), new Pair.ptr(new $Int64(0, 2341), new $Int64(0, 228)), new Pair.ptr(new $Int64(0, 2347), new $Int64(0, 2175)), new Pair.ptr(new $Int64(0, 2351), new $Int64(0, 365)), new Pair.ptr(new $Int64(0, 2357), new $Int64(0, 298)), new Pair.ptr(new $Int64(0, 2371), new $Int64(0, 74)), new Pair.ptr(new $Int64(0, 2377), new $Int64(0, 350)), new Pair.ptr(new $Int64(0, 2381), new $Int64(0, 2134)), new Pair.ptr(new $Int64(0, 2383), new $Int64(0, 2071)), new Pair.ptr(new $Int64(0, 2389), new $Int64(0, 2036)), new Pair.ptr(new $Int64(0, 2393), new $Int64(0, 779)), new Pair.ptr(new $Int64(0, 2399), new $Int64(0, 2272)), new Pair.ptr(new $Int64(0, 2411), new $Int64(0, 1127)), new Pair.ptr(new $Int64(0, 2417), new $Int64(0, 937)), new Pair.ptr(new $Int64(0, 2423), new $Int64(0, 534)), new Pair.ptr(new $Int64(0, 2437), new $Int64(0, 455)), new Pair.ptr(new $Int64(0, 2441), new $Int64(0, 621)), new Pair.ptr(new $Int64(0, 2447), new $Int64(0, 530)), new Pair.ptr(new $Int64(0, 2459), new $Int64(0, 1372)), new Pair.ptr(new $Int64(0, 2467), new $Int64(0, 2370)), new Pair.ptr(new $Int64(0, 2473), new $Int64(0, 124)), new Pair.ptr(new $Int64(0, 2477), new $Int64(0, 427)), new Pair.ptr(new $Int64(0, 2503), new $Int64(0, 730)), new Pair.ptr(new $Int64(0, 2521), new $Int64(0, 1093)), new Pair.ptr(new $Int64(0, 2531), new $Int64(0, 642)), new Pair.ptr(new $Int64(0, 2539), new $Int64(0, 271)), new Pair.ptr(new $Int64(0, 2543), new $Int64(0, 1851)), new Pair.ptr(new $Int64(0, 2549), new $Int64(0, 1568)), new Pair.ptr(new $Int64(0, 2551), new $Int64(0, 1796)), new Pair.ptr(new $Int64(0, 2557), new $Int64(0, 130)), new Pair.ptr(new $Int64(0, 2579), new $Int64(0, 210)), new Pair.ptr(new $Int64(0, 2591), new $Int64(0, 1756)), new Pair.ptr(new $Int64(0, 2593), new $Int64(0, 1161)), new Pair.ptr(new $Int64(0, 2609), new $Int64(0, 1846)), new Pair.ptr(new $Int64(0, 2617), new $Int64(0, 869)), new Pair.ptr(new $Int64(0, 2621), new $Int64(0, 2192)), new Pair.ptr(new $Int64(0, 2633), new $Int64(0, 2509)), new Pair.ptr(new $Int64(0, 2647), new $Int64(0, 1230)), new Pair.ptr(new $Int64(0, 2657), new $Int64(0, 608)), new Pair.ptr(new $Int64(0, 2659), new $Int64(0, 406)), new Pair.ptr(new $Int64(0, 2663), new $Int64(0, 2364)), new Pair.ptr(new $Int64(0, 2671), new $Int64(0, 1104)), new Pair.ptr(new $Int64(0, 2677), new $Int64(0, 1032)), new Pair.ptr(new $Int64(0, 2683), new $Int64(0, 1143)), new Pair.ptr(new $Int64(0, 2687), new $Int64(0, 1041)), new Pair.ptr(new $Int64(0, 2689), new $Int64(0, 2610)), new Pair.ptr(new $Int64(0, 2693), new $Int64(0, 574)), new Pair.ptr(new $Int64(0, 2699), new $Int64(0, 2606)), new Pair.ptr(new $Int64(0, 2707), new $Int64(0, 2057)), new Pair.ptr(new $Int64(0, 2711), new $Int64(0, 1469)), new Pair.ptr(new $Int64(0, 2713), new $Int64(0, 1128)), new Pair.ptr(new $Int64(0, 2719), new $Int64(0, 1264)), new Pair.ptr(new $Int64(0, 2729), new $Int64(0, 2667)), new Pair.ptr(new $Int64(0, 2731), new $Int64(0, 931)), new Pair.ptr(new $Int64(0, 2741), new $Int64(0, 1093)), new Pair.ptr(new $Int64(0, 2749), new $Int64(0, 2384)), new Pair.ptr(new $Int64(0, 2753), new $Int64(0, 1537)), new Pair.ptr(new $Int64(0, 2767), new $Int64(0, 2303)), new Pair.ptr(new $Int64(0, 2777), new $Int64(0, 2730)), new Pair.ptr(new $Int64(0, 2789), new $Int64(0, 1763)), new Pair.ptr(new $Int64(0, 2791), new $Int64(0, 2478)), new Pair.ptr(new $Int64(0, 2797), new $Int64(0, 1204)), new Pair.ptr(new $Int64(0, 2801), new $Int64(0, 2246)), new Pair.ptr(new $Int64(0, 2803), new $Int64(0, 2289)), new Pair.ptr(new $Int64(0, 2819), new $Int64(0, 866)), new Pair.ptr(new $Int64(0, 2833), new $Int64(0, 2126)), new Pair.ptr(new $Int64(0, 2837), new $Int64(0, 2558)), new Pair.ptr(new $Int64(0, 2843), new $Int64(0, 219)), new Pair.ptr(new $Int64(0, 2851), new $Int64(0, 445)), new Pair.ptr(new $Int64(0, 2857), new $Int64(0, 1882)), new Pair.ptr(new $Int64(0, 2861), new $Int64(0, 1158)), new Pair.ptr(new $Int64(0, 2879), new $Int64(0, 1858)), new Pair.ptr(new $Int64(0, 2887), new $Int64(0, 583)), new Pair.ptr(new $Int64(0, 2897), new $Int64(0, 1016)), new Pair.ptr(new $Int64(0, 2903), new $Int64(0, 1040)), new Pair.ptr(new $Int64(0, 2909), new $Int64(0, 2051)), new Pair.ptr(new $Int64(0, 2917), new $Int64(0, 396)), new Pair.ptr(new $Int64(0, 2927), new $Int64(0, 1865)), new Pair.ptr(new $Int64(0, 2939), new $Int64(0, 1264)), new Pair.ptr(new $Int64(0, 2953), new $Int64(0, 2042)), new Pair.ptr(new $Int64(0, 2957), new $Int64(0, 2229)), new Pair.ptr(new $Int64(0, 2963), new $Int64(0, 2913)), new Pair.ptr(new $Int64(0, 2969), new $Int64(0, 155)), new Pair.ptr(new $Int64(0, 2971), new $Int64(0, 253)), new Pair.ptr(new $Int64(0, 2999), new $Int64(0, 2268)), new Pair.ptr(new $Int64(0, 3001), new $Int64(0, 1463)), new Pair.ptr(new $Int64(0, 3011), new $Int64(0, 1609)), new Pair.ptr(new $Int64(0, 3019), new $Int64(0, 467)), new Pair.ptr(new $Int64(0, 3023), new $Int64(0, 2596)), new Pair.ptr(new $Int64(0, 3037), new $Int64(0, 297)), new Pair.ptr(new $Int64(0, 3041), new $Int64(0, 2)), new Pair.ptr(new $Int64(0, 3049), new $Int64(0, 1208)), new Pair.ptr(new $Int64(0, 3061), new $Int64(0, 1136)), new Pair.ptr(new $Int64(0, 3067), new $Int64(0, 2208)), new Pair.ptr(new $Int64(0, 3079), new $Int64(0, 1579)), new Pair.ptr(new $Int64(0, 3083), new $Int64(0, 527)), new Pair.ptr(new $Int64(0, 3089), new $Int64(0, 44)), new Pair.ptr(new $Int64(0, 3109), new $Int64(0, 2485)), new Pair.ptr(new $Int64(0, 3119), new $Int64(0, 2957)), new Pair.ptr(new $Int64(0, 3121), new $Int64(0, 1905)), new Pair.ptr(new $Int64(0, 3137), new $Int64(0, 2454)), new Pair.ptr(new $Int64(0, 3163), new $Int64(0, 1496)), new Pair.ptr(new $Int64(0, 3167), new $Int64(0, 2116)), new Pair.ptr(new $Int64(0, 3169), new $Int64(0, 787)), new Pair.ptr(new $Int64(0, 3181), new $Int64(0, 2690)), new Pair.ptr(new $Int64(0, 3187), new $Int64(0, 2686)), new Pair.ptr(new $Int64(0, 3191), new $Int64(0, 1388)), new Pair.ptr(new $Int64(0, 3203), new $Int64(0, 2349)), new Pair.ptr(new $Int64(0, 3209), new $Int64(0, 2309)), new Pair.ptr(new $Int64(0, 3217), new $Int64(0, 1666)), new Pair.ptr(new $Int64(0, 3221), new $Int64(0, 1175)), new Pair.ptr(new $Int64(0, 3229), new $Int64(0, 539)), new Pair.ptr(new $Int64(0, 3251), new $Int64(0, 292)), new Pair.ptr(new $Int64(0, 3253), new $Int64(0, 3226)), new Pair.ptr(new $Int64(0, 3257), new $Int64(0, 921)), new Pair.ptr(new $Int64(0, 3259), new $Int64(0, 1992)), new Pair.ptr(new $Int64(0, 3271), new $Int64(0, 339)), new Pair.ptr(new $Int64(0, 3299), new $Int64(0, 1287)), new Pair.ptr(new $Int64(0, 3301), new $Int64(0, 1324)), new Pair.ptr(new $Int64(0, 3307), new $Int64(0, 610)), new Pair.ptr(new $Int64(0, 3313), new $Int64(0, 1116)), new Pair.ptr(new $Int64(0, 3319), new $Int64(0, 2531)), new Pair.ptr(new $Int64(0, 3323), new $Int64(0, 412)), new Pair.ptr(new $Int64(0, 3329), new $Int64(0, 2545)), new Pair.ptr(new $Int64(0, 3331), new $Int64(0, 2237)), new Pair.ptr(new $Int64(0, 3343), new $Int64(0, 2214)), new Pair.ptr(new $Int64(0, 3347), new $Int64(0, 3338)), new Pair.ptr(new $Int64(0, 3359), new $Int64(0, 2302)), new Pair.ptr(new $Int64(0, 3361), new $Int64(0, 188)), new Pair.ptr(new $Int64(0, 3371), new $Int64(0, 30)), new Pair.ptr(new $Int64(0, 3373), new $Int64(0, 2014)), new Pair.ptr(new $Int64(0, 3389), new $Int64(0, 2772)), new Pair.ptr(new $Int64(0, 3391), new $Int64(0, 1510)), new Pair.ptr(new $Int64(0, 3407), new $Int64(0, 806)), new Pair.ptr(new $Int64(0, 3413), new $Int64(0, 349)), new Pair.ptr(new $Int64(0, 3433), new $Int64(0, 1177)), new Pair.ptr(new $Int64(0, 3449), new $Int64(0, 342)), new Pair.ptr(new $Int64(0, 3457), new $Int64(0, 1849)), new Pair.ptr(new $Int64(0, 3461), new $Int64(0, 208)), new Pair.ptr(new $Int64(0, 3463), new $Int64(0, 2847)), new Pair.ptr(new $Int64(0, 3467), new $Int64(0, 150)), new Pair.ptr(new $Int64(0, 3469), new $Int64(0, 1993)), new Pair.ptr(new $Int64(0, 3491), new $Int64(0, 2005)), new Pair.ptr(new $Int64(0, 3499), new $Int64(0, 1513)), new Pair.ptr(new $Int64(0, 3511), new $Int64(0, 2998)), new Pair.ptr(new $Int64(0, 3517), new $Int64(0, 3225)), new Pair.ptr(new $Int64(0, 3527), new $Int64(0, 2427)), new Pair.ptr(new $Int64(0, 3529), new $Int64(0, 3450)), new Pair.ptr(new $Int64(0, 3533), new $Int64(0, 1766)), new Pair.ptr(new $Int64(0, 3539), new $Int64(0, 670)), new Pair.ptr(new $Int64(0, 3541), new $Int64(0, 168)), new Pair.ptr(new $Int64(0, 3547), new $Int64(0, 2100)), new Pair.ptr(new $Int64(0, 3557), new $Int64(0, 2596)), new Pair.ptr(new $Int64(0, 3559), new $Int64(0, 3322)), new Pair.ptr(new $Int64(0, 3571), new $Int64(0, 643)), new Pair.ptr(new $Int64(0, 3581), new $Int64(0, 1453)), new Pair.ptr(new $Int64(0, 3583), new $Int64(0, 1181)), new Pair.ptr(new $Int64(0, 3593), new $Int64(0, 2810)), new Pair.ptr(new $Int64(0, 3607), new $Int64(0, 732)), new Pair.ptr(new $Int64(0, 3613), new $Int64(0, 811)), new Pair.ptr(new $Int64(0, 3617), new $Int64(0, 1077)), new Pair.ptr(new $Int64(0, 3623), new $Int64(0, 2467)), new Pair.ptr(new $Int64(0, 3631), new $Int64(0, 2005)), new Pair.ptr(new $Int64(0, 3637), new $Int64(0, 2939)), new Pair.ptr(new $Int64(0, 3643), new $Int64(0, 3459)), new Pair.ptr(new $Int64(0, 3659), new $Int64(0, 817)), new Pair.ptr(new $Int64(0, 3671), new $Int64(0, 933)), new Pair.ptr(new $Int64(0, 3673), new $Int64(0, 2705)), new Pair.ptr(new $Int64(0, 3677), new $Int64(0, 2364)), new Pair.ptr(new $Int64(0, 3691), new $Int64(0, 318)), new Pair.ptr(new $Int64(0, 3697), new $Int64(0, 910)), new Pair.ptr(new $Int64(0, 3701), new $Int64(0, 2585)), new Pair.ptr(new $Int64(0, 3709), new $Int64(0, 2142)), new Pair.ptr(new $Int64(0, 3719), new $Int64(0, 2010)), new Pair.ptr(new $Int64(0, 3727), new $Int64(0, 492)), new Pair.ptr(new $Int64(0, 3733), new $Int64(0, 1636)), new Pair.ptr(new $Int64(0, 3739), new $Int64(0, 3335)), new Pair.ptr(new $Int64(0, 3761), new $Int64(0, 2610)), new Pair.ptr(new $Int64(0, 3767), new $Int64(0, 1768)), new Pair.ptr(new $Int64(0, 3769), new $Int64(0, 3406)), new Pair.ptr(new $Int64(0, 3779), new $Int64(0, 1361)), new Pair.ptr(new $Int64(0, 3793), new $Int64(0, 607)), new Pair.ptr(new $Int64(0, 3797), new $Int64(0, 738)), new Pair.ptr(new $Int64(0, 3803), new $Int64(0, 1957)), new Pair.ptr(new $Int64(0, 3821), new $Int64(0, 2310)), new Pair.ptr(new $Int64(0, 3823), new $Int64(0, 1199)), new Pair.ptr(new $Int64(0, 3833), new $Int64(0, 727)), new Pair.ptr(new $Int64(0, 3847), new $Int64(0, 896)), new Pair.ptr(new $Int64(0, 3851), new $Int64(0, 469)), new Pair.ptr(new $Int64(0, 3853), new $Int64(0, 3005)), new Pair.ptr(new $Int64(0, 3863), new $Int64(0, 2642)), new Pair.ptr(new $Int64(0, 3877), new $Int64(0, 3009)), new Pair.ptr(new $Int64(0, 3881), new $Int64(0, 2418)), new Pair.ptr(new $Int64(0, 3889), new $Int64(0, 1568)), new Pair.ptr(new $Int64(0, 3907), new $Int64(0, 627)), new Pair.ptr(new $Int64(0, 3911), new $Int64(0, 1877)), new Pair.ptr(new $Int64(0, 3917), new $Int64(0, 2937)), new Pair.ptr(new $Int64(0, 3919), new $Int64(0, 3106)), new Pair.ptr(new $Int64(0, 3923), new $Int64(0, 2152)), new Pair.ptr(new $Int64(0, 3929), new $Int64(0, 578)), new Pair.ptr(new $Int64(0, 3931), new $Int64(0, 429)), new Pair.ptr(new $Int64(0, 3943), new $Int64(0, 3734)), new Pair.ptr(new $Int64(0, 3947), new $Int64(0, 2509)), new Pair.ptr(new $Int64(0, 3967), new $Int64(0, 1669)), new Pair.ptr(new $Int64(0, 3989), new $Int64(0, 3466)), new Pair.ptr(new $Int64(0, 4001), new $Int64(0, 3512)), new Pair.ptr(new $Int64(0, 4003), new $Int64(0, 3069)), new Pair.ptr(new $Int64(0, 4007), new $Int64(0, 1024)), new Pair.ptr(new $Int64(0, 4013), new $Int64(0, 2928)), new Pair.ptr(new $Int64(0, 4019), new $Int64(0, 259)), new Pair.ptr(new $Int64(0, 4021), new $Int64(0, 954)), new Pair.ptr(new $Int64(0, 4027), new $Int64(0, 2352)), new Pair.ptr(new $Int64(0, 4049), new $Int64(0, 4046)), new Pair.ptr(new $Int64(0, 4051), new $Int64(0, 2761)), new Pair.ptr(new $Int64(0, 4057), new $Int64(0, 569)), new Pair.ptr(new $Int64(0, 4073), new $Int64(0, 1155)), new Pair.ptr(new $Int64(0, 4079), new $Int64(0, 3207)), new Pair.ptr(new $Int64(0, 4091), new $Int64(0, 1569)), new Pair.ptr(new $Int64(0, 4093), new $Int64(0, 3000)), new Pair.ptr(new $Int64(0, 4099), new $Int64(0, 3738)), new Pair.ptr(new $Int64(0, 4111), new $Int64(0, 1346)), new Pair.ptr(new $Int64(0, 4127), new $Int64(0, 2106)), new Pair.ptr(new $Int64(0, 4129), new $Int64(0, 2168)), new Pair.ptr(new $Int64(0, 4133), new $Int64(0, 4023)), new Pair.ptr(new $Int64(0, 4139), new $Int64(0, 4046)), new Pair.ptr(new $Int64(0, 4153), new $Int64(0, 1428)), new Pair.ptr(new $Int64(0, 4157), new $Int64(0, 48)), new Pair.ptr(new $Int64(0, 4159), new $Int64(0, 4015)), new Pair.ptr(new $Int64(0, 4177), new $Int64(0, 1604)), new Pair.ptr(new $Int64(0, 4201), new $Int64(0, 1792)), new Pair.ptr(new $Int64(0, 4211), new $Int64(0, 3954)), new Pair.ptr(new $Int64(0, 4217), new $Int64(0, 1896)), new Pair.ptr(new $Int64(0, 4219), new $Int64(0, 2014)), new Pair.ptr(new $Int64(0, 4229), new $Int64(0, 2424)), new Pair.ptr(new $Int64(0, 4231), new $Int64(0, 1529)), new Pair.ptr(new $Int64(0, 4241), new $Int64(0, 2816)), new Pair.ptr(new $Int64(0, 4243), new $Int64(0, 2028)), new Pair.ptr(new $Int64(0, 4253), new $Int64(0, 78)), new Pair.ptr(new $Int64(0, 4259), new $Int64(0, 3891)), new Pair.ptr(new $Int64(0, 4261), new $Int64(0, 3731)), new Pair.ptr(new $Int64(0, 4271), new $Int64(0, 3701)), new Pair.ptr(new $Int64(0, 4273), new $Int64(0, 2720)), new Pair.ptr(new $Int64(0, 4283), new $Int64(0, 3693)), new Pair.ptr(new $Int64(0, 4289), new $Int64(0, 1685)), new Pair.ptr(new $Int64(0, 4297), new $Int64(0, 285)), new Pair.ptr(new $Int64(0, 4327), new $Int64(0, 1466)), new Pair.ptr(new $Int64(0, 4337), new $Int64(0, 3813)), new Pair.ptr(new $Int64(0, 4339), new $Int64(0, 1148)), new Pair.ptr(new $Int64(0, 4349), new $Int64(0, 3088)), new Pair.ptr(new $Int64(0, 4357), new $Int64(0, 857)), new Pair.ptr(new $Int64(0, 4363), new $Int64(0, 2713)), new Pair.ptr(new $Int64(0, 4373), new $Int64(0, 3562)), new Pair.ptr(new $Int64(0, 4391), new $Int64(0, 3669)), new Pair.ptr(new $Int64(0, 4397), new $Int64(0, 4193)), new Pair.ptr(new $Int64(0, 4409), new $Int64(0, 4278)), new Pair.ptr(new $Int64(0, 4421), new $Int64(0, 1732)), new Pair.ptr(new $Int64(0, 4423), new $Int64(0, 4056)), new Pair.ptr(new $Int64(0, 4441), new $Int64(0, 417)), new Pair.ptr(new $Int64(0, 4447), new $Int64(0, 436)), new Pair.ptr(new $Int64(0, 4451), new $Int64(0, 1796)), new Pair.ptr(new $Int64(0, 4457), new $Int64(0, 2605)), new Pair.ptr(new $Int64(0, 4463), new $Int64(0, 4381)), new Pair.ptr(new $Int64(0, 4481), new $Int64(0, 1995)), new Pair.ptr(new $Int64(0, 4483), new $Int64(0, 1874)), new Pair.ptr(new $Int64(0, 4493), new $Int64(0, 630)), new Pair.ptr(new $Int64(0, 4507), new $Int64(0, 2907)), new Pair.ptr(new $Int64(0, 4513), new $Int64(0, 73)), new Pair.ptr(new $Int64(0, 4517), new $Int64(0, 2525)), new Pair.ptr(new $Int64(0, 4519), new $Int64(0, 3884)), new Pair.ptr(new $Int64(0, 4523), new $Int64(0, 981)), new Pair.ptr(new $Int64(0, 4547), new $Int64(0, 333)), new Pair.ptr(new $Int64(0, 4549), new $Int64(0, 2309)), new Pair.ptr(new $Int64(0, 4561), new $Int64(0, 1335)), new Pair.ptr(new $Int64(0, 4567), new $Int64(0, 1561)), new Pair.ptr(new $Int64(0, 4583), new $Int64(0, 424)), new Pair.ptr(new $Int64(0, 4591), new $Int64(0, 274)), new Pair.ptr(new $Int64(0, 4597), new $Int64(0, 2360)), new Pair.ptr(new $Int64(0, 4603), new $Int64(0, 2968)), new Pair.ptr(new $Int64(0, 4621), new $Int64(0, 1955)), new Pair.ptr(new $Int64(0, 4637), new $Int64(0, 577)), new Pair.ptr(new $Int64(0, 4639), new $Int64(0, 2620)), new Pair.ptr(new $Int64(0, 4643), new $Int64(0, 3688)), new Pair.ptr(new $Int64(0, 4649), new $Int64(0, 1153)), new Pair.ptr(new $Int64(0, 4651), new $Int64(0, 4299)), new Pair.ptr(new $Int64(0, 4657), new $Int64(0, 2435)), new Pair.ptr(new $Int64(0, 4663), new $Int64(0, 2832)), new Pair.ptr(new $Int64(0, 4673), new $Int64(0, 919)), new Pair.ptr(new $Int64(0, 4679), new $Int64(0, 790)), new Pair.ptr(new $Int64(0, 4691), new $Int64(0, 4475)), new Pair.ptr(new $Int64(0, 4703), new $Int64(0, 717)), new Pair.ptr(new $Int64(0, 4721), new $Int64(0, 2116)), new Pair.ptr(new $Int64(0, 4723), new $Int64(0, 4626)), new Pair.ptr(new $Int64(0, 4729), new $Int64(0, 1113)), new Pair.ptr(new $Int64(0, 4733), new $Int64(0, 588)), new Pair.ptr(new $Int64(0, 4751), new $Int64(0, 4041)), new Pair.ptr(new $Int64(0, 4759), new $Int64(0, 1542)), new Pair.ptr(new $Int64(0, 4783), new $Int64(0, 4195)), new Pair.ptr(new $Int64(0, 4787), new $Int64(0, 3679)), new Pair.ptr(new $Int64(0, 4789), new $Int64(0, 3225)), new Pair.ptr(new $Int64(0, 4793), new $Int64(0, 3217)), new Pair.ptr(new $Int64(0, 4799), new $Int64(0, 1026)), new Pair.ptr(new $Int64(0, 4801), new $Int64(0, 2729)), new Pair.ptr(new $Int64(0, 4813), new $Int64(0, 4273)), new Pair.ptr(new $Int64(0, 4817), new $Int64(0, 3364)), new Pair.ptr(new $Int64(0, 4831), new $Int64(0, 1630)), new Pair.ptr(new $Int64(0, 4861), new $Int64(0, 2581)), new Pair.ptr(new $Int64(0, 4871), new $Int64(0, 1710)), new Pair.ptr(new $Int64(0, 4877), new $Int64(0, 3345)), new Pair.ptr(new $Int64(0, 4889), new $Int64(0, 4817)), new Pair.ptr(new $Int64(0, 4903), new $Int64(0, 2101)), new Pair.ptr(new $Int64(0, 4909), new $Int64(0, 4012)), new Pair.ptr(new $Int64(0, 4919), new $Int64(0, 4521)), new Pair.ptr(new $Int64(0, 4931), new $Int64(0, 236)), new Pair.ptr(new $Int64(0, 4933), new $Int64(0, 511)), new Pair.ptr(new $Int64(0, 4937), new $Int64(0, 602)), new Pair.ptr(new $Int64(0, 4943), new $Int64(0, 2714)), new Pair.ptr(new $Int64(0, 4951), new $Int64(0, 340)), new Pair.ptr(new $Int64(0, 4957), new $Int64(0, 3352)), new Pair.ptr(new $Int64(0, 4967), new $Int64(0, 659)), new Pair.ptr(new $Int64(0, 4969), new $Int64(0, 3721)), new Pair.ptr(new $Int64(0, 4973), new $Int64(0, 4319)), new Pair.ptr(new $Int64(0, 4987), new $Int64(0, 1443)), new Pair.ptr(new $Int64(0, 4993), new $Int64(0, 1647)), new Pair.ptr(new $Int64(0, 4999), new $Int64(0, 4756)), new Pair.ptr(new $Int64(0, 5003), new $Int64(0, 1355)), new Pair.ptr(new $Int64(0, 5009), new $Int64(0, 887)), new Pair.ptr(new $Int64(0, 5011), new $Int64(0, 4837)), new Pair.ptr(new $Int64(0, 5021), new $Int64(0, 693)), new Pair.ptr(new $Int64(0, 5023), new $Int64(0, 3151)), new Pair.ptr(new $Int64(0, 5039), new $Int64(0, 4440)), new Pair.ptr(new $Int64(0, 5051), new $Int64(0, 1917)), new Pair.ptr(new $Int64(0, 5059), new $Int64(0, 4290)), new Pair.ptr(new $Int64(0, 5077), new $Int64(0, 4128)), new Pair.ptr(new $Int64(0, 5081), new $Int64(0, 2521)), new Pair.ptr(new $Int64(0, 5087), new $Int64(0, 990)), new Pair.ptr(new $Int64(0, 5099), new $Int64(0, 1164)), new Pair.ptr(new $Int64(0, 5101), new $Int64(0, 507)), new Pair.ptr(new $Int64(0, 5107), new $Int64(0, 2493)), new Pair.ptr(new $Int64(0, 5113), new $Int64(0, 144)), new Pair.ptr(new $Int64(0, 5119), new $Int64(0, 58)), new Pair.ptr(new $Int64(0, 5147), new $Int64(0, 3750)), new Pair.ptr(new $Int64(0, 5153), new $Int64(0, 1487)), new Pair.ptr(new $Int64(0, 5167), new $Int64(0, 1317)), new Pair.ptr(new $Int64(0, 5171), new $Int64(0, 1198)), new Pair.ptr(new $Int64(0, 5179), new $Int64(0, 3000)), new Pair.ptr(new $Int64(0, 5189), new $Int64(0, 3249)), new Pair.ptr(new $Int64(0, 5197), new $Int64(0, 150)), new Pair.ptr(new $Int64(0, 5209), new $Int64(0, 1814)), new Pair.ptr(new $Int64(0, 5227), new $Int64(0, 207)), new Pair.ptr(new $Int64(0, 5231), new $Int64(0, 786)), new Pair.ptr(new $Int64(0, 5233), new $Int64(0, 1883)), new Pair.ptr(new $Int64(0, 5237), new $Int64(0, 3639)), new Pair.ptr(new $Int64(0, 5261), new $Int64(0, 3128)), new Pair.ptr(new $Int64(0, 5273), new $Int64(0, 4677)), new Pair.ptr(new $Int64(0, 5279), new $Int64(0, 5047)), new Pair.ptr(new $Int64(0, 5281), new $Int64(0, 3598)), new Pair.ptr(new $Int64(0, 5297), new $Int64(0, 3133)), new Pair.ptr(new $Int64(0, 5303), new $Int64(0, 978)), new Pair.ptr(new $Int64(0, 5309), new $Int64(0, 5138)), new Pair.ptr(new $Int64(0, 5323), new $Int64(0, 4198)), new Pair.ptr(new $Int64(0, 5333), new $Int64(0, 2426)), new Pair.ptr(new $Int64(0, 5347), new $Int64(0, 1654)), new Pair.ptr(new $Int64(0, 5351), new $Int64(0, 4840)), new Pair.ptr(new $Int64(0, 5381), new $Int64(0, 4511)), new Pair.ptr(new $Int64(0, 5387), new $Int64(0, 1600)), new Pair.ptr(new $Int64(0, 5393), new $Int64(0, 1233)), new Pair.ptr(new $Int64(0, 5399), new $Int64(0, 1219)), new Pair.ptr(new $Int64(0, 5407), new $Int64(0, 1470)), new Pair.ptr(new $Int64(0, 5413), new $Int64(0, 2183)), new Pair.ptr(new $Int64(0, 5417), new $Int64(0, 2468)), new Pair.ptr(new $Int64(0, 5419), new $Int64(0, 4644)), new Pair.ptr(new $Int64(0, 5431), new $Int64(0, 2375)), new Pair.ptr(new $Int64(0, 5437), new $Int64(0, 548)), new Pair.ptr(new $Int64(0, 5441), new $Int64(0, 2330)), new Pair.ptr(new $Int64(0, 5443), new $Int64(0, 3129)), new Pair.ptr(new $Int64(0, 5449), new $Int64(0, 3400)), new Pair.ptr(new $Int64(0, 5471), new $Int64(0, 3052)), new Pair.ptr(new $Int64(0, 5477), new $Int64(0, 4818)), new Pair.ptr(new $Int64(0, 5479), new $Int64(0, 4627)), new Pair.ptr(new $Int64(0, 5483), new $Int64(0, 3435)), new Pair.ptr(new $Int64(0, 5501), new $Int64(0, 2287)), new Pair.ptr(new $Int64(0, 5503), new $Int64(0, 1495)), new Pair.ptr(new $Int64(0, 5507), new $Int64(0, 4788)), new Pair.ptr(new $Int64(0, 5519), new $Int64(0, 3865)), new Pair.ptr(new $Int64(0, 5521), new $Int64(0, 1263)), new Pair.ptr(new $Int64(0, 5527), new $Int64(0, 2756)), new Pair.ptr(new $Int64(0, 5531), new $Int64(0, 5315)), new Pair.ptr(new $Int64(0, 5557), new $Int64(0, 388)), new Pair.ptr(new $Int64(0, 5563), new $Int64(0, 4554)), new Pair.ptr(new $Int64(0, 5569), new $Int64(0, 4582)), new Pair.ptr(new $Int64(0, 5573), new $Int64(0, 5369)), new Pair.ptr(new $Int64(0, 5581), new $Int64(0, 1759)), new Pair.ptr(new $Int64(0, 5591), new $Int64(0, 4169)), new Pair.ptr(new $Int64(0, 5623), new $Int64(0, 1786)), new Pair.ptr(new $Int64(0, 5639), new $Int64(0, 3335)), new Pair.ptr(new $Int64(0, 5641), new $Int64(0, 2812)), new Pair.ptr(new $Int64(0, 5647), new $Int64(0, 1665)), new Pair.ptr(new $Int64(0, 5651), new $Int64(0, 39)), new Pair.ptr(new $Int64(0, 5653), new $Int64(0, 4070)), new Pair.ptr(new $Int64(0, 5657), new $Int64(0, 5533)), new Pair.ptr(new $Int64(0, 5659), new $Int64(0, 751)), new Pair.ptr(new $Int64(0, 5669), new $Int64(0, 3340)), new Pair.ptr(new $Int64(0, 5683), new $Int64(0, 3284)), new Pair.ptr(new $Int64(0, 5689), new $Int64(0, 4317)), new Pair.ptr(new $Int64(0, 5693), new $Int64(0, 4950)), new Pair.ptr(new $Int64(0, 5701), new $Int64(0, 2429)), new Pair.ptr(new $Int64(0, 5711), new $Int64(0, 3203)), new Pair.ptr(new $Int64(0, 5717), new $Int64(0, 363)), new Pair.ptr(new $Int64(0, 5737), new $Int64(0, 1607)), new Pair.ptr(new $Int64(0, 5741), new $Int64(0, 5025)), new Pair.ptr(new $Int64(0, 5743), new $Int64(0, 975)), new Pair.ptr(new $Int64(0, 5749), new $Int64(0, 236)), new Pair.ptr(new $Int64(0, 5779), new $Int64(0, 3209)), new Pair.ptr(new $Int64(0, 5783), new $Int64(0, 5359)), new Pair.ptr(new $Int64(0, 5791), new $Int64(0, 2544)), new Pair.ptr(new $Int64(0, 5801), new $Int64(0, 989)), new Pair.ptr(new $Int64(0, 5807), new $Int64(0, 2476)), new Pair.ptr(new $Int64(0, 5813), new $Int64(0, 1390)), new Pair.ptr(new $Int64(0, 5821), new $Int64(0, 3963)), new Pair.ptr(new $Int64(0, 5827), new $Int64(0, 2990)), new Pair.ptr(new $Int64(0, 5839), new $Int64(0, 5596)), new Pair.ptr(new $Int64(0, 5843), new $Int64(0, 561)), new Pair.ptr(new $Int64(0, 5849), new $Int64(0, 95)), new Pair.ptr(new $Int64(0, 5851), new $Int64(0, 5566)), new Pair.ptr(new $Int64(0, 5857), new $Int64(0, 3355)), new Pair.ptr(new $Int64(0, 5861), new $Int64(0, 3555)), new Pair.ptr(new $Int64(0, 5867), new $Int64(0, 5523)), new Pair.ptr(new $Int64(0, 5869), new $Int64(0, 3108)), new Pair.ptr(new $Int64(0, 5879), new $Int64(0, 3289)), new Pair.ptr(new $Int64(0, 5881), new $Int64(0, 2303)), new Pair.ptr(new $Int64(0, 5897), new $Int64(0, 3806)), new Pair.ptr(new $Int64(0, 5903), new $Int64(0, 4049)), new Pair.ptr(new $Int64(0, 5923), new $Int64(0, 760)), new Pair.ptr(new $Int64(0, 5927), new $Int64(0, 739)), new Pair.ptr(new $Int64(0, 5939), new $Int64(0, 359)), new Pair.ptr(new $Int64(0, 5953), new $Int64(0, 4622)), new Pair.ptr(new $Int64(0, 5981), new $Int64(0, 945)), new Pair.ptr(new $Int64(0, 5987), new $Int64(0, 3734)), new Pair.ptr(new $Int64(0, 6007), new $Int64(0, 901)), new Pair.ptr(new $Int64(0, 6011), new $Int64(0, 5470)), new Pair.ptr(new $Int64(0, 6029), new $Int64(0, 2215)), new Pair.ptr(new $Int64(0, 6037), new $Int64(0, 2074)), new Pair.ptr(new $Int64(0, 6043), new $Int64(0, 2997)), new Pair.ptr(new $Int64(0, 6047), new $Int64(0, 1497)), new Pair.ptr(new $Int64(0, 6053), new $Int64(0, 2814)), new Pair.ptr(new $Int64(0, 6067), new $Int64(0, 5883)), new Pair.ptr(new $Int64(0, 6073), new $Int64(0, 3884)), new Pair.ptr(new $Int64(0, 6079), new $Int64(0, 4909)), new Pair.ptr(new $Int64(0, 6089), new $Int64(0, 3481)), new Pair.ptr(new $Int64(0, 6091), new $Int64(0, 756)), new Pair.ptr(new $Int64(0, 6101), new $Int64(0, 5462)), new Pair.ptr(new $Int64(0, 6113), new $Int64(0, 677)), new Pair.ptr(new $Int64(0, 6121), new $Int64(0, 3143)), new Pair.ptr(new $Int64(0, 6131), new $Int64(0, 3117)), new Pair.ptr(new $Int64(0, 6133), new $Int64(0, 862)), new Pair.ptr(new $Int64(0, 6143), new $Int64(0, 1047)), new Pair.ptr(new $Int64(0, 6151), new $Int64(0, 1805)), new Pair.ptr(new $Int64(0, 6163), new $Int64(0, 4214)), new Pair.ptr(new $Int64(0, 6173), new $Int64(0, 4578)), new Pair.ptr(new $Int64(0, 6197), new $Int64(0, 1254)), new Pair.ptr(new $Int64(0, 6199), new $Int64(0, 2857)), new Pair.ptr(new $Int64(0, 6203), new $Int64(0, 1302)), new Pair.ptr(new $Int64(0, 6211), new $Int64(0, 4531)), new Pair.ptr(new $Int64(0, 6217), new $Int64(0, 4704)), new Pair.ptr(new $Int64(0, 6221), new $Int64(0, 2866)), new Pair.ptr(new $Int64(0, 6229), new $Int64(0, 4817)), new Pair.ptr(new $Int64(0, 6247), new $Int64(0, 1611)), new Pair.ptr(new $Int64(0, 6257), new $Int64(0, 5301)), new Pair.ptr(new $Int64(0, 6263), new $Int64(0, 4127)), new Pair.ptr(new $Int64(0, 6269), new $Int64(0, 3324)), new Pair.ptr(new $Int64(0, 6271), new $Int64(0, 155)), new Pair.ptr(new $Int64(0, 6277), new $Int64(0, 3003)), new Pair.ptr(new $Int64(0, 6287), new $Int64(0, 3874)), new Pair.ptr(new $Int64(0, 6299), new $Int64(0, 5352)), new Pair.ptr(new $Int64(0, 6301), new $Int64(0, 2137)), new Pair.ptr(new $Int64(0, 6311), new $Int64(0, 2991)), new Pair.ptr(new $Int64(0, 6317), new $Int64(0, 521)), new Pair.ptr(new $Int64(0, 6323), new $Int64(0, 5951)), new Pair.ptr(new $Int64(0, 6329), new $Int64(0, 773)), new Pair.ptr(new $Int64(0, 6337), new $Int64(0, 1142)), new Pair.ptr(new $Int64(0, 6343), new $Int64(0, 703)), new Pair.ptr(new $Int64(0, 6353), new $Int64(0, 3604)), new Pair.ptr(new $Int64(0, 6359), new $Int64(0, 6232)), new Pair.ptr(new $Int64(0, 6361), new $Int64(0, 5681)), new Pair.ptr(new $Int64(0, 6367), new $Int64(0, 6158)), new Pair.ptr(new $Int64(0, 6373), new $Int64(0, 692)), new Pair.ptr(new $Int64(0, 6379), new $Int64(0, 2325)), new Pair.ptr(new $Int64(0, 6389), new $Int64(0, 2443)), new Pair.ptr(new $Int64(0, 6397), new $Int64(0, 4428)), new Pair.ptr(new $Int64(0, 6421), new $Int64(0, 991)), new Pair.ptr(new $Int64(0, 6427), new $Int64(0, 3773)), new Pair.ptr(new $Int64(0, 6449), new $Int64(0, 5684)), new Pair.ptr(new $Int64(0, 6451), new $Int64(0, 6343)), new Pair.ptr(new $Int64(0, 6469), new $Int64(0, 5623)), new Pair.ptr(new $Int64(0, 6473), new $Int64(0, 4073)), new Pair.ptr(new $Int64(0, 6481), new $Int64(0, 6086)), new Pair.ptr(new $Int64(0, 6491), new $Int64(0, 4357)), new Pair.ptr(new $Int64(0, 6521), new $Int64(0, 5496)), new Pair.ptr(new $Int64(0, 6529), new $Int64(0, 480)), new Pair.ptr(new $Int64(0, 6547), new $Int64(0, 619)), new Pair.ptr(new $Int64(0, 6551), new $Int64(0, 3216)), new Pair.ptr(new $Int64(0, 6553), new $Int64(0, 2502)), new Pair.ptr(new $Int64(0, 6563), new $Int64(0, 499)), new Pair.ptr(new $Int64(0, 6569), new $Int64(0, 822)), new Pair.ptr(new $Int64(0, 6571), new $Int64(0, 3100)), new Pair.ptr(new $Int64(0, 6577), new $Int64(0, 3774)), new Pair.ptr(new $Int64(0, 6581), new $Int64(0, 3045)), new Pair.ptr(new $Int64(0, 6599), new $Int64(0, 1958)), new Pair.ptr(new $Int64(0, 6607), new $Int64(0, 4377)), new Pair.ptr(new $Int64(0, 6619), new $Int64(0, 3120)), new Pair.ptr(new $Int64(0, 6637), new $Int64(0, 2121)), new Pair.ptr(new $Int64(0, 6653), new $Int64(0, 4708)), new Pair.ptr(new $Int64(0, 6659), new $Int64(0, 2039)), new Pair.ptr(new $Int64(0, 6661), new $Int64(0, 6631)), new Pair.ptr(new $Int64(0, 6673), new $Int64(0, 5561)), new Pair.ptr(new $Int64(0, 6679), new $Int64(0, 1637)), new Pair.ptr(new $Int64(0, 6689), new $Int64(0, 6096)), new Pair.ptr(new $Int64(0, 6691), new $Int64(0, 1031)), new Pair.ptr(new $Int64(0, 6701), new $Int64(0, 2893)), new Pair.ptr(new $Int64(0, 6703), new $Int64(0, 4908)), new Pair.ptr(new $Int64(0, 6709), new $Int64(0, 3459)), new Pair.ptr(new $Int64(0, 6719), new $Int64(0, 188)), new Pair.ptr(new $Int64(0, 6733), new $Int64(0, 5009)), new Pair.ptr(new $Int64(0, 6737), new $Int64(0, 2181)), new Pair.ptr(new $Int64(0, 6761), new $Int64(0, 2078)), new Pair.ptr(new $Int64(0, 6763), new $Int64(0, 2996)), new Pair.ptr(new $Int64(0, 6779), new $Int64(0, 2306)), new Pair.ptr(new $Int64(0, 6781), new $Int64(0, 5084)), new Pair.ptr(new $Int64(0, 6791), new $Int64(0, 4460)), new Pair.ptr(new $Int64(0, 6793), new $Int64(0, 2709)), new Pair.ptr(new $Int64(0, 6803), new $Int64(0, 2393)), new Pair.ptr(new $Int64(0, 6823), new $Int64(0, 504)), new Pair.ptr(new $Int64(0, 6827), new $Int64(0, 3685)), new Pair.ptr(new $Int64(0, 6829), new $Int64(0, 485)), new Pair.ptr(new $Int64(0, 6833), new $Int64(0, 825)), new Pair.ptr(new $Int64(0, 6841), new $Int64(0, 4572)), new Pair.ptr(new $Int64(0, 6857), new $Int64(0, 4590)), new Pair.ptr(new $Int64(0, 6863), new $Int64(0, 2157)), new Pair.ptr(new $Int64(0, 6869), new $Int64(0, 314)), new Pair.ptr(new $Int64(0, 6871), new $Int64(0, 1879)), new Pair.ptr(new $Int64(0, 6883), new $Int64(0, 2836)), new Pair.ptr(new $Int64(0, 6899), new $Int64(0, 4635)), new Pair.ptr(new $Int64(0, 6907), new $Int64(0, 5007)), new Pair.ptr(new $Int64(0, 6911), new $Int64(0, 5533)), new Pair.ptr(new $Int64(0, 6917), new $Int64(0, 4758)), new Pair.ptr(new $Int64(0, 6947), new $Int64(0, 2334)), new Pair.ptr(new $Int64(0, 6949), new $Int64(0, 3791)), new Pair.ptr(new $Int64(0, 6959), new $Int64(0, 3198)), new Pair.ptr(new $Int64(0, 6961), new $Int64(0, 3623)), new Pair.ptr(new $Int64(0, 6967), new $Int64(0, 2437)), new Pair.ptr(new $Int64(0, 6971), new $Int64(0, 5104)), new Pair.ptr(new $Int64(0, 6977), new $Int64(0, 5444)), new Pair.ptr(new $Int64(0, 6983), new $Int64(0, 1239)), new Pair.ptr(new $Int64(0, 6991), new $Int64(0, 5327)), new Pair.ptr(new $Int64(0, 6997), new $Int64(0, 5067)), new Pair.ptr(new $Int64(0, 7001), new $Int64(0, 6544)), new Pair.ptr(new $Int64(0, 7013), new $Int64(0, 5250)), new Pair.ptr(new $Int64(0, 7019), new $Int64(0, 2598)), new Pair.ptr(new $Int64(0, 7027), new $Int64(0, 1584)), new Pair.ptr(new $Int64(0, 7039), new $Int64(0, 5853)), new Pair.ptr(new $Int64(0, 7043), new $Int64(0, 6699)), new Pair.ptr(new $Int64(0, 7057), new $Int64(0, 1589)), new Pair.ptr(new $Int64(0, 7069), new $Int64(0, 1067)), new Pair.ptr(new $Int64(0, 7079), new $Int64(0, 4222)), new Pair.ptr(new $Int64(0, 7103), new $Int64(0, 6270)), new Pair.ptr(new $Int64(0, 7109), new $Int64(0, 1930)), new Pair.ptr(new $Int64(0, 7121), new $Int64(0, 7083)), new Pair.ptr(new $Int64(0, 7127), new $Int64(0, 2099)), new Pair.ptr(new $Int64(0, 7129), new $Int64(0, 4199)), new Pair.ptr(new $Int64(0, 7151), new $Int64(0, 2639)), new Pair.ptr(new $Int64(0, 7159), new $Int64(0, 5445)), new Pair.ptr(new $Int64(0, 7177), new $Int64(0, 1193)), new Pair.ptr(new $Int64(0, 7187), new $Int64(0, 5344)), new Pair.ptr(new $Int64(0, 7193), new $Int64(0, 2320)), new Pair.ptr(new $Int64(0, 7207), new $Int64(0, 721)), new Pair.ptr(new $Int64(0, 7211), new $Int64(0, 2391)), new Pair.ptr(new $Int64(0, 7213), new $Int64(0, 3507)), new Pair.ptr(new $Int64(0, 7219), new $Int64(0, 208)), new Pair.ptr(new $Int64(0, 7229), new $Int64(0, 5949)), new Pair.ptr(new $Int64(0, 7237), new $Int64(0, 7135)), new Pair.ptr(new $Int64(0, 7243), new $Int64(0, 611)), new Pair.ptr(new $Int64(0, 7247), new $Int64(0, 5204)), new Pair.ptr(new $Int64(0, 7253), new $Int64(0, 2727)), new Pair.ptr(new $Int64(0, 7283), new $Int64(0, 3384)), new Pair.ptr(new $Int64(0, 7297), new $Int64(0, 3655)), new Pair.ptr(new $Int64(0, 7307), new $Int64(0, 3674)), new Pair.ptr(new $Int64(0, 7309), new $Int64(0, 4002)), new Pair.ptr(new $Int64(0, 7321), new $Int64(0, 6926)), new Pair.ptr(new $Int64(0, 7331), new $Int64(0, 7074)), new Pair.ptr(new $Int64(0, 7333), new $Int64(0, 3895)), new Pair.ptr(new $Int64(0, 7349), new $Int64(0, 681)), new Pair.ptr(new $Int64(0, 7351), new $Int64(0, 5616)), new Pair.ptr(new $Int64(0, 7369), new $Int64(0, 6674)), new Pair.ptr(new $Int64(0, 7393), new $Int64(0, 4322)), new Pair.ptr(new $Int64(0, 7411), new $Int64(0, 24)), new Pair.ptr(new $Int64(0, 7417), new $Int64(0, 3478)), new Pair.ptr(new $Int64(0, 7433), new $Int64(0, 1640)), new Pair.ptr(new $Int64(0, 7451), new $Int64(0, 4525)), new Pair.ptr(new $Int64(0, 7457), new $Int64(0, 4716)), new Pair.ptr(new $Int64(0, 7459), new $Int64(0, 1586)), new Pair.ptr(new $Int64(0, 7477), new $Int64(0, 1762)), new Pair.ptr(new $Int64(0, 7481), new $Int64(0, 6193)), new Pair.ptr(new $Int64(0, 7487), new $Int64(0, 6962)), new Pair.ptr(new $Int64(0, 7489), new $Int64(0, 3618)), new Pair.ptr(new $Int64(0, 7499), new $Int64(0, 5128)), new Pair.ptr(new $Int64(0, 7507), new $Int64(0, 4692)), new Pair.ptr(new $Int64(0, 7517), new $Int64(0, 6973)), new Pair.ptr(new $Int64(0, 7523), new $Int64(0, 91)), new Pair.ptr(new $Int64(0, 7529), new $Int64(0, 2123)), new Pair.ptr(new $Int64(0, 7537), new $Int64(0, 6531)), new Pair.ptr(new $Int64(0, 7541), new $Int64(0, 408)), new Pair.ptr(new $Int64(0, 7547), new $Int64(0, 5099)), new Pair.ptr(new $Int64(0, 7549), new $Int64(0, 5423)), new Pair.ptr(new $Int64(0, 7559), new $Int64(0, 6449)), new Pair.ptr(new $Int64(0, 7561), new $Int64(0, 3754)), new Pair.ptr(new $Int64(0, 7573), new $Int64(0, 5528)), new Pair.ptr(new $Int64(0, 7577), new $Int64(0, 6003)), new Pair.ptr(new $Int64(0, 7583), new $Int64(0, 747)), new Pair.ptr(new $Int64(0, 7589), new $Int64(0, 5942)), new Pair.ptr(new $Int64(0, 7591), new $Int64(0, 3858)), new Pair.ptr(new $Int64(0, 7603), new $Int64(0, 5548)), new Pair.ptr(new $Int64(0, 7607), new $Int64(0, 4353)), new Pair.ptr(new $Int64(0, 7621), new $Int64(0, 491)), new Pair.ptr(new $Int64(0, 7639), new $Int64(0, 6764)), new Pair.ptr(new $Int64(0, 7643), new $Int64(0, 2154)), new Pair.ptr(new $Int64(0, 7649), new $Int64(0, 598)), new Pair.ptr(new $Int64(0, 7669), new $Int64(0, 6283)), new Pair.ptr(new $Int64(0, 7673), new $Int64(0, 3341)), new Pair.ptr(new $Int64(0, 7681), new $Int64(0, 3146)), new Pair.ptr(new $Int64(0, 7687), new $Int64(0, 6421)), new Pair.ptr(new $Int64(0, 7691), new $Int64(0, 5708)), new Pair.ptr(new $Int64(0, 7699), new $Int64(0, 691)), new Pair.ptr(new $Int64(0, 7703), new $Int64(0, 1613)), new Pair.ptr(new $Int64(0, 7717), new $Int64(0, 1356)), new Pair.ptr(new $Int64(0, 7723), new $Int64(0, 2372)), new Pair.ptr(new $Int64(0, 7727), new $Int64(0, 5155)), new Pair.ptr(new $Int64(0, 7741), new $Int64(0, 259)), new Pair.ptr(new $Int64(0, 7753), new $Int64(0, 6097)), new Pair.ptr(new $Int64(0, 7757), new $Int64(0, 3383)), new Pair.ptr(new $Int64(0, 7759), new $Int64(0, 5289)), new Pair.ptr(new $Int64(0, 7789), new $Int64(0, 6428)), new Pair.ptr(new $Int64(0, 7793), new $Int64(0, 1735)), new Pair.ptr(new $Int64(0, 7817), new $Int64(0, 633)), new Pair.ptr(new $Int64(0, 7823), new $Int64(0, 3631)), new Pair.ptr(new $Int64(0, 7829), new $Int64(0, 2321)), new Pair.ptr(new $Int64(0, 7841), new $Int64(0, 7384)), new Pair.ptr(new $Int64(0, 7853), new $Int64(0, 5769)), new Pair.ptr(new $Int64(0, 7867), new $Int64(0, 398)), new Pair.ptr(new $Int64(0, 7873), new $Int64(0, 5688)), new Pair.ptr(new $Int64(0, 7877), new $Int64(0, 5560)), new Pair.ptr(new $Int64(0, 7879), new $Int64(0, 5725)), new Pair.ptr(new $Int64(0, 7883), new $Int64(0, 1379)), new Pair.ptr(new $Int64(0, 7901), new $Int64(0, 4524)), new Pair.ptr(new $Int64(0, 7907), new $Int64(0, 2072)), new Pair.ptr(new $Int64(0, 7919), new $Int64(0, 7658)), new Pair.ptr(new $Int64(0, 7927), new $Int64(0, 7255)), new Pair.ptr(new $Int64(0, 7933), new $Int64(0, 7249)), new Pair.ptr(new $Int64(0, 7937), new $Int64(0, 1729)), new Pair.ptr(new $Int64(0, 7949), new $Int64(0, 1491)), new Pair.ptr(new $Int64(0, 7951), new $Int64(0, 3199)), new Pair.ptr(new $Int64(0, 7963), new $Int64(0, 5580)), new Pair.ptr(new $Int64(0, 7993), new $Int64(0, 5080)), new Pair.ptr(new $Int64(0, 8009), new $Int64(0, 7475)), new Pair.ptr(new $Int64(0, 8011), new $Int64(0, 178)), new Pair.ptr(new $Int64(0, 8017), new $Int64(0, 772)), new Pair.ptr(new $Int64(0, 8039), new $Int64(0, 1020)), new Pair.ptr(new $Int64(0, 8053), new $Int64(0, 6168)), new Pair.ptr(new $Int64(0, 8059), new $Int64(0, 6995)), new Pair.ptr(new $Int64(0, 8069), new $Int64(0, 6076)), new Pair.ptr(new $Int64(0, 8081), new $Int64(0, 6391)), new Pair.ptr(new $Int64(0, 8087), new $Int64(0, 1283)), new Pair.ptr(new $Int64(0, 8089), new $Int64(0, 1225)), new Pair.ptr(new $Int64(0, 8093), new $Int64(0, 7344)), new Pair.ptr(new $Int64(0, 8101), new $Int64(0, 3403)), new Pair.ptr(new $Int64(0, 8111), new $Int64(0, 8090)), new Pair.ptr(new $Int64(0, 8117), new $Int64(0, 5178)), new Pair.ptr(new $Int64(0, 8123), new $Int64(0, 2411)), new Pair.ptr(new $Int64(0, 8147), new $Int64(0, 2786)), new Pair.ptr(new $Int64(0, 8161), new $Int64(0, 6351)), new Pair.ptr(new $Int64(0, 8167), new $Int64(0, 1380)), new Pair.ptr(new $Int64(0, 8171), new $Int64(0, 4799)), new Pair.ptr(new $Int64(0, 8179), new $Int64(0, 4174)), new Pair.ptr(new $Int64(0, 8191), new $Int64(0, 2420)), new Pair.ptr(new $Int64(0, 8209), new $Int64(0, 1522)), new Pair.ptr(new $Int64(0, 8219), new $Int64(0, 4438)), new Pair.ptr(new $Int64(0, 8221), new $Int64(0, 1778)), new Pair.ptr(new $Int64(0, 8231), new $Int64(0, 6228)), new Pair.ptr(new $Int64(0, 8233), new $Int64(0, 2798)), new Pair.ptr(new $Int64(0, 8237), new $Int64(0, 235)), new Pair.ptr(new $Int64(0, 8243), new $Int64(0, 6564)), new Pair.ptr(new $Int64(0, 8263), new $Int64(0, 5621)), new Pair.ptr(new $Int64(0, 8269), new $Int64(0, 1149)), new Pair.ptr(new $Int64(0, 8273), new $Int64(0, 6685)), new Pair.ptr(new $Int64(0, 8287), new $Int64(0, 1897)), new Pair.ptr(new $Int64(0, 8291), new $Int64(0, 8166)), new Pair.ptr(new $Int64(0, 8293), new $Int64(0, 1323)), new Pair.ptr(new $Int64(0, 8297), new $Int64(0, 1824)), new Pair.ptr(new $Int64(0, 8311), new $Int64(0, 1675)), new Pair.ptr(new $Int64(0, 8317), new $Int64(0, 8125)), new Pair.ptr(new $Int64(0, 8329), new $Int64(0, 1927)), new Pair.ptr(new $Int64(0, 8353), new $Int64(0, 3982)), new Pair.ptr(new $Int64(0, 8363), new $Int64(0, 5657)), new Pair.ptr(new $Int64(0, 8369), new $Int64(0, 6281)), new Pair.ptr(new $Int64(0, 8377), new $Int64(0, 1518)), new Pair.ptr(new $Int64(0, 8387), new $Int64(0, 388)), new Pair.ptr(new $Int64(0, 8389), new $Int64(0, 160)), new Pair.ptr(new $Int64(0, 8419), new $Int64(0, 7728)), new Pair.ptr(new $Int64(0, 8423), new $Int64(0, 7898)), new Pair.ptr(new $Int64(0, 8429), new $Int64(0, 3122)), new Pair.ptr(new $Int64(0, 8431), new $Int64(0, 4167)), new Pair.ptr(new $Int64(0, 8443), new $Int64(0, 6220)), new Pair.ptr(new $Int64(0, 8447), new $Int64(0, 3416)), new Pair.ptr(new $Int64(0, 8461), new $Int64(0, 2971)), new Pair.ptr(new $Int64(0, 8467), new $Int64(0, 2949)), new Pair.ptr(new $Int64(0, 8501), new $Int64(0, 392)), new Pair.ptr(new $Int64(0, 8513), new $Int64(0, 2278)), new Pair.ptr(new $Int64(0, 8521), new $Int64(0, 2775)), new Pair.ptr(new $Int64(0, 8527), new $Int64(0, 4976)), new Pair.ptr(new $Int64(0, 8537), new $Int64(0, 3446)), new Pair.ptr(new $Int64(0, 8539), new $Int64(0, 7096)), new Pair.ptr(new $Int64(0, 8543), new $Int64(0, 1072)), new Pair.ptr(new $Int64(0, 8563), new $Int64(0, 5145)), new Pair.ptr(new $Int64(0, 8573), new $Int64(0, 2187)), new Pair.ptr(new $Int64(0, 8581), new $Int64(0, 7968)), new Pair.ptr(new $Int64(0, 8597), new $Int64(0, 7116)), new Pair.ptr(new $Int64(0, 8599), new $Int64(0, 5140)), new Pair.ptr(new $Int64(0, 8609), new $Int64(0, 3838)), new Pair.ptr(new $Int64(0, 8623), new $Int64(0, 7606)), new Pair.ptr(new $Int64(0, 8627), new $Int64(0, 8509)), new Pair.ptr(new $Int64(0, 8629), new $Int64(0, 5673)), new Pair.ptr(new $Int64(0, 8641), new $Int64(0, 7700)), new Pair.ptr(new $Int64(0, 8647), new $Int64(0, 1392)), new Pair.ptr(new $Int64(0, 8663), new $Int64(0, 6747)), new Pair.ptr(new $Int64(0, 8669), new $Int64(0, 327)), new Pair.ptr(new $Int64(0, 8677), new $Int64(0, 4888)), new Pair.ptr(new $Int64(0, 8681), new $Int64(0, 1983)), new Pair.ptr(new $Int64(0, 8689), new $Int64(0, 5005)), new Pair.ptr(new $Int64(0, 8693), new $Int64(0, 8149)), new Pair.ptr(new $Int64(0, 8699), new $Int64(0, 3159)), new Pair.ptr(new $Int64(0, 8707), new $Int64(0, 4520)), new Pair.ptr(new $Int64(0, 8713), new $Int64(0, 2700)), new Pair.ptr(new $Int64(0, 8719), new $Int64(0, 4933)), new Pair.ptr(new $Int64(0, 8731), new $Int64(0, 508)), new Pair.ptr(new $Int64(0, 8737), new $Int64(0, 4289)), new Pair.ptr(new $Int64(0, 8741), new $Int64(0, 6961)), new Pair.ptr(new $Int64(0, 8747), new $Int64(0, 4800)), new Pair.ptr(new $Int64(0, 8753), new $Int64(0, 777)), new Pair.ptr(new $Int64(0, 8761), new $Int64(0, 7098)), new Pair.ptr(new $Int64(0, 8779), new $Int64(0, 709)), new Pair.ptr(new $Int64(0, 8783), new $Int64(0, 4682)), new Pair.ptr(new $Int64(0, 8803), new $Int64(0, 8631)), new Pair.ptr(new $Int64(0, 8807), new $Int64(0, 8383)), new Pair.ptr(new $Int64(0, 8819), new $Int64(0, 5643)), new Pair.ptr(new $Int64(0, 8821), new $Int64(0, 4102)), new Pair.ptr(new $Int64(0, 8831), new $Int64(0, 480)), new Pair.ptr(new $Int64(0, 8837), new $Int64(0, 1594)), new Pair.ptr(new $Int64(0, 8839), new $Int64(0, 7959)), new Pair.ptr(new $Int64(0, 8849), new $Int64(0, 2009)), new Pair.ptr(new $Int64(0, 8861), new $Int64(0, 3498)), new Pair.ptr(new $Int64(0, 8863), new $Int64(0, 1850)), new Pair.ptr(new $Int64(0, 8867), new $Int64(0, 4919)), new Pair.ptr(new $Int64(0, 8887), new $Int64(0, 4245)), new Pair.ptr(new $Int64(0, 8893), new $Int64(0, 6687)), new Pair.ptr(new $Int64(0, 8923), new $Int64(0, 6119)), new Pair.ptr(new $Int64(0, 8929), new $Int64(0, 4724)), new Pair.ptr(new $Int64(0, 8933), new $Int64(0, 1672)), new Pair.ptr(new $Int64(0, 8941), new $Int64(0, 7945)), new Pair.ptr(new $Int64(0, 8951), new $Int64(0, 4734)), new Pair.ptr(new $Int64(0, 8963), new $Int64(0, 2723)), new Pair.ptr(new $Int64(0, 8969), new $Int64(0, 1194)), new Pair.ptr(new $Int64(0, 8971), new $Int64(0, 8068)), new Pair.ptr(new $Int64(0, 8999), new $Int64(0, 4567)), new Pair.ptr(new $Int64(0, 9001), new $Int64(0, 3291)), new Pair.ptr(new $Int64(0, 9007), new $Int64(0, 5742)), new Pair.ptr(new $Int64(0, 9011), new $Int64(0, 3717)), new Pair.ptr(new $Int64(0, 9013), new $Int64(0, 8506)), new Pair.ptr(new $Int64(0, 9029), new $Int64(0, 79)), new Pair.ptr(new $Int64(0, 9041), new $Int64(0, 7367)), new Pair.ptr(new $Int64(0, 9043), new $Int64(0, 5858)), new Pair.ptr(new $Int64(0, 9049), new $Int64(0, 6487)), new Pair.ptr(new $Int64(0, 9059), new $Int64(0, 77)), new Pair.ptr(new $Int64(0, 9067), new $Int64(0, 4725)), new Pair.ptr(new $Int64(0, 9091), new $Int64(0, 8739)), new Pair.ptr(new $Int64(0, 9103), new $Int64(0, 9057)), new Pair.ptr(new $Int64(0, 9109), new $Int64(0, 3113)), new Pair.ptr(new $Int64(0, 9127), new $Int64(0, 6940)), new Pair.ptr(new $Int64(0, 9133), new $Int64(0, 499)), new Pair.ptr(new $Int64(0, 9137), new $Int64(0, 5459)), new Pair.ptr(new $Int64(0, 9151), new $Int64(0, 4532)), new Pair.ptr(new $Int64(0, 9157), new $Int64(0, 6000)), new Pair.ptr(new $Int64(0, 9161), new $Int64(0, 6815)), new Pair.ptr(new $Int64(0, 9173), new $Int64(0, 2001)), new Pair.ptr(new $Int64(0, 9181), new $Int64(0, 7984)), new Pair.ptr(new $Int64(0, 9187), new $Int64(0, 9147)), new Pair.ptr(new $Int64(0, 9199), new $Int64(0, 1933)), new Pair.ptr(new $Int64(0, 9203), new $Int64(0, 4745)), new Pair.ptr(new $Int64(0, 9209), new $Int64(0, 8135)), new Pair.ptr(new $Int64(0, 9221), new $Int64(0, 112)), new Pair.ptr(new $Int64(0, 9227), new $Int64(0, 4750)), new Pair.ptr(new $Int64(0, 9239), new $Int64(0, 7107)), new Pair.ptr(new $Int64(0, 9241), new $Int64(0, 4265)), new Pair.ptr(new $Int64(0, 9257), new $Int64(0, 2220)), new Pair.ptr(new $Int64(0, 9277), new $Int64(0, 2353)), new Pair.ptr(new $Int64(0, 9281), new $Int64(0, 5189)), new Pair.ptr(new $Int64(0, 9283), new $Int64(0, 6709)), new Pair.ptr(new $Int64(0, 9293), new $Int64(0, 2185)), new Pair.ptr(new $Int64(0, 9311), new $Int64(0, 4943)), new Pair.ptr(new $Int64(0, 9319), new $Int64(0, 4537)), new Pair.ptr(new $Int64(0, 9323), new $Int64(0, 6800)), new Pair.ptr(new $Int64(0, 9337), new $Int64(0, 7671)), new Pair.ptr(new $Int64(0, 9341), new $Int64(0, 4546)), new Pair.ptr(new $Int64(0, 9343), new $Int64(0, 5917)), new Pair.ptr(new $Int64(0, 9349), new $Int64(0, 7594)), new Pair.ptr(new $Int64(0, 9371), new $Int64(0, 8331)), new Pair.ptr(new $Int64(0, 9377), new $Int64(0, 1490)), new Pair.ptr(new $Int64(0, 9391), new $Int64(0, 598)), new Pair.ptr(new $Int64(0, 9397), new $Int64(0, 5594)), new Pair.ptr(new $Int64(0, 9403), new $Int64(0, 9332)), new Pair.ptr(new $Int64(0, 9413), new $Int64(0, 7404)), new Pair.ptr(new $Int64(0, 9419), new $Int64(0, 2376)), new Pair.ptr(new $Int64(0, 9421), new $Int64(0, 2094)), new Pair.ptr(new $Int64(0, 9431), new $Int64(0, 5572)), new Pair.ptr(new $Int64(0, 9433), new $Int64(0, 5835)), new Pair.ptr(new $Int64(0, 9437), new $Int64(0, 1146)), new Pair.ptr(new $Int64(0, 9439), new $Int64(0, 4652)), new Pair.ptr(new $Int64(0, 9461), new $Int64(0, 1854)), new Pair.ptr(new $Int64(0, 9463), new $Int64(0, 803)), new Pair.ptr(new $Int64(0, 9467), new $Int64(0, 1989)), new Pair.ptr(new $Int64(0, 9473), new $Int64(0, 5620)), new Pair.ptr(new $Int64(0, 9479), new $Int64(0, 180)), new Pair.ptr(new $Int64(0, 9491), new $Int64(0, 4427)), new Pair.ptr(new $Int64(0, 9497), new $Int64(0, 6879)), new Pair.ptr(new $Int64(0, 9511), new $Int64(0, 6050)), new Pair.ptr(new $Int64(0, 9521), new $Int64(0, 5171)), new Pair.ptr(new $Int64(0, 9533), new $Int64(0, 2270)), new Pair.ptr(new $Int64(0, 9539), new $Int64(0, 6199)), new Pair.ptr(new $Int64(0, 9547), new $Int64(0, 1885)), new Pair.ptr(new $Int64(0, 9551), new $Int64(0, 6702)), new Pair.ptr(new $Int64(0, 9587), new $Int64(0, 5328)), new Pair.ptr(new $Int64(0, 9601), new $Int64(0, 4153)), new Pair.ptr(new $Int64(0, 9613), new $Int64(0, 7238)), new Pair.ptr(new $Int64(0, 9619), new $Int64(0, 3602)), new Pair.ptr(new $Int64(0, 9623), new $Int64(0, 8158)), new Pair.ptr(new $Int64(0, 9629), new $Int64(0, 8001)), new Pair.ptr(new $Int64(0, 9631), new $Int64(0, 36)), new Pair.ptr(new $Int64(0, 9643), new $Int64(0, 3453)), new Pair.ptr(new $Int64(0, 9649), new $Int64(0, 960)), new Pair.ptr(new $Int64(0, 9661), new $Int64(0, 7195)), new Pair.ptr(new $Int64(0, 9677), new $Int64(0, 3911)), new Pair.ptr(new $Int64(0, 9679), new $Int64(0, 8580)), new Pair.ptr(new $Int64(0, 9689), new $Int64(0, 5994)), new Pair.ptr(new $Int64(0, 9697), new $Int64(0, 2290)), new Pair.ptr(new $Int64(0, 9719), new $Int64(0, 9321)), new Pair.ptr(new $Int64(0, 9721), new $Int64(0, 8070)), new Pair.ptr(new $Int64(0, 9733), new $Int64(0, 6638)), new Pair.ptr(new $Int64(0, 9739), new $Int64(0, 5729)), new Pair.ptr(new $Int64(0, 9743), new $Int64(0, 7958)), new Pair.ptr(new $Int64(0, 9749), new $Int64(0, 6932)), new Pair.ptr(new $Int64(0, 9767), new $Int64(0, 8243)), new Pair.ptr(new $Int64(0, 9769), new $Int64(0, 7901)), new Pair.ptr(new $Int64(0, 9781), new $Int64(0, 210)), new Pair.ptr(new $Int64(0, 9787), new $Int64(0, 2871)), new Pair.ptr(new $Int64(0, 9791), new $Int64(0, 7917)), new Pair.ptr(new $Int64(0, 9803), new $Int64(0, 7297)), new Pair.ptr(new $Int64(0, 9811), new $Int64(0, 1894)), new Pair.ptr(new $Int64(0, 9817), new $Int64(0, 5947)), new Pair.ptr(new $Int64(0, 9829), new $Int64(0, 4557)), new Pair.ptr(new $Int64(0, 9833), new $Int64(0, 2199)), new Pair.ptr(new $Int64(0, 9839), new $Int64(0, 3342)), new Pair.ptr(new $Int64(0, 9851), new $Int64(0, 8679)), new Pair.ptr(new $Int64(0, 9857), new $Int64(0, 2679)), new Pair.ptr(new $Int64(0, 9859), new $Int64(0, 9168)), new Pair.ptr(new $Int64(0, 9871), new $Int64(0, 6989)), new Pair.ptr(new $Int64(0, 9883), new $Int64(0, 3223)), new Pair.ptr(new $Int64(0, 9887), new $Int64(0, 7643)), new Pair.ptr(new $Int64(0, 9901), new $Int64(0, 4080)), new Pair.ptr(new $Int64(0, 9907), new $Int64(0, 521)), new Pair.ptr(new $Int64(0, 9923), new $Int64(0, 2975)), new Pair.ptr(new $Int64(0, 9929), new $Int64(0, 6936)), new Pair.ptr(new $Int64(0, 9931), new $Int64(0, 8852)), new Pair.ptr(new $Int64(0, 9941), new $Int64(0, 3974)), new Pair.ptr(new $Int64(0, 9949), new $Int64(0, 965)), new Pair.ptr(new $Int64(0, 9967), new $Int64(0, 9600)), new Pair.ptr(new $Int64(0, 9973), new $Int64(0, 9681)), new Pair.ptr(new $Int64(0, 10007), new $Int64(0, 278)), new Pair.ptr(new $Int64(0, 10009), new $Int64(0, 9175)), new Pair.ptr(new $Int64(0, 10037), new $Int64(0, 5731)), new Pair.ptr(new $Int64(0, 10039), new $Int64(0, 4356)), new Pair.ptr(new $Int64(0, 10061), new $Int64(0, 8565)), new Pair.ptr(new $Int64(0, 10067), new $Int64(0, 6520)), new Pair.ptr(new $Int64(0, 10069), new $Int64(0, 6670)), new Pair.ptr(new $Int64(0, 10079), new $Int64(0, 4370)), new Pair.ptr(new $Int64(0, 10091), new $Int64(0, 1360)), new Pair.ptr(new $Int64(0, 10093), new $Int64(0, 3415)), new Pair.ptr(new $Int64(0, 10099), new $Int64(0, 8917)), new Pair.ptr(new $Int64(0, 10103), new $Int64(0, 2055)), new Pair.ptr(new $Int64(0, 10111), new $Int64(0, 7967)), new Pair.ptr(new $Int64(0, 10133), new $Int64(0, 611)), new Pair.ptr(new $Int64(0, 10139), new $Int64(0, 1251)), new Pair.ptr(new $Int64(0, 10141), new $Int64(0, 3490)), new Pair.ptr(new $Int64(0, 10151), new $Int64(0, 10145)), new Pair.ptr(new $Int64(0, 10159), new $Int64(0, 5017)), new Pair.ptr(new $Int64(0, 10163), new $Int64(0, 5707)), new Pair.ptr(new $Int64(0, 10169), new $Int64(0, 9684)), new Pair.ptr(new $Int64(0, 10177), new $Int64(0, 1102)), new Pair.ptr(new $Int64(0, 10181), new $Int64(0, 5026)), new Pair.ptr(new $Int64(0, 10193), new $Int64(0, 803)), new Pair.ptr(new $Int64(0, 10211), new $Int64(0, 1723)), new Pair.ptr(new $Int64(0, 10223), new $Int64(0, 10219)), new Pair.ptr(new $Int64(0, 10243), new $Int64(0, 7587)), new Pair.ptr(new $Int64(0, 10247), new $Int64(0, 8341)), new Pair.ptr(new $Int64(0, 10253), new $Int64(0, 10144)), new Pair.ptr(new $Int64(0, 10259), new $Int64(0, 1727)), new Pair.ptr(new $Int64(0, 10267), new $Int64(0, 263)), new Pair.ptr(new $Int64(0, 10271), new $Int64(0, 1256)), new Pair.ptr(new $Int64(0, 10273), new $Int64(0, 3050)), new Pair.ptr(new $Int64(0, 10289), new $Int64(0, 126)), new Pair.ptr(new $Int64(0, 10301), new $Int64(0, 9006)), new Pair.ptr(new $Int64(0, 10303), new $Int64(0, 6350)), new Pair.ptr(new $Int64(0, 10313), new $Int64(0, 10157)), new Pair.ptr(new $Int64(0, 10321), new $Int64(0, 8764)), new Pair.ptr(new $Int64(0, 10331), new $Int64(0, 2218)), new Pair.ptr(new $Int64(0, 10333), new $Int64(0, 9184)), new Pair.ptr(new $Int64(0, 10337), new $Int64(0, 6620)), new Pair.ptr(new $Int64(0, 10343), new $Int64(0, 4439)), new Pair.ptr(new $Int64(0, 10357), new $Int64(0, 9673)), new Pair.ptr(new $Int64(0, 10369), new $Int64(0, 8003)), new Pair.ptr(new $Int64(0, 10391), new $Int64(0, 25)), new Pair.ptr(new $Int64(0, 10399), new $Int64(0, 10174)), new Pair.ptr(new $Int64(0, 10427), new $Int64(0, 5649)), new Pair.ptr(new $Int64(0, 10429), new $Int64(0, 699)), new Pair.ptr(new $Int64(0, 10433), new $Int64(0, 2896)), new Pair.ptr(new $Int64(0, 10453), new $Int64(0, 6774)), new Pair.ptr(new $Int64(0, 10457), new $Int64(0, 5788)), new Pair.ptr(new $Int64(0, 10459), new $Int64(0, 10426)), new Pair.ptr(new $Int64(0, 10463), new $Int64(0, 1407)), new Pair.ptr(new $Int64(0, 10477), new $Int64(0, 10434)), new Pair.ptr(new $Int64(0, 10487), new $Int64(0, 6242)), new Pair.ptr(new $Int64(0, 10499), new $Int64(0, 3047)), new Pair.ptr(new $Int64(0, 10501), new $Int64(0, 1285)), new Pair.ptr(new $Int64(0, 10513), new $Int64(0, 2050)), new Pair.ptr(new $Int64(0, 10529), new $Int64(0, 3863)), new Pair.ptr(new $Int64(0, 10531), new $Int64(0, 1265)), new Pair.ptr(new $Int64(0, 10559), new $Int64(0, 6730)), new Pair.ptr(new $Int64(0, 10567), new $Int64(0, 4678)), new Pair.ptr(new $Int64(0, 10589), new $Int64(0, 2568)), new Pair.ptr(new $Int64(0, 10597), new $Int64(0, 2222)), new Pair.ptr(new $Int64(0, 10601), new $Int64(0, 6160)), new Pair.ptr(new $Int64(0, 10607), new $Int64(0, 496)), new Pair.ptr(new $Int64(0, 10613), new $Int64(0, 3545)), new Pair.ptr(new $Int64(0, 10627), new $Int64(0, 6090)), new Pair.ptr(new $Int64(0, 10631), new $Int64(0, 6812)), new Pair.ptr(new $Int64(0, 10639), new $Int64(0, 4712)), new Pair.ptr(new $Int64(0, 10651), new $Int64(0, 9132)), new Pair.ptr(new $Int64(0, 10657), new $Int64(0, 792)), new Pair.ptr(new $Int64(0, 10663), new $Int64(0, 777)), new Pair.ptr(new $Int64(0, 10667), new $Int64(0, 3051)), new Pair.ptr(new $Int64(0, 10687), new $Int64(0, 909)), new Pair.ptr(new $Int64(0, 10691), new $Int64(0, 5980)), new Pair.ptr(new $Int64(0, 10709), new $Int64(0, 3239)), new Pair.ptr(new $Int64(0, 10711), new $Int64(0, 5861)), new Pair.ptr(new $Int64(0, 10723), new $Int64(0, 8521)), new Pair.ptr(new $Int64(0, 10729), new $Int64(0, 1389)), new Pair.ptr(new $Int64(0, 10733), new $Int64(0, 9032)), new Pair.ptr(new $Int64(0, 10739), new $Int64(0, 2945)), new Pair.ptr(new $Int64(0, 10753), new $Int64(0, 7715)), new Pair.ptr(new $Int64(0, 10771), new $Int64(0, 3575)), new Pair.ptr(new $Int64(0, 10781), new $Int64(0, 691)), new Pair.ptr(new $Int64(0, 10789), new $Int64(0, 292)), new Pair.ptr(new $Int64(0, 10799), new $Int64(0, 8868)), new Pair.ptr(new $Int64(0, 10831), new $Int64(0, 3319)), new Pair.ptr(new $Int64(0, 10837), new $Int64(0, 5282)), new Pair.ptr(new $Int64(0, 10847), new $Int64(0, 6673)), new Pair.ptr(new $Int64(0, 10853), new $Int64(0, 1988)), new Pair.ptr(new $Int64(0, 10859), new $Int64(0, 971)), new Pair.ptr(new $Int64(0, 10861), new $Int64(0, 4736)), new Pair.ptr(new $Int64(0, 10867), new $Int64(0, 7400)), new Pair.ptr(new $Int64(0, 10883), new $Int64(0, 2567)), new Pair.ptr(new $Int64(0, 10889), new $Int64(0, 2842)), new Pair.ptr(new $Int64(0, 10891), new $Int64(0, 8228)), new Pair.ptr(new $Int64(0, 10903), new $Int64(0, 4781)), new Pair.ptr(new $Int64(0, 10909), new $Int64(0, 6311)), new Pair.ptr(new $Int64(0, 10937), new $Int64(0, 2164)), new Pair.ptr(new $Int64(0, 10939), new $Int64(0, 2774)), new Pair.ptr(new $Int64(0, 10949), new $Int64(0, 7654)), new Pair.ptr(new $Int64(0, 10957), new $Int64(0, 2396)), new Pair.ptr(new $Int64(0, 10973), new $Int64(0, 7491)), new Pair.ptr(new $Int64(0, 10979), new $Int64(0, 203)), new Pair.ptr(new $Int64(0, 10987), new $Int64(0, 5978)), new Pair.ptr(new $Int64(0, 10993), new $Int64(0, 9227)), new Pair.ptr(new $Int64(0, 11003), new $Int64(0, 1639)), new Pair.ptr(new $Int64(0, 11027), new $Int64(0, 3176)), new Pair.ptr(new $Int64(0, 11047), new $Int64(0, 3511)), new Pair.ptr(new $Int64(0, 11057), new $Int64(0, 5855)), new Pair.ptr(new $Int64(0, 11059), new $Int64(0, 4318)), new Pair.ptr(new $Int64(0, 11069), new $Int64(0, 3370)), new Pair.ptr(new $Int64(0, 11071), new $Int64(0, 7905)), new Pair.ptr(new $Int64(0, 11083), new $Int64(0, 4024)), new Pair.ptr(new $Int64(0, 11087), new $Int64(0, 7164)), new Pair.ptr(new $Int64(0, 11093), new $Int64(0, 8260)), new Pair.ptr(new $Int64(0, 11113), new $Int64(0, 424)), new Pair.ptr(new $Int64(0, 11117), new $Int64(0, 10368)), new Pair.ptr(new $Int64(0, 11119), new $Int64(0, 1981)), new Pair.ptr(new $Int64(0, 11131), new $Int64(0, 681)), new Pair.ptr(new $Int64(0, 11149), new $Int64(0, 8967)), new Pair.ptr(new $Int64(0, 11159), new $Int64(0, 4894)), new Pair.ptr(new $Int64(0, 11161), new $Int64(0, 4248)), new Pair.ptr(new $Int64(0, 11171), new $Int64(0, 6773)), new Pair.ptr(new $Int64(0, 11173), new $Int64(0, 8993)), new Pair.ptr(new $Int64(0, 11177), new $Int64(0, 4266)), new Pair.ptr(new $Int64(0, 11197), new $Int64(0, 7717)), new Pair.ptr(new $Int64(0, 11213), new $Int64(0, 9884)), new Pair.ptr(new $Int64(0, 11239), new $Int64(0, 5730)), new Pair.ptr(new $Int64(0, 11243), new $Int64(0, 2753)), new Pair.ptr(new $Int64(0, 11251), new $Int64(0, 5454)), new Pair.ptr(new $Int64(0, 11257), new $Int64(0, 8360)), new Pair.ptr(new $Int64(0, 11261), new $Int64(0, 1408)), new Pair.ptr(new $Int64(0, 11273), new $Int64(0, 3208)), new Pair.ptr(new $Int64(0, 11279), new $Int64(0, 417)), new Pair.ptr(new $Int64(0, 11287), new $Int64(0, 9383)), new Pair.ptr(new $Int64(0, 11299), new $Int64(0, 9288)), new Pair.ptr(new $Int64(0, 11311), new $Int64(0, 3048)), new Pair.ptr(new $Int64(0, 11317), new $Int64(0, 6997)), new Pair.ptr(new $Int64(0, 11321), new $Int64(0, 5323)), new Pair.ptr(new $Int64(0, 11329), new $Int64(0, 10634)), new Pair.ptr(new $Int64(0, 11351), new $Int64(0, 9031)), new Pair.ptr(new $Int64(0, 11353), new $Int64(0, 9756)), new Pair.ptr(new $Int64(0, 11369), new $Int64(0, 11247)), new Pair.ptr(new $Int64(0, 11383), new $Int64(0, 1978)), new Pair.ptr(new $Int64(0, 11393), new $Int64(0, 9650)), new Pair.ptr(new $Int64(0, 11399), new $Int64(0, 4316)), new Pair.ptr(new $Int64(0, 11411), new $Int64(0, 4422)), new Pair.ptr(new $Int64(0, 11423), new $Int64(0, 64)), new Pair.ptr(new $Int64(0, 11437), new $Int64(0, 6717)), new Pair.ptr(new $Int64(0, 11443), new $Int64(0, 7447)), new Pair.ptr(new $Int64(0, 11447), new $Int64(0, 6619)), new Pair.ptr(new $Int64(0, 11467), new $Int64(0, 6411)), new Pair.ptr(new $Int64(0, 11471), new $Int64(0, 10960)), new Pair.ptr(new $Int64(0, 11483), new $Int64(0, 4934)), new Pair.ptr(new $Int64(0, 11489), new $Int64(0, 8921)), new Pair.ptr(new $Int64(0, 11491), new $Int64(0, 8004)), new Pair.ptr(new $Int64(0, 11497), new $Int64(0, 2382)), new Pair.ptr(new $Int64(0, 11503), new $Int64(0, 5182)), new Pair.ptr(new $Int64(0, 11519), new $Int64(0, 9068)), new Pair.ptr(new $Int64(0, 11527), new $Int64(0, 4366)), new Pair.ptr(new $Int64(0, 11549), new $Int64(0, 11327)), new Pair.ptr(new $Int64(0, 11551), new $Int64(0, 5109)), new Pair.ptr(new $Int64(0, 11579), new $Int64(0, 1313)), new Pair.ptr(new $Int64(0, 11587), new $Int64(0, 5390)), new Pair.ptr(new $Int64(0, 11593), new $Int64(0, 6372)), new Pair.ptr(new $Int64(0, 11597), new $Int64(0, 10387)), new Pair.ptr(new $Int64(0, 11617), new $Int64(0, 5285)), new Pair.ptr(new $Int64(0, 11621), new $Int64(0, 4158)), new Pair.ptr(new $Int64(0, 11633), new $Int64(0, 9156)), new Pair.ptr(new $Int64(0, 11657), new $Int64(0, 1829)), new Pair.ptr(new $Int64(0, 11677), new $Int64(0, 9366)), new Pair.ptr(new $Int64(0, 11681), new $Int64(0, 10160)), new Pair.ptr(new $Int64(0, 11689), new $Int64(0, 8508)), new Pair.ptr(new $Int64(0, 11699), new $Int64(0, 228)), new Pair.ptr(new $Int64(0, 11701), new $Int64(0, 11321)), new Pair.ptr(new $Int64(0, 11717), new $Int64(0, 8329)), new Pair.ptr(new $Int64(0, 11719), new $Int64(0, 4)), new Pair.ptr(new $Int64(0, 11731), new $Int64(0, 5089)), new Pair.ptr(new $Int64(0, 11743), new $Int64(0, 9748)), new Pair.ptr(new $Int64(0, 11777), new $Int64(0, 436)), new Pair.ptr(new $Int64(0, 11779), new $Int64(0, 10318)), new Pair.ptr(new $Int64(0, 11783), new $Int64(0, 9483)), new Pair.ptr(new $Int64(0, 11789), new $Int64(0, 904)), new Pair.ptr(new $Int64(0, 11801), new $Int64(0, 3462)), new Pair.ptr(new $Int64(0, 11807), new $Int64(0, 3784)), new Pair.ptr(new $Int64(0, 11813), new $Int64(0, 11534)), new Pair.ptr(new $Int64(0, 11821), new $Int64(0, 10020)), new Pair.ptr(new $Int64(0, 11827), new $Int64(0, 9826)), new Pair.ptr(new $Int64(0, 11831), new $Int64(0, 5288)), new Pair.ptr(new $Int64(0, 11833), new $Int64(0, 747)), new Pair.ptr(new $Int64(0, 11839), new $Int64(0, 8082)), new Pair.ptr(new $Int64(0, 11863), new $Int64(0, 1457)), new Pair.ptr(new $Int64(0, 11867), new $Int64(0, 8978)), new Pair.ptr(new $Int64(0, 11887), new $Int64(0, 6438)), new Pair.ptr(new $Int64(0, 11897), new $Int64(0, 6383)), new Pair.ptr(new $Int64(0, 11903), new $Int64(0, 2326)), new Pair.ptr(new $Int64(0, 11909), new $Int64(0, 9955)), new Pair.ptr(new $Int64(0, 11923), new $Int64(0, 8748)), new Pair.ptr(new $Int64(0, 11927), new $Int64(0, 11043)), new Pair.ptr(new $Int64(0, 11933), new $Int64(0, 8051)), new Pair.ptr(new $Int64(0, 11939), new $Int64(0, 507)), new Pair.ptr(new $Int64(0, 11941), new $Int64(0, 11756)), new Pair.ptr(new $Int64(0, 11953), new $Int64(0, 11406)), new Pair.ptr(new $Int64(0, 11959), new $Int64(0, 11079)), new Pair.ptr(new $Int64(0, 11969), new $Int64(0, 8935)), new Pair.ptr(new $Int64(0, 11971), new $Int64(0, 9606)), new Pair.ptr(new $Int64(0, 11981), new $Int64(0, 8464)), new Pair.ptr(new $Int64(0, 11987), new $Int64(0, 3692)), new Pair.ptr(new $Int64(0, 12007), new $Int64(0, 1681)), new Pair.ptr(new $Int64(0, 12011), new $Int64(0, 10810)), new Pair.ptr(new $Int64(0, 12037), new $Int64(0, 10737)), new Pair.ptr(new $Int64(0, 12041), new $Int64(0, 5024)), new Pair.ptr(new $Int64(0, 12043), new $Int64(0, 10761)), new Pair.ptr(new $Int64(0, 12049), new $Int64(0, 7783)), new Pair.ptr(new $Int64(0, 12071), new $Int64(0, 7795)), new Pair.ptr(new $Int64(0, 12073), new $Int64(0, 6274)), new Pair.ptr(new $Int64(0, 12097), new $Int64(0, 3316)), new Pair.ptr(new $Int64(0, 12101), new $Int64(0, 10483)), new Pair.ptr(new $Int64(0, 12107), new $Int64(0, 548)), new Pair.ptr(new $Int64(0, 12109), new $Int64(0, 10973)), new Pair.ptr(new $Int64(0, 12113), new $Int64(0, 6920)), new Pair.ptr(new $Int64(0, 12119), new $Int64(0, 3160)), new Pair.ptr(new $Int64(0, 12143), new $Int64(0, 1548)), new Pair.ptr(new $Int64(0, 12149), new $Int64(0, 3893)), new Pair.ptr(new $Int64(0, 12157), new $Int64(0, 5391)), new Pair.ptr(new $Int64(0, 12161), new $Int64(0, 5803)), new Pair.ptr(new $Int64(0, 12163), new $Int64(0, 8353)), new Pair.ptr(new $Int64(0, 12197), new $Int64(0, 4503)), new Pair.ptr(new $Int64(0, 12203), new $Int64(0, 9181)), new Pair.ptr(new $Int64(0, 12211), new $Int64(0, 7615)), new Pair.ptr(new $Int64(0, 12227), new $Int64(0, 7467)), new Pair.ptr(new $Int64(0, 12239), new $Int64(0, 3607)), new Pair.ptr(new $Int64(0, 12241), new $Int64(0, 9734)), new Pair.ptr(new $Int64(0, 12251), new $Int64(0, 7489)), new Pair.ptr(new $Int64(0, 12253), new $Int64(0, 9899)), new Pair.ptr(new $Int64(0, 12263), new $Int64(0, 4871)), new Pair.ptr(new $Int64(0, 12269), new $Int64(0, 9925)), new Pair.ptr(new $Int64(0, 12277), new $Int64(0, 2145)), new Pair.ptr(new $Int64(0, 12281), new $Int64(0, 9455)), new Pair.ptr(new $Int64(0, 12289), new $Int64(0, 11486)), new Pair.ptr(new $Int64(0, 12301), new $Int64(0, 12135)), new Pair.ptr(new $Int64(0, 12323), new $Int64(0, 7794)), new Pair.ptr(new $Int64(0, 12329), new $Int64(0, 1124)), new Pair.ptr(new $Int64(0, 12343), new $Int64(0, 9013)), new Pair.ptr(new $Int64(0, 12347), new $Int64(0, 4913)), new Pair.ptr(new $Int64(0, 12373), new $Int64(0, 6399)), new Pair.ptr(new $Int64(0, 12377), new $Int64(0, 6826)), new Pair.ptr(new $Int64(0, 12379), new $Int64(0, 3201)), new Pair.ptr(new $Int64(0, 12391), new $Int64(0, 10073)), new Pair.ptr(new $Int64(0, 12401), new $Int64(0, 11926)), new Pair.ptr(new $Int64(0, 12409), new $Int64(0, 10718)), new Pair.ptr(new $Int64(0, 12413), new $Int64(0, 3241)), new Pair.ptr(new $Int64(0, 12421), new $Int64(0, 4771)), new Pair.ptr(new $Int64(0, 12433), new $Int64(0, 1704)), new Pair.ptr(new $Int64(0, 12437), new $Int64(0, 9139)), new Pair.ptr(new $Int64(0, 12451), new $Int64(0, 2130)), new Pair.ptr(new $Int64(0, 12457), new $Int64(0, 1660)), new Pair.ptr(new $Int64(0, 12473), new $Int64(0, 1967)), new Pair.ptr(new $Int64(0, 12479), new $Int64(0, 9724)), new Pair.ptr(new $Int64(0, 12487), new $Int64(0, 1112)), new Pair.ptr(new $Int64(0, 12491), new $Int64(0, 6887)), new Pair.ptr(new $Int64(0, 12497), new $Int64(0, 10263)), new Pair.ptr(new $Int64(0, 12503), new $Int64(0, 11324)), new Pair.ptr(new $Int64(0, 12511), new $Int64(0, 2259)), new Pair.ptr(new $Int64(0, 12517), new $Int64(0, 7939)), new Pair.ptr(new $Int64(0, 12527), new $Int64(0, 12437)), new Pair.ptr(new $Int64(0, 12539), new $Int64(0, 69)), new Pair.ptr(new $Int64(0, 12541), new $Int64(0, 2136)), new Pair.ptr(new $Int64(0, 12547), new $Int64(0, 6175)), new Pair.ptr(new $Int64(0, 12553), new $Int64(0, 8091)), new Pair.ptr(new $Int64(0, 12569), new $Int64(0, 2841)), new Pair.ptr(new $Int64(0, 12577), new $Int64(0, 7820)), new Pair.ptr(new $Int64(0, 12583), new $Int64(0, 1558)), new Pair.ptr(new $Int64(0, 12589), new $Int64(0, 12565)), new Pair.ptr(new $Int64(0, 12601), new $Int64(0, 7490)), new Pair.ptr(new $Int64(0, 12611), new $Int64(0, 9813)), new Pair.ptr(new $Int64(0, 12613), new $Int64(0, 2680)), new Pair.ptr(new $Int64(0, 12619), new $Int64(0, 7877)), new Pair.ptr(new $Int64(0, 12637), new $Int64(0, 2675)), new Pair.ptr(new $Int64(0, 12641), new $Int64(0, 5388)), new Pair.ptr(new $Int64(0, 12647), new $Int64(0, 8829)), new Pair.ptr(new $Int64(0, 12653), new $Int64(0, 8107)), new Pair.ptr(new $Int64(0, 12659), new $Int64(0, 10857)), new Pair.ptr(new $Int64(0, 12671), new $Int64(0, 9385)), new Pair.ptr(new $Int64(0, 12689), new $Int64(0, 11019)), new Pair.ptr(new $Int64(0, 12697), new $Int64(0, 3861)), new Pair.ptr(new $Int64(0, 12703), new $Int64(0, 1649)), new Pair.ptr(new $Int64(0, 12713), new $Int64(0, 4202)), new Pair.ptr(new $Int64(0, 12721), new $Int64(0, 5833)), new Pair.ptr(new $Int64(0, 12739), new $Int64(0, 11388)), new Pair.ptr(new $Int64(0, 12743), new $Int64(0, 11134)), new Pair.ptr(new $Int64(0, 12757), new $Int64(0, 5810)), new Pair.ptr(new $Int64(0, 12763), new $Int64(0, 6062)), new Pair.ptr(new $Int64(0, 12781), new $Int64(0, 4539)), new Pair.ptr(new $Int64(0, 12791), new $Int64(0, 133)), new Pair.ptr(new $Int64(0, 12799), new $Int64(0, 7024)), new Pair.ptr(new $Int64(0, 12809), new $Int64(0, 6427)), new Pair.ptr(new $Int64(0, 12821), new $Int64(0, 271)), new Pair.ptr(new $Int64(0, 12823), new $Int64(0, 5213)), new Pair.ptr(new $Int64(0, 12829), new $Int64(0, 2872)), new Pair.ptr(new $Int64(0, 12841), new $Int64(0, 12161)), new Pair.ptr(new $Int64(0, 12853), new $Int64(0, 12772)), new Pair.ptr(new $Int64(0, 12889), new $Int64(0, 7244)), new Pair.ptr(new $Int64(0, 12893), new $Int64(0, 6947)), new Pair.ptr(new $Int64(0, 12899), new $Int64(0, 10818)), new Pair.ptr(new $Int64(0, 12907), new $Int64(0, 3451)), new Pair.ptr(new $Int64(0, 12911), new $Int64(0, 7254)), new Pair.ptr(new $Int64(0, 12917), new $Int64(0, 12279)), new Pair.ptr(new $Int64(0, 12919), new $Int64(0, 8032)), new Pair.ptr(new $Int64(0, 12923), new $Int64(0, 3074)), new Pair.ptr(new $Int64(0, 12941), new $Int64(0, 3066)), new Pair.ptr(new $Int64(0, 12953), new $Int64(0, 11476)), new Pair.ptr(new $Int64(0, 12959), new $Int64(0, 26)), new Pair.ptr(new $Int64(0, 12967), new $Int64(0, 8694)), new Pair.ptr(new $Int64(0, 12973), new $Int64(0, 11673)), new Pair.ptr(new $Int64(0, 12979), new $Int64(0, 12575)), new Pair.ptr(new $Int64(0, 12983), new $Int64(0, 4288)), new Pair.ptr(new $Int64(0, 13001), new $Int64(0, 6022)), new Pair.ptr(new $Int64(0, 13003), new $Int64(0, 3565)), new Pair.ptr(new $Int64(0, 13007), new $Int64(0, 1102)), new Pair.ptr(new $Int64(0, 13009), new $Int64(0, 8754)), new Pair.ptr(new $Int64(0, 13033), new $Int64(0, 10106)), new Pair.ptr(new $Int64(0, 13037), new $Int64(0, 8551)), new Pair.ptr(new $Int64(0, 13043), new $Int64(0, 692)), new Pair.ptr(new $Int64(0, 13049), new $Int64(0, 1320)), new Pair.ptr(new $Int64(0, 13063), new $Int64(0, 10126)), new Pair.ptr(new $Int64(0, 13093), new $Int64(0, 1147)), new Pair.ptr(new $Int64(0, 13099), new $Int64(0, 12194)), new Pair.ptr(new $Int64(0, 13103), new $Int64(0, 1906)), new Pair.ptr(new $Int64(0, 13109), new $Int64(0, 429)), new Pair.ptr(new $Int64(0, 13121), new $Int64(0, 2119)), new Pair.ptr(new $Int64(0, 13127), new $Int64(0, 1899)), new Pair.ptr(new $Int64(0, 13147), new $Int64(0, 9189)), new Pair.ptr(new $Int64(0, 13151), new $Int64(0, 10358)), new Pair.ptr(new $Int64(0, 13159), new $Int64(0, 5368)), new Pair.ptr(new $Int64(0, 13163), new $Int64(0, 2158)), new Pair.ptr(new $Int64(0, 13171), new $Int64(0, 5490)), new Pair.ptr(new $Int64(0, 13177), new $Int64(0, 7706)), new Pair.ptr(new $Int64(0, 13183), new $Int64(0, 9442)), new Pair.ptr(new $Int64(0, 13187), new $Int64(0, 9397)), new Pair.ptr(new $Int64(0, 13217), new $Int64(0, 6365)), new Pair.ptr(new $Int64(0, 13219), new $Int64(0, 8410)), new Pair.ptr(new $Int64(0, 13229), new $Int64(0, 2336)), new Pair.ptr(new $Int64(0, 13241), new $Int64(0, 6530)), new Pair.ptr(new $Int64(0, 13249), new $Int64(0, 3105)), new Pair.ptr(new $Int64(0, 13259), new $Int64(0, 6974)), new Pair.ptr(new $Int64(0, 13267), new $Int64(0, 2646)), new Pair.ptr(new $Int64(0, 13291), new $Int64(0, 10081)), new Pair.ptr(new $Int64(0, 13297), new $Int64(0, 8002)), new Pair.ptr(new $Int64(0, 13309), new $Int64(0, 4083)), new Pair.ptr(new $Int64(0, 13313), new $Int64(0, 703)), new Pair.ptr(new $Int64(0, 13327), new $Int64(0, 1280)), new Pair.ptr(new $Int64(0, 13331), new $Int64(0, 12291)), new Pair.ptr(new $Int64(0, 13337), new $Int64(0, 1533)), new Pair.ptr(new $Int64(0, 13339), new $Int64(0, 9086)), new Pair.ptr(new $Int64(0, 13367), new $Int64(0, 1680)), new Pair.ptr(new $Int64(0, 13381), new $Int64(0, 12385)), new Pair.ptr(new $Int64(0, 13397), new $Int64(0, 8399)), new Pair.ptr(new $Int64(0, 13399), new $Int64(0, 9843)), new Pair.ptr(new $Int64(0, 13411), new $Int64(0, 3567)), new Pair.ptr(new $Int64(0, 13417), new $Int64(0, 2056)), new Pair.ptr(new $Int64(0, 13421), new $Int64(0, 7202)), new Pair.ptr(new $Int64(0, 13441), new $Int64(0, 11937)), new Pair.ptr(new $Int64(0, 13451), new $Int64(0, 9526)), new Pair.ptr(new $Int64(0, 13457), new $Int64(0, 10191)), new Pair.ptr(new $Int64(0, 13463), new $Int64(0, 2456)), new Pair.ptr(new $Int64(0, 13469), new $Int64(0, 4612)), new Pair.ptr(new $Int64(0, 13477), new $Int64(0, 12937)), new Pair.ptr(new $Int64(0, 13487), new $Int64(0, 13188)), new Pair.ptr(new $Int64(0, 13499), new $Int64(0, 13371)), new Pair.ptr(new $Int64(0, 13513), new $Int64(0, 2365)), new Pair.ptr(new $Int64(0, 13523), new $Int64(0, 6459)), new Pair.ptr(new $Int64(0, 13537), new $Int64(0, 8187)), new Pair.ptr(new $Int64(0, 13553), new $Int64(0, 3058)), new Pair.ptr(new $Int64(0, 13567), new $Int64(0, 8771)), new Pair.ptr(new $Int64(0, 13577), new $Int64(0, 12981)), new Pair.ptr(new $Int64(0, 13591), new $Int64(0, 4382)), new Pair.ptr(new $Int64(0, 13597), new $Int64(0, 8950)), new Pair.ptr(new $Int64(0, 13613), new $Int64(0, 1664)), new Pair.ptr(new $Int64(0, 13619), new $Int64(0, 3245)), new Pair.ptr(new $Int64(0, 13627), new $Int64(0, 2922)), new Pair.ptr(new $Int64(0, 13633), new $Int64(0, 8147)), new Pair.ptr(new $Int64(0, 13649), new $Int64(0, 5894)), new Pair.ptr(new $Int64(0, 13669), new $Int64(0, 1913)), new Pair.ptr(new $Int64(0, 13679), new $Int64(0, 8008)), new Pair.ptr(new $Int64(0, 13681), new $Int64(0, 2337)), new Pair.ptr(new $Int64(0, 13687), new $Int64(0, 7659)), new Pair.ptr(new $Int64(0, 13691), new $Int64(0, 9737)), new Pair.ptr(new $Int64(0, 13693), new $Int64(0, 5276)), new Pair.ptr(new $Int64(0, 13697), new $Int64(0, 12220)), new Pair.ptr(new $Int64(0, 13709), new $Int64(0, 4927)), new Pair.ptr(new $Int64(0, 13711), new $Int64(0, 8434)), new Pair.ptr(new $Int64(0, 13721), new $Int64(0, 13497)), new Pair.ptr(new $Int64(0, 13723), new $Int64(0, 9959)), new Pair.ptr(new $Int64(0, 13729), new $Int64(0, 6276)), new Pair.ptr(new $Int64(0, 13751), new $Int64(0, 4168)), new Pair.ptr(new $Int64(0, 13757), new $Int64(0, 2399)), new Pair.ptr(new $Int64(0, 13759), new $Int64(0, 12884)), new Pair.ptr(new $Int64(0, 13763), new $Int64(0, 13572)), new Pair.ptr(new $Int64(0, 13781), new $Int64(0, 11842)), new Pair.ptr(new $Int64(0, 13789), new $Int64(0, 3817)), new Pair.ptr(new $Int64(0, 13799), new $Int64(0, 5142)), new Pair.ptr(new $Int64(0, 13807), new $Int64(0, 1533)), new Pair.ptr(new $Int64(0, 13829), new $Int64(0, 8493)), new Pair.ptr(new $Int64(0, 13831), new $Int64(0, 7209)), new Pair.ptr(new $Int64(0, 13841), new $Int64(0, 9218)), new Pair.ptr(new $Int64(0, 13859), new $Int64(0, 12260)), new Pair.ptr(new $Int64(0, 13873), new $Int64(0, 8332)), new Pair.ptr(new $Int64(0, 13877), new $Int64(0, 9199)), new Pair.ptr(new $Int64(0, 13879), new $Int64(0, 12109)), new Pair.ptr(new $Int64(0, 13883), new $Int64(0, 3552)), new Pair.ptr(new $Int64(0, 13901), new $Int64(0, 9376)), new Pair.ptr(new $Int64(0, 13903), new $Int64(0, 2027)), new Pair.ptr(new $Int64(0, 13907), new $Int64(0, 10049)), new Pair.ptr(new $Int64(0, 13913), new $Int64(0, 11298)), new Pair.ptr(new $Int64(0, 13921), new $Int64(0, 5521)), new Pair.ptr(new $Int64(0, 13931), new $Int64(0, 3645)), new Pair.ptr(new $Int64(0, 13933), new $Int64(0, 6482)), new Pair.ptr(new $Int64(0, 13963), new $Int64(0, 10454)), new Pair.ptr(new $Int64(0, 13967), new $Int64(0, 5146)), new Pair.ptr(new $Int64(0, 13997), new $Int64(0, 11376)), new Pair.ptr(new $Int64(0, 13999), new $Int64(0, 10997)), new Pair.ptr(new $Int64(0, 14009), new $Int64(0, 12935)), new Pair.ptr(new $Int64(0, 14011), new $Int64(0, 11131)), new Pair.ptr(new $Int64(0, 14029), new $Int64(0, 13764)), new Pair.ptr(new $Int64(0, 14033), new $Int64(0, 2942)), new Pair.ptr(new $Int64(0, 14051), new $Int64(0, 8842)), new Pair.ptr(new $Int64(0, 14057), new $Int64(0, 3329)), new Pair.ptr(new $Int64(0, 14071), new $Int64(0, 5830)), new Pair.ptr(new $Int64(0, 14081), new $Int64(0, 10883)), new Pair.ptr(new $Int64(0, 14083), new $Int64(0, 2820)), new Pair.ptr(new $Int64(0, 14087), new $Int64(0, 13254)), new Pair.ptr(new $Int64(0, 14107), new $Int64(0, 8042)), new Pair.ptr(new $Int64(0, 14143), new $Int64(0, 12588)), new Pair.ptr(new $Int64(0, 14149), new $Int64(0, 12652)), new Pair.ptr(new $Int64(0, 14153), new $Int64(0, 12624)), new Pair.ptr(new $Int64(0, 14159), new $Int64(0, 3211)), new Pair.ptr(new $Int64(0, 14173), new $Int64(0, 10190)), new Pair.ptr(new $Int64(0, 14177), new $Int64(0, 10453)), new Pair.ptr(new $Int64(0, 14197), new $Int64(0, 6324)), new Pair.ptr(new $Int64(0, 14207), new $Int64(0, 8442)), new Pair.ptr(new $Int64(0, 14221), new $Int64(0, 12168)), new Pair.ptr(new $Int64(0, 14243), new $Int64(0, 8240)), new Pair.ptr(new $Int64(0, 14249), new $Int64(0, 13484)), new Pair.ptr(new $Int64(0, 14251), new $Int64(0, 8275)), new Pair.ptr(new $Int64(0, 14281), new $Int64(0, 11185)), new Pair.ptr(new $Int64(0, 14293), new $Int64(0, 11133)), new Pair.ptr(new $Int64(0, 14303), new $Int64(0, 11011)), new Pair.ptr(new $Int64(0, 14321), new $Int64(0, 11512)), new Pair.ptr(new $Int64(0, 14323), new $Int64(0, 7547)), new Pair.ptr(new $Int64(0, 14327), new $Int64(0, 13809)), new Pair.ptr(new $Int64(0, 14341), new $Int64(0, 5838)), new Pair.ptr(new $Int64(0, 14347), new $Int64(0, 11418)), new Pair.ptr(new $Int64(0, 14369), new $Int64(0, 11875)), new Pair.ptr(new $Int64(0, 14387), new $Int64(0, 7162)), new Pair.ptr(new $Int64(0, 14389), new $Int64(0, 12191)), new Pair.ptr(new $Int64(0, 14401), new $Int64(0, 10833)), new Pair.ptr(new $Int64(0, 14407), new $Int64(0, 12538)), new Pair.ptr(new $Int64(0, 14411), new $Int64(0, 12207)), new Pair.ptr(new $Int64(0, 14419), new $Int64(0, 12789)), new Pair.ptr(new $Int64(0, 14423), new $Int64(0, 2415)), new Pair.ptr(new $Int64(0, 14431), new $Int64(0, 4451)), new Pair.ptr(new $Int64(0, 14437), new $Int64(0, 9301)), new Pair.ptr(new $Int64(0, 14447), new $Int64(0, 12568)), new Pair.ptr(new $Int64(0, 14449), new $Int64(0, 12812)), new Pair.ptr(new $Int64(0, 14461), new $Int64(0, 4630)), new Pair.ptr(new $Int64(0, 14479), new $Int64(0, 9566)), new Pair.ptr(new $Int64(0, 14489), new $Int64(0, 12640)), new Pair.ptr(new $Int64(0, 14503), new $Int64(0, 825)), new Pair.ptr(new $Int64(0, 14519), new $Int64(0, 6063)), new Pair.ptr(new $Int64(0, 14533), new $Int64(0, 1941)), new Pair.ptr(new $Int64(0, 14537), new $Int64(0, 3007)), new Pair.ptr(new $Int64(0, 14543), new $Int64(0, 13869)), new Pair.ptr(new $Int64(0, 14549), new $Int64(0, 4008)), new Pair.ptr(new $Int64(0, 14551), new $Int64(0, 98)), new Pair.ptr(new $Int64(0, 14557), new $Int64(0, 14410)), new Pair.ptr(new $Int64(0, 14561), new $Int64(0, 7501)), new Pair.ptr(new $Int64(0, 14563), new $Int64(0, 5884)), new Pair.ptr(new $Int64(0, 14591), new $Int64(0, 14320)), new Pair.ptr(new $Int64(0, 14593), new $Int64(0, 134)), new Pair.ptr(new $Int64(0, 14621), new $Int64(0, 8883)), new Pair.ptr(new $Int64(0, 14627), new $Int64(0, 8845)), new Pair.ptr(new $Int64(0, 14629), new $Int64(0, 469)), new Pair.ptr(new $Int64(0, 14633), new $Int64(0, 7848)), new Pair.ptr(new $Int64(0, 14639), new $Int64(0, 14566)), new Pair.ptr(new $Int64(0, 14653), new $Int64(0, 10418)), new Pair.ptr(new $Int64(0, 14657), new $Int64(0, 14570)), new Pair.ptr(new $Int64(0, 14669), new $Int64(0, 13625)), new Pair.ptr(new $Int64(0, 14683), new $Int64(0, 1664)), new Pair.ptr(new $Int64(0, 14699), new $Int64(0, 1285)), new Pair.ptr(new $Int64(0, 14713), new $Int64(0, 1017)), new Pair.ptr(new $Int64(0, 14717), new $Int64(0, 9550)), new Pair.ptr(new $Int64(0, 14723), new $Int64(0, 3561)), new Pair.ptr(new $Int64(0, 14731), new $Int64(0, 5375)), new Pair.ptr(new $Int64(0, 14737), new $Int64(0, 3068)), new Pair.ptr(new $Int64(0, 14741), new $Int64(0, 12932)), new Pair.ptr(new $Int64(0, 14747), new $Int64(0, 13956)), new Pair.ptr(new $Int64(0, 14753), new $Int64(0, 1457)), new Pair.ptr(new $Int64(0, 14759), new $Int64(0, 3524)), new Pair.ptr(new $Int64(0, 14767), new $Int64(0, 14179)), new Pair.ptr(new $Int64(0, 14771), new $Int64(0, 8513)), new Pair.ptr(new $Int64(0, 14779), new $Int64(0, 7867)), new Pair.ptr(new $Int64(0, 14783), new $Int64(0, 2047)), new Pair.ptr(new $Int64(0, 14797), new $Int64(0, 10139)), new Pair.ptr(new $Int64(0, 14813), new $Int64(0, 7434)), new Pair.ptr(new $Int64(0, 14821), new $Int64(0, 1251)), new Pair.ptr(new $Int64(0, 14827), new $Int64(0, 9119)), new Pair.ptr(new $Int64(0, 14831), new $Int64(0, 3073)), new Pair.ptr(new $Int64(0, 14843), new $Int64(0, 10841)), new Pair.ptr(new $Int64(0, 14851), new $Int64(0, 5671)), new Pair.ptr(new $Int64(0, 14867), new $Int64(0, 8099)), new Pair.ptr(new $Int64(0, 14869), new $Int64(0, 5334)), new Pair.ptr(new $Int64(0, 14879), new $Int64(0, 3077)), new Pair.ptr(new $Int64(0, 14887), new $Int64(0, 8970)), new Pair.ptr(new $Int64(0, 14891), new $Int64(0, 8121)), new Pair.ptr(new $Int64(0, 14897), new $Int64(0, 6549)), new Pair.ptr(new $Int64(0, 14923), new $Int64(0, 588)), new Pair.ptr(new $Int64(0, 14929), new $Int64(0, 12477)), new Pair.ptr(new $Int64(0, 14939), new $Int64(0, 5037)), new Pair.ptr(new $Int64(0, 14947), new $Int64(0, 577)), new Pair.ptr(new $Int64(0, 14951), new $Int64(0, 4935)), new Pair.ptr(new $Int64(0, 14957), new $Int64(0, 10154)), new Pair.ptr(new $Int64(0, 14969), new $Int64(0, 6793)), new Pair.ptr(new $Int64(0, 14983), new $Int64(0, 11764)), new Pair.ptr(new $Int64(0, 15013), new $Int64(0, 2815)), new Pair.ptr(new $Int64(0, 15017), new $Int64(0, 8447)), new Pair.ptr(new $Int64(0, 15031), new $Int64(0, 822)), new Pair.ptr(new $Int64(0, 15053), new $Int64(0, 10547)), new Pair.ptr(new $Int64(0, 15061), new $Int64(0, 4461)), new Pair.ptr(new $Int64(0, 15073), new $Int64(0, 1072)), new Pair.ptr(new $Int64(0, 15077), new $Int64(0, 4286)), new Pair.ptr(new $Int64(0, 15083), new $Int64(0, 10730)), new Pair.ptr(new $Int64(0, 15091), new $Int64(0, 6230)), new Pair.ptr(new $Int64(0, 15101), new $Int64(0, 13806)), new Pair.ptr(new $Int64(0, 15107), new $Int64(0, 10735)), new Pair.ptr(new $Int64(0, 15121), new $Int64(0, 10574)), new Pair.ptr(new $Int64(0, 15131), new $Int64(0, 12832)), new Pair.ptr(new $Int64(0, 15137), new $Int64(0, 10934)), new Pair.ptr(new $Int64(0, 15139), new $Int64(0, 3098)), new Pair.ptr(new $Int64(0, 15149), new $Int64(0, 7306)), new Pair.ptr(new $Int64(0, 15161), new $Int64(0, 5932)), new Pair.ptr(new $Int64(0, 15173), new $Int64(0, 3037)), new Pair.ptr(new $Int64(0, 15187), new $Int64(0, 298)), new Pair.ptr(new $Int64(0, 15193), new $Int64(0, 8290)), new Pair.ptr(new $Int64(0, 15199), new $Int64(0, 8250)), new Pair.ptr(new $Int64(0, 15217), new $Int64(0, 3776)), new Pair.ptr(new $Int64(0, 15227), new $Int64(0, 2469)), new Pair.ptr(new $Int64(0, 15233), new $Int64(0, 987)), new Pair.ptr(new $Int64(0, 15241), new $Int64(0, 1020)), new Pair.ptr(new $Int64(0, 15259), new $Int64(0, 2650)), new Pair.ptr(new $Int64(0, 15263), new $Int64(0, 12055)), new Pair.ptr(new $Int64(0, 15269), new $Int64(0, 15006)), new Pair.ptr(new $Int64(0, 15271), new $Int64(0, 7807)), new Pair.ptr(new $Int64(0, 15277), new $Int64(0, 9949)), new Pair.ptr(new $Int64(0, 15287), new $Int64(0, 10840)), new Pair.ptr(new $Int64(0, 15289), new $Int64(0, 13343)), new Pair.ptr(new $Int64(0, 15299), new $Int64(0, 5892)), new Pair.ptr(new $Int64(0, 15307), new $Int64(0, 7778)), new Pair.ptr(new $Int64(0, 15313), new $Int64(0, 1548)), new Pair.ptr(new $Int64(0, 15319), new $Int64(0, 13549)), new Pair.ptr(new $Int64(0, 15329), new $Int64(0, 13480)), new Pair.ptr(new $Int64(0, 15331), new $Int64(0, 10158)), new Pair.ptr(new $Int64(0, 15349), new $Int64(0, 12023)), new Pair.ptr(new $Int64(0, 15359), new $Int64(0, 10710)), new Pair.ptr(new $Int64(0, 15361), new $Int64(0, 12614)), new Pair.ptr(new $Int64(0, 15373), new $Int64(0, 11621)), new Pair.ptr(new $Int64(0, 15377), new $Int64(0, 600)), new Pair.ptr(new $Int64(0, 15383), new $Int64(0, 10905)), new Pair.ptr(new $Int64(0, 15391), new $Int64(0, 11620)), new Pair.ptr(new $Int64(0, 15401), new $Int64(0, 11057)), new Pair.ptr(new $Int64(0, 15413), new $Int64(0, 760)), new Pair.ptr(new $Int64(0, 15427), new $Int64(0, 5743)), new Pair.ptr(new $Int64(0, 15439), new $Int64(0, 11866)), new Pair.ptr(new $Int64(0, 15443), new $Int64(0, 10369)), new Pair.ptr(new $Int64(0, 15451), new $Int64(0, 5329)), new Pair.ptr(new $Int64(0, 15461), new $Int64(0, 15448)), new Pair.ptr(new $Int64(0, 15467), new $Int64(0, 5351)), new Pair.ptr(new $Int64(0, 15473), new $Int64(0, 11761)), new Pair.ptr(new $Int64(0, 15493), new $Int64(0, 8415)), new Pair.ptr(new $Int64(0, 15497), new $Int64(0, 9553)), new Pair.ptr(new $Int64(0, 15511), new $Int64(0, 5156)), new Pair.ptr(new $Int64(0, 15527), new $Int64(0, 10762)), new Pair.ptr(new $Int64(0, 15541), new $Int64(0, 13639)), new Pair.ptr(new $Int64(0, 15551), new $Int64(0, 1389)), new Pair.ptr(new $Int64(0, 15559), new $Int64(0, 4544)), new Pair.ptr(new $Int64(0, 15569), new $Int64(0, 6692)), new Pair.ptr(new $Int64(0, 15581), new $Int64(0, 13451)), new Pair.ptr(new $Int64(0, 15583), new $Int64(0, 13714)), new Pair.ptr(new $Int64(0, 15601), new $Int64(0, 10333)), new Pair.ptr(new $Int64(0, 15607), new $Int64(0, 9092)), new Pair.ptr(new $Int64(0, 15619), new $Int64(0, 14103)), new Pair.ptr(new $Int64(0, 15629), new $Int64(0, 15594)), new Pair.ptr(new $Int64(0, 15641), new $Int64(0, 14120)), new Pair.ptr(new $Int64(0, 15643), new $Int64(0, 3945)), new Pair.ptr(new $Int64(0, 15647), new $Int64(0, 294)), new Pair.ptr(new $Int64(0, 15649), new $Int64(0, 7951)), new Pair.ptr(new $Int64(0, 15661), new $Int64(0, 14464)), new Pair.ptr(new $Int64(0, 15667), new $Int64(0, 14018)), new Pair.ptr(new $Int64(0, 15671), new $Int64(0, 1932)), new Pair.ptr(new $Int64(0, 15679), new $Int64(0, 7931)), new Pair.ptr(new $Int64(0, 15683), new $Int64(0, 14964)), new Pair.ptr(new $Int64(0, 15727), new $Int64(0, 15415)), new Pair.ptr(new $Int64(0, 15731), new $Int64(0, 6929)), new Pair.ptr(new $Int64(0, 15733), new $Int64(0, 9677)), new Pair.ptr(new $Int64(0, 15737), new $Int64(0, 15282)), new Pair.ptr(new $Int64(0, 15739), new $Int64(0, 13095)), new Pair.ptr(new $Int64(0, 15749), new $Int64(0, 15226)), new Pair.ptr(new $Int64(0, 15761), new $Int64(0, 14496)), new Pair.ptr(new $Int64(0, 15767), new $Int64(0, 12850)), new Pair.ptr(new $Int64(0, 15773), new $Int64(0, 6214)), new Pair.ptr(new $Int64(0, 15787), new $Int64(0, 2707)), new Pair.ptr(new $Int64(0, 15791), new $Int64(0, 4108)), new Pair.ptr(new $Int64(0, 15797), new $Int64(0, 15143)), new Pair.ptr(new $Int64(0, 15803), new $Int64(0, 6064)), new Pair.ptr(new $Int64(0, 15809), new $Int64(0, 14139)), new Pair.ptr(new $Int64(0, 15817), new $Int64(0, 5426)), new Pair.ptr(new $Int64(0, 15823), new $Int64(0, 2465)), new Pair.ptr(new $Int64(0, 15859), new $Int64(0, 14795)), new Pair.ptr(new $Int64(0, 15877), new $Int64(0, 13623)), new Pair.ptr(new $Int64(0, 15881), new $Int64(0, 13591)), new Pair.ptr(new $Int64(0, 15887), new $Int64(0, 13662)), new Pair.ptr(new $Int64(0, 15889), new $Int64(0, 7565)), new Pair.ptr(new $Int64(0, 15901), new $Int64(0, 4821)), new Pair.ptr(new $Int64(0, 15907), new $Int64(0, 8941)), new Pair.ptr(new $Int64(0, 15913), new $Int64(0, 9589)), new Pair.ptr(new $Int64(0, 15919), new $Int64(0, 13698)), new Pair.ptr(new $Int64(0, 15923), new $Int64(0, 2865)), new Pair.ptr(new $Int64(0, 15937), new $Int64(0, 659)), new Pair.ptr(new $Int64(0, 15959), new $Int64(0, 5357)), new Pair.ptr(new $Int64(0, 15971), new $Int64(0, 13321)), new Pair.ptr(new $Int64(0, 15973), new $Int64(0, 8197)), new Pair.ptr(new $Int64(0, 15991), new $Int64(0, 1194)), new Pair.ptr(new $Int64(0, 16001), new $Int64(0, 12303)), new Pair.ptr(new $Int64(0, 16007), new $Int64(0, 1660)), new Pair.ptr(new $Int64(0, 16033), new $Int64(0, 15027)), new Pair.ptr(new $Int64(0, 16057), new $Int64(0, 2637)), new Pair.ptr(new $Int64(0, 16061), new $Int64(0, 14443)), new Pair.ptr(new $Int64(0, 16063), new $Int64(0, 6129)), new Pair.ptr(new $Int64(0, 16067), new $Int64(0, 21)), new Pair.ptr(new $Int64(0, 16069), new $Int64(0, 13502)), new Pair.ptr(new $Int64(0, 16073), new $Int64(0, 3177)), new Pair.ptr(new $Int64(0, 16087), new $Int64(0, 15800)), new Pair.ptr(new $Int64(0, 16091), new $Int64(0, 11042)), new Pair.ptr(new $Int64(0, 16097), new $Int64(0, 4584)), new Pair.ptr(new $Int64(0, 16103), new $Int64(0, 1345)), new Pair.ptr(new $Int64(0, 16111), new $Int64(0, 13081)), new Pair.ptr(new $Int64(0, 16127), new $Int64(0, 9744)), new Pair.ptr(new $Int64(0, 16139), new $Int64(0, 3394)), new Pair.ptr(new $Int64(0, 16141), new $Int64(0, 6861)), new Pair.ptr(new $Int64(0, 16183), new $Int64(0, 10653)), new Pair.ptr(new $Int64(0, 16187), new $Int64(0, 10419)), new Pair.ptr(new $Int64(0, 16189), new $Int64(0, 1360)), new Pair.ptr(new $Int64(0, 16193), new $Int64(0, 2586)), new Pair.ptr(new $Int64(0, 16217), new $Int64(0, 5169)), new Pair.ptr(new $Int64(0, 16223), new $Int64(0, 10366)), new Pair.ptr(new $Int64(0, 16229), new $Int64(0, 2428)), new Pair.ptr(new $Int64(0, 16231), new $Int64(0, 6125)), new Pair.ptr(new $Int64(0, 16249), new $Int64(0, 14473)), new Pair.ptr(new $Int64(0, 16253), new $Int64(0, 5916)), new Pair.ptr(new $Int64(0, 16267), new $Int64(0, 12426)), new Pair.ptr(new $Int64(0, 16273), new $Int64(0, 9367)), new Pair.ptr(new $Int64(0, 16301), new $Int64(0, 4774)), new Pair.ptr(new $Int64(0, 16319), new $Int64(0, 2201)), new Pair.ptr(new $Int64(0, 16333), new $Int64(0, 14011)), new Pair.ptr(new $Int64(0, 16339), new $Int64(0, 634)), new Pair.ptr(new $Int64(0, 16349), new $Int64(0, 9469)), new Pair.ptr(new $Int64(0, 16361), new $Int64(0, 9981)), new Pair.ptr(new $Int64(0, 16363), new $Int64(0, 7919)), new Pair.ptr(new $Int64(0, 16369), new $Int64(0, 14678)), new Pair.ptr(new $Int64(0, 16381), new $Int64(0, 5212)), new Pair.ptr(new $Int64(0, 16411), new $Int64(0, 8398)), new Pair.ptr(new $Int64(0, 16417), new $Int64(0, 10306)), new Pair.ptr(new $Int64(0, 16421), new $Int64(0, 14291)), new Pair.ptr(new $Int64(0, 16427), new $Int64(0, 842)), new Pair.ptr(new $Int64(0, 16433), new $Int64(0, 1508)), new Pair.ptr(new $Int64(0, 16447), new $Int64(0, 6706)), new Pair.ptr(new $Int64(0, 16451), new $Int64(0, 14313)), new Pair.ptr(new $Int64(0, 16453), new $Int64(0, 13062)), new Pair.ptr(new $Int64(0, 16477), new $Int64(0, 8640)), new Pair.ptr(new $Int64(0, 16481), new $Int64(0, 10614)), new Pair.ptr(new $Int64(0, 16487), new $Int64(0, 5498)), new Pair.ptr(new $Int64(0, 16493), new $Int64(0, 2395)), new Pair.ptr(new $Int64(0, 16519), new $Int64(0, 5699)), new Pair.ptr(new $Int64(0, 16529), new $Int64(0, 4281)), new Pair.ptr(new $Int64(0, 16547), new $Int64(0, 15957)), new Pair.ptr(new $Int64(0, 16553), new $Int64(0, 13078)), new Pair.ptr(new $Int64(0, 16561), new $Int64(0, 6750)), new Pair.ptr(new $Int64(0, 16567), new $Int64(0, 9403)), new Pair.ptr(new $Int64(0, 16573), new $Int64(0, 16452)), new Pair.ptr(new $Int64(0, 16603), new $Int64(0, 12613)), new Pair.ptr(new $Int64(0, 16607), new $Int64(0, 12141)), new Pair.ptr(new $Int64(0, 16619), new $Int64(0, 8044)), new Pair.ptr(new $Int64(0, 16631), new $Int64(0, 256)), new Pair.ptr(new $Int64(0, 16633), new $Int64(0, 2047)), new Pair.ptr(new $Int64(0, 16649), new $Int64(0, 13726)), new Pair.ptr(new $Int64(0, 16651), new $Int64(0, 7739)), new Pair.ptr(new $Int64(0, 16657), new $Int64(0, 123)), new Pair.ptr(new $Int64(0, 16661), new $Int64(0, 2466)), new Pair.ptr(new $Int64(0, 16673), new $Int64(0, 13939)), new Pair.ptr(new $Int64(0, 16691), new $Int64(0, 1149)), new Pair.ptr(new $Int64(0, 16693), new $Int64(0, 10601)), new Pair.ptr(new $Int64(0, 16699), new $Int64(0, 13827)), new Pair.ptr(new $Int64(0, 16703), new $Int64(0, 10923)), new Pair.ptr(new $Int64(0, 16729), new $Int64(0, 15803)), new Pair.ptr(new $Int64(0, 16741), new $Int64(0, 2266)), new Pair.ptr(new $Int64(0, 16747), new $Int64(0, 4026)), new Pair.ptr(new $Int64(0, 16759), new $Int64(0, 14538)), new Pair.ptr(new $Int64(0, 16763), new $Int64(0, 9229)), new Pair.ptr(new $Int64(0, 16787), new $Int64(0, 3594)), new Pair.ptr(new $Int64(0, 16811), new $Int64(0, 1913)), new Pair.ptr(new $Int64(0, 16823), new $Int64(0, 14598)), new Pair.ptr(new $Int64(0, 16829), new $Int64(0, 6704)), new Pair.ptr(new $Int64(0, 16831), new $Int64(0, 4670)), new Pair.ptr(new $Int64(0, 16843), new $Int64(0, 630)), new Pair.ptr(new $Int64(0, 16871), new $Int64(0, 5771)), new Pair.ptr(new $Int64(0, 16879), new $Int64(0, 16244)), new Pair.ptr(new $Int64(0, 16883), new $Int64(0, 862)), new Pair.ptr(new $Int64(0, 16889), new $Int64(0, 6517)), new Pair.ptr(new $Int64(0, 16901), new $Int64(0, 14962)), new Pair.ptr(new $Int64(0, 16903), new $Int64(0, 10232)), new Pair.ptr(new $Int64(0, 16921), new $Int64(0, 12137)), new Pair.ptr(new $Int64(0, 16927), new $Int64(0, 10233)), new Pair.ptr(new $Int64(0, 16931), new $Int64(0, 13868)), new Pair.ptr(new $Int64(0, 16937), new $Int64(0, 11219)), new Pair.ptr(new $Int64(0, 16943), new $Int64(0, 12671)), new Pair.ptr(new $Int64(0, 16963), new $Int64(0, 13039)), new Pair.ptr(new $Int64(0, 16979), new $Int64(0, 14138)), new Pair.ptr(new $Int64(0, 16981), new $Int64(0, 11018)), new Pair.ptr(new $Int64(0, 16987), new $Int64(0, 11839)), new Pair.ptr(new $Int64(0, 16993), new $Int64(0, 1599)), new Pair.ptr(new $Int64(0, 17011), new $Int64(0, 14483)), new Pair.ptr(new $Int64(0, 17021), new $Int64(0, 1312)), new Pair.ptr(new $Int64(0, 17027), new $Int64(0, 8102)), new Pair.ptr(new $Int64(0, 17029), new $Int64(0, 4884)), new Pair.ptr(new $Int64(0, 17033), new $Int64(0, 14274)), new Pair.ptr(new $Int64(0, 17041), new $Int64(0, 7201)), new Pair.ptr(new $Int64(0, 17047), new $Int64(0, 7155)), new Pair.ptr(new $Int64(0, 17053), new $Int64(0, 14799)), new Pair.ptr(new $Int64(0, 17077), new $Int64(0, 14755)), new Pair.ptr(new $Int64(0, 17093), new $Int64(0, 3353)), new Pair.ptr(new $Int64(0, 17099), new $Int64(0, 15297)), new Pair.ptr(new $Int64(0, 17107), new $Int64(0, 8761)), new Pair.ptr(new $Int64(0, 17117), new $Int64(0, 8132)), new Pair.ptr(new $Int64(0, 17123), new $Int64(0, 8264)), new Pair.ptr(new $Int64(0, 17137), new $Int64(0, 3619)), new Pair.ptr(new $Int64(0, 17159), new $Int64(0, 7354)), new Pair.ptr(new $Int64(0, 17167), new $Int64(0, 9109)), new Pair.ptr(new $Int64(0, 17183), new $Int64(0, 16009)), new Pair.ptr(new $Int64(0, 17189), new $Int64(0, 13802)), new Pair.ptr(new $Int64(0, 17191), new $Int64(0, 8239)), new Pair.ptr(new $Int64(0, 17203), new $Int64(0, 4115)), new Pair.ptr(new $Int64(0, 17207), new $Int64(0, 5910)), new Pair.ptr(new $Int64(0, 17209), new $Int64(0, 12543)), new Pair.ptr(new $Int64(0, 17231), new $Int64(0, 3467)), new Pair.ptr(new $Int64(0, 17239), new $Int64(0, 12750)), new Pair.ptr(new $Int64(0, 17257), new $Int64(0, 10954)), new Pair.ptr(new $Int64(0, 17291), new $Int64(0, 14802)), new Pair.ptr(new $Int64(0, 17293), new $Int64(0, 6594)), new Pair.ptr(new $Int64(0, 17299), new $Int64(0, 11023)), new Pair.ptr(new $Int64(0, 17317), new $Int64(0, 7264)), new Pair.ptr(new $Int64(0, 17321), new $Int64(0, 15031)), new Pair.ptr(new $Int64(0, 17327), new $Int64(0, 10746)), new Pair.ptr(new $Int64(0, 17333), new $Int64(0, 7729)), new Pair.ptr(new $Int64(0, 17341), new $Int64(0, 15288)), new Pair.ptr(new $Int64(0, 17351), new $Int64(0, 13302)), new Pair.ptr(new $Int64(0, 17359), new $Int64(0, 162)), new Pair.ptr(new $Int64(0, 17377), new $Int64(0, 1899)), new Pair.ptr(new $Int64(0, 17383), new $Int64(0, 902)), new Pair.ptr(new $Int64(0, 17387), new $Int64(0, 15308)), new Pair.ptr(new $Int64(0, 17389), new $Int64(0, 5630)), new Pair.ptr(new $Int64(0, 17393), new $Int64(0, 9363)), new Pair.ptr(new $Int64(0, 17401), new $Int64(0, 6849)), new Pair.ptr(new $Int64(0, 17417), new $Int64(0, 9362)), new Pair.ptr(new $Int64(0, 17419), new $Int64(0, 16929)), new Pair.ptr(new $Int64(0, 17431), new $Int64(0, 13195)), new Pair.ptr(new $Int64(0, 17443), new $Int64(0, 2395)), new Pair.ptr(new $Int64(0, 17449), new $Int64(0, 13973)), new Pair.ptr(new $Int64(0, 17467), new $Int64(0, 9591)), new Pair.ptr(new $Int64(0, 17471), new $Int64(0, 3812)), new Pair.ptr(new $Int64(0, 17477), new $Int64(0, 1843)), new Pair.ptr(new $Int64(0, 17483), new $Int64(0, 4508)), new Pair.ptr(new $Int64(0, 17489), new $Int64(0, 10138)), new Pair.ptr(new $Int64(0, 17491), new $Int64(0, 13022)), new Pair.ptr(new $Int64(0, 17497), new $Int64(0, 14812)), new Pair.ptr(new $Int64(0, 17509), new $Int64(0, 10514)), new Pair.ptr(new $Int64(0, 17519), new $Int64(0, 9976)), new Pair.ptr(new $Int64(0, 17539), new $Int64(0, 3484)), new Pair.ptr(new $Int64(0, 17551), new $Int64(0, 17038)), new Pair.ptr(new $Int64(0, 17569), new $Int64(0, 13525)), new Pair.ptr(new $Int64(0, 17573), new $Int64(0, 10838)), new Pair.ptr(new $Int64(0, 17579), new $Int64(0, 10177)), new Pair.ptr(new $Int64(0, 17581), new $Int64(0, 12707)), new Pair.ptr(new $Int64(0, 17597), new $Int64(0, 10786)), new Pair.ptr(new $Int64(0, 17599), new $Int64(0, 12313)), new Pair.ptr(new $Int64(0, 17609), new $Int64(0, 6443)), new Pair.ptr(new $Int64(0, 17623), new $Int64(0, 87)), new Pair.ptr(new $Int64(0, 17627), new $Int64(0, 8951)), new Pair.ptr(new $Int64(0, 17657), new $Int64(0, 4111)), new Pair.ptr(new $Int64(0, 17659), new $Int64(0, 17568)), new Pair.ptr(new $Int64(0, 17669), new $Int64(0, 11981)), new Pair.ptr(new $Int64(0, 17681), new $Int64(0, 8649)), new Pair.ptr(new $Int64(0, 17683), new $Int64(0, 6226)), new Pair.ptr(new $Int64(0, 17707), new $Int64(0, 2081)), new Pair.ptr(new $Int64(0, 17713), new $Int64(0, 2233)), new Pair.ptr(new $Int64(0, 17729), new $Int64(0, 13536)), new Pair.ptr(new $Int64(0, 17737), new $Int64(0, 10355)), new Pair.ptr(new $Int64(0, 17747), new $Int64(0, 12806)), new Pair.ptr(new $Int64(0, 17749), new $Int64(0, 17396)), new Pair.ptr(new $Int64(0, 17761), new $Int64(0, 16714)), new Pair.ptr(new $Int64(0, 17783), new $Int64(0, 10439)), new Pair.ptr(new $Int64(0, 17789), new $Int64(0, 16985)), new Pair.ptr(new $Int64(0, 17791), new $Int64(0, 8100)), new Pair.ptr(new $Int64(0, 17807), new $Int64(0, 7895)), new Pair.ptr(new $Int64(0, 17827), new $Int64(0, 17785)), new Pair.ptr(new $Int64(0, 17837), new $Int64(0, 10648)), new Pair.ptr(new $Int64(0, 17839), new $Int64(0, 3802)), new Pair.ptr(new $Int64(0, 17851), new $Int64(0, 15323)), new Pair.ptr(new $Int64(0, 17863), new $Int64(0, 11634)), new Pair.ptr(new $Int64(0, 17881), new $Int64(0, 7681)), new Pair.ptr(new $Int64(0, 17891), new $Int64(0, 8220)), new Pair.ptr(new $Int64(0, 17903), new $Int64(0, 1549)), new Pair.ptr(new $Int64(0, 17909), new $Int64(0, 6186)), new Pair.ptr(new $Int64(0, 17911), new $Int64(0, 8763)), new Pair.ptr(new $Int64(0, 17921), new $Int64(0, 15122)), new Pair.ptr(new $Int64(0, 17923), new $Int64(0, 12631)), new Pair.ptr(new $Int64(0, 17929), new $Int64(0, 15844)), new Pair.ptr(new $Int64(0, 17939), new $Int64(0, 14794)), new Pair.ptr(new $Int64(0, 17957), new $Int64(0, 4136)), new Pair.ptr(new $Int64(0, 17959), new $Int64(0, 1872)), new Pair.ptr(new $Int64(0, 17971), new $Int64(0, 2428)), new Pair.ptr(new $Int64(0, 17977), new $Int64(0, 17122)), new Pair.ptr(new $Int64(0, 17981), new $Int64(0, 1871)), new Pair.ptr(new $Int64(0, 17987), new $Int64(0, 15405)), new Pair.ptr(new $Int64(0, 17989), new $Int64(0, 5986)), new Pair.ptr(new $Int64(0, 18013), new $Int64(0, 12429)), new Pair.ptr(new $Int64(0, 18041), new $Int64(0, 4824)), new Pair.ptr(new $Int64(0, 18043), new $Int64(0, 7975)), new Pair.ptr(new $Int64(0, 18047), new $Int64(0, 10237)), new Pair.ptr(new $Int64(0, 18049), new $Int64(0, 786)), new Pair.ptr(new $Int64(0, 18059), new $Int64(0, 17112)), new Pair.ptr(new $Int64(0, 18061), new $Int64(0, 63)), new Pair.ptr(new $Int64(0, 18077), new $Int64(0, 14385)), new Pair.ptr(new $Int64(0, 18089), new $Int64(0, 13847)), new Pair.ptr(new $Int64(0, 18097), new $Int64(0, 1363)), new Pair.ptr(new $Int64(0, 18119), new $Int64(0, 13069)), new Pair.ptr(new $Int64(0, 18121), new $Int64(0, 16564)), new Pair.ptr(new $Int64(0, 18127), new $Int64(0, 10053)), new Pair.ptr(new $Int64(0, 18131), new $Int64(0, 1067)), new Pair.ptr(new $Int64(0, 18133), new $Int64(0, 3871)), new Pair.ptr(new $Int64(0, 18143), new $Int64(0, 3781)), new Pair.ptr(new $Int64(0, 18149), new $Int64(0, 5036)), new Pair.ptr(new $Int64(0, 18169), new $Int64(0, 15203)), new Pair.ptr(new $Int64(0, 18181), new $Int64(0, 9163)), new Pair.ptr(new $Int64(0, 18191), new $Int64(0, 1225)), new Pair.ptr(new $Int64(0, 18199), new $Int64(0, 5515)), new Pair.ptr(new $Int64(0, 18211), new $Int64(0, 6572)), new Pair.ptr(new $Int64(0, 18217), new $Int64(0, 14093)), new Pair.ptr(new $Int64(0, 18223), new $Int64(0, 7827)), new Pair.ptr(new $Int64(0, 18229), new $Int64(0, 8324)), new Pair.ptr(new $Int64(0, 18233), new $Int64(0, 2930)), new Pair.ptr(new $Int64(0, 18251), new $Int64(0, 15952)), new Pair.ptr(new $Int64(0, 18253), new $Int64(0, 13014)), new Pair.ptr(new $Int64(0, 18257), new $Int64(0, 13899)), new Pair.ptr(new $Int64(0, 18269), new $Int64(0, 9997)), new Pair.ptr(new $Int64(0, 18287), new $Int64(0, 16822)), new Pair.ptr(new $Int64(0, 18289), new $Int64(0, 3263)), new Pair.ptr(new $Int64(0, 18301), new $Int64(0, 16500)), new Pair.ptr(new $Int64(0, 18307), new $Int64(0, 2499)), new Pair.ptr(new $Int64(0, 18311), new $Int64(0, 13727)), new Pair.ptr(new $Int64(0, 18313), new $Int64(0, 717)), new Pair.ptr(new $Int64(0, 18329), new $Int64(0, 14342)), new Pair.ptr(new $Int64(0, 18341), new $Int64(0, 406)), new Pair.ptr(new $Int64(0, 18353), new $Int64(0, 17397)), new Pair.ptr(new $Int64(0, 18367), new $Int64(0, 4076)), new Pair.ptr(new $Int64(0, 18371), new $Int64(0, 16167)), new Pair.ptr(new $Int64(0, 18379), new $Int64(0, 12262)), new Pair.ptr(new $Int64(0, 18397), new $Int64(0, 17715)), new Pair.ptr(new $Int64(0, 18401), new $Int64(0, 5196)), new Pair.ptr(new $Int64(0, 18413), new $Int64(0, 5433)), new Pair.ptr(new $Int64(0, 18427), new $Int64(0, 9842)), new Pair.ptr(new $Int64(0, 18433), new $Int64(0, 15748)), new Pair.ptr(new $Int64(0, 18439), new $Int64(0, 5293)), new Pair.ptr(new $Int64(0, 18443), new $Int64(0, 5253)), new Pair.ptr(new $Int64(0, 18451), new $Int64(0, 11746)), new Pair.ptr(new $Int64(0, 18457), new $Int64(0, 5926)), new Pair.ptr(new $Int64(0, 18461), new $Int64(0, 14425)), new Pair.ptr(new $Int64(0, 18481), new $Int64(0, 14216)), new Pair.ptr(new $Int64(0, 18493), new $Int64(0, 11818)), new Pair.ptr(new $Int64(0, 18503), new $Int64(0, 6869)), new Pair.ptr(new $Int64(0, 18517), new $Int64(0, 6121)), new Pair.ptr(new $Int64(0, 18521), new $Int64(0, 6081)), new Pair.ptr(new $Int64(0, 18523), new $Int64(0, 3413)), new Pair.ptr(new $Int64(0, 18539), new $Int64(0, 991)), new Pair.ptr(new $Int64(0, 18541), new $Int64(0, 18050)), new Pair.ptr(new $Int64(0, 18553), new $Int64(0, 782)), new Pair.ptr(new $Int64(0, 18583), new $Int64(0, 3192)), new Pair.ptr(new $Int64(0, 18587), new $Int64(0, 1844)), new Pair.ptr(new $Int64(0, 18593), new $Int64(0, 3025)), new Pair.ptr(new $Int64(0, 18617), new $Int64(0, 17279)), new Pair.ptr(new $Int64(0, 18637), new $Int64(0, 16829)), new Pair.ptr(new $Int64(0, 18661), new $Int64(0, 14196)), new Pair.ptr(new $Int64(0, 18671), new $Int64(0, 3850)), new Pair.ptr(new $Int64(0, 18679), new $Int64(0, 17827)), new Pair.ptr(new $Int64(0, 18691), new $Int64(0, 2712)), new Pair.ptr(new $Int64(0, 18701), new $Int64(0, 15173)), new Pair.ptr(new $Int64(0, 18713), new $Int64(0, 2465)), new Pair.ptr(new $Int64(0, 18719), new $Int64(0, 8995)), new Pair.ptr(new $Int64(0, 18731), new $Int64(0, 17382)), new Pair.ptr(new $Int64(0, 18743), new $Int64(0, 17219)), new Pair.ptr(new $Int64(0, 18749), new $Int64(0, 445)), new Pair.ptr(new $Int64(0, 18757), new $Int64(0, 8730)), new Pair.ptr(new $Int64(0, 18773), new $Int64(0, 138)), new Pair.ptr(new $Int64(0, 18787), new $Int64(0, 9490)), new Pair.ptr(new $Int64(0, 18793), new $Int64(0, 8452)), new Pair.ptr(new $Int64(0, 18797), new $Int64(0, 3015)), new Pair.ptr(new $Int64(0, 18803), new $Int64(0, 6708)), new Pair.ptr(new $Int64(0, 18839), new $Int64(0, 4517)), new Pair.ptr(new $Int64(0, 18859), new $Int64(0, 2710)), new Pair.ptr(new $Int64(0, 18869), new $Int64(0, 6970)), new Pair.ptr(new $Int64(0, 18899), new $Int64(0, 13018)), new Pair.ptr(new $Int64(0, 18911), new $Int64(0, 10814)), new Pair.ptr(new $Int64(0, 18913), new $Int64(0, 15459)), new Pair.ptr(new $Int64(0, 18917), new $Int64(0, 13466)), new Pair.ptr(new $Int64(0, 18919), new $Int64(0, 8039)), new Pair.ptr(new $Int64(0, 18947), new $Int64(0, 7331)), new Pair.ptr(new $Int64(0, 18959), new $Int64(0, 682)), new Pair.ptr(new $Int64(0, 18973), new $Int64(0, 4183)), new Pair.ptr(new $Int64(0, 18979), new $Int64(0, 945)), new Pair.ptr(new $Int64(0, 19001), new $Int64(0, 18482)), new Pair.ptr(new $Int64(0, 19009), new $Int64(0, 8063)), new Pair.ptr(new $Int64(0, 19013), new $Int64(0, 12068)), new Pair.ptr(new $Int64(0, 19031), new $Int64(0, 5141)), new Pair.ptr(new $Int64(0, 19037), new $Int64(0, 17336)), new Pair.ptr(new $Int64(0, 19051), new $Int64(0, 13936)), new Pair.ptr(new $Int64(0, 19069), new $Int64(0, 17642)), new Pair.ptr(new $Int64(0, 19073), new $Int64(0, 10134)), new Pair.ptr(new $Int64(0, 19079), new $Int64(0, 12351)), new Pair.ptr(new $Int64(0, 19081), new $Int64(0, 972)), new Pair.ptr(new $Int64(0, 19087), new $Int64(0, 1490)), new Pair.ptr(new $Int64(0, 19121), new $Int64(0, 3279)), new Pair.ptr(new $Int64(0, 19139), new $Int64(0, 19034)), new Pair.ptr(new $Int64(0, 19141), new $Int64(0, 9360)), new Pair.ptr(new $Int64(0, 19157), new $Int64(0, 17962)), new Pair.ptr(new $Int64(0, 19163), new $Int64(0, 1323)), new Pair.ptr(new $Int64(0, 19181), new $Int64(0, 17996)), new Pair.ptr(new $Int64(0, 19183), new $Int64(0, 2586)), new Pair.ptr(new $Int64(0, 19207), new $Int64(0, 9635)), new Pair.ptr(new $Int64(0, 19211), new $Int64(0, 13682)), new Pair.ptr(new $Int64(0, 19213), new $Int64(0, 8305)), new Pair.ptr(new $Int64(0, 19219), new $Int64(0, 15376)), new Pair.ptr(new $Int64(0, 19231), new $Int64(0, 17862)), new Pair.ptr(new $Int64(0, 19237), new $Int64(0, 8300)), new Pair.ptr(new $Int64(0, 19249), new $Int64(0, 13203)), new Pair.ptr(new $Int64(0, 19259), new $Int64(0, 8052)), new Pair.ptr(new $Int64(0, 19267), new $Int64(0, 3015)), new Pair.ptr(new $Int64(0, 19273), new $Int64(0, 14444)), new Pair.ptr(new $Int64(0, 19289), new $Int64(0, 12723)), new Pair.ptr(new $Int64(0, 19301), new $Int64(0, 11977)), new Pair.ptr(new $Int64(0, 19309), new $Int64(0, 3879)), new Pair.ptr(new $Int64(0, 19319), new $Int64(0, 3918)), new Pair.ptr(new $Int64(0, 19333), new $Int64(0, 12490)), new Pair.ptr(new $Int64(0, 19373), new $Int64(0, 13090)), new Pair.ptr(new $Int64(0, 19379), new $Int64(0, 17298)), new Pair.ptr(new $Int64(0, 19381), new $Int64(0, 15615)), new Pair.ptr(new $Int64(0, 19387), new $Int64(0, 1465)), new Pair.ptr(new $Int64(0, 19391), new $Int64(0, 5955)), new Pair.ptr(new $Int64(0, 19403), new $Int64(0, 3433)), new Pair.ptr(new $Int64(0, 19417), new $Int64(0, 8077)), new Pair.ptr(new $Int64(0, 19421), new $Int64(0, 18551)), new Pair.ptr(new $Int64(0, 19423), new $Int64(0, 13659)), new Pair.ptr(new $Int64(0, 19427), new $Int64(0, 13339)), new Pair.ptr(new $Int64(0, 19429), new $Int64(0, 3282)), new Pair.ptr(new $Int64(0, 19433), new $Int64(0, 10500)), new Pair.ptr(new $Int64(0, 19441), new $Int64(0, 9866)), new Pair.ptr(new $Int64(0, 19447), new $Int64(0, 741)), new Pair.ptr(new $Int64(0, 19457), new $Int64(0, 16698)), new Pair.ptr(new $Int64(0, 19463), new $Int64(0, 5981)), new Pair.ptr(new $Int64(0, 19469), new $Int64(0, 6472)), new Pair.ptr(new $Int64(0, 19471), new $Int64(0, 2193)), new Pair.ptr(new $Int64(0, 19477), new $Int64(0, 2469)), new Pair.ptr(new $Int64(0, 19483), new $Int64(0, 9935)), new Pair.ptr(new $Int64(0, 19489), new $Int64(0, 18235)), new Pair.ptr(new $Int64(0, 19501), new $Int64(0, 7471)), new Pair.ptr(new $Int64(0, 19507), new $Int64(0, 12504)), new Pair.ptr(new $Int64(0, 19531), new $Int64(0, 8980)), new Pair.ptr(new $Int64(0, 19541), new $Int64(0, 3556)), new Pair.ptr(new $Int64(0, 19543), new $Int64(0, 3025)), new Pair.ptr(new $Int64(0, 19553), new $Int64(0, 14745)), new Pair.ptr(new $Int64(0, 19559), new $Int64(0, 7347)), new Pair.ptr(new $Int64(0, 19571), new $Int64(0, 14740)), new Pair.ptr(new $Int64(0, 19577), new $Int64(0, 1996)), new Pair.ptr(new $Int64(0, 19583), new $Int64(0, 9911)), new Pair.ptr(new $Int64(0, 19597), new $Int64(0, 9258)), new Pair.ptr(new $Int64(0, 19603), new $Int64(0, 4082)), new Pair.ptr(new $Int64(0, 19609), new $Int64(0, 16643)), new Pair.ptr(new $Int64(0, 19661), new $Int64(0, 19232)), new Pair.ptr(new $Int64(0, 19681), new $Int64(0, 14156)), new Pair.ptr(new $Int64(0, 19687), new $Int64(0, 6316)), new Pair.ptr(new $Int64(0, 19697), new $Int64(0, 16963)), new Pair.ptr(new $Int64(0, 19699), new $Int64(0, 10545)), new Pair.ptr(new $Int64(0, 19709), new $Int64(0, 17755)), new Pair.ptr(new $Int64(0, 19717), new $Int64(0, 15086)), new Pair.ptr(new $Int64(0, 19727), new $Int64(0, 2637)), new Pair.ptr(new $Int64(0, 19739), new $Int64(0, 7247)), new Pair.ptr(new $Int64(0, 19751), new $Int64(0, 19029)), new Pair.ptr(new $Int64(0, 19753), new $Int64(0, 14488)), new Pair.ptr(new $Int64(0, 19759), new $Int64(0, 12403)), new Pair.ptr(new $Int64(0, 19763), new $Int64(0, 14316)), new Pair.ptr(new $Int64(0, 19777), new $Int64(0, 15043)), new Pair.ptr(new $Int64(0, 19793), new $Int64(0, 4723)), new Pair.ptr(new $Int64(0, 19801), new $Int64(0, 14361)), new Pair.ptr(new $Int64(0, 19813), new $Int64(0, 13097)), new Pair.ptr(new $Int64(0, 19819), new $Int64(0, 11520)), new Pair.ptr(new $Int64(0, 19841), new $Int64(0, 3898)), new Pair.ptr(new $Int64(0, 19843), new $Int64(0, 2784)), new Pair.ptr(new $Int64(0, 19853), new $Int64(0, 12740)), new Pair.ptr(new $Int64(0, 19861), new $Int64(0, 15843)), new Pair.ptr(new $Int64(0, 19867), new $Int64(0, 3744)), new Pair.ptr(new $Int64(0, 19889), new $Int64(0, 8072)), new Pair.ptr(new $Int64(0, 19891), new $Int64(0, 12464)), new Pair.ptr(new $Int64(0, 19913), new $Int64(0, 5428)), new Pair.ptr(new $Int64(0, 19919), new $Int64(0, 19163)), new Pair.ptr(new $Int64(0, 19927), new $Int64(0, 10892)), new Pair.ptr(new $Int64(0, 19937), new $Int64(0, 8207)), new Pair.ptr(new $Int64(0, 19949), new $Int64(0, 18310)), new Pair.ptr(new $Int64(0, 19961), new $Int64(0, 1748)), new Pair.ptr(new $Int64(0, 19963), new $Int64(0, 2043)), new Pair.ptr(new $Int64(0, 19973), new $Int64(0, 18344)), new Pair.ptr(new $Int64(0, 19979), new $Int64(0, 14700)), new Pair.ptr(new $Int64(0, 19991), new $Int64(0, 6319)), new Pair.ptr(new $Int64(0, 19993), new $Int64(0, 3579)), new Pair.ptr(new $Int64(0, 19997), new $Int64(0, 12317)), new Pair.ptr(new $Int64(0, 20011), new $Int64(0, 17417)), new Pair.ptr(new $Int64(0, 20021), new $Int64(0, 16684)), new Pair.ptr(new $Int64(0, 20023), new $Int64(0, 14461)), new Pair.ptr(new $Int64(0, 20029), new $Int64(0, 15949)), new Pair.ptr(new $Int64(0, 20047), new $Int64(0, 9776)), new Pair.ptr(new $Int64(0, 20051), new $Int64(0, 539)), new Pair.ptr(new $Int64(0, 20063), new $Int64(0, 15786)), new Pair.ptr(new $Int64(0, 20071), new $Int64(0, 15414)), new Pair.ptr(new $Int64(0, 20089), new $Int64(0, 7036)), new Pair.ptr(new $Int64(0, 20101), new $Int64(0, 1034)), new Pair.ptr(new $Int64(0, 20107), new $Int64(0, 9052)), new Pair.ptr(new $Int64(0, 20113), new $Int64(0, 2415)), new Pair.ptr(new $Int64(0, 20117), new $Int64(0, 795)), new Pair.ptr(new $Int64(0, 20123), new $Int64(0, 14034)), new Pair.ptr(new $Int64(0, 20129), new $Int64(0, 6802)), new Pair.ptr(new $Int64(0, 20143), new $Int64(0, 19679)), new Pair.ptr(new $Int64(0, 20147), new $Int64(0, 8540)), new Pair.ptr(new $Int64(0, 20149), new $Int64(0, 807)), new Pair.ptr(new $Int64(0, 20161), new $Int64(0, 18469)), new Pair.ptr(new $Int64(0, 20173), new $Int64(0, 9647)), new Pair.ptr(new $Int64(0, 20177), new $Int64(0, 19513)), new Pair.ptr(new $Int64(0, 20183), new $Int64(0, 5799)), new Pair.ptr(new $Int64(0, 20201), new $Int64(0, 5785)), new Pair.ptr(new $Int64(0, 20219), new $Int64(0, 11261)), new Pair.ptr(new $Int64(0, 20231), new $Int64(0, 8901)), new Pair.ptr(new $Int64(0, 20233), new $Int64(0, 18539)), new Pair.ptr(new $Int64(0, 20249), new $Int64(0, 14752)), new Pair.ptr(new $Int64(0, 20261), new $Int64(0, 19070)), new Pair.ptr(new $Int64(0, 20269), new $Int64(0, 1723)), new Pair.ptr(new $Int64(0, 20287), new $Int64(0, 18932)), new Pair.ptr(new $Int64(0, 20297), new $Int64(0, 1380)), new Pair.ptr(new $Int64(0, 20323), new $Int64(0, 18322)), new Pair.ptr(new $Int64(0, 20327), new $Int64(0, 19389)), new Pair.ptr(new $Int64(0, 20333), new $Int64(0, 10448)), new Pair.ptr(new $Int64(0, 20341), new $Int64(0, 2672)), new Pair.ptr(new $Int64(0, 20347), new $Int64(0, 11335)), new Pair.ptr(new $Int64(0, 20353), new $Int64(0, 7039)), new Pair.ptr(new $Int64(0, 20357), new $Int64(0, 8024)), new Pair.ptr(new $Int64(0, 20359), new $Int64(0, 19288)), new Pair.ptr(new $Int64(0, 20369), new $Int64(0, 107)), new Pair.ptr(new $Int64(0, 20389), new $Int64(0, 17967)), new Pair.ptr(new $Int64(0, 20393), new $Int64(0, 975)), new Pair.ptr(new $Int64(0, 20399), new $Int64(0, 15223)), new Pair.ptr(new $Int64(0, 20407), new $Int64(0, 18412)), new Pair.ptr(new $Int64(0, 20411), new $Int64(0, 7665)), new Pair.ptr(new $Int64(0, 20431), new $Int64(0, 16711)), new Pair.ptr(new $Int64(0, 20441), new $Int64(0, 5527)), new Pair.ptr(new $Int64(0, 20443), new $Int64(0, 3971)), new Pair.ptr(new $Int64(0, 20477), new $Int64(0, 12449)), new Pair.ptr(new $Int64(0, 20479), new $Int64(0, 989)), new Pair.ptr(new $Int64(0, 20483), new $Int64(0, 11318)), new Pair.ptr(new $Int64(0, 20507), new $Int64(0, 5804)), new Pair.ptr(new $Int64(0, 20509), new $Int64(0, 4243)), new Pair.ptr(new $Int64(0, 20521), new $Int64(0, 7011)), new Pair.ptr(new $Int64(0, 20533), new $Int64(0, 527)), new Pair.ptr(new $Int64(0, 20543), new $Int64(0, 15548)), new Pair.ptr(new $Int64(0, 20549), new $Int64(0, 2130)), new Pair.ptr(new $Int64(0, 20551), new $Int64(0, 15023)), new Pair.ptr(new $Int64(0, 20563), new $Int64(0, 11102)), new Pair.ptr(new $Int64(0, 20593), new $Int64(0, 12944)), new Pair.ptr(new $Int64(0, 20599), new $Int64(0, 3279)), new Pair.ptr(new $Int64(0, 20611), new $Int64(0, 10259)), new Pair.ptr(new $Int64(0, 20627), new $Int64(0, 15626)), new Pair.ptr(new $Int64(0, 20639), new $Int64(0, 14165)), new Pair.ptr(new $Int64(0, 20641), new $Int64(0, 11506)), new Pair.ptr(new $Int64(0, 20663), new $Int64(0, 11242)), new Pair.ptr(new $Int64(0, 20681), new $Int64(0, 19393)), new Pair.ptr(new $Int64(0, 20693), new $Int64(0, 19212)), new Pair.ptr(new $Int64(0, 20707), new $Int64(0, 427)), new Pair.ptr(new $Int64(0, 20717), new $Int64(0, 322)), new Pair.ptr(new $Int64(0, 20719), new $Int64(0, 4540)), new Pair.ptr(new $Int64(0, 20731), new $Int64(0, 9656)), new Pair.ptr(new $Int64(0, 20743), new $Int64(0, 15727)), new Pair.ptr(new $Int64(0, 20747), new $Int64(0, 566)), new Pair.ptr(new $Int64(0, 20749), new $Int64(0, 3961)), new Pair.ptr(new $Int64(0, 20753), new $Int64(0, 10301)), new Pair.ptr(new $Int64(0, 20759), new $Int64(0, 5164)), new Pair.ptr(new $Int64(0, 20771), new $Int64(0, 12635)), new Pair.ptr(new $Int64(0, 20773), new $Int64(0, 10598)), new Pair.ptr(new $Int64(0, 20789), new $Int64(0, 5997)), new Pair.ptr(new $Int64(0, 20807), new $Int64(0, 14193)), new Pair.ptr(new $Int64(0, 20809), new $Int64(0, 15354)), new Pair.ptr(new $Int64(0, 20849), new $Int64(0, 18355)), new Pair.ptr(new $Int64(0, 20857), new $Int64(0, 11093)), new Pair.ptr(new $Int64(0, 20873), new $Int64(0, 1978)), new Pair.ptr(new $Int64(0, 20879), new $Int64(0, 5319)), new Pair.ptr(new $Int64(0, 20887), new $Int64(0, 8725)), new Pair.ptr(new $Int64(0, 20897), new $Int64(0, 14531)), new Pair.ptr(new $Int64(0, 20899), new $Int64(0, 3713)), new Pair.ptr(new $Int64(0, 20903), new $Int64(0, 20686)), new Pair.ptr(new $Int64(0, 20921), new $Int64(0, 8541)), new Pair.ptr(new $Int64(0, 20929), new $Int64(0, 3964)), new Pair.ptr(new $Int64(0, 20939), new $Int64(0, 16515)), new Pair.ptr(new $Int64(0, 20947), new $Int64(0, 2399)), new Pair.ptr(new $Int64(0, 20959), new $Int64(0, 12905)), new Pair.ptr(new $Int64(0, 20963), new $Int64(0, 4798)), new Pair.ptr(new $Int64(0, 20981), new $Int64(0, 695)), new Pair.ptr(new $Int64(0, 20983), new $Int64(0, 12576)), new Pair.ptr(new $Int64(0, 21001), new $Int64(0, 15567)), new Pair.ptr(new $Int64(0, 21011), new $Int64(0, 8562)), new Pair.ptr(new $Int64(0, 21013), new $Int64(0, 1379)), new Pair.ptr(new $Int64(0, 21017), new $Int64(0, 16945)), new Pair.ptr(new $Int64(0, 21019), new $Int64(0, 7094)), new Pair.ptr(new $Int64(0, 21023), new $Int64(0, 2365)), new Pair.ptr(new $Int64(0, 21031), new $Int64(0, 5100)), new Pair.ptr(new $Int64(0, 21059), new $Int64(0, 17914)), new Pair.ptr(new $Int64(0, 21061), new $Int64(0, 12992)), new Pair.ptr(new $Int64(0, 21067), new $Int64(0, 9400)), new Pair.ptr(new $Int64(0, 21089), new $Int64(0, 18166)), new Pair.ptr(new $Int64(0, 21101), new $Int64(0, 4662)), new Pair.ptr(new $Int64(0, 21107), new $Int64(0, 1356)), new Pair.ptr(new $Int64(0, 21121), new $Int64(0, 5106)), new Pair.ptr(new $Int64(0, 21139), new $Int64(0, 9732)), new Pair.ptr(new $Int64(0, 21143), new $Int64(0, 5758)), new Pair.ptr(new $Int64(0, 21149), new $Int64(0, 6291)), new Pair.ptr(new $Int64(0, 21157), new $Int64(0, 14666)), new Pair.ptr(new $Int64(0, 21163), new $Int64(0, 4132)), new Pair.ptr(new $Int64(0, 21169), new $Int64(0, 7520)), new Pair.ptr(new $Int64(0, 21179), new $Int64(0, 7416)), new Pair.ptr(new $Int64(0, 21187), new $Int64(0, 6321)), new Pair.ptr(new $Int64(0, 21191), new $Int64(0, 18003)), new Pair.ptr(new $Int64(0, 21193), new $Int64(0, 12072)), new Pair.ptr(new $Int64(0, 21211), new $Int64(0, 2336)), new Pair.ptr(new $Int64(0, 21221), new $Int64(0, 16624)), new Pair.ptr(new $Int64(0, 21227), new $Int64(0, 16335)), new Pair.ptr(new $Int64(0, 21247), new $Int64(0, 4609)), new Pair.ptr(new $Int64(0, 21269), new $Int64(0, 19989)), new Pair.ptr(new $Int64(0, 21277), new $Int64(0, 14069)), new Pair.ptr(new $Int64(0, 21283), new $Int64(0, 4283)), new Pair.ptr(new $Int64(0, 21313), new $Int64(0, 1239)), new Pair.ptr(new $Int64(0, 21317), new $Int64(0, 9382)), new Pair.ptr(new $Int64(0, 21319), new $Int64(0, 5353)), new Pair.ptr(new $Int64(0, 21323), new $Int64(0, 4923)), new Pair.ptr(new $Int64(0, 21341), new $Int64(0, 3713)), new Pair.ptr(new $Int64(0, 21347), new $Int64(0, 17387)), new Pair.ptr(new $Int64(0, 21377), new $Int64(0, 15719)), new Pair.ptr(new $Int64(0, 21379), new $Int64(0, 19368)), new Pair.ptr(new $Int64(0, 21383), new $Int64(0, 12595)), new Pair.ptr(new $Int64(0, 21391), new $Int64(0, 13842)), new Pair.ptr(new $Int64(0, 21397), new $Int64(0, 19364)), new Pair.ptr(new $Int64(0, 21401), new $Int64(0, 1981)), new Pair.ptr(new $Int64(0, 21407), new $Int64(0, 18580)), new Pair.ptr(new $Int64(0, 21419), new $Int64(0, 4269)), new Pair.ptr(new $Int64(0, 21433), new $Int64(0, 19767)), new Pair.ptr(new $Int64(0, 21467), new $Int64(0, 3202)), new Pair.ptr(new $Int64(0, 21481), new $Int64(0, 18734)), new Pair.ptr(new $Int64(0, 21487), new $Int64(0, 13419)), new Pair.ptr(new $Int64(0, 21491), new $Int64(0, 19750)), new Pair.ptr(new $Int64(0, 21493), new $Int64(0, 7444)), new Pair.ptr(new $Int64(0, 21499), new $Int64(0, 14902)), new Pair.ptr(new $Int64(0, 21503), new $Int64(0, 3579)), new Pair.ptr(new $Int64(0, 21517), new $Int64(0, 10380)), new Pair.ptr(new $Int64(0, 21521), new $Int64(0, 6636)), new Pair.ptr(new $Int64(0, 21523), new $Int64(0, 7234)), new Pair.ptr(new $Int64(0, 21529), new $Int64(0, 15154)), new Pair.ptr(new $Int64(0, 21557), new $Int64(0, 5159)), new Pair.ptr(new $Int64(0, 21559), new $Int64(0, 19348)), new Pair.ptr(new $Int64(0, 21563), new $Int64(0, 8662)), new Pair.ptr(new $Int64(0, 21569), new $Int64(0, 8603)), new Pair.ptr(new $Int64(0, 21577), new $Int64(0, 21219)), new Pair.ptr(new $Int64(0, 21587), new $Int64(0, 287)), new Pair.ptr(new $Int64(0, 21589), new $Int64(0, 649)), new Pair.ptr(new $Int64(0, 21599), new $Int64(0, 5524)), new Pair.ptr(new $Int64(0, 21601), new $Int64(0, 8200)), new Pair.ptr(new $Int64(0, 21611), new $Int64(0, 17982)), new Pair.ptr(new $Int64(0, 21613), new $Int64(0, 2865)), new Pair.ptr(new $Int64(0, 21617), new $Int64(0, 282)), new Pair.ptr(new $Int64(0, 21647), new $Int64(0, 1142)), new Pair.ptr(new $Int64(0, 21649), new $Int64(0, 8707)), new Pair.ptr(new $Int64(0, 21661), new $Int64(0, 21650)), new Pair.ptr(new $Int64(0, 21673), new $Int64(0, 9639)), new Pair.ptr(new $Int64(0, 21683), new $Int64(0, 10898)), new Pair.ptr(new $Int64(0, 21701), new $Int64(0, 11255)), new Pair.ptr(new $Int64(0, 21713), new $Int64(0, 16786)), new Pair.ptr(new $Int64(0, 21727), new $Int64(0, 13634)), new Pair.ptr(new $Int64(0, 21737), new $Int64(0, 12835)), new Pair.ptr(new $Int64(0, 21739), new $Int64(0, 16632)), new Pair.ptr(new $Int64(0, 21751), new $Int64(0, 10620)), new Pair.ptr(new $Int64(0, 21757), new $Int64(0, 20494)), new Pair.ptr(new $Int64(0, 21767), new $Int64(0, 1518)), new Pair.ptr(new $Int64(0, 21773), new $Int64(0, 7947)), new Pair.ptr(new $Int64(0, 21787), new $Int64(0, 20778)), new Pair.ptr(new $Int64(0, 21799), new $Int64(0, 21654)), new Pair.ptr(new $Int64(0, 21803), new $Int64(0, 11089)), new Pair.ptr(new $Int64(0, 21817), new $Int64(0, 5174)), new Pair.ptr(new $Int64(0, 21821), new $Int64(0, 12320)), new Pair.ptr(new $Int64(0, 21839), new $Int64(0, 9927)), new Pair.ptr(new $Int64(0, 21841), new $Int64(0, 7942)), new Pair.ptr(new $Int64(0, 21851), new $Int64(0, 5237)), new Pair.ptr(new $Int64(0, 21859), new $Int64(0, 3556)), new Pair.ptr(new $Int64(0, 21863), new $Int64(0, 12703)), new Pair.ptr(new $Int64(0, 21871), new $Int64(0, 18151)), new Pair.ptr(new $Int64(0, 21881), new $Int64(0, 16059)), new Pair.ptr(new $Int64(0, 21893), new $Int64(0, 8975)), new Pair.ptr(new $Int64(0, 21911), new $Int64(0, 6116)), new Pair.ptr(new $Int64(0, 21929), new $Int64(0, 7235)), new Pair.ptr(new $Int64(0, 21937), new $Int64(0, 18483)), new Pair.ptr(new $Int64(0, 21943), new $Int64(0, 12976)), new Pair.ptr(new $Int64(0, 21961), new $Int64(0, 21895)), new Pair.ptr(new $Int64(0, 21977), new $Int64(0, 21627)), new Pair.ptr(new $Int64(0, 21991), new $Int64(0, 13703)), new Pair.ptr(new $Int64(0, 21997), new $Int64(0, 4942)), new Pair.ptr(new $Int64(0, 22003), new $Int64(0, 1988)), new Pair.ptr(new $Int64(0, 22013), new $Int64(0, 14390)), new Pair.ptr(new $Int64(0, 22027), new $Int64(0, 21513)), new Pair.ptr(new $Int64(0, 22031), new $Int64(0, 17176)), new Pair.ptr(new $Int64(0, 22037), new $Int64(0, 2522)), new Pair.ptr(new $Int64(0, 22039), new $Int64(0, 1923)), new Pair.ptr(new $Int64(0, 22051), new $Int64(0, 7363)), new Pair.ptr(new $Int64(0, 22063), new $Int64(0, 15758)), new Pair.ptr(new $Int64(0, 22067), new $Int64(0, 1087)), new Pair.ptr(new $Int64(0, 22073), new $Int64(0, 12169)), new Pair.ptr(new $Int64(0, 22079), new $Int64(0, 7676)), new Pair.ptr(new $Int64(0, 22091), new $Int64(0, 7369)), new Pair.ptr(new $Int64(0, 22093), new $Int64(0, 11757)), new Pair.ptr(new $Int64(0, 22109), new $Int64(0, 5163)), new Pair.ptr(new $Int64(0, 22111), new $Int64(0, 17312)), new Pair.ptr(new $Int64(0, 22123), new $Int64(0, 10795)), new Pair.ptr(new $Int64(0, 22129), new $Int64(0, 3926)), new Pair.ptr(new $Int64(0, 22133), new $Int64(0, 3413)), new Pair.ptr(new $Int64(0, 22147), new $Int64(0, 12736)), new Pair.ptr(new $Int64(0, 22153), new $Int64(0, 978)), new Pair.ptr(new $Int64(0, 22157), new $Int64(0, 610)), new Pair.ptr(new $Int64(0, 22159), new $Int64(0, 5254)), new Pair.ptr(new $Int64(0, 22171), new $Int64(0, 8732)), new Pair.ptr(new $Int64(0, 22189), new $Int64(0, 17935)), new Pair.ptr(new $Int64(0, 22193), new $Int64(0, 4298)), new Pair.ptr(new $Int64(0, 22229), new $Int64(0, 17538)), new Pair.ptr(new $Int64(0, 22247), new $Int64(0, 13864)), new Pair.ptr(new $Int64(0, 22259), new $Int64(0, 11441)), new Pair.ptr(new $Int64(0, 22271), new $Int64(0, 1522)), new Pair.ptr(new $Int64(0, 22273), new $Int64(0, 6991)), new Pair.ptr(new $Int64(0, 22277), new $Int64(0, 21466)), new Pair.ptr(new $Int64(0, 22279), new $Int64(0, 16166)), new Pair.ptr(new $Int64(0, 22283), new $Int64(0, 18323)), new Pair.ptr(new $Int64(0, 22291), new $Int64(0, 15304)), new Pair.ptr(new $Int64(0, 22303), new $Int64(0, 1848)), new Pair.ptr(new $Int64(0, 22307), new $Int64(0, 9879)), new Pair.ptr(new $Int64(0, 22343), new $Int64(0, 20437)), new Pair.ptr(new $Int64(0, 22349), new $Int64(0, 7608)), new Pair.ptr(new $Int64(0, 22367), new $Int64(0, 17000)), new Pair.ptr(new $Int64(0, 22369), new $Int64(0, 14181)), new Pair.ptr(new $Int64(0, 22381), new $Int64(0, 15036)), new Pair.ptr(new $Int64(0, 22391), new $Int64(0, 19358)), new Pair.ptr(new $Int64(0, 22397), new $Int64(0, 21962)), new Pair.ptr(new $Int64(0, 22409), new $Int64(0, 15363)), new Pair.ptr(new $Int64(0, 22433), new $Int64(0, 13488)), new Pair.ptr(new $Int64(0, 22441), new $Int64(0, 21701)), new Pair.ptr(new $Int64(0, 22447), new $Int64(0, 14624)), new Pair.ptr(new $Int64(0, 22453), new $Int64(0, 21504)), new Pair.ptr(new $Int64(0, 22469), new $Int64(0, 5696)), new Pair.ptr(new $Int64(0, 22481), new $Int64(0, 711)), new Pair.ptr(new $Int64(0, 22483), new $Int64(0, 1672)), new Pair.ptr(new $Int64(0, 22501), new $Int64(0, 10531)), new Pair.ptr(new $Int64(0, 22511), new $Int64(0, 4282)), new Pair.ptr(new $Int64(0, 22531), new $Int64(0, 1491)), new Pair.ptr(new $Int64(0, 22541), new $Int64(0, 6016)), new Pair.ptr(new $Int64(0, 22543), new $Int64(0, 18488)), new Pair.ptr(new $Int64(0, 22549), new $Int64(0, 20794)), new Pair.ptr(new $Int64(0, 22567), new $Int64(0, 12583)), new Pair.ptr(new $Int64(0, 22571), new $Int64(0, 12129)), new Pair.ptr(new $Int64(0, 22573), new $Int64(0, 2654)), new Pair.ptr(new $Int64(0, 22613), new $Int64(0, 6356)), new Pair.ptr(new $Int64(0, 22619), new $Int64(0, 16891)), new Pair.ptr(new $Int64(0, 22621), new $Int64(0, 15717)), new Pair.ptr(new $Int64(0, 22637), new $Int64(0, 3744)), new Pair.ptr(new $Int64(0, 22639), new $Int64(0, 6182)), new Pair.ptr(new $Int64(0, 22643), new $Int64(0, 7716)), new Pair.ptr(new $Int64(0, 22651), new $Int64(0, 7767)), new Pair.ptr(new $Int64(0, 22669), new $Int64(0, 17553)), new Pair.ptr(new $Int64(0, 22679), new $Int64(0, 22362)), new Pair.ptr(new $Int64(0, 22691), new $Int64(0, 5597)), new Pair.ptr(new $Int64(0, 22697), new $Int64(0, 4967)), new Pair.ptr(new $Int64(0, 22699), new $Int64(0, 17820)), new Pair.ptr(new $Int64(0, 22709), new $Int64(0, 18257)), new Pair.ptr(new $Int64(0, 22717), new $Int64(0, 11322)), new Pair.ptr(new $Int64(0, 22721), new $Int64(0, 4600)), new Pair.ptr(new $Int64(0, 22727), new $Int64(0, 13482)), new Pair.ptr(new $Int64(0, 22739), new $Int64(0, 6781)), new Pair.ptr(new $Int64(0, 22741), new $Int64(0, 670)), new Pair.ptr(new $Int64(0, 22751), new $Int64(0, 3964)), new Pair.ptr(new $Int64(0, 22769), new $Int64(0, 15951)), new Pair.ptr(new $Int64(0, 22777), new $Int64(0, 8519)), new Pair.ptr(new $Int64(0, 22783), new $Int64(0, 727)), new Pair.ptr(new $Int64(0, 22787), new $Int64(0, 15168)), new Pair.ptr(new $Int64(0, 22807), new $Int64(0, 16499)), new Pair.ptr(new $Int64(0, 22811), new $Int64(0, 16451)), new Pair.ptr(new $Int64(0, 22817), new $Int64(0, 6019)), new Pair.ptr(new $Int64(0, 22853), new $Int64(0, 13341)), new Pair.ptr(new $Int64(0, 22859), new $Int64(0, 7205)), new Pair.ptr(new $Int64(0, 22861), new $Int64(0, 16272)), new Pair.ptr(new $Int64(0, 22871), new $Int64(0, 22629)), new Pair.ptr(new $Int64(0, 22877), new $Int64(0, 11257)), new Pair.ptr(new $Int64(0, 22901), new $Int64(0, 3687)), new Pair.ptr(new $Int64(0, 22907), new $Int64(0, 808)), new Pair.ptr(new $Int64(0, 22921), new $Int64(0, 10968)), new Pair.ptr(new $Int64(0, 22937), new $Int64(0, 22228)), new Pair.ptr(new $Int64(0, 22943), new $Int64(0, 4873)), new Pair.ptr(new $Int64(0, 22961), new $Int64(0, 13755)), new Pair.ptr(new $Int64(0, 22963), new $Int64(0, 18431)), new Pair.ptr(new $Int64(0, 22973), new $Int64(0, 12057)), new Pair.ptr(new $Int64(0, 22993), new $Int64(0, 5678)), new Pair.ptr(new $Int64(0, 23003), new $Int64(0, 12067)), new Pair.ptr(new $Int64(0, 23011), new $Int64(0, 8741)), new Pair.ptr(new $Int64(0, 23017), new $Int64(0, 32)), new Pair.ptr(new $Int64(0, 23021), new $Int64(0, 7386)), new Pair.ptr(new $Int64(0, 23027), new $Int64(0, 5229)), new Pair.ptr(new $Int64(0, 23029), new $Int64(0, 18775)), new Pair.ptr(new $Int64(0, 23039), new $Int64(0, 22763)), new Pair.ptr(new $Int64(0, 23041), new $Int64(0, 15606)), new Pair.ptr(new $Int64(0, 23053), new $Int64(0, 22355)), new Pair.ptr(new $Int64(0, 23057), new $Int64(0, 21469)), new Pair.ptr(new $Int64(0, 23059), new $Int64(0, 411)), new Pair.ptr(new $Int64(0, 23063), new $Int64(0, 9230)), new Pair.ptr(new $Int64(0, 23071), new $Int64(0, 6701)), new Pair.ptr(new $Int64(0, 23081), new $Int64(0, 4719)), new Pair.ptr(new $Int64(0, 23087), new $Int64(0, 12773)), new Pair.ptr(new $Int64(0, 23099), new $Int64(0, 7996)), new Pair.ptr(new $Int64(0, 23117), new $Int64(0, 6433)), new Pair.ptr(new $Int64(0, 23131), new $Int64(0, 1808)), new Pair.ptr(new $Int64(0, 23143), new $Int64(0, 17616)), new Pair.ptr(new $Int64(0, 23159), new $Int64(0, 11036)), new Pair.ptr(new $Int64(0, 23167), new $Int64(0, 10094)), new Pair.ptr(new $Int64(0, 23173), new $Int64(0, 1868)), new Pair.ptr(new $Int64(0, 23189), new $Int64(0, 1894)), new Pair.ptr(new $Int64(0, 23197), new $Int64(0, 14597)), new Pair.ptr(new $Int64(0, 23201), new $Int64(0, 15753)), new Pair.ptr(new $Int64(0, 23203), new $Int64(0, 4878)), new Pair.ptr(new $Int64(0, 23209), new $Int64(0, 9033)), new Pair.ptr(new $Int64(0, 23227), new $Int64(0, 9250)), new Pair.ptr(new $Int64(0, 23251), new $Int64(0, 9529)), new Pair.ptr(new $Int64(0, 23269), new $Int64(0, 10300)), new Pair.ptr(new $Int64(0, 23279), new $Int64(0, 10349)), new Pair.ptr(new $Int64(0, 23291), new $Int64(0, 21823)), new Pair.ptr(new $Int64(0, 23293), new $Int64(0, 9929)), new Pair.ptr(new $Int64(0, 23297), new $Int64(0, 141)), new Pair.ptr(new $Int64(0, 23311), new $Int64(0, 16831)), new Pair.ptr(new $Int64(0, 23321), new $Int64(0, 5467)), new Pair.ptr(new $Int64(0, 23327), new $Int64(0, 415)), new Pair.ptr(new $Int64(0, 23333), new $Int64(0, 3971)), new Pair.ptr(new $Int64(0, 23339), new $Int64(0, 13908)), new Pair.ptr(new $Int64(0, 23357), new $Int64(0, 21410)), new Pair.ptr(new $Int64(0, 23369), new $Int64(0, 17632)), new Pair.ptr(new $Int64(0, 23371), new $Int64(0, 10372)), new Pair.ptr(new $Int64(0, 23399), new $Int64(0, 16106)), new Pair.ptr(new $Int64(0, 23417), new $Int64(0, 6458)), new Pair.ptr(new $Int64(0, 23431), new $Int64(0, 10621)), new Pair.ptr(new $Int64(0, 23447), new $Int64(0, 21147)), new Pair.ptr(new $Int64(0, 23459), new $Int64(0, 6527)), new Pair.ptr(new $Int64(0, 23473), new $Int64(0, 2326)), new Pair.ptr(new $Int64(0, 23497), new $Int64(0, 21018)), new Pair.ptr(new $Int64(0, 23509), new $Int64(0, 21327)), new Pair.ptr(new $Int64(0, 23531), new $Int64(0, 16171)), new Pair.ptr(new $Int64(0, 23537), new $Int64(0, 17660)), new Pair.ptr(new $Int64(0, 23539), new $Int64(0, 1854)), new Pair.ptr(new $Int64(0, 23549), new $Int64(0, 19097)), new Pair.ptr(new $Int64(0, 23557), new $Int64(0, 2845)), new Pair.ptr(new $Int64(0, 23561), new $Int64(0, 20752)), new Pair.ptr(new $Int64(0, 23563), new $Int64(0, 3353)), new Pair.ptr(new $Int64(0, 23567), new $Int64(0, 10025)), new Pair.ptr(new $Int64(0, 23581), new $Int64(0, 20483)), new Pair.ptr(new $Int64(0, 23593), new $Int64(0, 6109)), new Pair.ptr(new $Int64(0, 23599), new $Int64(0, 3898)), new Pair.ptr(new $Int64(0, 23603), new $Int64(0, 3846)), new Pair.ptr(new $Int64(0, 23609), new $Int64(0, 14063)), new Pair.ptr(new $Int64(0, 23623), new $Int64(0, 919)), new Pair.ptr(new $Int64(0, 23627), new $Int64(0, 857)), new Pair.ptr(new $Int64(0, 23629), new $Int64(0, 3661)), new Pair.ptr(new $Int64(0, 23633), new $Int64(0, 1366)), new Pair.ptr(new $Int64(0, 23663), new $Int64(0, 18524)), new Pair.ptr(new $Int64(0, 23669), new $Int64(0, 20282)), new Pair.ptr(new $Int64(0, 23671), new $Int64(0, 18226)), new Pair.ptr(new $Int64(0, 23677), new $Int64(0, 4326)), new Pair.ptr(new $Int64(0, 23687), new $Int64(0, 15140)), new Pair.ptr(new $Int64(0, 23689), new $Int64(0, 11894)), new Pair.ptr(new $Int64(0, 23719), new $Int64(0, 6548)), new Pair.ptr(new $Int64(0, 23741), new $Int64(0, 17768)), new Pair.ptr(new $Int64(0, 23743), new $Int64(0, 3177)), new Pair.ptr(new $Int64(0, 23747), new $Int64(0, 22924)), new Pair.ptr(new $Int64(0, 23753), new $Int64(0, 6451)), new Pair.ptr(new $Int64(0, 23761), new $Int64(0, 5222)), new Pair.ptr(new $Int64(0, 23767), new $Int64(0, 2164)), new Pair.ptr(new $Int64(0, 23773), new $Int64(0, 21462)), new Pair.ptr(new $Int64(0, 23789), new $Int64(0, 17533)), new Pair.ptr(new $Int64(0, 23801), new $Int64(0, 23246)), new Pair.ptr(new $Int64(0, 23813), new $Int64(0, 23655)), new Pair.ptr(new $Int64(0, 23819), new $Int64(0, 488)), new Pair.ptr(new $Int64(0, 23827), new $Int64(0, 12869)), new Pair.ptr(new $Int64(0, 23831), new $Int64(0, 6890)), new Pair.ptr(new $Int64(0, 23833), new $Int64(0, 13052)), new Pair.ptr(new $Int64(0, 23857), new $Int64(0, 200)), new Pair.ptr(new $Int64(0, 23869), new $Int64(0, 19126)), new Pair.ptr(new $Int64(0, 23873), new $Int64(0, 14640)), new Pair.ptr(new $Int64(0, 23879), new $Int64(0, 10902)), new Pair.ptr(new $Int64(0, 23887), new $Int64(0, 13844)), new Pair.ptr(new $Int64(0, 23893), new $Int64(0, 4122)), new Pair.ptr(new $Int64(0, 23899), new $Int64(0, 5774)), new Pair.ptr(new $Int64(0, 23909), new $Int64(0, 5655)), new Pair.ptr(new $Int64(0, 23911), new $Int64(0, 14135)), new Pair.ptr(new $Int64(0, 23917), new $Int64(0, 15289)), new Pair.ptr(new $Int64(0, 23929), new $Int64(0, 20453)), new Pair.ptr(new $Int64(0, 23957), new $Int64(0, 2646)), new Pair.ptr(new $Int64(0, 23971), new $Int64(0, 19810)), new Pair.ptr(new $Int64(0, 23977), new $Int64(0, 6836)), new Pair.ptr(new $Int64(0, 23981), new $Int64(0, 15504)), new Pair.ptr(new $Int64(0, 23993), new $Int64(0, 9752)), new Pair.ptr(new $Int64(0, 24001), new $Int64(0, 9183)), new Pair.ptr(new $Int64(0, 24007), new $Int64(0, 17511)), new Pair.ptr(new $Int64(0, 24019), new $Int64(0, 20176)), new Pair.ptr(new $Int64(0, 24023), new $Int64(0, 14414)), new Pair.ptr(new $Int64(0, 24029), new $Int64(0, 18262)), new Pair.ptr(new $Int64(0, 24043), new $Int64(0, 3037)), new Pair.ptr(new $Int64(0, 24049), new $Int64(0, 14237)), new Pair.ptr(new $Int64(0, 24061), new $Int64(0, 13136)), new Pair.ptr(new $Int64(0, 24071), new $Int64(0, 12394)), new Pair.ptr(new $Int64(0, 24077), new $Int64(0, 23441)), new Pair.ptr(new $Int64(0, 24083), new $Int64(0, 8327)), new Pair.ptr(new $Int64(0, 24091), new $Int64(0, 16612)), new Pair.ptr(new $Int64(0, 24097), new $Int64(0, 20664)), new Pair.ptr(new $Int64(0, 24103), new $Int64(0, 15072)), new Pair.ptr(new $Int64(0, 24107), new $Int64(0, 14987)), new Pair.ptr(new $Int64(0, 24109), new $Int64(0, 23485)), new Pair.ptr(new $Int64(0, 24113), new $Int64(0, 13655)), new Pair.ptr(new $Int64(0, 24121), new $Int64(0, 19446)), new Pair.ptr(new $Int64(0, 24133), new $Int64(0, 2524)), new Pair.ptr(new $Int64(0, 24137), new $Int64(0, 5041)), new Pair.ptr(new $Int64(0, 24151), new $Int64(0, 4602)), new Pair.ptr(new $Int64(0, 24169), new $Int64(0, 3467)), new Pair.ptr(new $Int64(0, 24179), new $Int64(0, 19312)), new Pair.ptr(new $Int64(0, 24181), new $Int64(0, 17743)), new Pair.ptr(new $Int64(0, 24197), new $Int64(0, 5259)), new Pair.ptr(new $Int64(0, 24203), new $Int64(0, 5733)), new Pair.ptr(new $Int64(0, 24223), new $Int64(0, 7839)), new Pair.ptr(new $Int64(0, 24229), new $Int64(0, 14041)), new Pair.ptr(new $Int64(0, 24239), new $Int64(0, 7531)), new Pair.ptr(new $Int64(0, 24247), new $Int64(0, 19963)), new Pair.ptr(new $Int64(0, 24251), new $Int64(0, 4722)), new Pair.ptr(new $Int64(0, 24281), new $Int64(0, 17214)), new Pair.ptr(new $Int64(0, 24317), new $Int64(0, 21877)), new Pair.ptr(new $Int64(0, 24329), new $Int64(0, 7881)), new Pair.ptr(new $Int64(0, 24337), new $Int64(0, 21429)), new Pair.ptr(new $Int64(0, 24359), new $Int64(0, 2385)), new Pair.ptr(new $Int64(0, 24371), new $Int64(0, 15044)), new Pair.ptr(new $Int64(0, 24373), new $Int64(0, 18814)), new Pair.ptr(new $Int64(0, 24379), new $Int64(0, 18116)), new Pair.ptr(new $Int64(0, 24391), new $Int64(0, 3868)), new Pair.ptr(new $Int64(0, 24407), new $Int64(0, 10553)), new Pair.ptr(new $Int64(0, 24413), new $Int64(0, 16154)), new Pair.ptr(new $Int64(0, 24419), new $Int64(0, 10868)), new Pair.ptr(new $Int64(0, 24421), new $Int64(0, 18651)), new Pair.ptr(new $Int64(0, 24439), new $Int64(0, 106)), new Pair.ptr(new $Int64(0, 24443), new $Int64(0, 18341)), new Pair.ptr(new $Int64(0, 24469), new $Int64(0, 20389)), new Pair.ptr(new $Int64(0, 24473), new $Int64(0, 16646)), new Pair.ptr(new $Int64(0, 24481), new $Int64(0, 9171)), new Pair.ptr(new $Int64(0, 24499), new $Int64(0, 19331)), new Pair.ptr(new $Int64(0, 24509), new $Int64(0, 12775)), new Pair.ptr(new $Int64(0, 24517), new $Int64(0, 2765)), new Pair.ptr(new $Int64(0, 24527), new $Int64(0, 11732)), new Pair.ptr(new $Int64(0, 24533), new $Int64(0, 20841)), new Pair.ptr(new $Int64(0, 24547), new $Int64(0, 3032)), new Pair.ptr(new $Int64(0, 24551), new $Int64(0, 22231)), new Pair.ptr(new $Int64(0, 24571), new $Int64(0, 10610)), new Pair.ptr(new $Int64(0, 24593), new $Int64(0, 15966)), new Pair.ptr(new $Int64(0, 24611), new $Int64(0, 21978)), new Pair.ptr(new $Int64(0, 24623), new $Int64(0, 11773)), new Pair.ptr(new $Int64(0, 24631), new $Int64(0, 12912)), new Pair.ptr(new $Int64(0, 24659), new $Int64(0, 9817)), new Pair.ptr(new $Int64(0, 24671), new $Int64(0, 18692)), new Pair.ptr(new $Int64(0, 24677), new $Int64(0, 8790)), new Pair.ptr(new $Int64(0, 24683), new $Int64(0, 10877)), new Pair.ptr(new $Int64(0, 24691), new $Int64(0, 21811)), new Pair.ptr(new $Int64(0, 24697), new $Int64(0, 7288)), new Pair.ptr(new $Int64(0, 24709), new $Int64(0, 101)), new Pair.ptr(new $Int64(0, 24733), new $Int64(0, 3921)), new Pair.ptr(new $Int64(0, 24749), new $Int64(0, 1700)), new Pair.ptr(new $Int64(0, 24763), new $Int64(0, 382)), new Pair.ptr(new $Int64(0, 24767), new $Int64(0, 20)), new Pair.ptr(new $Int64(0, 24781), new $Int64(0, 12217)), new Pair.ptr(new $Int64(0, 24793), new $Int64(0, 1367)), new Pair.ptr(new $Int64(0, 24799), new $Int64(0, 14873)), new Pair.ptr(new $Int64(0, 24809), new $Int64(0, 12572)), new Pair.ptr(new $Int64(0, 24821), new $Int64(0, 9972)), new Pair.ptr(new $Int64(0, 24841), new $Int64(0, 3077)), new Pair.ptr(new $Int64(0, 24847), new $Int64(0, 3007)), new Pair.ptr(new $Int64(0, 24851), new $Int64(0, 4243)), new Pair.ptr(new $Int64(0, 24859), new $Int64(0, 12885)), new Pair.ptr(new $Int64(0, 24877), new $Int64(0, 11479)), new Pair.ptr(new $Int64(0, 24889), new $Int64(0, 3073)), new Pair.ptr(new $Int64(0, 24907), new $Int64(0, 8874)), new Pair.ptr(new $Int64(0, 24917), new $Int64(0, 17986)), new Pair.ptr(new $Int64(0, 24919), new $Int64(0, 24106)), new Pair.ptr(new $Int64(0, 24923), new $Int64(0, 6526)), new Pair.ptr(new $Int64(0, 24943), new $Int64(0, 13853)), new Pair.ptr(new $Int64(0, 24953), new $Int64(0, 23379)), new Pair.ptr(new $Int64(0, 24967), new $Int64(0, 14869)), new Pair.ptr(new $Int64(0, 24971), new $Int64(0, 22524)), new Pair.ptr(new $Int64(0, 24977), new $Int64(0, 12727)), new Pair.ptr(new $Int64(0, 24979), new $Int64(0, 9254)), new Pair.ptr(new $Int64(0, 24989), new $Int64(0, 14548)), new Pair.ptr(new $Int64(0, 25013), new $Int64(0, 4082)), new Pair.ptr(new $Int64(0, 25031), new $Int64(0, 19990)), new Pair.ptr(new $Int64(0, 25033), new $Int64(0, 3781)), new Pair.ptr(new $Int64(0, 25037), new $Int64(0, 10519)), new Pair.ptr(new $Int64(0, 25057), new $Int64(0, 22088)), new Pair.ptr(new $Int64(0, 25073), new $Int64(0, 1850)), new Pair.ptr(new $Int64(0, 25087), new $Int64(0, 5041)), new Pair.ptr(new $Int64(0, 25097), new $Int64(0, 16223)), new Pair.ptr(new $Int64(0, 25111), new $Int64(0, 20865)), new Pair.ptr(new $Int64(0, 25117), new $Int64(0, 15755)), new Pair.ptr(new $Int64(0, 25121), new $Int64(0, 23431)), new Pair.ptr(new $Int64(0, 25127), new $Int64(0, 8078)), new Pair.ptr(new $Int64(0, 25147), new $Int64(0, 16069)), new Pair.ptr(new $Int64(0, 25153), new $Int64(0, 1613)), new Pair.ptr(new $Int64(0, 25163), new $Int64(0, 12270)), new Pair.ptr(new $Int64(0, 25169), new $Int64(0, 5513)), new Pair.ptr(new $Int64(0, 25171), new $Int64(0, 7751)), new Pair.ptr(new $Int64(0, 25183), new $Int64(0, 2942)), new Pair.ptr(new $Int64(0, 25189), new $Int64(0, 7174)), new Pair.ptr(new $Int64(0, 25219), new $Int64(0, 14684)), new Pair.ptr(new $Int64(0, 25229), new $Int64(0, 4581)), new Pair.ptr(new $Int64(0, 25237), new $Int64(0, 1989)), new Pair.ptr(new $Int64(0, 25243), new $Int64(0, 24775)), new Pair.ptr(new $Int64(0, 25247), new $Int64(0, 22039)), new Pair.ptr(new $Int64(0, 25253), new $Int64(0, 4878)), new Pair.ptr(new $Int64(0, 25261), new $Int64(0, 3394)), new Pair.ptr(new $Int64(0, 25301), new $Int64(0, 13021)), new Pair.ptr(new $Int64(0, 25303), new $Int64(0, 11601)), new Pair.ptr(new $Int64(0, 25307), new $Int64(0, 19500)), new Pair.ptr(new $Int64(0, 25309), new $Int64(0, 7638)), new Pair.ptr(new $Int64(0, 25321), new $Int64(0, 5236)), new Pair.ptr(new $Int64(0, 25339), new $Int64(0, 20171)), new Pair.ptr(new $Int64(0, 25343), new $Int64(0, 15763)), new Pair.ptr(new $Int64(0, 25349), new $Int64(0, 20658)), new Pair.ptr(new $Int64(0, 25357), new $Int64(0, 14031)), new Pair.ptr(new $Int64(0, 25367), new $Int64(0, 3619)), new Pair.ptr(new $Int64(0, 25373), new $Int64(0, 5763)), new Pair.ptr(new $Int64(0, 25391), new $Int64(0, 4703)), new Pair.ptr(new $Int64(0, 25409), new $Int64(0, 8307)), new Pair.ptr(new $Int64(0, 25411), new $Int64(0, 16126)), new Pair.ptr(new $Int64(0, 25423), new $Int64(0, 24558)), new Pair.ptr(new $Int64(0, 25439), new $Int64(0, 17561)), new Pair.ptr(new $Int64(0, 25447), new $Int64(0, 16731)), new Pair.ptr(new $Int64(0, 25453), new $Int64(0, 14969)), new Pair.ptr(new $Int64(0, 25457), new $Int64(0, 23780)), new Pair.ptr(new $Int64(0, 25463), new $Int64(0, 10394)), new Pair.ptr(new $Int64(0, 25469), new $Int64(0, 11647)), new Pair.ptr(new $Int64(0, 25471), new $Int64(0, 23327)), new Pair.ptr(new $Int64(0, 25523), new $Int64(0, 2680)), new Pair.ptr(new $Int64(0, 25537), new $Int64(0, 15572)), new Pair.ptr(new $Int64(0, 25541), new $Int64(0, 1586)), new Pair.ptr(new $Int64(0, 25561), new $Int64(0, 153)), new Pair.ptr(new $Int64(0, 25577), new $Int64(0, 23100)), new Pair.ptr(new $Int64(0, 25579), new $Int64(0, 8863)), new Pair.ptr(new $Int64(0, 25583), new $Int64(0, 16679)), new Pair.ptr(new $Int64(0, 25589), new $Int64(0, 16789)), new Pair.ptr(new $Int64(0, 25601), new $Int64(0, 3802)), new Pair.ptr(new $Int64(0, 25603), new $Int64(0, 574)), new Pair.ptr(new $Int64(0, 25609), new $Int64(0, 9174)), new Pair.ptr(new $Int64(0, 25621), new $Int64(0, 19977)), new Pair.ptr(new $Int64(0, 25633), new $Int64(0, 20414)), new Pair.ptr(new $Int64(0, 25639), new $Int64(0, 23445)), new Pair.ptr(new $Int64(0, 25643), new $Int64(0, 3871)), new Pair.ptr(new $Int64(0, 25657), new $Int64(0, 24001)), new Pair.ptr(new $Int64(0, 25667), new $Int64(0, 3290)), new Pair.ptr(new $Int64(0, 25673), new $Int64(0, 14205)), new Pair.ptr(new $Int64(0, 25679), new $Int64(0, 24807)), new Pair.ptr(new $Int64(0, 25693), new $Int64(0, 22374)), new Pair.ptr(new $Int64(0, 25703), new $Int64(0, 10569)), new Pair.ptr(new $Int64(0, 25717), new $Int64(0, 3594)), new Pair.ptr(new $Int64(0, 25733), new $Int64(0, 17593)), new Pair.ptr(new $Int64(0, 25741), new $Int64(0, 9193)), new Pair.ptr(new $Int64(0, 25747), new $Int64(0, 22857)), new Pair.ptr(new $Int64(0, 25759), new $Int64(0, 22757)), new Pair.ptr(new $Int64(0, 25763), new $Int64(0, 80)), new Pair.ptr(new $Int64(0, 25771), new $Int64(0, 21555)), new Pair.ptr(new $Int64(0, 25793), new $Int64(0, 14426)), new Pair.ptr(new $Int64(0, 25799), new $Int64(0, 10026)), new Pair.ptr(new $Int64(0, 25801), new $Int64(0, 4562)), new Pair.ptr(new $Int64(0, 25819), new $Int64(0, 20940)), new Pair.ptr(new $Int64(0, 25841), new $Int64(0, 13286)), new Pair.ptr(new $Int64(0, 25847), new $Int64(0, 8955)), new Pair.ptr(new $Int64(0, 25849), new $Int64(0, 7504)), new Pair.ptr(new $Int64(0, 25867), new $Int64(0, 24514)), new Pair.ptr(new $Int64(0, 25873), new $Int64(0, 19106)), new Pair.ptr(new $Int64(0, 25889), new $Int64(0, 9395)), new Pair.ptr(new $Int64(0, 25903), new $Int64(0, 6209)), new Pair.ptr(new $Int64(0, 25913), new $Int64(0, 9704)), new Pair.ptr(new $Int64(0, 25919), new $Int64(0, 10953)), new Pair.ptr(new $Int64(0, 25931), new $Int64(0, 21732)), new Pair.ptr(new $Int64(0, 25933), new $Int64(0, 2505)), new Pair.ptr(new $Int64(0, 25939), new $Int64(0, 9506)), new Pair.ptr(new $Int64(0, 25943), new $Int64(0, 24948)), new Pair.ptr(new $Int64(0, 25951), new $Int64(0, 25011)), new Pair.ptr(new $Int64(0, 25969), new $Int64(0, 6553)), new Pair.ptr(new $Int64(0, 25981), new $Int64(0, 19505)), new Pair.ptr(new $Int64(0, 25997), new $Int64(0, 12117)), new Pair.ptr(new $Int64(0, 25999), new $Int64(0, 8554)), new Pair.ptr(new $Int64(0, 26003), new $Int64(0, 4315)), new Pair.ptr(new $Int64(0, 26017), new $Int64(0, 530)), new Pair.ptr(new $Int64(0, 26021), new $Int64(0, 21424)), new Pair.ptr(new $Int64(0, 26029), new $Int64(0, 22703)), new Pair.ptr(new $Int64(0, 26041), new $Int64(0, 22945)), new Pair.ptr(new $Int64(0, 26053), new $Int64(0, 981)), new Pair.ptr(new $Int64(0, 26083), new $Int64(0, 2982)), new Pair.ptr(new $Int64(0, 26099), new $Int64(0, 16726)), new Pair.ptr(new $Int64(0, 26107), new $Int64(0, 5259)), new Pair.ptr(new $Int64(0, 26111), new $Int64(0, 25000)), new Pair.ptr(new $Int64(0, 26113), new $Int64(0, 5)), new Pair.ptr(new $Int64(0, 26119), new $Int64(0, 7054)), new Pair.ptr(new $Int64(0, 26141), new $Int64(0, 9066)), new Pair.ptr(new $Int64(0, 26153), new $Int64(0, 25470)), new Pair.ptr(new $Int64(0, 26161), new $Int64(0, 20777)), new Pair.ptr(new $Int64(0, 26171), new $Int64(0, 3318)), new Pair.ptr(new $Int64(0, 26177), new $Int64(0, 25394)), new Pair.ptr(new $Int64(0, 26183), new $Int64(0, 13539)), new Pair.ptr(new $Int64(0, 26189), new $Int64(0, 11453)), new Pair.ptr(new $Int64(0, 26203), new $Int64(0, 2001)), new Pair.ptr(new $Int64(0, 26209), new $Int64(0, 3812)), new Pair.ptr(new $Int64(0, 26227), new $Int64(0, 6174)), new Pair.ptr(new $Int64(0, 26237), new $Int64(0, 15479)), new Pair.ptr(new $Int64(0, 26249), new $Int64(0, 15924)), new Pair.ptr(new $Int64(0, 26251), new $Int64(0, 10234)), new Pair.ptr(new $Int64(0, 26261), new $Int64(0, 22225)), new Pair.ptr(new $Int64(0, 26263), new $Int64(0, 7371)), new Pair.ptr(new $Int64(0, 26267), new $Int64(0, 2396)), new Pair.ptr(new $Int64(0, 26293), new $Int64(0, 12705)), new Pair.ptr(new $Int64(0, 26297), new $Int64(0, 8198)), new Pair.ptr(new $Int64(0, 26309), new $Int64(0, 21966)), new Pair.ptr(new $Int64(0, 26317), new $Int64(0, 24763)), new Pair.ptr(new $Int64(0, 26321), new $Int64(0, 4540)), new Pair.ptr(new $Int64(0, 26339), new $Int64(0, 17485)), new Pair.ptr(new $Int64(0, 26347), new $Int64(0, 7413)), new Pair.ptr(new $Int64(0, 26357), new $Int64(0, 357)), new Pair.ptr(new $Int64(0, 26371), new $Int64(0, 13890)), new Pair.ptr(new $Int64(0, 26387), new $Int64(0, 21123)), new Pair.ptr(new $Int64(0, 26393), new $Int64(0, 24860)), new Pair.ptr(new $Int64(0, 26399), new $Int64(0, 5222)), new Pair.ptr(new $Int64(0, 26407), new $Int64(0, 1824)), new Pair.ptr(new $Int64(0, 26417), new $Int64(0, 13883)), new Pair.ptr(new $Int64(0, 26423), new $Int64(0, 14455)), new Pair.ptr(new $Int64(0, 26431), new $Int64(0, 20800)), new Pair.ptr(new $Int64(0, 26437), new $Int64(0, 25589)), new Pair.ptr(new $Int64(0, 26449), new $Int64(0, 9105)), new Pair.ptr(new $Int64(0, 26459), new $Int64(0, 15080)), new Pair.ptr(new $Int64(0, 26479), new $Int64(0, 5326)), new Pair.ptr(new $Int64(0, 26489), new $Int64(0, 18610)), new Pair.ptr(new $Int64(0, 26497), new $Int64(0, 6628)), new Pair.ptr(new $Int64(0, 26501), new $Int64(0, 20469)), new Pair.ptr(new $Int64(0, 26513), new $Int64(0, 22086)), new Pair.ptr(new $Int64(0, 26539), new $Int64(0, 4662)), new Pair.ptr(new $Int64(0, 26557), new $Int64(0, 23397)), new Pair.ptr(new $Int64(0, 26561), new $Int64(0, 4661)), new Pair.ptr(new $Int64(0, 26573), new $Int64(0, 5717)), new Pair.ptr(new $Int64(0, 26591), new $Int64(0, 8113)), new Pair.ptr(new $Int64(0, 26597), new $Int64(0, 10829)), new Pair.ptr(new $Int64(0, 26627), new $Int64(0, 13202)), new Pair.ptr(new $Int64(0, 26633), new $Int64(0, 8191)), new Pair.ptr(new $Int64(0, 26641), new $Int64(0, 24831)), new Pair.ptr(new $Int64(0, 26647), new $Int64(0, 18851)), new Pair.ptr(new $Int64(0, 26669), new $Int64(0, 18510)), new Pair.ptr(new $Int64(0, 26681), new $Int64(0, 22114)), new Pair.ptr(new $Int64(0, 26683), new $Int64(0, 20084)), new Pair.ptr(new $Int64(0, 26687), new $Int64(0, 2341)), new Pair.ptr(new $Int64(0, 26693), new $Int64(0, 17796)), new Pair.ptr(new $Int64(0, 26699), new $Int64(0, 2094)), new Pair.ptr(new $Int64(0, 26701), new $Int64(0, 26314)), new Pair.ptr(new $Int64(0, 26711), new $Int64(0, 26375)), new Pair.ptr(new $Int64(0, 26713), new $Int64(0, 15243)), new Pair.ptr(new $Int64(0, 26717), new $Int64(0, 11038)), new Pair.ptr(new $Int64(0, 26723), new $Int64(0, 15113)), new Pair.ptr(new $Int64(0, 26729), new $Int64(0, 9326)), new Pair.ptr(new $Int64(0, 26731), new $Int64(0, 9620)), new Pair.ptr(new $Int64(0, 26737), new $Int64(0, 16464)), new Pair.ptr(new $Int64(0, 26759), new $Int64(0, 17296)), new Pair.ptr(new $Int64(0, 26777), new $Int64(0, 20305)), new Pair.ptr(new $Int64(0, 26783), new $Int64(0, 7401)), new Pair.ptr(new $Int64(0, 26801), new $Int64(0, 15627)), new Pair.ptr(new $Int64(0, 26813), new $Int64(0, 6224)), new Pair.ptr(new $Int64(0, 26821), new $Int64(0, 817)), new Pair.ptr(new $Int64(0, 26833), new $Int64(0, 21048)), new Pair.ptr(new $Int64(0, 26839), new $Int64(0, 8455)), new Pair.ptr(new $Int64(0, 26849), new $Int64(0, 24281)), new Pair.ptr(new $Int64(0, 26861), new $Int64(0, 13475)), new Pair.ptr(new $Int64(0, 26863), new $Int64(0, 2199)), new Pair.ptr(new $Int64(0, 26879), new $Int64(0, 6579)), new Pair.ptr(new $Int64(0, 26881), new $Int64(0, 6955)), new Pair.ptr(new $Int64(0, 26891), new $Int64(0, 2872)), new Pair.ptr(new $Int64(0, 26893), new $Int64(0, 26025)), new Pair.ptr(new $Int64(0, 26903), new $Int64(0, 6601)), new Pair.ptr(new $Int64(0, 26921), new $Int64(0, 25594)), new Pair.ptr(new $Int64(0, 26927), new $Int64(0, 15032)), new Pair.ptr(new $Int64(0, 26947), new $Int64(0, 15604)), new Pair.ptr(new $Int64(0, 26951), new $Int64(0, 6392)), new Pair.ptr(new $Int64(0, 26953), new $Int64(0, 17911)), new Pair.ptr(new $Int64(0, 26959), new $Int64(0, 19912)), new Pair.ptr(new $Int64(0, 26981), new $Int64(0, 9546)), new Pair.ptr(new $Int64(0, 26987), new $Int64(0, 4942)), new Pair.ptr(new $Int64(0, 26993), new $Int64(0, 17605)), new Pair.ptr(new $Int64(0, 27011), new $Int64(0, 16080)), new Pair.ptr(new $Int64(0, 27017), new $Int64(0, 15062)), new Pair.ptr(new $Int64(0, 27031), new $Int64(0, 26862)), new Pair.ptr(new $Int64(0, 27043), new $Int64(0, 20409)), new Pair.ptr(new $Int64(0, 27059), new $Int64(0, 17990)), new Pair.ptr(new $Int64(0, 27061), new $Int64(0, 18883)), new Pair.ptr(new $Int64(0, 27067), new $Int64(0, 20757)), new Pair.ptr(new $Int64(0, 27073), new $Int64(0, 26970)), new Pair.ptr(new $Int64(0, 27077), new $Int64(0, 1584)), new Pair.ptr(new $Int64(0, 27091), new $Int64(0, 8667)), new Pair.ptr(new $Int64(0, 27103), new $Int64(0, 3058)), new Pair.ptr(new $Int64(0, 27107), new $Int64(0, 10055)), new Pair.ptr(new $Int64(0, 27109), new $Int64(0, 21993)), new Pair.ptr(new $Int64(0, 27127), new $Int64(0, 10627)), new Pair.ptr(new $Int64(0, 27143), new $Int64(0, 14876)), new Pair.ptr(new $Int64(0, 27179), new $Int64(0, 16142)), new Pair.ptr(new $Int64(0, 27191), new $Int64(0, 7291)), new Pair.ptr(new $Int64(0, 27197), new $Int64(0, 27185)), new Pair.ptr(new $Int64(0, 27211), new $Int64(0, 12049)), new Pair.ptr(new $Int64(0, 27239), new $Int64(0, 23484)), new Pair.ptr(new $Int64(0, 27241), new $Int64(0, 3211)), new Pair.ptr(new $Int64(0, 27253), new $Int64(0, 20901)), new Pair.ptr(new $Int64(0, 27259), new $Int64(0, 8492)), new Pair.ptr(new $Int64(0, 27271), new $Int64(0, 2009)), new Pair.ptr(new $Int64(0, 27277), new $Int64(0, 5229)), new Pair.ptr(new $Int64(0, 27281), new $Int64(0, 24083)), new Pair.ptr(new $Int64(0, 27283), new $Int64(0, 5763)), new Pair.ptr(new $Int64(0, 27299), new $Int64(0, 11168)), new Pair.ptr(new $Int64(0, 27329), new $Int64(0, 10409)), new Pair.ptr(new $Int64(0, 27337), new $Int64(0, 14676)), new Pair.ptr(new $Int64(0, 27361), new $Int64(0, 18696)), new Pair.ptr(new $Int64(0, 27367), new $Int64(0, 23598)), new Pair.ptr(new $Int64(0, 27397), new $Int64(0, 21838)), new Pair.ptr(new $Int64(0, 27407), new $Int64(0, 6648)), new Pair.ptr(new $Int64(0, 27409), new $Int64(0, 25043)), new Pair.ptr(new $Int64(0, 27427), new $Int64(0, 12457)), new Pair.ptr(new $Int64(0, 27431), new $Int64(0, 22948)), new Pair.ptr(new $Int64(0, 27437), new $Int64(0, 8293)), new Pair.ptr(new $Int64(0, 27449), new $Int64(0, 12100)), new Pair.ptr(new $Int64(0, 27457), new $Int64(0, 14905)), new Pair.ptr(new $Int64(0, 27479), new $Int64(0, 1263)), new Pair.ptr(new $Int64(0, 27481), new $Int64(0, 3706)), new Pair.ptr(new $Int64(0, 27487), new $Int64(0, 608)), new Pair.ptr(new $Int64(0, 27509), new $Int64(0, 8705)), new Pair.ptr(new $Int64(0, 27527), new $Int64(0, 12617)), new Pair.ptr(new $Int64(0, 27529), new $Int64(0, 13382)), new Pair.ptr(new $Int64(0, 27539), new $Int64(0, 10826)), new Pair.ptr(new $Int64(0, 27541), new $Int64(0, 14238)), new Pair.ptr(new $Int64(0, 27551), new $Int64(0, 7938)), new Pair.ptr(new $Int64(0, 27581), new $Int64(0, 9097)), new Pair.ptr(new $Int64(0, 27583), new $Int64(0, 14713)), new Pair.ptr(new $Int64(0, 27611), new $Int64(0, 9431)), new Pair.ptr(new $Int64(0, 27617), new $Int64(0, 27122)), new Pair.ptr(new $Int64(0, 27631), new $Int64(0, 22186)), new Pair.ptr(new $Int64(0, 27647), new $Int64(0, 24355)), new Pair.ptr(new $Int64(0, 27653), new $Int64(0, 16668)), new Pair.ptr(new $Int64(0, 27673), new $Int64(0, 17256)), new Pair.ptr(new $Int64(0, 27689), new $Int64(0, 18070)), new Pair.ptr(new $Int64(0, 27691), new $Int64(0, 11238)), new Pair.ptr(new $Int64(0, 27697), new $Int64(0, 25937)), new Pair.ptr(new $Int64(0, 27701), new $Int64(0, 6729)), new Pair.ptr(new $Int64(0, 27733), new $Int64(0, 4923)), new Pair.ptr(new $Int64(0, 27737), new $Int64(0, 251)), new Pair.ptr(new $Int64(0, 27739), new $Int64(0, 18867)), new Pair.ptr(new $Int64(0, 27743), new $Int64(0, 3897)), new Pair.ptr(new $Int64(0, 27749), new $Int64(0, 18622)), new Pair.ptr(new $Int64(0, 27751), new $Int64(0, 20314)), new Pair.ptr(new $Int64(0, 27763), new $Int64(0, 13658)), new Pair.ptr(new $Int64(0, 27767), new $Int64(0, 21132)), new Pair.ptr(new $Int64(0, 27773), new $Int64(0, 17212)), new Pair.ptr(new $Int64(0, 27779), new $Int64(0, 14306)), new Pair.ptr(new $Int64(0, 27791), new $Int64(0, 1927)), new Pair.ptr(new $Int64(0, 27793), new $Int64(0, 13999)), new Pair.ptr(new $Int64(0, 27799), new $Int64(0, 24226)), new Pair.ptr(new $Int64(0, 27803), new $Int64(0, 26695)), new Pair.ptr(new $Int64(0, 27809), new $Int64(0, 18315)), new Pair.ptr(new $Int64(0, 27817), new $Int64(0, 10015)), new Pair.ptr(new $Int64(0, 27823), new $Int64(0, 21901)), new Pair.ptr(new $Int64(0, 27827), new $Int64(0, 19885)), new Pair.ptr(new $Int64(0, 27847), new $Int64(0, 14303)), new Pair.ptr(new $Int64(0, 27851), new $Int64(0, 7621)), new Pair.ptr(new $Int64(0, 27883), new $Int64(0, 6224)), new Pair.ptr(new $Int64(0, 27893), new $Int64(0, 15503)), new Pair.ptr(new $Int64(0, 27901), new $Int64(0, 10494)), new Pair.ptr(new $Int64(0, 27917), new $Int64(0, 11980)), new Pair.ptr(new $Int64(0, 27919), new $Int64(0, 7317)), new Pair.ptr(new $Int64(0, 27941), new $Int64(0, 9774)), new Pair.ptr(new $Int64(0, 27943), new $Int64(0, 10969)), new Pair.ptr(new $Int64(0, 27947), new $Int64(0, 20920)), new Pair.ptr(new $Int64(0, 27953), new $Int64(0, 20884)), new Pair.ptr(new $Int64(0, 27961), new $Int64(0, 24525)), new Pair.ptr(new $Int64(0, 27967), new $Int64(0, 4111)), new Pair.ptr(new $Int64(0, 27983), new $Int64(0, 14945)), new Pair.ptr(new $Int64(0, 27997), new $Int64(0, 21645)), new Pair.ptr(new $Int64(0, 28001), new $Int64(0, 8746)), new Pair.ptr(new $Int64(0, 28019), new $Int64(0, 22519)), new Pair.ptr(new $Int64(0, 28027), new $Int64(0, 27093)), new Pair.ptr(new $Int64(0, 28031), new $Int64(0, 23982)), new Pair.ptr(new $Int64(0, 28051), new $Int64(0, 5163)), new Pair.ptr(new $Int64(0, 28057), new $Int64(0, 13577)), new Pair.ptr(new $Int64(0, 28069), new $Int64(0, 24258)), new Pair.ptr(new $Int64(0, 28081), new $Int64(0, 20787)), new Pair.ptr(new $Int64(0, 28087), new $Int64(0, 20010)), new Pair.ptr(new $Int64(0, 28097), new $Int64(0, 13587)), new Pair.ptr(new $Int64(0, 28099), new $Int64(0, 19168)), new Pair.ptr(new $Int64(0, 28109), new $Int64(0, 27681)), new Pair.ptr(new $Int64(0, 28111), new $Int64(0, 10917)), new Pair.ptr(new $Int64(0, 28123), new $Int64(0, 14397)), new Pair.ptr(new $Int64(0, 28151), new $Int64(0, 3105)), new Pair.ptr(new $Int64(0, 28163), new $Int64(0, 16265)), new Pair.ptr(new $Int64(0, 28181), new $Int64(0, 17234)), new Pair.ptr(new $Int64(0, 28183), new $Int64(0, 15934)), new Pair.ptr(new $Int64(0, 28201), new $Int64(0, 27750)), new Pair.ptr(new $Int64(0, 28211), new $Int64(0, 3633)), new Pair.ptr(new $Int64(0, 28219), new $Int64(0, 23112)), new Pair.ptr(new $Int64(0, 28229), new $Int64(0, 529)), new Pair.ptr(new $Int64(0, 28277), new $Int64(0, 6174)), new Pair.ptr(new $Int64(0, 28279), new $Int64(0, 13118)), new Pair.ptr(new $Int64(0, 28283), new $Int64(0, 14526)), new Pair.ptr(new $Int64(0, 28289), new $Int64(0, 27505)), new Pair.ptr(new $Int64(0, 28297), new $Int64(0, 23672)), new Pair.ptr(new $Int64(0, 28307), new $Int64(0, 1762)), new Pair.ptr(new $Int64(0, 28309), new $Int64(0, 6592)), new Pair.ptr(new $Int64(0, 28319), new $Int64(0, 20511)), new Pair.ptr(new $Int64(0, 28349), new $Int64(0, 1834)), new Pair.ptr(new $Int64(0, 28351), new $Int64(0, 26616)), new Pair.ptr(new $Int64(0, 28387), new $Int64(0, 23329)), new Pair.ptr(new $Int64(0, 28393), new $Int64(0, 516)), new Pair.ptr(new $Int64(0, 28403), new $Int64(0, 15070)), new Pair.ptr(new $Int64(0, 28409), new $Int64(0, 24216)), new Pair.ptr(new $Int64(0, 28411), new $Int64(0, 5655)), new Pair.ptr(new $Int64(0, 28429), new $Int64(0, 9318)), new Pair.ptr(new $Int64(0, 28433), new $Int64(0, 16215)), new Pair.ptr(new $Int64(0, 28439), new $Int64(0, 21365)), new Pair.ptr(new $Int64(0, 28447), new $Int64(0, 3329)), new Pair.ptr(new $Int64(0, 28463), new $Int64(0, 16225)), new Pair.ptr(new $Int64(0, 28477), new $Int64(0, 1334)), new Pair.ptr(new $Int64(0, 28493), new $Int64(0, 9802)), new Pair.ptr(new $Int64(0, 28499), new $Int64(0, 954)), new Pair.ptr(new $Int64(0, 28513), new $Int64(0, 8209)), new Pair.ptr(new $Int64(0, 28517), new $Int64(0, 9702)), new Pair.ptr(new $Int64(0, 28537), new $Int64(0, 6169)), new Pair.ptr(new $Int64(0, 28541), new $Int64(0, 4538)), new Pair.ptr(new $Int64(0, 28547), new $Int64(0, 11901)), new Pair.ptr(new $Int64(0, 28549), new $Int64(0, 27696)), new Pair.ptr(new $Int64(0, 28559), new $Int64(0, 18973)), new Pair.ptr(new $Int64(0, 28571), new $Int64(0, 19235)), new Pair.ptr(new $Int64(0, 28573), new $Int64(0, 3074)), new Pair.ptr(new $Int64(0, 28579), new $Int64(0, 7647)), new Pair.ptr(new $Int64(0, 28591), new $Int64(0, 26927)), new Pair.ptr(new $Int64(0, 28597), new $Int64(0, 454)), new Pair.ptr(new $Int64(0, 28603), new $Int64(0, 2270)), new Pair.ptr(new $Int64(0, 28607), new $Int64(0, 8368)), new Pair.ptr(new $Int64(0, 28619), new $Int64(0, 12337)), new Pair.ptr(new $Int64(0, 28621), new $Int64(0, 3245)), new Pair.ptr(new $Int64(0, 28627), new $Int64(0, 24184)), new Pair.ptr(new $Int64(0, 28631), new $Int64(0, 10995)), new Pair.ptr(new $Int64(0, 28643), new $Int64(0, 20491)), new Pair.ptr(new $Int64(0, 28649), new $Int64(0, 14060)), new Pair.ptr(new $Int64(0, 28657), new $Int64(0, 14125)), new Pair.ptr(new $Int64(0, 28661), new $Int64(0, 20763)), new Pair.ptr(new $Int64(0, 28663), new $Int64(0, 4723)), new Pair.ptr(new $Int64(0, 28669), new $Int64(0, 20280)), new Pair.ptr(new $Int64(0, 28687), new $Int64(0, 23160)), new Pair.ptr(new $Int64(0, 28697), new $Int64(0, 11383)), new Pair.ptr(new $Int64(0, 28703), new $Int64(0, 22068)), new Pair.ptr(new $Int64(0, 28711), new $Int64(0, 20902)), new Pair.ptr(new $Int64(0, 28723), new $Int64(0, 1390)), new Pair.ptr(new $Int64(0, 28729), new $Int64(0, 11411)), new Pair.ptr(new $Int64(0, 28751), new $Int64(0, 25632)), new Pair.ptr(new $Int64(0, 28753), new $Int64(0, 24019)), new Pair.ptr(new $Int64(0, 28759), new $Int64(0, 27045)), new Pair.ptr(new $Int64(0, 28771), new $Int64(0, 22081)), new Pair.ptr(new $Int64(0, 28789), new $Int64(0, 5237)), new Pair.ptr(new $Int64(0, 28793), new $Int64(0, 6209)), new Pair.ptr(new $Int64(0, 28807), new $Int64(0, 2220)), new Pair.ptr(new $Int64(0, 28813), new $Int64(0, 7878)), new Pair.ptr(new $Int64(0, 28817), new $Int64(0, 25105)), new Pair.ptr(new $Int64(0, 28837), new $Int64(0, 2532)), new Pair.ptr(new $Int64(0, 28843), new $Int64(0, 28193)), new Pair.ptr(new $Int64(0, 28859), new $Int64(0, 21176)), new Pair.ptr(new $Int64(0, 28867), new $Int64(0, 24877)), new Pair.ptr(new $Int64(0, 28871), new $Int64(0, 6732)), new Pair.ptr(new $Int64(0, 28879), new $Int64(0, 8261)), new Pair.ptr(new $Int64(0, 28901), new $Int64(0, 8262)), new Pair.ptr(new $Int64(0, 28909), new $Int64(0, 17504)), new Pair.ptr(new $Int64(0, 28921), new $Int64(0, 14128)), new Pair.ptr(new $Int64(0, 28927), new $Int64(0, 18181)), new Pair.ptr(new $Int64(0, 28933), new $Int64(0, 12073)), new Pair.ptr(new $Int64(0, 28949), new $Int64(0, 10491)), new Pair.ptr(new $Int64(0, 28961), new $Int64(0, 20908)), new Pair.ptr(new $Int64(0, 28979), new $Int64(0, 19556)), new Pair.ptr(new $Int64(0, 29009), new $Int64(0, 19569)), new Pair.ptr(new $Int64(0, 29017), new $Int64(0, 15375)), new Pair.ptr(new $Int64(0, 29021), new $Int64(0, 5774)), new Pair.ptr(new $Int64(0, 29023), new $Int64(0, 16003)), new Pair.ptr(new $Int64(0, 29027), new $Int64(0, 13667)), new Pair.ptr(new $Int64(0, 29033), new $Int64(0, 22561)), new Pair.ptr(new $Int64(0, 29059), new $Int64(0, 3479)), new Pair.ptr(new $Int64(0, 29063), new $Int64(0, 13983)), new Pair.ptr(new $Int64(0, 29077), new $Int64(0, 12807)), new Pair.ptr(new $Int64(0, 29101), new $Int64(0, 12021)), new Pair.ptr(new $Int64(0, 29123), new $Int64(0, 24122)), new Pair.ptr(new $Int64(0, 29129), new $Int64(0, 5100)), new Pair.ptr(new $Int64(0, 29131), new $Int64(0, 2568)), new Pair.ptr(new $Int64(0, 29137), new $Int64(0, 6648)), new Pair.ptr(new $Int64(0, 29147), new $Int64(0, 17305)), new Pair.ptr(new $Int64(0, 29153), new $Int64(0, 25887)), new Pair.ptr(new $Int64(0, 29167), new $Int64(0, 24917)), new Pair.ptr(new $Int64(0, 29173), new $Int64(0, 28756)), new Pair.ptr(new $Int64(0, 29179), new $Int64(0, 6729)), new Pair.ptr(new $Int64(0, 29191), new $Int64(0, 24955)), new Pair.ptr(new $Int64(0, 29201), new $Int64(0, 20527)), new Pair.ptr(new $Int64(0, 29207), new $Int64(0, 24212)), new Pair.ptr(new $Int64(0, 29209), new $Int64(0, 10522)), new Pair.ptr(new $Int64(0, 29221), new $Int64(0, 18376)), new Pair.ptr(new $Int64(0, 29231), new $Int64(0, 27228)), new Pair.ptr(new $Int64(0, 29243), new $Int64(0, 26354)), new Pair.ptr(new $Int64(0, 29251), new $Int64(0, 18709)), new Pair.ptr(new $Int64(0, 29269), new $Int64(0, 9798)), new Pair.ptr(new $Int64(0, 29287), new $Int64(0, 27799)), new Pair.ptr(new $Int64(0, 29297), new $Int64(0, 2548)), new Pair.ptr(new $Int64(0, 29303), new $Int64(0, 16294)), new Pair.ptr(new $Int64(0, 29311), new $Int64(0, 15746)), new Pair.ptr(new $Int64(0, 29327), new $Int64(0, 11274)), new Pair.ptr(new $Int64(0, 29333), new $Int64(0, 16655)), new Pair.ptr(new $Int64(0, 29339), new $Int64(0, 9394)), new Pair.ptr(new $Int64(0, 29347), new $Int64(0, 29014)), new Pair.ptr(new $Int64(0, 29363), new $Int64(0, 13702)), new Pair.ptr(new $Int64(0, 29383), new $Int64(0, 17405)), new Pair.ptr(new $Int64(0, 29387), new $Int64(0, 1154)), new Pair.ptr(new $Int64(0, 29389), new $Int64(0, 23784)), new Pair.ptr(new $Int64(0, 29399), new $Int64(0, 17064)), new Pair.ptr(new $Int64(0, 29401), new $Int64(0, 6579)), new Pair.ptr(new $Int64(0, 29411), new $Int64(0, 26382)), new Pair.ptr(new $Int64(0, 29423), new $Int64(0, 24297)), new Pair.ptr(new $Int64(0, 29429), new $Int64(0, 6990)), new Pair.ptr(new $Int64(0, 29437), new $Int64(0, 17759)), new Pair.ptr(new $Int64(0, 29443), new $Int64(0, 13455)), new Pair.ptr(new $Int64(0, 29453), new $Int64(0, 13310)), new Pair.ptr(new $Int64(0, 29473), new $Int64(0, 6601)), new Pair.ptr(new $Int64(0, 29483), new $Int64(0, 27071)), new Pair.ptr(new $Int64(0, 29501), new $Int64(0, 14151)), new Pair.ptr(new $Int64(0, 29527), new $Int64(0, 13927)), new Pair.ptr(new $Int64(0, 29531), new $Int64(0, 13863)), new Pair.ptr(new $Int64(0, 29537), new $Int64(0, 24729)), new Pair.ptr(new $Int64(0, 29567), new $Int64(0, 910)), new Pair.ptr(new $Int64(0, 29569), new $Int64(0, 8643)), new Pair.ptr(new $Int64(0, 29573), new $Int64(0, 28845)), new Pair.ptr(new $Int64(0, 29581), new $Int64(0, 19814)), new Pair.ptr(new $Int64(0, 29587), new $Int64(0, 551)), new Pair.ptr(new $Int64(0, 29599), new $Int64(0, 12104)), new Pair.ptr(new $Int64(0, 29611), new $Int64(0, 17756)), new Pair.ptr(new $Int64(0, 29629), new $Int64(0, 5597)), new Pair.ptr(new $Int64(0, 29633), new $Int64(0, 17373)), new Pair.ptr(new $Int64(0, 29641), new $Int64(0, 20402)), new Pair.ptr(new $Int64(0, 29663), new $Int64(0, 5678)), new Pair.ptr(new $Int64(0, 29669), new $Int64(0, 27676)), new Pair.ptr(new $Int64(0, 29671), new $Int64(0, 26551)), new Pair.ptr(new $Int64(0, 29683), new $Int64(0, 21749)), new Pair.ptr(new $Int64(0, 29717), new $Int64(0, 2065)), new Pair.ptr(new $Int64(0, 29723), new $Int64(0, 18710)), new Pair.ptr(new $Int64(0, 29741), new $Int64(0, 19733)), new Pair.ptr(new $Int64(0, 29753), new $Int64(0, 15333)), new Pair.ptr(new $Int64(0, 29759), new $Int64(0, 12546)), new Pair.ptr(new $Int64(0, 29761), new $Int64(0, 26193)), new Pair.ptr(new $Int64(0, 29789), new $Int64(0, 19128)), new Pair.ptr(new $Int64(0, 29803), new $Int64(0, 4628)), new Pair.ptr(new $Int64(0, 29819), new $Int64(0, 4275)), new Pair.ptr(new $Int64(0, 29833), new $Int64(0, 2688)), new Pair.ptr(new $Int64(0, 29837), new $Int64(0, 13102)), new Pair.ptr(new $Int64(0, 29851), new $Int64(0, 3377)), new Pair.ptr(new $Int64(0, 29863), new $Int64(0, 16675)), new Pair.ptr(new $Int64(0, 29867), new $Int64(0, 8841)), new Pair.ptr(new $Int64(0, 29873), new $Int64(0, 18409)), new Pair.ptr(new $Int64(0, 29879), new $Int64(0, 22805)), new Pair.ptr(new $Int64(0, 29881), new $Int64(0, 5164)), new Pair.ptr(new $Int64(0, 29917), new $Int64(0, 22173)), new Pair.ptr(new $Int64(0, 29921), new $Int64(0, 7343)), new Pair.ptr(new $Int64(0, 29927), new $Int64(0, 26513)), new Pair.ptr(new $Int64(0, 29947), new $Int64(0, 9832)), new Pair.ptr(new $Int64(0, 29959), new $Int64(0, 25001)), new Pair.ptr(new $Int64(0, 29983), new $Int64(0, 25039)), new Pair.ptr(new $Int64(0, 29989), new $Int64(0, 19566)), new Pair.ptr(new $Int64(0, 30011), new $Int64(0, 6713)), new Pair.ptr(new $Int64(0, 30013), new $Int64(0, 8386)), new Pair.ptr(new $Int64(0, 30029), new $Int64(0, 22522)), new Pair.ptr(new $Int64(0, 30047), new $Int64(0, 6628)), new Pair.ptr(new $Int64(0, 30059), new $Int64(0, 8033)), new Pair.ptr(new $Int64(0, 30071), new $Int64(0, 25487)), new Pair.ptr(new $Int64(0, 30089), new $Int64(0, 14917)), new Pair.ptr(new $Int64(0, 30091), new $Int64(0, 17142)), new Pair.ptr(new $Int64(0, 30097), new $Int64(0, 25268)), new Pair.ptr(new $Int64(0, 30103), new $Int64(0, 12268)), new Pair.ptr(new $Int64(0, 30109), new $Int64(0, 23344)), new Pair.ptr(new $Int64(0, 30113), new $Int64(0, 5170)), new Pair.ptr(new $Int64(0, 30119), new $Int64(0, 21574)), new Pair.ptr(new $Int64(0, 30133), new $Int64(0, 18504)), new Pair.ptr(new $Int64(0, 30137), new $Int64(0, 9365)), new Pair.ptr(new $Int64(0, 30139), new $Int64(0, 7673)), new Pair.ptr(new $Int64(0, 30161), new $Int64(0, 5353)), new Pair.ptr(new $Int64(0, 30169), new $Int64(0, 28921)), new Pair.ptr(new $Int64(0, 30181), new $Int64(0, 22236)), new Pair.ptr(new $Int64(0, 30187), new $Int64(0, 26678)), new Pair.ptr(new $Int64(0, 30197), new $Int64(0, 28434)), new Pair.ptr(new $Int64(0, 30203), new $Int64(0, 23176)), new Pair.ptr(new $Int64(0, 30211), new $Int64(0, 6134)), new Pair.ptr(new $Int64(0, 30223), new $Int64(0, 1840)), new Pair.ptr(new $Int64(0, 30241), new $Int64(0, 10785)), new Pair.ptr(new $Int64(0, 30253), new $Int64(0, 11294)), new Pair.ptr(new $Int64(0, 30259), new $Int64(0, 19523)), new Pair.ptr(new $Int64(0, 30269), new $Int64(0, 13963)), new Pair.ptr(new $Int64(0, 30271), new $Int64(0, 25969)), new Pair.ptr(new $Int64(0, 30293), new $Int64(0, 3945)), new Pair.ptr(new $Int64(0, 30307), new $Int64(0, 29842)), new Pair.ptr(new $Int64(0, 30313), new $Int64(0, 18236)), new Pair.ptr(new $Int64(0, 30319), new $Int64(0, 25362)), new Pair.ptr(new $Int64(0, 30323), new $Int64(0, 13635)), new Pair.ptr(new $Int64(0, 30341), new $Int64(0, 20707)), new Pair.ptr(new $Int64(0, 30347), new $Int64(0, 4284)), new Pair.ptr(new $Int64(0, 30367), new $Int64(0, 9439)), new Pair.ptr(new $Int64(0, 30389), new $Int64(0, 18390)), new Pair.ptr(new $Int64(0, 30391), new $Int64(0, 17237)), new Pair.ptr(new $Int64(0, 30403), new $Int64(0, 29323)), new Pair.ptr(new $Int64(0, 30427), new $Int64(0, 27802)), new Pair.ptr(new $Int64(0, 30431), new $Int64(0, 9467)), new Pair.ptr(new $Int64(0, 30449), new $Int64(0, 27415)), new Pair.ptr(new $Int64(0, 30467), new $Int64(0, 2353)), new Pair.ptr(new $Int64(0, 30469), new $Int64(0, 642)), new Pair.ptr(new $Int64(0, 30491), new $Int64(0, 6333)), new Pair.ptr(new $Int64(0, 30493), new $Int64(0, 14308)), new Pair.ptr(new $Int64(0, 30497), new $Int64(0, 25289)), new Pair.ptr(new $Int64(0, 30509), new $Int64(0, 12245)), new Pair.ptr(new $Int64(0, 30517), new $Int64(0, 6094)), new Pair.ptr(new $Int64(0, 30529), new $Int64(0, 933)), new Pair.ptr(new $Int64(0, 30539), new $Int64(0, 30524)), new Pair.ptr(new $Int64(0, 30553), new $Int64(0, 20578)), new Pair.ptr(new $Int64(0, 30557), new $Int64(0, 1696)), new Pair.ptr(new $Int64(0, 30559), new $Int64(0, 621)), new Pair.ptr(new $Int64(0, 30577), new $Int64(0, 17790)), new Pair.ptr(new $Int64(0, 30593), new $Int64(0, 22184)), new Pair.ptr(new $Int64(0, 30631), new $Int64(0, 8040)), new Pair.ptr(new $Int64(0, 30637), new $Int64(0, 20656)), new Pair.ptr(new $Int64(0, 30643), new $Int64(0, 2187)), new Pair.ptr(new $Int64(0, 30649), new $Int64(0, 18481)), new Pair.ptr(new $Int64(0, 30661), new $Int64(0, 28195)), new Pair.ptr(new $Int64(0, 30671), new $Int64(0, 21185)), new Pair.ptr(new $Int64(0, 30677), new $Int64(0, 27844)), new Pair.ptr(new $Int64(0, 30689), new $Int64(0, 18127)), new Pair.ptr(new $Int64(0, 30697), new $Int64(0, 1024)), new Pair.ptr(new $Int64(0, 30703), new $Int64(0, 25947)), new Pair.ptr(new $Int64(0, 30707), new $Int64(0, 28201)), new Pair.ptr(new $Int64(0, 30713), new $Int64(0, 15705)), new Pair.ptr(new $Int64(0, 30727), new $Int64(0, 28644)), new Pair.ptr(new $Int64(0, 30757), new $Int64(0, 29033)), new Pair.ptr(new $Int64(0, 30763), new $Int64(0, 12706)), new Pair.ptr(new $Int64(0, 30773), new $Int64(0, 16950)), new Pair.ptr(new $Int64(0, 30781), new $Int64(0, 16159)), new Pair.ptr(new $Int64(0, 30803), new $Int64(0, 28960)), new Pair.ptr(new $Int64(0, 30809), new $Int64(0, 26508)), new Pair.ptr(new $Int64(0, 30817), new $Int64(0, 18453)), new Pair.ptr(new $Int64(0, 30829), new $Int64(0, 17527)), new Pair.ptr(new $Int64(0, 30839), new $Int64(0, 26865)), new Pair.ptr(new $Int64(0, 30841), new $Int64(0, 14080)), new Pair.ptr(new $Int64(0, 30851), new $Int64(0, 4312)), new Pair.ptr(new $Int64(0, 30853), new $Int64(0, 20703)), new Pair.ptr(new $Int64(0, 30859), new $Int64(0, 24596)), new Pair.ptr(new $Int64(0, 30869), new $Int64(0, 19914)), new Pair.ptr(new $Int64(0, 30871), new $Int64(0, 1349)), new Pair.ptr(new $Int64(0, 30881), new $Int64(0, 8319)), new Pair.ptr(new $Int64(0, 30893), new $Int64(0, 19948)), new Pair.ptr(new $Int64(0, 30911), new $Int64(0, 18201)), new Pair.ptr(new $Int64(0, 30931), new $Int64(0, 10050)), new Pair.ptr(new $Int64(0, 30937), new $Int64(0, 20781)), new Pair.ptr(new $Int64(0, 30941), new $Int64(0, 8907)), new Pair.ptr(new $Int64(0, 30949), new $Int64(0, 21831)), new Pair.ptr(new $Int64(0, 30971), new $Int64(0, 28988)), new Pair.ptr(new $Int64(0, 30977), new $Int64(0, 1611)), new Pair.ptr(new $Int64(0, 30983), new $Int64(0, 1845)), new Pair.ptr(new $Int64(0, 31013), new $Int64(0, 20862)), new Pair.ptr(new $Int64(0, 31019), new $Int64(0, 9715)), new Pair.ptr(new $Int64(0, 31033), new $Int64(0, 905)), new Pair.ptr(new $Int64(0, 31039), new $Int64(0, 9344)), new Pair.ptr(new $Int64(0, 31051), new $Int64(0, 25630)), new Pair.ptr(new $Int64(0, 31063), new $Int64(0, 13404)), new Pair.ptr(new $Int64(0, 31069), new $Int64(0, 23840)), new Pair.ptr(new $Int64(0, 31079), new $Int64(0, 6955)), new Pair.ptr(new $Int64(0, 31081), new $Int64(0, 25647)), new Pair.ptr(new $Int64(0, 31091), new $Int64(0, 17018)), new Pair.ptr(new $Int64(0, 31121), new $Int64(0, 6083)), new Pair.ptr(new $Int64(0, 31123), new $Int64(0, 5517)), new Pair.ptr(new $Int64(0, 31139), new $Int64(0, 358)), new Pair.ptr(new $Int64(0, 31147), new $Int64(0, 28491)), new Pair.ptr(new $Int64(0, 31151), new $Int64(0, 27865)), new Pair.ptr(new $Int64(0, 31153), new $Int64(0, 5888)), new Pair.ptr(new $Int64(0, 31159), new $Int64(0, 6672)), new Pair.ptr(new $Int64(0, 31177), new $Int64(0, 14277)), new Pair.ptr(new $Int64(0, 31181), new $Int64(0, 6671)), new Pair.ptr(new $Int64(0, 31183), new $Int64(0, 11244)), new Pair.ptr(new $Int64(0, 31189), new $Int64(0, 8322)), new Pair.ptr(new $Int64(0, 31193), new $Int64(0, 19908)), new Pair.ptr(new $Int64(0, 31219), new $Int64(0, 6295)), new Pair.ptr(new $Int64(0, 31223), new $Int64(0, 12870)), new Pair.ptr(new $Int64(0, 31231), new $Int64(0, 21863)), new Pair.ptr(new $Int64(0, 31237), new $Int64(0, 21435)), new Pair.ptr(new $Int64(0, 31247), new $Int64(0, 7080)), new Pair.ptr(new $Int64(0, 31249), new $Int64(0, 4108)), new Pair.ptr(new $Int64(0, 31253), new $Int64(0, 13218)), new Pair.ptr(new $Int64(0, 31259), new $Int64(0, 10727)), new Pair.ptr(new $Int64(0, 31267), new $Int64(0, 8891)), new Pair.ptr(new $Int64(0, 31271), new $Int64(0, 9947)), new Pair.ptr(new $Int64(0, 31277), new $Int64(0, 18015)), new Pair.ptr(new $Int64(0, 31307), new $Int64(0, 20808)), new Pair.ptr(new $Int64(0, 31319), new $Int64(0, 20525)), new Pair.ptr(new $Int64(0, 31321), new $Int64(0, 3160)), new Pair.ptr(new $Int64(0, 31327), new $Int64(0, 11177)), new Pair.ptr(new $Int64(0, 31333), new $Int64(0, 4623)), new Pair.ptr(new $Int64(0, 31337), new $Int64(0, 14152)), new Pair.ptr(new $Int64(0, 31357), new $Int64(0, 22927)), new Pair.ptr(new $Int64(0, 31379), new $Int64(0, 11834)), new Pair.ptr(new $Int64(0, 31387), new $Int64(0, 20464)), new Pair.ptr(new $Int64(0, 31391), new $Int64(0, 24881)), new Pair.ptr(new $Int64(0, 31393), new $Int64(0, 15875)), new Pair.ptr(new $Int64(0, 31397), new $Int64(0, 10525)), new Pair.ptr(new $Int64(0, 31469), new $Int64(0, 17566)), new Pair.ptr(new $Int64(0, 31477), new $Int64(0, 2072)), new Pair.ptr(new $Int64(0, 31481), new $Int64(0, 7317)), new Pair.ptr(new $Int64(0, 31489), new $Int64(0, 26034)), new Pair.ptr(new $Int64(0, 31511), new $Int64(0, 16697)), new Pair.ptr(new $Int64(0, 31513), new $Int64(0, 2619)), new Pair.ptr(new $Int64(0, 31517), new $Int64(0, 1277)), new Pair.ptr(new $Int64(0, 31531), new $Int64(0, 7095)), new Pair.ptr(new $Int64(0, 31541), new $Int64(0, 16642)), new Pair.ptr(new $Int64(0, 31543), new $Int64(0, 5040)), new Pair.ptr(new $Int64(0, 31547), new $Int64(0, 6691)), new Pair.ptr(new $Int64(0, 31567), new $Int64(0, 4924)), new Pair.ptr(new $Int64(0, 31573), new $Int64(0, 10052)), new Pair.ptr(new $Int64(0, 31583), new $Int64(0, 14312)), new Pair.ptr(new $Int64(0, 31601), new $Int64(0, 12396)), new Pair.ptr(new $Int64(0, 31607), new $Int64(0, 9435)), new Pair.ptr(new $Int64(0, 31627), new $Int64(0, 29404)), new Pair.ptr(new $Int64(0, 31643), new $Int64(0, 14924)), new Pair.ptr(new $Int64(0, 31649), new $Int64(0, 9525)), new Pair.ptr(new $Int64(0, 31657), new $Int64(0, 30689)), new Pair.ptr(new $Int64(0, 31663), new $Int64(0, 15371)), new Pair.ptr(new $Int64(0, 31667), new $Int64(0, 15258)), new Pair.ptr(new $Int64(0, 31687), new $Int64(0, 6019)), new Pair.ptr(new $Int64(0, 31699), new $Int64(0, 660)), new Pair.ptr(new $Int64(0, 31721), new $Int64(0, 25404)), new Pair.ptr(new $Int64(0, 31723), new $Int64(0, 21881)), new Pair.ptr(new $Int64(0, 31727), new $Int64(0, 12989)), new Pair.ptr(new $Int64(0, 31729), new $Int64(0, 14758)), new Pair.ptr(new $Int64(0, 31741), new $Int64(0, 24622)), new Pair.ptr(new $Int64(0, 31751), new $Int64(0, 8482)), new Pair.ptr(new $Int64(0, 31769), new $Int64(0, 4864)), new Pair.ptr(new $Int64(0, 31771), new $Int64(0, 16766)), new Pair.ptr(new $Int64(0, 31793), new $Int64(0, 26135)), new Pair.ptr(new $Int64(0, 31799), new $Int64(0, 22555)), new Pair.ptr(new $Int64(0, 31817), new $Int64(0, 13447)), new Pair.ptr(new $Int64(0, 31847), new $Int64(0, 21151)), new Pair.ptr(new $Int64(0, 31849), new $Int64(0, 11823)), new Pair.ptr(new $Int64(0, 31859), new $Int64(0, 16439)), new Pair.ptr(new $Int64(0, 31873), new $Int64(0, 15863)), new Pair.ptr(new $Int64(0, 31883), new $Int64(0, 30485)), new Pair.ptr(new $Int64(0, 31891), new $Int64(0, 20748)), new Pair.ptr(new $Int64(0, 31907), new $Int64(0, 11963)), new Pair.ptr(new $Int64(0, 31957), new $Int64(0, 3636)), new Pair.ptr(new $Int64(0, 31963), new $Int64(0, 525)), new Pair.ptr(new $Int64(0, 31973), new $Int64(0, 25181)), new Pair.ptr(new $Int64(0, 31981), new $Int64(0, 25543)), new Pair.ptr(new $Int64(0, 31991), new $Int64(0, 20339)), new Pair.ptr(new $Int64(0, 32003), new $Int64(0, 515)), new Pair.ptr(new $Int64(0, 32009), new $Int64(0, 10113)), new Pair.ptr(new $Int64(0, 32027), new $Int64(0, 31173)), new Pair.ptr(new $Int64(0, 32029), new $Int64(0, 20641)), new Pair.ptr(new $Int64(0, 32051), new $Int64(0, 8322)), new Pair.ptr(new $Int64(0, 32057), new $Int64(0, 23252)), new Pair.ptr(new $Int64(0, 32059), new $Int64(0, 6016)), new Pair.ptr(new $Int64(0, 32063), new $Int64(0, 23306)), new Pair.ptr(new $Int64(0, 32069), new $Int64(0, 15370)), new Pair.ptr(new $Int64(0, 32077), new $Int64(0, 30984)), new Pair.ptr(new $Int64(0, 32083), new $Int64(0, 15014)), new Pair.ptr(new $Int64(0, 32089), new $Int64(0, 8482)), new Pair.ptr(new $Int64(0, 32099), new $Int64(0, 19994)), new Pair.ptr(new $Int64(0, 32117), new $Int64(0, 3451)), new Pair.ptr(new $Int64(0, 32119), new $Int64(0, 4824)), new Pair.ptr(new $Int64(0, 32141), new $Int64(0, 7647)), new Pair.ptr(new $Int64(0, 32143), new $Int64(0, 2278)), new Pair.ptr(new $Int64(0, 32159), new $Int64(0, 3984)), new Pair.ptr(new $Int64(0, 32173), new $Int64(0, 19821)), new Pair.ptr(new $Int64(0, 32183), new $Int64(0, 16738)), new Pair.ptr(new $Int64(0, 32189), new $Int64(0, 21473)), new Pair.ptr(new $Int64(0, 32191), new $Int64(0, 24754)), new Pair.ptr(new $Int64(0, 32203), new $Int64(0, 3553)), new Pair.ptr(new $Int64(0, 32213), new $Int64(0, 31774)), new Pair.ptr(new $Int64(0, 32233), new $Int64(0, 25316)), new Pair.ptr(new $Int64(0, 32237), new $Int64(0, 22980)), new Pair.ptr(new $Int64(0, 32251), new $Int64(0, 27136)), new Pair.ptr(new $Int64(0, 32257), new $Int64(0, 17414)), new Pair.ptr(new $Int64(0, 32261), new $Int64(0, 20277)), new Pair.ptr(new $Int64(0, 32297), new $Int64(0, 260)), new Pair.ptr(new $Int64(0, 32299), new $Int64(0, 20452)), new Pair.ptr(new $Int64(0, 32303), new $Int64(0, 27837)), new Pair.ptr(new $Int64(0, 32309), new $Int64(0, 24813)), new Pair.ptr(new $Int64(0, 32321), new $Int64(0, 26498)), new Pair.ptr(new $Int64(0, 32323), new $Int64(0, 15869)), new Pair.ptr(new $Int64(0, 32327), new $Int64(0, 10425)), new Pair.ptr(new $Int64(0, 32341), new $Int64(0, 18658)), new Pair.ptr(new $Int64(0, 32353), new $Int64(0, 26897)), new Pair.ptr(new $Int64(0, 32359), new $Int64(0, 8319)), new Pair.ptr(new $Int64(0, 32363), new $Int64(0, 18238)), new Pair.ptr(new $Int64(0, 32369), new $Int64(0, 3048)), new Pair.ptr(new $Int64(0, 32371), new $Int64(0, 27431)), new Pair.ptr(new $Int64(0, 32377), new $Int64(0, 21910)), new Pair.ptr(new $Int64(0, 32381), new $Int64(0, 29313)), new Pair.ptr(new $Int64(0, 32401), new $Int64(0, 25312)), new Pair.ptr(new $Int64(0, 32411), new $Int64(0, 20946)), new Pair.ptr(new $Int64(0, 32413), new $Int64(0, 20066)), new Pair.ptr(new $Int64(0, 32423), new $Int64(0, 2449)), new Pair.ptr(new $Int64(0, 32429), new $Int64(0, 22605)), new Pair.ptr(new $Int64(0, 32441), new $Int64(0, 7054)), new Pair.ptr(new $Int64(0, 32443), new $Int64(0, 16803)), new Pair.ptr(new $Int64(0, 32467), new $Int64(0, 30412)), new Pair.ptr(new $Int64(0, 32479), new $Int64(0, 5527)), new Pair.ptr(new $Int64(0, 32491), new $Int64(0, 30811)), new Pair.ptr(new $Int64(0, 32497), new $Int64(0, 23095)), new Pair.ptr(new $Int64(0, 32503), new $Int64(0, 26007)), new Pair.ptr(new $Int64(0, 32507), new $Int64(0, 29984)), new Pair.ptr(new $Int64(0, 32531), new $Int64(0, 452)), new Pair.ptr(new $Int64(0, 32533), new $Int64(0, 1355)), new Pair.ptr(new $Int64(0, 32537), new $Int64(0, 15214)), new Pair.ptr(new $Int64(0, 32561), new $Int64(0, 119)), new Pair.ptr(new $Int64(0, 32563), new $Int64(0, 14035)), new Pair.ptr(new $Int64(0, 32569), new $Int64(0, 27903)), new Pair.ptr(new $Int64(0, 32573), new $Int64(0, 15566)), new Pair.ptr(new $Int64(0, 32579), new $Int64(0, 11896)), new Pair.ptr(new $Int64(0, 32587), new $Int64(0, 26097)), new Pair.ptr(new $Int64(0, 32603), new $Int64(0, 31206)), new Pair.ptr(new $Int64(0, 32609), new $Int64(0, 27112)), new Pair.ptr(new $Int64(0, 32611), new $Int64(0, 1930)), new Pair.ptr(new $Int64(0, 32621), new $Int64(0, 13953)), new Pair.ptr(new $Int64(0, 32633), new $Int64(0, 1495)), new Pair.ptr(new $Int64(0, 32647), new $Int64(0, 2679)), new Pair.ptr(new $Int64(0, 32653), new $Int64(0, 8406)), new Pair.ptr(new $Int64(0, 32687), new $Int64(0, 31995)), new Pair.ptr(new $Int64(0, 32693), new $Int64(0, 20849)), new Pair.ptr(new $Int64(0, 32707), new $Int64(0, 4432)), new Pair.ptr(new $Int64(0, 32713), new $Int64(0, 5758)), new Pair.ptr(new $Int64(0, 32717), new $Int64(0, 4496)), new Pair.ptr(new $Int64(0, 32719), new $Int64(0, 23578)), new Pair.ptr(new $Int64(0, 32749), new $Int64(0, 7037)), new Pair.ptr(new $Int64(0, 32771), new $Int64(0, 4875)), new Pair.ptr(new $Int64(0, 32779), new $Int64(0, 20232)), new Pair.ptr(new $Int64(0, 32783), new $Int64(0, 10107)), new Pair.ptr(new $Int64(0, 32789), new $Int64(0, 13979)), new Pair.ptr(new $Int64(0, 32797), new $Int64(0, 19098)), new Pair.ptr(new $Int64(0, 32801), new $Int64(0, 6182)), new Pair.ptr(new $Int64(0, 32803), new $Int64(0, 22331)), new Pair.ptr(new $Int64(0, 32831), new $Int64(0, 18118)), new Pair.ptr(new $Int64(0, 32833), new $Int64(0, 18604)), new Pair.ptr(new $Int64(0, 32839), new $Int64(0, 30685)), new Pair.ptr(new $Int64(0, 32843), new $Int64(0, 7878)), new Pair.ptr(new $Int64(0, 32869), new $Int64(0, 7621)), new Pair.ptr(new $Int64(0, 32887), new $Int64(0, 13442)), new Pair.ptr(new $Int64(0, 32909), new $Int64(0, 13011)), new Pair.ptr(new $Int64(0, 32911), new $Int64(0, 2556)), new Pair.ptr(new $Int64(0, 32917), new $Int64(0, 31335)), new Pair.ptr(new $Int64(0, 32933), new $Int64(0, 3565)), new Pair.ptr(new $Int64(0, 32939), new $Int64(0, 14989)), new Pair.ptr(new $Int64(0, 32941), new $Int64(0, 2945)), new Pair.ptr(new $Int64(0, 32957), new $Int64(0, 12760)), new Pair.ptr(new $Int64(0, 32969), new $Int64(0, 5937)), new Pair.ptr(new $Int64(0, 32971), new $Int64(0, 17004)), new Pair.ptr(new $Int64(0, 32983), new $Int64(0, 14562)), new Pair.ptr(new $Int64(0, 32987), new $Int64(0, 16619)), new Pair.ptr(new $Int64(0, 32993), new $Int64(0, 24188)), new Pair.ptr(new $Int64(0, 32999), new $Int64(0, 26472)), new Pair.ptr(new $Int64(0, 33013), new $Int64(0, 14567)), new Pair.ptr(new $Int64(0, 33023), new $Int64(0, 3550)), new Pair.ptr(new $Int64(0, 33029), new $Int64(0, 16721)), new Pair.ptr(new $Int64(0, 33037), new $Int64(0, 4749)), new Pair.ptr(new $Int64(0, 33049), new $Int64(0, 29899)), new Pair.ptr(new $Int64(0, 33053), new $Int64(0, 20121)), new Pair.ptr(new $Int64(0, 33071), new $Int64(0, 24825)), new Pair.ptr(new $Int64(0, 33073), new $Int64(0, 10480)), new Pair.ptr(new $Int64(0, 33083), new $Int64(0, 20131)), new Pair.ptr(new $Int64(0, 33091), new $Int64(0, 4008)), new Pair.ptr(new $Int64(0, 33107), new $Int64(0, 27660)), new Pair.ptr(new $Int64(0, 33113), new $Int64(0, 30495)), new Pair.ptr(new $Int64(0, 33119), new $Int64(0, 25311)), new Pair.ptr(new $Int64(0, 33149), new $Int64(0, 23140)), new Pair.ptr(new $Int64(0, 33151), new $Int64(0, 11947)), new Pair.ptr(new $Int64(0, 33161), new $Int64(0, 6548)), new Pair.ptr(new $Int64(0, 33179), new $Int64(0, 8005)), new Pair.ptr(new $Int64(0, 33181), new $Int64(0, 8469)), new Pair.ptr(new $Int64(0, 33191), new $Int64(0, 8303)), new Pair.ptr(new $Int64(0, 33199), new $Int64(0, 33144)), new Pair.ptr(new $Int64(0, 33203), new $Int64(0, 18247)), new Pair.ptr(new $Int64(0, 33211), new $Int64(0, 19782)), new Pair.ptr(new $Int64(0, 33223), new $Int64(0, 26915)), new Pair.ptr(new $Int64(0, 33247), new $Int64(0, 8906)), new Pair.ptr(new $Int64(0, 33287), new $Int64(0, 1091)), new Pair.ptr(new $Int64(0, 33289), new $Int64(0, 12025)), new Pair.ptr(new $Int64(0, 33301), new $Int64(0, 28427)), new Pair.ptr(new $Int64(0, 33311), new $Int64(0, 19714)), new Pair.ptr(new $Int64(0, 33317), new $Int64(0, 14497)), new Pair.ptr(new $Int64(0, 33329), new $Int64(0, 4670)), new Pair.ptr(new $Int64(0, 33331), new $Int64(0, 5036)), new Pair.ptr(new $Int64(0, 33343), new $Int64(0, 2896)), new Pair.ptr(new $Int64(0, 33347), new $Int64(0, 30992)), new Pair.ptr(new $Int64(0, 33349), new $Int64(0, 17094)), new Pair.ptr(new $Int64(0, 33353), new $Int64(0, 29150)), new Pair.ptr(new $Int64(0, 33359), new $Int64(0, 17163)), new Pair.ptr(new $Int64(0, 33377), new $Int64(0, 24943)), new Pair.ptr(new $Int64(0, 33391), new $Int64(0, 26911)), new Pair.ptr(new $Int64(0, 33403), new $Int64(0, 11594)), new Pair.ptr(new $Int64(0, 33409), new $Int64(0, 20212)), new Pair.ptr(new $Int64(0, 33413), new $Int64(0, 26482)), new Pair.ptr(new $Int64(0, 33427), new $Int64(0, 6433)), new Pair.ptr(new $Int64(0, 33457), new $Int64(0, 27387)), new Pair.ptr(new $Int64(0, 33461), new $Int64(0, 24140)), new Pair.ptr(new $Int64(0, 33469), new $Int64(0, 6523)), new Pair.ptr(new $Int64(0, 33479), new $Int64(0, 28429)), new Pair.ptr(new $Int64(0, 33487), new $Int64(0, 9539)), new Pair.ptr(new $Int64(0, 33493), new $Int64(0, 19162)), new Pair.ptr(new $Int64(0, 33503), new $Int64(0, 20738)), new Pair.ptr(new $Int64(0, 33521), new $Int64(0, 10872)), new Pair.ptr(new $Int64(0, 33529), new $Int64(0, 6116)), new Pair.ptr(new $Int64(0, 33533), new $Int64(0, 280)), new Pair.ptr(new $Int64(0, 33547), new $Int64(0, 22375)), new Pair.ptr(new $Int64(0, 33563), new $Int64(0, 8386)), new Pair.ptr(new $Int64(0, 33569), new $Int64(0, 31532)), new Pair.ptr(new $Int64(0, 33577), new $Int64(0, 11485)), new Pair.ptr(new $Int64(0, 33581), new $Int64(0, 10036)), new Pair.ptr(new $Int64(0, 33587), new $Int64(0, 16116)), new Pair.ptr(new $Int64(0, 33589), new $Int64(0, 22955)), new Pair.ptr(new $Int64(0, 33599), new $Int64(0, 23966)), new Pair.ptr(new $Int64(0, 33601), new $Int64(0, 31251)), new Pair.ptr(new $Int64(0, 33613), new $Int64(0, 2676)), new Pair.ptr(new $Int64(0, 33617), new $Int64(0, 16525)), new Pair.ptr(new $Int64(0, 33619), new $Int64(0, 17224)), new Pair.ptr(new $Int64(0, 33623), new $Int64(0, 17890)), new Pair.ptr(new $Int64(0, 33629), new $Int64(0, 23979)), new Pair.ptr(new $Int64(0, 33637), new $Int64(0, 32054)), new Pair.ptr(new $Int64(0, 33641), new $Int64(0, 31277)), new Pair.ptr(new $Int64(0, 33647), new $Int64(0, 1607)), new Pair.ptr(new $Int64(0, 33679), new $Int64(0, 26053)), new Pair.ptr(new $Int64(0, 33703), new $Int64(0, 16395)), new Pair.ptr(new $Int64(0, 33713), new $Int64(0, 7371)), new Pair.ptr(new $Int64(0, 33721), new $Int64(0, 28196)), new Pair.ptr(new $Int64(0, 33739), new $Int64(0, 11050)), new Pair.ptr(new $Int64(0, 33749), new $Int64(0, 9803)), new Pair.ptr(new $Int64(0, 33751), new $Int64(0, 22447)), new Pair.ptr(new $Int64(0, 33757), new $Int64(0, 29774)), new Pair.ptr(new $Int64(0, 33767), new $Int64(0, 567)), new Pair.ptr(new $Int64(0, 33769), new $Int64(0, 21678)), new Pair.ptr(new $Int64(0, 33773), new $Int64(0, 10505)), new Pair.ptr(new $Int64(0, 33791), new $Int64(0, 15002)), new Pair.ptr(new $Int64(0, 33797), new $Int64(0, 7413)), new Pair.ptr(new $Int64(0, 33809), new $Int64(0, 3724)), new Pair.ptr(new $Int64(0, 33811), new $Int64(0, 30205)), new Pair.ptr(new $Int64(0, 33827), new $Int64(0, 31945)), new Pair.ptr(new $Int64(0, 33829), new $Int64(0, 31703)), new Pair.ptr(new $Int64(0, 33851), new $Int64(0, 12002)), new Pair.ptr(new $Int64(0, 33857), new $Int64(0, 14343)), new Pair.ptr(new $Int64(0, 33863), new $Int64(0, 31820)), new Pair.ptr(new $Int64(0, 33871), new $Int64(0, 2123)), new Pair.ptr(new $Int64(0, 33889), new $Int64(0, 12648)), new Pair.ptr(new $Int64(0, 33893), new $Int64(0, 14707)), new Pair.ptr(new $Int64(0, 33911), new $Int64(0, 12650)), new Pair.ptr(new $Int64(0, 33923), new $Int64(0, 33215)), new Pair.ptr(new $Int64(0, 33931), new $Int64(0, 22143)), new Pair.ptr(new $Int64(0, 33937), new $Int64(0, 30899)), new Pair.ptr(new $Int64(0, 33941), new $Int64(0, 7804)), new Pair.ptr(new $Int64(0, 33961), new $Int64(0, 29177)), new Pair.ptr(new $Int64(0, 33967), new $Int64(0, 921)), new Pair.ptr(new $Int64(0, 33997), new $Int64(0, 5804)), new Pair.ptr(new $Int64(0, 34019), new $Int64(0, 21054)), new Pair.ptr(new $Int64(0, 34031), new $Int64(0, 21364)), new Pair.ptr(new $Int64(0, 34033), new $Int64(0, 17584)), new Pair.ptr(new $Int64(0, 34039), new $Int64(0, 23033)), new Pair.ptr(new $Int64(0, 34057), new $Int64(0, 11377)), new Pair.ptr(new $Int64(0, 34061), new $Int64(0, 5824)), new Pair.ptr(new $Int64(0, 34123), new $Int64(0, 16480)), new Pair.ptr(new $Int64(0, 34127), new $Int64(0, 13767)), new Pair.ptr(new $Int64(0, 34129), new $Int64(0, 22591)), new Pair.ptr(new $Int64(0, 34141), new $Int64(0, 2643)), new Pair.ptr(new $Int64(0, 34147), new $Int64(0, 4286)), new Pair.ptr(new $Int64(0, 34157), new $Int64(0, 8891)), new Pair.ptr(new $Int64(0, 34159), new $Int64(0, 9396)), new Pair.ptr(new $Int64(0, 34171), new $Int64(0, 4685)), new Pair.ptr(new $Int64(0, 34183), new $Int64(0, 3208)), new Pair.ptr(new $Int64(0, 34211), new $Int64(0, 7174)), new Pair.ptr(new $Int64(0, 34213), new $Int64(0, 5253)), new Pair.ptr(new $Int64(0, 34217), new $Int64(0, 9539)), new Pair.ptr(new $Int64(0, 34231), new $Int64(0, 6044)), new Pair.ptr(new $Int64(0, 34253), new $Int64(0, 21399)), new Pair.ptr(new $Int64(0, 34259), new $Int64(0, 11072)), new Pair.ptr(new $Int64(0, 34261), new $Int64(0, 3816)), new Pair.ptr(new $Int64(0, 34267), new $Int64(0, 32235)), new Pair.ptr(new $Int64(0, 34273), new $Int64(0, 7813)), new Pair.ptr(new $Int64(0, 34283), new $Int64(0, 26341)), new Pair.ptr(new $Int64(0, 34297), new $Int64(0, 17042)), new Pair.ptr(new $Int64(0, 34301), new $Int64(0, 21148)), new Pair.ptr(new $Int64(0, 34303), new $Int64(0, 13260)), new Pair.ptr(new $Int64(0, 34313), new $Int64(0, 21008)), new Pair.ptr(new $Int64(0, 34319), new $Int64(0, 4903)), new Pair.ptr(new $Int64(0, 34327), new $Int64(0, 28022)), new Pair.ptr(new $Int64(0, 34337), new $Int64(0, 6348)), new Pair.ptr(new $Int64(0, 34351), new $Int64(0, 31185)), new Pair.ptr(new $Int64(0, 34361), new $Int64(0, 8261)), new Pair.ptr(new $Int64(0, 34367), new $Int64(0, 21623)), new Pair.ptr(new $Int64(0, 34369), new $Int64(0, 501)), new Pair.ptr(new $Int64(0, 34381), new $Int64(0, 18358)), new Pair.ptr(new $Int64(0, 34403), new $Int64(0, 19422)), new Pair.ptr(new $Int64(0, 34421), new $Int64(0, 20156)), new Pair.ptr(new $Int64(0, 34429), new $Int64(0, 12454)), new Pair.ptr(new $Int64(0, 34439), new $Int64(0, 24806)), new Pair.ptr(new $Int64(0, 34457), new $Int64(0, 16456)), new Pair.ptr(new $Int64(0, 34469), new $Int64(0, 24819)), new Pair.ptr(new $Int64(0, 34471), new $Int64(0, 29090)), new Pair.ptr(new $Int64(0, 34483), new $Int64(0, 20581)), new Pair.ptr(new $Int64(0, 34487), new $Int64(0, 11535)), new Pair.ptr(new $Int64(0, 34499), new $Int64(0, 17043)), new Pair.ptr(new $Int64(0, 34501), new $Int64(0, 20559)), new Pair.ptr(new $Int64(0, 34511), new $Int64(0, 6737)), new Pair.ptr(new $Int64(0, 34513), new $Int64(0, 5799)), new Pair.ptr(new $Int64(0, 34519), new $Int64(0, 15116)), new Pair.ptr(new $Int64(0, 34537), new $Int64(0, 13642)), new Pair.ptr(new $Int64(0, 34543), new $Int64(0, 26466)), new Pair.ptr(new $Int64(0, 34549), new $Int64(0, 21057)), new Pair.ptr(new $Int64(0, 34583), new $Int64(0, 8209)), new Pair.ptr(new $Int64(0, 34589), new $Int64(0, 20206)), new Pair.ptr(new $Int64(0, 34591), new $Int64(0, 1477)), new Pair.ptr(new $Int64(0, 34603), new $Int64(0, 19581)), new Pair.ptr(new $Int64(0, 34607), new $Int64(0, 31558)), new Pair.ptr(new $Int64(0, 34613), new $Int64(0, 29162)), new Pair.ptr(new $Int64(0, 34631), new $Int64(0, 22398)), new Pair.ptr(new $Int64(0, 34649), new $Int64(0, 29985)), new Pair.ptr(new $Int64(0, 34651), new $Int64(0, 5997)), new Pair.ptr(new $Int64(0, 34667), new $Int64(0, 30314)), new Pair.ptr(new $Int64(0, 34673), new $Int64(0, 18873)), new Pair.ptr(new $Int64(0, 34679), new $Int64(0, 34610)), new Pair.ptr(new $Int64(0, 34687), new $Int64(0, 9465)), new Pair.ptr(new $Int64(0, 34693), new $Int64(0, 12397)), new Pair.ptr(new $Int64(0, 34703), new $Int64(0, 32852)), new Pair.ptr(new $Int64(0, 34721), new $Int64(0, 24442)), new Pair.ptr(new $Int64(0, 34729), new $Int64(0, 6890)), new Pair.ptr(new $Int64(0, 34739), new $Int64(0, 10186)), new Pair.ptr(new $Int64(0, 34747), new $Int64(0, 34561)), new Pair.ptr(new $Int64(0, 34757), new $Int64(0, 1443)), new Pair.ptr(new $Int64(0, 34759), new $Int64(0, 34250)), new Pair.ptr(new $Int64(0, 34763), new $Int64(0, 30391)), new Pair.ptr(new $Int64(0, 34781), new $Int64(0, 20888)), new Pair.ptr(new $Int64(0, 34807), new $Int64(0, 10680)), new Pair.ptr(new $Int64(0, 34819), new $Int64(0, 14743)), new Pair.ptr(new $Int64(0, 34841), new $Int64(0, 31975)), new Pair.ptr(new $Int64(0, 34843), new $Int64(0, 22223)), new Pair.ptr(new $Int64(0, 34847), new $Int64(0, 15624)), new Pair.ptr(new $Int64(0, 34849), new $Int64(0, 4442)), new Pair.ptr(new $Int64(0, 34871), new $Int64(0, 7504)), new Pair.ptr(new $Int64(0, 34877), new $Int64(0, 13364)), new Pair.ptr(new $Int64(0, 34883), new $Int64(0, 24049)), new Pair.ptr(new $Int64(0, 34897), new $Int64(0, 432)), new Pair.ptr(new $Int64(0, 34913), new $Int64(0, 30060)), new Pair.ptr(new $Int64(0, 34919), new $Int64(0, 25675)), new Pair.ptr(new $Int64(0, 34939), new $Int64(0, 19820)), new Pair.ptr(new $Int64(0, 34949), new $Int64(0, 23384)), new Pair.ptr(new $Int64(0, 34961), new $Int64(0, 27894)), new Pair.ptr(new $Int64(0, 34963), new $Int64(0, 29844)), new Pair.ptr(new $Int64(0, 34981), new $Int64(0, 28638)), new Pair.ptr(new $Int64(0, 35023), new $Int64(0, 2797)), new Pair.ptr(new $Int64(0, 35027), new $Int64(0, 12223)), new Pair.ptr(new $Int64(0, 35051), new $Int64(0, 31126)), new Pair.ptr(new $Int64(0, 35053), new $Int64(0, 13226)), new Pair.ptr(new $Int64(0, 35059), new $Int64(0, 9556)), new Pair.ptr(new $Int64(0, 35069), new $Int64(0, 22133)), new Pair.ptr(new $Int64(0, 35081), new $Int64(0, 4544)), new Pair.ptr(new $Int64(0, 35083), new $Int64(0, 34748)), new Pair.ptr(new $Int64(0, 35089), new $Int64(0, 20983)), new Pair.ptr(new $Int64(0, 35099), new $Int64(0, 8889)), new Pair.ptr(new $Int64(0, 35107), new $Int64(0, 19768)), new Pair.ptr(new $Int64(0, 35111), new $Int64(0, 8643)), new Pair.ptr(new $Int64(0, 35117), new $Int64(0, 33172)), new Pair.ptr(new $Int64(0, 35129), new $Int64(0, 34366)), new Pair.ptr(new $Int64(0, 35141), new $Int64(0, 18717)), new Pair.ptr(new $Int64(0, 35149), new $Int64(0, 26760)), new Pair.ptr(new $Int64(0, 35153), new $Int64(0, 5052)), new Pair.ptr(new $Int64(0, 35159), new $Int64(0, 1335)), new Pair.ptr(new $Int64(0, 35171), new $Int64(0, 13243)), new Pair.ptr(new $Int64(0, 35201), new $Int64(0, 34556)), new Pair.ptr(new $Int64(0, 35221), new $Int64(0, 10186)), new Pair.ptr(new $Int64(0, 35227), new $Int64(0, 27437)), new Pair.ptr(new $Int64(0, 35251), new $Int64(0, 35013)), new Pair.ptr(new $Int64(0, 35257), new $Int64(0, 27839)), new Pair.ptr(new $Int64(0, 35267), new $Int64(0, 15689)), new Pair.ptr(new $Int64(0, 35279), new $Int64(0, 247)), new Pair.ptr(new $Int64(0, 35281), new $Int64(0, 12089)), new Pair.ptr(new $Int64(0, 35291), new $Int64(0, 12160)), new Pair.ptr(new $Int64(0, 35311), new $Int64(0, 15230)), new Pair.ptr(new $Int64(0, 35317), new $Int64(0, 24270)), new Pair.ptr(new $Int64(0, 35323), new $Int64(0, 14907)), new Pair.ptr(new $Int64(0, 35327), new $Int64(0, 12063)), new Pair.ptr(new $Int64(0, 35339), new $Int64(0, 25366)), new Pair.ptr(new $Int64(0, 35353), new $Int64(0, 19043)), new Pair.ptr(new $Int64(0, 35363), new $Int64(0, 7246)), new Pair.ptr(new $Int64(0, 35381), new $Int64(0, 23157)), new Pair.ptr(new $Int64(0, 35393), new $Int64(0, 20856)), new Pair.ptr(new $Int64(0, 35401), new $Int64(0, 3607)), new Pair.ptr(new $Int64(0, 35407), new $Int64(0, 13234)), new Pair.ptr(new $Int64(0, 35419), new $Int64(0, 8628)), new Pair.ptr(new $Int64(0, 35423), new $Int64(0, 34666)), new Pair.ptr(new $Int64(0, 35437), new $Int64(0, 775)), new Pair.ptr(new $Int64(0, 35447), new $Int64(0, 7288)), new Pair.ptr(new $Int64(0, 35449), new $Int64(0, 21517)), new Pair.ptr(new $Int64(0, 35461), new $Int64(0, 6642)), new Pair.ptr(new $Int64(0, 35491), new $Int64(0, 5646)), new Pair.ptr(new $Int64(0, 35507), new $Int64(0, 22358)), new Pair.ptr(new $Int64(0, 35509), new $Int64(0, 21110)), new Pair.ptr(new $Int64(0, 35521), new $Int64(0, 28672)), new Pair.ptr(new $Int64(0, 35527), new $Int64(0, 23110)), new Pair.ptr(new $Int64(0, 35531), new $Int64(0, 5889)), new Pair.ptr(new $Int64(0, 35533), new $Int64(0, 770)), new Pair.ptr(new $Int64(0, 35537), new $Int64(0, 22013)), new Pair.ptr(new $Int64(0, 35543), new $Int64(0, 13763)), new Pair.ptr(new $Int64(0, 35569), new $Int64(0, 29194)), new Pair.ptr(new $Int64(0, 35573), new $Int64(0, 20660)), new Pair.ptr(new $Int64(0, 35591), new $Int64(0, 23730)), new Pair.ptr(new $Int64(0, 35593), new $Int64(0, 20239)), new Pair.ptr(new $Int64(0, 35597), new $Int64(0, 22388)), new Pair.ptr(new $Int64(0, 35603), new $Int64(0, 25399)), new Pair.ptr(new $Int64(0, 35617), new $Int64(0, 26700)), new Pair.ptr(new $Int64(0, 35671), new $Int64(0, 8864)), new Pair.ptr(new $Int64(0, 35677), new $Int64(0, 1600)), new Pair.ptr(new $Int64(0, 35729), new $Int64(0, 27850)), new Pair.ptr(new $Int64(0, 35731), new $Int64(0, 6291)), new Pair.ptr(new $Int64(0, 35747), new $Int64(0, 29080)), new Pair.ptr(new $Int64(0, 35753), new $Int64(0, 16032)), new Pair.ptr(new $Int64(0, 35759), new $Int64(0, 23792)), new Pair.ptr(new $Int64(0, 35771), new $Int64(0, 22367)), new Pair.ptr(new $Int64(0, 35797), new $Int64(0, 6755)), new Pair.ptr(new $Int64(0, 35801), new $Int64(0, 22806)), new Pair.ptr(new $Int64(0, 35803), new $Int64(0, 17041)), new Pair.ptr(new $Int64(0, 35809), new $Int64(0, 10932)), new Pair.ptr(new $Int64(0, 35831), new $Int64(0, 32982)), new Pair.ptr(new $Int64(0, 35837), new $Int64(0, 6321)), new Pair.ptr(new $Int64(0, 35839), new $Int64(0, 8605)), new Pair.ptr(new $Int64(0, 35851), new $Int64(0, 15445)), new Pair.ptr(new $Int64(0, 35863), new $Int64(0, 10137)), new Pair.ptr(new $Int64(0, 35869), new $Int64(0, 25409)), new Pair.ptr(new $Int64(0, 35879), new $Int64(0, 27492)), new Pair.ptr(new $Int64(0, 35897), new $Int64(0, 24818)), new Pair.ptr(new $Int64(0, 35899), new $Int64(0, 10036)), new Pair.ptr(new $Int64(0, 35911), new $Int64(0, 5085)), new Pair.ptr(new $Int64(0, 35923), new $Int64(0, 10459)), new Pair.ptr(new $Int64(0, 35933), new $Int64(0, 15664)), new Pair.ptr(new $Int64(0, 35951), new $Int64(0, 18906)), new Pair.ptr(new $Int64(0, 35963), new $Int64(0, 23105)), new Pair.ptr(new $Int64(0, 35969), new $Int64(0, 29151)), new Pair.ptr(new $Int64(0, 35977), new $Int64(0, 5549)), new Pair.ptr(new $Int64(0, 35983), new $Int64(0, 18942)), new Pair.ptr(new $Int64(0, 35993), new $Int64(0, 12472)), new Pair.ptr(new $Int64(0, 35999), new $Int64(0, 34345)), new Pair.ptr(new $Int64(0, 36007), new $Int64(0, 13782)), new Pair.ptr(new $Int64(0, 36011), new $Int64(0, 32698)), new Pair.ptr(new $Int64(0, 36013), new $Int64(0, 2975)), new Pair.ptr(new $Int64(0, 36017), new $Int64(0, 13459)), new Pair.ptr(new $Int64(0, 36037), new $Int64(0, 32433)), new Pair.ptr(new $Int64(0, 36061), new $Int64(0, 17742)), new Pair.ptr(new $Int64(0, 36067), new $Int64(0, 3374)), new Pair.ptr(new $Int64(0, 36073), new $Int64(0, 8872)), new Pair.ptr(new $Int64(0, 36083), new $Int64(0, 7754)), new Pair.ptr(new $Int64(0, 36097), new $Int64(0, 25978)), new Pair.ptr(new $Int64(0, 36107), new $Int64(0, 29445)), new Pair.ptr(new $Int64(0, 36109), new $Int64(0, 20132)), new Pair.ptr(new $Int64(0, 36131), new $Int64(0, 23314)), new Pair.ptr(new $Int64(0, 36137), new $Int64(0, 27872)), new Pair.ptr(new $Int64(0, 36151), new $Int64(0, 9525)), new Pair.ptr(new $Int64(0, 36161), new $Int64(0, 9344)), new Pair.ptr(new $Int64(0, 36187), new $Int64(0, 32089)), new Pair.ptr(new $Int64(0, 36191), new $Int64(0, 25287)), new Pair.ptr(new $Int64(0, 36209), new $Int64(0, 33216)), new Pair.ptr(new $Int64(0, 36217), new $Int64(0, 12786)), new Pair.ptr(new $Int64(0, 36229), new $Int64(0, 7640)), new Pair.ptr(new $Int64(0, 36241), new $Int64(0, 17378)), new Pair.ptr(new $Int64(0, 36251), new $Int64(0, 7638)), new Pair.ptr(new $Int64(0, 36263), new $Int64(0, 32445)), new Pair.ptr(new $Int64(0, 36269), new $Int64(0, 26260)), new Pair.ptr(new $Int64(0, 36277), new $Int64(0, 286)), new Pair.ptr(new $Int64(0, 36293), new $Int64(0, 14842)), new Pair.ptr(new $Int64(0, 36299), new $Int64(0, 10172)), new Pair.ptr(new $Int64(0, 36307), new $Int64(0, 8293)), new Pair.ptr(new $Int64(0, 36313), new $Int64(0, 19415)), new Pair.ptr(new $Int64(0, 36319), new $Int64(0, 27297)), new Pair.ptr(new $Int64(0, 36341), new $Int64(0, 8138)), new Pair.ptr(new $Int64(0, 36343), new $Int64(0, 15283)), new Pair.ptr(new $Int64(0, 36353), new $Int64(0, 25126)), new Pair.ptr(new $Int64(0, 36373), new $Int64(0, 31311)), new Pair.ptr(new $Int64(0, 36383), new $Int64(0, 11544)), new Pair.ptr(new $Int64(0, 36389), new $Int64(0, 26565)), new Pair.ptr(new $Int64(0, 36433), new $Int64(0, 16895)), new Pair.ptr(new $Int64(0, 36451), new $Int64(0, 32964)), new Pair.ptr(new $Int64(0, 36457), new $Int64(0, 12288)), new Pair.ptr(new $Int64(0, 36467), new $Int64(0, 8791)), new Pair.ptr(new $Int64(0, 36469), new $Int64(0, 17746)), new Pair.ptr(new $Int64(0, 36473), new $Int64(0, 22877)), new Pair.ptr(new $Int64(0, 36479), new $Int64(0, 23032)), new Pair.ptr(new $Int64(0, 36493), new $Int64(0, 2723)), new Pair.ptr(new $Int64(0, 36497), new $Int64(0, 13055)), new Pair.ptr(new $Int64(0, 36523), new $Int64(0, 27381)), new Pair.ptr(new $Int64(0, 36527), new $Int64(0, 3861)), new Pair.ptr(new $Int64(0, 36529), new $Int64(0, 29690)), new Pair.ptr(new $Int64(0, 36541), new $Int64(0, 8560)), new Pair.ptr(new $Int64(0, 36551), new $Int64(0, 21668)), new Pair.ptr(new $Int64(0, 36559), new $Int64(0, 30107)), new Pair.ptr(new $Int64(0, 36563), new $Int64(0, 22139)), new Pair.ptr(new $Int64(0, 36571), new $Int64(0, 3370)), new Pair.ptr(new $Int64(0, 36583), new $Int64(0, 4822)), new Pair.ptr(new $Int64(0, 36587), new $Int64(0, 14668)), new Pair.ptr(new $Int64(0, 36599), new $Int64(0, 32029)), new Pair.ptr(new $Int64(0, 36607), new $Int64(0, 11854)), new Pair.ptr(new $Int64(0, 36629), new $Int64(0, 1711)), new Pair.ptr(new $Int64(0, 36637), new $Int64(0, 15112)), new Pair.ptr(new $Int64(0, 36643), new $Int64(0, 8216)), new Pair.ptr(new $Int64(0, 36653), new $Int64(0, 35055)), new Pair.ptr(new $Int64(0, 36671), new $Int64(0, 10932)), new Pair.ptr(new $Int64(0, 36677), new $Int64(0, 30835)), new Pair.ptr(new $Int64(0, 36683), new $Int64(0, 16788)), new Pair.ptr(new $Int64(0, 36691), new $Int64(0, 27353)), new Pair.ptr(new $Int64(0, 36697), new $Int64(0, 161)), new Pair.ptr(new $Int64(0, 36709), new $Int64(0, 36529)), new Pair.ptr(new $Int64(0, 36713), new $Int64(0, 17196)), new Pair.ptr(new $Int64(0, 36721), new $Int64(0, 33199)), new Pair.ptr(new $Int64(0, 36739), new $Int64(0, 9757)), new Pair.ptr(new $Int64(0, 36749), new $Int64(0, 28590)), new Pair.ptr(new $Int64(0, 36761), new $Int64(0, 35610)), new Pair.ptr(new $Int64(0, 36767), new $Int64(0, 2711)), new Pair.ptr(new $Int64(0, 36779), new $Int64(0, 25775)), new Pair.ptr(new $Int64(0, 36781), new $Int64(0, 2039)), new Pair.ptr(new $Int64(0, 36787), new $Int64(0, 24830)), new Pair.ptr(new $Int64(0, 36791), new $Int64(0, 2110)), new Pair.ptr(new $Int64(0, 36793), new $Int64(0, 7101)), new Pair.ptr(new $Int64(0, 36809), new $Int64(0, 3319)), new Pair.ptr(new $Int64(0, 36821), new $Int64(0, 14977)), new Pair.ptr(new $Int64(0, 36833), new $Int64(0, 3748)), new Pair.ptr(new $Int64(0, 36847), new $Int64(0, 22349)), new Pair.ptr(new $Int64(0, 36857), new $Int64(0, 10680)), new Pair.ptr(new $Int64(0, 36871), new $Int64(0, 15424)), new Pair.ptr(new $Int64(0, 36877), new $Int64(0, 7143)), new Pair.ptr(new $Int64(0, 36887), new $Int64(0, 15470)), new Pair.ptr(new $Int64(0, 36899), new $Int64(0, 29361)), new Pair.ptr(new $Int64(0, 36901), new $Int64(0, 866)), new Pair.ptr(new $Int64(0, 36913), new $Int64(0, 5981)), new Pair.ptr(new $Int64(0, 36919), new $Int64(0, 2078)), new Pair.ptr(new $Int64(0, 36923), new $Int64(0, 16197)), new Pair.ptr(new $Int64(0, 36929), new $Int64(0, 15578)), new Pair.ptr(new $Int64(0, 36931), new $Int64(0, 32033)), new Pair.ptr(new $Int64(0, 36943), new $Int64(0, 8191)), new Pair.ptr(new $Int64(0, 36947), new $Int64(0, 16178)), new Pair.ptr(new $Int64(0, 36973), new $Int64(0, 35004)), new Pair.ptr(new $Int64(0, 36979), new $Int64(0, 10929)), new Pair.ptr(new $Int64(0, 36997), new $Int64(0, 3692)), new Pair.ptr(new $Int64(0, 37003), new $Int64(0, 21050)), new Pair.ptr(new $Int64(0, 37013), new $Int64(0, 34327)), new Pair.ptr(new $Int64(0, 37019), new $Int64(0, 30455)), new Pair.ptr(new $Int64(0, 37021), new $Int64(0, 18954)), new Pair.ptr(new $Int64(0, 37039), new $Int64(0, 6636)), new Pair.ptr(new $Int64(0, 37049), new $Int64(0, 4451)), new Pair.ptr(new $Int64(0, 37057), new $Int64(0, 36146)), new Pair.ptr(new $Int64(0, 37061), new $Int64(0, 9484)), new Pair.ptr(new $Int64(0, 37087), new $Int64(0, 36166)), new Pair.ptr(new $Int64(0, 37097), new $Int64(0, 25870)), new Pair.ptr(new $Int64(0, 37117), new $Int64(0, 10675)), new Pair.ptr(new $Int64(0, 37123), new $Int64(0, 19709)), new Pair.ptr(new $Int64(0, 37139), new $Int64(0, 798)), new Pair.ptr(new $Int64(0, 37159), new $Int64(0, 12597)), new Pair.ptr(new $Int64(0, 37171), new $Int64(0, 11112)), new Pair.ptr(new $Int64(0, 37181), new $Int64(0, 4426)), new Pair.ptr(new $Int64(0, 37189), new $Int64(0, 18988)), new Pair.ptr(new $Int64(0, 37199), new $Int64(0, 29321)), new Pair.ptr(new $Int64(0, 37201), new $Int64(0, 6875)), new Pair.ptr(new $Int64(0, 37217), new $Int64(0, 18369)), new Pair.ptr(new $Int64(0, 37223), new $Int64(0, 2700)), new Pair.ptr(new $Int64(0, 37243), new $Int64(0, 8797)), new Pair.ptr(new $Int64(0, 37253), new $Int64(0, 28930)), new Pair.ptr(new $Int64(0, 37273), new $Int64(0, 31099)), new Pair.ptr(new $Int64(0, 37277), new $Int64(0, 17449)), new Pair.ptr(new $Int64(0, 37307), new $Int64(0, 26473)), new Pair.ptr(new $Int64(0, 37309), new $Int64(0, 12154)), new Pair.ptr(new $Int64(0, 37313), new $Int64(0, 8009)), new Pair.ptr(new $Int64(0, 37321), new $Int64(0, 7531)), new Pair.ptr(new $Int64(0, 37337), new $Int64(0, 9439)), new Pair.ptr(new $Int64(0, 37339), new $Int64(0, 11110)), new Pair.ptr(new $Int64(0, 37357), new $Int64(0, 8990)), new Pair.ptr(new $Int64(0, 37361), new $Int64(0, 26711)), new Pair.ptr(new $Int64(0, 37363), new $Int64(0, 10505)), new Pair.ptr(new $Int64(0, 37369), new $Int64(0, 9467)), new Pair.ptr(new $Int64(0, 37379), new $Int64(0, 31498)), new Pair.ptr(new $Int64(0, 37397), new $Int64(0, 35251)), new Pair.ptr(new $Int64(0, 37409), new $Int64(0, 5877)), new Pair.ptr(new $Int64(0, 37423), new $Int64(0, 12522)), new Pair.ptr(new $Int64(0, 37441), new $Int64(0, 28202)), new Pair.ptr(new $Int64(0, 37447), new $Int64(0, 8198)), new Pair.ptr(new $Int64(0, 37463), new $Int64(0, 36363)), new Pair.ptr(new $Int64(0, 37483), new $Int64(0, 23083)), new Pair.ptr(new $Int64(0, 37489), new $Int64(0, 36088)), new Pair.ptr(new $Int64(0, 37493), new $Int64(0, 35334)), new Pair.ptr(new $Int64(0, 37501), new $Int64(0, 20998)), new Pair.ptr(new $Int64(0, 37507), new $Int64(0, 36969)), new Pair.ptr(new $Int64(0, 37511), new $Int64(0, 21675)), new Pair.ptr(new $Int64(0, 37517), new $Int64(0, 25507)), new Pair.ptr(new $Int64(0, 37529), new $Int64(0, 16281)), new Pair.ptr(new $Int64(0, 37537), new $Int64(0, 14077)), new Pair.ptr(new $Int64(0, 37547), new $Int64(0, 25443)), new Pair.ptr(new $Int64(0, 37549), new $Int64(0, 11632)), new Pair.ptr(new $Int64(0, 37561), new $Int64(0, 7692)), new Pair.ptr(new $Int64(0, 37567), new $Int64(0, 23161)), new Pair.ptr(new $Int64(0, 37571), new $Int64(0, 30211)), new Pair.ptr(new $Int64(0, 37573), new $Int64(0, 26526)), new Pair.ptr(new $Int64(0, 37579), new $Int64(0, 17601)), new Pair.ptr(new $Int64(0, 37589), new $Int64(0, 22672)), new Pair.ptr(new $Int64(0, 37591), new $Int64(0, 9266)), new Pair.ptr(new $Int64(0, 37607), new $Int64(0, 20393)), new Pair.ptr(new $Int64(0, 37619), new $Int64(0, 20050)), new Pair.ptr(new $Int64(0, 37633), new $Int64(0, 18053)), new Pair.ptr(new $Int64(0, 37643), new $Int64(0, 31555)), new Pair.ptr(new $Int64(0, 37649), new $Int64(0, 23404)), new Pair.ptr(new $Int64(0, 37657), new $Int64(0, 30035)), new Pair.ptr(new $Int64(0, 37663), new $Int64(0, 19563)), new Pair.ptr(new $Int64(0, 37691), new $Int64(0, 32642)), new Pair.ptr(new $Int64(0, 37693), new $Int64(0, 27891)), new Pair.ptr(new $Int64(0, 37699), new $Int64(0, 21461)), new Pair.ptr(new $Int64(0, 37717), new $Int64(0, 22076)), new Pair.ptr(new $Int64(0, 37747), new $Int64(0, 34943)), new Pair.ptr(new $Int64(0, 37781), new $Int64(0, 29257)), new Pair.ptr(new $Int64(0, 37783), new $Int64(0, 20267)), new Pair.ptr(new $Int64(0, 37799), new $Int64(0, 36742)), new Pair.ptr(new $Int64(0, 37811), new $Int64(0, 10913)), new Pair.ptr(new $Int64(0, 37813), new $Int64(0, 33155)), new Pair.ptr(new $Int64(0, 37831), new $Int64(0, 26899)), new Pair.ptr(new $Int64(0, 37847), new $Int64(0, 31450)), new Pair.ptr(new $Int64(0, 37853), new $Int64(0, 8106)), new Pair.ptr(new $Int64(0, 37861), new $Int64(0, 7205)), new Pair.ptr(new $Int64(0, 37871), new $Int64(0, 26196)), new Pair.ptr(new $Int64(0, 37879), new $Int64(0, 24534)), new Pair.ptr(new $Int64(0, 37889), new $Int64(0, 4022)), new Pair.ptr(new $Int64(0, 37897), new $Int64(0, 30340)), new Pair.ptr(new $Int64(0, 37907), new $Int64(0, 17280)), new Pair.ptr(new $Int64(0, 37951), new $Int64(0, 10113)), new Pair.ptr(new $Int64(0, 37957), new $Int64(0, 25250)), new Pair.ptr(new $Int64(0, 37963), new $Int64(0, 25199)), new Pair.ptr(new $Int64(0, 37967), new $Int64(0, 36746)), new Pair.ptr(new $Int64(0, 37987), new $Int64(0, 36038)), new Pair.ptr(new $Int64(0, 37991), new $Int64(0, 36792)), new Pair.ptr(new $Int64(0, 37993), new $Int64(0, 17125)), new Pair.ptr(new $Int64(0, 37997), new $Int64(0, 29857)), new Pair.ptr(new $Int64(0, 38011), new $Int64(0, 8705)), new Pair.ptr(new $Int64(0, 38039), new $Int64(0, 25993)), new Pair.ptr(new $Int64(0, 38047), new $Int64(0, 32199)), new Pair.ptr(new $Int64(0, 38053), new $Int64(0, 22113)), new Pair.ptr(new $Int64(0, 38069), new $Int64(0, 33382)), new Pair.ptr(new $Int64(0, 38083), new $Int64(0, 19648)), new Pair.ptr(new $Int64(0, 38113), new $Int64(0, 11544)), new Pair.ptr(new $Int64(0, 38119), new $Int64(0, 34362)), new Pair.ptr(new $Int64(0, 38149), new $Int64(0, 8426)), new Pair.ptr(new $Int64(0, 38153), new $Int64(0, 1786)), new Pair.ptr(new $Int64(0, 38167), new $Int64(0, 3437)), new Pair.ptr(new $Int64(0, 38177), new $Int64(0, 3511)), new Pair.ptr(new $Int64(0, 38183), new $Int64(0, 31569)), new Pair.ptr(new $Int64(0, 38189), new $Int64(0, 25590)), new Pair.ptr(new $Int64(0, 38197), new $Int64(0, 35102)), new Pair.ptr(new $Int64(0, 38201), new $Int64(0, 12886)), new Pair.ptr(new $Int64(0, 38219), new $Int64(0, 5212)), new Pair.ptr(new $Int64(0, 38231), new $Int64(0, 7425)), new Pair.ptr(new $Int64(0, 38237), new $Int64(0, 23208)), new Pair.ptr(new $Int64(0, 38239), new $Int64(0, 35769)), new Pair.ptr(new $Int64(0, 38261), new $Int64(0, 19385)), new Pair.ptr(new $Int64(0, 38273), new $Int64(0, 20909)), new Pair.ptr(new $Int64(0, 38281), new $Int64(0, 36598)), new Pair.ptr(new $Int64(0, 38287), new $Int64(0, 5169)), new Pair.ptr(new $Int64(0, 38299), new $Int64(0, 34046)), new Pair.ptr(new $Int64(0, 38303), new $Int64(0, 21375)), new Pair.ptr(new $Int64(0, 38317), new $Int64(0, 37509)), new Pair.ptr(new $Int64(0, 38321), new $Int64(0, 28163)), new Pair.ptr(new $Int64(0, 38327), new $Int64(0, 37171)), new Pair.ptr(new $Int64(0, 38329), new $Int64(0, 24567)), new Pair.ptr(new $Int64(0, 38333), new $Int64(0, 33445)), new Pair.ptr(new $Int64(0, 38351), new $Int64(0, 21624)), new Pair.ptr(new $Int64(0, 38371), new $Int64(0, 15189)), new Pair.ptr(new $Int64(0, 38377), new $Int64(0, 38277)), new Pair.ptr(new $Int64(0, 38393), new $Int64(0, 16372)), new Pair.ptr(new $Int64(0, 38431), new $Int64(0, 18073)), new Pair.ptr(new $Int64(0, 38447), new $Int64(0, 14127)), new Pair.ptr(new $Int64(0, 38449), new $Int64(0, 25681)), new Pair.ptr(new $Int64(0, 38453), new $Int64(0, 26443)), new Pair.ptr(new $Int64(0, 38459), new $Int64(0, 4630)), new Pair.ptr(new $Int64(0, 38461), new $Int64(0, 9394)), new Pair.ptr(new $Int64(0, 38501), new $Int64(0, 23199)), new Pair.ptr(new $Int64(0, 38543), new $Int64(0, 678)), new Pair.ptr(new $Int64(0, 38557), new $Int64(0, 12861)), new Pair.ptr(new $Int64(0, 38561), new $Int64(0, 31113)), new Pair.ptr(new $Int64(0, 38567), new $Int64(0, 5926)), new Pair.ptr(new $Int64(0, 38569), new $Int64(0, 22409)), new Pair.ptr(new $Int64(0, 38593), new $Int64(0, 13540)), new Pair.ptr(new $Int64(0, 38603), new $Int64(0, 197)), new Pair.ptr(new $Int64(0, 38609), new $Int64(0, 4137)), new Pair.ptr(new $Int64(0, 38611), new $Int64(0, 26200)), new Pair.ptr(new $Int64(0, 38629), new $Int64(0, 13433)), new Pair.ptr(new $Int64(0, 38639), new $Int64(0, 7566)), new Pair.ptr(new $Int64(0, 38651), new $Int64(0, 7912)), new Pair.ptr(new $Int64(0, 38653), new $Int64(0, 24431)), new Pair.ptr(new $Int64(0, 38669), new $Int64(0, 32981)), new Pair.ptr(new $Int64(0, 38671), new $Int64(0, 24792)), new Pair.ptr(new $Int64(0, 38677), new $Int64(0, 35234)), new Pair.ptr(new $Int64(0, 38693), new $Int64(0, 20462)), new Pair.ptr(new $Int64(0, 38699), new $Int64(0, 30484)), new Pair.ptr(new $Int64(0, 38707), new $Int64(0, 12128)), new Pair.ptr(new $Int64(0, 38711), new $Int64(0, 37876)), new Pair.ptr(new $Int64(0, 38713), new $Int64(0, 26538)), new Pair.ptr(new $Int64(0, 38723), new $Int64(0, 26619)), new Pair.ptr(new $Int64(0, 38729), new $Int64(0, 4382)), new Pair.ptr(new $Int64(0, 38737), new $Int64(0, 10425)), new Pair.ptr(new $Int64(0, 38747), new $Int64(0, 17121)), new Pair.ptr(new $Int64(0, 38749), new $Int64(0, 12236)), new Pair.ptr(new $Int64(0, 38767), new $Int64(0, 9339)), new Pair.ptr(new $Int64(0, 38783), new $Int64(0, 32530)), new Pair.ptr(new $Int64(0, 38791), new $Int64(0, 21730)), new Pair.ptr(new $Int64(0, 38803), new $Int64(0, 5134)), new Pair.ptr(new $Int64(0, 38821), new $Int64(0, 11072)), new Pair.ptr(new $Int64(0, 38833), new $Int64(0, 28366)), new Pair.ptr(new $Int64(0, 38839), new $Int64(0, 27833)), new Pair.ptr(new $Int64(0, 38851), new $Int64(0, 8354)), new Pair.ptr(new $Int64(0, 38861), new $Int64(0, 31258)), new Pair.ptr(new $Int64(0, 38867), new $Int64(0, 36161)), new Pair.ptr(new $Int64(0, 38873), new $Int64(0, 7839)), new Pair.ptr(new $Int64(0, 38891), new $Int64(0, 5630)), new Pair.ptr(new $Int64(0, 38903), new $Int64(0, 31387)), new Pair.ptr(new $Int64(0, 38917), new $Int64(0, 8860)), new Pair.ptr(new $Int64(0, 38921), new $Int64(0, 1542)), new Pair.ptr(new $Int64(0, 38923), new $Int64(0, 19537)), new Pair.ptr(new $Int64(0, 38933), new $Int64(0, 25334)), new Pair.ptr(new $Int64(0, 38953), new $Int64(0, 16974)), new Pair.ptr(new $Int64(0, 38959), new $Int64(0, 10872)), new Pair.ptr(new $Int64(0, 38971), new $Int64(0, 24887)), new Pair.ptr(new $Int64(0, 38977), new $Int64(0, 25948)), new Pair.ptr(new $Int64(0, 38993), new $Int64(0, 2098)), new Pair.ptr(new $Int64(0, 39019), new $Int64(0, 23070)), new Pair.ptr(new $Int64(0, 39023), new $Int64(0, 11524)), new Pair.ptr(new $Int64(0, 39041), new $Int64(0, 6344)), new Pair.ptr(new $Int64(0, 39043), new $Int64(0, 27086)), new Pair.ptr(new $Int64(0, 39047), new $Int64(0, 16961)), new Pair.ptr(new $Int64(0, 39079), new $Int64(0, 18245)), new Pair.ptr(new $Int64(0, 39089), new $Int64(0, 29649)), new Pair.ptr(new $Int64(0, 39097), new $Int64(0, 10600)), new Pair.ptr(new $Int64(0, 39103), new $Int64(0, 779)), new Pair.ptr(new $Int64(0, 39107), new $Int64(0, 35642)), new Pair.ptr(new $Int64(0, 39113), new $Int64(0, 15077)), new Pair.ptr(new $Int64(0, 39119), new $Int64(0, 2775)), new Pair.ptr(new $Int64(0, 39133), new $Int64(0, 29152)), new Pair.ptr(new $Int64(0, 39139), new $Int64(0, 3591)), new Pair.ptr(new $Int64(0, 39157), new $Int64(0, 19985)), new Pair.ptr(new $Int64(0, 39161), new $Int64(0, 12623)), new Pair.ptr(new $Int64(0, 39163), new $Int64(0, 31512)), new Pair.ptr(new $Int64(0, 39181), new $Int64(0, 9609)), new Pair.ptr(new $Int64(0, 39191), new $Int64(0, 19357)), new Pair.ptr(new $Int64(0, 39199), new $Int64(0, 14620)), new Pair.ptr(new $Int64(0, 39209), new $Int64(0, 27429)), new Pair.ptr(new $Int64(0, 39217), new $Int64(0, 29242)), new Pair.ptr(new $Int64(0, 39227), new $Int64(0, 13140)), new Pair.ptr(new $Int64(0, 39229), new $Int64(0, 37665)), new Pair.ptr(new $Int64(0, 39233), new $Int64(0, 10420)), new Pair.ptr(new $Int64(0, 39239), new $Int64(0, 24853)), new Pair.ptr(new $Int64(0, 39241), new $Int64(0, 33282)), new Pair.ptr(new $Int64(0, 39251), new $Int64(0, 29915)), new Pair.ptr(new $Int64(0, 39293), new $Int64(0, 22899)), new Pair.ptr(new $Int64(0, 39301), new $Int64(0, 9874)), new Pair.ptr(new $Int64(0, 39313), new $Int64(0, 18584)), new Pair.ptr(new $Int64(0, 39317), new $Int64(0, 29166)), new Pair.ptr(new $Int64(0, 39323), new $Int64(0, 38738)), new Pair.ptr(new $Int64(0, 39341), new $Int64(0, 11050)), new Pair.ptr(new $Int64(0, 39343), new $Int64(0, 19060)), new Pair.ptr(new $Int64(0, 39359), new $Int64(0, 944)), new Pair.ptr(new $Int64(0, 39367), new $Int64(0, 22501)), new Pair.ptr(new $Int64(0, 39371), new $Int64(0, 9318)), new Pair.ptr(new $Int64(0, 39373), new $Int64(0, 15092)), new Pair.ptr(new $Int64(0, 39383), new $Int64(0, 11709)), new Pair.ptr(new $Int64(0, 39397), new $Int64(0, 37661)), new Pair.ptr(new $Int64(0, 39409), new $Int64(0, 19590)), new Pair.ptr(new $Int64(0, 39419), new $Int64(0, 37155)), new Pair.ptr(new $Int64(0, 39439), new $Int64(0, 6081)), new Pair.ptr(new $Int64(0, 39443), new $Int64(0, 21164)), new Pair.ptr(new $Int64(0, 39451), new $Int64(0, 38357)), new Pair.ptr(new $Int64(0, 39461), new $Int64(0, 13449)), new Pair.ptr(new $Int64(0, 39499), new $Int64(0, 28523)), new Pair.ptr(new $Int64(0, 39503), new $Int64(0, 13560)), new Pair.ptr(new $Int64(0, 39509), new $Int64(0, 30382)), new Pair.ptr(new $Int64(0, 39511), new $Int64(0, 15660)), new Pair.ptr(new $Int64(0, 39521), new $Int64(0, 8554)), new Pair.ptr(new $Int64(0, 39541), new $Int64(0, 15267)), new Pair.ptr(new $Int64(0, 39551), new $Int64(0, 11593)), new Pair.ptr(new $Int64(0, 39563), new $Int64(0, 39093)), new Pair.ptr(new $Int64(0, 39569), new $Int64(0, 15822)), new Pair.ptr(new $Int64(0, 39581), new $Int64(0, 17879)), new Pair.ptr(new $Int64(0, 39607), new $Int64(0, 3171)), new Pair.ptr(new $Int64(0, 39619), new $Int64(0, 9097)), new Pair.ptr(new $Int64(0, 39623), new $Int64(0, 1647)), new Pair.ptr(new $Int64(0, 39631), new $Int64(0, 7235)), new Pair.ptr(new $Int64(0, 39659), new $Int64(0, 23039)), new Pair.ptr(new $Int64(0, 39667), new $Int64(0, 17937)), new Pair.ptr(new $Int64(0, 39671), new $Int64(0, 24548)), new Pair.ptr(new $Int64(0, 39679), new $Int64(0, 33707)), new Pair.ptr(new $Int64(0, 39703), new $Int64(0, 4202)), new Pair.ptr(new $Int64(0, 39709), new $Int64(0, 25273)), new Pair.ptr(new $Int64(0, 39719), new $Int64(0, 14642)), new Pair.ptr(new $Int64(0, 39727), new $Int64(0, 39177)), new Pair.ptr(new $Int64(0, 39733), new $Int64(0, 21700)), new Pair.ptr(new $Int64(0, 39749), new $Int64(0, 28184)), new Pair.ptr(new $Int64(0, 39761), new $Int64(0, 22707)), new Pair.ptr(new $Int64(0, 39769), new $Int64(0, 13452)), new Pair.ptr(new $Int64(0, 39779), new $Int64(0, 18340)), new Pair.ptr(new $Int64(0, 39791), new $Int64(0, 16513)), new Pair.ptr(new $Int64(0, 39799), new $Int64(0, 22239)), new Pair.ptr(new $Int64(0, 39821), new $Int64(0, 22244)), new Pair.ptr(new $Int64(0, 39827), new $Int64(0, 23248)), new Pair.ptr(new $Int64(0, 39829), new $Int64(0, 2391)), new Pair.ptr(new $Int64(0, 39839), new $Int64(0, 16517)), new Pair.ptr(new $Int64(0, 39841), new $Int64(0, 37572)), new Pair.ptr(new $Int64(0, 39847), new $Int64(0, 14177)), new Pair.ptr(new $Int64(0, 39857), new $Int64(0, 20110)), new Pair.ptr(new $Int64(0, 39863), new $Int64(0, 38812)), new Pair.ptr(new $Int64(0, 39869), new $Int64(0, 3575)), new Pair.ptr(new $Int64(0, 39877), new $Int64(0, 8481)), new Pair.ptr(new $Int64(0, 39883), new $Int64(0, 21254)), new Pair.ptr(new $Int64(0, 39887), new $Int64(0, 869)), new Pair.ptr(new $Int64(0, 39901), new $Int64(0, 18276)), new Pair.ptr(new $Int64(0, 39929), new $Int64(0, 5156)), new Pair.ptr(new $Int64(0, 39937), new $Int64(0, 32053)), new Pair.ptr(new $Int64(0, 39953), new $Int64(0, 1990)), new Pair.ptr(new $Int64(0, 39971), new $Int64(0, 5986)), new Pair.ptr(new $Int64(0, 39979), new $Int64(0, 33862)), new Pair.ptr(new $Int64(0, 39983), new $Int64(0, 37411)), new Pair.ptr(new $Int64(0, 39989), new $Int64(0, 29273)), new Pair.ptr(new $Int64(0, 40009), new $Int64(0, 18929)), new Pair.ptr(new $Int64(0, 40013), new $Int64(0, 494)), new Pair.ptr(new $Int64(0, 40031), new $Int64(0, 28170)), new Pair.ptr(new $Int64(0, 40037), new $Int64(0, 31140)), new Pair.ptr(new $Int64(0, 40039), new $Int64(0, 26693)), new Pair.ptr(new $Int64(0, 40063), new $Int64(0, 35418)), new Pair.ptr(new $Int64(0, 40087), new $Int64(0, 23313)), new Pair.ptr(new $Int64(0, 40093), new $Int64(0, 17651)), new Pair.ptr(new $Int64(0, 40099), new $Int64(0, 16538)), new Pair.ptr(new $Int64(0, 40111), new $Int64(0, 23351)), new Pair.ptr(new $Int64(0, 40123), new $Int64(0, 3545)), new Pair.ptr(new $Int64(0, 40127), new $Int64(0, 11377)), new Pair.ptr(new $Int64(0, 40129), new $Int64(0, 25400)), new Pair.ptr(new $Int64(0, 40151), new $Int64(0, 8199)), new Pair.ptr(new $Int64(0, 40153), new $Int64(0, 27124)), new Pair.ptr(new $Int64(0, 40163), new $Int64(0, 32544)), new Pair.ptr(new $Int64(0, 40169), new $Int64(0, 35083)), new Pair.ptr(new $Int64(0, 40177), new $Int64(0, 11535)), new Pair.ptr(new $Int64(0, 40189), new $Int64(0, 9800)), new Pair.ptr(new $Int64(0, 40193), new $Int64(0, 12522)), new Pair.ptr(new $Int64(0, 40213), new $Int64(0, 27506)), new Pair.ptr(new $Int64(0, 40231), new $Int64(0, 28927)), new Pair.ptr(new $Int64(0, 40237), new $Int64(0, 13140)), new Pair.ptr(new $Int64(0, 40241), new $Int64(0, 36971)), new Pair.ptr(new $Int64(0, 40253), new $Int64(0, 30174)), new Pair.ptr(new $Int64(0, 40277), new $Int64(0, 22716)), new Pair.ptr(new $Int64(0, 40283), new $Int64(0, 29784)), new Pair.ptr(new $Int64(0, 40289), new $Int64(0, 36999)), new Pair.ptr(new $Int64(0, 40343), new $Int64(0, 29647)), new Pair.ptr(new $Int64(0, 40351), new $Int64(0, 24176)), new Pair.ptr(new $Int64(0, 40357), new $Int64(0, 2334)), new Pair.ptr(new $Int64(0, 40361), new $Int64(0, 38936)), new Pair.ptr(new $Int64(0, 40387), new $Int64(0, 27623)), new Pair.ptr(new $Int64(0, 40423), new $Int64(0, 36342)), new Pair.ptr(new $Int64(0, 40427), new $Int64(0, 29737)), new Pair.ptr(new $Int64(0, 40429), new $Int64(0, 29447)), new Pair.ptr(new $Int64(0, 40433), new $Int64(0, 10254)), new Pair.ptr(new $Int64(0, 40459), new $Int64(0, 33056)), new Pair.ptr(new $Int64(0, 40471), new $Int64(0, 313)), new Pair.ptr(new $Int64(0, 40483), new $Int64(0, 16114)), new Pair.ptr(new $Int64(0, 40487), new $Int64(0, 12288)), new Pair.ptr(new $Int64(0, 40493), new $Int64(0, 35815)), new Pair.ptr(new $Int64(0, 40499), new $Int64(0, 35705)), new Pair.ptr(new $Int64(0, 40507), new $Int64(0, 30214)), new Pair.ptr(new $Int64(0, 40519), new $Int64(0, 12886)), new Pair.ptr(new $Int64(0, 40529), new $Int64(0, 1630)), new Pair.ptr(new $Int64(0, 40531), new $Int64(0, 35358)), new Pair.ptr(new $Int64(0, 40543), new $Int64(0, 38313)), new Pair.ptr(new $Int64(0, 40559), new $Int64(0, 4741)), new Pair.ptr(new $Int64(0, 40577), new $Int64(0, 40174)), new Pair.ptr(new $Int64(0, 40583), new $Int64(0, 15147)), new Pair.ptr(new $Int64(0, 40591), new $Int64(0, 6802)), new Pair.ptr(new $Int64(0, 40597), new $Int64(0, 7823)), new Pair.ptr(new $Int64(0, 40609), new $Int64(0, 29071)), new Pair.ptr(new $Int64(0, 40627), new $Int64(0, 38989)), new Pair.ptr(new $Int64(0, 40637), new $Int64(0, 32378)), new Pair.ptr(new $Int64(0, 40639), new $Int64(0, 22140)), new Pair.ptr(new $Int64(0, 40693), new $Int64(0, 33485)), new Pair.ptr(new $Int64(0, 40697), new $Int64(0, 1466)), new Pair.ptr(new $Int64(0, 40699), new $Int64(0, 20648)), new Pair.ptr(new $Int64(0, 40709), new $Int64(0, 3935)), new Pair.ptr(new $Int64(0, 40739), new $Int64(0, 2137)), new Pair.ptr(new $Int64(0, 40751), new $Int64(0, 12189)), new Pair.ptr(new $Int64(0, 40759), new $Int64(0, 35846)), new Pair.ptr(new $Int64(0, 40763), new $Int64(0, 24112)), new Pair.ptr(new $Int64(0, 40771), new $Int64(0, 34264)), new Pair.ptr(new $Int64(0, 40787), new $Int64(0, 30613)), new Pair.ptr(new $Int64(0, 40801), new $Int64(0, 3342)), new Pair.ptr(new $Int64(0, 40813), new $Int64(0, 34970)), new Pair.ptr(new $Int64(0, 40819), new $Int64(0, 31719)), new Pair.ptr(new $Int64(0, 40823), new $Int64(0, 2798)), new Pair.ptr(new $Int64(0, 40829), new $Int64(0, 23321)), new Pair.ptr(new $Int64(0, 40841), new $Int64(0, 28587)), new Pair.ptr(new $Int64(0, 40847), new $Int64(0, 2767)), new Pair.ptr(new $Int64(0, 40849), new $Int64(0, 32181)), new Pair.ptr(new $Int64(0, 40853), new $Int64(0, 40786)), new Pair.ptr(new $Int64(0, 40867), new $Int64(0, 9702)), new Pair.ptr(new $Int64(0, 40879), new $Int64(0, 22965)), new Pair.ptr(new $Int64(0, 40883), new $Int64(0, 38151)), new Pair.ptr(new $Int64(0, 40897), new $Int64(0, 17625)), new Pair.ptr(new $Int64(0, 40903), new $Int64(0, 23003)), new Pair.ptr(new $Int64(0, 40927), new $Int64(0, 32960)), new Pair.ptr(new $Int64(0, 40933), new $Int64(0, 7716)), new Pair.ptr(new $Int64(0, 40939), new $Int64(0, 13449)), new Pair.ptr(new $Int64(0, 40949), new $Int64(0, 931)), new Pair.ptr(new $Int64(0, 40961), new $Int64(0, 10748)), new Pair.ptr(new $Int64(0, 40973), new $Int64(0, 17288)), new Pair.ptr(new $Int64(0, 40993), new $Int64(0, 40018)), new Pair.ptr(new $Int64(0, 41011), new $Int64(0, 12178)), new Pair.ptr(new $Int64(0, 41017), new $Int64(0, 12063)), new Pair.ptr(new $Int64(0, 41023), new $Int64(0, 24177)), new Pair.ptr(new $Int64(0, 41039), new $Int64(0, 7011)), new Pair.ptr(new $Int64(0, 41047), new $Int64(0, 35517)), new Pair.ptr(new $Int64(0, 41051), new $Int64(0, 3113)), new Pair.ptr(new $Int64(0, 41057), new $Int64(0, 1561)), new Pair.ptr(new $Int64(0, 41077), new $Int64(0, 2786)), new Pair.ptr(new $Int64(0, 41081), new $Int64(0, 18495)), new Pair.ptr(new $Int64(0, 41113), new $Int64(0, 4649)), new Pair.ptr(new $Int64(0, 41117), new $Int64(0, 16289)), new Pair.ptr(new $Int64(0, 41131), new $Int64(0, 4612)), new Pair.ptr(new $Int64(0, 41141), new $Int64(0, 3089)), new Pair.ptr(new $Int64(0, 41143), new $Int64(0, 32427)), new Pair.ptr(new $Int64(0, 41149), new $Int64(0, 38193)), new Pair.ptr(new $Int64(0, 41161), new $Int64(0, 33389)), new Pair.ptr(new $Int64(0, 41177), new $Int64(0, 21681)), new Pair.ptr(new $Int64(0, 41179), new $Int64(0, 22825)), new Pair.ptr(new $Int64(0, 41183), new $Int64(0, 1177)), new Pair.ptr(new $Int64(0, 41189), new $Int64(0, 7767)), new Pair.ptr(new $Int64(0, 41201), new $Int64(0, 14680)), new Pair.ptr(new $Int64(0, 41203), new $Int64(0, 22863)), new Pair.ptr(new $Int64(0, 41213), new $Int64(0, 16607)), new Pair.ptr(new $Int64(0, 41221), new $Int64(0, 10727)), new Pair.ptr(new $Int64(0, 41227), new $Int64(0, 18107)), new Pair.ptr(new $Int64(0, 41231), new $Int64(0, 38900)), new Pair.ptr(new $Int64(0, 41233), new $Int64(0, 13560)), new Pair.ptr(new $Int64(0, 41243), new $Int64(0, 26044)), new Pair.ptr(new $Int64(0, 41257), new $Int64(0, 5910)), new Pair.ptr(new $Int64(0, 41263), new $Int64(0, 14013)), new Pair.ptr(new $Int64(0, 41269), new $Int64(0, 10723)), new Pair.ptr(new $Int64(0, 41281), new $Int64(0, 9691)), new Pair.ptr(new $Int64(0, 41299), new $Int64(0, 26811)), new Pair.ptr(new $Int64(0, 41333), new $Int64(0, 36847)), new Pair.ptr(new $Int64(0, 41341), new $Int64(0, 805)), new Pair.ptr(new $Int64(0, 41351), new $Int64(0, 9105)), new Pair.ptr(new $Int64(0, 41357), new $Int64(0, 26713)), new Pair.ptr(new $Int64(0, 41381), new $Int64(0, 22578)), new Pair.ptr(new $Int64(0, 41387), new $Int64(0, 33296)), new Pair.ptr(new $Int64(0, 41389), new $Int64(0, 12160)), new Pair.ptr(new $Int64(0, 41399), new $Int64(0, 30605)), new Pair.ptr(new $Int64(0, 41411), new $Int64(0, 19895)), new Pair.ptr(new $Int64(0, 41413), new $Int64(0, 38256)), new Pair.ptr(new $Int64(0, 41443), new $Int64(0, 23700)), new Pair.ptr(new $Int64(0, 41453), new $Int64(0, 31322)), new Pair.ptr(new $Int64(0, 41467), new $Int64(0, 13987)), new Pair.ptr(new $Int64(0, 41479), new $Int64(0, 19697)), new Pair.ptr(new $Int64(0, 41491), new $Int64(0, 6186)), new Pair.ptr(new $Int64(0, 41507), new $Int64(0, 19004)), new Pair.ptr(new $Int64(0, 41513), new $Int64(0, 7459)), new Pair.ptr(new $Int64(0, 41519), new $Int64(0, 21859)), new Pair.ptr(new $Int64(0, 41521), new $Int64(0, 18541)), new Pair.ptr(new $Int64(0, 41539), new $Int64(0, 7131)), new Pair.ptr(new $Int64(0, 41543), new $Int64(0, 7039)), new Pair.ptr(new $Int64(0, 41549), new $Int64(0, 22321)), new Pair.ptr(new $Int64(0, 41579), new $Int64(0, 30385)), new Pair.ptr(new $Int64(0, 41593), new $Int64(0, 15382)), new Pair.ptr(new $Int64(0, 41597), new $Int64(0, 33974)), new Pair.ptr(new $Int64(0, 41603), new $Int64(0, 7444)), new Pair.ptr(new $Int64(0, 41609), new $Int64(0, 35925)), new Pair.ptr(new $Int64(0, 41611), new $Int64(0, 12855)), new Pair.ptr(new $Int64(0, 41617), new $Int64(0, 8955)), new Pair.ptr(new $Int64(0, 41621), new $Int64(0, 8863)), new Pair.ptr(new $Int64(0, 41627), new $Int64(0, 26877)), new Pair.ptr(new $Int64(0, 41641), new $Int64(0, 3702)), new Pair.ptr(new $Int64(0, 41647), new $Int64(0, 8535)), new Pair.ptr(new $Int64(0, 41651), new $Int64(0, 4490)), new Pair.ptr(new $Int64(0, 41659), new $Int64(0, 9066)), new Pair.ptr(new $Int64(0, 41669), new $Int64(0, 9814)), new Pair.ptr(new $Int64(0, 41681), new $Int64(0, 34713)), new Pair.ptr(new $Int64(0, 41687), new $Int64(0, 37806)), new Pair.ptr(new $Int64(0, 41719), new $Int64(0, 19936)), new Pair.ptr(new $Int64(0, 41729), new $Int64(0, 32110)), new Pair.ptr(new $Int64(0, 41737), new $Int64(0, 13609)), new Pair.ptr(new $Int64(0, 41759), new $Int64(0, 24989)), new Pair.ptr(new $Int64(0, 41761), new $Int64(0, 7676)), new Pair.ptr(new $Int64(0, 41771), new $Int64(0, 13433)), new Pair.ptr(new $Int64(0, 41777), new $Int64(0, 32389)), new Pair.ptr(new $Int64(0, 41801), new $Int64(0, 22661)), new Pair.ptr(new $Int64(0, 41809), new $Int64(0, 26171)), new Pair.ptr(new $Int64(0, 41813), new $Int64(0, 23198)), new Pair.ptr(new $Int64(0, 41843), new $Int64(0, 30394)), new Pair.ptr(new $Int64(0, 41849), new $Int64(0, 5822)), new Pair.ptr(new $Int64(0, 41851), new $Int64(0, 25012)), new Pair.ptr(new $Int64(0, 41863), new $Int64(0, 34040)), new Pair.ptr(new $Int64(0, 41879), new $Int64(0, 41712)), new Pair.ptr(new $Int64(0, 41887), new $Int64(0, 35658)), new Pair.ptr(new $Int64(0, 41893), new $Int64(0, 36565)), new Pair.ptr(new $Int64(0, 41897), new $Int64(0, 21223)), new Pair.ptr(new $Int64(0, 41903), new $Int64(0, 10114)), new Pair.ptr(new $Int64(0, 41911), new $Int64(0, 9326)), new Pair.ptr(new $Int64(0, 41927), new $Int64(0, 12013)), new Pair.ptr(new $Int64(0, 41941), new $Int64(0, 32660)), new Pair.ptr(new $Int64(0, 41947), new $Int64(0, 37951)), new Pair.ptr(new $Int64(0, 41953), new $Int64(0, 20293)), new Pair.ptr(new $Int64(0, 41957), new $Int64(0, 28358)), new Pair.ptr(new $Int64(0, 41959), new $Int64(0, 1188)), new Pair.ptr(new $Int64(0, 41969), new $Int64(0, 33259)), new Pair.ptr(new $Int64(0, 41981), new $Int64(0, 34858)), new Pair.ptr(new $Int64(0, 41983), new $Int64(0, 29566)), new Pair.ptr(new $Int64(0, 41999), new $Int64(0, 20853)), new Pair.ptr(new $Int64(0, 42013), new $Int64(0, 39188)), new Pair.ptr(new $Int64(0, 42017), new $Int64(0, 2437)), new Pair.ptr(new $Int64(0, 42019), new $Int64(0, 9774)), new Pair.ptr(new $Int64(0, 42023), new $Int64(0, 38816)), new Pair.ptr(new $Int64(0, 42043), new $Int64(0, 18919)), new Pair.ptr(new $Int64(0, 42061), new $Int64(0, 7416)), new Pair.ptr(new $Int64(0, 42071), new $Int64(0, 7036)), new Pair.ptr(new $Int64(0, 42073), new $Int64(0, 27076)), new Pair.ptr(new $Int64(0, 42083), new $Int64(0, 23043)), new Pair.ptr(new $Int64(0, 42089), new $Int64(0, 15358)), new Pair.ptr(new $Int64(0, 42101), new $Int64(0, 16662)), new Pair.ptr(new $Int64(0, 42131), new $Int64(0, 25965)), new Pair.ptr(new $Int64(0, 42139), new $Int64(0, 27651)), new Pair.ptr(new $Int64(0, 42157), new $Int64(0, 17431)), new Pair.ptr(new $Int64(0, 42169), new $Int64(0, 1710)), new Pair.ptr(new $Int64(0, 42179), new $Int64(0, 2971)), new Pair.ptr(new $Int64(0, 42181), new $Int64(0, 36218)), new Pair.ptr(new $Int64(0, 42187), new $Int64(0, 8161)), new Pair.ptr(new $Int64(0, 42193), new $Int64(0, 18428)), new Pair.ptr(new $Int64(0, 42197), new $Int64(0, 35813)), new Pair.ptr(new $Int64(0, 42209), new $Int64(0, 27082)), new Pair.ptr(new $Int64(0, 42221), new $Int64(0, 12112)), new Pair.ptr(new $Int64(0, 42223), new $Int64(0, 38129)), new Pair.ptr(new $Int64(0, 42227), new $Int64(0, 5033)), new Pair.ptr(new $Int64(0, 42239), new $Int64(0, 4642)), new Pair.ptr(new $Int64(0, 42257), new $Int64(0, 15242)), new Pair.ptr(new $Int64(0, 42281), new $Int64(0, 15276)), new Pair.ptr(new $Int64(0, 42283), new $Int64(0, 23589)), new Pair.ptr(new $Int64(0, 42293), new $Int64(0, 6226)), new Pair.ptr(new $Int64(0, 42299), new $Int64(0, 23643)), new Pair.ptr(new $Int64(0, 42307), new $Int64(0, 39122)), new Pair.ptr(new $Int64(0, 42323), new $Int64(0, 38776)), new Pair.ptr(new $Int64(0, 42331), new $Int64(0, 31177)), new Pair.ptr(new $Int64(0, 42337), new $Int64(0, 10125)), new Pair.ptr(new $Int64(0, 42349), new $Int64(0, 24161)), new Pair.ptr(new $Int64(0, 42359), new $Int64(0, 35631)), new Pair.ptr(new $Int64(0, 42373), new $Int64(0, 20348)), new Pair.ptr(new $Int64(0, 42379), new $Int64(0, 459)), new Pair.ptr(new $Int64(0, 42391), new $Int64(0, 34842)), new Pair.ptr(new $Int64(0, 42397), new $Int64(0, 33625)), new Pair.ptr(new $Int64(0, 42403), new $Int64(0, 11329)), new Pair.ptr(new $Int64(0, 42407), new $Int64(0, 12786)), new Pair.ptr(new $Int64(0, 42409), new $Int64(0, 364)), new Pair.ptr(new $Int64(0, 42433), new $Int64(0, 42102)), new Pair.ptr(new $Int64(0, 42437), new $Int64(0, 21009)), new Pair.ptr(new $Int64(0, 42443), new $Int64(0, 471)), new Pair.ptr(new $Int64(0, 42451), new $Int64(0, 5693)), new Pair.ptr(new $Int64(0, 42457), new $Int64(0, 2307)), new Pair.ptr(new $Int64(0, 42461), new $Int64(0, 33984)), new Pair.ptr(new $Int64(0, 42463), new $Int64(0, 37667)), new Pair.ptr(new $Int64(0, 42467), new $Int64(0, 20589)), new Pair.ptr(new $Int64(0, 42473), new $Int64(0, 33599)), new Pair.ptr(new $Int64(0, 42487), new $Int64(0, 37527)), new Pair.ptr(new $Int64(0, 42491), new $Int64(0, 31026)), new Pair.ptr(new $Int64(0, 42499), new $Int64(0, 9546)), new Pair.ptr(new $Int64(0, 42509), new $Int64(0, 22497)), new Pair.ptr(new $Int64(0, 42533), new $Int64(0, 27889)), new Pair.ptr(new $Int64(0, 42557), new $Int64(0, 31612)), new Pair.ptr(new $Int64(0, 42569), new $Int64(0, 32161)), new Pair.ptr(new $Int64(0, 42571), new $Int64(0, 39179)), new Pair.ptr(new $Int64(0, 42577), new $Int64(0, 10310)), new Pair.ptr(new $Int64(0, 42589), new $Int64(0, 12002)), new Pair.ptr(new $Int64(0, 42611), new $Int64(0, 29794)), new Pair.ptr(new $Int64(0, 42641), new $Int64(0, 22520)), new Pair.ptr(new $Int64(0, 42643), new $Int64(0, 41043)), new Pair.ptr(new $Int64(0, 42649), new $Int64(0, 15960)), new Pair.ptr(new $Int64(0, 42667), new $Int64(0, 41032)), new Pair.ptr(new $Int64(0, 42677), new $Int64(0, 19124)), new Pair.ptr(new $Int64(0, 42683), new $Int64(0, 16677)), new Pair.ptr(new $Int64(0, 42689), new $Int64(0, 25940)), new Pair.ptr(new $Int64(0, 42697), new $Int64(0, 38235)), new Pair.ptr(new $Int64(0, 42701), new $Int64(0, 20952)), new Pair.ptr(new $Int64(0, 42703), new $Int64(0, 23674)), new Pair.ptr(new $Int64(0, 42709), new $Int64(0, 31321)), new Pair.ptr(new $Int64(0, 42719), new $Int64(0, 26417)), new Pair.ptr(new $Int64(0, 42727), new $Int64(0, 2311)), new Pair.ptr(new $Int64(0, 42737), new $Int64(0, 14177)), new Pair.ptr(new $Int64(0, 42743), new $Int64(0, 3442)), new Pair.ptr(new $Int64(0, 42751), new $Int64(0, 8915)), new Pair.ptr(new $Int64(0, 42767), new $Int64(0, 5076)), new Pair.ptr(new $Int64(0, 42773), new $Int64(0, 26679)), new Pair.ptr(new $Int64(0, 42787), new $Int64(0, 8790)), new Pair.ptr(new $Int64(0, 42793), new $Int64(0, 9627)), new Pair.ptr(new $Int64(0, 42797), new $Int64(0, 8874)), new Pair.ptr(new $Int64(0, 42821), new $Int64(0, 32561)), new Pair.ptr(new $Int64(0, 42829), new $Int64(0, 12797)), new Pair.ptr(new $Int64(0, 42839), new $Int64(0, 10785)), new Pair.ptr(new $Int64(0, 42841), new $Int64(0, 20072)), new Pair.ptr(new $Int64(0, 42853), new $Int64(0, 6708)), new Pair.ptr(new $Int64(0, 42859), new $Int64(0, 41739)), new Pair.ptr(new $Int64(0, 42863), new $Int64(0, 35995)), new Pair.ptr(new $Int64(0, 42899), new $Int64(0, 9193)), new Pair.ptr(new $Int64(0, 42901), new $Int64(0, 3064)), new Pair.ptr(new $Int64(0, 42923), new $Int64(0, 12397)), new Pair.ptr(new $Int64(0, 42929), new $Int64(0, 25271)), new Pair.ptr(new $Int64(0, 42937), new $Int64(0, 746)), new Pair.ptr(new $Int64(0, 42943), new $Int64(0, 1070)), new Pair.ptr(new $Int64(0, 42953), new $Int64(0, 42432)), new Pair.ptr(new $Int64(0, 42961), new $Int64(0, 26008)), new Pair.ptr(new $Int64(0, 42967), new $Int64(0, 13055)), new Pair.ptr(new $Int64(0, 42979), new $Int64(0, 4158)), new Pair.ptr(new $Int64(0, 42989), new $Int64(0, 32328)), new Pair.ptr(new $Int64(0, 43003), new $Int64(0, 27943)), new Pair.ptr(new $Int64(0, 43013), new $Int64(0, 3453)), new Pair.ptr(new $Int64(0, 43019), new $Int64(0, 3331)), new Pair.ptr(new $Int64(0, 43037), new $Int64(0, 35924)), new Pair.ptr(new $Int64(0, 43049), new $Int64(0, 27922)), new Pair.ptr(new $Int64(0, 43051), new $Int64(0, 8655)), new Pair.ptr(new $Int64(0, 43063), new $Int64(0, 22626)), new Pair.ptr(new $Int64(0, 43067), new $Int64(0, 17481)), new Pair.ptr(new $Int64(0, 43093), new $Int64(0, 22631)), new Pair.ptr(new $Int64(0, 43103), new $Int64(0, 10662)), new Pair.ptr(new $Int64(0, 43117), new $Int64(0, 32430)), new Pair.ptr(new $Int64(0, 43133), new $Int64(0, 38624)), new Pair.ptr(new $Int64(0, 43151), new $Int64(0, 39332)), new Pair.ptr(new $Int64(0, 43159), new $Int64(0, 26531)), new Pair.ptr(new $Int64(0, 43177), new $Int64(0, 19384)), new Pair.ptr(new $Int64(0, 43189), new $Int64(0, 6821)), new Pair.ptr(new $Int64(0, 43201), new $Int64(0, 7207)), new Pair.ptr(new $Int64(0, 43207), new $Int64(0, 14466)), new Pair.ptr(new $Int64(0, 43223), new $Int64(0, 1883)), new Pair.ptr(new $Int64(0, 43237), new $Int64(0, 27337)), new Pair.ptr(new $Int64(0, 43261), new $Int64(0, 1361)), new Pair.ptr(new $Int64(0, 43271), new $Int64(0, 10522)), new Pair.ptr(new $Int64(0, 43283), new $Int64(0, 783)), new Pair.ptr(new $Int64(0, 43291), new $Int64(0, 32749)), new Pair.ptr(new $Int64(0, 43313), new $Int64(0, 11244)), new Pair.ptr(new $Int64(0, 43319), new $Int64(0, 15796)), new Pair.ptr(new $Int64(0, 43321), new $Int64(0, 22028)), new Pair.ptr(new $Int64(0, 43331), new $Int64(0, 24064)), new Pair.ptr(new $Int64(0, 43391), new $Int64(0, 12025)), new Pair.ptr(new $Int64(0, 43397), new $Int64(0, 38002)), new Pair.ptr(new $Int64(0, 43399), new $Int64(0, 15276)), new Pair.ptr(new $Int64(0, 43403), new $Int64(0, 21381)), new Pair.ptr(new $Int64(0, 43411), new $Int64(0, 29327)), new Pair.ptr(new $Int64(0, 43427), new $Int64(0, 16369)), new Pair.ptr(new $Int64(0, 43441), new $Int64(0, 694)), new Pair.ptr(new $Int64(0, 43451), new $Int64(0, 12454)), new Pair.ptr(new $Int64(0, 43457), new $Int64(0, 32172)), new Pair.ptr(new $Int64(0, 43481), new $Int64(0, 19923)), new Pair.ptr(new $Int64(0, 43487), new $Int64(0, 22061)), new Pair.ptr(new $Int64(0, 43499), new $Int64(0, 4020)), new Pair.ptr(new $Int64(0, 43517), new $Int64(0, 31673)), new Pair.ptr(new $Int64(0, 43541), new $Int64(0, 6749)), new Pair.ptr(new $Int64(0, 43543), new $Int64(0, 40278)), new Pair.ptr(new $Int64(0, 43573), new $Int64(0, 7256)), new Pair.ptr(new $Int64(0, 43577), new $Int64(0, 41577)), new Pair.ptr(new $Int64(0, 43579), new $Int64(0, 37303)), new Pair.ptr(new $Int64(0, 43591), new $Int64(0, 9395)), new Pair.ptr(new $Int64(0, 43597), new $Int64(0, 17286)), new Pair.ptr(new $Int64(0, 43607), new $Int64(0, 30791)), new Pair.ptr(new $Int64(0, 43609), new $Int64(0, 27472)), new Pair.ptr(new $Int64(0, 43613), new $Int64(0, 4024)), new Pair.ptr(new $Int64(0, 43627), new $Int64(0, 17810)), new Pair.ptr(new $Int64(0, 43633), new $Int64(0, 19580)), new Pair.ptr(new $Int64(0, 43649), new $Int64(0, 43137)), new Pair.ptr(new $Int64(0, 43651), new $Int64(0, 36946)), new Pair.ptr(new $Int64(0, 43661), new $Int64(0, 8774)), new Pair.ptr(new $Int64(0, 43669), new $Int64(0, 29233)), new Pair.ptr(new $Int64(0, 43691), new $Int64(0, 26359)), new Pair.ptr(new $Int64(0, 43711), new $Int64(0, 40250)), new Pair.ptr(new $Int64(0, 43717), new $Int64(0, 13534)), new Pair.ptr(new $Int64(0, 43721), new $Int64(0, 20164)), new Pair.ptr(new $Int64(0, 43753), new $Int64(0, 20814)), new Pair.ptr(new $Int64(0, 43759), new $Int64(0, 9064)), new Pair.ptr(new $Int64(0, 43777), new $Int64(0, 40864)), new Pair.ptr(new $Int64(0, 43781), new $Int64(0, 2325)), new Pair.ptr(new $Int64(0, 43783), new $Int64(0, 9970)), new Pair.ptr(new $Int64(0, 43787), new $Int64(0, 40476)), new Pair.ptr(new $Int64(0, 43789), new $Int64(0, 30057)), new Pair.ptr(new $Int64(0, 43793), new $Int64(0, 32237)), new Pair.ptr(new $Int64(0, 43801), new $Int64(0, 15796)), new Pair.ptr(new $Int64(0, 43853), new $Int64(0, 16707)), new Pair.ptr(new $Int64(0, 43867), new $Int64(0, 14928)), new Pair.ptr(new $Int64(0, 43889), new $Int64(0, 27853)), new Pair.ptr(new $Int64(0, 43891), new $Int64(0, 34606)), new Pair.ptr(new $Int64(0, 43913), new $Int64(0, 257)), new Pair.ptr(new $Int64(0, 43933), new $Int64(0, 39355)), new Pair.ptr(new $Int64(0, 43943), new $Int64(0, 24698)), new Pair.ptr(new $Int64(0, 43951), new $Int64(0, 6443)), new Pair.ptr(new $Int64(0, 43961), new $Int64(0, 512)), new Pair.ptr(new $Int64(0, 43963), new $Int64(0, 9462)), new Pair.ptr(new $Int64(0, 43969), new $Int64(0, 35781)), new Pair.ptr(new $Int64(0, 43973), new $Int64(0, 22771)), new Pair.ptr(new $Int64(0, 43987), new $Int64(0, 13299)), new Pair.ptr(new $Int64(0, 43991), new $Int64(0, 29023)), new Pair.ptr(new $Int64(0, 43997), new $Int64(0, 5211)), new Pair.ptr(new $Int64(0, 44017), new $Int64(0, 16683)), new Pair.ptr(new $Int64(0, 44021), new $Int64(0, 9506)), new Pair.ptr(new $Int64(0, 44027), new $Int64(0, 24776)), new Pair.ptr(new $Int64(0, 44029), new $Int64(0, 23580)), new Pair.ptr(new $Int64(0, 44041), new $Int64(0, 23978)), new Pair.ptr(new $Int64(0, 44053), new $Int64(0, 17458)), new Pair.ptr(new $Int64(0, 44059), new $Int64(0, 32212)), new Pair.ptr(new $Int64(0, 44071), new $Int64(0, 3863)), new Pair.ptr(new $Int64(0, 44087), new $Int64(0, 43506)), new Pair.ptr(new $Int64(0, 44089), new $Int64(0, 29360)), new Pair.ptr(new $Int64(0, 44101), new $Int64(0, 7247)), new Pair.ptr(new $Int64(0, 44111), new $Int64(0, 23065)), new Pair.ptr(new $Int64(0, 44119), new $Int64(0, 19981)), new Pair.ptr(new $Int64(0, 44123), new $Int64(0, 20237)), new Pair.ptr(new $Int64(0, 44129), new $Int64(0, 35632)), new Pair.ptr(new $Int64(0, 44131), new $Int64(0, 2215)), new Pair.ptr(new $Int64(0, 44159), new $Int64(0, 8691)), new Pair.ptr(new $Int64(0, 44171), new $Int64(0, 1055)), new Pair.ptr(new $Int64(0, 44179), new $Int64(0, 28460)), new Pair.ptr(new $Int64(0, 44189), new $Int64(0, 43163)), new Pair.ptr(new $Int64(0, 44201), new $Int64(0, 25066)), new Pair.ptr(new $Int64(0, 44203), new $Int64(0, 20730)), new Pair.ptr(new $Int64(0, 44207), new $Int64(0, 21543)), new Pair.ptr(new $Int64(0, 44221), new $Int64(0, 5588)), new Pair.ptr(new $Int64(0, 44249), new $Int64(0, 18268)), new Pair.ptr(new $Int64(0, 44257), new $Int64(0, 5146)), new Pair.ptr(new $Int64(0, 44263), new $Int64(0, 23964)), new Pair.ptr(new $Int64(0, 44267), new $Int64(0, 29068)), new Pair.ptr(new $Int64(0, 44269), new $Int64(0, 10618)), new Pair.ptr(new $Int64(0, 44273), new $Int64(0, 14545)), new Pair.ptr(new $Int64(0, 44279), new $Int64(0, 30832)), new Pair.ptr(new $Int64(0, 44281), new $Int64(0, 14642)), new Pair.ptr(new $Int64(0, 44293), new $Int64(0, 30341)), new Pair.ptr(new $Int64(0, 44351), new $Int64(0, 24564)), new Pair.ptr(new $Int64(0, 44357), new $Int64(0, 31664)), new Pair.ptr(new $Int64(0, 44371), new $Int64(0, 6970)), new Pair.ptr(new $Int64(0, 44381), new $Int64(0, 44122)), new Pair.ptr(new $Int64(0, 44383), new $Int64(0, 24295)), new Pair.ptr(new $Int64(0, 44389), new $Int64(0, 16722)), new Pair.ptr(new $Int64(0, 44417), new $Int64(0, 11007)), new Pair.ptr(new $Int64(0, 44449), new $Int64(0, 28312)), new Pair.ptr(new $Int64(0, 44453), new $Int64(0, 40783)), new Pair.ptr(new $Int64(0, 44483), new $Int64(0, 31334)), new Pair.ptr(new $Int64(0, 44491), new $Int64(0, 3122)), new Pair.ptr(new $Int64(0, 44497), new $Int64(0, 11175)), new Pair.ptr(new $Int64(0, 44501), new $Int64(0, 9254)), new Pair.ptr(new $Int64(0, 44507), new $Int64(0, 33494)), new Pair.ptr(new $Int64(0, 44519), new $Int64(0, 27708)), new Pair.ptr(new $Int64(0, 44531), new $Int64(0, 39322)), new Pair.ptr(new $Int64(0, 44533), new $Int64(0, 35933)), new Pair.ptr(new $Int64(0, 44537), new $Int64(0, 42137)), new Pair.ptr(new $Int64(0, 44543), new $Int64(0, 31799)), new Pair.ptr(new $Int64(0, 44549), new $Int64(0, 7466)), new Pair.ptr(new $Int64(0, 44563), new $Int64(0, 39374)), new Pair.ptr(new $Int64(0, 44579), new $Int64(0, 1136)), new Pair.ptr(new $Int64(0, 44587), new $Int64(0, 32990)), new Pair.ptr(new $Int64(0, 44617), new $Int64(0, 36968)), new Pair.ptr(new $Int64(0, 44621), new $Int64(0, 32637)), new Pair.ptr(new $Int64(0, 44623), new $Int64(0, 33877)), new Pair.ptr(new $Int64(0, 44633), new $Int64(0, 5701)), new Pair.ptr(new $Int64(0, 44641), new $Int64(0, 25152)), new Pair.ptr(new $Int64(0, 44647), new $Int64(0, 20122)), new Pair.ptr(new $Int64(0, 44651), new $Int64(0, 15965)), new Pair.ptr(new $Int64(0, 44657), new $Int64(0, 15840)), new Pair.ptr(new $Int64(0, 44683), new $Int64(0, 20598)), new Pair.ptr(new $Int64(0, 44687), new $Int64(0, 33250)), new Pair.ptr(new $Int64(0, 44699), new $Int64(0, 30343)), new Pair.ptr(new $Int64(0, 44701), new $Int64(0, 35881)), new Pair.ptr(new $Int64(0, 44711), new $Int64(0, 32044)), new Pair.ptr(new $Int64(0, 44729), new $Int64(0, 37457)), new Pair.ptr(new $Int64(0, 44741), new $Int64(0, 27540)), new Pair.ptr(new $Int64(0, 44753), new $Int64(0, 44389)), new Pair.ptr(new $Int64(0, 44771), new $Int64(0, 28084)), new Pair.ptr(new $Int64(0, 44773), new $Int64(0, 35411)), new Pair.ptr(new $Int64(0, 44777), new $Int64(0, 31181)), new Pair.ptr(new $Int64(0, 44789), new $Int64(0, 44286)), new Pair.ptr(new $Int64(0, 44797), new $Int64(0, 31814)), new Pair.ptr(new $Int64(0, 44809), new $Int64(0, 12650)), new Pair.ptr(new $Int64(0, 44819), new $Int64(0, 19410)), new Pair.ptr(new $Int64(0, 44839), new $Int64(0, 39479)), new Pair.ptr(new $Int64(0, 44843), new $Int64(0, 11294)), new Pair.ptr(new $Int64(0, 44851), new $Int64(0, 37424)), new Pair.ptr(new $Int64(0, 44867), new $Int64(0, 42819)), new Pair.ptr(new $Int64(0, 44879), new $Int64(0, 15782)), new Pair.ptr(new $Int64(0, 44887), new $Int64(0, 13459)), new Pair.ptr(new $Int64(0, 44893), new $Int64(0, 27209)), new Pair.ptr(new $Int64(0, 44909), new $Int64(0, 42969)), new Pair.ptr(new $Int64(0, 44917), new $Int64(0, 15835)), new Pair.ptr(new $Int64(0, 44927), new $Int64(0, 8519)), new Pair.ptr(new $Int64(0, 44939), new $Int64(0, 35983)), new Pair.ptr(new $Int64(0, 44953), new $Int64(0, 35486)), new Pair.ptr(new $Int64(0, 44959), new $Int64(0, 26335)), new Pair.ptr(new $Int64(0, 44963), new $Int64(0, 17478)), new Pair.ptr(new $Int64(0, 44971), new $Int64(0, 32133)), new Pair.ptr(new $Int64(0, 44983), new $Int64(0, 9704)), new Pair.ptr(new $Int64(0, 44987), new $Int64(0, 19294)), new Pair.ptr(new $Int64(0, 45007), new $Int64(0, 35976)), new Pair.ptr(new $Int64(0, 45013), new $Int64(0, 24089)), new Pair.ptr(new $Int64(0, 45053), new $Int64(0, 44349)), new Pair.ptr(new $Int64(0, 45061), new $Int64(0, 36260)), new Pair.ptr(new $Int64(0, 45077), new $Int64(0, 32223)), new Pair.ptr(new $Int64(0, 45083), new $Int64(0, 20317)), new Pair.ptr(new $Int64(0, 45119), new $Int64(0, 24160)), new Pair.ptr(new $Int64(0, 45121), new $Int64(0, 7347)), new Pair.ptr(new $Int64(0, 45127), new $Int64(0, 38867)), new Pair.ptr(new $Int64(0, 45131), new $Int64(0, 29978)), new Pair.ptr(new $Int64(0, 45137), new $Int64(0, 20790)), new Pair.ptr(new $Int64(0, 45139), new $Int64(0, 40397)), new Pair.ptr(new $Int64(0, 45161), new $Int64(0, 27009)), new Pair.ptr(new $Int64(0, 45179), new $Int64(0, 10494)), new Pair.ptr(new $Int64(0, 45181), new $Int64(0, 13247)), new Pair.ptr(new $Int64(0, 45191), new $Int64(0, 6384)), new Pair.ptr(new $Int64(0, 45197), new $Int64(0, 29103)), new Pair.ptr(new $Int64(0, 45233), new $Int64(0, 40030)), new Pair.ptr(new $Int64(0, 45247), new $Int64(0, 45163)), new Pair.ptr(new $Int64(0, 45259), new $Int64(0, 43805)), new Pair.ptr(new $Int64(0, 45263), new $Int64(0, 36880)), new Pair.ptr(new $Int64(0, 45281), new $Int64(0, 43818)), new Pair.ptr(new $Int64(0, 45289), new $Int64(0, 41832)), new Pair.ptr(new $Int64(0, 45293), new $Int64(0, 24450)), new Pair.ptr(new $Int64(0, 45307), new $Int64(0, 18179)), new Pair.ptr(new $Int64(0, 45317), new $Int64(0, 20805)), new Pair.ptr(new $Int64(0, 45319), new $Int64(0, 28221)), new Pair.ptr(new $Int64(0, 45329), new $Int64(0, 6125)), new Pair.ptr(new $Int64(0, 45337), new $Int64(0, 11703)), new Pair.ptr(new $Int64(0, 45341), new $Int64(0, 1819)), new Pair.ptr(new $Int64(0, 45343), new $Int64(0, 38591)), new Pair.ptr(new $Int64(0, 45361), new $Int64(0, 18715)), new Pair.ptr(new $Int64(0, 45377), new $Int64(0, 17546)), new Pair.ptr(new $Int64(0, 45389), new $Int64(0, 20303)), new Pair.ptr(new $Int64(0, 45403), new $Int64(0, 22971)), new Pair.ptr(new $Int64(0, 45413), new $Int64(0, 20840)), new Pair.ptr(new $Int64(0, 45427), new $Int64(0, 43777)), new Pair.ptr(new $Int64(0, 45433), new $Int64(0, 40676)), new Pair.ptr(new $Int64(0, 45439), new $Int64(0, 40552)), new Pair.ptr(new $Int64(0, 45481), new $Int64(0, 4316)), new Pair.ptr(new $Int64(0, 45491), new $Int64(0, 34080)), new Pair.ptr(new $Int64(0, 45497), new $Int64(0, 4366)), new Pair.ptr(new $Int64(0, 45503), new $Int64(0, 23211)), new Pair.ptr(new $Int64(0, 45523), new $Int64(0, 13345)), new Pair.ptr(new $Int64(0, 45533), new $Int64(0, 1108)), new Pair.ptr(new $Int64(0, 45541), new $Int64(0, 3753)), new Pair.ptr(new $Int64(0, 45553), new $Int64(0, 13843)), new Pair.ptr(new $Int64(0, 45557), new $Int64(0, 20187)), new Pair.ptr(new $Int64(0, 45569), new $Int64(0, 6294)), new Pair.ptr(new $Int64(0, 45587), new $Int64(0, 27430)), new Pair.ptr(new $Int64(0, 45589), new $Int64(0, 1917)), new Pair.ptr(new $Int64(0, 45599), new $Int64(0, 8200)), new Pair.ptr(new $Int64(0, 45613), new $Int64(0, 28739)), new Pair.ptr(new $Int64(0, 45631), new $Int64(0, 18815)), new Pair.ptr(new $Int64(0, 45641), new $Int64(0, 27980)), new Pair.ptr(new $Int64(0, 45659), new $Int64(0, 34142)), new Pair.ptr(new $Int64(0, 45667), new $Int64(0, 41271)), new Pair.ptr(new $Int64(0, 45673), new $Int64(0, 100)), new Pair.ptr(new $Int64(0, 45677), new $Int64(0, 35116)), new Pair.ptr(new $Int64(0, 45691), new $Int64(0, 30776)), new Pair.ptr(new $Int64(0, 45697), new $Int64(0, 29463)), new Pair.ptr(new $Int64(0, 45707), new $Int64(0, 32114)), new Pair.ptr(new $Int64(0, 45737), new $Int64(0, 44506)), new Pair.ptr(new $Int64(0, 45751), new $Int64(0, 10409)), new Pair.ptr(new $Int64(0, 45757), new $Int64(0, 33410)), new Pair.ptr(new $Int64(0, 45763), new $Int64(0, 16707)), new Pair.ptr(new $Int64(0, 45767), new $Int64(0, 33002)), new Pair.ptr(new $Int64(0, 45779), new $Int64(0, 32814)), new Pair.ptr(new $Int64(0, 45817), new $Int64(0, 42219)), new Pair.ptr(new $Int64(0, 45821), new $Int64(0, 465)), new Pair.ptr(new $Int64(0, 45823), new $Int64(0, 27189)), new Pair.ptr(new $Int64(0, 45827), new $Int64(0, 32473)), new Pair.ptr(new $Int64(0, 45833), new $Int64(0, 6129)), new Pair.ptr(new $Int64(0, 45841), new $Int64(0, 38376)), new Pair.ptr(new $Int64(0, 45853), new $Int64(0, 41533)), new Pair.ptr(new $Int64(0, 45863), new $Int64(0, 2502)), new Pair.ptr(new $Int64(0, 45869), new $Int64(0, 5671)), new Pair.ptr(new $Int64(0, 45887), new $Int64(0, 35839)), new Pair.ptr(new $Int64(0, 45893), new $Int64(0, 26241)), new Pair.ptr(new $Int64(0, 45943), new $Int64(0, 16199)), new Pair.ptr(new $Int64(0, 45949), new $Int64(0, 28051)), new Pair.ptr(new $Int64(0, 45953), new $Int64(0, 42733)), new Pair.ptr(new $Int64(0, 45959), new $Int64(0, 9183)), new Pair.ptr(new $Int64(0, 45971), new $Int64(0, 36644)), new Pair.ptr(new $Int64(0, 45979), new $Int64(0, 33432)), new Pair.ptr(new $Int64(0, 45989), new $Int64(0, 3940)), new Pair.ptr(new $Int64(0, 46021), new $Int64(0, 37952)), new Pair.ptr(new $Int64(0, 46027), new $Int64(0, 13364)), new Pair.ptr(new $Int64(0, 46049), new $Int64(0, 32490)), new Pair.ptr(new $Int64(0, 46051), new $Int64(0, 26556)), new Pair.ptr(new $Int64(0, 46061), new $Int64(0, 32908)), new Pair.ptr(new $Int64(0, 46073), new $Int64(0, 40129)), new Pair.ptr(new $Int64(0, 46091), new $Int64(0, 29925)), new Pair.ptr(new $Int64(0, 46093), new $Int64(0, 6064)), new Pair.ptr(new $Int64(0, 46099), new $Int64(0, 27210)), new Pair.ptr(new $Int64(0, 46103), new $Int64(0, 43690)), new Pair.ptr(new $Int64(0, 46133), new $Int64(0, 38453)), new Pair.ptr(new $Int64(0, 46141), new $Int64(0, 25928)), new Pair.ptr(new $Int64(0, 46147), new $Int64(0, 31747)), new Pair.ptr(new $Int64(0, 46153), new $Int64(0, 35880)), new Pair.ptr(new $Int64(0, 46171), new $Int64(0, 8083)), new Pair.ptr(new $Int64(0, 46181), new $Int64(0, 28980)), new Pair.ptr(new $Int64(0, 46183), new $Int64(0, 38660)), new Pair.ptr(new $Int64(0, 46187), new $Int64(0, 41541)), new Pair.ptr(new $Int64(0, 46199), new $Int64(0, 21323)), new Pair.ptr(new $Int64(0, 46219), new $Int64(0, 38547)), new Pair.ptr(new $Int64(0, 46229), new $Int64(0, 45248)), new Pair.ptr(new $Int64(0, 46237), new $Int64(0, 40181)), new Pair.ptr(new $Int64(0, 46261), new $Int64(0, 5892)), new Pair.ptr(new $Int64(0, 46271), new $Int64(0, 10327)), new Pair.ptr(new $Int64(0, 46273), new $Int64(0, 37545)), new Pair.ptr(new $Int64(0, 46279), new $Int64(0, 29651)), new Pair.ptr(new $Int64(0, 46301), new $Int64(0, 26095)), new Pair.ptr(new $Int64(0, 46307), new $Int64(0, 1032)), new Pair.ptr(new $Int64(0, 46309), new $Int64(0, 9118)), new Pair.ptr(new $Int64(0, 46327), new $Int64(0, 13104)), new Pair.ptr(new $Int64(0, 46337), new $Int64(0, 35878)), new Pair.ptr(new $Int64(0, 46349), new $Int64(0, 41013)), new Pair.ptr(new $Int64(0, 46351), new $Int64(0, 6517)), new Pair.ptr(new $Int64(0, 46381), new $Int64(0, 42419)), new Pair.ptr(new $Int64(0, 46399), new $Int64(0, 30006)), new Pair.ptr(new $Int64(0, 46411), new $Int64(0, 3164)), new Pair.ptr(new $Int64(0, 46439), new $Int64(0, 18743)), new Pair.ptr(new $Int64(0, 46441), new $Int64(0, 12155)), new Pair.ptr(new $Int64(0, 46447), new $Int64(0, 17546)), new Pair.ptr(new $Int64(0, 46451), new $Int64(0, 28813)), new Pair.ptr(new $Int64(0, 46457), new $Int64(0, 37224)), new Pair.ptr(new $Int64(0, 46471), new $Int64(0, 11687)), new Pair.ptr(new $Int64(0, 46477), new $Int64(0, 7331)), new Pair.ptr(new $Int64(0, 46489), new $Int64(0, 25478)), new Pair.ptr(new $Int64(0, 46499), new $Int64(0, 1603)), new Pair.ptr(new $Int64(0, 46507), new $Int64(0, 12760)), new Pair.ptr(new $Int64(0, 46511), new $Int64(0, 18326)), new Pair.ptr(new $Int64(0, 46523), new $Int64(0, 41648)), new Pair.ptr(new $Int64(0, 46549), new $Int64(0, 4422)), new Pair.ptr(new $Int64(0, 46559), new $Int64(0, 419)), new Pair.ptr(new $Int64(0, 46567), new $Int64(0, 937)), new Pair.ptr(new $Int64(0, 46573), new $Int64(0, 24319)), new Pair.ptr(new $Int64(0, 46589), new $Int64(0, 24377)), new Pair.ptr(new $Int64(0, 46591), new $Int64(0, 7342)), new Pair.ptr(new $Int64(0, 46601), new $Int64(0, 22563)), new Pair.ptr(new $Int64(0, 46619), new $Int64(0, 28526)), new Pair.ptr(new $Int64(0, 46633), new $Int64(0, 23768)), new Pair.ptr(new $Int64(0, 46639), new $Int64(0, 44931)), new Pair.ptr(new $Int64(0, 46643), new $Int64(0, 16174)), new Pair.ptr(new $Int64(0, 46649), new $Int64(0, 10917)), new Pair.ptr(new $Int64(0, 46663), new $Int64(0, 40740)), new Pair.ptr(new $Int64(0, 46679), new $Int64(0, 26814)), new Pair.ptr(new $Int64(0, 46681), new $Int64(0, 10026)), new Pair.ptr(new $Int64(0, 46687), new $Int64(0, 35360)), new Pair.ptr(new $Int64(0, 46691), new $Int64(0, 41929)), new Pair.ptr(new $Int64(0, 46703), new $Int64(0, 27369)), new Pair.ptr(new $Int64(0, 46723), new $Int64(0, 17991)), new Pair.ptr(new $Int64(0, 46727), new $Int64(0, 21464)), new Pair.ptr(new $Int64(0, 46747), new $Int64(0, 20905)), new Pair.ptr(new $Int64(0, 46751), new $Int64(0, 9033)), new Pair.ptr(new $Int64(0, 46757), new $Int64(0, 20999)), new Pair.ptr(new $Int64(0, 46769), new $Int64(0, 34680)), new Pair.ptr(new $Int64(0, 46771), new $Int64(0, 41409)), new Pair.ptr(new $Int64(0, 46807), new $Int64(0, 10855)), new Pair.ptr(new $Int64(0, 46811), new $Int64(0, 12435)), new Pair.ptr(new $Int64(0, 46817), new $Int64(0, 45136)), new Pair.ptr(new $Int64(0, 46819), new $Int64(0, 320)), new Pair.ptr(new $Int64(0, 46829), new $Int64(0, 10234)), new Pair.ptr(new $Int64(0, 46831), new $Int64(0, 15146)), new Pair.ptr(new $Int64(0, 46853), new $Int64(0, 28943)), new Pair.ptr(new $Int64(0, 46861), new $Int64(0, 1287)), new Pair.ptr(new $Int64(0, 46867), new $Int64(0, 9675)), new Pair.ptr(new $Int64(0, 46877), new $Int64(0, 36741)), new Pair.ptr(new $Int64(0, 46889), new $Int64(0, 3900)), new Pair.ptr(new $Int64(0, 46901), new $Int64(0, 4318)), new Pair.ptr(new $Int64(0, 46919), new $Int64(0, 6375)), new Pair.ptr(new $Int64(0, 46933), new $Int64(0, 16677)), new Pair.ptr(new $Int64(0, 46957), new $Int64(0, 16648)), new Pair.ptr(new $Int64(0, 46993), new $Int64(0, 24374)), new Pair.ptr(new $Int64(0, 46997), new $Int64(0, 34065)), new Pair.ptr(new $Int64(0, 47017), new $Int64(0, 21014)), new Pair.ptr(new $Int64(0, 47041), new $Int64(0, 28290)), new Pair.ptr(new $Int64(0, 47051), new $Int64(0, 38915)), new Pair.ptr(new $Int64(0, 47057), new $Int64(0, 10627)), new Pair.ptr(new $Int64(0, 47059), new $Int64(0, 1732)), new Pair.ptr(new $Int64(0, 47087), new $Int64(0, 28262)), new Pair.ptr(new $Int64(0, 47093), new $Int64(0, 39065)), new Pair.ptr(new $Int64(0, 47111), new $Int64(0, 7220)), new Pair.ptr(new $Int64(0, 47119), new $Int64(0, 12396)), new Pair.ptr(new $Int64(0, 47123), new $Int64(0, 44586)), new Pair.ptr(new $Int64(0, 47129), new $Int64(0, 30380)), new Pair.ptr(new $Int64(0, 47137), new $Int64(0, 12356)), new Pair.ptr(new $Int64(0, 47143), new $Int64(0, 25900)), new Pair.ptr(new $Int64(0, 47147), new $Int64(0, 10612)), new Pair.ptr(new $Int64(0, 47149), new $Int64(0, 44233)), new Pair.ptr(new $Int64(0, 47161), new $Int64(0, 31189)), new Pair.ptr(new $Int64(0, 47189), new $Int64(0, 8427)), new Pair.ptr(new $Int64(0, 47207), new $Int64(0, 23901)), new Pair.ptr(new $Int64(0, 47221), new $Int64(0, 10826)), new Pair.ptr(new $Int64(0, 47237), new $Int64(0, 4415)), new Pair.ptr(new $Int64(0, 47251), new $Int64(0, 47168)), new Pair.ptr(new $Int64(0, 47269), new $Int64(0, 23143)), new Pair.ptr(new $Int64(0, 47279), new $Int64(0, 6849)), new Pair.ptr(new $Int64(0, 47287), new $Int64(0, 18194)), new Pair.ptr(new $Int64(0, 47293), new $Int64(0, 2017)), new Pair.ptr(new $Int64(0, 47297), new $Int64(0, 1184)), new Pair.ptr(new $Int64(0, 47303), new $Int64(0, 2108)), new Pair.ptr(new $Int64(0, 47309), new $Int64(0, 8732)), new Pair.ptr(new $Int64(0, 47317), new $Int64(0, 29633)), new Pair.ptr(new $Int64(0, 47339), new $Int64(0, 1963)), new Pair.ptr(new $Int64(0, 47351), new $Int64(0, 29253)), new Pair.ptr(new $Int64(0, 47353), new $Int64(0, 43483)), new Pair.ptr(new $Int64(0, 47363), new $Int64(0, 9279)), new Pair.ptr(new $Int64(0, 47381), new $Int64(0, 24479)), new Pair.ptr(new $Int64(0, 47387), new $Int64(0, 32963)), new Pair.ptr(new $Int64(0, 47389), new $Int64(0, 35984)), new Pair.ptr(new $Int64(0, 47407), new $Int64(0, 40736)), new Pair.ptr(new $Int64(0, 47417), new $Int64(0, 29893)), new Pair.ptr(new $Int64(0, 47419), new $Int64(0, 3498)), new Pair.ptr(new $Int64(0, 47431), new $Int64(0, 6811)), new Pair.ptr(new $Int64(0, 47441), new $Int64(0, 41548)), new Pair.ptr(new $Int64(0, 47459), new $Int64(0, 42979)), new Pair.ptr(new $Int64(0, 47491), new $Int64(0, 13011)), new Pair.ptr(new $Int64(0, 47497), new $Int64(0, 14206)), new Pair.ptr(new $Int64(0, 47501), new $Int64(0, 45990)), new Pair.ptr(new $Int64(0, 47507), new $Int64(0, 40640)), new Pair.ptr(new $Int64(0, 47513), new $Int64(0, 373)), new Pair.ptr(new $Int64(0, 47521), new $Int64(0, 23499)), new Pair.ptr(new $Int64(0, 47527), new $Int64(0, 28352)), new Pair.ptr(new $Int64(0, 47533), new $Int64(0, 24108)), new Pair.ptr(new $Int64(0, 47543), new $Int64(0, 41160)), new Pair.ptr(new $Int64(0, 47563), new $Int64(0, 32284)), new Pair.ptr(new $Int64(0, 47569), new $Int64(0, 45126)), new Pair.ptr(new $Int64(0, 47581), new $Int64(0, 34295)), new Pair.ptr(new $Int64(0, 47591), new $Int64(0, 1208)), new Pair.ptr(new $Int64(0, 47599), new $Int64(0, 24743)), new Pair.ptr(new $Int64(0, 47609), new $Int64(0, 15660)), new Pair.ptr(new $Int64(0, 47623), new $Int64(0, 36440)), new Pair.ptr(new $Int64(0, 47629), new $Int64(0, 21416)), new Pair.ptr(new $Int64(0, 47639), new $Int64(0, 5521)), new Pair.ptr(new $Int64(0, 47653), new $Int64(0, 35975)), new Pair.ptr(new $Int64(0, 47657), new $Int64(0, 12286)), new Pair.ptr(new $Int64(0, 47659), new $Int64(0, 25655)), new Pair.ptr(new $Int64(0, 47681), new $Int64(0, 11511)), new Pair.ptr(new $Int64(0, 47699), new $Int64(0, 20419)), new Pair.ptr(new $Int64(0, 47701), new $Int64(0, 37336)), new Pair.ptr(new $Int64(0, 47711), new $Int64(0, 11411)), new Pair.ptr(new $Int64(0, 47713), new $Int64(0, 4871)), new Pair.ptr(new $Int64(0, 47717), new $Int64(0, 36732)), new Pair.ptr(new $Int64(0, 47737), new $Int64(0, 41413)), new Pair.ptr(new $Int64(0, 47741), new $Int64(0, 32439)), new Pair.ptr(new $Int64(0, 47743), new $Int64(0, 41826)), new Pair.ptr(new $Int64(0, 47777), new $Int64(0, 22531)), new Pair.ptr(new $Int64(0, 47779), new $Int64(0, 34884)), new Pair.ptr(new $Int64(0, 47791), new $Int64(0, 33026)), new Pair.ptr(new $Int64(0, 47797), new $Int64(0, 4913)), new Pair.ptr(new $Int64(0, 47807), new $Int64(0, 33088)), new Pair.ptr(new $Int64(0, 47809), new $Int64(0, 42488)), new Pair.ptr(new $Int64(0, 47819), new $Int64(0, 33703)), new Pair.ptr(new $Int64(0, 47837), new $Int64(0, 9250)), new Pair.ptr(new $Int64(0, 47843), new $Int64(0, 29686)), new Pair.ptr(new $Int64(0, 47857), new $Int64(0, 35780)), new Pair.ptr(new $Int64(0, 47869), new $Int64(0, 46104)), new Pair.ptr(new $Int64(0, 47881), new $Int64(0, 29130)), new Pair.ptr(new $Int64(0, 47903), new $Int64(0, 2709)), new Pair.ptr(new $Int64(0, 47911), new $Int64(0, 8603)), new Pair.ptr(new $Int64(0, 47917), new $Int64(0, 17850)), new Pair.ptr(new $Int64(0, 47933), new $Int64(0, 40097)), new Pair.ptr(new $Int64(0, 47939), new $Int64(0, 4574)), new Pair.ptr(new $Int64(0, 47947), new $Int64(0, 44529)), new Pair.ptr(new $Int64(0, 47951), new $Int64(0, 28474)), new Pair.ptr(new $Int64(0, 47963), new $Int64(0, 10834)), new Pair.ptr(new $Int64(0, 47969), new $Int64(0, 27567)), new Pair.ptr(new $Int64(0, 47977), new $Int64(0, 42436)), new Pair.ptr(new $Int64(0, 47981), new $Int64(0, 34088)), new Pair.ptr(new $Int64(0, 48017), new $Int64(0, 29120)), new Pair.ptr(new $Int64(0, 48023), new $Int64(0, 29198)), new Pair.ptr(new $Int64(0, 48029), new $Int64(0, 3539)), new Pair.ptr(new $Int64(0, 48049), new $Int64(0, 28829)), new Pair.ptr(new $Int64(0, 48073), new $Int64(0, 9230)), new Pair.ptr(new $Int64(0, 48079), new $Int64(0, 38153)), new Pair.ptr(new $Int64(0, 48091), new $Int64(0, 36236)), new Pair.ptr(new $Int64(0, 48109), new $Int64(0, 20190)), new Pair.ptr(new $Int64(0, 48119), new $Int64(0, 24805)), new Pair.ptr(new $Int64(0, 48121), new $Int64(0, 22017)), new Pair.ptr(new $Int64(0, 48131), new $Int64(0, 10670)), new Pair.ptr(new $Int64(0, 48157), new $Int64(0, 14668)), new Pair.ptr(new $Int64(0, 48163), new $Int64(0, 46404)), new Pair.ptr(new $Int64(0, 48179), new $Int64(0, 1324)), new Pair.ptr(new $Int64(0, 48187), new $Int64(0, 416)), new Pair.ptr(new $Int64(0, 48193), new $Int64(0, 35829)), new Pair.ptr(new $Int64(0, 48197), new $Int64(0, 18179)), new Pair.ptr(new $Int64(0, 48221), new $Int64(0, 39413)), new Pair.ptr(new $Int64(0, 48239), new $Int64(0, 31469)), new Pair.ptr(new $Int64(0, 48247), new $Int64(0, 25263)), new Pair.ptr(new $Int64(0, 48259), new $Int64(0, 9972)), new Pair.ptr(new $Int64(0, 48271), new $Int64(0, 20434)), new Pair.ptr(new $Int64(0, 48281), new $Int64(0, 30129)), new Pair.ptr(new $Int64(0, 48299), new $Int64(0, 14355)), new Pair.ptr(new $Int64(0, 48311), new $Int64(0, 8707)), new Pair.ptr(new $Int64(0, 48313), new $Int64(0, 22935)), new Pair.ptr(new $Int64(0, 48337), new $Int64(0, 42851)), new Pair.ptr(new $Int64(0, 48341), new $Int64(0, 24154)), new Pair.ptr(new $Int64(0, 48353), new $Int64(0, 44675)), new Pair.ptr(new $Int64(0, 48371), new $Int64(0, 37349)), new Pair.ptr(new $Int64(0, 48383), new $Int64(0, 33767)), new Pair.ptr(new $Int64(0, 48397), new $Int64(0, 47038)), new Pair.ptr(new $Int64(0, 48407), new $Int64(0, 31714)), new Pair.ptr(new $Int64(0, 48409), new $Int64(0, 20195)), new Pair.ptr(new $Int64(0, 48413), new $Int64(0, 41224)), new Pair.ptr(new $Int64(0, 48437), new $Int64(0, 41738)), new Pair.ptr(new $Int64(0, 48449), new $Int64(0, 7805)), new Pair.ptr(new $Int64(0, 48463), new $Int64(0, 29288)), new Pair.ptr(new $Int64(0, 48473), new $Int64(0, 1688)), new Pair.ptr(new $Int64(0, 48479), new $Int64(0, 45622)), new Pair.ptr(new $Int64(0, 48481), new $Int64(0, 18743)), new Pair.ptr(new $Int64(0, 48487), new $Int64(0, 3446)), new Pair.ptr(new $Int64(0, 48491), new $Int64(0, 25767)), new Pair.ptr(new $Int64(0, 48497), new $Int64(0, 42686)), new Pair.ptr(new $Int64(0, 48523), new $Int64(0, 18878)), new Pair.ptr(new $Int64(0, 48527), new $Int64(0, 21903)), new Pair.ptr(new $Int64(0, 48533), new $Int64(0, 5884)), new Pair.ptr(new $Int64(0, 48539), new $Int64(0, 39108)), new Pair.ptr(new $Int64(0, 48541), new $Int64(0, 34599)), new Pair.ptr(new $Int64(0, 48563), new $Int64(0, 14220)), new Pair.ptr(new $Int64(0, 48571), new $Int64(0, 35142)), new Pair.ptr(new $Int64(0, 48589), new $Int64(0, 26459)), new Pair.ptr(new $Int64(0, 48593), new $Int64(0, 45722)), new Pair.ptr(new $Int64(0, 48611), new $Int64(0, 37680)), new Pair.ptr(new $Int64(0, 48619), new $Int64(0, 1158)), new Pair.ptr(new $Int64(0, 48623), new $Int64(0, 44378)), new Pair.ptr(new $Int64(0, 48647), new $Int64(0, 32989)), new Pair.ptr(new $Int64(0, 48649), new $Int64(0, 5472)), new Pair.ptr(new $Int64(0, 48661), new $Int64(0, 5906)), new Pair.ptr(new $Int64(0, 48673), new $Int64(0, 24905)), new Pair.ptr(new $Int64(0, 48677), new $Int64(0, 15880)), new Pair.ptr(new $Int64(0, 48679), new $Int64(0, 37462)), new Pair.ptr(new $Int64(0, 48731), new $Int64(0, 27355)), new Pair.ptr(new $Int64(0, 48733), new $Int64(0, 29439)), new Pair.ptr(new $Int64(0, 48751), new $Int64(0, 8072)), new Pair.ptr(new $Int64(0, 48757), new $Int64(0, 17481)), new Pair.ptr(new $Int64(0, 48761), new $Int64(0, 33059)), new Pair.ptr(new $Int64(0, 48767), new $Int64(0, 624)), new Pair.ptr(new $Int64(0, 48779), new $Int64(0, 37742)), new Pair.ptr(new $Int64(0, 48781), new $Int64(0, 22587)), new Pair.ptr(new $Int64(0, 48787), new $Int64(0, 10510)), new Pair.ptr(new $Int64(0, 48799), new $Int64(0, 18298)), new Pair.ptr(new $Int64(0, 48809), new $Int64(0, 744)), new Pair.ptr(new $Int64(0, 48817), new $Int64(0, 12455)), new Pair.ptr(new $Int64(0, 48821), new $Int64(0, 48341)), new Pair.ptr(new $Int64(0, 48823), new $Int64(0, 9752)), new Pair.ptr(new $Int64(0, 48847), new $Int64(0, 30213)), new Pair.ptr(new $Int64(0, 48857), new $Int64(0, 45004)), new Pair.ptr(new $Int64(0, 48859), new $Int64(0, 14977)), new Pair.ptr(new $Int64(0, 48869), new $Int64(0, 48369)), new Pair.ptr(new $Int64(0, 48871), new $Int64(0, 35237)), new Pair.ptr(new $Int64(0, 48883), new $Int64(0, 5784)), new Pair.ptr(new $Int64(0, 48889), new $Int64(0, 43692)), new Pair.ptr(new $Int64(0, 48907), new $Int64(0, 10829)), new Pair.ptr(new $Int64(0, 48947), new $Int64(0, 22606)), new Pair.ptr(new $Int64(0, 48953), new $Int64(0, 12268)), new Pair.ptr(new $Int64(0, 48973), new $Int64(0, 41815)), new Pair.ptr(new $Int64(0, 48989), new $Int64(0, 38504)), new Pair.ptr(new $Int64(0, 48991), new $Int64(0, 9580)), new Pair.ptr(new $Int64(0, 49003), new $Int64(0, 47556)), new Pair.ptr(new $Int64(0, 49009), new $Int64(0, 39197)), new Pair.ptr(new $Int64(0, 49019), new $Int64(0, 11288)), new Pair.ptr(new $Int64(0, 49031), new $Int64(0, 35434)), new Pair.ptr(new $Int64(0, 49033), new $Int64(0, 10394)), new Pair.ptr(new $Int64(0, 49037), new $Int64(0, 17810)), new Pair.ptr(new $Int64(0, 49043), new $Int64(0, 18868)), new Pair.ptr(new $Int64(0, 49057), new $Int64(0, 17221)), new Pair.ptr(new $Int64(0, 49069), new $Int64(0, 33142)), new Pair.ptr(new $Int64(0, 49081), new $Int64(0, 23633)), new Pair.ptr(new $Int64(0, 49103), new $Int64(0, 13814)), new Pair.ptr(new $Int64(0, 49109), new $Int64(0, 19514)), new Pair.ptr(new $Int64(0, 49117), new $Int64(0, 40672)), new Pair.ptr(new $Int64(0, 49121), new $Int64(0, 12104)), new Pair.ptr(new $Int64(0, 49123), new $Int64(0, 14842)), new Pair.ptr(new $Int64(0, 49139), new $Int64(0, 2234)), new Pair.ptr(new $Int64(0, 49157), new $Int64(0, 3023)), new Pair.ptr(new $Int64(0, 49169), new $Int64(0, 36607)), new Pair.ptr(new $Int64(0, 49171), new $Int64(0, 11752)), new Pair.ptr(new $Int64(0, 49177), new $Int64(0, 12989)), new Pair.ptr(new $Int64(0, 49193), new $Int64(0, 40291)), new Pair.ptr(new $Int64(0, 49199), new $Int64(0, 3146)), new Pair.ptr(new $Int64(0, 49201), new $Int64(0, 20201)), new Pair.ptr(new $Int64(0, 49207), new $Int64(0, 15590)), new Pair.ptr(new $Int64(0, 49211), new $Int64(0, 33868)), new Pair.ptr(new $Int64(0, 49223), new $Int64(0, 620)), new Pair.ptr(new $Int64(0, 49253), new $Int64(0, 38495)), new Pair.ptr(new $Int64(0, 49261), new $Int64(0, 33439)), new Pair.ptr(new $Int64(0, 49277), new $Int64(0, 19374)), new Pair.ptr(new $Int64(0, 49279), new $Int64(0, 21481)), new Pair.ptr(new $Int64(0, 49297), new $Int64(0, 44687)), new Pair.ptr(new $Int64(0, 49307), new $Int64(0, 38584)), new Pair.ptr(new $Int64(0, 49331), new $Int64(0, 18279)), new Pair.ptr(new $Int64(0, 49333), new $Int64(0, 44488)), new Pair.ptr(new $Int64(0, 49339), new $Int64(0, 46916)), new Pair.ptr(new $Int64(0, 49363), new $Int64(0, 19550)), new Pair.ptr(new $Int64(0, 49367), new $Int64(0, 40579)), new Pair.ptr(new $Int64(0, 49369), new $Int64(0, 46439)), new Pair.ptr(new $Int64(0, 49391), new $Int64(0, 36681)), new Pair.ptr(new $Int64(0, 49393), new $Int64(0, 10569)), new Pair.ptr(new $Int64(0, 49409), new $Int64(0, 31751)), new Pair.ptr(new $Int64(0, 49411), new $Int64(0, 27457)), new Pair.ptr(new $Int64(0, 49417), new $Int64(0, 40797)), new Pair.ptr(new $Int64(0, 49429), new $Int64(0, 42471)), new Pair.ptr(new $Int64(0, 49433), new $Int64(0, 45821)), new Pair.ptr(new $Int64(0, 49451), new $Int64(0, 34873)), new Pair.ptr(new $Int64(0, 49459), new $Int64(0, 45449)), new Pair.ptr(new $Int64(0, 49463), new $Int64(0, 14360)), new Pair.ptr(new $Int64(0, 49477), new $Int64(0, 38993)), new Pair.ptr(new $Int64(0, 49481), new $Int64(0, 26429)), new Pair.ptr(new $Int64(0, 49499), new $Int64(0, 4080)), new Pair.ptr(new $Int64(0, 49523), new $Int64(0, 13759)), new Pair.ptr(new $Int64(0, 49529), new $Int64(0, 18815)), new Pair.ptr(new $Int64(0, 49531), new $Int64(0, 6593)), new Pair.ptr(new $Int64(0, 49537), new $Int64(0, 19369)), new Pair.ptr(new $Int64(0, 49547), new $Int64(0, 15112)), new Pair.ptr(new $Int64(0, 49549), new $Int64(0, 3717)), new Pair.ptr(new $Int64(0, 49559), new $Int64(0, 18715)), new Pair.ptr(new $Int64(0, 49597), new $Int64(0, 18129)), new Pair.ptr(new $Int64(0, 49603), new $Int64(0, 46949)), new Pair.ptr(new $Int64(0, 49613), new $Int64(0, 12706)), new Pair.ptr(new $Int64(0, 49627), new $Int64(0, 11038)), new Pair.ptr(new $Int64(0, 49633), new $Int64(0, 47560)), new Pair.ptr(new $Int64(0, 49639), new $Int64(0, 29721)), new Pair.ptr(new $Int64(0, 49663), new $Int64(0, 25548)), new Pair.ptr(new $Int64(0, 49667), new $Int64(0, 17431)), new Pair.ptr(new $Int64(0, 49669), new $Int64(0, 24715)), new Pair.ptr(new $Int64(0, 49681), new $Int64(0, 26602)), new Pair.ptr(new $Int64(0, 49697), new $Int64(0, 37437)), new Pair.ptr(new $Int64(0, 49711), new $Int64(0, 23328)), new Pair.ptr(new $Int64(0, 49727), new $Int64(0, 30393)), new Pair.ptr(new $Int64(0, 49739), new $Int64(0, 32373)), new Pair.ptr(new $Int64(0, 49741), new $Int64(0, 36796)), new Pair.ptr(new $Int64(0, 49747), new $Int64(0, 25626)), new Pair.ptr(new $Int64(0, 49757), new $Int64(0, 43969)), new Pair.ptr(new $Int64(0, 49783), new $Int64(0, 24068)), new Pair.ptr(new $Int64(0, 49787), new $Int64(0, 10112)), new Pair.ptr(new $Int64(0, 49789), new $Int64(0, 18806)), new Pair.ptr(new $Int64(0, 49801), new $Int64(0, 16517)), new Pair.ptr(new $Int64(0, 49807), new $Int64(0, 25433)), new Pair.ptr(new $Int64(0, 49811), new $Int64(0, 43437)), new Pair.ptr(new $Int64(0, 49823), new $Int64(0, 49256)), new Pair.ptr(new $Int64(0, 49831), new $Int64(0, 23683)), new Pair.ptr(new $Int64(0, 49843), new $Int64(0, 20487)), new Pair.ptr(new $Int64(0, 49853), new $Int64(0, 46036)), new Pair.ptr(new $Int64(0, 49871), new $Int64(0, 47201)), new Pair.ptr(new $Int64(0, 49877), new $Int64(0, 28230)), new Pair.ptr(new $Int64(0, 49891), new $Int64(0, 27325)), new Pair.ptr(new $Int64(0, 49919), new $Int64(0, 7780)), new Pair.ptr(new $Int64(0, 49921), new $Int64(0, 18801)), new Pair.ptr(new $Int64(0, 49927), new $Int64(0, 21953)), new Pair.ptr(new $Int64(0, 49937), new $Int64(0, 28688)), new Pair.ptr(new $Int64(0, 49939), new $Int64(0, 2287)), new Pair.ptr(new $Int64(0, 49943), new $Int64(0, 1128)), new Pair.ptr(new $Int64(0, 49957), new $Int64(0, 14817)), new Pair.ptr(new $Int64(0, 49991), new $Int64(0, 41871)), new Pair.ptr(new $Int64(0, 49993), new $Int64(0, 42611)), new Pair.ptr(new $Int64(0, 49999), new $Int64(0, 32434)), new Pair.ptr(new $Int64(0, 50021), new $Int64(0, 3306)), new Pair.ptr(new $Int64(0, 50023), new $Int64(0, 46472)), new Pair.ptr(new $Int64(0, 50033), new $Int64(0, 5641)), new Pair.ptr(new $Int64(0, 50047), new $Int64(0, 34755)), new Pair.ptr(new $Int64(0, 50051), new $Int64(0, 29196)), new Pair.ptr(new $Int64(0, 50053), new $Int64(0, 23636)), new Pair.ptr(new $Int64(0, 50069), new $Int64(0, 5490)), new Pair.ptr(new $Int64(0, 50077), new $Int64(0, 11901)), new Pair.ptr(new $Int64(0, 50087), new $Int64(0, 26510)), new Pair.ptr(new $Int64(0, 50093), new $Int64(0, 26891)), new Pair.ptr(new $Int64(0, 50101), new $Int64(0, 25951)), new Pair.ptr(new $Int64(0, 50111), new $Int64(0, 20195)), new Pair.ptr(new $Int64(0, 50119), new $Int64(0, 5024)), new Pair.ptr(new $Int64(0, 50123), new $Int64(0, 12073)), new Pair.ptr(new $Int64(0, 50129), new $Int64(0, 30511)), new Pair.ptr(new $Int64(0, 50131), new $Int64(0, 40177)), new Pair.ptr(new $Int64(0, 50147), new $Int64(0, 39592)), new Pair.ptr(new $Int64(0, 50153), new $Int64(0, 22439)), new Pair.ptr(new $Int64(0, 50159), new $Int64(0, 4410)), new Pair.ptr(new $Int64(0, 50177), new $Int64(0, 8725)), new Pair.ptr(new $Int64(0, 50207), new $Int64(0, 36003)), new Pair.ptr(new $Int64(0, 50221), new $Int64(0, 8052)), new Pair.ptr(new $Int64(0, 50227), new $Int64(0, 13881)), new Pair.ptr(new $Int64(0, 50231), new $Int64(0, 1827)), new Pair.ptr(new $Int64(0, 50261), new $Int64(0, 9548)), new Pair.ptr(new $Int64(0, 50263), new $Int64(0, 33489)), new Pair.ptr(new $Int64(0, 50273), new $Int64(0, 10389)), new Pair.ptr(new $Int64(0, 50287), new $Int64(0, 24171)), new Pair.ptr(new $Int64(0, 50291), new $Int64(0, 34762)), new Pair.ptr(new $Int64(0, 50311), new $Int64(0, 39693)), new Pair.ptr(new $Int64(0, 50321), new $Int64(0, 45880)), new Pair.ptr(new $Int64(0, 50329), new $Int64(0, 34169)), new Pair.ptr(new $Int64(0, 50333), new $Int64(0, 21891)), new Pair.ptr(new $Int64(0, 50341), new $Int64(0, 27232)), new Pair.ptr(new $Int64(0, 50359), new $Int64(0, 21499)), new Pair.ptr(new $Int64(0, 50363), new $Int64(0, 13288)), new Pair.ptr(new $Int64(0, 50377), new $Int64(0, 15470)), new Pair.ptr(new $Int64(0, 50383), new $Int64(0, 4829)), new Pair.ptr(new $Int64(0, 50387), new $Int64(0, 7264)), new Pair.ptr(new $Int64(0, 50411), new $Int64(0, 20190)), new Pair.ptr(new $Int64(0, 50417), new $Int64(0, 7155)), new Pair.ptr(new $Int64(0, 50423), new $Int64(0, 40228)), new Pair.ptr(new $Int64(0, 50441), new $Int64(0, 6332)), new Pair.ptr(new $Int64(0, 50459), new $Int64(0, 3403)), new Pair.ptr(new $Int64(0, 50461), new $Int64(0, 28658)), new Pair.ptr(new $Int64(0, 50497), new $Int64(0, 11118)), new Pair.ptr(new $Int64(0, 50503), new $Int64(0, 40460)), new Pair.ptr(new $Int64(0, 50513), new $Int64(0, 15283)), new Pair.ptr(new $Int64(0, 50527), new $Int64(0, 13232)), new Pair.ptr(new $Int64(0, 50539), new $Int64(0, 48360)), new Pair.ptr(new $Int64(0, 50543), new $Int64(0, 25075)), new Pair.ptr(new $Int64(0, 50549), new $Int64(0, 43669)), new Pair.ptr(new $Int64(0, 50551), new $Int64(0, 4633)), new Pair.ptr(new $Int64(0, 50581), new $Int64(0, 24330)), new Pair.ptr(new $Int64(0, 50587), new $Int64(0, 45869)), new Pair.ptr(new $Int64(0, 50591), new $Int64(0, 26706)), new Pair.ptr(new $Int64(0, 50593), new $Int64(0, 14667)), new Pair.ptr(new $Int64(0, 50599), new $Int64(0, 15384)), new Pair.ptr(new $Int64(0, 50627), new $Int64(0, 44624)), new Pair.ptr(new $Int64(0, 50647), new $Int64(0, 36133)), new Pair.ptr(new $Int64(0, 50651), new $Int64(0, 4853)), new Pair.ptr(new $Int64(0, 50671), new $Int64(0, 15578)), new Pair.ptr(new $Int64(0, 50683), new $Int64(0, 17288)), new Pair.ptr(new $Int64(0, 50707), new $Int64(0, 48308)), new Pair.ptr(new $Int64(0, 50723), new $Int64(0, 34412)), new Pair.ptr(new $Int64(0, 50741), new $Int64(0, 667)), new Pair.ptr(new $Int64(0, 50753), new $Int64(0, 48160)), new Pair.ptr(new $Int64(0, 50767), new $Int64(0, 13447)), new Pair.ptr(new $Int64(0, 50773), new $Int64(0, 25802)), new Pair.ptr(new $Int64(0, 50777), new $Int64(0, 39468)), new Pair.ptr(new $Int64(0, 50789), new $Int64(0, 50726)), new Pair.ptr(new $Int64(0, 50821), new $Int64(0, 37138)), new Pair.ptr(new $Int64(0, 50833), new $Int64(0, 50081)), new Pair.ptr(new $Int64(0, 50839), new $Int64(0, 24802)), new Pair.ptr(new $Int64(0, 50849), new $Int64(0, 20434)), new Pair.ptr(new $Int64(0, 50857), new $Int64(0, 50064)), new Pair.ptr(new $Int64(0, 50867), new $Int64(0, 5453)), new Pair.ptr(new $Int64(0, 50873), new $Int64(0, 25658)), new Pair.ptr(new $Int64(0, 50891), new $Int64(0, 44633)), new Pair.ptr(new $Int64(0, 50893), new $Int64(0, 43251)), new Pair.ptr(new $Int64(0, 50909), new $Int64(0, 242)), new Pair.ptr(new $Int64(0, 50923), new $Int64(0, 45960)), new Pair.ptr(new $Int64(0, 50929), new $Int64(0, 47245)), new Pair.ptr(new $Int64(0, 50951), new $Int64(0, 8063)), new Pair.ptr(new $Int64(0, 50957), new $Int64(0, 25736)), new Pair.ptr(new $Int64(0, 50969), new $Int64(0, 27458)), new Pair.ptr(new $Int64(0, 50971), new $Int64(0, 9127)), new Pair.ptr(new $Int64(0, 50989), new $Int64(0, 18648)), new Pair.ptr(new $Int64(0, 50993), new $Int64(0, 49916)), new Pair.ptr(new $Int64(0, 51001), new $Int64(0, 25067)), new Pair.ptr(new $Int64(0, 51031), new $Int64(0, 25069)), new Pair.ptr(new $Int64(0, 51043), new $Int64(0, 41632)), new Pair.ptr(new $Int64(0, 51047), new $Int64(0, 28395)), new Pair.ptr(new $Int64(0, 51059), new $Int64(0, 6861)), new Pair.ptr(new $Int64(0, 51061), new $Int64(0, 50678)), new Pair.ptr(new $Int64(0, 51071), new $Int64(0, 33643)), new Pair.ptr(new $Int64(0, 51109), new $Int64(0, 49633)), new Pair.ptr(new $Int64(0, 51131), new $Int64(0, 49645)), new Pair.ptr(new $Int64(0, 51133), new $Int64(0, 21030)), new Pair.ptr(new $Int64(0, 51137), new $Int64(0, 41638)), new Pair.ptr(new $Int64(0, 51151), new $Int64(0, 50729)), new Pair.ptr(new $Int64(0, 51157), new $Int64(0, 30658)), new Pair.ptr(new $Int64(0, 51169), new $Int64(0, 10765)), new Pair.ptr(new $Int64(0, 51193), new $Int64(0, 48390)), new Pair.ptr(new $Int64(0, 51197), new $Int64(0, 14912)), new Pair.ptr(new $Int64(0, 51199), new $Int64(0, 5388)), new Pair.ptr(new $Int64(0, 51203), new $Int64(0, 9929)), new Pair.ptr(new $Int64(0, 51217), new $Int64(0, 2476)), new Pair.ptr(new $Int64(0, 51229), new $Int64(0, 22830)), new Pair.ptr(new $Int64(0, 51239), new $Int64(0, 1792)), new Pair.ptr(new $Int64(0, 51241), new $Int64(0, 44074)), new Pair.ptr(new $Int64(0, 51257), new $Int64(0, 26630)), new Pair.ptr(new $Int64(0, 51263), new $Int64(0, 23691)), new Pair.ptr(new $Int64(0, 51283), new $Int64(0, 46746)), new Pair.ptr(new $Int64(0, 51287), new $Int64(0, 6036)), new Pair.ptr(new $Int64(0, 51307), new $Int64(0, 21099)), new Pair.ptr(new $Int64(0, 51329), new $Int64(0, 22678)), new Pair.ptr(new $Int64(0, 51341), new $Int64(0, 47964)), new Pair.ptr(new $Int64(0, 51343), new $Int64(0, 41492)), new Pair.ptr(new $Int64(0, 51347), new $Int64(0, 9762)), new Pair.ptr(new $Int64(0, 51349), new $Int64(0, 56)), new Pair.ptr(new $Int64(0, 51361), new $Int64(0, 7029)), new Pair.ptr(new $Int64(0, 51383), new $Int64(0, 48129)), new Pair.ptr(new $Int64(0, 51407), new $Int64(0, 24949)), new Pair.ptr(new $Int64(0, 51413), new $Int64(0, 17430)), new Pair.ptr(new $Int64(0, 51419), new $Int64(0, 31309)), new Pair.ptr(new $Int64(0, 51421), new $Int64(0, 20419)), new Pair.ptr(new $Int64(0, 51427), new $Int64(0, 33684)), new Pair.ptr(new $Int64(0, 51431), new $Int64(0, 43334)), new Pair.ptr(new $Int64(0, 51437), new $Int64(0, 31785)), new Pair.ptr(new $Int64(0, 51439), new $Int64(0, 2330)), new Pair.ptr(new $Int64(0, 51449), new $Int64(0, 48841)), new Pair.ptr(new $Int64(0, 51461), new $Int64(0, 46431)), new Pair.ptr(new $Int64(0, 51473), new $Int64(0, 2101)), new Pair.ptr(new $Int64(0, 51479), new $Int64(0, 29417)), new Pair.ptr(new $Int64(0, 51481), new $Int64(0, 7354)), new Pair.ptr(new $Int64(0, 51487), new $Int64(0, 12609)), new Pair.ptr(new $Int64(0, 51503), new $Int64(0, 33269)), new Pair.ptr(new $Int64(0, 51511), new $Int64(0, 32046)), new Pair.ptr(new $Int64(0, 51517), new $Int64(0, 19294)), new Pair.ptr(new $Int64(0, 51521), new $Int64(0, 34467)), new Pair.ptr(new $Int64(0, 51539), new $Int64(0, 8985)), new Pair.ptr(new $Int64(0, 51551), new $Int64(0, 3008)), new Pair.ptr(new $Int64(0, 51563), new $Int64(0, 51208)), new Pair.ptr(new $Int64(0, 51577), new $Int64(0, 40107)), new Pair.ptr(new $Int64(0, 51581), new $Int64(0, 15467)), new Pair.ptr(new $Int64(0, 51593), new $Int64(0, 7827)), new Pair.ptr(new $Int64(0, 51599), new $Int64(0, 7681)), new Pair.ptr(new $Int64(0, 51607), new $Int64(0, 37849)), new Pair.ptr(new $Int64(0, 51613), new $Int64(0, 4934)), new Pair.ptr(new $Int64(0, 51631), new $Int64(0, 6692)), new Pair.ptr(new $Int64(0, 51637), new $Int64(0, 29037)), new Pair.ptr(new $Int64(0, 51647), new $Int64(0, 39409)), new Pair.ptr(new $Int64(0, 51659), new $Int64(0, 40280)), new Pair.ptr(new $Int64(0, 51673), new $Int64(0, 23446)), new Pair.ptr(new $Int64(0, 51679), new $Int64(0, 7865)), new Pair.ptr(new $Int64(0, 51683), new $Int64(0, 16476)), new Pair.ptr(new $Int64(0, 51691), new $Int64(0, 38742)), new Pair.ptr(new $Int64(0, 51713), new $Int64(0, 13063)), new Pair.ptr(new $Int64(0, 51719), new $Int64(0, 44176)), new Pair.ptr(new $Int64(0, 51721), new $Int64(0, 27746)), new Pair.ptr(new $Int64(0, 51749), new $Int64(0, 15445)), new Pair.ptr(new $Int64(0, 51767), new $Int64(0, 17625)), new Pair.ptr(new $Int64(0, 51769), new $Int64(0, 26665)), new Pair.ptr(new $Int64(0, 51787), new $Int64(0, 35834)), new Pair.ptr(new $Int64(0, 51797), new $Int64(0, 42460)), new Pair.ptr(new $Int64(0, 51803), new $Int64(0, 5957)), new Pair.ptr(new $Int64(0, 51817), new $Int64(0, 36463)), new Pair.ptr(new $Int64(0, 51827), new $Int64(0, 8300)), new Pair.ptr(new $Int64(0, 51829), new $Int64(0, 38527)), new Pair.ptr(new $Int64(0, 51839), new $Int64(0, 14708)), new Pair.ptr(new $Int64(0, 51853), new $Int64(0, 33344)), new Pair.ptr(new $Int64(0, 51859), new $Int64(0, 2893)), new Pair.ptr(new $Int64(0, 51869), new $Int64(0, 10610)), new Pair.ptr(new $Int64(0, 51871), new $Int64(0, 5894)), new Pair.ptr(new $Int64(0, 51893), new $Int64(0, 17178)), new Pair.ptr(new $Int64(0, 51899), new $Int64(0, 37460)), new Pair.ptr(new $Int64(0, 51907), new $Int64(0, 21968)), new Pair.ptr(new $Int64(0, 51913), new $Int64(0, 8204)), new Pair.ptr(new $Int64(0, 51929), new $Int64(0, 11582)), new Pair.ptr(new $Int64(0, 51941), new $Int64(0, 1513)), new Pair.ptr(new $Int64(0, 51949), new $Int64(0, 26109)), new Pair.ptr(new $Int64(0, 51971), new $Int64(0, 18115)), new Pair.ptr(new $Int64(0, 51973), new $Int64(0, 17741)), new Pair.ptr(new $Int64(0, 51977), new $Int64(0, 49228)), new Pair.ptr(new $Int64(0, 51991), new $Int64(0, 38837)), new Pair.ptr(new $Int64(0, 52009), new $Int64(0, 21489)), new Pair.ptr(new $Int64(0, 52021), new $Int64(0, 19410)), new Pair.ptr(new $Int64(0, 52027), new $Int64(0, 50709)), new Pair.ptr(new $Int64(0, 52051), new $Int64(0, 29496)), new Pair.ptr(new $Int64(0, 52057), new $Int64(0, 37828)), new Pair.ptr(new $Int64(0, 52067), new $Int64(0, 45009)), new Pair.ptr(new $Int64(0, 52069), new $Int64(0, 43595)), new Pair.ptr(new $Int64(0, 52081), new $Int64(0, 4370)), new Pair.ptr(new $Int64(0, 52103), new $Int64(0, 15699)), new Pair.ptr(new $Int64(0, 52121), new $Int64(0, 4356)), new Pair.ptr(new $Int64(0, 52127), new $Int64(0, 30558)), new Pair.ptr(new $Int64(0, 52147), new $Int64(0, 37125)), new Pair.ptr(new $Int64(0, 52153), new $Int64(0, 12410)), new Pair.ptr(new $Int64(0, 52163), new $Int64(0, 47166)), new Pair.ptr(new $Int64(0, 52177), new $Int64(0, 16961)), new Pair.ptr(new $Int64(0, 52181), new $Int64(0, 40356)), new Pair.ptr(new $Int64(0, 52183), new $Int64(0, 41441)), new Pair.ptr(new $Int64(0, 52189), new $Int64(0, 51516)), new Pair.ptr(new $Int64(0, 52201), new $Int64(0, 7509)), new Pair.ptr(new $Int64(0, 52223), new $Int64(0, 49281)), new Pair.ptr(new $Int64(0, 52237), new $Int64(0, 1873)), new Pair.ptr(new $Int64(0, 52249), new $Int64(0, 1388)), new Pair.ptr(new $Int64(0, 52253), new $Int64(0, 32331)), new Pair.ptr(new $Int64(0, 52259), new $Int64(0, 28166)), new Pair.ptr(new $Int64(0, 52267), new $Int64(0, 14497)), new Pair.ptr(new $Int64(0, 52289), new $Int64(0, 13804)), new Pair.ptr(new $Int64(0, 52291), new $Int64(0, 14535)), new Pair.ptr(new $Int64(0, 52301), new $Int64(0, 42800)), new Pair.ptr(new $Int64(0, 52313), new $Int64(0, 29938)), new Pair.ptr(new $Int64(0, 52321), new $Int64(0, 22841)), new Pair.ptr(new $Int64(0, 52361), new $Int64(0, 21481)), new Pair.ptr(new $Int64(0, 52363), new $Int64(0, 15664)), new Pair.ptr(new $Int64(0, 52369), new $Int64(0, 39687)), new Pair.ptr(new $Int64(0, 52379), new $Int64(0, 4736)), new Pair.ptr(new $Int64(0, 52387), new $Int64(0, 3383)), new Pair.ptr(new $Int64(0, 52391), new $Int64(0, 35664)), new Pair.ptr(new $Int64(0, 52433), new $Int64(0, 23721)), new Pair.ptr(new $Int64(0, 52453), new $Int64(0, 48664)), new Pair.ptr(new $Int64(0, 52457), new $Int64(0, 40407)), new Pair.ptr(new $Int64(0, 52489), new $Int64(0, 36422)), new Pair.ptr(new $Int64(0, 52501), new $Int64(0, 33960)), new Pair.ptr(new $Int64(0, 52511), new $Int64(0, 41044)), new Pair.ptr(new $Int64(0, 52517), new $Int64(0, 28570)), new Pair.ptr(new $Int64(0, 52529), new $Int64(0, 2375)), new Pair.ptr(new $Int64(0, 52541), new $Int64(0, 49400)), new Pair.ptr(new $Int64(0, 52543), new $Int64(0, 30074)), new Pair.ptr(new $Int64(0, 52553), new $Int64(0, 45983)), new Pair.ptr(new $Int64(0, 52561), new $Int64(0, 42899)), new Pair.ptr(new $Int64(0, 52567), new $Int64(0, 34667)), new Pair.ptr(new $Int64(0, 52571), new $Int64(0, 888)), new Pair.ptr(new $Int64(0, 52579), new $Int64(0, 35342)), new Pair.ptr(new $Int64(0, 52583), new $Int64(0, 13900)), new Pair.ptr(new $Int64(0, 52609), new $Int64(0, 46964)), new Pair.ptr(new $Int64(0, 52627), new $Int64(0, 14702)), new Pair.ptr(new $Int64(0, 52631), new $Int64(0, 46974)), new Pair.ptr(new $Int64(0, 52639), new $Int64(0, 34725)), new Pair.ptr(new $Int64(0, 52667), new $Int64(0, 48211)), new Pair.ptr(new $Int64(0, 52673), new $Int64(0, 4781)), new Pair.ptr(new $Int64(0, 52691), new $Int64(0, 31315)), new Pair.ptr(new $Int64(0, 52697), new $Int64(0, 2530)), new Pair.ptr(new $Int64(0, 52709), new $Int64(0, 38795)), new Pair.ptr(new $Int64(0, 52711), new $Int64(0, 21471)), new Pair.ptr(new $Int64(0, 52721), new $Int64(0, 52545)), new Pair.ptr(new $Int64(0, 52727), new $Int64(0, 51084)), new Pair.ptr(new $Int64(0, 52733), new $Int64(0, 493)), new Pair.ptr(new $Int64(0, 52747), new $Int64(0, 13102)), new Pair.ptr(new $Int64(0, 52757), new $Int64(0, 18107)), new Pair.ptr(new $Int64(0, 52769), new $Int64(0, 2544)), new Pair.ptr(new $Int64(0, 52783), new $Int64(0, 28524)), new Pair.ptr(new $Int64(0, 52807), new $Int64(0, 6549)), new Pair.ptr(new $Int64(0, 52813), new $Int64(0, 41295)), new Pair.ptr(new $Int64(0, 52817), new $Int64(0, 21953)), new Pair.ptr(new $Int64(0, 52837), new $Int64(0, 25014)), new Pair.ptr(new $Int64(0, 52859), new $Int64(0, 40582)), new Pair.ptr(new $Int64(0, 52861), new $Int64(0, 36358)), new Pair.ptr(new $Int64(0, 52879), new $Int64(0, 49569)), new Pair.ptr(new $Int64(0, 52883), new $Int64(0, 17651)), new Pair.ptr(new $Int64(0, 52889), new $Int64(0, 3448)), new Pair.ptr(new $Int64(0, 52901), new $Int64(0, 39116)), new Pair.ptr(new $Int64(0, 52903), new $Int64(0, 46875)), new Pair.ptr(new $Int64(0, 52919), new $Int64(0, 50329)), new Pair.ptr(new $Int64(0, 52937), new $Int64(0, 41570)), new Pair.ptr(new $Int64(0, 52951), new $Int64(0, 12100)), new Pair.ptr(new $Int64(0, 52957), new $Int64(0, 32689)), new Pair.ptr(new $Int64(0, 52963), new $Int64(0, 47907)), new Pair.ptr(new $Int64(0, 52967), new $Int64(0, 38088)), new Pair.ptr(new $Int64(0, 52973), new $Int64(0, 50981)), new Pair.ptr(new $Int64(0, 52981), new $Int64(0, 47873)), new Pair.ptr(new $Int64(0, 52999), new $Int64(0, 35439)), new Pair.ptr(new $Int64(0, 53003), new $Int64(0, 14567)), new Pair.ptr(new $Int64(0, 53017), new $Int64(0, 29098)), new Pair.ptr(new $Int64(0, 53047), new $Int64(0, 39859)), new Pair.ptr(new $Int64(0, 53051), new $Int64(0, 3758)), new Pair.ptr(new $Int64(0, 53069), new $Int64(0, 39166)), new Pair.ptr(new $Int64(0, 53077), new $Int64(0, 17121)), new Pair.ptr(new $Int64(0, 53087), new $Int64(0, 36159)), new Pair.ptr(new $Int64(0, 53089), new $Int64(0, 40763)), new Pair.ptr(new $Int64(0, 53093), new $Int64(0, 7975)), new Pair.ptr(new $Int64(0, 53101), new $Int64(0, 2148)), new Pair.ptr(new $Int64(0, 53113), new $Int64(0, 8712)), new Pair.ptr(new $Int64(0, 53117), new $Int64(0, 16108)), new Pair.ptr(new $Int64(0, 53129), new $Int64(0, 5109)), new Pair.ptr(new $Int64(0, 53147), new $Int64(0, 1503)), new Pair.ptr(new $Int64(0, 53149), new $Int64(0, 37172)), new Pair.ptr(new $Int64(0, 53161), new $Int64(0, 44026)), new Pair.ptr(new $Int64(0, 53171), new $Int64(0, 10300)), new Pair.ptr(new $Int64(0, 53173), new $Int64(0, 27181)), new Pair.ptr(new $Int64(0, 53189), new $Int64(0, 12049)), new Pair.ptr(new $Int64(0, 53197), new $Int64(0, 9879)), new Pair.ptr(new $Int64(0, 53201), new $Int64(0, 4712)), new Pair.ptr(new $Int64(0, 53231), new $Int64(0, 22835)), new Pair.ptr(new $Int64(0, 53233), new $Int64(0, 51116)), new Pair.ptr(new $Int64(0, 53239), new $Int64(0, 7411)), new Pair.ptr(new $Int64(0, 53267), new $Int64(0, 5391)), new Pair.ptr(new $Int64(0, 53269), new $Int64(0, 44919)), new Pair.ptr(new $Int64(0, 53279), new $Int64(0, 39973)), new Pair.ptr(new $Int64(0, 53281), new $Int64(0, 8516)), new Pair.ptr(new $Int64(0, 53299), new $Int64(0, 10268)), new Pair.ptr(new $Int64(0, 53309), new $Int64(0, 10372)), new Pair.ptr(new $Int64(0, 53323), new $Int64(0, 9399)), new Pair.ptr(new $Int64(0, 53327), new $Int64(0, 40318)), new Pair.ptr(new $Int64(0, 53353), new $Int64(0, 38386)), new Pair.ptr(new $Int64(0, 53359), new $Int64(0, 3643)), new Pair.ptr(new $Int64(0, 53377), new $Int64(0, 41720)), new Pair.ptr(new $Int64(0, 53381), new $Int64(0, 13607)), new Pair.ptr(new $Int64(0, 53401), new $Int64(0, 10349)), new Pair.ptr(new $Int64(0, 53407), new $Int64(0, 42317)), new Pair.ptr(new $Int64(0, 53411), new $Int64(0, 34144)), new Pair.ptr(new $Int64(0, 53419), new $Int64(0, 50849)), new Pair.ptr(new $Int64(0, 53437), new $Int64(0, 15689)), new Pair.ptr(new $Int64(0, 53441), new $Int64(0, 1530)), new Pair.ptr(new $Int64(0, 53453), new $Int64(0, 44768)), new Pair.ptr(new $Int64(0, 53479), new $Int64(0, 1995)), new Pair.ptr(new $Int64(0, 53503), new $Int64(0, 45429)), new Pair.ptr(new $Int64(0, 53507), new $Int64(0, 6324)), new Pair.ptr(new $Int64(0, 53527), new $Int64(0, 34498)), new Pair.ptr(new $Int64(0, 53549), new $Int64(0, 843)), new Pair.ptr(new $Int64(0, 53551), new $Int64(0, 3838)), new Pair.ptr(new $Int64(0, 53569), new $Int64(0, 44396)), new Pair.ptr(new $Int64(0, 53591), new $Int64(0, 33804)), new Pair.ptr(new $Int64(0, 53593), new $Int64(0, 47821)), new Pair.ptr(new $Int64(0, 53597), new $Int64(0, 9400)), new Pair.ptr(new $Int64(0, 53609), new $Int64(0, 27702)), new Pair.ptr(new $Int64(0, 53611), new $Int64(0, 33165)), new Pair.ptr(new $Int64(0, 53617), new $Int64(0, 33391)), new Pair.ptr(new $Int64(0, 53623), new $Int64(0, 479)), new Pair.ptr(new $Int64(0, 53629), new $Int64(0, 49080)), new Pair.ptr(new $Int64(0, 53633), new $Int64(0, 48964)), new Pair.ptr(new $Int64(0, 53639), new $Int64(0, 18541)), new Pair.ptr(new $Int64(0, 53653), new $Int64(0, 42327)), new Pair.ptr(new $Int64(0, 53657), new $Int64(0, 42189)), new Pair.ptr(new $Int64(0, 53681), new $Int64(0, 7275)), new Pair.ptr(new $Int64(0, 53693), new $Int64(0, 28609)), new Pair.ptr(new $Int64(0, 53699), new $Int64(0, 32590)), new Pair.ptr(new $Int64(0, 53717), new $Int64(0, 20905)), new Pair.ptr(new $Int64(0, 53719), new $Int64(0, 13542)), new Pair.ptr(new $Int64(0, 53731), new $Int64(0, 20303)), new Pair.ptr(new $Int64(0, 53759), new $Int64(0, 8647)), new Pair.ptr(new $Int64(0, 53773), new $Int64(0, 47525)), new Pair.ptr(new $Int64(0, 53777), new $Int64(0, 38469)), new Pair.ptr(new $Int64(0, 53783), new $Int64(0, 1161)), new Pair.ptr(new $Int64(0, 53791), new $Int64(0, 52165)), new Pair.ptr(new $Int64(0, 53813), new $Int64(0, 13029)), new Pair.ptr(new $Int64(0, 53819), new $Int64(0, 26211)), new Pair.ptr(new $Int64(0, 53831), new $Int64(0, 39118)), new Pair.ptr(new $Int64(0, 53849), new $Int64(0, 41490)), new Pair.ptr(new $Int64(0, 53857), new $Int64(0, 15624)), new Pair.ptr(new $Int64(0, 53861), new $Int64(0, 2107)), new Pair.ptr(new $Int64(0, 53881), new $Int64(0, 17924)), new Pair.ptr(new $Int64(0, 53887), new $Int64(0, 40867)), new Pair.ptr(new $Int64(0, 53891), new $Int64(0, 48287)), new Pair.ptr(new $Int64(0, 53897), new $Int64(0, 43993)), new Pair.ptr(new $Int64(0, 53899), new $Int64(0, 29714)), new Pair.ptr(new $Int64(0, 53917), new $Int64(0, 17769)), new Pair.ptr(new $Int64(0, 53923), new $Int64(0, 49745)), new Pair.ptr(new $Int64(0, 53927), new $Int64(0, 19384)), new Pair.ptr(new $Int64(0, 53939), new $Int64(0, 53212)), new Pair.ptr(new $Int64(0, 53951), new $Int64(0, 26216)), new Pair.ptr(new $Int64(0, 53959), new $Int64(0, 32631)), new Pair.ptr(new $Int64(0, 53987), new $Int64(0, 46453)), new Pair.ptr(new $Int64(0, 53993), new $Int64(0, 28634)), new Pair.ptr(new $Int64(0, 54001), new $Int64(0, 31127)), new Pair.ptr(new $Int64(0, 54011), new $Int64(0, 21416)), new Pair.ptr(new $Int64(0, 54013), new $Int64(0, 13635)), new Pair.ptr(new $Int64(0, 54037), new $Int64(0, 25906)), new Pair.ptr(new $Int64(0, 54049), new $Int64(0, 31889)), new Pair.ptr(new $Int64(0, 54059), new $Int64(0, 27570)), new Pair.ptr(new $Int64(0, 54083), new $Int64(0, 46903)), new Pair.ptr(new $Int64(0, 54091), new $Int64(0, 16008)), new Pair.ptr(new $Int64(0, 54101), new $Int64(0, 14331)), new Pair.ptr(new $Int64(0, 54121), new $Int64(0, 23789)), new Pair.ptr(new $Int64(0, 54133), new $Int64(0, 20317)), new Pair.ptr(new $Int64(0, 54139), new $Int64(0, 39203)), new Pair.ptr(new $Int64(0, 54151), new $Int64(0, 30118)), new Pair.ptr(new $Int64(0, 54163), new $Int64(0, 46287)), new Pair.ptr(new $Int64(0, 54167), new $Int64(0, 51938)), new Pair.ptr(new $Int64(0, 54181), new $Int64(0, 50960)), new Pair.ptr(new $Int64(0, 54193), new $Int64(0, 30274)), new Pair.ptr(new $Int64(0, 54217), new $Int64(0, 21903)), new Pair.ptr(new $Int64(0, 54251), new $Int64(0, 537)), new Pair.ptr(new $Int64(0, 54269), new $Int64(0, 3294)), new Pair.ptr(new $Int64(0, 54277), new $Int64(0, 31118)), new Pair.ptr(new $Int64(0, 54287), new $Int64(0, 42020)), new Pair.ptr(new $Int64(0, 54293), new $Int64(0, 3328)), new Pair.ptr(new $Int64(0, 54311), new $Int64(0, 24926)), new Pair.ptr(new $Int64(0, 54319), new $Int64(0, 33934)), new Pair.ptr(new $Int64(0, 54323), new $Int64(0, 11945)), new Pair.ptr(new $Int64(0, 54331), new $Int64(0, 31765)), new Pair.ptr(new $Int64(0, 54347), new $Int64(0, 35307)), new Pair.ptr(new $Int64(0, 54361), new $Int64(0, 25578)), new Pair.ptr(new $Int64(0, 54367), new $Int64(0, 34279)), new Pair.ptr(new $Int64(0, 54371), new $Int64(0, 40298)), new Pair.ptr(new $Int64(0, 54377), new $Int64(0, 50143)), new Pair.ptr(new $Int64(0, 54401), new $Int64(0, 19981)), new Pair.ptr(new $Int64(0, 54403), new $Int64(0, 28394)), new Pair.ptr(new $Int64(0, 54409), new $Int64(0, 26829)), new Pair.ptr(new $Int64(0, 54413), new $Int64(0, 11163)), new Pair.ptr(new $Int64(0, 54419), new $Int64(0, 82)), new Pair.ptr(new $Int64(0, 54421), new $Int64(0, 49446)), new Pair.ptr(new $Int64(0, 54437), new $Int64(0, 9928)), new Pair.ptr(new $Int64(0, 54443), new $Int64(0, 22414)), new Pair.ptr(new $Int64(0, 54449), new $Int64(0, 10621)), new Pair.ptr(new $Int64(0, 54469), new $Int64(0, 41088)), new Pair.ptr(new $Int64(0, 54493), new $Int64(0, 33844)), new Pair.ptr(new $Int64(0, 54497), new $Int64(0, 37133)), new Pair.ptr(new $Int64(0, 54499), new $Int64(0, 31787)), new Pair.ptr(new $Int64(0, 54503), new $Int64(0, 23446)), new Pair.ptr(new $Int64(0, 54517), new $Int64(0, 36484)), new Pair.ptr(new $Int64(0, 54521), new $Int64(0, 23402)), new Pair.ptr(new $Int64(0, 54539), new $Int64(0, 14793)), new Pair.ptr(new $Int64(0, 54541), new $Int64(0, 43616)), new Pair.ptr(new $Int64(0, 54547), new $Int64(0, 47062)), new Pair.ptr(new $Int64(0, 54559), new $Int64(0, 4597)), new Pair.ptr(new $Int64(0, 54563), new $Int64(0, 32711)), new Pair.ptr(new $Int64(0, 54577), new $Int64(0, 47674)), new Pair.ptr(new $Int64(0, 54581), new $Int64(0, 35778)), new Pair.ptr(new $Int64(0, 54583), new $Int64(0, 33859)), new Pair.ptr(new $Int64(0, 54601), new $Int64(0, 9927)), new Pair.ptr(new $Int64(0, 54617), new $Int64(0, 50528)), new Pair.ptr(new $Int64(0, 54623), new $Int64(0, 21806)), new Pair.ptr(new $Int64(0, 54629), new $Int64(0, 3425)), new Pair.ptr(new $Int64(0, 54631), new $Int64(0, 35406)), new Pair.ptr(new $Int64(0, 54647), new $Int64(0, 5285)), new Pair.ptr(new $Int64(0, 54667), new $Int64(0, 14835)), new Pair.ptr(new $Int64(0, 54673), new $Int64(0, 11098)), new Pair.ptr(new $Int64(0, 54679), new $Int64(0, 36180)), new Pair.ptr(new $Int64(0, 54709), new $Int64(0, 32579)), new Pair.ptr(new $Int64(0, 54713), new $Int64(0, 10432)), new Pair.ptr(new $Int64(0, 54721), new $Int64(0, 34658)), new Pair.ptr(new $Int64(0, 54727), new $Int64(0, 2468)), new Pair.ptr(new $Int64(0, 54751), new $Int64(0, 29139)), new Pair.ptr(new $Int64(0, 54767), new $Int64(0, 45346)), new Pair.ptr(new $Int64(0, 54773), new $Int64(0, 30826)), new Pair.ptr(new $Int64(0, 54779), new $Int64(0, 44847)), new Pair.ptr(new $Int64(0, 54787), new $Int64(0, 33586)), new Pair.ptr(new $Int64(0, 54799), new $Int64(0, 49617)), new Pair.ptr(new $Int64(0, 54829), new $Int64(0, 19176)), new Pair.ptr(new $Int64(0, 54833), new $Int64(0, 25245)), new Pair.ptr(new $Int64(0, 54851), new $Int64(0, 8324)), new Pair.ptr(new $Int64(0, 54869), new $Int64(0, 52718)), new Pair.ptr(new $Int64(0, 54877), new $Int64(0, 47799)), new Pair.ptr(new $Int64(0, 54881), new $Int64(0, 50531)), new Pair.ptr(new $Int64(0, 54907), new $Int64(0, 11609)), new Pair.ptr(new $Int64(0, 54917), new $Int64(0, 46444)), new Pair.ptr(new $Int64(0, 54919), new $Int64(0, 47970)), new Pair.ptr(new $Int64(0, 54941), new $Int64(0, 26848)), new Pair.ptr(new $Int64(0, 54949), new $Int64(0, 39419)), new Pair.ptr(new $Int64(0, 54959), new $Int64(0, 22017)), new Pair.ptr(new $Int64(0, 54973), new $Int64(0, 16788)), new Pair.ptr(new $Int64(0, 54979), new $Int64(0, 211)), new Pair.ptr(new $Int64(0, 54983), new $Int64(0, 37769)), new Pair.ptr(new $Int64(0, 55001), new $Int64(0, 35861)), new Pair.ptr(new $Int64(0, 55009), new $Int64(0, 6627)), new Pair.ptr(new $Int64(0, 55021), new $Int64(0, 34051)), new Pair.ptr(new $Int64(0, 55049), new $Int64(0, 29436)), new Pair.ptr(new $Int64(0, 55051), new $Int64(0, 17777)), new Pair.ptr(new $Int64(0, 55057), new $Int64(0, 12617)), new Pair.ptr(new $Int64(0, 55061), new $Int64(0, 30207)), new Pair.ptr(new $Int64(0, 55073), new $Int64(0, 11601)), new Pair.ptr(new $Int64(0, 55079), new $Int64(0, 5833)), new Pair.ptr(new $Int64(0, 55103), new $Int64(0, 45393)), new Pair.ptr(new $Int64(0, 55109), new $Int64(0, 23770)), new Pair.ptr(new $Int64(0, 55117), new $Int64(0, 52413)), new Pair.ptr(new $Int64(0, 55127), new $Int64(0, 21853)), new Pair.ptr(new $Int64(0, 55147), new $Int64(0, 20805)), new Pair.ptr(new $Int64(0, 55163), new $Int64(0, 33732)), new Pair.ptr(new $Int64(0, 55171), new $Int64(0, 28398)), new Pair.ptr(new $Int64(0, 55201), new $Int64(0, 3198)), new Pair.ptr(new $Int64(0, 55207), new $Int64(0, 30948)), new Pair.ptr(new $Int64(0, 55213), new $Int64(0, 47860)), new Pair.ptr(new $Int64(0, 55217), new $Int64(0, 46284)), new Pair.ptr(new $Int64(0, 55219), new $Int64(0, 1922)), new Pair.ptr(new $Int64(0, 55229), new $Int64(0, 8980)), new Pair.ptr(new $Int64(0, 55243), new $Int64(0, 44285)), new Pair.ptr(new $Int64(0, 55249), new $Int64(0, 18357)), new Pair.ptr(new $Int64(0, 55259), new $Int64(0, 51478)), new Pair.ptr(new $Int64(0, 55291), new $Int64(0, 48897)), new Pair.ptr(new $Int64(0, 55313), new $Int64(0, 18393)), new Pair.ptr(new $Int64(0, 55331), new $Int64(0, 14643)), new Pair.ptr(new $Int64(0, 55333), new $Int64(0, 11536)), new Pair.ptr(new $Int64(0, 55337), new $Int64(0, 28805)), new Pair.ptr(new $Int64(0, 55339), new $Int64(0, 2866)), new Pair.ptr(new $Int64(0, 55343), new $Int64(0, 14132)), new Pair.ptr(new $Int64(0, 55351), new $Int64(0, 52959)), new Pair.ptr(new $Int64(0, 55373), new $Int64(0, 20598)), new Pair.ptr(new $Int64(0, 55381), new $Int64(0, 18340)), new Pair.ptr(new $Int64(0, 55399), new $Int64(0, 20164)), new Pair.ptr(new $Int64(0, 55411), new $Int64(0, 13963)), new Pair.ptr(new $Int64(0, 55439), new $Int64(0, 4265)), new Pair.ptr(new $Int64(0, 55441), new $Int64(0, 21323)), new Pair.ptr(new $Int64(0, 55457), new $Int64(0, 47427)), new Pair.ptr(new $Int64(0, 55469), new $Int64(0, 24424)), new Pair.ptr(new $Int64(0, 55487), new $Int64(0, 37960)), new Pair.ptr(new $Int64(0, 55501), new $Int64(0, 36954)), new Pair.ptr(new $Int64(0, 55511), new $Int64(0, 55090)), new Pair.ptr(new $Int64(0, 55529), new $Int64(0, 23757)), new Pair.ptr(new $Int64(0, 55541), new $Int64(0, 35575)), new Pair.ptr(new $Int64(0, 55547), new $Int64(0, 26875)), new Pair.ptr(new $Int64(0, 55579), new $Int64(0, 3045)), new Pair.ptr(new $Int64(0, 55589), new $Int64(0, 36361)), new Pair.ptr(new $Int64(0, 55603), new $Int64(0, 50906)), new Pair.ptr(new $Int64(0, 55609), new $Int64(0, 5366)), new Pair.ptr(new $Int64(0, 55619), new $Int64(0, 22587)), new Pair.ptr(new $Int64(0, 55621), new $Int64(0, 29477)), new Pair.ptr(new $Int64(0, 55631), new $Int64(0, 49985)), new Pair.ptr(new $Int64(0, 55633), new $Int64(0, 42972)), new Pair.ptr(new $Int64(0, 55639), new $Int64(0, 6022)), new Pair.ptr(new $Int64(0, 55661), new $Int64(0, 49442)), new Pair.ptr(new $Int64(0, 55663), new $Int64(0, 30414)), new Pair.ptr(new $Int64(0, 55667), new $Int64(0, 37388)), new Pair.ptr(new $Int64(0, 55673), new $Int64(0, 50159)), new Pair.ptr(new $Int64(0, 55681), new $Int64(0, 31706)), new Pair.ptr(new $Int64(0, 55691), new $Int64(0, 4557)), new Pair.ptr(new $Int64(0, 55697), new $Int64(0, 48912)), new Pair.ptr(new $Int64(0, 55711), new $Int64(0, 44009)), new Pair.ptr(new $Int64(0, 55717), new $Int64(0, 34504)), new Pair.ptr(new $Int64(0, 55721), new $Int64(0, 13118)), new Pair.ptr(new $Int64(0, 55733), new $Int64(0, 8984)), new Pair.ptr(new $Int64(0, 55763), new $Int64(0, 24183)), new Pair.ptr(new $Int64(0, 55787), new $Int64(0, 48169)), new Pair.ptr(new $Int64(0, 55793), new $Int64(0, 42018)), new Pair.ptr(new $Int64(0, 55799), new $Int64(0, 34840)), new Pair.ptr(new $Int64(0, 55807), new $Int64(0, 26880)), new Pair.ptr(new $Int64(0, 55813), new $Int64(0, 3384)), new Pair.ptr(new $Int64(0, 55817), new $Int64(0, 1230)), new Pair.ptr(new $Int64(0, 55819), new $Int64(0, 46665)), new Pair.ptr(new $Int64(0, 55823), new $Int64(0, 17266)), new Pair.ptr(new $Int64(0, 55829), new $Int64(0, 7739)), new Pair.ptr(new $Int64(0, 55837), new $Int64(0, 34913)), new Pair.ptr(new $Int64(0, 55843), new $Int64(0, 2814)), new Pair.ptr(new $Int64(0, 55849), new $Int64(0, 31333)), new Pair.ptr(new $Int64(0, 55871), new $Int64(0, 14758)), new Pair.ptr(new $Int64(0, 55889), new $Int64(0, 30276)), new Pair.ptr(new $Int64(0, 55897), new $Int64(0, 38999)), new Pair.ptr(new $Int64(0, 55901), new $Int64(0, 29886)), new Pair.ptr(new $Int64(0, 55903), new $Int64(0, 27306)), new Pair.ptr(new $Int64(0, 55921), new $Int64(0, 29217)), new Pair.ptr(new $Int64(0, 55927), new $Int64(0, 29452)), new Pair.ptr(new $Int64(0, 55931), new $Int64(0, 54529)), new Pair.ptr(new $Int64(0, 55933), new $Int64(0, 55357)), new Pair.ptr(new $Int64(0, 55949), new $Int64(0, 9656)), new Pair.ptr(new $Int64(0, 55967), new $Int64(0, 42929)), new Pair.ptr(new $Int64(0, 55987), new $Int64(0, 12117)), new Pair.ptr(new $Int64(0, 55997), new $Int64(0, 55301)), new Pair.ptr(new $Int64(0, 56003), new $Int64(0, 20147)), new Pair.ptr(new $Int64(0, 56009), new $Int64(0, 45840)), new Pair.ptr(new $Int64(0, 56039), new $Int64(0, 14724)), new Pair.ptr(new $Int64(0, 56041), new $Int64(0, 24409)), new Pair.ptr(new $Int64(0, 56053), new $Int64(0, 13702)), new Pair.ptr(new $Int64(0, 56081), new $Int64(0, 18245)), new Pair.ptr(new $Int64(0, 56087), new $Int64(0, 51986)), new Pair.ptr(new $Int64(0, 56093), new $Int64(0, 4447)), new Pair.ptr(new $Int64(0, 56099), new $Int64(0, 38530)), new Pair.ptr(new $Int64(0, 56101), new $Int64(0, 31749)), new Pair.ptr(new $Int64(0, 56113), new $Int64(0, 48500)), new Pair.ptr(new $Int64(0, 56123), new $Int64(0, 12509)), new Pair.ptr(new $Int64(0, 56131), new $Int64(0, 19808)), new Pair.ptr(new $Int64(0, 56149), new $Int64(0, 1127)), new Pair.ptr(new $Int64(0, 56167), new $Int64(0, 15214)), new Pair.ptr(new $Int64(0, 56171), new $Int64(0, 5438)), new Pair.ptr(new $Int64(0, 56179), new $Int64(0, 49267)), new Pair.ptr(new $Int64(0, 56197), new $Int64(0, 45861)), new Pair.ptr(new $Int64(0, 56207), new $Int64(0, 40474)), new Pair.ptr(new $Int64(0, 56209), new $Int64(0, 21259)), new Pair.ptr(new $Int64(0, 56237), new $Int64(0, 10481)), new Pair.ptr(new $Int64(0, 56239), new $Int64(0, 50359)), new Pair.ptr(new $Int64(0, 56249), new $Int64(0, 2487)), new Pair.ptr(new $Int64(0, 56263), new $Int64(0, 17196)), new Pair.ptr(new $Int64(0, 56267), new $Int64(0, 19129)), new Pair.ptr(new $Int64(0, 56269), new $Int64(0, 45931)), new Pair.ptr(new $Int64(0, 56299), new $Int64(0, 45379)), new Pair.ptr(new $Int64(0, 56311), new $Int64(0, 27044)), new Pair.ptr(new $Int64(0, 56333), new $Int64(0, 20730)), new Pair.ptr(new $Int64(0, 56359), new $Int64(0, 45174)), new Pair.ptr(new $Int64(0, 56369), new $Int64(0, 23328)), new Pair.ptr(new $Int64(0, 56377), new $Int64(0, 1768)), new Pair.ptr(new $Int64(0, 56383), new $Int64(0, 48325)), new Pair.ptr(new $Int64(0, 56393), new $Int64(0, 39146)), new Pair.ptr(new $Int64(0, 56401), new $Int64(0, 15607)), new Pair.ptr(new $Int64(0, 56417), new $Int64(0, 31058)), new Pair.ptr(new $Int64(0, 56431), new $Int64(0, 28060)), new Pair.ptr(new $Int64(0, 56437), new $Int64(0, 46226)), new Pair.ptr(new $Int64(0, 56443), new $Int64(0, 11415)), new Pair.ptr(new $Int64(0, 56453), new $Int64(0, 16770)), new Pair.ptr(new $Int64(0, 56467), new $Int64(0, 40539)), new Pair.ptr(new $Int64(0, 56473), new $Int64(0, 42831)), new Pair.ptr(new $Int64(0, 56477), new $Int64(0, 9623)), new Pair.ptr(new $Int64(0, 56479), new $Int64(0, 5323)), new Pair.ptr(new $Int64(0, 56489), new $Int64(0, 18073)), new Pair.ptr(new $Int64(0, 56501), new $Int64(0, 32013)), new Pair.ptr(new $Int64(0, 56503), new $Int64(0, 43517)), new Pair.ptr(new $Int64(0, 56509), new $Int64(0, 53748)), new Pair.ptr(new $Int64(0, 56519), new $Int64(0, 25578)), new Pair.ptr(new $Int64(0, 56527), new $Int64(0, 8)), new Pair.ptr(new $Int64(0, 56531), new $Int64(0, 29531)), new Pair.ptr(new $Int64(0, 56533), new $Int64(0, 45898)), new Pair.ptr(new $Int64(0, 56543), new $Int64(0, 32966)), new Pair.ptr(new $Int64(0, 56569), new $Int64(0, 52364)), new Pair.ptr(new $Int64(0, 56591), new $Int64(0, 52374)), new Pair.ptr(new $Int64(0, 56597), new $Int64(0, 38366)), new Pair.ptr(new $Int64(0, 56599), new $Int64(0, 24898)), new Pair.ptr(new $Int64(0, 56611), new $Int64(0, 22692)), new Pair.ptr(new $Int64(0, 56629), new $Int64(0, 29932)), new Pair.ptr(new $Int64(0, 56633), new $Int64(0, 24433)), new Pair.ptr(new $Int64(0, 56659), new $Int64(0, 8538)), new Pair.ptr(new $Int64(0, 56663), new $Int64(0, 3261)), new Pair.ptr(new $Int64(0, 56671), new $Int64(0, 38653)), new Pair.ptr(new $Int64(0, 56681), new $Int64(0, 36560)), new Pair.ptr(new $Int64(0, 56687), new $Int64(0, 51183)), new Pair.ptr(new $Int64(0, 56701), new $Int64(0, 46193)), new Pair.ptr(new $Int64(0, 56711), new $Int64(0, 32826)), new Pair.ptr(new $Int64(0, 56713), new $Int64(0, 28509)), new Pair.ptr(new $Int64(0, 56731), new $Int64(0, 41726)), new Pair.ptr(new $Int64(0, 56737), new $Int64(0, 21334)), new Pair.ptr(new $Int64(0, 56747), new $Int64(0, 9258)), new Pair.ptr(new $Int64(0, 56767), new $Int64(0, 20764)), new Pair.ptr(new $Int64(0, 56773), new $Int64(0, 46263)), new Pair.ptr(new $Int64(0, 56779), new $Int64(0, 37371)), new Pair.ptr(new $Int64(0, 56783), new $Int64(0, 18584)), new Pair.ptr(new $Int64(0, 56807), new $Int64(0, 28875)), new Pair.ptr(new $Int64(0, 56809), new $Int64(0, 23302)), new Pair.ptr(new $Int64(0, 56813), new $Int64(0, 1496)), new Pair.ptr(new $Int64(0, 56821), new $Int64(0, 10359)), new Pair.ptr(new $Int64(0, 56827), new $Int64(0, 50051)), new Pair.ptr(new $Int64(0, 56843), new $Int64(0, 55827)), new Pair.ptr(new $Int64(0, 56857), new $Int64(0, 43588)), new Pair.ptr(new $Int64(0, 56873), new $Int64(0, 37377)), new Pair.ptr(new $Int64(0, 56891), new $Int64(0, 14317)), new Pair.ptr(new $Int64(0, 56893), new $Int64(0, 47327)), new Pair.ptr(new $Int64(0, 56897), new $Int64(0, 1538)), new Pair.ptr(new $Int64(0, 56909), new $Int64(0, 56611)), new Pair.ptr(new $Int64(0, 56911), new $Int64(0, 497)), new Pair.ptr(new $Int64(0, 56921), new $Int64(0, 48770)), new Pair.ptr(new $Int64(0, 56923), new $Int64(0, 40855)), new Pair.ptr(new $Int64(0, 56929), new $Int64(0, 2991)), new Pair.ptr(new $Int64(0, 56941), new $Int64(0, 31428)), new Pair.ptr(new $Int64(0, 56951), new $Int64(0, 39906)), new Pair.ptr(new $Int64(0, 56957), new $Int64(0, 17557)), new Pair.ptr(new $Int64(0, 56963), new $Int64(0, 3136)), new Pair.ptr(new $Int64(0, 56983), new $Int64(0, 23621)), new Pair.ptr(new $Int64(0, 56989), new $Int64(0, 27845)), new Pair.ptr(new $Int64(0, 56993), new $Int64(0, 44459)), new Pair.ptr(new $Int64(0, 56999), new $Int64(0, 7346)), new Pair.ptr(new $Int64(0, 57037), new $Int64(0, 36575)), new Pair.ptr(new $Int64(0, 57041), new $Int64(0, 19697)), new Pair.ptr(new $Int64(0, 57047), new $Int64(0, 17542)), new Pair.ptr(new $Int64(0, 57059), new $Int64(0, 713)), new Pair.ptr(new $Int64(0, 57073), new $Int64(0, 28804)), new Pair.ptr(new $Int64(0, 57077), new $Int64(0, 46161)), new Pair.ptr(new $Int64(0, 57089), new $Int64(0, 23683)), new Pair.ptr(new $Int64(0, 57097), new $Int64(0, 29512)), new Pair.ptr(new $Int64(0, 57107), new $Int64(0, 46171)), new Pair.ptr(new $Int64(0, 57119), new $Int64(0, 41941)), new Pair.ptr(new $Int64(0, 57131), new $Int64(0, 24879)), new Pair.ptr(new $Int64(0, 57139), new $Int64(0, 32071)), new Pair.ptr(new $Int64(0, 57143), new $Int64(0, 20814)), new Pair.ptr(new $Int64(0, 57149), new $Int64(0, 9178)), new Pair.ptr(new $Int64(0, 57163), new $Int64(0, 8534)), new Pair.ptr(new $Int64(0, 57173), new $Int64(0, 17041)), new Pair.ptr(new $Int64(0, 57179), new $Int64(0, 9854)), new Pair.ptr(new $Int64(0, 57191), new $Int64(0, 7565)), new Pair.ptr(new $Int64(0, 57193), new $Int64(0, 56804)), new Pair.ptr(new $Int64(0, 57203), new $Int64(0, 48123)), new Pair.ptr(new $Int64(0, 57221), new $Int64(0, 1038)), new Pair.ptr(new $Int64(0, 57223), new $Int64(0, 34239)), new Pair.ptr(new $Int64(0, 57241), new $Int64(0, 11036)), new Pair.ptr(new $Int64(0, 57251), new $Int64(0, 18068)), new Pair.ptr(new $Int64(0, 57259), new $Int64(0, 39975)), new Pair.ptr(new $Int64(0, 57269), new $Int64(0, 35057)), new Pair.ptr(new $Int64(0, 57271), new $Int64(0, 49704)), new Pair.ptr(new $Int64(0, 57283), new $Int64(0, 29611)), new Pair.ptr(new $Int64(0, 57287), new $Int64(0, 32610)), new Pair.ptr(new $Int64(0, 57301), new $Int64(0, 47197)), new Pair.ptr(new $Int64(0, 57329), new $Int64(0, 9121)), new Pair.ptr(new $Int64(0, 57331), new $Int64(0, 29968)), new Pair.ptr(new $Int64(0, 57347), new $Int64(0, 4830)), new Pair.ptr(new $Int64(0, 57349), new $Int64(0, 54948)), new Pair.ptr(new $Int64(0, 57367), new $Int64(0, 16456)), new Pair.ptr(new $Int64(0, 57373), new $Int64(0, 6459)), new Pair.ptr(new $Int64(0, 57383), new $Int64(0, 6570)), new Pair.ptr(new $Int64(0, 57389), new $Int64(0, 4974)), new Pair.ptr(new $Int64(0, 57397), new $Int64(0, 35143)), new Pair.ptr(new $Int64(0, 57413), new $Int64(0, 2028)), new Pair.ptr(new $Int64(0, 57427), new $Int64(0, 31418)), new Pair.ptr(new $Int64(0, 57457), new $Int64(0, 11732)), new Pair.ptr(new $Int64(0, 57467), new $Int64(0, 3003)), new Pair.ptr(new $Int64(0, 57487), new $Int64(0, 16835)), new Pair.ptr(new $Int64(0, 57493), new $Int64(0, 45701)), new Pair.ptr(new $Int64(0, 57503), new $Int64(0, 25828)), new Pair.ptr(new $Int64(0, 57527), new $Int64(0, 47114)), new Pair.ptr(new $Int64(0, 57529), new $Int64(0, 14172)), new Pair.ptr(new $Int64(0, 57557), new $Int64(0, 11992)), new Pair.ptr(new $Int64(0, 57559), new $Int64(0, 13590)), new Pair.ptr(new $Int64(0, 57571), new $Int64(0, 15370)), new Pair.ptr(new $Int64(0, 57587), new $Int64(0, 25906)), new Pair.ptr(new $Int64(0, 57593), new $Int64(0, 31061)), new Pair.ptr(new $Int64(0, 57601), new $Int64(0, 54263)), new Pair.ptr(new $Int64(0, 57637), new $Int64(0, 16116)), new Pair.ptr(new $Int64(0, 57641), new $Int64(0, 5278)), new Pair.ptr(new $Int64(0, 57649), new $Int64(0, 1877)), new Pair.ptr(new $Int64(0, 57653), new $Int64(0, 18048)), new Pair.ptr(new $Int64(0, 57667), new $Int64(0, 10061)), new Pair.ptr(new $Int64(0, 57679), new $Int64(0, 34823)), new Pair.ptr(new $Int64(0, 57689), new $Int64(0, 27044)), new Pair.ptr(new $Int64(0, 57697), new $Int64(0, 51898)), new Pair.ptr(new $Int64(0, 57709), new $Int64(0, 19895)), new Pair.ptr(new $Int64(0, 57713), new $Int64(0, 33086)), new Pair.ptr(new $Int64(0, 57719), new $Int64(0, 23238)), new Pair.ptr(new $Int64(0, 57727), new $Int64(0, 39627)), new Pair.ptr(new $Int64(0, 57731), new $Int64(0, 57322)), new Pair.ptr(new $Int64(0, 57737), new $Int64(0, 24171)), new Pair.ptr(new $Int64(0, 57751), new $Int64(0, 34428)), new Pair.ptr(new $Int64(0, 57773), new $Int64(0, 51445)), new Pair.ptr(new $Int64(0, 57781), new $Int64(0, 27851)), new Pair.ptr(new $Int64(0, 57787), new $Int64(0, 22436)), new Pair.ptr(new $Int64(0, 57791), new $Int64(0, 35645)), new Pair.ptr(new $Int64(0, 57793), new $Int64(0, 13983)), new Pair.ptr(new $Int64(0, 57803), new $Int64(0, 21372)), new Pair.ptr(new $Int64(0, 57809), new $Int64(0, 15319)), new Pair.ptr(new $Int64(0, 57829), new $Int64(0, 35939)), new Pair.ptr(new $Int64(0, 57839), new $Int64(0, 23633)), new Pair.ptr(new $Int64(0, 57847), new $Int64(0, 6365)), new Pair.ptr(new $Int64(0, 57853), new $Int64(0, 31076)), new Pair.ptr(new $Int64(0, 57859), new $Int64(0, 45885)), new Pair.ptr(new $Int64(0, 57881), new $Int64(0, 1368)), new Pair.ptr(new $Int64(0, 57899), new $Int64(0, 27851)), new Pair.ptr(new $Int64(0, 57901), new $Int64(0, 33751)), new Pair.ptr(new $Int64(0, 57917), new $Int64(0, 36715)), new Pair.ptr(new $Int64(0, 57923), new $Int64(0, 17713)), new Pair.ptr(new $Int64(0, 57943), new $Int64(0, 43642)), new Pair.ptr(new $Int64(0, 57947), new $Int64(0, 10380)), new Pair.ptr(new $Int64(0, 57973), new $Int64(0, 8264)), new Pair.ptr(new $Int64(0, 57977), new $Int64(0, 28905)), new Pair.ptr(new $Int64(0, 57991), new $Int64(0, 36367)), new Pair.ptr(new $Int64(0, 58013), new $Int64(0, 16480)), new Pair.ptr(new $Int64(0, 58027), new $Int64(0, 30355)), new Pair.ptr(new $Int64(0, 58031), new $Int64(0, 3618)), new Pair.ptr(new $Int64(0, 58043), new $Int64(0, 12705)), new Pair.ptr(new $Int64(0, 58049), new $Int64(0, 32142)), new Pair.ptr(new $Int64(0, 58057), new $Int64(0, 41608)), new Pair.ptr(new $Int64(0, 58061), new $Int64(0, 35159)), new Pair.ptr(new $Int64(0, 58067), new $Int64(0, 39464)), new Pair.ptr(new $Int64(0, 58073), new $Int64(0, 24068)), new Pair.ptr(new $Int64(0, 58099), new $Int64(0, 35686)), new Pair.ptr(new $Int64(0, 58109), new $Int64(0, 26225)), new Pair.ptr(new $Int64(0, 58111), new $Int64(0, 28489)), new Pair.ptr(new $Int64(0, 58129), new $Int64(0, 25121)), new Pair.ptr(new $Int64(0, 58147), new $Int64(0, 39712)), new Pair.ptr(new $Int64(0, 58151), new $Int64(0, 198)), new Pair.ptr(new $Int64(0, 58153), new $Int64(0, 15232)), new Pair.ptr(new $Int64(0, 58169), new $Int64(0, 3153)), new Pair.ptr(new $Int64(0, 58171), new $Int64(0, 42204)), new Pair.ptr(new $Int64(0, 58189), new $Int64(0, 54939)), new Pair.ptr(new $Int64(0, 58193), new $Int64(0, 19060)), new Pair.ptr(new $Int64(0, 58199), new $Int64(0, 34885)), new Pair.ptr(new $Int64(0, 58207), new $Int64(0, 17104)), new Pair.ptr(new $Int64(0, 58211), new $Int64(0, 21046)), new Pair.ptr(new $Int64(0, 58217), new $Int64(0, 43797)), new Pair.ptr(new $Int64(0, 58229), new $Int64(0, 5454)), new Pair.ptr(new $Int64(0, 58231), new $Int64(0, 42742)), new Pair.ptr(new $Int64(0, 58237), new $Int64(0, 20589)), new Pair.ptr(new $Int64(0, 58243), new $Int64(0, 34122)), new Pair.ptr(new $Int64(0, 58271), new $Int64(0, 46594)), new Pair.ptr(new $Int64(0, 58309), new $Int64(0, 12471)), new Pair.ptr(new $Int64(0, 58313), new $Int64(0, 15371)), new Pair.ptr(new $Int64(0, 58321), new $Int64(0, 5651)), new Pair.ptr(new $Int64(0, 58337), new $Int64(0, 47384)), new Pair.ptr(new $Int64(0, 58363), new $Int64(0, 49060)), new Pair.ptr(new $Int64(0, 58367), new $Int64(0, 32700)), new Pair.ptr(new $Int64(0, 58369), new $Int64(0, 26216)), new Pair.ptr(new $Int64(0, 58379), new $Int64(0, 47561)), new Pair.ptr(new $Int64(0, 58391), new $Int64(0, 13382)), new Pair.ptr(new $Int64(0, 58393), new $Int64(0, 35887)), new Pair.ptr(new $Int64(0, 58403), new $Int64(0, 3507)), new Pair.ptr(new $Int64(0, 58411), new $Int64(0, 31933)), new Pair.ptr(new $Int64(0, 58417), new $Int64(0, 33404)), new Pair.ptr(new $Int64(0, 58427), new $Int64(0, 44670)), new Pair.ptr(new $Int64(0, 58439), new $Int64(0, 35204)), new Pair.ptr(new $Int64(0, 58441), new $Int64(0, 55463)), new Pair.ptr(new $Int64(0, 58451), new $Int64(0, 17746)), new Pair.ptr(new $Int64(0, 58453), new $Int64(0, 56216)), new Pair.ptr(new $Int64(0, 58477), new $Int64(0, 50701)), new Pair.ptr(new $Int64(0, 58481), new $Int64(0, 4537)), new Pair.ptr(new $Int64(0, 58511), new $Int64(0, 54677)), new Pair.ptr(new $Int64(0, 58537), new $Int64(0, 21543)), new Pair.ptr(new $Int64(0, 58543), new $Int64(0, 2219)), new Pair.ptr(new $Int64(0, 58549), new $Int64(0, 42294)), new Pair.ptr(new $Int64(0, 58567), new $Int64(0, 56586)), new Pair.ptr(new $Int64(0, 58573), new $Int64(0, 12270)), new Pair.ptr(new $Int64(0, 58579), new $Int64(0, 42184)), new Pair.ptr(new $Int64(0, 58601), new $Int64(0, 24802)), new Pair.ptr(new $Int64(0, 58603), new $Int64(0, 50257)), new Pair.ptr(new $Int64(0, 58613), new $Int64(0, 10795)), new Pair.ptr(new $Int64(0, 58631), new $Int64(0, 30013)), new Pair.ptr(new $Int64(0, 58657), new $Int64(0, 34889)), new Pair.ptr(new $Int64(0, 58661), new $Int64(0, 7862)), new Pair.ptr(new $Int64(0, 58679), new $Int64(0, 14128)), new Pair.ptr(new $Int64(0, 58687), new $Int64(0, 14255)), new Pair.ptr(new $Int64(0, 58693), new $Int64(0, 53691)), new Pair.ptr(new $Int64(0, 58699), new $Int64(0, 26848)), new Pair.ptr(new $Int64(0, 58711), new $Int64(0, 51247)), new Pair.ptr(new $Int64(0, 58727), new $Int64(0, 8613)), new Pair.ptr(new $Int64(0, 58733), new $Int64(0, 30473)), new Pair.ptr(new $Int64(0, 58741), new $Int64(0, 28079)), new Pair.ptr(new $Int64(0, 58757), new $Int64(0, 6020)), new Pair.ptr(new $Int64(0, 58763), new $Int64(0, 52488)), new Pair.ptr(new $Int64(0, 58771), new $Int64(0, 34948)), new Pair.ptr(new $Int64(0, 58787), new $Int64(0, 4364)), new Pair.ptr(new $Int64(0, 58789), new $Int64(0, 40588)), new Pair.ptr(new $Int64(0, 58831), new $Int64(0, 53350)), new Pair.ptr(new $Int64(0, 58889), new $Int64(0, 28489)), new Pair.ptr(new $Int64(0, 58897), new $Int64(0, 36032)), new Pair.ptr(new $Int64(0, 58901), new $Int64(0, 57910)), new Pair.ptr(new $Int64(0, 58907), new $Int64(0, 52393)), new Pair.ptr(new $Int64(0, 58909), new $Int64(0, 2124)), new Pair.ptr(new $Int64(0, 58913), new $Int64(0, 46663)), new Pair.ptr(new $Int64(0, 58921), new $Int64(0, 36082)), new Pair.ptr(new $Int64(0, 58937), new $Int64(0, 3595)), new Pair.ptr(new $Int64(0, 58943), new $Int64(0, 19762)), new Pair.ptr(new $Int64(0, 58963), new $Int64(0, 9863)), new Pair.ptr(new $Int64(0, 58967), new $Int64(0, 4289)), new Pair.ptr(new $Int64(0, 58979), new $Int64(0, 6629)), new Pair.ptr(new $Int64(0, 58991), new $Int64(0, 27840)), new Pair.ptr(new $Int64(0, 58997), new $Int64(0, 29443)), new Pair.ptr(new $Int64(0, 59009), new $Int64(0, 25069)), new Pair.ptr(new $Int64(0, 59011), new $Int64(0, 1547)), new Pair.ptr(new $Int64(0, 59021), new $Int64(0, 28488)), new Pair.ptr(new $Int64(0, 59023), new $Int64(0, 5834)), new Pair.ptr(new $Int64(0, 59029), new $Int64(0, 8674)), new Pair.ptr(new $Int64(0, 59051), new $Int64(0, 56037)), new Pair.ptr(new $Int64(0, 59053), new $Int64(0, 17798)), new Pair.ptr(new $Int64(0, 59063), new $Int64(0, 31131)), new Pair.ptr(new $Int64(0, 59069), new $Int64(0, 54688)), new Pair.ptr(new $Int64(0, 59077), new $Int64(0, 34106)), new Pair.ptr(new $Int64(0, 59083), new $Int64(0, 51554)), new Pair.ptr(new $Int64(0, 59093), new $Int64(0, 13658)), new Pair.ptr(new $Int64(0, 59107), new $Int64(0, 11257)), new Pair.ptr(new $Int64(0, 59113), new $Int64(0, 11704)), new Pair.ptr(new $Int64(0, 59119), new $Int64(0, 18565)), new Pair.ptr(new $Int64(0, 59123), new $Int64(0, 50447)), new Pair.ptr(new $Int64(0, 59141), new $Int64(0, 32209)), new Pair.ptr(new $Int64(0, 59149), new $Int64(0, 56909)), new Pair.ptr(new $Int64(0, 59159), new $Int64(0, 54727)), new Pair.ptr(new $Int64(0, 59167), new $Int64(0, 57875)), new Pair.ptr(new $Int64(0, 59183), new $Int64(0, 37757)), new Pair.ptr(new $Int64(0, 59197), new $Int64(0, 35772)), new Pair.ptr(new $Int64(0, 59207), new $Int64(0, 14125)), new Pair.ptr(new $Int64(0, 59209), new $Int64(0, 58061)), new Pair.ptr(new $Int64(0, 59219), new $Int64(0, 12217)), new Pair.ptr(new $Int64(0, 59221), new $Int64(0, 35822)), new Pair.ptr(new $Int64(0, 59233), new $Int64(0, 55043)), new Pair.ptr(new $Int64(0, 59239), new $Int64(0, 6530)), new Pair.ptr(new $Int64(0, 59243), new $Int64(0, 57829)), new Pair.ptr(new $Int64(0, 59263), new $Int64(0, 41380)), new Pair.ptr(new $Int64(0, 59273), new $Int64(0, 38599)), new Pair.ptr(new $Int64(0, 59281), new $Int64(0, 23096)), new Pair.ptr(new $Int64(0, 59333), new $Int64(0, 18159)), new Pair.ptr(new $Int64(0, 59341), new $Int64(0, 17043)), new Pair.ptr(new $Int64(0, 59351), new $Int64(0, 55877)), new Pair.ptr(new $Int64(0, 59357), new $Int64(0, 7979)), new Pair.ptr(new $Int64(0, 59359), new $Int64(0, 51611)), new Pair.ptr(new $Int64(0, 59369), new $Int64(0, 4167)), new Pair.ptr(new $Int64(0, 59377), new $Int64(0, 43859)), new Pair.ptr(new $Int64(0, 59387), new $Int64(0, 24046)), new Pair.ptr(new $Int64(0, 59393), new $Int64(0, 12867)), new Pair.ptr(new $Int64(0, 59399), new $Int64(0, 23499)), new Pair.ptr(new $Int64(0, 59407), new $Int64(0, 20424)), new Pair.ptr(new $Int64(0, 59417), new $Int64(0, 46896)), new Pair.ptr(new $Int64(0, 59419), new $Int64(0, 33232)), new Pair.ptr(new $Int64(0, 59441), new $Int64(0, 38459)), new Pair.ptr(new $Int64(0, 59443), new $Int64(0, 50146)), new Pair.ptr(new $Int64(0, 59447), new $Int64(0, 10619)), new Pair.ptr(new $Int64(0, 59453), new $Int64(0, 34232)), new Pair.ptr(new $Int64(0, 59467), new $Int64(0, 21009)), new Pair.ptr(new $Int64(0, 59471), new $Int64(0, 47910)), new Pair.ptr(new $Int64(0, 59473), new $Int64(0, 12310)), new Pair.ptr(new $Int64(0, 59497), new $Int64(0, 31228)), new Pair.ptr(new $Int64(0, 59509), new $Int64(0, 59455)), new Pair.ptr(new $Int64(0, 59513), new $Int64(0, 39766)), new Pair.ptr(new $Int64(0, 59539), new $Int64(0, 17656)), new Pair.ptr(new $Int64(0, 59557), new $Int64(0, 13202)), new Pair.ptr(new $Int64(0, 59561), new $Int64(0, 13070)), new Pair.ptr(new $Int64(0, 59567), new $Int64(0, 34979)), new Pair.ptr(new $Int64(0, 59581), new $Int64(0, 50563)), new Pair.ptr(new $Int64(0, 59611), new $Int64(0, 25026)), new Pair.ptr(new $Int64(0, 59617), new $Int64(0, 45823)), new Pair.ptr(new $Int64(0, 59621), new $Int64(0, 13649)), new Pair.ptr(new $Int64(0, 59627), new $Int64(0, 54463)), new Pair.ptr(new $Int64(0, 59629), new $Int64(0, 9477)), new Pair.ptr(new $Int64(0, 59651), new $Int64(0, 948)), new Pair.ptr(new $Int64(0, 59659), new $Int64(0, 56014)), new Pair.ptr(new $Int64(0, 59663), new $Int64(0, 20063)), new Pair.ptr(new $Int64(0, 59669), new $Int64(0, 57151)), new Pair.ptr(new $Int64(0, 59671), new $Int64(0, 26154)), new Pair.ptr(new $Int64(0, 59693), new $Int64(0, 56196)), new Pair.ptr(new $Int64(0, 59699), new $Int64(0, 40764)), new Pair.ptr(new $Int64(0, 59707), new $Int64(0, 40002)), new Pair.ptr(new $Int64(0, 59723), new $Int64(0, 56090)), new Pair.ptr(new $Int64(0, 59729), new $Int64(0, 28060)), new Pair.ptr(new $Int64(0, 59743), new $Int64(0, 6502)), new Pair.ptr(new $Int64(0, 59747), new $Int64(0, 48962)), new Pair.ptr(new $Int64(0, 59753), new $Int64(0, 22675)), new Pair.ptr(new $Int64(0, 59771), new $Int64(0, 24715)), new Pair.ptr(new $Int64(0, 59779), new $Int64(0, 2021)), new Pair.ptr(new $Int64(0, 59791), new $Int64(0, 37675)), new Pair.ptr(new $Int64(0, 59797), new $Int64(0, 7162)), new Pair.ptr(new $Int64(0, 59809), new $Int64(0, 48014)), new Pair.ptr(new $Int64(0, 59833), new $Int64(0, 54166)), new Pair.ptr(new $Int64(0, 59863), new $Int64(0, 50291)), new Pair.ptr(new $Int64(0, 59879), new $Int64(0, 2812)), new Pair.ptr(new $Int64(0, 59887), new $Int64(0, 28905)), new Pair.ptr(new $Int64(0, 59921), new $Int64(0, 17459)), new Pair.ptr(new $Int64(0, 59929), new $Int64(0, 4346)), new Pair.ptr(new $Int64(0, 59951), new $Int64(0, 59676)), new Pair.ptr(new $Int64(0, 59957), new $Int64(0, 38128)), new Pair.ptr(new $Int64(0, 59971), new $Int64(0, 32007)), new Pair.ptr(new $Int64(0, 59981), new $Int64(0, 28472)), new Pair.ptr(new $Int64(0, 59999), new $Int64(0, 40819)), new Pair.ptr(new $Int64(0, 60013), new $Int64(0, 35114)), new Pair.ptr(new $Int64(0, 60017), new $Int64(0, 32800)), new Pair.ptr(new $Int64(0, 60029), new $Int64(0, 18396)), new Pair.ptr(new $Int64(0, 60037), new $Int64(0, 16967)), new Pair.ptr(new $Int64(0, 60041), new $Int64(0, 58461)), new Pair.ptr(new $Int64(0, 60077), new $Int64(0, 58310)), new Pair.ptr(new $Int64(0, 60083), new $Int64(0, 43103)), new Pair.ptr(new $Int64(0, 60089), new $Int64(0, 1036)), new Pair.ptr(new $Int64(0, 60091), new $Int64(0, 41676)), new Pair.ptr(new $Int64(0, 60101), new $Int64(0, 35914)), new Pair.ptr(new $Int64(0, 60103), new $Int64(0, 27256)), new Pair.ptr(new $Int64(0, 60107), new $Int64(0, 24938)), new Pair.ptr(new $Int64(0, 60127), new $Int64(0, 35448)), new Pair.ptr(new $Int64(0, 60133), new $Int64(0, 9473)), new Pair.ptr(new $Int64(0, 60139), new $Int64(0, 31592)), new Pair.ptr(new $Int64(0, 60149), new $Int64(0, 28047)), new Pair.ptr(new $Int64(0, 60161), new $Int64(0, 22337)), new Pair.ptr(new $Int64(0, 60167), new $Int64(0, 3655)), new Pair.ptr(new $Int64(0, 60169), new $Int64(0, 276)), new Pair.ptr(new $Int64(0, 60209), new $Int64(0, 4647)), new Pair.ptr(new $Int64(0, 60217), new $Int64(0, 38163)), new Pair.ptr(new $Int64(0, 60223), new $Int64(0, 57452)), new Pair.ptr(new $Int64(0, 60251), new $Int64(0, 33280)), new Pair.ptr(new $Int64(0, 60257), new $Int64(0, 9635)), new Pair.ptr(new $Int64(0, 60259), new $Int64(0, 13475)), new Pair.ptr(new $Int64(0, 60271), new $Int64(0, 6427)), new Pair.ptr(new $Int64(0, 60289), new $Int64(0, 23826)), new Pair.ptr(new $Int64(0, 60293), new $Int64(0, 19537)), new Pair.ptr(new $Int64(0, 60317), new $Int64(0, 36730)), new Pair.ptr(new $Int64(0, 60331), new $Int64(0, 49979)), new Pair.ptr(new $Int64(0, 60337), new $Int64(0, 44327)), new Pair.ptr(new $Int64(0, 60343), new $Int64(0, 21216)), new Pair.ptr(new $Int64(0, 60353), new $Int64(0, 12050)), new Pair.ptr(new $Int64(0, 60373), new $Int64(0, 10898)), new Pair.ptr(new $Int64(0, 60383), new $Int64(0, 28509)), new Pair.ptr(new $Int64(0, 60397), new $Int64(0, 3674)), new Pair.ptr(new $Int64(0, 60413), new $Int64(0, 19938)), new Pair.ptr(new $Int64(0, 60427), new $Int64(0, 3540)), new Pair.ptr(new $Int64(0, 60443), new $Int64(0, 44267)), new Pair.ptr(new $Int64(0, 60449), new $Int64(0, 33954)), new Pair.ptr(new $Int64(0, 60457), new $Int64(0, 40127)), new Pair.ptr(new $Int64(0, 60493), new $Int64(0, 5239)), new Pair.ptr(new $Int64(0, 60497), new $Int64(0, 50045)), new Pair.ptr(new $Int64(0, 60509), new $Int64(0, 35106)), new Pair.ptr(new $Int64(0, 60521), new $Int64(0, 57961)), new Pair.ptr(new $Int64(0, 60527), new $Int64(0, 35059)), new Pair.ptr(new $Int64(0, 60539), new $Int64(0, 9163)), new Pair.ptr(new $Int64(0, 60589), new $Int64(0, 46673)), new Pair.ptr(new $Int64(0, 60601), new $Int64(0, 26940)), new Pair.ptr(new $Int64(0, 60607), new $Int64(0, 20110)), new Pair.ptr(new $Int64(0, 60611), new $Int64(0, 55)), new Pair.ptr(new $Int64(0, 60617), new $Int64(0, 1578)), new Pair.ptr(new $Int64(0, 60623), new $Int64(0, 28804)), new Pair.ptr(new $Int64(0, 60631), new $Int64(0, 56012)), new Pair.ptr(new $Int64(0, 60637), new $Int64(0, 48394)), new Pair.ptr(new $Int64(0, 60647), new $Int64(0, 48094)), new Pair.ptr(new $Int64(0, 60649), new $Int64(0, 11790)), new Pair.ptr(new $Int64(0, 60659), new $Int64(0, 22937)), new Pair.ptr(new $Int64(0, 60661), new $Int64(0, 757)), new Pair.ptr(new $Int64(0, 60679), new $Int64(0, 21419)), new Pair.ptr(new $Int64(0, 60689), new $Int64(0, 1592)), new Pair.ptr(new $Int64(0, 60703), new $Int64(0, 12792)), new Pair.ptr(new $Int64(0, 60719), new $Int64(0, 20685)), new Pair.ptr(new $Int64(0, 60727), new $Int64(0, 47571)), new Pair.ptr(new $Int64(0, 60733), new $Int64(0, 36142)), new Pair.ptr(new $Int64(0, 60737), new $Int64(0, 40596)), new Pair.ptr(new $Int64(0, 60757), new $Int64(0, 41449)), new Pair.ptr(new $Int64(0, 60761), new $Int64(0, 7931)), new Pair.ptr(new $Int64(0, 60763), new $Int64(0, 52595)), new Pair.ptr(new $Int64(0, 60773), new $Int64(0, 22971)), new Pair.ptr(new $Int64(0, 60779), new $Int64(0, 43323)), new Pair.ptr(new $Int64(0, 60793), new $Int64(0, 9911)), new Pair.ptr(new $Int64(0, 60811), new $Int64(0, 16721)), new Pair.ptr(new $Int64(0, 60821), new $Int64(0, 55666)), new Pair.ptr(new $Int64(0, 60859), new $Int64(0, 19385)), new Pair.ptr(new $Int64(0, 60869), new $Int64(0, 37808)), new Pair.ptr(new $Int64(0, 60887), new $Int64(0, 4307)), new Pair.ptr(new $Int64(0, 60889), new $Int64(0, 33309)), new Pair.ptr(new $Int64(0, 60899), new $Int64(0, 24062)), new Pair.ptr(new $Int64(0, 60901), new $Int64(0, 48337)), new Pair.ptr(new $Int64(0, 60913), new $Int64(0, 46381)), new Pair.ptr(new $Int64(0, 60917), new $Int64(0, 16100)), new Pair.ptr(new $Int64(0, 60919), new $Int64(0, 56132)), new Pair.ptr(new $Int64(0, 60923), new $Int64(0, 24108)), new Pair.ptr(new $Int64(0, 60937), new $Int64(0, 22061)), new Pair.ptr(new $Int64(0, 60943), new $Int64(0, 39996)), new Pair.ptr(new $Int64(0, 60953), new $Int64(0, 1331)), new Pair.ptr(new $Int64(0, 60961), new $Int64(0, 4567)), new Pair.ptr(new $Int64(0, 61001), new $Int64(0, 41845)), new Pair.ptr(new $Int64(0, 61007), new $Int64(0, 48928)), new Pair.ptr(new $Int64(0, 61027), new $Int64(0, 46922)), new Pair.ptr(new $Int64(0, 61031), new $Int64(0, 7951)), new Pair.ptr(new $Int64(0, 61043), new $Int64(0, 25802)), new Pair.ptr(new $Int64(0, 61051), new $Int64(0, 4528)), new Pair.ptr(new $Int64(0, 61057), new $Int64(0, 28875)), new Pair.ptr(new $Int64(0, 61091), new $Int64(0, 52114)), new Pair.ptr(new $Int64(0, 61099), new $Int64(0, 31608)), new Pair.ptr(new $Int64(0, 61121), new $Int64(0, 18175)), new Pair.ptr(new $Int64(0, 61129), new $Int64(0, 32280)), new Pair.ptr(new $Int64(0, 61141), new $Int64(0, 54269)), new Pair.ptr(new $Int64(0, 61151), new $Int64(0, 57816)), new Pair.ptr(new $Int64(0, 61153), new $Int64(0, 56705)), new Pair.ptr(new $Int64(0, 61169), new $Int64(0, 46580)), new Pair.ptr(new $Int64(0, 61211), new $Int64(0, 59004)), new Pair.ptr(new $Int64(0, 61223), new $Int64(0, 23768)), new Pair.ptr(new $Int64(0, 61231), new $Int64(0, 31609)), new Pair.ptr(new $Int64(0, 61253), new $Int64(0, 9935)), new Pair.ptr(new $Int64(0, 61261), new $Int64(0, 27570)), new Pair.ptr(new $Int64(0, 61283), new $Int64(0, 10598)), new Pair.ptr(new $Int64(0, 61291), new $Int64(0, 20588)), new Pair.ptr(new $Int64(0, 61297), new $Int64(0, 2106)), new Pair.ptr(new $Int64(0, 61331), new $Int64(0, 18988)), new Pair.ptr(new $Int64(0, 61333), new $Int64(0, 56780)), new Pair.ptr(new $Int64(0, 61339), new $Int64(0, 21989)), new Pair.ptr(new $Int64(0, 61343), new $Int64(0, 4327)), new Pair.ptr(new $Int64(0, 61357), new $Int64(0, 6552)), new Pair.ptr(new $Int64(0, 61363), new $Int64(0, 55076)), new Pair.ptr(new $Int64(0, 61379), new $Int64(0, 32039)), new Pair.ptr(new $Int64(0, 61381), new $Int64(0, 51600)), new Pair.ptr(new $Int64(0, 61403), new $Int64(0, 27181)), new Pair.ptr(new $Int64(0, 61409), new $Int64(0, 7807)), new Pair.ptr(new $Int64(0, 61417), new $Int64(0, 24689)), new Pair.ptr(new $Int64(0, 61441), new $Int64(0, 46648)), new Pair.ptr(new $Int64(0, 61463), new $Int64(0, 24905)), new Pair.ptr(new $Int64(0, 61469), new $Int64(0, 8398)), new Pair.ptr(new $Int64(0, 61471), new $Int64(0, 50340)), new Pair.ptr(new $Int64(0, 61483), new $Int64(0, 58869)), new Pair.ptr(new $Int64(0, 61487), new $Int64(0, 10492)), new Pair.ptr(new $Int64(0, 61493), new $Int64(0, 14397)), new Pair.ptr(new $Int64(0, 61507), new $Int64(0, 50179)), new Pair.ptr(new $Int64(0, 61511), new $Int64(0, 60430)), new Pair.ptr(new $Int64(0, 61519), new $Int64(0, 35482)), new Pair.ptr(new $Int64(0, 61543), new $Int64(0, 51272)), new Pair.ptr(new $Int64(0, 61547), new $Int64(0, 48654)), new Pair.ptr(new $Int64(0, 61553), new $Int64(0, 2082)), new Pair.ptr(new $Int64(0, 61559), new $Int64(0, 308)), new Pair.ptr(new $Int64(0, 61561), new $Int64(0, 60023)), new Pair.ptr(new $Int64(0, 61583), new $Int64(0, 38919)), new Pair.ptr(new $Int64(0, 61603), new $Int64(0, 4212)), new Pair.ptr(new $Int64(0, 61609), new $Int64(0, 4037)), new Pair.ptr(new $Int64(0, 61613), new $Int64(0, 12517)), new Pair.ptr(new $Int64(0, 61627), new $Int64(0, 41904)), new Pair.ptr(new $Int64(0, 61631), new $Int64(0, 8768)), new Pair.ptr(new $Int64(0, 61637), new $Int64(0, 2990)), new Pair.ptr(new $Int64(0, 61643), new $Int64(0, 8197)), new Pair.ptr(new $Int64(0, 61651), new $Int64(0, 30748)), new Pair.ptr(new $Int64(0, 61657), new $Int64(0, 41909)), new Pair.ptr(new $Int64(0, 61667), new $Int64(0, 2360)), new Pair.ptr(new $Int64(0, 61673), new $Int64(0, 13669)), new Pair.ptr(new $Int64(0, 61681), new $Int64(0, 24524)), new Pair.ptr(new $Int64(0, 61687), new $Int64(0, 44379)), new Pair.ptr(new $Int64(0, 61703), new $Int64(0, 26420)), new Pair.ptr(new $Int64(0, 61717), new $Int64(0, 58011)), new Pair.ptr(new $Int64(0, 61723), new $Int64(0, 10448)), new Pair.ptr(new $Int64(0, 61729), new $Int64(0, 47582)), new Pair.ptr(new $Int64(0, 61751), new $Int64(0, 34016)), new Pair.ptr(new $Int64(0, 61757), new $Int64(0, 9844)), new Pair.ptr(new $Int64(0, 61781), new $Int64(0, 1059)), new Pair.ptr(new $Int64(0, 61813), new $Int64(0, 1957)), new Pair.ptr(new $Int64(0, 61819), new $Int64(0, 13021)), new Pair.ptr(new $Int64(0, 61837), new $Int64(0, 4750)), new Pair.ptr(new $Int64(0, 61843), new $Int64(0, 10839)), new Pair.ptr(new $Int64(0, 61861), new $Int64(0, 14306)), new Pair.ptr(new $Int64(0, 61871), new $Int64(0, 26665)), new Pair.ptr(new $Int64(0, 61879), new $Int64(0, 7501)), new Pair.ptr(new $Int64(0, 61909), new $Int64(0, 39526)), new Pair.ptr(new $Int64(0, 61927), new $Int64(0, 41644)), new Pair.ptr(new $Int64(0, 61933), new $Int64(0, 4745)), new Pair.ptr(new $Int64(0, 61949), new $Int64(0, 17004)), new Pair.ptr(new $Int64(0, 61961), new $Int64(0, 37923)), new Pair.ptr(new $Int64(0, 61967), new $Int64(0, 45736)), new Pair.ptr(new $Int64(0, 61979), new $Int64(0, 53404)), new Pair.ptr(new $Int64(0, 61981), new $Int64(0, 16439)), new Pair.ptr(new $Int64(0, 61987), new $Int64(0, 53543)), new Pair.ptr(new $Int64(0, 61991), new $Int64(0, 35201)), new Pair.ptr(new $Int64(0, 62003), new $Int64(0, 33331)), new Pair.ptr(new $Int64(0, 62011), new $Int64(0, 34025)), new Pair.ptr(new $Int64(0, 62017), new $Int64(0, 40357)), new Pair.ptr(new $Int64(0, 62039), new $Int64(0, 4091)), new Pair.ptr(new $Int64(0, 62047), new $Int64(0, 36332)), new Pair.ptr(new $Int64(0, 62053), new $Int64(0, 19880)), new Pair.ptr(new $Int64(0, 62057), new $Int64(0, 44888)), new Pair.ptr(new $Int64(0, 62071), new $Int64(0, 27702)), new Pair.ptr(new $Int64(0, 62081), new $Int64(0, 599)), new Pair.ptr(new $Int64(0, 62099), new $Int64(0, 14238)), new Pair.ptr(new $Int64(0, 62119), new $Int64(0, 890)), new Pair.ptr(new $Int64(0, 62129), new $Int64(0, 23167)), new Pair.ptr(new $Int64(0, 62131), new $Int64(0, 15)), new Pair.ptr(new $Int64(0, 62137), new $Int64(0, 31248)), new Pair.ptr(new $Int64(0, 62141), new $Int64(0, 31608)), new Pair.ptr(new $Int64(0, 62143), new $Int64(0, 31161)), new Pair.ptr(new $Int64(0, 62171), new $Int64(0, 61420)), new Pair.ptr(new $Int64(0, 62189), new $Int64(0, 54346)), new Pair.ptr(new $Int64(0, 62191), new $Int64(0, 42915)), new Pair.ptr(new $Int64(0, 62201), new $Int64(0, 43041)), new Pair.ptr(new $Int64(0, 62207), new $Int64(0, 1666)), new Pair.ptr(new $Int64(0, 62213), new $Int64(0, 16803)), new Pair.ptr(new $Int64(0, 62219), new $Int64(0, 25951)), new Pair.ptr(new $Int64(0, 62233), new $Int64(0, 53541)), new Pair.ptr(new $Int64(0, 62273), new $Int64(0, 55421)), new Pair.ptr(new $Int64(0, 62297), new $Int64(0, 46493)), new Pair.ptr(new $Int64(0, 62299), new $Int64(0, 11255)), new Pair.ptr(new $Int64(0, 62303), new $Int64(0, 24374)), new Pair.ptr(new $Int64(0, 62311), new $Int64(0, 45799)), new Pair.ptr(new $Int64(0, 62323), new $Int64(0, 30473)), new Pair.ptr(new $Int64(0, 62327), new $Int64(0, 47247)), new Pair.ptr(new $Int64(0, 62347), new $Int64(0, 6829)), new Pair.ptr(new $Int64(0, 62351), new $Int64(0, 35530)), new Pair.ptr(new $Int64(0, 62383), new $Int64(0, 36267)), new Pair.ptr(new $Int64(0, 62401), new $Int64(0, 37278)), new Pair.ptr(new $Int64(0, 62417), new $Int64(0, 39100)), new Pair.ptr(new $Int64(0, 62423), new $Int64(0, 6274)), new Pair.ptr(new $Int64(0, 62459), new $Int64(0, 27923)), new Pair.ptr(new $Int64(0, 62467), new $Int64(0, 42912)), new Pair.ptr(new $Int64(0, 62473), new $Int64(0, 16738)), new Pair.ptr(new $Int64(0, 62477), new $Int64(0, 55459)), new Pair.ptr(new $Int64(0, 62483), new $Int64(0, 45012)), new Pair.ptr(new $Int64(0, 62497), new $Int64(0, 42917)), new Pair.ptr(new $Int64(0, 62501), new $Int64(0, 47151)), new Pair.ptr(new $Int64(0, 62507), new $Int64(0, 44792)), new Pair.ptr(new $Int64(0, 62533), new $Int64(0, 34402)), new Pair.ptr(new $Int64(0, 62539), new $Int64(0, 60155)), new Pair.ptr(new $Int64(0, 62549), new $Int64(0, 45850)), new Pair.ptr(new $Int64(0, 62563), new $Int64(0, 49528)), new Pair.ptr(new $Int64(0, 62581), new $Int64(0, 58423)), new Pair.ptr(new $Int64(0, 62591), new $Int64(0, 47172)), new Pair.ptr(new $Int64(0, 62597), new $Int64(0, 4725)), new Pair.ptr(new $Int64(0, 62603), new $Int64(0, 14266)), new Pair.ptr(new $Int64(0, 62617), new $Int64(0, 34492)), new Pair.ptr(new $Int64(0, 62627), new $Int64(0, 12845)), new Pair.ptr(new $Int64(0, 62633), new $Int64(0, 44291)), new Pair.ptr(new $Int64(0, 62639), new $Int64(0, 36420)), new Pair.ptr(new $Int64(0, 62653), new $Int64(0, 59379)), new Pair.ptr(new $Int64(0, 62659), new $Int64(0, 25905)), new Pair.ptr(new $Int64(0, 62683), new $Int64(0, 466)), new Pair.ptr(new $Int64(0, 62687), new $Int64(0, 49837)), new Pair.ptr(new $Int64(0, 62701), new $Int64(0, 32039)), new Pair.ptr(new $Int64(0, 62723), new $Int64(0, 24319)), new Pair.ptr(new $Int64(0, 62731), new $Int64(0, 57294)), new Pair.ptr(new $Int64(0, 62743), new $Int64(0, 58101)), new Pair.ptr(new $Int64(0, 62753), new $Int64(0, 44752)), new Pair.ptr(new $Int64(0, 62761), new $Int64(0, 54547)), new Pair.ptr(new $Int64(0, 62773), new $Int64(0, 57486)), new Pair.ptr(new $Int64(0, 62791), new $Int64(0, 52801)), new Pair.ptr(new $Int64(0, 62801), new $Int64(0, 56443)), new Pair.ptr(new $Int64(0, 62819), new $Int64(0, 11077)), new Pair.ptr(new $Int64(0, 62827), new $Int64(0, 20878)), new Pair.ptr(new $Int64(0, 62851), new $Int64(0, 24377)), new Pair.ptr(new $Int64(0, 62861), new $Int64(0, 18975)), new Pair.ptr(new $Int64(0, 62869), new $Int64(0, 43028)), new Pair.ptr(new $Int64(0, 62873), new $Int64(0, 62236)), new Pair.ptr(new $Int64(0, 62897), new $Int64(0, 25263)), new Pair.ptr(new $Int64(0, 62903), new $Int64(0, 36297)), new Pair.ptr(new $Int64(0, 62921), new $Int64(0, 56928)), new Pair.ptr(new $Int64(0, 62927), new $Int64(0, 428)), new Pair.ptr(new $Int64(0, 62929), new $Int64(0, 54605)), new Pair.ptr(new $Int64(0, 62939), new $Int64(0, 9149)), new Pair.ptr(new $Int64(0, 62969), new $Int64(0, 12912)), new Pair.ptr(new $Int64(0, 62971), new $Int64(0, 52858)), new Pair.ptr(new $Int64(0, 62981), new $Int64(0, 27631)), new Pair.ptr(new $Int64(0, 62983), new $Int64(0, 55366)), new Pair.ptr(new $Int64(0, 62987), new $Int64(0, 8640)), new Pair.ptr(new $Int64(0, 62989), new $Int64(0, 35559)), new Pair.ptr(new $Int64(0, 63029), new $Int64(0, 34805)), new Pair.ptr(new $Int64(0, 63031), new $Int64(0, 36883)), new Pair.ptr(new $Int64(0, 63059), new $Int64(0, 16159)), new Pair.ptr(new $Int64(0, 63067), new $Int64(0, 56366)), new Pair.ptr(new $Int64(0, 63073), new $Int64(0, 43678)), new Pair.ptr(new $Int64(0, 63079), new $Int64(0, 41297)), new Pair.ptr(new $Int64(0, 63097), new $Int64(0, 37719)), new Pair.ptr(new $Int64(0, 63103), new $Int64(0, 4220)), new Pair.ptr(new $Int64(0, 63113), new $Int64(0, 22626)), new Pair.ptr(new $Int64(0, 63127), new $Int64(0, 13883)), new Pair.ptr(new $Int64(0, 63131), new $Int64(0, 32285)), new Pair.ptr(new $Int64(0, 63149), new $Int64(0, 32474)), new Pair.ptr(new $Int64(0, 63179), new $Int64(0, 28308)), new Pair.ptr(new $Int64(0, 63197), new $Int64(0, 17839)), new Pair.ptr(new $Int64(0, 63199), new $Int64(0, 9050)), new Pair.ptr(new $Int64(0, 63211), new $Int64(0, 331)), new Pair.ptr(new $Int64(0, 63241), new $Int64(0, 21859)), new Pair.ptr(new $Int64(0, 63247), new $Int64(0, 21681)), new Pair.ptr(new $Int64(0, 63277), new $Int64(0, 1131)), new Pair.ptr(new $Int64(0, 63281), new $Int64(0, 54725)), new Pair.ptr(new $Int64(0, 63299), new $Int64(0, 51759)), new Pair.ptr(new $Int64(0, 63311), new $Int64(0, 37342)), new Pair.ptr(new $Int64(0, 63313), new $Int64(0, 31131)), new Pair.ptr(new $Int64(0, 63317), new $Int64(0, 49563)), new Pair.ptr(new $Int64(0, 63331), new $Int64(0, 38229)), new Pair.ptr(new $Int64(0, 63337), new $Int64(0, 42608)), new Pair.ptr(new $Int64(0, 63347), new $Int64(0, 11727)), new Pair.ptr(new $Int64(0, 63353), new $Int64(0, 40180)), new Pair.ptr(new $Int64(0, 63361), new $Int64(0, 57094)), new Pair.ptr(new $Int64(0, 63367), new $Int64(0, 43372)), new Pair.ptr(new $Int64(0, 63377), new $Int64(0, 43057)), new Pair.ptr(new $Int64(0, 63389), new $Int64(0, 16766)), new Pair.ptr(new $Int64(0, 63391), new $Int64(0, 10876)), new Pair.ptr(new $Int64(0, 63397), new $Int64(0, 36980)), new Pair.ptr(new $Int64(0, 63409), new $Int64(0, 26706)), new Pair.ptr(new $Int64(0, 63419), new $Int64(0, 11753)), new Pair.ptr(new $Int64(0, 63421), new $Int64(0, 35258)), new Pair.ptr(new $Int64(0, 63439), new $Int64(0, 22520)), new Pair.ptr(new $Int64(0, 63443), new $Int64(0, 34422)), new Pair.ptr(new $Int64(0, 63463), new $Int64(0, 47863)), new Pair.ptr(new $Int64(0, 63467), new $Int64(0, 46748)), new Pair.ptr(new $Int64(0, 63473), new $Int64(0, 38227)), new Pair.ptr(new $Int64(0, 63487), new $Int64(0, 36097)), new Pair.ptr(new $Int64(0, 63493), new $Int64(0, 53515)), new Pair.ptr(new $Int64(0, 63499), new $Int64(0, 60000)), new Pair.ptr(new $Int64(0, 63521), new $Int64(0, 35578)), new Pair.ptr(new $Int64(0, 63527), new $Int64(0, 34512)), new Pair.ptr(new $Int64(0, 63533), new $Int64(0, 23443)), new Pair.ptr(new $Int64(0, 63541), new $Int64(0, 21804)), new Pair.ptr(new $Int64(0, 63559), new $Int64(0, 59263)), new Pair.ptr(new $Int64(0, 63577), new $Int64(0, 26510)), new Pair.ptr(new $Int64(0, 63587), new $Int64(0, 11962)), new Pair.ptr(new $Int64(0, 63589), new $Int64(0, 30371)), new Pair.ptr(new $Int64(0, 63599), new $Int64(0, 43840)), new Pair.ptr(new $Int64(0, 63601), new $Int64(0, 34818)), new Pair.ptr(new $Int64(0, 63607), new $Int64(0, 5855)), new Pair.ptr(new $Int64(0, 63611), new $Int64(0, 3108)), new Pair.ptr(new $Int64(0, 63617), new $Int64(0, 14621)), new Pair.ptr(new $Int64(0, 63629), new $Int64(0, 29479)), new Pair.ptr(new $Int64(0, 63647), new $Int64(0, 15375)), new Pair.ptr(new $Int64(0, 63649), new $Int64(0, 16697)), new Pair.ptr(new $Int64(0, 63659), new $Int64(0, 29477)), new Pair.ptr(new $Int64(0, 63667), new $Int64(0, 44754)), new Pair.ptr(new $Int64(0, 63671), new $Int64(0, 43279)), new Pair.ptr(new $Int64(0, 63689), new $Int64(0, 32020)), new Pair.ptr(new $Int64(0, 63691), new $Int64(0, 3324)), new Pair.ptr(new $Int64(0, 63697), new $Int64(0, 19624)), new Pair.ptr(new $Int64(0, 63703), new $Int64(0, 28634)), new Pair.ptr(new $Int64(0, 63709), new $Int64(0, 33356)), new Pair.ptr(new $Int64(0, 63719), new $Int64(0, 46087)), new Pair.ptr(new $Int64(0, 63727), new $Int64(0, 19490)), new Pair.ptr(new $Int64(0, 63737), new $Int64(0, 9109)), new Pair.ptr(new $Int64(0, 63743), new $Int64(0, 61744)), new Pair.ptr(new $Int64(0, 63761), new $Int64(0, 12654)), new Pair.ptr(new $Int64(0, 63773), new $Int64(0, 19709)), new Pair.ptr(new $Int64(0, 63781), new $Int64(0, 26474)), new Pair.ptr(new $Int64(0, 63793), new $Int64(0, 59854)), new Pair.ptr(new $Int64(0, 63799), new $Int64(0, 25006)), new Pair.ptr(new $Int64(0, 63803), new $Int64(0, 3895)), new Pair.ptr(new $Int64(0, 63809), new $Int64(0, 33164)), new Pair.ptr(new $Int64(0, 63823), new $Int64(0, 10134)), new Pair.ptr(new $Int64(0, 63839), new $Int64(0, 54911)), new Pair.ptr(new $Int64(0, 63841), new $Int64(0, 41072)), new Pair.ptr(new $Int64(0, 63853), new $Int64(0, 42145)), new Pair.ptr(new $Int64(0, 63857), new $Int64(0, 44340)), new Pair.ptr(new $Int64(0, 63863), new $Int64(0, 932)), new Pair.ptr(new $Int64(0, 63901), new $Int64(0, 51931)), new Pair.ptr(new $Int64(0, 63907), new $Int64(0, 46838)), new Pair.ptr(new $Int64(0, 63913), new $Int64(0, 17890)), new Pair.ptr(new $Int64(0, 63929), new $Int64(0, 29139)), new Pair.ptr(new $Int64(0, 63949), new $Int64(0, 57758)), new Pair.ptr(new $Int64(0, 63977), new $Int64(0, 15982)), new Pair.ptr(new $Int64(0, 63997), new $Int64(0, 49733)), new Pair.ptr(new $Int64(0, 64007), new $Int64(0, 8684)), new Pair.ptr(new $Int64(0, 64013), new $Int64(0, 21254)), new Pair.ptr(new $Int64(0, 64019), new $Int64(0, 27789)), new Pair.ptr(new $Int64(0, 64033), new $Int64(0, 4682)), new Pair.ptr(new $Int64(0, 64037), new $Int64(0, 13598)), new Pair.ptr(new $Int64(0, 64063), new $Int64(0, 17084)), new Pair.ptr(new $Int64(0, 64067), new $Int64(0, 48406)), new Pair.ptr(new $Int64(0, 64081), new $Int64(0, 47244)), new Pair.ptr(new $Int64(0, 64091), new $Int64(0, 59027)), new Pair.ptr(new $Int64(0, 64109), new $Int64(0, 32007)), new Pair.ptr(new $Int64(0, 64123), new $Int64(0, 797)), new Pair.ptr(new $Int64(0, 64151), new $Int64(0, 56679)), new Pair.ptr(new $Int64(0, 64153), new $Int64(0, 14945)), new Pair.ptr(new $Int64(0, 64157), new $Int64(0, 9842)), new Pair.ptr(new $Int64(0, 64171), new $Int64(0, 53096)), new Pair.ptr(new $Int64(0, 64187), new $Int64(0, 661)), new Pair.ptr(new $Int64(0, 64189), new $Int64(0, 1609)), new Pair.ptr(new $Int64(0, 64217), new $Int64(0, 32850)), new Pair.ptr(new $Int64(0, 64223), new $Int64(0, 19415)), new Pair.ptr(new $Int64(0, 64231), new $Int64(0, 29436)), new Pair.ptr(new $Int64(0, 64237), new $Int64(0, 56786)), new Pair.ptr(new $Int64(0, 64271), new $Int64(0, 28213)), new Pair.ptr(new $Int64(0, 64279), new $Int64(0, 62824)), new Pair.ptr(new $Int64(0, 64283), new $Int64(0, 24089)), new Pair.ptr(new $Int64(0, 64301), new $Int64(0, 10545)), new Pair.ptr(new $Int64(0, 64303), new $Int64(0, 62886)), new Pair.ptr(new $Int64(0, 64319), new $Int64(0, 26602)), new Pair.ptr(new $Int64(0, 64327), new $Int64(0, 15882)), new Pair.ptr(new $Int64(0, 64333), new $Int64(0, 8785)), new Pair.ptr(new $Int64(0, 64373), new $Int64(0, 7097)), new Pair.ptr(new $Int64(0, 64381), new $Int64(0, 42352)), new Pair.ptr(new $Int64(0, 64399), new $Int64(0, 49238)), new Pair.ptr(new $Int64(0, 64403), new $Int64(0, 24520)), new Pair.ptr(new $Int64(0, 64433), new $Int64(0, 20267)), new Pair.ptr(new $Int64(0, 64439), new $Int64(0, 27746)), new Pair.ptr(new $Int64(0, 64451), new $Int64(0, 21628)), new Pair.ptr(new $Int64(0, 64453), new $Int64(0, 21164)), new Pair.ptr(new $Int64(0, 64483), new $Int64(0, 26891)), new Pair.ptr(new $Int64(0, 64489), new $Int64(0, 6545)), new Pair.ptr(new $Int64(0, 64499), new $Int64(0, 30317)), new Pair.ptr(new $Int64(0, 64513), new $Int64(0, 22376)), new Pair.ptr(new $Int64(0, 64553), new $Int64(0, 41328)), new Pair.ptr(new $Int64(0, 64567), new $Int64(0, 9362)), new Pair.ptr(new $Int64(0, 64577), new $Int64(0, 3810)), new Pair.ptr(new $Int64(0, 64579), new $Int64(0, 23215)), new Pair.ptr(new $Int64(0, 64591), new $Int64(0, 36957)), new Pair.ptr(new $Int64(0, 64601), new $Int64(0, 38119)), new Pair.ptr(new $Int64(0, 64609), new $Int64(0, 490)), new Pair.ptr(new $Int64(0, 64613), new $Int64(0, 63797)), new Pair.ptr(new $Int64(0, 64621), new $Int64(0, 51225)), new Pair.ptr(new $Int64(0, 64627), new $Int64(0, 54403)), new Pair.ptr(new $Int64(0, 64633), new $Int64(0, 20416)), new Pair.ptr(new $Int64(0, 64661), new $Int64(0, 25655)), new Pair.ptr(new $Int64(0, 64663), new $Int64(0, 9363)), new Pair.ptr(new $Int64(0, 64667), new $Int64(0, 18367)), new Pair.ptr(new $Int64(0, 64679), new $Int64(0, 39803)), new Pair.ptr(new $Int64(0, 64693), new $Int64(0, 51295)), new Pair.ptr(new $Int64(0, 64709), new $Int64(0, 48403)), new Pair.ptr(new $Int64(0, 64717), new $Int64(0, 1480)), new Pair.ptr(new $Int64(0, 64747), new $Int64(0, 40662)), new Pair.ptr(new $Int64(0, 64763), new $Int64(0, 42255)), new Pair.ptr(new $Int64(0, 64781), new $Int64(0, 61426)), new Pair.ptr(new $Int64(0, 64783), new $Int64(0, 31061)), new Pair.ptr(new $Int64(0, 64793), new $Int64(0, 40446)), new Pair.ptr(new $Int64(0, 64811), new $Int64(0, 22720)), new Pair.ptr(new $Int64(0, 64817), new $Int64(0, 35229)), new Pair.ptr(new $Int64(0, 64849), new $Int64(0, 11246)), new Pair.ptr(new $Int64(0, 64853), new $Int64(0, 11102)), new Pair.ptr(new $Int64(0, 64871), new $Int64(0, 43317)), new Pair.ptr(new $Int64(0, 64877), new $Int64(0, 12869)), new Pair.ptr(new $Int64(0, 64879), new $Int64(0, 56929)), new Pair.ptr(new $Int64(0, 64891), new $Int64(0, 54340)), new Pair.ptr(new $Int64(0, 64901), new $Int64(0, 62642)), new Pair.ptr(new $Int64(0, 64919), new $Int64(0, 61158)), new Pair.ptr(new $Int64(0, 64921), new $Int64(0, 2010)), new Pair.ptr(new $Int64(0, 64927), new $Int64(0, 49499)), new Pair.ptr(new $Int64(0, 64937), new $Int64(0, 12070)), new Pair.ptr(new $Int64(0, 64951), new $Int64(0, 26327)), new Pair.ptr(new $Int64(0, 64969), new $Int64(0, 20613)), new Pair.ptr(new $Int64(0, 64997), new $Int64(0, 40424)), new Pair.ptr(new $Int64(0, 65003), new $Int64(0, 3189)), new Pair.ptr(new $Int64(0, 65011), new $Int64(0, 36970)), new Pair.ptr(new $Int64(0, 65027), new $Int64(0, 41141)), new Pair.ptr(new $Int64(0, 65029), new $Int64(0, 16182)), new Pair.ptr(new $Int64(0, 65033), new $Int64(0, 23964)), new Pair.ptr(new $Int64(0, 65053), new $Int64(0, 53985)), new Pair.ptr(new $Int64(0, 65063), new $Int64(0, 50153)), new Pair.ptr(new $Int64(0, 65071), new $Int64(0, 30276)), new Pair.ptr(new $Int64(0, 65089), new $Int64(0, 1469)), new Pair.ptr(new $Int64(0, 65099), new $Int64(0, 24811)), new Pair.ptr(new $Int64(0, 65101), new $Int64(0, 43476)), new Pair.ptr(new $Int64(0, 65111), new $Int64(0, 57267)), new Pair.ptr(new $Int64(0, 65119), new $Int64(0, 22661)), new Pair.ptr(new $Int64(0, 65123), new $Int64(0, 42620)), new Pair.ptr(new $Int64(0, 65129), new $Int64(0, 212)), new Pair.ptr(new $Int64(0, 65141), new $Int64(0, 64891)), new Pair.ptr(new $Int64(0, 65147), new $Int64(0, 45252)), new Pair.ptr(new $Int64(0, 65167), new $Int64(0, 64395)), new Pair.ptr(new $Int64(0, 65171), new $Int64(0, 18419)), new Pair.ptr(new $Int64(0, 65173), new $Int64(0, 34422)), new Pair.ptr(new $Int64(0, 65179), new $Int64(0, 33328)), new Pair.ptr(new $Int64(0, 65183), new $Int64(0, 58255)), new Pair.ptr(new $Int64(0, 65203), new $Int64(0, 10060)), new Pair.ptr(new $Int64(0, 65213), new $Int64(0, 51425)), new Pair.ptr(new $Int64(0, 65239), new $Int64(0, 5171)), new Pair.ptr(new $Int64(0, 65257), new $Int64(0, 34512)), new Pair.ptr(new $Int64(0, 65267), new $Int64(0, 54268)), new Pair.ptr(new $Int64(0, 65269), new $Int64(0, 55364)), new Pair.ptr(new $Int64(0, 65287), new $Int64(0, 35229)), new Pair.ptr(new $Int64(0, 65293), new $Int64(0, 56141)), new Pair.ptr(new $Int64(0, 65309), new $Int64(0, 49439)), new Pair.ptr(new $Int64(0, 65323), new $Int64(0, 16278)), new Pair.ptr(new $Int64(0, 65327), new $Int64(0, 15324)), new Pair.ptr(new $Int64(0, 65353), new $Int64(0, 11242)), new Pair.ptr(new $Int64(0, 65357), new $Int64(0, 5978)), new Pair.ptr(new $Int64(0, 65371), new $Int64(0, 63297)), new Pair.ptr(new $Int64(0, 65381), new $Int64(0, 16078)), new Pair.ptr(new $Int64(0, 65393), new $Int64(0, 62444)), new Pair.ptr(new $Int64(0, 65407), new $Int64(0, 52936)), new Pair.ptr(new $Int64(0, 65413), new $Int64(0, 58466)), new Pair.ptr(new $Int64(0, 65419), new $Int64(0, 32209)), new Pair.ptr(new $Int64(0, 65423), new $Int64(0, 22196)), new Pair.ptr(new $Int64(0, 65437), new $Int64(0, 8099)), new Pair.ptr(new $Int64(0, 65447), new $Int64(0, 52162)), new Pair.ptr(new $Int64(0, 65449), new $Int64(0, 65030)), new Pair.ptr(new $Int64(0, 65479), new $Int64(0, 23375)), new Pair.ptr(new $Int64(0, 65497), new $Int64(0, 39350)), new Pair.ptr(new $Int64(0, 65519), new $Int64(0, 53607)), new Pair.ptr(new $Int64(0, 65521), new $Int64(0, 59564))]); + m = 120120; + bigOne = big.NewInt(new $Int64(0, 1)); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["crypto/rand"] = (function() { + var $pkg = {}, $init, errors, js, io, big, rngReader, sliceType, ptrType$1, smallPrimesProduct, init; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + io = $packages["io"]; + big = $packages["math/big"]; + rngReader = $pkg.rngReader = $newType(0, $kindStruct, "rand.rngReader", true, "crypto/rand", false, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + sliceType = $sliceType($Uint8); + ptrType$1 = $ptrType(rngReader); + init = function() { + $pkg.Reader = new rngReader.ptr(); + }; + rngReader.ptr.prototype.Read = function(b) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, array, b, crypto, err, n, offset, r, randomBytes, require; + n = 0; + err = $ifaceNil; + r = this; + array = b.$array; + offset = $parseInt(b.$offset) >> 0; + crypto = $global.crypto; + if (crypto === undefined) { + crypto = $global.msCrypto; + } + if (!(crypto === undefined)) { + if (!(crypto.getRandomValues === undefined)) { + n = b.$length; + if (n > 65536) { + n = 65536; + } + crypto.getRandomValues(array.subarray(offset, offset + n >> 0)); + _tmp = n; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + } + require = $global.require; + if (!(require === undefined)) { + randomBytes = require($externalize("crypto", $String)).randomBytes; + if (!(randomBytes === undefined)) { + array.set(randomBytes(b.$length), offset); + _tmp$2 = b.$length; + _tmp$3 = $ifaceNil; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + } + _tmp$4 = 0; + _tmp$5 = errors.New("crypto/rand not available in this environment"); + n = _tmp$4; + err = _tmp$5; + return [n, err]; + }; + rngReader.prototype.Read = function(b) { return this.$val.Read(b); }; + ptrType$1.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]; + rngReader.init("", []); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = big.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Reader = $ifaceNil; + smallPrimesProduct = new big.Int.ptr(false, big.nat.nil).SetUint64(new $Uint64(3793877372, 820596253)); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["context"] = (function() { + var $pkg = {}, $init, errors, fmt, reflect, sync, time, emptyCtx, ptrType, structType, ptrType$1, chanType, background, todo, closedchan, init; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + reflect = $packages["reflect"]; + sync = $packages["sync"]; + time = $packages["time"]; + emptyCtx = $pkg.emptyCtx = $newType(4, $kindInt, "context.emptyCtx", true, "context", false, null); + ptrType = $ptrType(emptyCtx); + structType = $structType("", []); + ptrType$1 = $ptrType(time.Location); + chanType = $chanType(structType, false, true); + $ptrType(emptyCtx).prototype.Deadline = function() { + var deadline, ok; + deadline = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$1.nil); + ok = false; + return [deadline, ok]; + }; + $ptrType(emptyCtx).prototype.Done = function() { + return $chanNil; + }; + $ptrType(emptyCtx).prototype.Err = function() { + return $ifaceNil; + }; + $ptrType(emptyCtx).prototype.Value = function(key) { + var key; + return $ifaceNil; + }; + $ptrType(emptyCtx).prototype.String = function() { + var _1, e; + e = this; + _1 = e; + if (_1 === (background)) { + return "context.Background"; + } else if (_1 === (todo)) { + return "context.TODO"; + } + return "unknown empty Context"; + }; + init = function() { + $close(closedchan); + }; + ptrType.methods = [{prop: "Deadline", name: "Deadline", pkg: "", typ: $funcType([], [time.Time, $Bool], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Canceled = errors.New("context canceled"); + background = $newDataPointer(0, ptrType); + todo = $newDataPointer(0, ptrType); + closedchan = new $Chan(structType, 0); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["database/sql/driver"] = (function() { + var $pkg = {}, $init, context, errors, fmt, reflect, strconv, time, Value, Valuer, ptrType, valuerReflectType, _r; + context = $packages["context"]; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + reflect = $packages["reflect"]; + strconv = $packages["strconv"]; + time = $packages["time"]; + Value = $pkg.Value = $newType(8, $kindInterface, "driver.Value", true, "database/sql/driver", true, null); + Valuer = $pkg.Valuer = $newType(8, $kindInterface, "driver.Valuer", true, "database/sql/driver", true, null); + ptrType = $ptrType(Valuer); + Value.init([]); + Valuer.init([{prop: "Value", name: "Value", pkg: "", typ: $funcType([], [Value, $error], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = context.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrSkip = errors.New("driver: skip fast-path; continue as if unimplemented"); + $pkg.ErrBadConn = errors.New("driver: bad connection"); + $pkg.ErrRemoveArgument = errors.New("driver: remove argument from query"); + _r = reflect.TypeOf((ptrType.nil)).Elem(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + valuerReflectType = _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/segmentio/ksuid"] = (function() { + var $pkg = {}, $init, bytes, rand, driver, binary, errors, fmt, io, math, rand$1, sync, time, KSUID, randSourceReader, uint128, arrayType, arrayType$1, sliceType, sliceType$1, arrayType$2, sliceType$2, arrayType$3, ptrType, arrayType$4, arrayType$5, ptrType$1, errShortBuffer, rander, randMutex, randBuffer, errSize, errStrSize, errStrValue, errPayloadSize, _r, _r$1, _r$2, _r$3, _r$4, base62Value, fastEncodeBase62, fastAppendEncodeBase62, fastDecodeBase62, reserve, Parse, timeToCorrectedUTCTimestamp, correctedUTCTimestampToTime, NewRandom, NewRandomWithTime, FromBytes, newRBG, newRandomBitsGenerator, readCryptoRandomSeed, uint128Payload, makeUint128, makeUint128FromPayload, add128, sub128; + bytes = $packages["bytes"]; + rand = $packages["crypto/rand"]; + driver = $packages["database/sql/driver"]; + binary = $packages["encoding/binary"]; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + io = $packages["io"]; + math = $packages["math"]; + rand$1 = $packages["math/rand"]; + sync = $packages["sync"]; + time = $packages["time"]; + KSUID = $pkg.KSUID = $newType(20, $kindArray, "ksuid.KSUID", true, "github.com/segmentio/ksuid", true, null); + randSourceReader = $pkg.randSourceReader = $newType(0, $kindStruct, "ksuid.randSourceReader", true, "github.com/segmentio/ksuid", false, function(source_) { + this.$val = this; + if (arguments.length === 0) { + this.source = $ifaceNil; + return; + } + this.source = source_; + }); + uint128 = $pkg.uint128 = $newType(16, $kindArray, "ksuid.uint128", true, "github.com/segmentio/ksuid", false, null); + arrayType = $arrayType($Uint8, 20); + arrayType$1 = $arrayType($Uint8, 16); + sliceType = $sliceType($emptyInterface); + sliceType$1 = $sliceType($Uint32); + arrayType$2 = $arrayType($Uint32, 5); + sliceType$2 = $sliceType($Uint8); + arrayType$3 = $arrayType($Uint8, 27); + ptrType = $ptrType(KSUID); + arrayType$4 = $arrayType($Uint8, 8); + arrayType$5 = $arrayType($Uint64, 2); + ptrType$1 = $ptrType(randSourceReader); + base62Value = function(digit) { + var digit; + if (digit >= 48 && digit <= 57) { + return digit - 48 << 24 >>> 24; + } else if (digit >= 65 && digit <= 90) { + return 10 + ((digit - 65 << 24 >>> 24)) << 24 >>> 24; + } else { + return 36 + ((digit - 97 << 24 >>> 24)) << 24 >>> 24; + } + }; + fastEncodeBase62 = function(dst, src) { + var _i, _ref, bp, bq, c, digit, dst, n, parts, quotient, remainder, src, value, x, x$1; + parts = $toNativeArray($kindUint32, [(((((((((0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]) >>> 0)) << 24 >>> 0) | ((((1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | (((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]) >>> 0))) >>> 0, (((((((((4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4]) >>> 0)) << 24 >>> 0) | ((((5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6]) >>> 0)) << 8 >>> 0)) >>> 0) | (((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7]) >>> 0))) >>> 0, (((((((((8 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 8]) >>> 0)) << 24 >>> 0) | ((((9 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 9]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((10 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 10]) >>> 0)) << 8 >>> 0)) >>> 0) | (((11 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 11]) >>> 0))) >>> 0, (((((((((12 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 12]) >>> 0)) << 24 >>> 0) | ((((13 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 13]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((14 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 14]) >>> 0)) << 8 >>> 0)) >>> 0) | (((15 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 15]) >>> 0))) >>> 0, (((((((((16 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 16]) >>> 0)) << 24 >>> 0) | ((((17 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 17]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((18 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 18]) >>> 0)) << 8 >>> 0)) >>> 0) | (((19 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 19]) >>> 0))) >>> 0]); + n = dst.$length; + bp = new sliceType$1(parts); + bq = arrayType$2.zero(); + while (true) { + if (!(!((bp.$length === 0)))) { break; } + quotient = $subslice(new sliceType$1(bq), 0, 0); + remainder = new $Uint64(0, 0); + _ref = bp; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + value = (x = (new $Uint64(0, c)), x$1 = $mul64((remainder), new $Uint64(1, 0)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + digit = $div64(value, new $Uint64(0, 62), false); + remainder = $div64(value, new $Uint64(0, 62), true); + if (!((quotient.$length === 0)) || !((digit.$high === 0 && digit.$low === 0))) { + quotient = $append(quotient, ((digit.$low >>> 0))); + } + _i++; + } + n = n - (1) >> 0; + ((n < 0 || n >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + n] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".charCodeAt($flatten64(remainder))); + bp = quotient; + } + $copyString($subslice(dst, 0, n), "000000000000000000000000000"); + }; + fastAppendEncodeBase62 = function(dst, src) { + var dst, n, src; + dst = reserve(dst, 27); + n = dst.$length; + fastEncodeBase62($subslice(dst, n, (n + 27 >> 0)), src); + return $subslice(dst, 0, (n + 27 >> 0)); + }; + fastDecodeBase62 = function(dst, src) { + var _i, _ref, bp, bq, c, digit, dst, n, parts, quotient, remainder, src, value, x, x$1, x$2, x$3, x$4, x$5, zero; + $unused((26 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 26])); + parts = $toNativeArray($kindUint8, [base62Value((0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0])), base62Value((1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1])), base62Value((2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2])), base62Value((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3])), base62Value((4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4])), base62Value((5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5])), base62Value((6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6])), base62Value((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7])), base62Value((8 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 8])), base62Value((9 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 9])), base62Value((10 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 10])), base62Value((11 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 11])), base62Value((12 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 12])), base62Value((13 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 13])), base62Value((14 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 14])), base62Value((15 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 15])), base62Value((16 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 16])), base62Value((17 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 17])), base62Value((18 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 18])), base62Value((19 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 19])), base62Value((20 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 20])), base62Value((21 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 21])), base62Value((22 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 22])), base62Value((23 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 23])), base62Value((24 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 24])), base62Value((25 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 25])), base62Value((26 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 26]))]); + n = dst.$length; + bp = new sliceType$2(parts); + bq = arrayType$3.zero(); + while (true) { + if (!(bp.$length > 0)) { break; } + quotient = $subslice(new sliceType$2(bq), 0, 0); + remainder = new $Uint64(0, 0); + _ref = bp; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + value = (x = (new $Uint64(0, c)), x$1 = $mul64((remainder), new $Uint64(0, 62)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + digit = $div64(value, new $Uint64(1, 0), false); + remainder = $div64(value, new $Uint64(1, 0), true); + if (!((quotient.$length === 0)) || !((digit.$high === 0 && digit.$low === 0))) { + quotient = $append(quotient, ((digit.$low << 24 >>> 24))); + } + _i++; + } + if (n < 4) { + return errShortBuffer; + } + (x$2 = n - 4 >> 0, ((x$2 < 0 || x$2 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$2] = (($shiftRightUint64(remainder, 24).$low << 24 >>> 24)))); + (x$3 = n - 3 >> 0, ((x$3 < 0 || x$3 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$3] = (($shiftRightUint64(remainder, 16).$low << 24 >>> 24)))); + (x$4 = n - 2 >> 0, ((x$4 < 0 || x$4 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$4] = (($shiftRightUint64(remainder, 8).$low << 24 >>> 24)))); + (x$5 = n - 1 >> 0, ((x$5 < 0 || x$5 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$5] = ((remainder.$low << 24 >>> 24)))); + n = n - (4) >> 0; + bp = quotient; + } + zero = arrayType.zero(); + $copySlice($subslice(dst, 0, n), new sliceType$2(zero)); + return $ifaceNil; + }; + reserve = function(dst, nbytes) { + var avail, b, c, dst, n, nbytes; + c = dst.$capacity; + n = dst.$length; + avail = c - n >> 0; + if (avail < nbytes) { + c = $imul(c, (2)); + if (((c - n >> 0)) < nbytes) { + c = n + nbytes >> 0; + } + b = $makeSlice(sliceType$2, n, c); + $copySlice(b, dst); + dst = b; + } + return dst; + }; + KSUID.prototype.Append = function(b) { + var b, i; + i = this.$val; + return fastAppendEncodeBase62(b, new sliceType$2(i)); + }; + $ptrType(KSUID).prototype.Append = function(b) { return new KSUID(this.$get()).Append(b); }; + KSUID.prototype.Time = function() { + var i; + i = this.$val; + return correctedUTCTimestampToTime(new KSUID($clone(i, KSUID)).Timestamp()); + }; + $ptrType(KSUID).prototype.Time = function() { return new KSUID(this.$get()).Time(); }; + KSUID.prototype.Timestamp = function() { + var i; + i = this.$val; + return $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(new sliceType$2(i), 0, 4)); + }; + $ptrType(KSUID).prototype.Timestamp = function() { return new KSUID(this.$get()).Timestamp(); }; + KSUID.prototype.Payload = function() { + var i; + i = this.$val; + return $subslice(new sliceType$2(i), 4); + }; + $ptrType(KSUID).prototype.Payload = function() { return new KSUID(this.$get()).Payload(); }; + KSUID.prototype.String = function() { + var i; + i = this.$val; + return ($bytesToString(new KSUID($clone(i, KSUID)).Append($makeSlice(sliceType$2, 0, 27)))); + }; + $ptrType(KSUID).prototype.String = function() { return new KSUID(this.$get()).String(); }; + KSUID.prototype.Bytes = function() { + var i; + i = this.$val; + return new sliceType$2(i); + }; + $ptrType(KSUID).prototype.Bytes = function() { return new KSUID(this.$get()).Bytes(); }; + KSUID.prototype.IsNil = function() { + var i; + i = this.$val; + return $equal(i, $pkg.Nil, KSUID); + }; + $ptrType(KSUID).prototype.IsNil = function() { return new KSUID(this.$get()).IsNil(); }; + KSUID.prototype.Get = function() { + var i; + i = this.$val; + return new KSUID(i); + }; + $ptrType(KSUID).prototype.Get = function() { return new KSUID(this.$get()).Get(); }; + KSUID.prototype.Set = function(s) { + var i, s; + i = this.$val; + return new ptrType(i).UnmarshalText((new sliceType$2($stringToBytes(s)))); + }; + $ptrType(KSUID).prototype.Set = function(s) { return (new KSUID(this.$get())).Set(s); }; + KSUID.prototype.MarshalText = function() { + var i; + i = this.$val; + return [(new sliceType$2($stringToBytes(new KSUID($clone(i, KSUID)).String()))), $ifaceNil]; + }; + $ptrType(KSUID).prototype.MarshalText = function() { return new KSUID(this.$get()).MarshalText(); }; + KSUID.prototype.MarshalBinary = function() { + var i; + i = this.$val; + return [new KSUID($clone(i, KSUID)).Bytes(), $ifaceNil]; + }; + $ptrType(KSUID).prototype.MarshalBinary = function() { return new KSUID(this.$get()).MarshalBinary(); }; + KSUID.prototype.UnmarshalText = function(b) { + var _tuple, b, err, i, id; + i = this.$val; + _tuple = Parse(($bytesToString(b))); + id = $clone(_tuple[0], KSUID); + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + KSUID.copy(i, id); + return $ifaceNil; + }; + $ptrType(KSUID).prototype.UnmarshalText = function(b) { return (new KSUID(this.$get())).UnmarshalText(b); }; + KSUID.prototype.UnmarshalBinary = function(b) { + var _tuple, b, err, i, id; + i = this.$val; + _tuple = FromBytes(b); + id = $clone(_tuple[0], KSUID); + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + KSUID.copy(i, id); + return $ifaceNil; + }; + $ptrType(KSUID).prototype.UnmarshalBinary = function(b) { return (new KSUID(this.$get())).UnmarshalBinary(b); }; + KSUID.prototype.Value = function() { + var i; + i = this.$val; + if (new KSUID($clone(i, KSUID)).IsNil()) { + return [$ifaceNil, $ifaceNil]; + } + return [new $String(new KSUID($clone(i, KSUID)).String()), $ifaceNil]; + }; + $ptrType(KSUID).prototype.Value = function() { return new KSUID(this.$get()).Value(); }; + KSUID.prototype.Scan = function(src) { + var _r$5, _ref, i, src, v, v$1, v$2, v$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _ref = $f._ref; i = $f.i; src = $f.src; v = $f.v; v$1 = $f.v$1; v$2 = $f.v$2; v$3 = $f.v$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this.$val; + _ref = src; + /* */ if (_ref === $ifaceNil) { $s = 1; continue; } + /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 2; continue; } + /* */ if ($assertType(_ref, $String, true)[1]) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_ref === $ifaceNil) { */ case 1: + v = _ref; + $s = -1; return new ptrType(i).scan(sliceType$2.nil); + /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 2: + v$1 = _ref.$val; + $s = -1; return new ptrType(i).scan(v$1); + /* } else if ($assertType(_ref, $String, true)[1]) { */ case 3: + v$2 = _ref.$val; + $s = -1; return new ptrType(i).scan((new sliceType$2($stringToBytes(v$2)))); + /* } else { */ case 4: + v$3 = _ref; + _r$5 = fmt.Errorf("Scan: unable to scan type %T into KSUID", new sliceType([v$3])); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return _r$5; + /* } */ case 5: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: KSUID.prototype.Scan }; } $f._r$5 = _r$5; $f._ref = _ref; $f.i = i; $f.src = src; $f.v = v; $f.v$1 = v$1; $f.v$2 = v$2; $f.v$3 = v$3; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(KSUID).prototype.Scan = function(src) { return (new KSUID(this.$get())).Scan(src); }; + KSUID.prototype.scan = function(b) { + var _1, b, i; + i = this.$val; + _1 = b.$length; + if (_1 === (0)) { + KSUID.copy(i, $pkg.Nil); + return $ifaceNil; + } else if (_1 === (20)) { + return new ptrType(i).UnmarshalBinary(b); + } else if (_1 === (27)) { + return new ptrType(i).UnmarshalText(b); + } else { + return errSize; + } + }; + $ptrType(KSUID).prototype.scan = function(b) { return (new KSUID(this.$get())).scan(b); }; + Parse = function(s) { + var dst, err, s, src; + if (!((s.length === 27))) { + return [$pkg.Nil, errStrSize]; + } + src = arrayType$3.zero(); + dst = arrayType.zero(); + $copyString(new sliceType$2(src), s); + err = fastDecodeBase62(new sliceType$2(dst), new sliceType$2(src)); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [$pkg.Nil, errStrValue]; + } + return FromBytes(new sliceType$2(dst)); + }; + $pkg.Parse = Parse; + timeToCorrectedUTCTimestamp = function(t) { + var t, x; + return (((x = $clone(t, time.Time).Unix(), new $Int64(x.$high - 0, x.$low - 1400000000)).$low >>> 0)); + }; + correctedUTCTimestampToTime = function(ts) { + var ts, x; + return time.Unix((x = (new $Int64(0, ts)), new $Int64(x.$high + 0, x.$low + 1400000000)), new $Int64(0, 0)); + }; + NewRandom = function() { + var _r$5, _tuple, err, ksuid, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; ksuid = $f.ksuid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ksuid = arrayType.zero(); + err = $ifaceNil; + _r$5 = NewRandomWithTime($clone(time.Now(), time.Time)); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + KSUID.copy(ksuid, _tuple[0]); + err = _tuple[1]; + $s = -1; return [ksuid, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewRandom }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.ksuid = ksuid; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewRandom = NewRandom; + NewRandomWithTime = function(t) { + var _r$5, _tuple, err, ksuid, t, ts, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; ksuid = $f.ksuid; t = $f.t; ts = $f.ts; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ksuid = arrayType.zero(); + err = $ifaceNil; + $r = randMutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$5 = io.ReadAtLeast(rander, new sliceType$2(randBuffer), 16); /* */ $s = 2; case 2: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + err = _tuple[1]; + $copySlice($subslice(new sliceType$2(ksuid), 4), new sliceType$2(randBuffer)); + $r = randMutex.Unlock(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (!($interfaceIsEqual(err, $ifaceNil))) { + KSUID.copy(ksuid, $pkg.Nil); + $s = -1; return [ksuid, err]; + } + ts = timeToCorrectedUTCTimestamp($clone(t, time.Time)); + $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(new sliceType$2(ksuid), 0, 4), ts); + $s = -1; return [ksuid, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewRandomWithTime }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.ksuid = ksuid; $f.t = t; $f.ts = ts; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewRandomWithTime = NewRandomWithTime; + FromBytes = function(b) { + var b, ksuid; + ksuid = arrayType.zero(); + if (!((b.$length === 20))) { + return [$pkg.Nil, errSize]; + } + $copySlice(new sliceType$2(ksuid), b); + return [ksuid, $ifaceNil]; + }; + $pkg.FromBytes = FromBytes; + KSUID.prototype.Next = function() { + var id, t, u, v, zero; + id = this.$val; + zero = $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 0)), uint128); + t = new KSUID($clone(id, KSUID)).Timestamp(); + u = $clone(uint128Payload($clone(id, KSUID)), uint128); + v = $clone(add128($clone(u, uint128), $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 1)), uint128)), uint128); + if ($equal(v, zero, uint128)) { + t = t + (1) >>> 0; + } + return new uint128($clone(v, uint128)).ksuid(t); + }; + $ptrType(KSUID).prototype.Next = function() { return new KSUID(this.$get()).Next(); }; + KSUID.prototype.Prev = function() { + var id, max, t, u, v; + id = this.$val; + max = $clone(makeUint128(new $Uint64(4294967295, 4294967295), new $Uint64(4294967295, 4294967295)), uint128); + t = new KSUID($clone(id, KSUID)).Timestamp(); + u = $clone(uint128Payload($clone(id, KSUID)), uint128); + v = $clone(sub128($clone(u, uint128), $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 1)), uint128)), uint128); + if ($equal(v, max, uint128)) { + t = t - (1) >>> 0; + } + return new uint128($clone(v, uint128)).ksuid(t); + }; + $ptrType(KSUID).prototype.Prev = function() { return new KSUID(this.$get()).Prev(); }; + newRBG = function() { + var _r$5, _tuple, err, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$5 = newRandomBitsGenerator(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + r = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $panic(err); + } + $s = -1; return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: newRBG }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + newRandomBitsGenerator = function() { + var _r$5, _tuple, err, r, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = $ifaceNil; + err = $ifaceNil; + seed = new $Int64(0, 0); + _r$5 = readCryptoRandomSeed(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + seed = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [r, err]; + } + r = new randSourceReader.ptr($assertType(rand$1.NewSource(seed), rand$1.Source64)); + $s = -1; return [r, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: newRandomBitsGenerator }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + readCryptoRandomSeed = function() { + var _r$5, _tuple, b, err, seed, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; b = $f.b; err = $f.err; seed = $f.seed; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + seed = new $Int64(0, 0); + err = $ifaceNil; + b = arrayType$4.zero(); + _r$5 = io.ReadFull(rand.Reader, new sliceType$2(b)); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [seed, err]; + } + seed = ((x = $clone(binary.LittleEndian, binary.littleEndian).Uint64(new sliceType$2(b)), new $Int64(x.$high, x.$low))); + $s = -1; return [seed, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: readCryptoRandomSeed }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.seed = seed; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + randSourceReader.ptr.prototype.Read = function(b) { + var _arg, _arg$1, _arg$2, _arg$3, _r$5, _r$6, b, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$5 = $f._r$5; _r$6 = $f._r$6; b = $f.b; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + _arg = $subslice(b, 0, 8); + _r$5 = r.source.Uint64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + $r = $clone(binary.LittleEndian, binary.littleEndian).PutUint64(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _arg$2 = $subslice(b, 8); + _r$6 = r.source.Uint64(); /* */ $s = 3; case 3: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$3 = _r$6; + $r = $clone(binary.LittleEndian, binary.littleEndian).PutUint64(_arg$2, _arg$3); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return [16, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: randSourceReader.ptr.prototype.Read }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.b = b; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; + }; + randSourceReader.prototype.Read = function(b) { return this.$val.Read(b); }; + uint128Payload = function(ksuid) { + var ksuid; + return makeUint128FromPayload($subslice(new sliceType$2(ksuid), 4)); + }; + makeUint128 = function(high, low) { + var high, low; + return $toNativeArray($kindUint64, [low, high]); + }; + makeUint128FromPayload = function(payload) { + var payload, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$25, x$26, x$27, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + return $toNativeArray($kindUint64, [(x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = $shiftLeft64((new $Uint64(0, (8 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 8]))), 56), x$7 = $shiftLeft64((new $Uint64(0, (9 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 9]))), 48), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (10 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 10]))), 40), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (11 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 11]))), 32), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (12 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 12]))), 24), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (13 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 13]))), 16), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (14 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 14]))), 8), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = (new $Uint64(0, (15 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 15]))), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)), (x$14 = (x$15 = (x$16 = (x$17 = (x$18 = (x$19 = (x$20 = $shiftLeft64((new $Uint64(0, (0 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 0]))), 56), x$21 = $shiftLeft64((new $Uint64(0, (1 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 1]))), 48), new $Uint64(x$20.$high | x$21.$high, (x$20.$low | x$21.$low) >>> 0)), x$22 = $shiftLeft64((new $Uint64(0, (2 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 2]))), 40), new $Uint64(x$19.$high | x$22.$high, (x$19.$low | x$22.$low) >>> 0)), x$23 = $shiftLeft64((new $Uint64(0, (3 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 3]))), 32), new $Uint64(x$18.$high | x$23.$high, (x$18.$low | x$23.$low) >>> 0)), x$24 = $shiftLeft64((new $Uint64(0, (4 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 4]))), 24), new $Uint64(x$17.$high | x$24.$high, (x$17.$low | x$24.$low) >>> 0)), x$25 = $shiftLeft64((new $Uint64(0, (5 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 5]))), 16), new $Uint64(x$16.$high | x$25.$high, (x$16.$low | x$25.$low) >>> 0)), x$26 = $shiftLeft64((new $Uint64(0, (6 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 6]))), 8), new $Uint64(x$15.$high | x$26.$high, (x$15.$low | x$26.$low) >>> 0)), x$27 = (new $Uint64(0, (7 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 7]))), new $Uint64(x$14.$high | x$27.$high, (x$14.$low | x$27.$low) >>> 0))]); + }; + uint128.prototype.ksuid = function(timestamp) { + var timestamp, v; + v = this.$val; + return $toNativeArray($kindUint8, [(((timestamp >>> 24 >>> 0) << 24 >>> 24)), (((timestamp >>> 16 >>> 0) << 24 >>> 24)), (((timestamp >>> 8 >>> 0) << 24 >>> 24)), ((timestamp << 24 >>> 24)), (($shiftRightUint64(v[1], 56).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 48).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 40).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 32).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 24).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 16).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 8).$low << 24 >>> 24)), ((v[1].$low << 24 >>> 24)), (($shiftRightUint64(v[0], 56).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 48).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 40).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 32).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 24).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 16).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 8).$low << 24 >>> 24)), ((v[0].$low << 24 >>> 24))]); + }; + $ptrType(uint128).prototype.ksuid = function(timestamp) { return new uint128(this.$get()).ksuid(timestamp); }; + uint128.prototype.String = function() { + var _r$5, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this.$val; + _r$5 = fmt.Sprintf("0x%016X%016X", new sliceType([v[0], v[1]])); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return _r$5; + /* */ } return; } if ($f === undefined) { $f = { $blk: uint128.prototype.String }; } $f._r$5 = _r$5; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(uint128).prototype.String = function() { return new uint128(this.$get()).String(); }; + add128 = function(x, y) { + var c, x, x$1, x$2, x$3, x$4, x$5, x$6, x0, y, y0, z, z0; + z = arrayType$5.zero(); + x0 = x[0]; + y0 = y[0]; + z0 = new $Uint64(x0.$high + y0.$high, x0.$low + y0.$low); + z[0] = z0; + c = $shiftRightUint64(((x$1 = new $Uint64(x0.$high & y0.$high, (x0.$low & y0.$low) >>> 0), x$2 = (x$3 = new $Uint64(x0.$high | y0.$high, (x0.$low | y0.$low) >>> 0), new $Uint64(x$3.$high & ~z0.$high, (x$3.$low & ~z0.$low) >>> 0)), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0))), 63); + z[1] = (x$4 = (x$5 = x[1], x$6 = y[1], new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), new $Uint64(x$4.$high + c.$high, x$4.$low + c.$low)); + return z; + }; + sub128 = function(x, y) { + var c, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x0, y, y0, z, z0; + z = arrayType$5.zero(); + x0 = x[0]; + y0 = y[0]; + z0 = new $Uint64(x0.$high - y0.$high, x0.$low - y0.$low); + z[0] = z0; + c = $shiftRightUint64(((x$1 = new $Uint64(y0.$high & ~x0.$high, (y0.$low & ~x0.$low) >>> 0), x$2 = (x$3 = (x$4 = new $Uint64(~x0.$high, ~x0.$low >>> 0), new $Uint64(y0.$high | x$4.$high, (y0.$low | x$4.$low) >>> 0)), new $Uint64(x$3.$high & z0.$high, (x$3.$low & z0.$low) >>> 0)), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0))), 63); + z[1] = (x$5 = (x$6 = x[1], x$7 = y[1], new $Uint64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), new $Uint64(x$5.$high - c.$high, x$5.$low - c.$low)); + return z; + }; + KSUID.methods = [{prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$2], [sliceType$2], false)}, {prop: "Time", name: "Time", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Timestamp", name: "Timestamp", pkg: "", typ: $funcType([], [$Uint32], false)}, {prop: "Payload", name: "Payload", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$2, $error], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$2, $error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([], [driver.Value, $error], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([], [KSUID], false)}, {prop: "Prev", name: "Prev", pkg: "", typ: $funcType([], [KSUID], false)}]; + ptrType.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "scan", name: "scan", pkg: "github.com/segmentio/ksuid", typ: $funcType([sliceType$2], [$error], false)}]; + ptrType$1.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}]; + uint128.methods = [{prop: "ksuid", name: "ksuid", pkg: "github.com/segmentio/ksuid", typ: $funcType([$Uint32], [KSUID], false)}, {prop: "bytes", name: "bytes", pkg: "github.com/segmentio/ksuid", typ: $funcType([], [arrayType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + KSUID.init($Uint8, 20); + randSourceReader.init("github.com/segmentio/ksuid", [{prop: "source", name: "source", embedded: false, exported: false, typ: rand$1.Source64, tag: ""}]); + uint128.init($Uint64, 2); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = rand.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = driver.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = binary.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = errors.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = rand$1.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Nil = arrayType.zero(); + errShortBuffer = errors.New("the output buffer is too small to hold to decoded value"); + rander = rand.Reader; + randMutex = new sync.Mutex.ptr(0, 0); + randBuffer = arrayType$1.zero(); + _r = fmt.Errorf("Valid KSUIDs are %v bytes", new sliceType([new $Int(20)])); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + errSize = _r; + _r$1 = fmt.Errorf("Valid encoded KSUIDs are %v characters", new sliceType([new $Int(27)])); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + errStrSize = _r$1; + _r$2 = fmt.Errorf("Valid encoded KSUIDs are bounded by %s and %s", new sliceType([new $String("000000000000000000000000000"), new $String("aWgEPTl1tmebfsQzFP4bxwgy80V")])); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + errStrValue = _r$2; + _r$3 = fmt.Errorf("Valid KSUID payloads are %v bytes", new sliceType([new $Int(16)])); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + errPayloadSize = _r$3; + _r$4 = newRBG(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $pkg.FastRander = _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/bonedaddy/vcaptcha/ticket"] = (function() { + var $pkg = {}, $init, sha256, hex, json, vdf, ksuid, Ticket, arrayType, ptrType, arrayType$1, sliceType, NewTicket, NewSeed, IDToBytes32; + sha256 = $packages["crypto/sha256"]; + hex = $packages["encoding/hex"]; + json = $packages["encoding/json"]; + vdf = $packages["github.com/bonedaddy/vcaptcha/vdf"]; + ksuid = $packages["github.com/segmentio/ksuid"]; + Ticket = $pkg.Ticket = $newType(0, $kindStruct, "ticket.Ticket", true, "github.com/bonedaddy/vcaptcha/ticket", true, function(Seed_, Difficulty_, Proof_) { + this.$val = this; + if (arguments.length === 0) { + this.Seed = arrayType.zero(); + this.Difficulty = 0; + this.Proof = arrayType$1.zero(); + return; + } + this.Seed = Seed_; + this.Difficulty = Difficulty_; + this.Proof = Proof_; + }); + arrayType = $arrayType($Uint8, 32); + ptrType = $ptrType(Ticket); + arrayType$1 = $arrayType($Uint8, 516); + sliceType = $sliceType($Uint8); + NewTicket = function(diff) { + var _r, _tuple, diff, err, seed, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; diff = $f.diff; err = $f.err; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = NewSeed(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + seed = $clone(_tuple[0], arrayType); + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [ptrType.nil, err]; + } + $s = -1; return [new Ticket.ptr($clone(seed, arrayType), diff, arrayType$1.zero()), $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewTicket }; } $f._r = _r; $f._tuple = _tuple; $f.diff = diff; $f.err = err; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewTicket = NewTicket; + Ticket.ptr.prototype.Encode = function() { + var _r, _tuple, data, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = t.Marshal(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + data = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return ["", err]; + } + $s = -1; return [hex.EncodeToString(data), $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Encode }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Ticket.prototype.Encode = function() { return this.$val.Encode(); }; + Ticket.ptr.prototype.Marshal = function() { + var _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = json.Marshal(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Marshal }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Ticket.prototype.Marshal = function() { return this.$val.Marshal(); }; + Ticket.ptr.prototype.Hash = function() { + var _r, _r$1, _tuple, bytes, dt, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; bytes = $f.bytes; dt = $f.dt; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = json.Marshal(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + bytes = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return ""; + } + _r$1 = sha256.Sum256(bytes); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + dt = $clone(_r$1, arrayType); + $s = -1; return hex.EncodeToString(new sliceType(dt)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Hash }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.bytes = bytes; $f.dt = dt; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Ticket.prototype.Hash = function() { return this.$val.Hash(); }; + Ticket.ptr.prototype.Verify = function(proof) { + var _r, gvdf, proof, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; gvdf = $f.gvdf; proof = $f.proof; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + gvdf = vdf.New(t.Difficulty, $clone(t.Seed, arrayType)); + _r = gvdf.Verify($clone(proof, arrayType$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Verify }; } $f._r = _r; $f.gvdf = gvdf; $f.proof = proof; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Ticket.prototype.Verify = function(proof) { return this.$val.Verify(proof); }; + Ticket.ptr.prototype.Solve = function() { + var _r, gvdf, proof, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; gvdf = $f.gvdf; proof = $f.proof; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + gvdf = vdf.New(t.Difficulty, $clone(t.Seed, arrayType)); + $r = gvdf.Execute(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r = $recv(gvdf.GetOutputChannel()); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + proof = $clone(_r[0], arrayType$1); + arrayType$1.copy(t.Proof, proof); + $s = -1; return proof; + /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Solve }; } $f._r = _r; $f.gvdf = gvdf; $f.proof = proof; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Ticket.prototype.Solve = function() { return this.$val.Solve(); }; + NewSeed = function() { + var _r, _tuple, err, kid, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; kid = $f.kid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = ksuid.NewRandom(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + kid = $clone(_tuple[0], ksuid.KSUID); + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [arrayType.zero(), err]; + } + $s = -1; return [IDToBytes32($clone(kid, ksuid.KSUID)), $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: NewSeed }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.kid = kid; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.NewSeed = NewSeed; + IDToBytes32 = function(kid) { + var combined, i, id, kid; + id = arrayType.zero(); + combined = sliceType.nil; + combined = $appendSlice(combined, new ksuid.KSUID($clone(kid, ksuid.KSUID)).Bytes()); + combined = $appendSlice(combined, $subslice(new ksuid.KSUID($clone(kid, ksuid.KSUID)).Payload(), 0, 12)); + i = 0; + while (true) { + if (!(i < combined.$length)) { break; } + ((i < 0 || i >= id.length) ? ($throwRuntimeError("index out of range"), undefined) : id[i] = ((i < 0 || i >= combined.$length) ? ($throwRuntimeError("index out of range"), undefined) : combined.$array[combined.$offset + i])); + i = i + (1) >> 0; + } + return id; + }; + $pkg.IDToBytes32 = IDToBytes32; + ptrType.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([], [$String, $error], false)}, {prop: "Marshal", name: "Marshal", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "Hash", name: "Hash", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Verify", name: "Verify", pkg: "", typ: $funcType([arrayType$1], [$Bool], false)}, {prop: "Solve", name: "Solve", pkg: "", typ: $funcType([], [arrayType$1], false)}]; + Ticket.init("", [{prop: "Seed", name: "Seed", embedded: false, exported: true, typ: arrayType, tag: "json:\"seed\""}, {prop: "Difficulty", name: "Difficulty", embedded: false, exported: true, typ: $Int, tag: "json:\"difficulty\""}, {prop: "Proof", name: "Proof", embedded: false, exported: true, typ: arrayType$1, tag: "json:\"proof\""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = sha256.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = hex.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = json.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = vdf.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = ksuid.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["."] = (function() { + var $pkg = {}, $init, ticket, js, ptrType, funcType, mapType, main; + ticket = $packages["github.com/bonedaddy/vcaptcha/ticket"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + ptrType = $ptrType(ticket.Ticket); + funcType = $funcType([$Int], [ptrType, $error], false); + mapType = $mapType($String, $emptyInterface); + main = function() { + $global.ticket = $externalize($makeMap($String.keyFor, [{ k: "New", v: new funcType(ticket.NewTicket) }]), mapType); + }; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = ticket.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if ($pkg === $mainPkg) { + main(); + $mainFinished = true; + } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$synthesizeMethods(); +var $mainPkg = $packages["."]; +$packages["runtime"].$init(); +$go($mainPkg.$init, []); +$flushConsole(); + +}).call(this); +//# sourceMappingURL=js.js.map diff --git a/ticket/js/js.js.map b/ticket/js/js.js.map new file mode 100644 index 0000000..76dccea --- /dev/null +++ b/ticket/js/js.js.map @@ -0,0 +1 @@ +{"version":3,"file":"js.js","sources":["/github.com/gopherjs/gopherjs/js/js.go","/internal/bytealg/index_generic.go","/internal/bytealg/indexbyte_generic.go","runtime.go","/runtime/error.go","/errors/errors.go","atomic.go","pool.go","sync.go","/sync/mutex.go","/sync/pool.go","/sync/runtime.go","/sync/rwmutex.go","/io/io.go","/math/bits/bits.go","math.go","/math/abs.go","/math/dim.go","/math/floor.go","/math/frexp.go","/math/ldexp.go","/math/log10.go","/unicode/utf8/utf8.go","/strconv/atof.go","/strconv/atoi.go","/strconv/decimal.go","/strconv/extfloat.go","/strconv/ftoa.go","/strconv/itoa.go","/strconv/quote.go","/crypto/crypto.go","/crypto/sha256/sha256.go","/crypto/sha256/sha256block.go","unicode.go","/unicode/digit.go","/unicode/graphic.go","/unicode/letter.go","reflect.go","swapper.go","/reflect/type.go","/reflect/value.go","/sort/search.go","/sort/slice.go","/sort/sort.go","/sort/zfuncversion.go","/internal/fmtsort/sort.go","syscall.go","syscall_unix.go","/syscall/dirent.go","/syscall/exec_unix.go","/syscall/str.go","/syscall/syscall.go","/syscall/syscall_linux.go","/syscall/syscall_linux_amd64.go","/syscall/syscall_unix.go","/syscall/zsyscall_linux_amd64.go","/github.com/gopherjs/gopherjs/nosync/map.go","/github.com/gopherjs/gopherjs/nosync/mutex.go","/github.com/gopherjs/gopherjs/nosync/once.go","/github.com/gopherjs/gopherjs/nosync/pool.go","time.go","/time/format.go","/time/time.go","/time/zoneinfo.go","fd_poll.go","/internal/poll/fd.go","/internal/poll/fd_fsync_posix.go","/internal/poll/fd_mutex.go","/internal/poll/fd_posix.go","/internal/poll/fd_unix.go","/internal/poll/fd_writev_unix.go","/internal/poll/sock_cloexec.go","/internal/poll/sockopt.go","/internal/poll/sockopt_linux.go","/internal/poll/sockopt_unix.go","/internal/poll/sockoptip.go","/internal/poll/writev.go","/internal/testlog/log.go","os.go","/os/dir.go","/os/dir_unix.go","/os/error.go","/os/error_posix.go","/os/error_unix.go","/os/file.go","/os/file_posix.go","/os/file_unix.go","/os/path_unix.go","/os/proc.go","/os/rawconn.go","/os/stat.go","/os/stat_linux.go","/os/stat_unix.go","/os/types.go","/os/types_unix.go","/fmt/format.go","/fmt/print.go","/fmt/scan.go","strings.go","/strings/builder.go","/strings/reader.go","/strings/strings.go","/encoding/hex/hex.go","bytes.go","/bytes/buffer.go","/bytes/bytes.go","/bytes/reader.go","/encoding/binary/binary.go","/encoding/base64/base64.go","/encoding/json/decode.go","/encoding/json/encode.go","/encoding/json/fold.go","/encoding/json/indent.go","/encoding/json/scanner.go","/encoding/json/tags.go","/log/log.go","/math/rand/exp.go","/math/rand/normal.go","/math/rand/rand.go","/math/rand/rng.go","/math/big/accuracy_string.go","/math/big/arith.go","/math/big/decimal.go","/math/big/float.go","/math/big/floatconv.go","/math/big/floatmarsh.go","/math/big/ftoa.go","/math/big/int.go","/math/big/intconv.go","/math/big/intmarsh.go","/math/big/nat.go","/math/big/natconv.go","/math/big/prime.go","/math/big/rat.go","/math/big/ratconv.go","/math/big/ratmarsh.go","/math/big/roundingmode_string.go","/math/big/sqrt.go","/regexp/syntax/compile.go","/regexp/syntax/op_string.go","/regexp/syntax/parse.go","/regexp/syntax/prog.go","/regexp/syntax/regexp.go","/regexp/syntax/simplify.go","/regexp/backtrack.go","/regexp/exec.go","/regexp/onepass.go","/regexp/regexp.go","/github.com/bonedaddy/vcaptcha/vdf/classgroup.go","/github.com/bonedaddy/vcaptcha/vdf/discriminant.go","/github.com/bonedaddy/vcaptcha/vdf/division.go","/github.com/bonedaddy/vcaptcha/vdf/encode.go","/github.com/bonedaddy/vcaptcha/vdf/gcd.go","/github.com/bonedaddy/vcaptcha/vdf/prime.go","/github.com/bonedaddy/vcaptcha/vdf/proof_wesolowski.go","/github.com/bonedaddy/vcaptcha/vdf/vdf.go","rand.go","/context/context.go","/github.com/segmentio/ksuid/base62.go","/github.com/segmentio/ksuid/ksuid.go","/github.com/segmentio/ksuid/rand.go","/github.com/segmentio/ksuid/uint128.go","/github.com/bonedaddy/vcaptcha/ticket/ticket.go","main.go"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+B4C;A;;;;;AAGW;A;;;;;AAGhB;A;;;;;AAGN;A;;;;;AAGQ;A;;;;;AAGc;A;;;;;AAGY;A;;;;;AAGX;A;;;;;AAGH;A;;;;;AAGrB;A;;;;;AAGI;A;;;;;AAGN;A;;;;;AAGI;A;;;;;AAGE;A;;;;;AAGA;A;;;;;AAGQ;A;;;;;AAGP;A;;;;;AASnC;A;;;;;AAKA;A;;;;AAsBA;A;;;;AAkDA;AACA;A;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;ACzJA;A;;;;AAcA;A;;;;ACTI;;;A;AAEF;A;AAFsB;A;AAKxB;A;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;A;;;;;AAGA;A;;;;AAIA;AACA;AACA;AACA;AAEI;AACJ;AACA;A;;;AAIA;A;AAEC;A;AAEE;A;AAEF;A;AACS;A;AACT;A;A;AAID;A;;;;;;;;AAQA;A;A;;;;;;;;;A;AAIA;A;;;;;;;;;A;;;AA6BA;AACA;A;;;;A;;;AAiF6D;A;;;;;;A;;;;;A;;;AAEA;A;;;;AAG7D;A;;;;A;;;;AA6CA;A;;A;;;;;ACpMA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAEC;A;A;AAIE;A;AAEA;A;A;AAGF;A;AAED;A;;;;;A;;;;;AAUA;A;;;;;;;;;;;;A;A;A;A;;;;;;;;;;;;;;;;;;;ACpDA;A;;;;;AASA;A;;;;;;;;;;;;;;;;A;;;;A;;;;A;;;A;;;A;;;;A;;;;A;;;;;;;;;;;;;;;;;;;;;;;;A;AC8BC;AACA;A;AAED;A;;;;A;AAqBC;AACA;A;AAED;A;;;;AAoBA;AACA;AACA;A;;;;AA4BA;A;;;;AAYA;A;;;;AAYA;A;;;;AAQA;A;;;;;;A;;A;;;;;A;AAqBC;A;A;AAGA;A;AAED;A;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxKA;;A;AACC;;A;AACC;;A;AAED;A;AAED;AACA;AACA;A;;;;;;A;AAKC;A;AAED;A;;;;A;;;;ACHA;;A;AACC;A;AAEC;A;AAEA;A;AAED;;AACA;A;AAEC;A;A;A;A;;;;;;A;AAUF;A;AAEC;A;AAGD;AACA;AACA;A;AAEC;A;AAGD;A;A;;;;;A;;;AAQA;A;;AAMA;A;;;AAKA;A;;;;;A;A;ACHE;A;AAED;A;AAGG;AACJ;AACA;AACA;AACA;AACA;AAGC;;A;A;AAME;A;AAED;AACA;AACA;AACA;A;AAED;A;AAGC;A;A;AAGA;A;A;AAOA;A;A;A;AAMC;A;AAED;A;AAED;;A;A;AAEE;A;AAGD;A;AAEC;A;AAED;AACA;AACA;A;A;AAOE;A;AAED;A;AAOC;A;AAED;AACA;A;AAED;AACA;A;;AAEA;A;A;A;AAKD;A;A;;;;;;;;A;AAYA;AACA;A;AAID;A;AAEC;A;AAED;;A;AACC;AACA;A;AAQE;A;AAGD;AACA;;A;AACC;AACA;A;AAED;A;A;;AAOD;A;A;;;;;;ACcD;;;;;;AACC;AACI;;;AACH;AACA;AACA;;;;;AACC;A;;AAED;AANiC;A;AAQlC;AACA;A;;AAED;A;;AASA;A;;;AAIA;AACA;A;;;ACxMI;AACJ;A;;;;;;;;A;ACRC;AACA;A;AAED;;A;AAEC;A;A;AAGA;AACA;A;A;;;;;;;;A;AAUA;AACA;AACA;A;AAEE;AAAH;;A;A;AAEE;AACA;A;AAGD;;A;AAEC;A;A;A;AAID;A;A;;;;;;;;A;AASA;AACA;A;AAGD;AAEA;AAEA;;A;AACC;A;A;AAGA;AACA;AACA;A;A;;;;;;;;A;AAYA;AACA;AACA;A;AAID;A;AAEC;AACA;A;AAGG;;;AACH;AADuB;A;AAIxB;A;AAEC;A;A;;;;;;;AAOD;A;;;;;;AAK4B;A;;;;;;;;AACA;A;;;;;;;;;;;;;;;;;;;A;A;A;A;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;ACgJzB;;;AAAH;;A;A;;;;;A;A;;;;;A;;;;;;;;A;A;;;;;A;AAkBA;;AACK;AACJ;;;;AACA;A;A;AAGA;A;AAEA;A;AAED;A;;;;;;;;A;;;;;A;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;A;;;;;;;;;;ACzS+B;A;;;;AAYI;A;;;;A;AAwBlC;A;AAED;A;;;;A;AAoBC;A;AAGD;A;;;;A;AAMC;A;AAaD;A;;;;A;AAwLC;A;AAED;A;;;;;A;AAoBC;AACA;A;A;AAGA;AACA;A;A;;A;;;;;A;AAQA;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;A;;A;;;;;A;A;A;;;;;;;;;;;;;;;;ACzRD;A;;;;A;AAKC;A;AAED;A;;;;AAoBA;A;;;;AAYA;A;;;;;;A;;;;A;;;;A;AAcC;A;AAEA;A;A;;;;A;AAMA;A;A;AAGA;A;AAED;A;;;;;A;;A;;;;A;A;AAUE;A;AAED;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;AAYA;A;;;;AAIA;A;;;AAuBA;A;;;;A;AAKC;A;AAED;A;;;;AAQA;A;;;;AAgBA;A;;;;AAyBA;AACA;AACA;AACA;A;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;A;;;;ACjPA;A;;;;;;A;A;;;;;A;A;;;;;A;;;A;AC4BC;A;AAEA;A;A;AAGC;A;AAED;A;A;AAGA;A;AAED;A;;;ACqBA;AACA;A;AAGC;A;AAEC;A;A;AAQD;AACA;AACA;A;AAED;A;;;;;;A;A;;;;;A;A;;;;;A;AClEA;;;AACA;AACA;AACA;AACA;AACA;AACA;A;;;A;ACZC;A;AAEA;A;AAED;;;AACA;AACA;AACA;A;AAEC;A;A;A;AAIC;A;AAED;A;AAEG;A;AAEH;AACA;A;AAED;AACA;AACA;A;;;ACxBA;;;A;AAIC;A;AAED;A;;;;A;A;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;AC4HA;A;A;;;;;A;AAIA;AACA;A;AAKC;A;;;;;A;AAGD;AACA;A;A;;;;;A;AAIA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;AAKC;A;;;;;A;AAGD;AACA;A;A;;;;;A;AAIA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;A;;;;;A;AAOA;A;AAEC;A;AAEG;A;;A;AAEF;A;AAFyB;A;A;AAM1B;A;AAED;;;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;A;;;;;A;AAOA;A;AAEC;A;AAEG;A;;A;AAEF;A;AAFyB;A;A;AAM1B;A;AAED;;;A;A;;;;;A;A;;;;;A;;;;A;AAYC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAOO;A;AAEN;AACA;A;AAEA;AACA;AACA;AACA;A;AAEA;AAGA;AACA;AACA;AACA;AACA;A;AAJA;AACA;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;AACA;AACA;A;A;;;;AAOD;AACI;AACA;;;AACH;AACA;A;AAGC;AACA;A;AAED;A;AAEC;AACA;A;AAED;A;AAEC;AACA;A;AAED;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;A;AAED;A;;;;;AAKA;AACI;;;AACH;A;AAGC;AAJkB;A;A;AAOnB;A;AAEC;AATkB;A;A;AAYnB;A;AAEC;AAdkB;A;A;AAiBnB;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;AA3BmB;A;A;;A;;;;AAmCS;A;;;;AAoC7B;AACI;;;AACH;A;AAEC;AACA;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAED;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;A;AAED;A;;;;A;AAQC;A;AAEA;A;AAED;A;;;;;;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;ACrfC;A;AAEG;;;AACH;A;AAEC;A;AAED;A;AAEC;A;A;AAGA;A;AAVuB;A;AAazB;A;;;;;A;AAKC;A;A;A;A;A;;;;;A;A;A;A;;;;;A;A;A;A;;;;;A;A;A;A;;;;;A;A;AAIA;A;AAkBD;A;;;;;AAIA;AACA;AACA;A;AAIC;A;A;AAIA;A;AAEA;AACA;A;AAID;AACA;AACA;;A;A;AAIG;A;AAED;AACA;AAPgB;A;A;AAWhB;A;AAEC;AAbe;A;A;A;AAiBf;AACA;A;AAEA;A;AApBe;A;A;AAwBjB;A;A;AAGA;A;A;AAGA;A;A;AASA;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAGA;A;AAED;AACA;;A;AAEE;A;AAF8C;A;AAKhD;A;A;AAIA;A;AAGD;AACA;A;;;;;;;;;AAQA;A;AAIC;A;A;AAIA;A;AAEA;AACA;A;AAID;AACA;AACA;AACA;AACA;AACA;;AACQ;A;A;A;AAGL;A;AAED;AACA;AAPgB;A;A;AAWhB;A;AAEC;AAbe;A;A;AAgBhB;A;AAEC;AACA;AACA;A;AAEA;A;AAtBe;A;A;AA0BjB;A;A;AAGA;A;A;AAGA;A;A;AASA;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAGA;A;AAED;AACA;;A;AAEE;A;AAF8C;A;AAKhD;A;A;AAIA;A;A;AAIA;A;AAED;AACA;A;;;;;;;AAQI;AACA;AAGJ;;A;AACC;AACA;AACA;A;AAMD;;A;AACC;A;AAED;;A;AAEC;AACA;AACA;A;AAID;AACA;;AACK;A;AAEH;A;AAEA;A;AAED;AACA;A;AAED;;AACK;A;AAEH;A;AAEA;A;AAED;AACA;A;AAID;A;AAMC;AACA;AACA;A;AAGD;;A;AACC;A;AAID;AACA;AAGA;;A;AACC;AACA;AACA;;A;AACC;A;A;A;AAMD;A;AAED;AAED;AAEC;AACA;AACA;AAED;AAEC;AACA;A;AAEC;A;A;;;;;A;;;;;;;A;AAsBA;A;AAED;A;AAEC;A;A;A;;;;;A;A;AAYC;AACA;A;A;AAIA;A;A;;;;;A;A;;;;;A;AAMF;A;;;;;A;AAOC;A;AAED;A;AAEC;A;A;A;;;;;A;A;AAWC;AACA;A;A;AAIA;A;A;;;;;A;A;;;;;A;AAMF;A;;;;;AAMG;;;A;A;;;;;A;A;AAMF;;;;;;A;A;AAIK;;;A;A;;;;;A;A;AAKJ;AACG;A;AACF;;;AACA;A;AAEC;A;A;;;;;A;A;A;AAMA;A;A;;;;;A;AAIJ;;;AACA;A;AAEC;A;A;;;;;A;;;;;AAME;;;A;A;;;;;A;A;AAMF;;;;;;A;A;AAIK;;;A;A;;;;;A;A;AAKJ;AACG;A;AACF;;;AACA;A;AAEC;A;A;;;;;A;A;A;AAMA;A;A;;;;;A;AAIJ;;;AACA;A;AAEC;A;A;;;;;A;;;A;AAwBA;;;AACA;A;AAED;A;;;;;;ACngBA;;A;;;;;AAIA;A;;;AAIA;A;;;AAIA;A;;;AAIA;A;;;A;AAeC;A;AAGD;A;A;A;A;AAUG;A;AAED;AACA;A;AAEA;AACA;A;AAEA;A;A;AAID;A;A;AAIA;A;AAEA;A;AAKG;A;A;AAGH;A;AAEA;A;AAEA;A;AAGD;AAEI;AACJ;;;;;AACK;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;A;AAKA;A;AAED;AAEA;A;AAGC;A;AAED;A;;AAGD;A;;;;;;A;A;;;;;A;AA+BA;AACA;A;AAEC;A;AAEA;AACA;A;AAIG;AACJ;;;A;AAEC;AACA;A;;;;;A;A;AAKA;A;AAGD;A;A;;;;;A;A;A;;;;;A;AAOA;A;AAEC;A;A;;;;;A;;;;;AC7KD;A;AAEC;A;A;AAGA;A;AAGD;AACA;A;AAGC;A;AAIA;AACA;AACA;AACA;AACA;AACA;A;AAIA;AACA;AACA;AACA;A;AAIA;AACA;A;AAED;A;;;;AAIA;;;;;AACC;A;;AAED;A;;;AAOA;;AACC;A;A;AAGA;A;A;;;;AAMG;AAGJ;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAID;AACI;A;;AACH;AACA;AAFgB;A;AAIjB;AACA;A;;;;AAUA;AACA;AAGI;AACJ;;A;A;AAIG;AACA;A;AAED;;AACC;AACA;A;AAED;A;AAED;AACA;AAdgB;A;AAgBjB;AAEI;AAGJ;;AACC;AACA;AACA;AACA;AACA;AACA;AANe;A;AAUhB;;AACC;AACA;A;AAEC;AACA;A;AAEA;A;AAED;A;AAGD;AACA;A;;;AAiGI;;;A;AAEF;A;A;AAGA;A;AALsB;A;AAQxB;A;;;AAKA;A;AAEC;A;AAGD;AACA;AAGI;AACA;A;;AACH;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAED;AAVgB;A;AAcjB;;AACC;AACA;AACA;A;AAEC;A;AAEA;A;AAED;A;AAGD;A;AAEC;A;AAED;AACA;A;;;;A;A;AASC;;AACC;AACA;A;AAED;A;AAEA;;AACC;AACA;A;AAED;A;A;;;;A;AAOA;A;A;A;AAKC;A;AAED;A;AAGD;A;;;;A;AASC;A;A;AAGA;A;AAEA;A;A;;;;;A;AAOA;A;AAED;AACA;A;;;;;A;AAMC;A;AAIG;;;AACH;A;AAEC;AACA;AACA;A;AALuB;A;AAWzB;AACA;AACA;A;;;;;A;AAOC;A;AAEG;AACJ;AACI;;;AACH;AADgC;A;AAGjC;;AACC;AADe;A;A;AAIf;A;AAED;A;;;;;;;ACzRA;AAEA;A;AAIC;AACA;AACA;A;AAID;A;AAGC;A;A;AAKA;AACA;A;A;AAMA;AACA;AACA;A;AAGA;A;AAGD;AACA;A;AAEC;A;AAED;A;;;;;;;AAQA;AACA;AACA;A;AAGC;AACA;A;;;;;A;AAGD;AAEA;A;AAEC;A;AAEA;A;AAED;A;;;;;A;AAQC;A;AAED;AACA;AACA;AACA;A;;;;;AAMA;;;;AACA;;;;AAGA;AACA;AAGA;AACA;AAEA;AAEA;AACA;A;;;;;;AAeA;A;AAGC;A;AAGD;AACA;AACA;AAGA;A;A;;A;AAIA;A;AAKC;AACA;A;AAEA;AACA;AACA;A;AAID;A;AAEC;A;AAED;AAGA;AACA;AAQA;AACI;A;AAGH;A;AAEA;A;AAGD;AACA;A;A;;A;A;;A;;;;;;;AA0BA;AACA;AAEA;;AACC;A;AAGC;A;AAEA;A;AAEA;A;A;AAKF;A;;;;;A;;;;;AAOA;;;AACA;AACA;AACA;A;;;;A;AAQC;AACA;AACA;AACA;A;A;AAGA;A;AAID;AACA;;AAEA;AACA;AACA;AACA;AAGA;AACA;AACA;AACI;;;;;;A;AAEF;AACA;A;AAED;AALmC;A;AAOpC;A;AAGC;AACA;AACA;A;AAEA;A;AAIG;AACJ;AACI;;;AACH;AACA;AACA;AACA;AACA;A;AAEG;;;AACH;AAD2B;A;AAG5B;AACA;AACA;AACA;A;A;AAIE;A;AAID;;AACC;AACA;A;AAGC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;AAkBD;A;AAEC;A;AAGG;;;A;AAEF;AACA;A;AAHyB;A;AAM3B;A;;;;A;AAaC;A;A;AAGA;A;A;AAGA;A;A;AAIA;AACA;;A;AAEE;A;AAEA;A;AAJY;A;A;AAQb;AACA;AACA;A;AAEA;A;AAED;A;AAED;A;;;;A;AASC;AACA;AACA;AACA;A;A;AAII;AACJ;AACI;;;AACH;AACA;AACA;AACA;AACA;A;AAED;AACI;;;AACH;AADmB;A;AAGpB;;;;AACA;;AACC;A;A;AAGA;A;AAED;AACA;A;AAED;A;AAGC;AACA;A;A;AAGA;AACA;A;AAGD;AAEA;AACA;AAIA;AACA;AACA;AAGA;AAEA;AAGI;AACA;;;;;;A;AAEF;AACA;A;AAED;AALmC;A;AAOhC;;;AACH;AACA;AACA;AACA;AAEG;A;AACF;AACA;AACA;AAGA;A;AAZ6B;A;AAe/B;AACA;AACA;AAII;AACJ;AACA;AACC;AACA;AACA;AACA;AACA;AACA;A;AAKC;A;A;A;;;;A;AAcD;A;AAED;;A;AACC;AACA;A;A;AAIA;A;A;AAIA;A;A;AAIA;AACA;A;AAED;A;;;AC1lBA;A;;;;AAMA;A;;;;AAII;AACA;A;A;AAGH;AACA;A;AAEA;AACA;A;AAEA;A;AAGD;AACA;AACA;A;A;AAKK;A;AAGH;A;AAEA;A;AAEA;A;AAED;A;AAIA;A;AAIA;A;AAED;A;AAIC;A;A;AAIA;A;AAGG;AACJ;AAEA;A;AAGC;AACA;;;AACI;AACJ;AACA;A;AAEC;A;A;A;AAKA;A;AAEA;A;AAEA;A;A;AAID;A;A;AAGC;A;A;AAGC;A;AAED;A;A;AAII;AACJ;AACA;AACA;A;A;A;AAID;A;AAED;A;;;AAKA;AACA;AACA;AACI;AACJ;A;AAEC;AACA;A;A;AAIC;A;AAEA;A;AAEA;A;A;A;A;AAMA;A;AAEA;A;A;AAGC;A;AAED;A;AAED;A;AAED;A;;;A;A;AAMC;A;AAEA;A;AAGA;A;AAEC;A;A;AAMA;A;AAED;A;A;AAGE;A;AAED;A;A;AAGA;A;AAED;A;AAID;A;;;A;AAQC;AACA;A;AAiBD;A;AAGC;A;AAMD;AACA;AACA;AAQI;AACA;A;AAEH;AACA;A;AAEA;AACA;A;AAED;AACA;AACA;AAKA;AAII;;;AACH;A;AAEC;A;AAED;AACA;A;AAEC;A;AAMD;AAIA;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AA/BoB;A;A;;;A;AA8CrB;A;AAID;A;AAEC;A;AAED;A;AAIC;AACA;AACA;A;AAEC;AACA;A;AAED;;AACC;AADgB;A;A;AAMlB;AACA;A;AAEC;A;A;AAGA;AACA;A;AAEA;A;AAED;A;AAKC;A;AAEA;A;AAEA;A;AAGD;A;;;A;AAOC;A;A;AAKA;AACA;AACA;;AACC;AADe;A;A;AAIhB;A;A;AAKA;AACI;;;AACH;AACG;A;AACF;A;AAED;AALqB;A;A;AASvB;A;;;A;AAOC;A;AAID;;AAGA;AAGA;A;AAEC;A;AAED;;AAEA;A;;;A;AAKC;A;AAED;A;;;A;AAKC;A;AAED;A;;;A;ACrbC;A;AAED;;AACA;A;;;;A;AAQC;A;AAED;;AACA;A;;;;AAKA;A;;;;A;AAOC;A;AAED;;AACA;A;;;;A;AAOC;A;AAED;;AACA;A;;;;A;AAMC;A;AAED;A;;;;;A;AA4BC;A;AAIG;AACJ;A;AAGC;A;A;A;AAYC;;AAIC;AACA;AACI;;;AACH;AACA;AACA;AACA;AACA;AALkB;A;AAUnB;AACA;AAEA;A;A;AAMF;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;AAEC;AACA;A;A;AAWD;AACA;AACA;AACA;;AACC;AACA;AACA;A;AAGD;AACA;A;AAGA;AACA;;AACC;AAIA;AACA;AACA;A;AAGD;AACA;A;A;AAKA;AACA;A;A;AAIA;AACA;A;AAED;AACA;A;;;AAIA;A;;;AC5LA;A;;;AAQA;AACI;;;AACH;AACA;A;AAEC;;;A;A;AAGA;AACA;AACA;AAT0B;;A;AAY3B;AAZ2B;;AAc5B;AACA;A;;;AAIA;A;AAEC;A;AAED;AACA;AACA;A;;;AAII;A;AAEH;AACA;AACA;A;A;A;AAIC;AACA;A;A;AAGD;AACA;AACA;A;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIC;AACA;AACA;A;AAEA;AAGA;AACI;;;AACH;AADoB;A;A;AADrB;AACI;;;AACH;AADoB;A;A;AAIrB;AACI;;;AACH;AADoB;A;A;A;AAKvB;A;;;AAQA;A;;;;AAMA;A;;;;AAOA;A;;;;AAMA;A;;;;AA0BA;A;;;;AAcA;A;;;;AAqBA;;AACC;;;AACA;A;A;AAGE;A;AAED;A;A;AAGA;A;A;AAGA;A;A;AAGF;A;;;;;;AAIA;A;A;;;;;A;A;;;;;A;A;;;;;A;AASA;A;;;;;;;A;AAoBC;AACA;A;AAEM;A;AAEN;AACA;A;AAEA;;;A;;;;;;;;;A;A;;;;;;;;;A;A;AAQA;AACA;A;AAED;AACA;AAEA;A;A;AAEC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEG;A;AAEH;AACA;A;AAEG;;;AACH;;;A;AAEC;AACA;A;AAED;AANkB;A;AAQnB;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;AACA;A;AAEA;A;AAEC;AACA;A;AAEG;;;AACH;A;AAEC;AACA;A;AAED;AANkB;A;AAQnB;A;AAEC;AACA;A;AAED;A;AAEA;A;A;AAGC;AACA;A;AAED;A;AAEA;AACA;A;A;AAED;AACA;A;;;;AASA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;A;AAIE;A;A;AAIA;AACI;;;A;AAEF;A;AAFsB;A;AAKxB;A;AAED;A;A;AAGA;A;A;AAGA;A;A;A;A;A;AAQE;A;A;AAGD;;;A;AAEC;A;A;A;AAKC;AACJ;AACA;;AACC;;;;;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAIA;A;A;AAGF;A;;;;AAKA;A;;;AAMA;;;;AACA;;AACC;A;AAEC;A;AAEA;A;A;AAGF;A;;;AAMA;;;;AACA;;AACC;A;AAEC;A;AAEA;A;A;AAGF;A;;;A;A;AAiBE;A;A;AAIA;A;AAED;A;A;AAUA;;;;;;AACA;A;AAEC;A;AAED;AACA;A;AAGD;;;;;;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;A;AAmBC;A;AAED;AACA;AACA;A;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;A;ACjbC;A;AAED;A;;;;;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxFA;AACA;A;;;;AAgDA;A;AAEC;A;AAEA;A;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;;;A;AAKC;A;A;AAGA;A;AAED;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;AACA;;;AACA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAII;AACJ;AACA;A;;;AAII;AACJ;AACA;A;;;AAIA;AACA;AAEA;A;;;AAIA;AACA;AACA;A;;;;A;AAKC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAED;AACA;A;;;;AAQA;AACA;AACA;A;;;;AAKA;AACA;AACA;AACA;A;;;;;A;AAKC;A;AAED;A;;;;;AAGkC;A;;;;;;;;AAGlC;AACA;AACA;;A;AACC;AACA;AACA;;A;AACC;AACA;A;AAED;A;AAED;;A;AACC;AACA;AACA;A;A;AAGA;A;AAED;A;;;;;;;AAKA;AACA;;A;AAEC;A;AAED;A;;;;;;;AAIA;AAEI;AACJ;AACA;;A;AACC;;A;;AAEA;;A;AAID;AACA;AACA;;A;AAGC;A;AAGG;AAEJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEC;A;AAGD;A;;;;;;AAKI;AACJ;AACA;;AACA;;A;;;;;ACtMI;AACJ;;;;;;;;;;;;;;;;AACA;;AAGK;;;AACH;AACA;AAFmB;A;AAIhB;;;AACH;AACA;AACA;AACA;AACA;AALoB;A;AAQrB;;;;;;;;;;;;;;;;AAEI;;;AACH;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAZmB;A;AAepB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAGD;;;;;;;;;;;;;;;;A;;;;;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;;;;;A;ACpHA;AACA;AACA;;AACC;AACA;A;AAEC;A;A;;;;;A;A;;;;;A;A;AAOA;A;AAEA;A;A;A;;;;;A;;;A;ACdD;A;AAED;A;;;;A;ACwCC;A;AAED;A;;;;AAgBA;;;;;A;AAEE;A;A;;AAGF;A;;;;A;AAiBC;A;AAED;A;;;;A;ACAC;;;;;AACC;A;AAEC;A;A;AAGA;A;A;;AAGF;A;AAID;AACA;AACA;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAEA;A;A;AAGF;A;;;A;AAMC;;;;;AACC;A;AAEC;A;A;AAGA;A;A;;AAGF;A;AAID;AACA;AACA;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAEA;A;A;AAGF;A;;;AAKA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;;;;AAIA;AACG;A;AACF;A;AAED;A;AAEC;A;AAED;A;;;AAqEA;;AACA;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;A;AAsEC;A;A;AAIA;A;AAID;AACA;AACA;;AACC;A;AAEC;A;AAEA;A;A;A;AAID;A;AAME;A;AACF;A;AAED;A;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AChWA;;A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;A;;;;;AAIA;A;;;A;AAKC;AAKA;AACA;AAEA;A;AAEC;A;AAEC;A;AAEG;AACA;;;AACH;AACA;A;AAFmC;A;A;AAMnC;AANmC;A;AAWpC;AACI;;;AACH;AACA;A;AAFmC;A;A;AAMnC;AANmC;A;AAWpC;AAMA;AACA;A;A;A;AAKA;A;AAKA;A;AAEC;A;A;AAGA;A;AAED;A;AAKA;AACA;AACA;;;;;AACC;A;;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;AAEC;A;AAED;A;AAQA;AACA;AACA;;;;;AACC;AACA;A;;AAKD;A;AAMA;A;AAKA;A;AAIA;A;AAIA;AACA;AACA;;;;;AACC;AACA;A;AAEC;A;AAED;A;;AAMD;A;A;AAQF;A;;;AAIA;AACA;A;;;;AAaA;A;;;;;AAIA;A;;;;;AAMA;A;;;;;AAaA;A;;;;;AAIA;A;;;;;;A;;A;;;;;;A;;A;;;;;AAiBiC;A;;;;;AACA;A;;;;AAGjC;AACA;AAKA;A;;;;AAQA;A;;;;AAIA;AACA;AACA;A;;;;AAMA;A;;;;AAIA;AACA;AACA;A;;;AAII;AACJ;AACA;A;;;AAIA;A;;;AAIA;AACI;;;AACH;AACA;AAFgC;A;A;;;;AAOjC;;AACA;;;;;;;;;A;AACC;;A;AAED;;A;;;;;;AAIA;;;A;AACC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;AAGD;;;AAAgH;;;A;;;A;;;;;A;AAK/G;A;A;AAGA;A;AAED;A;;;;;A;AAKC;A;AAED;;A;;;;;;AAYA;;;;;;;A;AACC;A;AAGD;AACA;;;;;;AACC;A;;AAED;AACA;;;;;;AACC;A;;AAED;A;;;;;;AAaA;A;;;;AAIA;A;;;;;AA2CA;;A;;;;;A;A;AAMC;A;AAEA;A;AAEA;A;A;;;;AAKD;;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAoCA;A;;;AAiBA;A;AAEC;A;AAED;AACA;A;;;AAIA;;AACA;A;AAEC;A;AAED;A;;;;AAIA;;;AACA;AACA;AACA;;;A;AACC;AACA;AACA;A;AAED;AACA;AACA;AACA;A;;;;;AAIA;;AACA;A;;;;AAgBA;;AACC;A;AAEC;A;AAGD;A;A;;;;AAKD;A;;;;AAIA;AACI;A;AAEH;A;AAEA;A;AAEC;A;AAED;AACA;AAGA;A;AAED;;;;A;;;;;AAIA;AACI;A;AAEH;A;AAEA;A;AAEC;A;AAED;AACA;AACA;A;AAED;;;;A;;;;AAIA;AACA;AACA;A;;;AAIA;A;;;;AAII;AACJ;;A;AACC;;A;AAGG;AACG;;A;AACP;;;;;A;AACC;AACA;AACA;AACA;AACA;A;A;AAEA;;;;A;AACC;;;A;AACC;AACA;A;AAED;AACA;;;;;AACA;A;AAED;A;A;AAEA;AACA;A;A;AAEA;A;;AAEA;A;A;AAED;;;A;;;;;;;AA4CI;A;AAEH;A;AAEC;A;AAED;A;AAEC;A;AAED;AACA;A;AAEA;A;AAEC;A;AAED;A;AAEC;A;AAED;AACA;A;AAED;A;AAEC;A;AAED;AACA;A;;;;A;AAKC;A;A;AAGA;A;AAED;;A;AACC;;A;A;AAIA;A;AAED;A;;;;AAIA;A;;AAIA;A;;;;;;A;AAKC;A;AAGD;;AACA;A;AAEC;A;AAED;;AACC;A;AAED;;A;;;;;A;A;AAMC;A;AAEA;A;A;;;;;;A;AAMD;;;;A;AACC;A;AAEA;;A;AAEI;;;AACH;;;A;AACC;A;AAF4B;A;A;A;AAM/B;A;;;;;;;;;A;AAKC;A;;A;AAGD;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACC;A;;AAED;AACA;;;;;AACC;A;;AAED;;AACA;AACA;AACA;;AACC;AACA;A;AAED;AAEA;A;;A;;;;;;A;AAMC;A;A;AAGA;A;AAEC;A;A;AAEC;A;AAEA;A;A;AAGC;AACA;A;AAED;AACA;AACA;AACA;AACA;A;A;A;AAGF;A;AAED;A;;;;;;AAIA;;A;AACC;;A;AAID;;;;A;AAGC;AACA;AACA;A;A;AAIC;A;AAKD;;A;AAEC;A;AAEA;A;AAED;A;A;AAID;A;;;;;;;;AAOC;AACA;AACA;A;AAGA;;;AACA;A;AAEC;A;A;AAGD;AACA;AACA;A;A;AAIA;A;AAGD;AACA;A;A;AAGE;A;A;AAGA;A;A;AAGA;A;A;A;AAIA;A;A;AAGA;A;A;AAGA;A;A;AAGF;;;;;A;AAEE;A;A;;AAGE;;;AACA;;;;AAAH;;;A;AACC;;;A;AAFiB;A;AAKnB;;A;AAEC;AACA;;AACA;;AACI;;;AACH;AACG;AAAH;;;A;AACC;;;A;AAED;;AALkB;A;AAOnB;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAED;AAEA;AACA;;;;;;AACC;;;;;;;;;A;;AAED;;A;AAGA;;;A;AACC;A;AAEA;;A;AAEA;AACA;;;;;AACC;;A;;AAED;A;A;A;;;;;;;AAKD;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAOC;A;AAED;A;;;A;AAKC;A;AAED;A;;;;;AAIO;A;AACP;;;A;AACC;A;AAEC;A;AAED;AACA;;A;A;AAIC;A;AAED;AACA;AACA;AACA;AACA;A;AAGA;A;A;A;;;;;;;;;;;;A;AAMA;A;AAED;A;AAEC;A;AAGD;AACA;AACA;AAEA;A;A;AAGE;A;AAEA;A;A;AAIC;AAAH;;A;AACI;AAAH;;A;AACC;;AACC;;AACA;;A;AACC;AACA;AACuC;A;;AACC;A;A;AAGzC;;A;AACC;;A;A;A;A;AAMJ;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;;;;;AAIA;;AAEC;AACA;;AACC;A;AAED;A;AAEC;A;AAKD;AACA;;AACC;A;A;AAGA;A;AAED;AACA;AAGA;AACA;;A;AAEE;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;;AACA;A;A;AAGF;A;;;;;;;;;;;AAIO;A;AACP;;;;A;AACC;A;AAEC;A;AAED;AACA;AAEA;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;AAGA;A;AAEC;A;AAED;AACA;AACA;AAEA;AACA;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;AAGA;A;AAEC;A;AAED;AACA;AACA;A;AAGA;A;A;A;;;;;;;AAKD;A;;;;;AAIO;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;;AAKM;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;;AAKM;A;A;A;AAGL;A;AAED;A;A;AAGC;A;AAED;A;A;AAGC;A;AAED;A;AAEA;A;A;;;;;;AAKD;AACA;AACA;;AACA;;A;A;AAEC;;;;A;AACC;A;A;AAEA;;A;A;AAEA;A;;AAEA;A;A;AAED;A;AAED;A;;;;;;;;AAIA;AACA;AACA;;;A;AACC;A;AAED;AACA;;;;;A;AACC;AACA;AACA;AACA;AACA;A;AAED;A;;;;;;;AAIA;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;;;AAKC;AACA;AACA;AAEM;A;AACP;;;;A;A;AAEE;A;AAED;AACA;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;AAGA;A;AAEC;A;AAED;;A;AAGA;A;A;A;AAIA;A;AAGD;;A;;;;;;;AAKC;AACA;AACA;AAEM;A;A;A;AAGL;A;AAED;AACA;AACA;AACA;A;AAGA;AACA;AACA;A;AAGA;A;A;AAIA;A;AAGD;;A;;;;;;AAIA;AACA;AACA;A;;;;;;;AAMA;A;AAEC;A;AAED;;A;A;;;;;A;AAIA;AACA;A;;;;;A;;;;;AAKA;A;AAEC;A;AAED;;A;AAEC;A;AAED;A;;;;;;;;ACv4CA;;A;AAEC;A;AAGD;A;A;AAGC;;AAAwB;A;A;AAExB;;A;AAEE;A;A;A;AAIH;AACA;AACA;;A;AAEE;A;AAED;AACA;AACA;AACA;AACA;A;A;;;;;;ACwYD;A;;;;;AAIA;A;;;;;A;AAsKC;A;AAED;A;;;;;AAiKA;A;AAEC;A;AAED;A;;;;;AAGgC;A;;;;;A;AAI/B;A;AAED;A;AAEC;A;AAED;A;;;;;AAG6B;A;;;;;AAEK;A;;;;;AAEL;A;;;;;AAII;A;;;;;AAGjC;A;AAEC;A;AAED;A;;;;;A;AAKC;AACA;A;AAED;A;;;;;;;;A;AAuCC;A;;;;A;AAGD;A;A;;;;;A;AAKA;;;;;;AACC;;A;A;;;;;;A;A;;A;;;;;A;;;;;;A;AASA;A;AAED;A;AAEC;A;AAED;A;;;;;A;AASC;A;AAED;AACA;AACA;;A;AAEE;A;AAED;A;AAED;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAED;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;A;AAwCC;A;AAEA;A;AAEA;A;AAED;A;;;;;;A;AAMC;A;AAED;AACA;AACA;A;AAEC;A;AAEC;A;A;AAGF;AACA;AACA;A;;;;;AAIyC;A;;;;;;;A;AAKxC;A;AAEG;AACJ;;;;;AACC;A;A;;;;;A;A;;AAKD;A;;;;;AAmCA;;AACA;A;;;;;;;AAaA;;AAEC;AACA;;AACC;A;AAED;A;AAEC;A;AAOD;AACA;;AACC;A;A;AAGA;A;AAED;AACA;AAGA;AACA;;A;AAEE;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;;;A;AAEC;A;A;;;;;A;A;A;;;;;A;;;;;;A;AAWF;A;AAED;AACA;AACA;AACA;A;AAEC;A;AAEE;A;AACF;A;AAED;AASA;AACA;A;;;;;;;AAQA;AACA;;;;;;AACC;;A;AACC;AACA;;;;;;;A;AACC;;A;AAED;A;AAED;;A;;AAED;A;;;;;;;;;AAoBA;AACA;AAQI;AAOJ;AAEA;;AACC;;;;AACA;AACA;AAMA;;;;;AACC;AACA;;A;AAIC;;A;AAED;AACA;;;;;AACC;AAEA;AACI;AACJ;;A;AAEC;AACA;;A;AACC;;A;A;AAKF;;;A;A;A;;;;;A;AAMC;AACA;AACA;AACA;AACA;AACA;;A;A;AAOA;;A;AAED;A;AAEC;AACA;;A;A;AAGA;A;AAED;A;AAEC;A;AAEG;AACJ;AACA;AACA;A;;A;;A;AAID;A;A;AAGF;A;;;;;;;;;;AAOA;A;AAEC;;;;;AACC;A;A;;;;;A;A;AAKC;A;A;;A;A;AAKF;A;A;;AAE8C;A;;;;;A;;;;;AAgB/C;A;;;;;;A;AAwDC;A;AAED;;;A;AACC;A;AAED;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;A;AAUC;A;AAED;A;AAEC;A;A;AAgBA;AACA;AACI;;;AACH;AACA;AACA;AACA;A;A;AAGE;A;AAEC;A;AAED;A;AAEC;A;A;AAb4B;A;A;A;AAmB3B;A;AACF;A;A;AApB6B;A;AAwBhC;A;AAGD;A;AAEC;A;AAED;AACA;AACI;;;AACH;AACA;AACA;AACA;A;A;AAGE;A;AAEC;A;AAED;A;AAEC;A;A;AAb2B;A;A;A;AAmB1B;A;AACF;A;A;AApB4B;A;AAwB/B;A;;;;A;AAWC;A;A;AAMA;A;AAID;;A;;;;;A;AAKC;A;AAGD;;;;;;;;A;AACC;A;AAGD;;;;;;A;;;;;A;AAKC;A;AAGD;A;AAEC;A;A;AAMA;A;A;AAKD;;;;;;;;A;AACC;;;;A;AAMA;;;;;A;AACC;A;AAID;;;;A;AAGA;AACA;A;AAEC;A;AAEG;;;AACH;;;A;AACC;A;AAFyB;A;AAKvB;;;AACH;;;A;AACC;A;AAF0B;A;AAK5B;A;AAGA;AACA;A;AAEC;A;AAID;A;AAGA;;;;;A;AAGA;;A;AAGA;AACA;A;AAEC;A;A;AAGA;A;AAED;;;;;AACC;AACA;A;AAEC;A;AAED;;;A;AACC;A;A;AAGA;A;A;AAGA;A;A;;AAGF;A;A;AAGD;A;;;;A;AA4yCC;A;AAED;A;;;AA6GA;A;;;;AC59FA;A;;;;;A;AAKC;A;AAED;A;;;;;A;AAOC;A;A;AAGA;A;AAED;A;;;;;A;AAiEC;A;AAED;A;;;;;A;AAyCC;A;A;;;;;A;AAQA;A;A;AAGA;A;A;;;;;A;AASA;A;A;AAIA;A;A;AAGA;A;A;;;;;A;AAWA;A;AAED;A;;;;;AAMA;AACA;A;;;;;;AAMA;AACA;;;A;AACC;A;AAGD;A;;;;;;;AAMA;AACA;;;A;AACC;A;AAGD;A;;;;;;AASA;A;;;;;AASA;A;;;;;;AAYA;AACA;AACA;;A;;;;;;;AAWA;AACA;AACA;;A;;;;;;AAubA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;;AA6EA;;A;AACC;;A;AAED;AACA;;;;;;AACC;;A;AACC;;;;;A;A;AAEE;A;AAED;;A;A;AAGF;;A;;AAED;A;;;;;;;AAOA;AACG;;;;AAAH;;A;AACC;;A;AAED;A;;;;;;;AAQG;;;;AAAH;;A;AACC;;A;AAED;A;;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAsDA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;A;AAMC;A;AAED;A;;;;;;;A;;;A;;;;;;AAwFA;A;;;;;AAMA;A;;;;;;AA8BA;AACA;AASA;;AAEI;A;AAEH;A;AAEA;A;AAED;A;AAEC;A;AAED;AACA;AACA;AACA;A;;;;;;;AAQA;AACA;AACA;AAEA;AAEA;AACA;A;AAEC;A;AAED;AACA;AACI;AACA;;;AACH;;A;AAKC;A;AAED;AACA;AATsB;A;AAWvB;A;;;;;;;A;AAaC;A;AAED;;;A;AACC;A;AAGD;AACA;AACA;;;;;;A;;;;;;;A;AAMC;A;AAED;;;A;AACC;A;AAGD;AACA;AACA;;;;;;A;;;;;;;AAOA;;A;AACC;A;;AAEA;;;A;AACC;A;AAED;A;AAED;;A;;;;;;AAoBA;AACA;A;;;;A;AASC;AACA;AACA;A;AAED;A;;;;A;AASC;A;A;AAGA;A;A;AAGA;A;AAED;AACA;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAED;A;;;;;;A;AAUC;A;A;AAGA;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;AAMA;AACA;AACA;A;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;AAMA;A;A;AAGC;AACA;AACA;A;AAED;A;;;;;AAMA;A;A;AAGC;AACA;AACA;A;AAED;A;;;;;;;;AAsDA;AACA;A;;;;;A;;;;;;;;;AAOA;A;AAEC;A;AAED;AACA;AACI;A;AAEH;AACA;AACA;A;AAEA;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;AAOA;AACA;AACA;;A;;;;;;;;;AAMA;A;AAEC;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;A;;;A;;;;;;AA0BD;AACA;AACA;A;;;;;;AAiBA;AACA;AACA;;;A;AACC;A;AAED;A;;;;;;;AAMA;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;;AAWD;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;;AAWD;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAVA;A;A;;;;;;AA+CD;AACA;AACA;AACA;AACA;;AACI;A;AAEH;A;AAEA;A;A;AAGA;AACA;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;AAED;A;;;;;;;AAMA;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAZA;A;A;;;;;AAmBD;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;;AA4HO;A;A;AAEN;A;AAEA;A;AAID;;A;;;;;;;;;AASA;AACA;A;;;;;A;;;;;;;AASA;AACA;AACA;;A;;;;;;AAKA;A;AAEC;A;A;AAIA;A;AAKD;A;AAGC;A;AAEC;A;AAED;AACA;A;AAGD;A;AAEC;A;AAED;AACA;A;;;;;AAMA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;A;AASC;A;A;AAGA;A;AAED;A;;;;A;AA6ZC;A;AAED;AACA;AACA;AACA;A;;;;;;AAsDA;;A;AACC;;A;AAED;;;AACA;;A;AACC;;A;AAED;;A;;;;;;A;AAOA;;;;;;;A;A;A;AAGE;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;A;A;AAID;;;;;A;A;;A;AAGE;A;AAEA;A;A;A;A;A;AAKF;;;;;A;A;;A;AAGE;A;AAEA;A;A;A;A;A;AAMH;;;A;AACC;A;AAID;;;;;;;;;A;AAGC;A;A;A;AAKC;A;AAED;A;AAGD;A;;;;;AAwBA;;AACA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAMA;;AACA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAUA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAoBA;;;AACA;;AACA;;;A;AACC;A;;AAEA;A;AAED;;A;;;;;AAKA;;A;AACC;;AACA;AACA;A;AAED;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;ACz/EA;;;;AACA;;AACC;AAEA;;;A;AACC;A;;AAEA;A;A;AAIF;A;;;;;;;;AAWA;;AAAyC;A;;A;;;;;;;AAsBJ;;A;;;;;;ACxFrC;;AACA;;AACA;AACA;A;;;;;;;ACKI;;;AACC;;;;;;AACH;AADuC;A;AADlB;A;A;;;;;;AAUvB;AACA;AACC;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;;A;AACC;A;AAED;AACA;A;A;;;;;;AAKD;AACA;AACA;AAGI;;;AACH;AAD8B;A;AAK3B;;;AACH;AACA;AAFwB;A;A;;;;;;AAYzB;;;A;AACC;A;AAGD;;;A;AACC;AAEA;;;A;AACC;A;A;A;;;;;;AAOE;;;AACH;AADkB;A;A;;;;;;;;AAMnB;AACA;;A;AAEC;AACA;AACA;AACA;A;AAED;AASA;AACA;;;;AAEA;;;;;AAAoC;A;AAEpC;AACA;AACC;;;;;AAAqC;A;AAErC;;;;;AAAsC;A;A;AAGrC;A;AAGD;AACA;AACA;A;AAID;AACA;;A;AAEC;AACA;;;A;AACC;AACA;AACA;A;AAED;;;A;AACC;AACA;A;AAKD;;;A;AACC;AACA;AACA;A;AAGD;A;AAED;;A;AAKC;AACC;;;;;AAAuC;A;AAEvC;;;;;AAAoC;A;A;AAGnC;A;AAGD;AACA;AACA;A;A;AAIF;A;;;;;A;;;;;AAKA;;AACC;;A;AACC;AACA;A;AAED;AACA;;;;AAGA;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAGF;;A;AAGK;;;AACH;;;A;AACC;A;AAFqB;A;AAKvB;A;A;;;;;;AAQD;;AACA;A;;;;;;AAMI;AACA;;;AACH;AADkB;A;AAGnB;A;;;;AA2CuC;A;;;;;AACA;A;;;;;AACA;;;;A;;;;;;AAGb;A;;;;;;;AA+BN;A;;;;;;;AAkDpB;;;;A;;;;;;;AAIA;AACA;;;;AACA;;AACC;AACA;AACA;A;AAED;AAEA;;AACC;;;;AACA;;AACC;AACA;AACA;A;AAEE;AAAH;;A;AACC;A;AAED;A;A;;;;;;AA2BD;;A;AAIC;AACA;AACA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIE;;;AACH;AADoB;A;AAGrB;A;AAMD;;A;AAIC;AACA;AACA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIE;;;AACH;AADkB;A;AAGnB;A;AAGD;AACA;AACI;;;;A;AAEH;AACA;A;AAEA;AACA;A;AAED;AAEA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIF;AACA;;A;AACC;A;AAED;;A;AACC;A;AAED;;A;AACC;A;A;;;;;;AASD;AACA;AAEA;;AACC;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAIF;A;;;;;;AC5eI;;;AACC;;;;;;AACH;AADuC;A;AADlB;A;A;;;;;;AASvB;AACA;AACC;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;;A;AACC;A;AAED;AACA;A;A;;;;;;AAMD;AACA;AACA;AACI;;;AACH;AAD8B;A;AAG3B;;;AACH;AACA;AAFwB;A;A;;;;;;AAQzB;;;A;AACC;A;AAED;;;A;AACC;AACA;;;A;AACC;A;A;A;;;;;;;;AAcF;AACA;;A;AACC;AACA;AACA;AACA;A;AAED;AACA;AACA;;;;AACA;;;;;AAAoC;A;AAEpC;AACA;AACC;;;;;AAAqC;A;AAErC;;;;;AAAsC;A;A;AAGrC;A;AAED;AACA;AACA;A;AAED;AACA;;A;AACC;AACA;;;A;AACC;AACA;AACA;A;AAED;;;A;AACC;AACA;A;AAED;;;A;AACC;AACA;AACA;A;AAED;A;AAED;;A;AACC;AACC;;;;;AAAuC;A;AAEvC;;;;;AAAoC;A;A;AAGnC;A;AAED;AACA;AACA;A;A;AAGF;A;;;;;A;;;;;AAMA;;AACC;;A;AACC;AACA;A;AAED;AACA;;;;AACA;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAGF;;A;AACK;;;AACH;;;A;AACC;A;AAFqB;A;AAKvB;A;A;;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;ACpIwC;A;;;;;;AACA;;A;;;;;;AAEzC;;;;AACA;;;;A;;;;;AAuBA;;;A;AACC;A;AAED;AACA;AACA;AACI;;;;AACH;;AACA;;AAFwB;A;AAIzB;AAIA;AACA;A;;;;;;AAQA;;;;A;AAEC;A;A;AAGD;;;;;;;;;;;;A;AACC;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;A;AAEA;;;;AACG;A;AACF;A;AAED;A;AAEA;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGE;;;A;AACF;A;AAED;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGG;;;AACA;;;;;;A;AACF;A;AAF+B;A;AAKjC;A;AAEI;;;AACA;;;;;;A;AACF;A;AAF0B;A;AAK5B;A;AAEG;;;A;AACF;A;AAED;;;;;;;;;;A;AAEC;A;AAED;;;;;;A;AAGA;;A;A;A;;;;;A;A;AAYC;A;AAED;A;A;AAGA;A;AAED;A;;;A;AAOC;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;AAIA;A;;;;;;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxMA;A;AAEE;AACA;A;A;A;;A;AAOD;A;AAED;A;;;AAIA;A;AAEC;AACA;A;AAGD;AACA;AACC;A;AAEC;A;AAED;AACA;A;A;;;AASD;A;;;;AAKA;;;;;;A;AAEE;A;A;;AAGF;A;;;AClDA;A;AAEC;A;AAED;AACA;AACA;AACI;;;AACH;AACA;AAFiC;A;AAIlC;A;;;;AAwBA;AACC;A;A;A;AAKC;A;AAED;AACA;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIG;A;AACF;A;;;;;;;A;A;AAIA;AACA;AACA;AACA;A;;;;;;;A;A;AAIA;A;AAED;A;;;;;;;A;;;;;;;AAKG;A;AACF;A;;;;;;;A;A;AAIA;A;A;;;;;;;A;;;;AAiCD;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;AACA;A;;;;;;A;A;;;;;A;A;A;;;;;A;A;;;;;A;;;A;A;AC3GC;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAGA;A;A;;;A;A;AAOA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAGA;A;A;;;;;;AASD;AACA;AACA;;AACC;;;A;A;;;;;;;A;AAIA;AACA;AACA;;;A;AAEC;A;A;AAGA;A;AAGD;;;A;AAEC;A;AAED;AACA;;;;;;A;AAEE;AACA;A;A;;A;AAKD;A;AAED;AACA;AACA;A;A;;;;;;;A;;;;ACHyB;A;;;;;AAG1B;;;A;A;;A;A;AAKC;A;AAEA;A;AAED;;A;;A;;;;A;;;A;;;A;ACnGC;A;AAED;A;;;AAII;AACJ;AACA;;AACC;AACA;AACA;A;AAED;AACA;A;;;;;;A;;;;;A;;;;;ACuEA;A;;;;;A;ACoQC;A;AAED;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;A;AAKC;A;AAED;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;AAIA;AACA;A;AAEC;A;A;AAGA;A;AAED;AACI;;;AACH;AADkB;A;AAInB;A;AAEC;A;A;AAGA;AAEA;A;AAGD;;A;;;;;A;AAeC;A;AAED;AACA;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;AAYA;AACA;AACA;AACA;AACA;;A;;;;A;A;AAMC;;;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAGA;;;AACA;A;AAOC;A;AAQD;AACA;;AACC;A;AAED;AACA;AACA;A;AAGA;;;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAGA;;;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAED;A;;;;;;AAII;AACA;AACJ;;;A;AAEC;A;AAED;;;A;AAEC;AACA;A;AAED;A;;;;;;;AAII;AACA;AACJ;;;A;AAEC;A;A;AAGA;A;AAED;;;A;AAEC;AACA;A;AAED;A;;;;;A;;;;A;;;;;;;;;AAiEI;AACA;AACJ;;;AACA;AACI;A;AAEH;AACA;A;AAEG;A;A;AAGE;AACJ;;;A;AAEC;A;A;AAIA;AACA;A;A;AAGF;AACA;A;AAED;AACA;AACG;;;A;AACF;A;AAED;AACA;A;AAGC;;;A;AAED;A;;;;;;;;;;AASI;AACA;AACJ;;A;AACK;AACJ;;;;;A;A;;;;;A;A;AAKG;AACJ;AACA;AACI;A;AAEH;AACA;A;AAEG;A;A;AAGE;AACJ;;;A;A;;;;;A;A;AAMC;AACA;A;A;AAGF;AACA;A;AAED;AACA;AACG;;;A;A;;;;;A;A;AAIF;A;A;;;;;A;;;;;;;A;;;;A;;;;AAmKD;A;;;AAIA;A;;;AAIA;;;A;AAEC;A;AAED;A;;;;A;;A;;;;;ACtuBA;A;;;;;AAIA;A;;;;;;;;;A;A;;;;;A;AClFA;;;;A;A;;;;;A;AAMI;AAOJ;AAGA;AACA;AACA;AACA;A;;;;;A;;;;;;;;A;A;;A;AAUA;AACA;AACA;AACA;A;A;;A;AAMG;;A;A;;A;AAGH;A;;A;;;;;;A;AAeC;A;AAEC;A;A;AAGF;A;;;;;AAIA;A;;;;;AAIA;A;;;;A;A;AAgBC;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAoBA;;;A;A;AAGE;A;A;AAGA;A;A;A;AAID;A;AAED;A;;;;;;A;AAKC;A;AAED;;;A;AAEC;A;A;AAGA;A;AAED;A;;;;;;AAuDI;AACJ;AACA;A;;;;;A;;;;;;;AAKI;AACA;AACD;;;A;AACF;A;A;AAGA;;;A;AAED;A;;;;;;AAIA;;;;;A;A;;A;A;;A;;;;;;A;;A;;;;;AAYI;A;;A;;;;;A;;A;;;;;A;;;;A;;;;;A;;;;A;;;;;A;;;;A;;;;;AC0BJ;;A;AAEC;A;AAED;A;;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;AA0DA;;A;AAEC;A;AAED;A;;;;;AAMA;;A;AAEC;A;AAED;A;;;;;;AAqBA;;;AACA;A;AAEC;A;AAED;A;;;;AA0BA;;A;AAEC;A;AAED;A;;;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAgQI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;AAsQI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;AAsCA;;A;AAEC;A;AAED;A;;;;AAoGA;;A;AAEC;A;AAED;A;;;;;AAMA;;;;A;AAEC;A;AAED;A;;;;;AAgBA;;A;AAEC;A;AAED;A;;;;;;AAyFI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;AAkGA;;A;AAEC;A;AAED;A;;;;;;AAyDA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;AA0BI;AACJ;;;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;AA2BA;;A;AAEC;A;AAED;A;;;;AAMA;;A;AAEC;A;AAED;A;;;;;AA+CI;A;AAEH;A;AAEA;A;AAED;;;;;AACA;A;AAEC;A;AAED;A;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvnDA;;;A;;;;;A;;;;;A;AAOC;A;AAED;A;;;;;;;AAOG;;;A;A;;;;;A;A;AAIF;A;AAED;A;;;;;A;;;;;A;AAOC;A;AAED;A;;;;;;AAcA;;;;;;A;A;;A;;;AACC;;;A;AACC;A;A;;A;;;;;;;A;ACrDD;A;AAED;A;;;;;A;AAMC;A;AAED;A;;;;;AAgDA;A;AAEC;A;A;;;;;AAMD;A;;;;;A;AAMC;A;A;;;;;;;A;ACvDA;A;A;AAGA;A;AAED;AACA;AACC;AACA;A;AAED;A;;;;;;;;ACQA;;A;AACC;;A;AACC;;A;AAED;A;AAED;AACA;AACA;A;;;;;;A;AAMC;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/CI;A;;;AAcJ;AACA;AACA;AACA;A;AAEC;AACA;A;AAED;AACA;A;;AAIA;A;;;;;;AAIA;A;;;;;;;A;;;AA6CA;A;;;A;AC8CC;A;AAED;AACA;A;;;;;;AAMI;;;AACI;A;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;;;;;;;A;A;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;AA2GL;AACA;AACA;;AACC;A;A;AAIA;A;AAEC;A;AAED;A;;;;;;;A;A;A;AAvHyB;A;A;;;;;;;A;;;AAqLzB;;;AACH;AACA;A;AAGC;AACA;A;AAEC;A;A;AARsB;A;AAYzB;A;;;AAIA;;;;;;A;AAEE;A;A;;AAGF;A;;;AAOA;A;AAEC;AACA;A;AAIG;AACJ;AACA;;AACC;AACA;AACA;AACA;A;AAED;AACA;AAGI;;;AACH;AADiC;A;AAIlC;A;;;;;AAQA;A;AAEC;AACA;A;AAED;;;;AACA;A;A;;;;;A;A;AAKC;A;A;;;;;A;;;AAQD;AACI;AACA;;;AACH;AACA;AACA;A;A;AAIA;A;A;AAGA;;AACC;A;A;AAGA;A;A;AAGF;AACA;A;;;;;AAcA;;A;AAIC;AACA;A;AAEC;AACA;A;AAED;;;;AACA;;;;AACI;AACJ;AACA;AACA;A;AAEC;AACA;A;AAED;AACA;AACA;AACA;A;AAED;A;;;;;;;AAqBI;AACJ;A;AAEK;AACJ;A;AAEA;A;AAED;;AACA;A;;;;;;;AAOC;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AAGD;;AACC;;;;A;AAEC;A;A;AAGA;A;AAED;A;AAIC;;;;A;A;AAKA;;;;A;AAGD;A;A;AAEC;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEA;A;A;AAGC;A;AAED;A;AAEA;A;AAEA;A;AAGA;A;AAEC;A;AAED;A;AAGA;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;A;A;AAIA;A;AAEA;A;A;A;AAMA;AACA;A;AAED;AACA;A;AAEC;AACA;AACA;A;AAEA;A;AAED;A;AAEC;A;A;AAGA;A;A;A;AAMC;A;AAED;A;A;A;AAKA;AACA;A;AAID;A;AAEC;AACA;A;AAEA;A;AAED;AACA;A;AAEA;A;A;A;AAGF;A;;;;;AAeA;A;;;;A;AAMC;A;AAMD;A;;;;A;AAOC;A;AAED;AACA;A;;;A;AAQC;A;A;A;AAIC;A;AAED;A;AAED;A;;;AAIA;;AACC;A;AAED;A;;;AAMA;;A;A;AAGG;A;AAED;AACA;AACA;A;A;AAGA;A;AAED;AACA;A;AAED;A;;;;AA0CA;;A;;;;;;AAaA;;;;AACA;AACA;AACA;AAIC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAID;AACK;AACJ;;;;AACA;AACA;;;A;AAEC;A;A;A;AAIC;A;AAED;A;AAED;AACI;AACJ;A;A;A;AAGE;AACA;A;AAED;;;;AACA;;;A;AAEC;A;AAEA;A;A;A;AAIA;AACA;A;AAED;;;;AACA;;;A;AAEA;;;;AACA;A;AAEA;;;;AACA;A;AAEA;;;;A;AAEC;A;A;AAID;;;A;AAEA;;;A;A;AAGC;A;AAED;;;;A;AAGC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;AACA;A;A;AAKA;;AACA;A;AAGC;A;AAGD;AACA;;AAA2C;A;AAE3C;;;;AACA;A;A;A;AAIA;AACA;A;AAED;;;;A;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAIA;AACA;A;AAED;;;;A;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAIA;AACA;AACA;A;AAEG;;;;;;;;A;A;AAGF;AACA;A;A;AAGA;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;AAEG;;;;;;AACJ;;;A;AAEC;;;A;A;AAGA;;;A;AAED;A;A;A;AAIC;A;AAEA;A;A;A;AAKA;AACA;AACA;A;AAED;;;A;AAEC;AACA;A;AAED;;;;A;AAKA;A;AAEC;AACA;A;AAED;;;;AACA;A;A;AAKC;A;AAID;AACA;;AACC;A;AAED;;;;AACA;A;A;A;AAGA;A;A;AAGA;A;A;A;AAID;A;AAEA;A;A;AAKA;A;AAGD;;A;AACC;;A;AAGD;;A;AACC;;AACA;AAIA;;;;A;AAEC;AACA;A;AAID;AACA;A;AAGD;;A;AACC;;AAGA;;;;A;AAEC;AACA;AACA;A;A;AAKA;;AACA;A;AAED;AACA;A;AAID;;A;;;;;;A;A;;;;;A;A;A;;;;;A;A;AAuBC;A;;;;;A;A;AAKA;AACA;A;;;;;A;AAIG;AACA;;;A;AAEF;A;AAEE;A;AACF;A;AAL0B;A;A;A;A;;;;;A;A;A;;;;;A;A;A;A;;;;;A;A;A;;;;;A;A;;;;;A;;;AA8B5B;A;AAEC;A;AAGD;A;;;AAOA;A;AAEC;A;AAED;;;;A;AAIC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;;;A;AAKC;AACA;A;AAEE;;;A;AACF;A;A;AAGA;AACA;A;AAKD;AACI;;;AACH;AAD4B;A;AAG7B;A;;;;;;AAOA;AACA;;AACC;A;AAEC;A;A;A;;;;;;;A;AAMD;A;A;;;;;;;A;AATiB;A;A;;;;;;;A;;;;AC5hClB;A;;;;;A;AAMC;A;AAED;A;;;;;AAIgC;A;;;;;A;AAK/B;AACA;A;AAEC;AACA;A;AAID;A;AAID;A;;;;;A;AAMC;A;AAED;AACA;A;;;;;A;AAMC;AACA;A;A;;;;;A;AAkCA;A;AAED;AACA;AACA;A;;;;;A;AAMC;A;AAED;A;;;;;A;AAUC;A;AAED;A;;;;;A;AAuCC;A;AAED;AACA;AACA;A;;;;;A;AA6BC;A;AAED;AACA;AACA;A;;;;;AA2GA;A;;;;;;AAMA;AAEA;;A;AACC;;A;AAED;AACA;;A;AACC;;A;AACC;A;;AAEA;;;AACA;A;A;AAGF;A;;;;;;;;;;AAMA;AACA;;A;AACC;;A;AAGD;AACA;;A;AACC;;A;AACC;AACA;A;;AAEA;;;;A;AAED;A;;AAEA;A;AAED;AACA;A;;;;;;;;;;AAKA;;;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;A;;;;;AAMA;AACA;A;;;;;;;AAQA;;;;;;AACA;;AAgBA;AAMA;A;AAEC;A;A;AAMA;AACA;A;AAKC;A;A;A;AAQE;A;AACF;AACA;A;A;AAIF;A;;;;;;;;;;A;;;;;;;A;;;;;;;;AAUA;AACA;AACA;AACA;AACA;AACA;A;;;;;AAKA;;A;;;;;;;AAKA;;A;;;;;;;AAKA;;A;;;;;;AAMA;A;;;;;;AAMA;;;AACA;A;;;;;;AAuCI;AACJ;AAEA;AACA;A;AAEC;A;A;AAMI;AACJ;AACA;AACA;A;AAGC;A;AAGA;AACA;A;AAGA;AAEA;AACA;A;AAGA;AACA;A;AAED;;;AACA;A;AAEA;AACA;AAEA;;;AAGA;AACA;A;AAIC;AACA;AACA;AACA;A;AAKC;AACA;AACA;A;A;A;A;AAMF;AACA;A;AAGD;A;;;;;;AASA;AACA;AACI;;;AACH;AACA;A;AAEC;AACA;A;AAED;AAPqB;A;A;AAUrB;AACA;A;A;;;;;A;;;AAQD;A;AAEC;AACA;A;AAEA;;AACC;AACA;AACA;A;A;AAGF;A;;;;AAIuC;A;;;;;AAavC;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAOC;A;AAED;A;;;;AAMA;A;;;;A;AAWC;A;AAED;A;AAEC;A;AAEC;A;AAEE;A;AACF;A;AAED;A;A;AAGA;A;AAEE;A;AACF;A;AAED;A;;;;;AAKA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;AAEC;A;AAGC;A;AAEA;A;A;AAGF;A;;;;;A;AASC;AACA;AACA;A;AAEC;A;A;AAGA;A;AAED;A;AAED;A;AAIC;A;AAEA;A;AAEA;A;A;;;;AAOG;A;AAGH;A;AAEA;A;AAED;A;;;;;;AAyBA;;;;;AACA;;;;;AACA;;A;;;;;;;;;;;A;;;;;;;;A;;;;;;;;;AAsBA;AAGA;AACA;AACA;AAMA;AACA;AACA;AACA;AAKA;AACA;AACA;AAMA;AACA;AACA;AACA;AAEA;AACA;A;AAGC;A;AAGD;A;A;AAME;A;AAGA;AACA;AACA;A;A;AAMF;AACA;AACI;A;AAEH;AACA;A;AAEA;A;AAGD;AACA;AACA;A;;;A;AAwBC;A;AAED;A;;;AAoBA;;;;AACA;AACA;A;AAEC;A;AAED;A;;;;AAIA;A;;;;AAKA;AACA;A;;;;;AAKA;AACA;A;;;;;A;AAUC;A;AAED;AACA;A;;;;;AAKA;A;AAEC;A;AAED;A;;;;;;;;AAMA;;;;AACA;A;;;;;;AAOA;A;;;;;AAUA;A;;;;;;AAOI;AAEJ;;A;AACC;A;;AAEA;;;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAGD;AACA;AACA;AAkBA;A;;;;;;;AAKA;A;AAEC;A;A;AAIA;A;A;AAIA;A;AAGD;AACA;AAGA;AACA;AAEA;AACA;AAEA;AACA;AACA;AAEA;;A;AACC;A;;AACS;;;A;AACT;A;AAEA;A;A;AAGD;A;;;;;;;AASA;;A;;;;;;;AAKA;;A;;;;;;;AAMG;;A;AAGF;A;AAGD;AACA;AACA;;AACA;AACA;A;;;;;;;A;AAQC;A;AAGG;AACJ;;;;AACA;A;;;;;;;AAMG;;A;AACF;A;AAGD;AACA;;A;;;;;;;AAOI;AACJ;;;;AACA;A;;;;;A;AAUC;AACA;AACA;A;AAEC;AACA;A;A;AAGF;A;;;;AAIA;A;;;;;A;AAQC;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;;;;;A;;;;A;AAuBA;A;AAID;AACA;;;AACA;AAGA;;;AACA;;;AACA;;;AACA;;;AAEA;AAKA;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AAGA;A;AAEC;A;AAID;AAGA;AACA;AAEA;AAMA;;;;;AACA;;A;AACQ;AACP;;;A;AACC;;;A;A;AAEA;;;A;A;AAED;A;AAGD;AACA;AACA;A;;;;;;AAWA;A;AAEC;A;AAED;;AACA;A;;;;;AAYA;A;AAEC;A;AAED;;A;AAEC;A;AAED;A;;;;;;AAOA;AACA;AACA;A;AAGC;AACA;AACA;A;AAEC;AACA;A;A;A;AAOD;AACA;A;AAIA;AACA;AACA;A;AAQA;AACA;AACA;AACA;AACA;AACA;;;;A;AAEC;A;AAED;;;;A;AAEC;A;AAKD;AACA;;AACC;A;AAED;AACA;AACC;A;AAGC;AACA;;;;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;AACA;A;AAED;A;A;AAUA;AACA;A;AAED;A;;;;;A;AC18CC;A;AAED;;A;AACC;A;AAED;A;;;;;;;AAMA;;A;;;;;AAMA;AAOA;AACA;A;;;;;;;;;;AAWA;;A;AAGC;AACA;AACA;AACA;AACA;A;AAGE;A;AACF;AACA;AACA;AACA;AACA;A;A;AAIA;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAED;A;AAKD;AACA;AACA;AACA;AACA;;AACC;AACA;A;AAEC;AACA;A;AAEA;A;A;AAGF;AACA;AACA;AACA;AAEA;A;;;;;;A;AAqBC;A;A;AAKI;;;A;AAEF;A;AAFyC;A;A;AAQ5C;;;;;A;AAEE;A;A;;AAKF;A;;;;;AAMA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;;AAOA;;AAQA;;;;;AACC;AACA;;A;AACC;;;;A;A;;;;;A;A;A;;AAQF;;;;;AACC;A;A;;;;;A;A;;AAOD;A;;;;;;;;;;;;;;;;;;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3OwC;A;;;;;A;;;;;AAIX;A;;;;;A;AAI5B;A;AAED;A;;;;;AAGoD;A;;;;;AAEC;A;;;;;A;AAIpD;A;AAED;A;;;;;AAGiD;A;;;;;AAEC;A;;;AAIhB;A;;;;AAES;A;;;;AAEI;A;;;;AAEC;A;;;;;AAUhD;;A;AACC;AACA;AACA;;A;A;A;;;;;;A;AASD;A;AAEC;A;AAGD;AACA;AACA;A;AAEC;A;A;A;;;;;A;ACnDA;A;AAED;A;;;;AAUyC;A;;;;;AACA;A;;;;;AACA;A;;;;AAIzC;;AACC;A;AAEC;AACA;A;AAED;AACA;A;A;;;;;AC3CE;A;AACF;A;AAED;AACA;A;;;;;AAIA;;;A;AAEC;A;AAED;A;;;;AC6BA;AACC;A;AAEC;A;AAED;A;AAEC;A;A;AAGA;A;A;A;;;;;;AAQF;AACC;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;;A;AAGC;;AACC;AACA;A;AAED;;AACC;AACA;A;AAED;A;A;A;;;;;;;AAQF;AACC;A;AAEC;A;AAED;A;AAEC;A;A;A;;;;;;AAQE;;;;;;AACA;A;AAEH;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;A;AAED;AACC;A;AAEC;A;AAEG;A;AAGH;A;AAEC;A;A;AAID;A;AAEC;A;A;AAGF;;A;A;AAEE;A;AAED;A;A;A;;;;;;;;AASE;;;;;;AACA;A;AAEH;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;A;AAED;AACC;A;AAEC;A;AAGD;A;AAEC;A;AAED;;A;AACC;;A;AACC;A;AAED;A;A;A;;;;;;;A;AAaD;A;AAED;A;;;;;;AAOA;;A;AACC;;A;AAED;A;;;;;;;AAMA;;;A;AACC;A;AAED;A;;;;;;;AAOA;;;A;AACC;;A;A;;;;;;;;AAOD;;;A;AACC;A;AAED;A;;;;;;;AAOA;;;A;AACC;;A;A;;;;;;;A;ACxOA;A;AAED;A;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;A;ACUC;A;A;AAGA;AACA;A;AAED;A;AAIC;A;AAED;A;;;;;;AAQA;AACA;;AACA;AACA;AACA;A;;;;;;;AAMA;;;A;AACC;A;AAQD;AAIA;;AAQA;;A;AACC;A;AAGD;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AAIA;AACA;A;;;;;;;AAYG;;A;AACF;A;AAED;A;AAOC;A;AAEE;A;AACF;A;A;AAGA;A;AAED;AACC;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAOD;A;A;AAGF;AACA;A;A;;;;;;;;AASE;A;AACF;A;A;AAGA;A;AAED;;;A;AAEC;A;AAED;;AACA;AACA;A;;;;;;;AAKG;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAIH;AACA;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;;;A;A;AAIK;A;AACF;A;A;A;AAIH;AACA;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAEG;AACJ;AACC;A;AAEC;A;AAED;;;A;AAEC;A;A;AAGA;A;A;AAGG;A;AACF;A;A;A;AAID;A;A;AAGA;A;A;A;;;;;;;;AAUC;A;AACF;A;AAED;AACI;AACJ;AACC;A;AAEC;A;AAED;;;A;AAEC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;A;;;;;;;;AAOC;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;A;AAEI;A;AACF;A;A;A;AAID;A;AAED;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;A;AAEI;A;AACF;A;A;A;AAID;A;AAED;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AAEG;A;AACF;A;AAED;AACC;;;;;;A;AAEC;A;A;A;A;AAKI;A;AACF;A;A;A;AAOF;A;AAED;A;A;;;;;;;;AAME;A;AACF;A;AAED;AACA;A;;;;;;;AAOG;A;AACF;A;AAED;AACA;AACC;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAKH;A;A;;;;;;;;AAME;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;A;AAUC;;;A;AAEC;A;A;A;AAOA;A;AAEA;A;A;AAGF;;A;;;;;;AAMA;AACA;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;;AAKG;A;AACF;A;AAED;AACA;;A;;;;;;AAOA;A;;;;;;AAKG;;A;AACF;A;AAED;AACA;A;;;;;;;AAMG;A;AACF;A;AAED;AACA;AACA;A;;;;;;;AAKG;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;A;AACC;A;AAEE;A;AACF;A;A;A;;;;;;;;AAOC;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;A;AACC;A;AAEE;A;AACF;A;A;A;;;;;;AC3hBF;;;A;AAEC;A;AAED;A;;;;ACFA;;;;;A;A;AAOC;A;A;A;A;A;AAEA;A;AAYD;;;;;A;AAEC;A;A;AAGA;A;AAEE;AAAH;;A;AACC;;AACA;A;AAED;A;;;;;;ACpCG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;ACxBG;A;AACF;A;AAED;AACA;A;;;;;;;ACFG;A;AACF;A;AAED;AACA;A;;;;;;;ACJG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;;ACVG;;A;AACF;A;AAED;AACG;A;AACF;A;AAGG;A;AAEH;A;AAKD;AAEI;AACA;AACJ;;AACC;AACA;;;;;A;AAEE;;A;AAED;A;AAEC;AACA;A;AAED;A;AAEC;A;A;;A;AAID;A;AAED;AAEI;AACJ;;;A;AAEC;A;AAED;AACA;AACA;A;A;AAGK;A;AACF;A;A;AAGF;A;A;AAGA;AACA;A;A;AAGF;A;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;;;;;;;;;;;;;;A;;;;;A;;;;;A;A;;;;;;;;;;;;;AClCA;A;AAEC;A;AAED;A;;;;;AAmBG;AAAH;;A;AACC;A;A;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvDD;A;;;AAIG;A;AACF;AACA;AACI;;;AACH;AADgC;A;A;A;AAKjC;A;A;;A;;;;;A;ACAA;A;AAED;;A;;;;;;;;;A;A;;;;;A;A;;;;;A;;;;;;A;;;;;;;;A;ACMC;AAEA;A;AAED;AAEA;A;AAEC;AACA;A;AAGD;AACA;;AAEC;;A;AACC;AACI;AACJ;;;;AACA;A;A;;;;;A;A;AAKC;A;A;AAKE;;;;AACJ;;;;AACA;AACA;A;A;A;;;;;A;A;;;;;A;;;;;;;AC/BmC;;A;;;;;;;AAIpC;;;AACA;;;;A;;;;;;;AASuC;;A;;;;;;;AAIvC;;;AACA;;;;A;;;;;A;AAQC;A;AAED;A;;;;AAcA;A;;;;AAmBA;A;A;AAEC;A;A;AAEA;A;A;AAEA;A;AAED;A;;;ACzFG;;A;AACF;A;AAED;A;;;ACAA;AACA;A;;;;ACgC8B;A;;;;;;AAgD9B;;A;;;;;;;;;AAOG;A;A;;;;;A;AAGH;;;;A;;;;;A;;;;;;;;;AASG;A;A;;;;;A;A;A;;;;;A;AAQH;;AACC;;;;A;AAEC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;;;;AAOG;A;A;;;;;A;AAGH;;;;A;AAEC;A;A;AAGA;A;AAGD;A;AAGC;A;A;;;;;A;;;;;;;;;AAUE;A;A;;;;;A;A;A;;;;;A;AAQH;;AACC;;;;A;AAEC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;;;;AASG;A;A;;;;;A;AAGH;;;;A;AAEC;A;A;A;;;;;A;A;;;;;A;;;;;;;;;A;;;;;A;;;;;;A;AAkHA;A;A;AAGA;A;AAED;A;;;;;;AAkH2C;;A;;;;;;AAyB3C;A;;;;;AAQA;A;;;;;AAUA;A;;;;;AAMG;A;AACF;A;AAED;;A;;;;;;;;AC7bA;A;AAEC;A;A;AAGA;A;A;AAGA;A;AAGD;A;;;;;AAaG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAoCG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAOG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAOG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAuBG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;AAKG;A;AACF;A;AAED;A;;;;;AAKG;A;AACF;A;AAED;A;;;;;AAKG;A;AACF;A;AAED;A;;;;;A;AAOC;A;AAED;A;;;;;;A;ACxIC;A;AAQD;;A;AACC;;A;AAGD;A;;;;;AASA;AACG;;;A;AACF;A;AAED;A;;;;AAiBA;A;AAEC;A;AAED;AAUA;A;AAMK;A;A;AAQH;A;AASG;A;AACF;A;A;AAQE;A;AACF;A;A;A;AAKA;A;A;AAUC;A;AACF;A;A;AAIF;AACA;A;;;A;AAQC;A;A;;;;;A;AAuDA;A;AAED;;A;;;;;;;A;AAKC;A;A;AAGA;A;AAEG;AACD;;A;A;AAED;A;AAED;A;AAID;AACA;A;;;;;;;;;AAMA;;;;AACA;A;;;;;A;;;;;;;;;AAQA;;;;AACA;A;;;;;A;;;;;;;;;AAOA;;;;AACA;A;;;;;A;;;;;;;;;AAOA;;;;AACA;A;;;;;A;;;;;;;;;AASA;;;;AACA;A;;;;;A;;;;;;;;;AA8EA;A;AAEC;A;AAED;;;;AACA;AACA;;;;;AACC;;;;A;AAIC;;A;A;A;;;;;A;AAKD;A;;A;AAKA;A;A;;;;;A;;;;;ACzXD;AAEA;;AACC;AAD8B;A;AAI3B;A;;A;AAEF;AACA;A;AAHe;A;AAOjB;A;;A;ACdC;A;AAED;A;;;A;AAyCC;A;AAED;A;;;;;;AC9CG;A;AACF;A;AAED;;AACA;AACA;A;;;;;;;AAIG;A;AACF;A;AAED;;AACA;AACA;A;;;;;;;AAIG;A;AACF;A;AAED;;AACA;AACA;A;;;;;AAIA;A;;;;ACzBA;AACA;A;;;;;ACTA;AACA;AACA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;;;AAKD;A;;;;;;A;AC5BC;A;AAEG;AACJ;;A;AAEC;A;AAED;AACA;A;;;;;AAgBI;AACJ;A;AAEC;A;AAED;AACA;A;;;;ACoBI;AACJ;AACA;;;;;;;A;AAEE;AACA;A;A;;A;AAID;AACA;A;AAGD;;;;;;;A;AAEE;A;AAEA;A;AAED;A;;AAED;A;;;;;AAMA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAGmC;A;;;;;AACA;A;;;;;ACrFM;A;;;;;AACA;A;;;;;AACA;A;;;;;AACA;A;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC4BzC;A;;;;;AAIA;AACA;A;;;;;A;AAMC;A;AAED;AACA;AACA;A;AAGC;AACA;A;AAGD;A;AAEC;A;AAGD;AACA;;;;;AACC;A;;AAED;A;;;;;A;AAMC;AACA;A;AAED;A;AAGC;AACA;A;AAGA;AACA;A;A;;;;;A;AAOA;AACA;A;AAED;A;AAGC;AACA;A;AAGA;AACA;A;A;;;;;A;AAOA;A;AAEA;A;A;;;;;AAMD;AAKA;A;AAEC;AAEA;A;AAEC;A;A;AAKF;A;AAIC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGD;;AACC;AACA;AACA;AACA;A;AAED;AACA;AACA;AAEA;;AACC;AACA;AACA;A;AAGD;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;A;;;;;AAKA;A;AAEC;A;AAGD;A;AAKC;A;AAGC;A;A;AAOF;A;AAEC;A;AAGC;AACA;AACA;AACA;AACA;A;A;AAGD;A;AAEC;A;A;AAOF;A;A;AAKC;;AACC;AACA;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;A;AAED;AACA;AACA;;AACC;AACA;A;A;A;A;A;AAQE;AACA;A;A;AAID;AACA;AACA;AACA;A;A;A;AAKD;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAKD;AACA;AACA;AACA;A;;;;;A;AAMC;AACA;;;;;;AACC;A;AAEC;A;A;;A;AAIH;A;;;;;A;AAMC;AACI;;;AACH;A;AAEC;A;AAED;A;AAEC;;A;AAED;A;A;AAGF;A;;;;;AAKA;AACA;A;;;;;AAKA;AACA;A;;;;;AAKA;A;AAGC;A;A;AAIA;A;AAGD;A;A;A;AAKG;A;AAGD;A;AAGA;A;A;A;AAIA;A;AAED;A;A;AAIA;A;AAGD;A;AAGC;A;AAEG;AACA;;;A;AAGF;A;AAGC;A;A;A;AAID;A;AAEA;A;AAGD;AAfuB;A;AAiBxB;A;AAGC;A;A;;;;;AAMD;A;;;;;AAKA;A;;;;;AAOA;A;AAEC;AACA;A;AAED;A;AAEC;A;AAEA;A;A;;;;;AAOD;A;AAEC;A;AAED;AACA;AACA;A;;;;;AAMA;A;AAEC;A;AAED;A;AAEC;A;AAEA;A;A;;;;;A;AASA;A;AAGD;A;AAEC;A;AAEA;A;A;AAKA;A;A;AAKA;AACA;A;AAGC;A;AAED;AACA;AACA;A;A;AAKA;A;A;AAGC;A;AAGC;A;A;AAME;AACJ;AAEA;AAEI;;;A;A;AAGF;A;AAEA;AACA;A;AAEA;A;AARwB;A;A;AAYzB;A;AAED;;AACC;AACA;A;AAED;A;A;A;AAOC;AACA;AACA;AACA;A;AAED;AACA;A;AAGD;A;;;;;ACneA;A;;;;AAIA;A;;;;AAIA;A;;;;A;AAKC;AACA;A;AAGD;AACA;AACA;;AACC;A;AAED;AACA;A;;;;AAgCA;;AACA;AACA;AACA;AACA;A;;;;;A;AAYC;A;AAGD;AACA;AACA;AACA;A;;;;;;;A;;;;;A;;;;;;;A;;;;;A;;;;;A;A;AAUC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;;;AAMA;A;;;;;A;;;;;;;AAOA;A;;;;;A;;;;;;;AASA;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAWA;;AACA;AACA;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;;;AASA;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAaA;;AACA;AACA;AACA;AACA;A;;;;;;AA4BA;;AACA;AACA;AACA;AACA;A;;;;;;AAOA;;AACA;;A;AACC;;A;AAED;A;;;;AAOA;A;;;;;;A;A;;;;;;;A;AAQI;;;A;A;;;;;;;A;AAIH;AACA;AALiE;A;AAOlE;A;;;;;A;AAKC;AACA;A;AAED;AACA;;AACA;A;;;;;;;;AAIA;AACA;AACA;AACA;AAEA;;;A;AACC;;AACA;AACA;A;A;AAEA;;AACA;AACA;A;;AAEA;A;A;AAED;AACA;A;;;;;;;;A;AAKA;;A;AACC;A;;AAEA;A;A;A;;;;;;;AAOD;AACA;AACA;AACA;A;;;;;;A;AAMA;;;;;;;;;;A;A;AAEE;A;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;AACC;A;;AAEA;A;A;A;AAGD;A;;AAEA;A;A;A;;;;;;;;A;AAQD;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;A;AAWD;;A;AACC;AACA;AACA;AAEA;AACA;AACA;AACA;A;;AAEA;A;A;A;;;;;;;;A;AAMD;;;;;;A;A;AAEE;A;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;A;AAMD;;;;;;A;A;AAEE;A;AAEC;AACA;A;AAED;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;A;AAEA;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;;A;A;A;;;;;;;;AAKG;A;AAEJ;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;;;;A;AACC;;A;AACC;AACA;;AACA;A;AAEC;A;AAEA;A;AAED;A;;A;AAGC;A;AAEA;A;A;A;A;AAIF;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;AAKE;AAAH;;A;AAII;;A;AACF;AACA;A;A;AAMA;A;AAGD;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;A;A;;;;;;;;;A;AAMA;A;AAGE;;;AAAH;;A;AACC;AACA;AACA;AACA;A;AAID;;A;AACI;;;AAAH;;A;AACC;AACA;AAEA;;AACA;A;A;;A;AAOD;;A;AAKC;;;;A;A;AAEC;AACA;AACA;;AACA;A;A;AAGA;AACA;AACA;;AACA;A;A;A;A;A;;A;;;;;;;AAQH;AACA;AAEA;;A;A;AAEC;;A;AACC;A;;AAEA;A;A;AAED;A;A;AAMD;;;A;AACC;;AACA;A;AAEA;;AACA;A;A;AAID;;;;;;;;;;;;;;;;;;;;;A;A;AAEC;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAIA;;A;AACC;;AACA;;;A;AACC;A;A;AAGF;A;;A;AAGA;;;A;AAGC;;A;A;A;;;;;;;;AASF;;A;AACC;;AACA;;;A;AACC;A;A;AAGF;AACA;AAEO;A;AACP;;;;;;;;;;;;;;;;A;AACC;;A;AACC;A;;A;AAGA;;A;AACC;A;;AAEA;A;A;A;A;A;AAIF;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;A;AAEA;;A;AACC;;A;AAEC;AACA;A;AAED;A;;AAEA;A;AAED;;AACA;;;;;;A;A;AAGG;A;AAEA;A;A;AAGF;AACA;AACA;A;;A;AAGA;A;AAEA;A;A;A;AAGD;;A;AACC;;A;AAED;AACI;;;A;A;AAGD;A;AAEA;A;A;AAGF;;A;AACI;;A;AACF;AACA;A;A;AAGF;;AAd6B;A;AAgB9B;A;A;AAEA;;AACA;;A;AACC;;A;AACC;;AACA;A;;AAEA;A;A;;AAGD;A;A;A;A;AAID;;A;AAEC;AACA;;;;A;AACK;AACJ;;;A;AACC;;A;A;AAEA;;;A;;AAKA;AACA;;;;;AACC;;;A;;A;AAGF;;;;;AACA;A;A;A;AAGF;;A;AACC;;A;AAEC;AACA;A;AAED;AACI;;;A;AAEF;A;AAED;;AAJwB;A;AAMzB;A;;AAEA;AACI;;;A;AAEF;A;AAED;;AAJwB;A;AAMzB;A;A;A;AAKD;;A;AACQ;;A;AACP;;A;AACC;AACA;AACA;A;A;A;AAKF;A;A;AAAA;A;;AAEA;A;A;A;;;;;;;;;;AAMD;AACA;;A;AACC;;;AACA;;A;AAEQ;;A;A;AAEN;A;AAEC;AACA;A;A;AAGD;A;AAEC;AACA;A;A;A;A;AAMH;A;AAEC;AACA;A;A;AAGF;A;;;;;;;A;A;;;;;;;A;AAgBI;;;A;AAEF;;;;A;A;;;;;;;A;A;;;;;;;A;AAF2B;A;A;;;;;;;A;;;;;;;A;A;;;;;;;A;AAmB7B;AACA;;;;A;A;;;;;;;A;AAIA;A;;;;;;;A;;;;;AAKA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;;AAIA;AACA;AACA;AACA;AAEI;;;AACH;AACA;AACA;;AACC;A;A;AAGA;A;A;AAIA;A;AAID;AAGA;AAEA;;AACC;A;AAEA;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;AACA;A;A;AAEA;A;;AAIA;;A;A;AAGE;AACA;AAEA;AACA;A;AAED;AACA;AACA;AACA;A;AAGD;A;A;AAhCa;A;AAqCf;;;;AAGA;;A;AACC;AACA;;;;;A;AAGC;A;A;AAMA;AACA;AACA;A;AAED;A;;AAEA;;;;A;AAEC;A;A;AAKF;;A;AACC;A;AAEC;A;AAED;;;;AACA;;A;AACC;AACA;;;;;A;AAGC;AACA;A;A;AAGA;A;AAED;A;;AAEA;;;;A;AAEC;AACA;A;A;A;A;AAMF;;;;A;A;AAIA;AACA;A;AAGD;;;;A;AAEC;;;A;AAED;AAGA;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAGA;AACA;AAEA;AACA;AAGA;AACA;A;;AADA;AACA;A;A;A;AAOF;;A;AACC;AACA;AACA;;;;;;A;AAEE;A;AAED;;A;AACC;A;;AAEA;;AACA;AACA;A;A;;AAGF;A;A;;;;;;;;AAKD;AACA;;;;;;AACC;;;;A;AAGC;A;AAED;AACA;A;;A;;;;;;;;AAOD;;;;;;A;AAEE;A;AAED;A;;AAED;A;;;;;;;;;A;;;;;A;;;;;;;;;A;ACh9BC;AACA;A;AAGD;;;;;A;AAEC;A;AAEC;A;A;AAGD;A;AAED;A;;;;;;;;A;A;;;;;A;A;;;;;A;;;;;;;AAaA;;;;A;A;A;;A;AAKC;A;AAED;A;;;;;;;AAeA;;AACA;AACA;AACA;A;;;;;;AAIA;A;;;;;AAIA;A;;;;;;;;;AAIA;;AACI;A;AACC;;;A;AACF;A;AAEA;A;A;A;A;AAKF;A;AAED;AACA;;AACA;A;;;;;A;AAoBC;A;AAED;AACA;;;;;A;AAEE;A;A;AAGA;A;A;;AAGF;A;;;AAKA;A;;;;A;AA2GC;AACA;A;A;AAIA;A;AAED;AACA;AACA;A;;;;;;AAOA;AACC;;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;A;A;AAEE;A;AAED;AACA;A;AAED;;A;AACC;;AACA;A;A;A;;;;;;;;AASF;;A;AACC;A;AAGD;AACC;;A;AAEC;A;AAED;;;A;AACC;;AACA;A;AAED;A;AAED;A;;;;;AAOA;;;;;;;A;AAEE;A;A;;AAGF;A;;;;;AAwBA;;AACA;;A;AACC;;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;ADrX0B;A;A;A;AC0PA;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/W1B;A;;;;AAIA;A;;;;;AAwCA;A;;;;;A;AAOC;A;AAEA;A;A;;;;;ACd4B;A;;;;;AAKA;A;;;;;AAI7B;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;AAOA;A;AAEC;A;A;AAGA;A;A;;;;;AAOD;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;AAMA;A;AAEC;AACA;A;AAED;A;AAEC;A;AAED;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;A;AChGC;A;AAED;A;;;;;AAO+B;A;;;;;;;A;A;;;;;A;AAM/B;AACA;AACA;AACA;A;;;;;;;A;A;;;;;A;A;A;;;;;A;AAWA;A;AAEC;A;AAED;A;;;;;AAIA;A;AAEC;A;AAED;AACA;AACA;A;;;;;A;AAKC;A;AAED;AACA;AACA;A;;;;;;;;A;AAKC;A;;;;;;;A;AAGD;AACG;A;AACF;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;A;AAKC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;;AAKA;AACI;A;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;;;;;;;AAKA;A;A;;;;;A;AAIA;AACA;;;;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;;AAIkC;A;;;;AAIA;A;;;;ACvDlC;A;;;;AAUA;A;;;;A;AAoDC;A;AAEA;;;;;;;A;AAEE;A;A;;AAGF;A;AAEA;A;AAEA;A;A;;;;AAqRD;A;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;AC9a4B;A;;;;AAO5B;;;;;;AACC;AACA;A;;AAGD;A;;;;AAkEA;AACA;AACA;A;;;;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7FA;;;;;;A;AAEE;A;A;;AAGF;A;;;;A;AAKC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;ACkCiC;A;;;;;A;AAShC;A;AAED;A;;;;;AAI+B;A;;;;;AAIH;A;;;;;AAIA;A;;;;;A;AAO3B;AACA;A;AAED;A;AAEC;A;AAED;A;;;;;AAOA;AACA;AACA;A;;;;;AAOG;A;AACF;AACA;A;AAED;A;;;;;AAOA;A;AAGC;A;AAGE;;;A;AACF;A;A;AAGA;AACA;A;AAED;A;AAMC;A;AAEA;A;AAGA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;A;AAUC;A;AAED;AACA;A;;;;;;;AAOA;AACA;;;A;AAEC;A;A;;;;;A;;;;;;;AASD;AACA;;;A;AAEC;A;A;;;;;A;;;;;;;;AAgBD;AACA;AACC;AACA;AACA;;;;A;AAEC;A;AAGD;AACA;A;A;;;;;A;A;A;;;;;A;A;A;;;;;;;AAcD;A;AAEE;A;A;AAGF;A;;;;;;;;AAQA;AACG;AAAH;;A;AACC;;;;A;AAEC;A;AAED;AACA;A;A;;;;;A;A;A;;;;;A;A;AAWD;A;;;;;A;;;;;;AASA;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;;;A;AASC;A;;;;;A;AAGD;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;A;;;;;;;AASA;A;AAGC;A;A;;;;;A;A;;;;;A;AAMD;AACA;A;AAEC;A;A;;;;;A;;;;;AAUD;AACA;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;A;AAQC;AACA;A;AAED;AACA;AACA;AACA;A;;;;;;;;A;AAWC;A;;;;;;;A;AAGD;A;AAEC;AACA;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;;;A;;;;;A;AAWC;A;A;AAGA;A;AAED;AACA;A;;;;;A;AASC;A;AAED;A;AAEC;A;AAED;A;;;;;;;AAUA;;;AAGA;A;;;;;A;;;;;;;AAMA;AACA;A;AAEC;AACA;A;AAED;AACA;AACA;A;;;;;A;;;;;;;AAWA;;;A;;;;;A;;;;ACRA;A;;;;;AA2JA;;A;AAEC;;AACA;A;AAEA;A;AAED;A;;;;;;AAgEI;;;AACH;;;;A;AAEC;;;A;AAED;AACA;;;A;AACC;A;A;AAGF;A;;;;;;AAcI;;;AACH;A;A;;;;;A;A;AAIA;AAL2B;A;A;;;;;A;;;;AAY5B;A;;;;A;AAKC;;AACC;A;A;AAGC;;;A;AACF;;AACC;A;A;AAGF;;AACC;;;;;;A;AAEE;A;A;;AAGF;A;A;;;;AAmBD;;A;;;;;AA6EA;;AAEK;;;;A;AAEH;;;;A;AAEA;;;AACA;;;;A;A;AAGA;;;;A;AAEA;;;AACA;;;;A;A;AAOA;A;A;AAKA;;;;A;A;A;AAMC;A;AAED;A;AAKD;AACA;;AACC;A;A;AAGA;A;AAED;A;AAID;A;;;;AAKA;A;AAGC;A;AAEA;A;A;AAGC;A;AAED;A;AAEA;A;A;AAIC;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;AAIE;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;A;AAEC;A;AAED;A;A;AAGF;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;AAEE;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAUC;A;AAEC;A;AAED;A;A;AAGF;A;;;;AAKA;;;AACA;AACI;AACA;;;AACH;AADkB;A;A;AAIlB;A;AAEG;;;AACH;AACA;AACA;AACA;A;AAEC;A;A;AAGF;A;;;AASA;AACI;;;AACH;AADyB;A;AAGtB;;;;AACA;;;A;AAEF;A;AAED;AAJyB;A;AAM1B;A;;;;A;ACh8BC;A;AAED;A;;;;;AAO+B;A;;;;;;;A;A;;;;;A;AAO/B;AACA;AACA;AACA;A;;;;;;;A;A;;;;;A;A;A;;;;;A;AAYA;A;AAEC;A;AAED;A;;;;;AAKA;A;AAEC;A;AAED;AACA;AACA;A;;;;;A;AAMC;A;AAED;AACA;AACA;A;;;;;;;;A;AAMC;A;;;;;;;A;AAGD;AACG;A;AACF;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;;AAKA;AACI;A;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;;;;;;;AAKA;A;A;;;;;A;AAIA;AACA;;;;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;;AAIkC;A;;;;AAGA;A;;;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5GlC;AACA;A;;;;AAIA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAGqC;A;;;AAEE;A;;;;AAKvC;AACA;A;;;;AAIA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAGkC;A;;;AAEE;A;;;;;;;;;A;A;A;A;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;AClGnC;A;AAEG;;;A;AAEF;A;AAF4B;A;AAM9B;AACA;AACA;AAEI;;;AACH;AADiC;A;AAG9B;;;AACH;AAD6B;A;AAG9B;A;;;;;A;AAUC;A;AAGG;;;A;AAEF;A;AAF+B;A;AAMjC;AACA;A;;;;;AAOA;AACA;A;;;;;A;AAiCC;A;AAGD;;;;AACA;AACA;;AAEC;AAEA;AACA;AACA;AACA;AAEA;AACA;A;AAGD;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;A;A;AAIC;A;AAEC;A;A;A;AAIA;AACA;A;A;A;;;;;AAOF;AACA;AACA;A;;;;;;;;A;A;;;;;A;AAkBA;;A;AACK;AACA;;;AACH;AACA;AAFoC;A;AAIrC;AACA;A;AAEC;A;AAED;AACG;;;A;A;;;;;A;AAGH;A;AAID;;AACC;A;AAEC;AACA;A;AAED;AACG;;;A;A;;;;;A;AAGH;AACA;A;AAIG;;;AACH;AADuB;A;AAGxB;AACA;AACA;A;;;;;;;AAOA;;A;AACC;AACA;;;AACA;A;AAED;A;;;;;AASA;A;;;;;A;AAOC;A;AAED;A;;;;;AAUA;A;;;;;;;;AAUI;AACJ;;;;AAEI;;;A;A;A;;;;;;;A;A;;;;;;;A;AAQF;;;;AACA;A;AAED;AACA;AAEA;A;AAEC;AAhByB;A;A;A;AAqBzB;AArByB;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;AAqCzB;;AACC;A;A;A;;;;;;;A;A;A;;;;;;;A;AAWD;A;AAID;;AACC;A;A;AAIA;A;AAED;;;;AACA;A;AAID;AACA;;;;;;A;A;AAGC;AACA;AAGA;A;A;;;;;;;A;AAIA;AAGA;A;A;;;;;;;A;A;AAPA;A;A;;;;;;;A;AAIA;AAGA;A;A;;;;;;;A;A;AAAA;A;A;;;;;;;A;A;AAKD;A;;;;;;;A;;;;;AAOA;AACA;;;AACA;A;;;;;;;A;A;;;;;A;AA0FA;AACA;;AACI;;;A;AACF;AACA;AACA;A;AAEI;AACJ;;;;AACA;A;A;;;;;A;A;A;AAOF;;AACI;;;A;AACF;AACA;AACA;A;AAEI;AACJ;;;;AACA;A;A;;;;;A;A;A;AAOF;;AACK;AACJ;;;;AACA;A;A;;;;;A;A;A;;;;;A;;;;;;;AAYG;AACJ;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;A;;;;;A;;;;;;;AAQI;AACJ;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;A;;;;;A;;;;;A;AAuCC;A;AAGD;A;;;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvaiC;A;;;;;AAIjC;A;;;;;AAKA;A;;;;A;AAUC;A;A;AAKA;A;AAEC;A;A;A;AAUD;A;AAGA;AACA;;AACC;A;A;AARD;A;A;AAcA;AACA;;AACC;A;A;A;AAOD;A;AAEC;A;AAEC;A;A;AAGF;;AACC;A;A;AAKF;A;;;;ACrGA;;AAEA;;A;AAEC;A;AAED;AAEA;AACA;AAEA;A;;;;;AA4BA;AACA;;;;;;A;A;AAGG;A;AAED;AACA;AACA;AACA;A;A;A;AAKC;A;AAED;AACA;AACA;A;A;;A;AAID;A;A;;;;;;AAiBD;;A;;;;;;AASA;A;;;;;;AAwBA;;;A;;;;;;AAcG;;A;AACF;AACA;AACA;A;AAED;A;;;;;;;;AASA;;AACI;A;AACC;;;A;AACF;A;AAEA;A;A;A;AAIH;;A;;A;;;;;;AAMA;A;;;;A;A;AAMC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAIA;;A;;;;;;;A;AAgBC;A;AAED;;A;;;;;;;AAIG;;;A;AACF;A;AAQA;AACA;AAED;AACA;;;AACC;AACA;A;;;;;A;AAGA;A;AAID;;AACA;AACA;AACA;A;;;;;AAWA;;;A;AACC;A;AAED;;;A;AACC;;;A;AACC;;;;;A;A;AAIF;;;A;AACC;A;AAED;;;A;AACC;;;A;AACC;;;;;A;A;A;;AAKF;;;;;;;;;;;;;A;AACC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;A;A;A;;;;;AAKD;A;;;;A;AAKC;AACA;A;AAED;;;;A;AAEC;AACA;A;AAED;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;;AAKD;A;AAEC;AACA;A;AAED;;AACA;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;;A;AAMA;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;;;AAIA;A;AAEC;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;;A;AAKC;A;A;AAGA;A;AAEA;A;A;AAGA;A;A;;;AAKD;A;AAEC;A;AAED;A;AAEC;A;A;;;AAKD;A;AAEC;A;AAED;A;AAEC;A;A;;;;AAOD;A;AAEC;A;AAQD;AACA;AACA;A;A;AAIE;A;A;AAGF;A;AAGC;A;AAEC;AACA;A;A;A;AAKD;A;AAED;A;AAEC;A;A;;;;;AAUD;;A;AACC;;A;AAIC;A;AAED;;A;AACC;;A;AAED;AACA;A;AAED;;A;AACC;;;;;A;AAEC;A;AAED;A;;AAEA;;A;A;;;;;;A;AAMA;AACA;A;AAED;;A;;;;;AAIA;A;;;;;AAQA;AAEA;;;;;AACC;AAGA;AACA;;;;;AACC;;A;AACC;;A;AACC;;A;AAED;;A;AAED;;A;;AAGD;;A;AACC;;A;AAED;AACA;A;AAEC;A;AAEA;A;AAED;AACA;A;;A;AAGA;A;AAEA;A;A;;;;;;;AAKD;;AACA;A;;;;;;;A;AASC;AACA;A;AAED;AAGA;;AACA;AACA;;;;;;AACC;AACG;;A;AACF;A;A;;AAGF;;AAAqC;A;AAErC;;;;;;A;AAEE;A;AAED;AACA;AACA;;;;;A;;AAED;A;;;;;;;A;;;AAKA;;;;;A;A;A;AAKE;A;A;AAGF;;;AACA;A;;;;;A;AAKC;AACA;A;AAED;;AACA;AACA;AACA;;;A;AAGC;AACA;AACA;A;A;AAIA;AACA;AACA;A;;AAIA;AACA;;AACA;;A;AAED;A;;;;;;;A;AAUC;AACA;A;AAED;A;;;;;;;AAKA;;;;A;AACC;;;AACA;;;;;;A;AACC;A;A;AAGF;;AACA;A;;;;;;AAQA;AACA;AACI;;;A;AAEF;A;AAED;;;;;AAJkB;A;AAMnB;A;;;;;;;AAIA;;;AACA;A;;;;;;A;AASC;AACA;A;AAED;;;;;A;;;;;;;AAIA;;;AACA;A;;;;;;AAQA;;A;AACC;A;;AAEA;A;A;;;;;;AAOD;AACA;A;;;A;AAKC;A;AAED;;;;;;A;A;AAOE;A;A;;AAGF;A;;;;AAIA;;;;;AACC;;;A;AACC;;A;AAED;;A;;AAED;A;;;;;;AASA;;A;AACC;;AACA;A;AAEE;;;;AAAH;;A;AACC;;;;AACA;AACA;A;A;A;AAIA;AACA;A;AAEA;AACA;A;AAED;A;;;;;;;AAKA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;AAED;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAOA;AACA;AACA;A;AAED;AACA;AACA;A;AAED;;;A;A;AAGE;A;AAED;AACA;AACA;AACA;A;A;A;AAWC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;;AAKA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;AAED;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAOA;AACA;AACA;A;AAED;AACA;AACA;A;AAED;;;A;A;AAGE;A;AAED;AACA;AACA;AACA;A;A;A;AAWC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;;AAwB4B;A;;;;;AAEK;;;;A;;;;;AAGjC;;;;;;A;AAEE;A;A;AAGA;A;A;;AAGF;A;;;;;;;AAQA;AACA;AAGA;AACA;AAGA;AAGI;AAGA;AAEJ;;AACC;;;;AACA;;;;AAEA;;;;;AACC;;A;AACC;;A;AAED;AAGI;;;;AACH;;AACA;AACA;;;A;AACC;AACA;;;A;AACC;;A;AAED;;;;;A;AARgC;A;A;A;A;AAAA;A;A;AAkBjC;AACA;;A;AAnBiC;A;A;AAsBjC;;;A;AAEC;A;AAED;AACA;AACA;AAEA;AACA;;;;;;A;AAEC;;A;AAID;AACA;;A;A;;A;AAOE;A;A;A;AAKF;;;;;A;AACC;A;AAEC;A;AAED;AAQA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAMC;A;AAhF+B;A;A;AAsFjC;AACA;;A;AACC;;A;AAxFgC;A;A;;A;AA8FpC;;AACC;A;AAKC;A;A;AAGA;A;A;AAGA;A;AAED;A;AASD;AACI;;;;;;AAGH;AACA;AACI;;;AACH;A;AAEC;A;AAHwC;A;A;AAOzC;AAZuC;A;A;AAexC;;;A;AAEC;A;AAjBuC;A;AAqBzC;AACA;AAEA;;;;;AACC;AACA;;;A;;AAED;A;;;;A;AAcC;A;AAED;A;;;;AAOG;;;A;AACF;A;AAED;;;;;;AACA;A;;;;ACttCA;AACA;AACA;;;;;A;AAEE;A;AAED;A;AAEC;A;AAGA;A;A;;A;AAID;A;A;AAGA;A;AAED;A;;;AAQA;;;;;A;AAEE;A;AAED;A;A;AAGE;A;A;AAGE;A;A;AAGD;A;A;AAGF;AACA;;A;AAID;;;A;A;A;AAIE;A;A;A;AAIA;A;A;AAGD;A;AAED;A;;A;AAIA;A;AAED;A;;;A;AASC;A;AAED;;;;;;AACC;A;AAEC;;A;A;A;AAIC;A;A;AAGD;A;A;;AAGF;A;;;A;AASC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;AC9HA;AACI;AACJ;AACA;AACA;;;;;;A;A;AAGG;A;AAED;AACA;AACA;AACA;A;A;A;AAKC;A;AAED;AACA;AACA;A;AAED;;A;A;AAGE;A;A;AAGA;A;AAED;A;A;;AAGF;;;A;AACC;AACA;A;A;AAGA;A;AAED;A;;;;;ACZsC;A;;;;;AAwEtC;AACA;AACA;AACA;A;;;;;;A;AAOC;A;A;AAGA;A;AAED;;A;AAEC;A;A;AAGA;A;AAED;A;;;;;;AAKA;A;;;;;AAMA;AACA;A;AAEC;AACA;A;AAEA;A;A;;;;AAKD;A;;;A;AAMC;A;A;AAGA;A;AAED;A;;;A;AAMC;A;A;A;AAIA;AACA;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAMC;A;A;AAGA;AACA;AACA;A;AAED;A;;;A;AAMC;A;A;AAGA;AACA;A;AAED;A;;;AAMA;A;AAGC;AACA;AACA;A;A;AAGA;AACA;A;AAED;A;A;A;AAIE;AACA;AACA;A;AAED;A;A;AAGC;AACA;AACA;A;A;AAGA;AACA;A;AAED;A;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;A;AAED;A;;;A;AASC;A;AAED;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;A;AAGA;A;AAED;A;;;A;A;AAOC;AACA;A;AAEA;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAOC;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAQC;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;AAMA;A;;;;AAKA;AACA;AACA;A;;;;A;AAOC;A;A;AAGA;A;AAID;AACA;A;;;AC1iBG;A;AACF;A;AAED;A;;;;A;AAQC;A;AAED;AACA;;AACK;AACJ;A;AAEC;;;;A;A;AAGA;A;AAED;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;A;;A;A;A;;A;;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACoBA;A;;;;;;AAKA;AACA;AACA;A;;;;;AAQI;AACJ;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAGD;AACA;A;;;;;AAQA;AACA;;A;A;AAEE;A;AAED;;A;AACC;;;;;AACA;AACA;AACA;AACA;AACA;AACA;A;AAED;;A;AACC;;;;;AACA;AACA;AACA;AACA;AACA;A;AAEC;AACA;A;AAED;A;A;A;A;AAKA;AACI;;;A;AAEF;AACA;A;AAH6B;A;AAM/B;A;AAED;AACA;AACA;AACA;A;A;;;;;;;;AAWD;AACI;AACA;AACJ;AACA;A;AAGC;AACI;AACJ;;;;A;AAEC;AACA;A;AAED;A;AAED;AACA;AACA;A;AAEC;A;AAED;;;AACA;A;;;;;;;AAMA;;;;A;;;;;;;;AAK0C;;;;A;;;;;;;;AAIE;;;;A;;;;;;;;AAI5C;;;;AACA;A;;;;;;;;AAKA;;;;AACA;A;;;;;;;;AAKA;;;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;AAyCA;;;;A;;;;;;;AAMA;;;;A;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpRA;AACC;;AACA;AACA;A;AAEC;A;AAED;;A;AACC;;;A;AAED;;;A;AACC;A;A;A;;;;;;A;AClBD;A;AAED;A;;;;;AAYA;AACC;;AACA;AACA;A;AAGC;A;AAGD;;A;AAEC;AACC;;;AACA;;;A;AAEC;A;A;A;AAID;A;AAED;A;AAED;;;A;AACC;A;A;A;;;;;;AClBE;AACJ;AACA;A;;;;AAqBA;;AACA;A;;;;;;AAMG;;;AAAH;;A;AACC;AACA;A;AAGD;AACA;A;;;;;;;;AAI8B;;A;;;;;;;AAGE;;A;;;;;;;AAIhC;;A;AACC;;A;AAED;;;A;;;;;;;AAI8B;;A;;;;;;;AAI9B;;AACA;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;AACA;;AACA;;AACC;;A;AAED;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;AACA;;AACA;;AACC;;A;AAED;A;;;;;;;AAaA;;AACA;AACA;AACA;;A;AACC;AACA;;AACC;;AACA;AACA;A;A;AAGF;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;;A;;;;;;;AAqBD;AACC;;AACA;;A;AACC;A;AAED;A;;;;;;;AAQD;AACC;;AACA;;A;AACC;A;AAED;A;;;;;;;AAKA;AAMI;;;AACH;;AACA;AACA;AAHkB;A;AAKnB;A;;;;;;;A;AAQC;A;AASD;AACA;;AACC;;AACA;AAFoB;A;AAIrB;;AACC;;AACA;AAFY;A;A;;;;;;;;;;AAUV;;;AAAH;;A;A;;;;;A;A;;;;;A;;;;;;;;AAOA;AACA;AACI;;;AACH;;A;AACC;;AACA;A;AAED;AACA;AACA;AAPsB;A;AASvB;AACA;AACA;A;;;;;;;AAmGA;AACA;;AACA;AACA;A;;;;;;;;AAIA;AACA;;AACA;AACA;A;;;;;;;AAIA;AACA;AACA;A;;;;;;;;AAKA;AACA;AACA;AACA;A;;;;;;;;;;AAKA;AACA;;;;AACA;AACA;A;;;;;AC1NA;AACA;AACA;A;AAEC;A;AAED;A;;;;AAKA;AACA;AAEA;A;AAEC;A;A;AAGA;A;AAGD;AACI;;;AACH;A;AAEK;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAVwB;A;A;;;;;AAiB1B;A;;;;;AAKA;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;AACA;A;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/OA;A;AAEC;A;AAED;A;;;;;;ACmBA;AACA;A;AAEC;A;AAED;A;;;;;AAKA;AACA;A;AAEC;A;AAED;A;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;;;AAKA;;;AACG;A;AACF;A;AAED;A;;;AAMA;A;;;;;A;A;;;;;A;AAUA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;AACC;AACA;A;AAEC;A;A;AAIF;AACA;AACA;AAEA;;AACC;AACA;A;AAEC;A;A;A;;;;;A;;;;A;AAcD;;;;;AACC;;;A;;AAED;A;AAGD;;;;;;AACC;AACA;AACA;AAEA;A;;AAED;A;;;;A;AAMC;;;;;AACC;;;A;;AAED;A;AAGD;;;;;;AACC;AACA;AACA;AAEA;A;;AAED;A;;;;A;AAMC;AACA;;;;;AACC;;;A;;AAED;A;AAGD;AACA;;;;;;AACC;AACA;AACA;A;;AAED;A;;;;A;AAKC;AACA;;;;;AACC;;;A;;AAED;A;AAGD;AACA;;;;;;AACC;AACA;AACA;A;;AAED;A;;;;AAIG;A;AACF;AACA;AACA;AACI;;;AACH;AACA;AACA;AAHsB;A;AAKvB;A;AAED;A;;;;AAIG;A;AACF;AACA;AACA;AACI;;;AACH;AACA;AACA;AAHoB;A;AAKrB;A;AAED;A;;;;AAIA;AACA;;;;;AACC;;;A;;AAED;A;;;;AAKA;;;;;AACC;;;AACA;;;AACA;A;;AAED;A;;;;AAIA;AACI;;;AACH;;;AAD4B;A;AAG7B;A;;;;;A;;;;A;;;;;A;;;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;AChOC;A;AAED;A;;;;;;A;AAqBC;AACA;AACA;A;A;AAOA;AACA;A;AAEC;A;AAED;AACA;A;A;AAKA;AACA;A;AAID;;AACA;AACA;AAGA;;AACC;A;AAED;A;AAIC;;AACC;AACA;A;AAED;A;A;;;;;;AASD;AACI;AACJ;;AACC;AACA;AACA;A;A;AAIA;AACA;A;AAED;;AACC;AACA;A;AAED;AAGA;AACA;AACA;;AACC;AACA;AACA;AACA;AACA;AACA;AACA;A;AAID;;AACC;AACA;AACA;AACA;AACA;A;AAED;AAGA;;AACC;AACA;AACA;AACA;A;AAGD;A;;;;A;AAKC;A;AAGG;A;AAIH;AACA;AACA;A;AAIA;AACA;AACA;A;AAIA;AACA;A;AAGD;A;;;;AAKA;;AACC;AADY;A;AAGb;A;;;A;AASC;A;AAGD;A;;;;A;AAQC;A;A;AAIA;A;AAEA;A;A;;;;;A;AAMA;A;AAKD;;AACC;A;A;AAKA;AACA;AACA;AACA;A;A;AAID;AACA;A;;;;;A;AAMC;A;AAED;AACA;A;;;;AAMA;AACA;;AACC;A;AAED;A;AAEC;A;A;;;;ACvLD;A;;;;;A;AAQC;A;AAED;;A;;;;;;;AAyEA;A;AAIC;A;AAGC;AACA;A;AAED;A;A;AAKA;A;AAED;AACA;AACA;;A;AACC;A;AAED;A;;;;;A;AAKC;A;AAED;A;;;;AAOA;AACA;AACA;A;;;;;AAMA;A;;;;;A;AAQC;A;AAED;A;;;;;AAKA;A;;;;;AAKA;A;;;;;;AAUA;;A;AACC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;;;;;AAmBA;;A;AACC;A;A;AAGA;A;AAED;;A;AACC;;A;AAEC;A;A;AAGF;A;;;;;;;A;AAMC;AACA;AACA;A;A;AAKA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;;;;AAmBA;;A;AACC;AACA;A;AAED;;A;AAEC;A;AAED;AACA;A;;;;;;AAKA;A;;;;;AAKA;A;;;;;;AAMA;;A;AACC;A;A;AAIA;A;A;AAIA;A;AAGD;A;;;;;;;A;AAOC;A;A;AAGA;A;AAED;A;AAEC;A;AAGD;;A;AACC;;;;;A;A;AAGA;A;A;;;;;;;;AAaD;;A;AACC;A;AAGD;A;AAGC;A;AAKD;AACA;A;AAGC;A;AAiBD;AACA;A;AAIC;A;AAED;AAGA;A;AAEC;AACA;A;AAID;AACA;A;AAOC;A;A;AAGC;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAMD;A;A;A;AAQG;AACA;A;AAED;AAEA;A;AAGA;A;A;A;AAMH;AAEA;;A;AACC;A;A;;;;;;;;A;AAMA;A;AAED;AACA;A;AAEC;AACA;A;AAGD;AACA;AACA;AACA;AACA;;A;AACC;A;AAED;A;;;;;;;AAOA;;A;;;;;;;AAOA;A;AAEC;A;AAID;;A;;;;;;;A;AAQC;A;A;AAGA;A;AAED;AACA;A;AAEC;AACA;A;A;AAGA;AACA;A;AAGD;AACA;;;AACA;AACA;AACA;;A;AACC;A;AAED;A;;;;;A;AAQC;A;AAED;A;AAEC;A;AAEC;A;A;AAGF;A;;;;;AAUA;A;AAEC;A;AAED;AACA;A;AAEC;AACA;A;AAGD;AACA;AACA;AACA;A;;;;;;;;;AAOA;;A;AACC;;A;AAEG;;;;AACJ;;AACA;;A;AAEC;A;AAED;;A;;;;;;AAQA;AACA;AACA;AACA;A;;;;;;AAUA;;A;AACC;A;AAED;AACA;;A;AACC;AACA;A;AAEC;AACA;A;AAED;;;A;AACC;A;A;AAEA;A;A;AAGF;A;;;;;;;AAOA;;A;AACC;A;A;AAGA;AACA;AACA;AACA;AACA;A;AAEC;AACA;A;A;AAGF;A;;;;;AAKA;A;AAEC;A;A;AAGA;A;A;A;AAIA;A;AAEA;A;AAED;A;;;AAKA;A;AAEC;A;A;AAGA;A;A;A;AAIA;A;AAEC;A;AAED;A;AAEA;A;AAED;A;;;;;AASA;;A;AACC;A;A;A;A;AAMC;A;A;AAKA;A;A;AAKA;A;AAEC;A;AAED;A;AAGD;A;AAGA;A;A;AAIC;A;AAED;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;A;AAMA;A;AAGC;A;A;AAOA;A;AAEC;A;A;AAGA;A;AAED;A;A;A;AAKC;A;AAED;A;AAGD;A;AAGA;A;A;AAIC;A;AAED;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAID;;;;A;AAcC;AAMA;A;AAGC;A;A;AAWM;AACJ;A;AAED;A;A;A;AAOC;A;AAED;A;A;AAME;AACJ;AACA;;AACA;A;A;AAQE;A;AAED;A;AAKG;;;;;;A;AAEH;A;A;AAUA;AACA;A;AAGA;AACA;A;AAGD;A;A;AAIK;AACJ;A;AAED;A;A;AAIC;A;AAED;A;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAID;;;;A;AAcC;AAMA;A;AAGC;A;A;AAWM;AACJ;A;AAED;A;A;A;AAOC;A;AAED;A;A;AAME;AACJ;AACA;;AACA;A;A;AAQE;A;AAED;A;AAKG;;;;;;A;AAEH;A;A;AAUA;AACA;A;AAGA;AACA;A;AAGD;A;A;AAIK;AACJ;A;AAED;A;A;AAIC;A;AAED;A;A;AAGD;A;;;;;;;;AAUA;;A;AACC;A;A;AAIA;A;A;A;AAMA;A;AAGC;A;AAMD;AACA;A;AAEC;A;A;AAIA;A;AAED;A;AAGC;A;AAIA;A;AAFA;A;AAID;A;AAGA;A;AAGA;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAIA;A;A;AAID;;;;A;AAEC;AAEA;AAEA;;;A;AACC;AACA;A;A;AAOA;AACA;AACA;AACA;;A;;AAPA;AACA;A;A;AAQD;A;AAGA;A;AAGA;A;A;AAGD;A;;;;;;;;AAMA;;AACA;AACA;A;;;;;;;AAMA;;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;A;AAGA;A;A;;;;;A;AAmBA;A;AAKD;AACA;AAEA;A;A;AAOE;AACA;A;AAEA;AACA;A;A;A;AAOA;AACA;A;AAEA;AACA;A;AAED;A;AATA;A;AAaD;A;;;;;;;;A;AAaC;A;AAGD;AACA;AAEA;A;A;AAKE;AACA;A;AAEA;AACA;A;A;A;AAOA;AACA;A;AAEA;AACA;A;AAED;A;AATA;A;A;AAcA;AACA;AACA;AACA;A;AAID;A;;;;;;;;A;AAQC;A;AASD;A;AAEC;A;AAEA;A;AAED;A;;;;;;;;A;AAQC;A;AAMD;AAGA;AACG;A;AAEF;AACA;A;AAQD;AAGI;AACJ;;;;AACA;AAMI;A;AAEH;A;AAGD;A;;;;;;;A;AAQC;A;A;AAKA;A;AAEA;A;AAKD;AACA;AACA;;AACK;;;;A;AAEH;AACA;A;A;AAGA;AACA;A;A;AAIA;A;AAEA;A;A;AAIF;A;;;;;;AA6BA;;A;AACC;AACA;A;A;AAIA;A;AAGD;;A;AAQC;AAEA;AACA;;A;AAGC;A;;AAIA;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;A;AAED;A;A;AAOA;AACA;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAGD;;A;AAGC;;A;AAKD;;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;;A;AAEC;AACA;AACA;;A;AAGC;A;;AAIA;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;A;AAED;A;A;AAOA;AACA;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAGD;;A;AAGC;;A;AAKD;;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;AAEA;;A;AAEC;AACA;A;AAGD;A;AAKC;AACA;AACA;A;A;AAMA;AACA;A;AAKD;AACA;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;AAEA;;A;AAEC;AACA;A;AAGD;A;AAKC;AACA;AACA;A;A;AAMA;AACA;A;AAKD;AACA;A;;;;;;;AAUA;;A;AACC;AACA;A;AAGD;AACA;A;AAGC;A;AAEA;A;A;A;AAOA;A;AAEA;A;AAGD;A;;;;;;AAYI;A;A;AAGH;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;;ACvqDG;;;;A;AACF;A;AAED;A;;;;;;;;;;AAQA;A;AAEC;A;AAID;AAGA;;;;A;AAEC;A;AAIG;AACJ;;;;;;A;AAEC;A;AAIG;AACA;AACJ;;;;;A;AAEC;A;A;AAKA;AACA;AACA;AACA;AACA;A;AAgBD;AACA;A;AAOC;A;A;AAGC;AAGA;A;AAAA;A;AAEA;A;AAEA;A;A;A;A;AAQD;AAGA;A;AAAA;A;AAEA;A;AAKD;;A;AACC;AACA;AACA;AACA;A;;AAEA;;AACA;A;AAGD;;A;AAEC;AACA;A;AAKD;;AACA;;A;AACC;;;;;A;;AAEA;;;;;A;AAGD;A;;;;;;;AA4CA;;A;AACC;;A;AAID;;AACA;AAIA;;;AAEA;;AACC;;A;AACC;;A;AAED;;AACA;A;AAGD;A;;;;;;;;;;A;AA2CC;AACA;A;A;AAGA;AACA;A;AAGD;AACG;;;;;A;AACF;A;AAIE;;;AAAH;;;A;AACC;;A;A;AAEA;A;AAGD;A;;;;;;;AAiBA;AACA;;;AACA;A;;;;;;A;AC9QC;A;AAID;AACA;A;AAGC;A;AAOC;A;AAGD;A;AAED;AAEA;AACA;A;AAEC;A;AAED;AACA;A;AAGC;AACA;A;AAGD;A;;;;;;A;AAUC;AACA;A;AAGD;;A;AACC;;A;AAGD;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;A;AAGC;AACA;A;AAGD;;A;AACC;AACA;;A;AAGD;A;;;;;;;;;A;A;;;;;A;AAUI;A;;;;;;A;;;;;;;AAUJ;;;AACA;;A;AACC;;A;AAED;A;;;;;;;AC3EA;A;AAEC;A;AAED;;A;;;;;;;AAMA;;A;;;;;;;;A;AAQC;A;A;A;AAMC;A;AAED;A;A;AAKD;;;A;AACC;;A;AAEA;;A;A;AASG;AACJ;;A;AAEC;A;AAID;AACA;;A;AACC;AACA;A;A;AAIC;A;AAEA;A;AAEA;A;A;;A;A;AAOA;A;AAGA;A;A;AAGC;A;AAED;A;A;A;A;AAOD;A;AAEA;A;AAGA;A;AAEC;A;A;AAOA;A;AAED;A;A;AAGE;A;AAED;A;A;AAGA;A;AAED;A;A;AAKA;A;AAED;A;;;;;;A;AAMC;A;AAcD;AACA;AACA;A;AAGC;A;AAEA;A;AAED;AAII;AACA;AACJ;AAGI;AACJ;AAKA;AAIA;;;;;;AACC;AACA;AAKA;AAIA;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;;A;;;;;AAQF;A;AAEC;A;AAED;A;AAIC;AACA;AACA;A;AAEC;AACA;A;AAED;;AACC;AADgB;A;A;AAMlB;AACI;A;AAEH;A;A;AAGA;AACA;A;AAEA;A;AAED;A;AAIC;A;AAED;A;;;A;AAOC;AACA;AACA;;AACC;AADgB;A;A;AAIjB;A;A;AAKA;AACI;;;AACH;AADqB;A;A;AAKvB;A;;;;;A;AAWC;A;A;AAIA;A;AAKD;AACO;A;AAEN;A;AAEA;A;AAGD;;;;AACA;AACA;A;AAEC;A;AAED;A;;;;;;;A;AAUC;A;A;AAIA;A;AAMD;AACA;AACA;;AACC;A;AAED;AAEA;AACA;;;;;AACA;A;AAEC;A;AAED;A;;;;;A;AAKC;A;AAED;A;;;;;AAeA;;;;A;AAEC;A;A;AAID;;;;;A;A;A;AAIC;A;A;AAGA;A;AAIC;A;A;A;A;AAAA;A;A;;AAGD;;;;;;AACA;A;A;AAEG;AACJ;;A;AAEC;A;AAIG;AAEJ;;;;;;;A;AACC;AACA;A;A;AAGA;AACA;;;A;AACC;A;AAED;A;A;AAEA;A;A;AAEA;A;A;AAGG;AACD;;;;A;AACF;A;AAID;;;;;A;AAEC;AACA;AACA;;A;A;AAGA;AACA;;AACA;A;;AAGA;AACA;AACA;;A;A;A;;;;;;;A;ACnaA;A;A;AAGA;A;AAED;A;;;;;AAKA;A;AAEC;AACA;A;AAED;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;AAKA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AASA;A;;;;;AASA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;A;AAIC;A;A;AAKC;A;AAEA;AACA;A;A;AAGF;AACA;A;;;;;AAKA;A;AAIC;A;A;AAKC;A;AAEA;AACA;A;A;AAGF;AACA;A;;;;;A;AAUC;AACA;AACA;A;AAED;AACA;AACA;A;;;;;A;AASC;A;AAEA;A;AAID;A;AAEC;AACA;;;;A;AAGD;AACA;AACA;A;;;;;;;;A;AAOC;A;AAEG;;;;AACJ;AACA;AACA;;A;;;;;;;AAOA;;;AACA;AACA;A;;;;;;;AAOA;;;AACA;AACA;A;;;;;;;AAgBA;;;;AACA;;;;AACA;A;;;;;;;;AAOA;AACI;AACJ;;A;A;AAGE;A;AAEA;A;A;AAGF;A;;;;;;;AAOA;A;AAEC;A;AAEG;AACJ;;A;A;AAGE;A;AAEA;A;A;AAGF;A;;;;;;;AAmBA;A;AAEC;A;AAED;;A;A;AAGE;AACA;A;AAEA;AACA;A;A;AAGF;A;;;;;;;A;AAgBC;A;AAEC;A;A;AAGD;A;AAEA;A;AAED;A;;;;;AAUA;A;;;;A;AAMC;A;AAED;A;;;A;AAMC;A;AAED;A;AAEC;A;AAED;A;;;;AAMA;A;AAEC;A;AAED;A;;;;;AAMA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AAKA;A;;;;;;AAmBA;;A;;;;;;;AAMG;;;A;AACF;A;AAGE;;;A;AACF;A;AAED;A;;;;;;AAMA;AACA;AACA;A;;;;;AAKA;AACA;A;;;;;AAMA;A;;;;;;AAUA;AACA;;A;A;AAEE;A;AAGD;;A;AAED;AAEI;A;AAEH;A;AAGD;;AACA;A;AAGC;AACA;A;AAGD;A;;;;;;;A;AASC;A;AAEC;A;A;AAGA;A;AAED;A;AAGD;;A;;;;;;;;;;AAeI;;;;;;;;AAEJ;AACA;AAGA;AACA;A;AAIC;A;AAEA;A;AAEA;A;AAQD;AAEA;;;;;;AACA;;;;;;AAMA;;AACC;;;;AACA;;;;AACA;;;;;;AACA;;;;;;AACA;A;AAED;A;;;AAYA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;A;;;;AAMA;;;;AAEA;;;;;;A;AAIC;AACA;AACA;AACA;A;A;;;;;;;AAeG;;;;;;;;AAEJ;AACA;AAEA;A;AAIC;AACA;A;AAID;AACA;AACA;AACA;A;AAIC;;;;AACA;;;;A;AAID;;AAEC;;;;;;AAGA;;A;AAIC;A;AAKC;A;A;;AAMD;A;A;AAIF;;A;AAEC;;A;AAEC;A;A;AAIA;;;;A;AAEK;;;;;;;;AACJ;;;;AACA;;;;AACA;AACA;;AACC;;;;AACA;;;;AACA;;;;AACA;;;;AACA;A;AAGD;AACA;AACA;AACA;AAEA;AACA;AAEA;A;AAEA;;AACC;;;;A;A;AAGF;A;A;A;AAKD;A;AAGD;;A;AAEC;AACA;AACA;;A;AAGD;AAEA;A;;;;;;;AAQA;A;AAEC;AACA;A;AAED;;AACA;A;;;;;;;;A;AAUK;AACJ;A;AAED;;A;AACK;AACJ;;A;AAEG;;;;AACJ;;A;AAIC;A;A;AAMA;A;AAEA;A;AAED;A;;;;;;;;;AAMA;;A;AACC;;A;AAOG;;;;;;AACJ;AACA;AACA;A;A;AAIE;A;AAED;A;AAGD;A;AAEE;A;A;AAGA;A;AAED;;A;AAEC;A;AAKD;A;AAEC;A;AAEC;A;A;AAGF;A;AAIC;A;AAED;AACA;A;A;;;;;;;;AAWD;AACA;AACA;;AACA;A;;;;;;;AAYA;AACA;AACA;;AACA;AACA;;AACA;AACA;;AACA;AACA;AACA;;AACA;AACA;;AACA;A;;;;;;;;;;;;;AAOI;AACJ;AACA;AACA;AAGI;AACJ;AACA;;;AACC;A;AAOG;;;;;;;;AACJ;AACA;AACA;;AACA;;AACA;;AACA;AACA;AAEK;AACJ;AACA;;AACC;;AACA;A;A;AAIA;A;AAGD;;AAEA;;AACA;;AACA;;AACA;A;A;;;;;;;;A;;A;AAWA;A;AAEA;A;AAEA;A;A;AAED;;A;AACC;;A;AAID;;;A;AAEC;;A;AAGA;;A;AAGA;;A;A;A;;;;;;;AAMD;AACA;AACA;A;;;;;A;AAOC;AACA;AACA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;A;A;AASE;A;AAED;A;A;AAGA;A;A;AAGA;AACA;A;AAGD;A;;;;;A;AASC;A;A;AAGA;AACA;AACA;AACA;AACA;A;AAED;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;AAOC;AACA;AACA;A;AAID;AACA;AACA;A;;;;;;A;AAOC;A;AAED;AACA;;AACA;A;;;;;;;A;ACpmCC;A;AAED;;A;;;;;;;A;AAOC;A;AAED;;;;A;;;;;;;AAIA;;A;;;;;;AAKA;;A;AACC;AACA;;AACC;;AADgB;A;A;A;;;;;;;AAqBd;A;AAEJ;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAGA;;;;;;AACA;A;A;AAGD;;A;AACC;;AACA;A;AAID;AAEA;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAID;AACA;;;A;A;A;AAGE;A;AAEA;A;AAEA;A;A;AAIF;;A;AAGC;;;;;;A;AAEE;A;A;;A;AAMC;AACA;AACA;AAGJ;;;;A;A;AAIE;A;AAEA;A;A;AAKF;AACG;;;;AAAH;;A;AACQ;AACP;;;;;A;AAEC;A;A;AAGA;A;;AAGA;A;A;A;AAKF;AACA;AACA;AACA;AACA;;AACA;A;;;;;;;;AAgBA;;;;A;AAEC;A;AAID;;;;;A;AAEC;A;AAED;AAEA;A;;;;;;;;AAII;AACD;;;;A;A;;;;;A;A;AAIH;;;A;AACC;A;A;A;;AAIA;;A;A;AAED;A;;;;;;AAUA;;;;;AACA;;A;AACC;;A;AAED;A;;;;;;;AAIA;;A;;;;;;;AASA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;AAED;;;AACA;A;;;;;;A;AClOC;A;AAED;AACA;AACA;A;AAEC;A;AAED;AACA;A;;;;;;A;AAOC;AACA;A;AAED;AACA;;A;AACC;;A;AAED;AACA;AACA;A;;;;;;;;;A;A;;;;;A;A;;;;;;A;;;;;;;AAaG;;;AAAH;;A;AACC;;A;AAED;A;;;;;;;AASA;;A;;;;;;;A;AAOC;A;AAED;;A;;;;;;ACnCA;;;;;AACC;A;;A;;;;;AAKD;AACA;;AACC;A;AAED;A;;;;;A;AAKC;A;A;AAIA;A;AAKD;A;;;;;A;AAKC;A;AAED;AACA;AACA;A;;;;;AAKG;A;AACF;A;AAGD;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;AAIA;AACA;A;AAIC;A;AAGA;A;AAGA;A;AAID;AACA;A;AAEC;A;AAED;AAEA;A;;;;;AAIA;AACA;A;AAIC;A;AAGA;A;AAGA;A;AAID;AACA;A;AAEC;A;A;AAGA;A;AAGD;A;;;;;;AAIA;AACA;A;A;AAIE;A;AAEA;A;AAED;A;AAGD;AACA;;AACC;A;A;AAKA;A;AAEA;A;AAED;A;;;;;AAIA;A;AAEC;A;AAID;AACA;AAEA;A;;;;AAMA;AACA;;;;;;A;AAEE;A;A;;A;;;;A;AAoBD;A;AAED;AACA;AACI;AACA;;;AACH;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAXiB;A;A;AAelB;A;AAEA;A;AAED;A;;;;AAMG;A;AACF;A;A;;;AAME;A;AACF;A;A;;;AAcD;A;AAMC;AACA;A;AA4BD;AACA;;;;AACA;;;;AAYA;AACA;AAGA;AACA;A;AAEC;AACA;A;AAID;A;AAEC;AACA;A;AAKD;AACA;AAIA;AACA;AAUA;AACA;A;AAEC;A;AAEA;A;A;;;AAUD;A;;;AAOG;A;AACC;A;AACF;A;AAEC;A;A;A;A;;;A;AAQF;A;AAED;A;;;AAQA;AACA;;AACC;AACA;A;AAED;A;;;;AAIA;AACA;A;AAIC;A;AAEA;A;AAEA;A;A;AAMA;A;A;AAKA;AACA;AACA;A;AAUD;AAIA;AACA;AACA;AACA;AACA;AACA;A;AAgBK;AAGJ;AACA;AACA;AACA;AAGA;AACI;;;AACH;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;AATuB;A;A;AAazB;A;;;;AAQA;AACA;AACA;;;AACI;;;AACH;AAEA;;;AAEA;AALkB;A;AAOnB;AACA;A;;;AASA;A;AAGC;AACA;A;AAGD;AACA;;;;AAEA;AACA;AAGA;A;AAEC;A;AAGD;AACA;AAEA;AACA;AAEA;AACA;AACA;A;;;;AAWA;A;AAGC;A;AAEA;AACA;AACA;;;AACA;A;A;AAIA;A;A;AAIA;AACA;AACA;A;A;AAGA;AACA;AACA;A;AAQD;AAEA;AACA;AACA;AACA;AACA;A;AAGK;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGD;A;;;;;A;AASC;A;AAEA;A;AAEA;A;AAEA;A;AAED;AACA;A;;;;;;;AAKA;A;AAGC;A;AAEA;AACA;A;AAEA;AACA;A;AAGD;AACA;AACA;AACA;A;;;;;;;;A;AAKC;A;A;AAIA;AACA;AACA;A;A;AAII;AACJ;;;AACA;AACA;A;AAGD;;;;AACA;A;;;;;;AAMI;AACD;;A;AACF;A;A;AAGA;A;AAED;AACA;A;;;;AAIA;A;;;;;;;AAaA;AACA;AAGA;AAEA;;AACA;AACA;AAGA;AACA;A;AAIC;A;AAED;AAEA;;AACA;AAGA;AACI;;;AAEH;AACG;A;AACE;AACJ;;;AAGA;AACA;;;AAEA;AACA;;AACC;AACA;AACA;A;AAGC;A;AAED;;;A;A;AAKF;AAEA;A;AAEC;A;AACA;AACA;A;AAGD;AAlCmB;A;AAqCpB;AACA;AAEA;AACA;AACA;A;;;;;A;;;;;;AAOG;A;AACF;A;AAED;A;;;;;A;AAOC;A;AAEG;AACJ;;AACC;A;AAGD;A;;;;AAIA;A;;;;A;A;AAOE;A;A;AAGA;A;A;AAIF;A;AAEC;A;AAID;AACA;AACA;AACA;AAEA;A;;;;;A;A;AAOE;A;A;AAGA;A;A;AAIF;AACA;A;AAEC;A;AAID;AACA;AAEA;A;;;;;AAIA;AACA;AACA;A;A;AAGC;AACA;A;AAGC;A;AAED;AACA;A;A;AAGC;AACA;A;AAEA;A;AAED;AACA;AAEA;A;AAED;A;;;;;AAKA;A;AAEC;A;AAGD;A;;;;;AAMA;A;A;AAGE;A;AAED;A;AAGD;;;;;A;AAEE;A;A;;A;AAID;A;AAED;A;;;;;AAIA;AACA;A;AAEC;A;AAID;AACI;;;AACH;AADkB;A;AAInB;A;;;;;AAIA;AACA;A;AAEC;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;;AAIA;AACA;AACA;A;AAEC;;;;AACA;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;;AAIA;AACA;AACA;A;AAEC;;;;AACA;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;AAKA;A;;;;;AAMI;AACJ;A;;A;;;;;;A;AAQC;A;AAED;AAEA;A;AAEC;A;AAED;AAEA;A;AAEC;;;A;AACC;;;;;AACC;;A;;A;A;AAGD;;;;;AACC;;A;;A;;AAGD;A;A;A;AAED;A;AAEC;A;A;AAIF;A;;;;;;;A;AAQC;A;A;AAKA;A;A;AAMA;A;AAKD;;A;AACC;;;AACA;A;A;AAMA;A;AAED;AAOA;;A;AACC;;A;AACC;;A;AAED;;A;AAGD;AACA;AACA;AACI;AAQJ;AAGI;;;;AACA;;;AACH;AACA;;;;A;AAGC;AACA;;;;A;AAGD;;A;AACC;;;;AACA;;;;;;;;A;AAGD;AAdkB;A;AAiBf;;;AACH;AAEI;;;AACH;AACA;;;;A;AAGC;AACA;;;;A;AAGD;;A;AACC;;;;AACA;;;;;;;;A;AAGD;AAdmB;A;AAHQ;A;AAqB7B;A;;;;;;;AAOI;;;;AAIA;AACJ;AACA;AACI;;;AACH;;;;;;AACA;AACA;;;;AACA;;;;AACA;AACA;;;;AACA;;;;AAPqB;A;AAUtB;AAEI;;;AACH;AACI;;;AACH;;A;AAIC;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;A;AAGD;AACA;;;;AACA;;;;AACA;;;;AAEA;AA/BmB;A;AAFQ;A;AAqC7B;A;;;;;;;AAMA;AAIA;;A;AACC;;;A;A;AAIA;AACA;AACA;A;AAMD;AACA;AACI;;;AACH;AACA;AAFmB;A;AAIpB;AAGA;AACA;AACA;;;A;AAEC;AACA;AACA;A;AAGD;AACA;AAII;AACJ;AACA;AACI;;;AACH;AADqB;A;AAKtB;AACA;AAEA;AAGI;;;AACH;AACI;;;A;AAEF;AACA;AACA;AACA;A;AAED;AACA;;;;AACA;AATmB;A;AAFQ;A;AAe7B;AAIA;;A;AAQC;AACA;;A;AACC;;;A;A;AAIF;A;;;;;;;AAQA;AACA;;;;;AACK;;;AACH;AACA;AACA;AAHmB;A;A;;AAOrB;;AACC;A;AAGD;A;;;;A;AAMC;A;AAED;A;;;;AAMA;AAEA;AACI;;;AACH;AACA;AAFoB;A;A;AAKhB;AACA;;;AACH;AACA;AAFwB;A;AAIzB;A;AAGD;A;;;;;;A;AAMC;A;A;AAGA;A;AAQG;;;;AACJ;AACA;AACA;AACI;;AACH;;;AACA;AACA;A;A;AAKE;A;AAED;A;AAED;;;;AAZa;A;A;;;;;;;;ACryCd;;;;AACI;;;AAEH;AACA;A;AAGD;A;;;;AAQA;AACA;;A;AAEE;A;AAED;AACA;A;AAED;A;;;;;;;;;AAyCA;AAGA;;A;AACC;;A;AAID;;;;A;AAEC;A;AAID;AACA;;A;AAEC;AACA;;A;AACC;AACO;;;;A;AACP;;;A;A;AAGE;A;A;A;AAIA;A;AAEA;A;A;AAGD;;;A;AACC;AACG;;;;A;AAEF;A;A;A;AAGD;A;A;A;A;AAID;AACA;AACA;A;AAGA;A;A;A;A;AASH;AACA;AACA;;;AACA;AACA;AACA;AACA;AACC;;A;AACC;AACA;AAEG;;;;A;A;AAED;AACA;A;AAED;A;A;AAKE;A;AAGH;A;AAEA;A;A;AAGC;A;AAEA;A;A;AAGD;A;AAED;;A;AACC;;AACA;A;AAED;AAGA;AACA;A;AAIC;AACA;AACA;A;AAIE;;;;A;A;AAED;AACA;A;AAED;A;A;A;A;AAUA;AACA;A;AAGA;A;AAED;A;A;AAMA;A;AAED;A;AAKC;A;AAGD;A;;;;;;;AAMA;;A;;;;;;;A;AAMC;A;A;AAKA;A;AAKD;A;AAEC;A;AAED;AAGG;AAAH;;A;AAEC;AACA;AACA;AACA;AAGI;;;AAEH;;AACC;AACA;AACA;AACA;A;A;AAMA;AACA;A;AAGA;AACA;AACA;AAGA;AACA;A;AAtBsB;A;AA2BxB;;AACC;AACA;AACA;A;A;;AAID;;;AAIA;;AAGA;AAGA;AAKA;AACA;;AACC;A;A;A;AAKD;AACA;A;AAGD;A;;;;;;;AAqBA;;A;AAEK;AACJ;AACA;;AAEC;AACA;AACA;;AACC;A;A;AAGA;A;AAEC;A;A;AAKF;;;;AAGA;AACA;AACA;A;A;AAKF;AACI;A;AAGH;;AAEC;;;AACI;;;AACH;AAIA;AACA;AACA;AAPiC;A;A;A;AAWnC;;AAEC;;;AACI;;;AACH;AACA;AACA;AAHiC;A;A;A;AASpC;;AACC;AACA;A;A;;;;;;;;AAuBD;;A;;;;;;A;AAOC;A;AAID;AACI;;;AACH;AADkE;A;AAK/D;A;AAEH;AACA;A;AAEA;A;AAID;;A;AAEK;AACA;;;AACH;;A;AACC;;A;AACC;;AACA;A;;AAEA;AACA;A;AAID;AACA;;AACC;AACA;A;AAGD;A;AAjBiB;A;A;A;AAuBnB;A;AAGD;A;;;;;;A;ACjdC;A;A;AAGA;A;AAQD;A;AAEC;A;A;AAIA;A;AAMG;;;;A;A;AAGH;AACA;A;AAEA;AACA;AACA;A;AAEA;A;A;AAKA;A;AAGD;;;;;A;;;;;;;AASA;AAEA;AACA;AAEA;AACA;AAEI;;;;;;AACJ;AAGI;;;AACH;;A;AACC;A;;AAEA;;AACA;A;AAED;;AACA;;A;AARqB;A;A;AAWjB;;;AACH;AACA;;;;A;AAboB;A;A;A;AAkBnB;A;AAPuB;A;AAUzB;A;AAGD;A;;;;;;;A;AA8BC;A;A;AAKA;A;AAUD;AACA;AACA;AACA;AACA;AACA;AACC;;A;AAGC;;A;AAED;AACA;;A;AAEC;A;A;AAQA;A;AAED;;A;AAIC;;AACA;A;AAEC;A;A;AA1BK;A;AA2CR;AACA;AACA;AACA;AA8BA;AACA;AACA;AACA;AACI;;;AACH;;A;AAGC;AACA;AACA;AACA;;;;AAEA;AACA;AACA;;;;A;;AAIA;AACA;AACA;AACA;;;;AAEA;AACA;AACA;;;;A;AAtBgC;A;AA2BlC;;A;AAQC;AACA;A;AAEC;;;;A;AAED;AACA;AACA;AACA;AACA;;;;A;AAEC;A;A;AAKE;;;A;AAEF;A;A;AAKA;A;AAID;AACA;AACA;;;;AAboB;A;AAerB;A;;;;;;;ACxRA;AACA;AACA;A;A;AAGC;A;AAEA;A;AAEA;AACA;A;AAGD;AAGA;;AACC;AACA;A;AAGD;AACA;AACA;A;AAEC;A;AAEA;A;AAED;;A;;;;;;;;AAyBA;A;A;;;;;A;AAIA;A;AAEC;A;AASD;AACI;;;;AACJ;AACA;AACG;A;AACF;A;AAEA;A;AAMG;AACJ;;;;AACA;AACA;A;A;AAME;A;AAED;AACA;A;AAED;;A;AACC;;A;A;AAMA;AACA;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAEI;A;AAEF;AACA;A;A;A;AAIH;AAEA;A;AAEC;A;AAED;A;;;;;;;AAyBA;A;A;;;;;A;AAIA;A;AAEC;A;AASD;AACI;;;;AACJ;AACA;AACG;A;AACF;A;AAEA;A;AAMG;AACJ;;;;AACA;AACA;A;A;AAME;A;AAED;AACA;A;AAED;;A;AACC;;A;A;AAMA;AACA;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAEI;A;AAEF;AACA;A;A;A;AAIH;AAEA;A;AAEC;A;AAED;A;;;;;;;;AAQA;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;;;AAQA;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;AAKA;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;;A;;;;;;;AAKA;A;AAEC;A;A;AAGA;AACA;A;AAED;AACA;;A;;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAMC;A;AAED;AACA;A;AAEC;A;AAED;A;AAEC;A;AAED;;;;AACA;A;;;;;AAUA;A;;;;;AAKA;A;;;;;AAQA;A;;;;;AAOA;A;AAEC;A;AAED;A;;;;;;AAKA;;;;A;AAEC;AACA;A;A;A;A;AAKA;A;;AAEA;AACA;AACA;AACG;;AAAH;;A;AACC;;;AACA;;;A;AAGC;A;A;AAGF;A;A;AAED;A;;;;;A;AASC;A;AAEA;A;AAED;A;;;AAMI;A;AAEH;A;AAED;AACA;AACA;A;;;;AAUA;A;;;;;;AAKA;AACA;AACA;AACA;AACA;;A;;;;;;;AAKA;AACA;AACA;AACA;AACA;;A;;;;;;;A;AAOC;AACA;AACA;AACA;A;AAED;AACA;AACA;;A;;;;;;;A;AAOC;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;;;;;ACzfA;A;;;;;AASA;;;;A;AAEC;A;A;AAGA;A;AAEE;;;A;AACF;A;AAED;A;;;;;;;A;AAUC;A;AAKE;AAAH;;A;AACI;;;A;AACF;A;AAED;AACI;AACD;;;;A;AACF;A;AAGE;;A;AACF;A;A;AAGA;A;AAED;;A;AAID;AAGA;;;;A;AAEC;A;AAKG;AACJ;;;;;A;AAEC;A;AAIG;AACJ;;;;A;AAEC;A;AAIE;;A;AACF;A;A;AAKA;A;A;AAMA;A;AAID;A;AAEC;A;AAED;;AAGA;;A;AACC;AACA;;A;;AAEA;AACA;A;AAGD;AAEA;A;;;;;;;;;AAcA;AAEI;AACD;;;;A;A;AAED;A;AAED;A;A;AAID;;;A;A;A;A;AAIE;AACA;A;AAID;;AACA;A;AADA;;AACA;A;A;AAGG;AACD;;;;A;AACF;A;AAGG;A;AAEH;A;AAMG;;AACA;;;;A;A;AAED;A;AAED;AACA;A;AAED;;A;AACC;;A;AACC;;AACA;;AACA;A;AAED;A;AAED;AAhBa;A;AAoBd;;;AACA;A;;;;;;AAKA;;A;;;;;;;AAKI;AACJ;;AACA;AACA;;A;AACC;;A;;AAEA;A;AAED;A;;;;;;;AAMA;;A;AACC;;A;AAED;;A;;;;;;;AAOI;AAEJ;;A;AACC;;A;AAEC;AACI;;;AACH;AADqB;A;A;AAIvB;A;AAID;;;;AAEA;AACA;;A;AACC;;A;AAGD;AACA;;;;AAGA;A;AAEC;A;AAEC;AACA;A;A;A;AAKD;A;AAED;;;;AAEA;;A;AACC;AACA;;AACI;;;AACH;AAD+B;A;AAGhC;A;AAGD;A;;;;;;A;ACtQC;A;AAED;AACA;AACA;AACA;A;AAGC;A;AAED;AACA;AACA;A;AAEC;A;AAED;AACA;A;;;;;;A;AAOC;AACA;A;AAED;AACA;;A;AACC;;A;AAGD;AACA;AACA;AACA;AACA;A;;;;;;;;;AAKA;;A;A;;;;;A;A;;;;;;A;;;;;;;AASG;;;AAAH;;A;AACC;;A;AAED;A;;;;;;A;AC7DC;A;AAED;A;;;;;;ACOA;;A;AACC;A;A;AAIA;A;AAGD;;;A;AAEC;A;A;AAKA;AACA;AACA;AACA;A;AAMD;AACA;;AACA;A;A;A;AAUC;A;AAEA;A;AAWD;;A;AACC;A;;AAEA;A;AAID;;A;;;;;;;;;AAcA;AACA;;;AACC;AACA;;AACA;;AACA;AACA;;A;;AAGD;;;AACA;;AAGA;;;A;AACC;A;A;AAEA;AACA;;AAGA;AACA;;A;;AADA;AACA;;A;A;AAGD;;A;;;;;;;;;;;AAaA;AACA;AACA;;;AACC;AACA;AACA;;AACA;;AACA;;AACA;;AACA;AACA;;A;;AAID;;;AACA;AACA;;AACI;;;AACH;AACA;;A;AAKD;;A;;;;;;AAMA;AAEA;AACA;A;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5IA;A;AAEC;A;AAED;A;;;;;AAIA;;AACC;A;AAEC;AACA;A;AAEA;AACA;A;A;A;;;;;A;AAOD;A;A;AAGA;A;AAGD;AACA;AACC;A;AAEC;A;AAED;A;AAGD;A;AAEC;A;AAEA;A;AAED;A;;;;AAgBI;AACJ;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;A;A;AASC;A;AAEA;A;A;AAGC;A;AAEG;AACJ;;;;;AACC;A;AAEC;A;AAEA;A;A;;AAGF;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;AACA;AACA;AACA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEG;AACJ;;;;;;A;AAEE;A;AAEA;A;A;;AAGF;A;AAEI;AACJ;;;;;AACC;A;;AAED;A;AAED;A;;;;;AAKA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;A;AAGC;A;AAED;A;;;;;A;AAMC;A;AAKD;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAGD;AACA;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;;AAIA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;AACA;A;AAGC;A;AAED;AACA;A;AAKC;A;AAEA;A;AAEA;A;AAGD;A;;;;;A;AC7QC;AACA;A;AAEA;A;AAEA;A;A;;;;;ACFD;A;;;;;AA2BA;A;;;;;AAwCA;A;AAEC;AACA;A;AAEA;A;AAED;AACA;A;;;;;AAIA;AACA;A;;;;;A;A;AAUE;A;AAED;AACA;AACA;A;A;AAWC;A;AAID;AACA;AACA;A;AAGA;A;AAGD;AACA;A;;;;;AAaA;A;AAEC;A;AAGD;AACA;A;AAEC;A;AAID;A;AAIC;AACA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;AAKA;AACA;A;AAEC;A;AAED;AACA;AACA;A;;;;A;AAMC;A;AAED;AACA;AACI;;;A;AAEF;A;AAFsC;;AAKxC;A;;;;AAMA;A;;;;;AAMA;AACA;AACA;A;;;;;AAQA;A;A;AAGE;AACA;A;A;AAMA;A;A;AAGF;A;AAEC;A;AAED;A;AAEC;A;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGC;A;AAGD;A;;;;A;AAcC;A;AAEC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;AAGF;;;;;A;AAEE;A;A;;AAGF;A;;;;;AAKA;AAGA;AACA;;AACC;A;AAED;AACA;A;AAIC;A;AAGD;;;A;;;;;;;AAOA;AACA;;AACC;A;AAED;AACA;AAIA;;A;AACC;A;A;AAMA;A;AAGD;;;A;;;;;;A;AAMA;;A;AACC;;A;AAEC;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;AAKA;A;A;A;A;;;;;;;A;AAWD;A;AAED;AACA;AACA;;;;;A;AAEE;AACA;A;AAEA;A;A;;AAGF;;A;AACC;;A;AAEC;AACA;AACA;A;A;AAGF;A;;;;;;;A;AAgBC;A;AAIG;AACA;AACJ;AACA;AACI;;;AAOC;AACA;AACJ;;A;AACC;;;A;AAEC;AACA;;AACC;A;A;AAKA;AAnBuB;A;A;A;A;AA8B1B;;;A;A;A;AAIC;A;;AAGA;AACA;AACA;AAEI;;;AACH;AADsB;A;AAGvB;;AAEA;AACA;AACA;A;AAID;AACA;AACA;AAtD0B;A;AAwD3B;AAUA;AACA;AACI;AACA;;;AAMC;AACJ;;A;AACC;A;AARyB;A;A;A;AAoB1B;;;A;A;A;AAIC;A;;AAGA;AACI;;;AACH;AACA;AAFsB;A;AAIvB;;AAEA;AACA;AACA;A;AAID;AACA;AAzC0B;A;AA2C3B;AAGA;AACA;AACI;;;AAOH;;A;AAP0B;A;A;AAa1B;;;A;A;A;AAGC;A;;AAIA;AACI;;;A;AAEF;A;AAFyB;A;AAK3B;;;;AAEI;;;AACH;AACA;AAF0B;A;AAI3B;AACA;A;A;AAKA;A;AAED;AAxC0B;A;AA0C3B;AAGA;AACA;AACA;;;;;A;AAEE;;A;AAED;A;;AAED;AAEA;A;;;;;;A;AAOC;A;A;AAGA;A;AAED;A;;;;;A;AASC;AACA;AACA;A;AAEC;A;A;AAIC;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;A;A;AAGF;A;A;AAIA;A;AAEC;A;A;AAGF;A;;;;;A;AAOC;A;A;AAGA;A;AAEC;A;AAED;A;AAED;A;;;;;A;A;AASE;A;AAED;A;A;AAGC;AACA;A;AAEA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;AAIA;AACA;AACA;AACA;;;;;;A;AAGE;AACA;A;AAED;A;;AAED;A;;;;A;AAWI;A;AACF;A;AAED;A;AAKA;AACA;AACA;AACA;AACA;AAED;AACA;AACA;AACA;;AACC;A;AASA;;;;;;;;;;;A;A;AAGK;;;A;AACF;A;AAED;A;AAED;AACA;AACA;A;A;AAEG;;A;AACF;A;AAED;A;A;AAEG;;A;AACF;A;AAED;A;A;A;AAGC;A;AAEA;A;AAED;A;A;A;A;A;A;AAKC;A;AAED;A;A;A;AAGC;A;AAEA;A;AAED;A;A;AAEG;;;;A;AACF;A;A;A;AAGD;A;A;AAGC;A;AAEA;A;AAEA;A;AAED;AACG;;;A;AACF;A;AAED;AACA;A;A;AAEA;AACA;AACA;;;;;A;AAGC;AACA;AACA;A;A;AAIA;A;AAEE;;;A;AACF;A;AAED;AACA;A;A;A;A;A;AAKE;AACA;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;AACA;A;AAGA;A;AAGI;AACD;A;AACF;AACA;A;AAEA;AACA;A;AAED;;AACC;;;;A;AAEC;A;AAED;AACA;A;AAED;A;AAEA;AACA;AACA;A;A;AAIF;AACA;AAGA;;A;AACC;;;;;A;AAEC;A;A;AAGA;AACA;AACA;AACA;A;A;AAKC;;;;A;AACF;AACA;AACA;AACA;A;AAED;AAGG;;;;A;AACF;A;AAED;A;;AAhKG;;;;A;AACF;A;AAED;A;A;AA+JD;A;AAGD;;AACA;;;A;AAEC;A;AAED;;AAEA;A;AAEC;A;AAED;A;;;;;;;;;;A;AAQC;A;AAED;AACI;AACD;;;;A;AACF;A;A;AAGA;A;A;AAGA;A;AAEA;A;AAEC;A;A;AAGA;A;AACS;;;;A;AACT;A;AAGA;A;A;A;A;AAID;A;AAED;AACA;AACA;A;;;;;;;AAOA;A;AAmBC;A;AAEI;A;A;;;;;A;A;;;;;A;AAMJ;AACA;AACG;A;A;;;;;A;A;A;;;;;A;AAQH;AACA;AACA;AACA;A;;;;;A;AAKG;AACJ;AACA;AACA;AACA;AAEA;;;AACI;;;;A;A;;;;;A;A;A;AASF;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;AAKC;A;AAED;AAGA;AACA;A;A;A;AAME;A;AAED;A;A;AAIA;A;AAED;A;;;;;A;AAvCA;A;A;A;;;;;A;;;;A;AAsDD;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;A;AAMC;A;A;AAIA;A;AAED;AACA;;AACC;A;AAED;AACA;AAEA;AACI;;;A;AAGF;AACA;A;AAED;AANuB;A;AAQxB;A;;;;AAMA;A;;;A;A;AAUC;A;AAEI;;;A;AAEF;A;AAF4B;A;AAK9B;A;AAEA;A;AAEA;A;AAED;A;;;;;AAKA;;AAMA;;;A;AACC;A;AAGD;A;;;;;AAOA;A;A;A;A;AAME;A;A;A;AAKA;A;AAEA;A;A;A;AAKA;A;AAED;AACA;AACA;A;A;A;;;;;AAUD;A;AAEC;AACA;A;AAGC;;;;AACA;A;AAED;AACA;AACA;AACA;A;AAGD;;A;AACC;AACA;AACA;;A;AACC;;A;AAGC;A;AAED;AACA;AACA;A;A;AAGF;A;;;;;;;AAKA;;AACA;;;A;AAEC;A;AAED;;AAEA;A;AAEC;A;AAED;AACA;AACA;A;AAEC;A;AAGD;A;AAGC;A;AAEA;AACA;AACA;AACA;A;AAED;A;;;;;;;;;AAMA;A;A;;;;;;;A;AAIA;;;;A;A;;;;;;;A;AAMA;;A;A;A;AAcE;A;AAKD;AACI;;;A;AAEF;A;AAED;AACA;AALkB;A;A;;;;;;;A;AADnB;AACI;;;A;AAEF;A;AAED;AACA;AALkB;A;A;;;;;;;A;A;AAYlB;A;AAEE;;;;A;A;;;;;;;A;A;AAQF;AACA;AACA;A;AAEE;A;AAEE;;;;A;A;;;;;;;A;A;AAIF;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAED;A;A;AAGA;A;A;;;;;;;A;AAMF;AACG;;;;A;A;;;;;;;A;AAGH;A;AAEC;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;;;;;;;;A;A;;;;;;;A;A;A;;;;;A;A;;;;;A;;;;;;;;A;AAoDD;A;AAED;A;AAEC;A;A;;;;;;A;;;;;;;;;;A;AAUA;A;AAGD;A;AAEC;A;AAED;AACA;;;;AACA;A;A;;;;;;;A;A;;;;;;;;A;;;;;;;AAQA;;A;A;AAEE;A;AAEA;A;A;;AAGD;AACA;AACA;AACA;;A;AAEC;A;AAEA;A;A;AAGF;A;;;;;A;AAaC;A;AAEE;A;AACF;A;AAEE;A;AACF;A;AAED;A;;;;;;;;A;AAQC;A;AAID;A;AAEC;A;AAED;AACA;;;;A;AAEC;A;AAEG;;;;A;AAGH;AACA;A;AAGA;A;AAEI;A;AACF;A;A;;;;;;;A;AAIF;;;;AACA;AACG;A;AACF;A;A;A;AAMD;AACA;A;AAGD;;;A;A;;;;;;;A;AAKA;;A;A;AAEE;A;AAEA;A;A;;AAMD;AACA;AACA;AACA;AACA;;A;AAEC;A;AAEA;A;A;A;;;;;;;A;;;;;;;;;AASF;AACA;AACA;AACA;AAEA;A;AAEC;AACA;A;AAKC;A;A;AAIF;AACA;AACA;;A;AAIE;;A;;;;;A;AAGD;AAGA;;A;AACC;;;;;A;A;;;;;A;A;AAKC;;;;AACA;A;A;AAKF;;;;;A;A;;;;;A;AAIA;;A;AACC;;;;AACA;A;AAIE;;;;A;AACF;;;;AACA;A;AAID;AACI;;;;AACD;;;;A;A;;;;;A;AAGH;A;AAGC;AACG;;;;A;A;;;;;A;A;AAIF;A;;;;;A;A;A;AAKD;A;AAEA;A;A;AAGF;AAGA;AACA;;A;AAEC;A;AAED;AACA;A;;;;;A;;;;;;AASA;AAEA;A;AAEC;A;AAID;AACI;;;AACH;;;;A;A;AAIE;A;AALqB;A;A;AAUvB;AACA;AACA;AAZuB;A;AAexB;A;;;;A;AAMC;A;AAED;A;;;AASA;AACI;;;A;AAEF;;;;A;A;AAGE;A;A;AAGA;A;AAED;A;A;AAViB;A;AAepB;A;;;A;AAgBC;A;A;AAIA;A;A;AAIA;AACA;A;A;AAIA;AACA;A;AAIG;;;AACH;AACA;AACA;;AACC;AACA;A;AALoB;A;AAQtB;A;;;AAMI;;;AACH;AADuB;A;AAGxB;A;;;AAKI;;;AACH;AADuB;A;AAGxB;A;;;AAMA;AACI;;;AACH;;;;A;AAEC;A;AAED;AALuB;A;A;AAQvB;A;AAED;A;;;AAKA;;;;;AACC;;;;;;A;AAEC;AACA;;A;AAEG;;;AACH;AADqB;A;A;;AAIvB;;;;;AACC;;;;;;A;AAEC;AACA;;A;AAEG;;;AACH;AADqB;A;A;;AAIvB;A;;;AAKA;AACA;;;;;AACC;;;;;;A;A;AAGE;A;AAED;AACA;;A;AAEG;;;A;AAEF;A;AAED;AAJqB;A;A;;AAOvB;;;;;AACC;;;;;;A;A;AAGE;A;AAED;AACA;;A;AAEG;;;A;AAEF;A;AAED;AAJqB;A;A;;A;AAQtB;A;AAED;A;;;AAMA;AACA;AACI;;;AACH;;;;A;AAEC;AACA;AACA;A;AAED;AAPuB;A;AASxB;A;AAIC;A;AAED;A;;;;AAYA;AACA;AACA;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;AACA;;;;;;;;A;;;;AAIA;;AACC;;;A;AAEC;A;AAED;A;AAED;A;;;;;;AAIA;;;A;A;;;;;;;A;A;;;;;;;A;;;AAQA;A;;;A;AAKC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;A;ACn0DC;A;AAED;A;;;;AAkDA;A;;;;;AAYI;AACJ;AACA;A;;;;;AAKA;AACA;;AACC;A;AAED;A;;;;;AAKA;A;A;AAGC;A;AAED;A;;;;;;;AAOA;A;A;;;;;A;AAQI;AACJ;;AACC;AACA;A;A;;;;;A;;;;;AAQG;AACJ;AACA;AAEA;;A;A;AAGE;A;AAEA;A;A;AAIA;A;AAED;AACA;A;AAED;A;;;;;AAQA;A;;;;;AASA;A;A;AAIC;A;AAIA;A;AAEC;A;A;AAGI;;;A;AAEF;A;AAF0C;;A;AAM7C;A;A;AAIC;A;AAED;A;AAKI;;;A;AAEF;A;A;AAGA;A;AALyB;A;AAQ3B;A;AAID;AACA;AACA;;AACC;AACG;A;A;AAED;A;AAED;A;AAEA;A;A;AAGF;A;;;;;A;A;AASC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAII;AACJ;AACA;A;;;;AAIA;;;;;AACC;A;;A;;;AAKD;;;;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;A;;A;;;AAKD;A;;;A;A;AAMC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIC;A;AAED;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;A;A;;;;A;ACvRA;A;A;AAGA;A;A;A;A;AAMC;A;A;A;AAKA;A;AAED;;;;;;A;AAEE;A;A;;A;A;AAMD;A;AAED;;;;;;A;AAEE;A;A;;A;A;AAMD;A;A;A;AAKA;A;A;A;AAKA;A;A;AAGF;A;;;;AAKA;A;A;AAIC;A;AAEA;A;A;AAGC;A;AAED;;;;;AACC;A;;A;AAGA;A;A;A;AAIA;AACA;A;AAED;A;AAEC;A;AAIA;AACI;;;AACH;;;;AACA;A;AAEC;AACA;A;AAL8B;A;A;AAS5B;;;AACH;;;;AACA;A;AAEC;AACA;A;AAL4B;A;A;AAS/B;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;A;AAGD;A;AAEA;A;A;AAGC;AACA;AACA;A;AAEA;A;A;AAGA;A;AAED;A;AAEG;A;AACF;AACA;AACA;A;AAEA;A;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEC;A;AAEC;A;A;AAGF;A;A;AAGA;A;A;AAGD;;;;;A;AAEE;AACA;AACA;A;AAEA;A;A;;A;AAIF;;;;;;A;AAEE;A;AAED;A;;A;AA1HD;A;A;A;;;;AAgIG;AACJ;AACA;A;;;;A;A;AAQE;A;AAED;AACA;A;AAGD;A;A;AAEC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;AACA;A;AAEC;A;AAED;AACA;A;AAED;AACA;AACA;A;A;A;;;;AAMD;A;AAEC;A;AAED;;;;;AACI;A;AACF;A;A;;AAGF;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAKC;A;AAED;;;;;AACC;A;;A;;;;;A;AC9SA;A;A;A;AAKA;AACA;;;;;;AACC;A;AAGC;AACA;AACA;AACA;A;A;AAGA;A;A;;AAGF;A;AAGA;AACA;A;A;AAMC;A;AAID;A;A;AAME;A;A;AAKA;A;AAID;AACA;AACI;;;AACH;AADyB;A;AAG1B;AACA;A;A;AAOA;A;AAQG;A;AAEH;AACA;AACI;;;AACH;AADuB;A;A;A;AAOxB;AACI;;;AACH;AACA;AACA;AAHgC;A;A;AAMhC;A;AAED;A;A;AAGA;A;AAKD;A;AAGD;A;;;;A;AAsBC;A;A;AAIA;A;A;AAGA;A;AAGD;AACA;AACA;A;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpGA;;;;A;AAEC;A;AAED;A;;;;AAIA;AACA;A;;;A;AAOC;A;AAED;A;;;AAMA;A;;;;AAOA;A;AAGC;A;AAEA;A;AAGD;A;AAEC;A;AAEA;AACA;;;;;AACC;A;;A;A;AAKD;A;AAEA;A;AAED;;;;;AACC;A;;A;AAIA;A;AAEA;A;AAED;;;;;AACC;A;;A;;;;;AAOD;A;AAEC;A;A;AAED;AACA;A;;;;;A;AASC;A;A;;;;;;AAMD;AAEA;AACA;;AACC;AAEA;AACA;AACA;AACA;AASA;AACD;A;AAEE;A;AAEF;AAEC;A;AAKA;;;;;;;;;;;;A;AACC;A;A;AAUA;;A;AAEC;AACA;AACA;A;;AAEA;AACA;AACA;A;A;A;A;AAMD;;A;AAEC;AACA;AACA;AACA;A;A;AAGD;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;A;AAEC;AACA;A;;A;AAIC;AACA;A;AAED;AACA;A;A;A;AAID;;AACA;;A;AACC;A;AAED;AACA;A;A;AAGA;AACA;A;A;A;AAMC;A;A;AAOA;A;AAEE;A;AACF;A;A;AAKA;A;A;AAKA;A;AAID;A;;AAjIA;A;A;A;AAqIF;A;;;;;;;AAKA;A;AAEC;A;A;AAIA;A;AAGD;;AACA;;;AACA;AAGA;;A;A;AAEE;A;AAED;;;A;AACC;AACA;A;A;;AAUD;AACA;;AACC;;A;AAEC;;A;AAEC;AACA;A;AAED;A;A;AAIA;A;AAED;;;A;AAEC;A;AAED;;;AAlB+B;A;AAoBhC;AACA;A;AAGF;AACC;AACA;AACA;A;;;;;;ACrTA;AACA;A;;;;;AAIA;AACA;A;;;;;AAIA;AACA;AACA;AACA;A;;;;;A;AAOC;A;AAEA;A;AAEA;A;A;;;;;A;AAMA;A;A;AAGA;A;AAED;A;;;;;AAIA;;;;;AACC;A;;AAED;A;;;;;AAMI;AACD;A;AACF;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;AAWA;A;;;;A;AAKC;A;AAED;A;A;AAGE;A;AAED;A;A;A;AAIC;A;AAED;A;A;AAGA;A;AAED;A;A;AAGE;A;AAED;A;A;A;AAIC;A;AAED;A;A;AAGA;A;A;AAGA;A;AAEA;A;AAED;A;;;;;;;AAOA;A;AAEC;A;AAED;AACA;;;;;AACC;A;;AAED;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;A;AACC;;;;A;AAEG;AACJ;;A;AACC;A;;AAEA;;A;AAED;AACC;;A;A;AAGE;A;A;AAIA;A;AAED;;;;;A;AAEC;;A;AAEC;A;AAED;AACA;;;;AACA;;;;A;A;A;A;AAKA;A;AAED;A;AAED;AACA;A;AAEC;A;A;AAKA;A;AAED;AACA;;;;AACA;;A;AACC;;;;A;AAED;;;;A;AAED;AACA;A;;;;;;AAKA;;;;;A;AAEE;A;A;;AAGF;A;;;;;AASA;AACI;;;AACH;AACA;A;AAFgC;A;A;A;AAO/B;AAP+B;A;A;AAUhC;AACA;A;A;A;AAOE;AACA;A;A;AAIA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;AAGA;A;AAEA;A;AAEA;A;AAEA;A;AAzBA;A;A;AA4BA;A;A;AAGA;A;AA7C+B;A;AAgDjC;A;;;;;;AAQD;A;AAEE;A;AAEE;A;AACF;A;AAGD;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAIA;;;;;;;A;A;A;AAGC;AACA;AACA;A;A;AAEA;;A;AACC;AACA;A;A;A;AAGD;AACA;A;A;AAEA;;A;AACC;AACA;AACA;AACA;A;;AAEA;AACA;A;A;A;A;AAIA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;AAnCA;A;A;AAqCD;A;;;;;;AAWA;;;;A;AAEC;A;AAED;A;;;;AAIA;AACA;A;;;;;;AAKA;A;AAEC;A;AAGD;;A;AAEC;A;AAEA;A;AAGD;AACA;;;;;AACC;A;;AAGD;;AAEA;;;;AACA;;;;AACA;;;;AACA;;A;AACC;;;;A;AAEG;AACJ;;A;AACC;A;;AAEA;;A;AAED;AACA;AAEA;;;;;A;AAGC;;;A;AACC;A;AAED;AACA;;;;AACA;;;;AACA;;AACA;A;AAED;AACC;AACA;A;AAIA;;;;;;;;;;;A;AACC;A;AAEC;AACA;A;AAED;A;A;AAEA;;A;AACC;A;A;A;AAGD;;A;AACC;A;A;A;A;A;AAKD;;A;AACC;A;A;A;AAID;AACA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;AACC;A;AAED;A;A;A;AAGC;A;AAED;A;;AAvCA;A;A;A;AA0CA;A;AAED;AACA;AACA;;;;AACA;;A;AACC;;;;A;A;AAIH;A;AAEE;AACA;A;AAGD;AACA;AACA;A;;;;;;;AAKA;;A;;;;;;;A;AAUC;A;AAGD;;A;AACC;;A;AAED;;A;AACC;;A;AAGD;;AACA;;AAEA;AACA;;;A;AACC;AACA;A;AAGD;AACA;AACA;A;;;;;;;;ACxfA;A;A;;;;;;;A;AAIA;AACA;AACA;;AACC;AACA;A;A;A;;;;;;;A;AAQG;AACJ;;AACC;AACA;;;;A;A;AAKA;A;A;;;;;;;A;;;AAUD;A;AAEC;A;A;AAGA;A;AAED;A;;;AAIA;A;A;AAGC;A;AAED;A;;;;AAWA;A;;;;;;AAIA;AACA;AACA;A;;;;;AAIA;AACA;A;;;;;A;AAKC;A;AAED;A;;;;;A;AAKC;A;A;;;;;A;AAMA;A;AAED;AACA;AACA;A;;;;;A;;A;;;;;;;;;;AAuBA;AACA;A;AAEC;A;AAGA;;;;AAED;AACA;AACA;AACA;A;AAEE;AACA;A;A;AAIF;AACA;;A;AAEE;A;AAED;A;AAEA;AACA;AACA;A;AAGD;;AAEC;;;;A;AACC;;A;A;AAEA;;A;A;AAEA;;A;;AAEA;;A;A;A;AAGA;A;A;AAGF;A;;;;AAKA;;;;;;A;A;A;AAIE;A;AAEA;AACA;A;A;;A;;;AAOF;AAKA;;;;;;AACC;A;;AAQD;;;;;A;A;AAME;AACA;AAEA;A;AAEC;;;;AACA;A;AAEC;;A;A;AAGF;A;AAIC;;A;AAID;AACA;AACA;A;AAEC;A;AAEA;AACA;;;;A;A;AAGA;A;A;AAMA;A;A;AAtCD;;A;A;;AA0CF;A;;;;AAMwC;A;;;;;AACA;A;;;;;AACA;;;;A;;;;;;;;;;A;AAavC;A;AAIA;AACA;AACA;AACA;AAKD;;;;AACC;AACA;A;AAEC;A;AAED;A;AAEA;;;;;;;;;A;AACC;;;;;AAEA;AACA;A;AAEC;AACA;A;A;AAIA;;;;AACA;;;;A;A;AAGA;AACA;A;AAID;;;;A;AAGC;AACA;A;A;A;AAGD;;AACA;AAEA;AACA;AACA;;;;;AACC;A;;A;A;AAGD;;AACA;AACA;AACA;AACA;;;;;AACC;A;;A;A;AAGD;A;A;AAEA;A;AAEC;A;AAED;A;AAEC;AACA;AACA;A;AAED;AACA;;A;AACC;AACA;AACI;;;AACH;AAD2C;;AAG5C;A;;AAEA;A;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;A;AAEA;A;AAEC;A;AAED;AACA;AAEA;;A;AACC;AACA;AACI;;;AACH;AAD2C;;AAG5C;A;;AAEA;A;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;A;AAEA;A;AAEC;A;AAED;AACA;AACA;A;A;AAEA;A;AAEC;A;AAED;AACA;AACA;AACA;;;;;AACC;A;;A;A;AAGF;A;;AAGD;AACA;AACA;AACA;;AACC;AACA;AACA;;;A;AACC;AACA;A;A;A;AAID;;;;;AACC;A;;A;AAGF;A;;;;;;A;A;;A;A;A;;A;AAiBA;;;;;AACC;A;A;A;A;;A;A;A;A;AAaG;;A;A;;A;A;A;;A;A;;AAQJ;AAGA;;A;AAGC;A;A;;A;;;;;AC/YD;A;;;;;AAYA;AACA;A;;;;;AAcA;;A;;;;;;AAiCA;A;;;;;AAIA;;;;A;AAEC;A;AAED;AACA;AAEA;AACA;;;A;AAEC;A;AAED;A;AAEC;A;AAED;;A;AAWC;;;AACA;A;AAEA;;;;A;A;AAKA;AACA;;A;AAGD;AACA;AACA;;AACC;A;AAED;AAEA;A;;;;;;AAkBA;;;;A;AAEC;A;AAED;AACA;A;AAEC;AACA;;;;;AACC;A;;A;AAMF;A;AAEC;A;A;AAGA;AACA;A;AAED;A;;;;;;AAKA;AACA;AACA;AACA;A;;;;;AAOA;;;;AACA;;A;AACC;;A;AAED;A;;;;;A;AAgBC;A;AAED;A;;;;AAKA;A;;;;;AASA;A;;;;;A;AAsBC;A;AAEC;A;AAED;A;AAED;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;;A;AAGC;A;AAEC;;A;A;A;AAKD;A;AAEC;;A;A;AAGF;A;;;;;A;AAUC;A;AAEC;A;AAED;A;AAED;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;;A;AAGC;A;AAEC;;A;A;A;AAKD;A;AAEC;;A;A;AAGF;A;;;;;;A;AAYC;A;AAGD;;;;;A;AAEC;AACA;A;AAED;AACA;A;;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;;;A;;;;;A;;;;;;AAaA;;A;;;;;;;AAMA;;A;;;;;;;AAMA;;A;;;;;;;;;;AAwCA;A;AAEC;A;AAED;;AACC;A;;AAED;A;;;;;;;;AAOA;;AACC;A;;A;;;;;;;;;AASD;;;AACC;;;;A;;;AAED;A;;;;;;;AAIA;AACA;AACI;AACA;A;AAEH;A;AAEA;A;A;AAGA;A;AAGG;AACJ;;AACC;;A;AAEC;A;A;AAKA;A;AAEA;A;AAOD;;A;AACC;;A;AAED;AAGI;A;AAEH;;A;AAEA;;A;A;AAGA;A;AAIA;A;AAEA;A;A;A;AAMD;A;AAEA;A;AAGD;A;;;;;;;;;;;AAOA;A;AAEC;A;AAED;AACA;;A;AAEE;A;AAED;A;;AAED;A;;;;;;;;AAOA;;AACC;A;;A;;;;;;;;;AASD;;;AACC;;;;A;;;A;;;;;AAaD;;;;;A;AACC;A;;A;;;;A;AA0CA;A;AAED;AACA;;AACC;A;AAED;A;;;;;;AAOI;A;AAEH;A;AAEA;A;AAGG;;;;;;;;AACH;;A;AAEC;A;AAGD;A;A;AAME;A;AAEG;A;AAGH;;A;AAEA;;A;A;AAGA;A;AAEA;A;A;AAGD;A;AAED;AAEA;;A;AACC;AACA;A;A;A;;;;;;;;AAQE;AACJ;;A;AAEC;A;AAED;A;;;;;;;;AAQA;;A;A;;A;A;;A;;;;;;;AAaI;AACJ;;A;AAEC;A;AAED;A;;;;;;;;AAQA;;A;A;;A;A;;A;;;;;;;;AAaA;;A;A;;A;A;;A;;;;;;;AAaI;AACJ;;A;AAEC;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;AAqBA;A;;;;;AAOA;A;;;;;AAIA;;AACC;A;AAEC;A;AAED;AACA;A;AAGC;AACA;AACA;A;AAED;;;;;A;AAGC;AACA;AACA;A;AAED;A;A;A;AAIG;A;AAEA;A;A;A;AAIF;;;;;;A;A;AAGG;A;AAEA;A;AAED;A;A;;A;A;AAKJ;AACA;A;;;;;;;;A;AAOC;A;AAED;A;AAEC;AACA;A;AAEA;A;AAED;AACA;;AACC;;;A;AAEC;A;AAED;A;A;AAIA;A;AAED;A;A;AAIE;A;AAED;A;AAID;AACI;;;A;AAEF;AACA;A;AAED;AAL0B;A;A;AAS1B;A;AAGD;AACA;AACA;A;;;;;AASA;;;A;;;;;;;AASI;AACJ;;A;AAEC;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;AASA;;;A;;;;;;;AASA;;;A;;;;;;;;;A;AAWC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;;;;;;;;A;AAUC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;A;AAqBC;A;A;AAIA;A;AAGD;;AACA;AAEA;AACA;AACA;;;;;A;AAEE;A;AAGD;A;AAEC;A;AAED;A;;A;AAIA;A;AAGD;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;;;;;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnrCA;A;;;;AAIA;A;;;;;AAKA;AAGA;;AAEA;A;;;;;;AAIA;AAGA;A;AAIC;A;AAGD;AACA;AAEA;;A;;;;;;AAIA;;A;;;;;;;AAIA;AACA;AACA;A;AAIC;A;AAID;AACA;;AAGA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;A;;;;;;;AAIA;;AACA;AACA;AACA;AAGA;;AAEC;AACA;;AAGA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;A;AAGD;;A;;;;;;;AAIA;;A;;;;;;A;AAKC;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAED;A;;;;;;AAKA;;AAGA;;AAGA;AACA;;AAGA;AACA;;AAGA;;AACA;;AAGA;AAEA;AAEA;;AAEA;;AAEA;;AAGA;AACA;AACA;AACA;;;;;A;AAEC;A;AAID;;;;A;AAEC;A;AAID;AAGA;;AAGA;AACA;AAEA;AAEA;AACA;AAEA;AACA;;AAGA;AACA;AAGA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAGA;AACA;AAEA;AACA;;A;;;;;;;AAIA;AACA;;AAEA;;AACC;;A;AACC;;A;AAEC;A;A;AAGF;;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIA;AACA;;AAEA;AACA;;AACC;;A;AACC;;A;AAEC;A;A;AAGF;;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIA;;;;A;AAEC;A;AAID;AAGA;AACA;AAGA;AACA;AACA;AACA;;AACA;AAEA;;A;;;;;;;AAKA;;AAGA;AAEA;AAGA;;AAGA;AAEA;AAEA;;AAEA;AAEA;;AAGA;AACA;AACA;AACA;;;;;A;AAEC;A;AAID;;;;A;AAEC;A;AAID;AAGA;;AAGA;AACA;AAEA;AAEA;AACA;AAEA;AACA;;AAGA;AACA;AAGA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAGA;AACA;AAEA;AAEA;;A;;;;;;;AAMA;;AACA;AACA;AAEA;AACA;AACA;AAEA;A;;;;;;;AAIA;;AACA;;AAEA;A;;;;;;AC1WA;AACA;AAEA;AACA;AACA;AACA;;AACC;AACA;;AACA;AACA;AACA;A;AAGD;A;;;;;;AAOA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;;;AACA;AAEA;AAGA;AACC;AAEA;;;;;AAIC;;;AAEA;;AACC;AACA;A;A;;AAIF;;;;;;AACC;AACA;;;;;A;AACC;A;A;;AAKF;AACA;A;A;;;;;;;;ACnEG;AACJ;;;A;AAGC;A;AAGD;A;;;;A;ACPC;A;AAED;AACA;;;;;AACC;A;;AAED;AACA;A;;;A;AAKC;A;AAEC;A;AAGD;AACA;AACA;A;A;AAOA;AACA;AACA;A;AAGC;A;AAED;;;;;AACC;A;;A;AAGA;A;AAGD;AACA;AACA;AACA;A;AAED;A;;;A;AAKC;A;AAED;AACA;A;AAEK;;;AACH;AADuB;A;A;AAIzB;AACA;A;;;;;;;AC5DA;AACA;AAGA;AACA;AACA;AACA;A;AAKC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAID;;AAEC;AACA;AACA;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;A;;;;;;;A;;;;;;A;A;;A;A;A;;A;A;;;A;;;;;;;;AAgCD;;;;AAGA;AACA;AACA;;;;A;A;;;;;;;A;AAWA;AACA;;AACA;;A;;;;;;;A;;;;;ACvFA;AAEI;;;A;AAEE;;;AACH;AADyB;A;A;AAF+B;A;AAQ3D;AACI;;;A;AAEF;A;AAFoB;A;AAMtB;A;;;A;AAMC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;AAII;AACA;;;AACH;;;A;AACC;A;AAFmB;A;AAMjB;AACJ;AAEA;;A;AACC;A;;AAEA;A;A;;;;;;AAKD;A;;;;;AC3CA;AACA;AACA;A;AAGC;A;AAOD;AACA;AAGA;AAEA;A;;;;AAIA;AAEA;AACA;AACA;AACA;;;;;AAEK;;;AACH;;A;AAEC;A;AAH4C;A;AAO9C;AACA;AAEA;A;AAEC;A;A;A;;AAKF;A;;;;;AAIA;;A;;;;;;AAIA;AAEA;;AACA;;AAEA;;;;AAEA;;A;AACC;A;AAEA;;;A;A;;;;;;;AAKD;AAEA;AAEA;;AACA;;AACA;;;AACA;;;AAEA;;A;;;;;;AAKI;AAEJ;AACA;AACA;AACC;AACA;AACA;AACA;AAEA;;AACA;AAEA;;;A;AACC;A;AAED;A;A;;;;;;AASD;AACA;;AACA;;A;;;;;AAMI;AACJ;AAGA;AAEI;;;AAEH;AACA;;A;AAEC;A;AAID;AACI;;;AACH;AAD+B;A;AAK5B;;;AACH;;A;AADwD;A;A;AAMxD;;;AACA;;A;AAEC;A;AATuD;A;AAcrD;;;AACH;AAEI;;;AAEH;;A;AAEC;A;AAJ0D;A;AAS5D;;A;AAEC;A;AAED;;A;AAEC;A;AAlBwD;A;AAuBtD;;;AACH;AAEI;;;AAEH;;A;AAEC;A;AAJwD;A;AAQ1D;;A;AAEC;A;AAED;;A;AAEC;A;AAjBwD;A;AApDnC;A;AA0ExB;A;;;;;AAMA;;AAGA;;AAEA;;AAEA;;AAEA;A;;;;;;;AAIA;;;AAEA;AACA;AAEI;;;AACH;AAD4B;A;AAI7B;AAEA;;A;A;;;;;A;AAMA;AAEA;;AAEA;;A;;;;;A;;;;;AAOA;;AAGA;;AAEA;;AAEA;;AAEA;;A;AAEC;A;AAGD;;A;AAEC;A;AAGD;;AACA;;;;;A;AACC;A;AAEA;A;A;;;;;;AAKD;AAGA;;AAGA;AAGA;;AACA;;AAEA;;A;;;;;AC5RA;A;;;;;AAUA;A;;;;;;;AAMA;AAEA;;;;AAEA;AACA;AAEA;;;A;A;;;AAIA;A;;;;;;;;AAMA;;A;;;;;;AAKA;A;;;;;AAKA;A;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;AClDA;A;;;;;;AAMA;AACA;AAGA;A;AAEC;A;A;A;AAIC;A;AAKC;A;AAED;A;;;;;A;A;AAMC;A;AACC;A;AACF;A;;;;;A;A;A;;;;;A;;;;;;;A;A;A;A;;A;A;;;;;;;;;;;;;;;;;;;;;;ACiIF;A;;AAIA;A;;AAIA;A;;;AAIA;A;;;;A;A;AAMC;A;AAEA;A;AAED;A;;AAoHA;A;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;ACjSC;A;AAEA;A;AAEA;A;A;;;AAkBD;AAoBA;AACA;AACA;AAEA;;AACC;AACA;AAEA;;;;;AACC;AACA;AACA;A;AAGC;A;A;;AAMF;AACA;AACA;A;AAKD;A;;;AAQA;AACA;AACA;AACA;A;;;AAgBA;AAEA;AAgCA;AACA;AACA;AAEA;;AACC;AACA;AAEA;;;;;AACC;AACA;AACA;A;AAGC;A;A;;A;AAKD;A;AAGD;AACA;AACA;AACA;AACA;AACA;A;AAGG;AACJ;AACA;A;;;AAcA;AACA;AAEG;A;AACF;A;AAEC;A;AAED;AACA;AACA;A;AAGD;A;;;;AClJA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAMA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;A;AAEC;A;AAED;AACA;A;;;;;AAIA;;;A;AAEC;A;AAED;AACA;A;;;;;A;AAOC;A;AAED;A;;;;;;AAOA;;;;;A;A;AAEC;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;A;;;;;;;A;A;AAOA;AACA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;A;AAOA;A;AAGD;AACA;AAEA;AAEG;A;AACF;A;AAGD;A;;;;AAIA;A;;;AAIA;A;;;;;;A;;;;;A;;;;;;;;AAsBA;AAEA;;;AACA;AAEA;A;AAGC;AACA;A;AAGD;AACA;AACA;A;;;;;AAqBI;A;AAGH;A;AAGD;AACA;A;;;;;AA+DA;AAEA;AACA;AACA;A;AAGC;A;AAGD;A;;;;;AAKA;AAEA;AACA;AACA;A;AAGC;A;AAGD;A;;;;;AC9UA;;;;A;AAEC;A;AAED;A;;;;;;;AAII;AAED;;;;A;AACF;A;AAGD;AACA;A;;;;;;;AAII;AAED;;;A;AACF;A;AAGD;AACA;A;;;;;;AASA;;;;AACA;;;;AACA;A;;;;;AC7CA;A;;;AAIA;A;;;AAIA;A;;;;AAuBA;A;;;;;;AAsDA;;A;;;;;;AAsBA;AACA;AACA;AACA;AAEA;AAEA;AACA;A;;;;AAIA;AACA;AACA;AACA;AAEA;AAEA;AACA;A;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;;A;;A;;A;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpHA;;;;A;AAEC;A;AAED;A;;;;;;;AAYA;;;;A;AAEC;A;AAED;A;;;;;;;AAIA;;A;;;;;;;AAIA;;;;A;AAEC;A;AAED;;AACA;A;;;;;;;AAIA;AACA;;A;;;;;;;AAIA;AACA;AACA;;AACA;AACA;A;;;;;;AAIA;;;;A;AAEC;A;AAED;A;;;;;AAMC;AACA;AAED;AACA;AACI;;;AACH;AAD8B;A;AAG/B;A;;;;;;;A;A;A;A;A;;;;;;;;;;;;;;AC/EA;A;;;;A;A;A;A;A;A"} diff --git a/ticket/js/main.go b/ticket/js/main.go new file mode 100644 index 0000000..26df307 --- /dev/null +++ b/ticket/js/main.go @@ -0,0 +1,12 @@ +package main + +import ( + "github.com/bonedaddy/vcaptcha/ticket" + "github.com/gopherjs/gopherjs/js" +) + +func main() { + js.Global.Set("ticket", map[string]interface{}{ + "New": ticket.NewTicket, + }) +} From 8b9e0cbbc89d27fc42239a57cc5dbe6f245e53ef Mon Sep 17 00:00:00 2001 From: postables Date: Wed, 2 Sep 2020 23:41:56 -0700 Subject: [PATCH 2/3] chore: add gopherjs implementation --- README.md | 2 + ticket/js/index.js | 7 + ticket/js/js.js | 44958 +----------------------------------------- ticket/js/js.js.map | 2 +- ticket/js/main.go | 12 +- 5 files changed, 72 insertions(+), 44909 deletions(-) create mode 100644 ticket/js/index.js diff --git a/README.md b/README.md index 09598cf..7f3511f 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,8 @@ go1.12.16 download export GOPHERJS_GOROOT="$(go1.12.16 env GOROOT)" # Also add this line to your .profile or equivalent. ``` +Build with `gopherjs build -m` + # future improvements * each captcha can be used by at most one session diff --git a/ticket/js/index.js b/ticket/js/index.js new file mode 100644 index 0000000..99a467b --- /dev/null +++ b/ticket/js/index.js @@ -0,0 +1,7 @@ +require("./js.js"); + +var main = global.ticket; + +var vdftick = main.New(1); + +vdftick.Solve(); \ No newline at end of file diff --git a/ticket/js/js.js b/ticket/js/js.js index a1b46ed..6647904 100644 --- a/ticket/js/js.js +++ b/ticket/js/js.js @@ -1,44913 +1,57 @@ "use strict"; (function() { -Error.stackTraceLimit = Infinity; - -var $global, $module; -if (typeof window !== "undefined") { /* web page */ - $global = window; -} else if (typeof self !== "undefined") { /* web worker */ - $global = self; -} else if (typeof global !== "undefined") { /* Node.js */ - $global = global; - $global.require = require; -} else { /* others (e.g. Nashorn) */ - $global = this; -} - -if ($global === undefined || $global.Array === undefined) { - throw new Error("no global object found"); -} -if (typeof module !== "undefined") { - $module = module; -} - -var $packages = {}, $idCounter = 0; -var $keys = function(m) { return m ? Object.keys(m) : []; }; -var $flushConsole = function() {}; -var $throwRuntimeError; /* set by package "runtime" */ -var $throwNilPointerError = function() { $throwRuntimeError("invalid memory address or nil pointer dereference"); }; -var $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); }; -var $makeFunc = function(fn) { return function() { return $externalize(fn(this, new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))), $emptyInterface); }; }; -var $unused = function(v) {}; - -var $mapArray = function(array, f) { - var newArray = new array.constructor(array.length); - for (var i = 0; i < array.length; i++) { - newArray[i] = f(array[i]); - } - return newArray; -}; - -var $methodVal = function(recv, name) { - var vals = recv.$methodVals || {}; - recv.$methodVals = vals; /* noop for primitives */ - var f = vals[name]; - if (f !== undefined) { - return f; - } - var method = recv[name]; - f = function() { - $stackDepthOffset--; - try { - return method.apply(recv, arguments); - } finally { - $stackDepthOffset++; - } - }; - vals[name] = f; - return f; -}; - -var $methodExpr = function(typ, name) { - var method = typ.prototype[name]; - if (method.$expr === undefined) { - method.$expr = function() { - $stackDepthOffset--; - try { - if (typ.wrapped) { - arguments[0] = new typ(arguments[0]); - } - return Function.call.apply(method, arguments); - } finally { - $stackDepthOffset++; - } - }; - } - return method.$expr; -}; - -var $ifaceMethodExprs = {}; -var $ifaceMethodExpr = function(name) { - var expr = $ifaceMethodExprs["$" + name]; - if (expr === undefined) { - expr = $ifaceMethodExprs["$" + name] = function() { - $stackDepthOffset--; - try { - return Function.call.apply(arguments[0][name], arguments); - } finally { - $stackDepthOffset++; - } - }; - } - return expr; -}; - -var $subslice = function(slice, low, high, max) { - if (high === undefined) { - high = slice.$length; - } - if (max === undefined) { - max = slice.$capacity; - } - if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) { - $throwRuntimeError("slice bounds out of range"); - } - if (slice === slice.constructor.nil) { - return slice; - } - var s = new slice.constructor(slice.$array); - s.$offset = slice.$offset + low; - s.$length = high - low; - s.$capacity = max - low; - return s; -}; - -var $substring = function(str, low, high) { - if (low < 0 || high < low || high > str.length) { - $throwRuntimeError("slice bounds out of range"); - } - return str.substring(low, high); -}; - -var $sliceToArray = function(slice) { - if (slice.$array.constructor !== Array) { - return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length); - } - return slice.$array.slice(slice.$offset, slice.$offset + slice.$length); -}; - -var $decodeRune = function(str, pos) { - var c0 = str.charCodeAt(pos); - - if (c0 < 0x80) { - return [c0, 1]; - } - - if (c0 !== c0 || c0 < 0xC0) { - return [0xFFFD, 1]; - } - - var c1 = str.charCodeAt(pos + 1); - if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) { - return [0xFFFD, 1]; - } - - if (c0 < 0xE0) { - var r = (c0 & 0x1F) << 6 | (c1 & 0x3F); - if (r <= 0x7F) { - return [0xFFFD, 1]; - } - return [r, 2]; - } - - var c2 = str.charCodeAt(pos + 2); - if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) { - return [0xFFFD, 1]; - } - - if (c0 < 0xF0) { - var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F); - if (r <= 0x7FF) { - return [0xFFFD, 1]; - } - if (0xD800 <= r && r <= 0xDFFF) { - return [0xFFFD, 1]; - } - return [r, 3]; - } - - var c3 = str.charCodeAt(pos + 3); - if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) { - return [0xFFFD, 1]; - } - - if (c0 < 0xF8) { - var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F); - if (r <= 0xFFFF || 0x10FFFF < r) { - return [0xFFFD, 1]; - } - return [r, 4]; - } - - return [0xFFFD, 1]; -}; - -var $encodeRune = function(r) { - if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) { - r = 0xFFFD; - } - if (r <= 0x7F) { - return String.fromCharCode(r); - } - if (r <= 0x7FF) { - return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F)); - } - if (r <= 0xFFFF) { - return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); - } - return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); -}; - -var $stringToBytes = function(str) { - var array = new Uint8Array(str.length); - for (var i = 0; i < str.length; i++) { - array[i] = str.charCodeAt(i); - } - return array; -}; - -var $bytesToString = function(slice) { - if (slice.$length === 0) { - return ""; - } - var str = ""; - for (var i = 0; i < slice.$length; i += 10000) { - str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000))); - } - return str; -}; - -var $stringToRunes = function(str) { - var array = new Int32Array(str.length); - var rune, j = 0; - for (var i = 0; i < str.length; i += rune[1], j++) { - rune = $decodeRune(str, i); - array[j] = rune[0]; - } - return array.subarray(0, j); -}; - -var $runesToString = function(slice) { - if (slice.$length === 0) { - return ""; - } - var str = ""; - for (var i = 0; i < slice.$length; i++) { - str += $encodeRune(slice.$array[slice.$offset + i]); - } - return str; -}; - -var $copyString = function(dst, src) { - var n = Math.min(src.length, dst.$length); - for (var i = 0; i < n; i++) { - dst.$array[dst.$offset + i] = src.charCodeAt(i); - } - return n; -}; - -var $copySlice = function(dst, src) { - var n = Math.min(src.$length, dst.$length); - $copyArray(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem); - return n; -}; - -var $copyArray = function(dst, src, dstOffset, srcOffset, n, elem) { - if (n === 0 || (dst === src && dstOffset === srcOffset)) { - return; - } - - if (src.subarray) { - dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset); - return; - } - - switch (elem.kind) { - case $kindArray: - case $kindStruct: - if (dst === src && dstOffset > srcOffset) { - for (var i = n - 1; i >= 0; i--) { - elem.copy(dst[dstOffset + i], src[srcOffset + i]); - } - return; - } - for (var i = 0; i < n; i++) { - elem.copy(dst[dstOffset + i], src[srcOffset + i]); - } - return; - } - - if (dst === src && dstOffset > srcOffset) { - for (var i = n - 1; i >= 0; i--) { - dst[dstOffset + i] = src[srcOffset + i]; - } - return; - } - for (var i = 0; i < n; i++) { - dst[dstOffset + i] = src[srcOffset + i]; - } -}; - -var $clone = function(src, type) { - var clone = type.zero(); - type.copy(clone, src); - return clone; -}; - -var $pointerOfStructConversion = function(obj, type) { - if(obj.$proxies === undefined) { - obj.$proxies = {}; - obj.$proxies[obj.constructor.string] = obj; - } - var proxy = obj.$proxies[type.string]; - if (proxy === undefined) { - var properties = {}; - for (var i = 0; i < type.elem.fields.length; i++) { - (function(fieldProp) { - properties[fieldProp] = { - get: function() { return obj[fieldProp]; }, - set: function(value) { obj[fieldProp] = value; } - }; - })(type.elem.fields[i].prop); - } - proxy = Object.create(type.prototype, properties); - proxy.$val = proxy; - obj.$proxies[type.string] = proxy; - proxy.$proxies = obj.$proxies; - } - return proxy; -}; - -var $append = function(slice) { - return $internalAppend(slice, arguments, 1, arguments.length - 1); -}; - -var $appendSlice = function(slice, toAppend) { - if (toAppend.constructor === String) { - var bytes = $stringToBytes(toAppend); - return $internalAppend(slice, bytes, 0, bytes.length); - } - return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length); -}; - -var $internalAppend = function(slice, array, offset, length) { - if (length === 0) { - return slice; - } - - var newArray = slice.$array; - var newOffset = slice.$offset; - var newLength = slice.$length + length; - var newCapacity = slice.$capacity; - - if (newLength > newCapacity) { - newOffset = 0; - newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4)); - - if (slice.$array.constructor === Array) { - newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length); - newArray.length = newCapacity; - var zero = slice.constructor.elem.zero; - for (var i = slice.$length; i < newCapacity; i++) { - newArray[i] = zero(); - } - } else { - newArray = new slice.$array.constructor(newCapacity); - newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length)); - } - } - - $copyArray(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem); - - var newSlice = new slice.constructor(newArray); - newSlice.$offset = newOffset; - newSlice.$length = newLength; - newSlice.$capacity = newCapacity; - return newSlice; -}; - -var $equal = function(a, b, type) { - if (type === $jsObjectPtr) { - return a === b; - } - switch (type.kind) { - case $kindComplex64: - case $kindComplex128: - return a.$real === b.$real && a.$imag === b.$imag; - case $kindInt64: - case $kindUint64: - return a.$high === b.$high && a.$low === b.$low; - case $kindArray: - if (a.length !== b.length) { - return false; - } - for (var i = 0; i < a.length; i++) { - if (!$equal(a[i], b[i], type.elem)) { - return false; - } - } - return true; - case $kindStruct: - for (var i = 0; i < type.fields.length; i++) { - var f = type.fields[i]; - if (!$equal(a[f.prop], b[f.prop], f.typ)) { - return false; - } - } - return true; - case $kindInterface: - return $interfaceIsEqual(a, b); - default: - return a === b; - } -}; - -var $interfaceIsEqual = function(a, b) { - if (a === $ifaceNil || b === $ifaceNil) { - return a === b; - } - if (a.constructor !== b.constructor) { - return false; - } - if (a.constructor === $jsObjectPtr) { - return a.object === b.object; - } - if (!a.constructor.comparable) { - $throwRuntimeError("comparing uncomparable type " + a.constructor.string); - } - return $equal(a.$val, b.$val, a.constructor); -}; - -var $min = Math.min; -var $mod = function(x, y) { return x % y; }; -var $parseInt = parseInt; -var $parseFloat = function(f) { - if (f !== undefined && f !== null && f.constructor === Number) { - return f; - } - return parseFloat(f); -}; - -var $froundBuf = new Float32Array(1); -var $fround = Math.fround || function(f) { - $froundBuf[0] = f; - return $froundBuf[0]; -}; - -var $imul = Math.imul || function(a, b) { - var ah = (a >>> 16) & 0xffff; - var al = a & 0xffff; - var bh = (b >>> 16) & 0xffff; - var bl = b & 0xffff; - return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) >> 0); -}; - -var $floatKey = function(f) { - if (f !== f) { - $idCounter++; - return "NaN$" + $idCounter; - } - return String(f); -}; - -var $flatten64 = function(x) { - return x.$high * 4294967296 + x.$low; -}; - -var $shiftLeft64 = function(x, y) { - if (y === 0) { - return x; - } - if (y < 32) { - return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0); - } - if (y < 64) { - return new x.constructor(x.$low << (y - 32), 0); - } - return new x.constructor(0, 0); -}; - -var $shiftRightInt64 = function(x, y) { - if (y === 0) { - return x; - } - if (y < 32) { - return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); - } - if (y < 64) { - return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0); - } - if (x.$high < 0) { - return new x.constructor(-1, 4294967295); - } - return new x.constructor(0, 0); -}; - -var $shiftRightUint64 = function(x, y) { - if (y === 0) { - return x; - } - if (y < 32) { - return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); - } - if (y < 64) { - return new x.constructor(0, x.$high >>> (y - 32)); - } - return new x.constructor(0, 0); -}; - -var $mul64 = function(x, y) { - var high = 0, low = 0; - if ((y.$low & 1) !== 0) { - high = x.$high; - low = x.$low; - } - for (var i = 1; i < 32; i++) { - if ((y.$low & 1<>> (32 - i); - low += (x.$low << i) >>> 0; - } - } - for (var i = 0; i < 32; i++) { - if ((y.$high & 1< yHigh) || (xHigh === yHigh && xLow > yLow))) { - yHigh = (yHigh << 1 | yLow >>> 31) >>> 0; - yLow = (yLow << 1) >>> 0; - n++; - } - for (var i = 0; i <= n; i++) { - high = high << 1 | low >>> 31; - low = (low << 1) >>> 0; - if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) { - xHigh = xHigh - yHigh; - xLow = xLow - yLow; - if (xLow < 0) { - xHigh--; - xLow += 4294967296; - } - low++; - if (low === 4294967296) { - high++; - low = 0; - } - } - yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0; - yHigh = yHigh >>> 1; - } - - if (returnRemainder) { - return new x.constructor(xHigh * rs, xLow * rs); - } - return new x.constructor(high * s, low * s); -}; - -var $divComplex = function(n, d) { - var ninf = n.$real === Infinity || n.$real === -Infinity || n.$imag === Infinity || n.$imag === -Infinity; - var dinf = d.$real === Infinity || d.$real === -Infinity || d.$imag === Infinity || d.$imag === -Infinity; - var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag); - var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag); - if(nnan || dnan) { - return new n.constructor(NaN, NaN); - } - if (ninf && !dinf) { - return new n.constructor(Infinity, Infinity); - } - if (!ninf && dinf) { - return new n.constructor(0, 0); - } - if (d.$real === 0 && d.$imag === 0) { - if (n.$real === 0 && n.$imag === 0) { - return new n.constructor(NaN, NaN); - } - return new n.constructor(Infinity, Infinity); - } - var a = Math.abs(d.$real); - var b = Math.abs(d.$imag); - if (a <= b) { - var ratio = d.$real / d.$imag; - var denom = d.$real * ratio + d.$imag; - return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom); - } - var ratio = d.$imag / d.$real; - var denom = d.$imag * ratio + d.$real; - return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom); -}; - -var $kindBool = 1; -var $kindInt = 2; -var $kindInt8 = 3; -var $kindInt16 = 4; -var $kindInt32 = 5; -var $kindInt64 = 6; -var $kindUint = 7; -var $kindUint8 = 8; -var $kindUint16 = 9; -var $kindUint32 = 10; -var $kindUint64 = 11; -var $kindUintptr = 12; -var $kindFloat32 = 13; -var $kindFloat64 = 14; -var $kindComplex64 = 15; -var $kindComplex128 = 16; -var $kindArray = 17; -var $kindChan = 18; -var $kindFunc = 19; -var $kindInterface = 20; -var $kindMap = 21; -var $kindPtr = 22; -var $kindSlice = 23; -var $kindString = 24; -var $kindStruct = 25; -var $kindUnsafePointer = 26; - -var $methodSynthesizers = []; -var $addMethodSynthesizer = function(f) { - if ($methodSynthesizers === null) { - f(); - return; - } - $methodSynthesizers.push(f); -}; -var $synthesizeMethods = function() { - $methodSynthesizers.forEach(function(f) { f(); }); - $methodSynthesizers = null; -}; - -var $ifaceKeyFor = function(x) { - if (x === $ifaceNil) { - return 'nil'; - } - var c = x.constructor; - return c.string + '$' + c.keyFor(x.$val); -}; - -var $identity = function(x) { return x; }; - -var $typeIDCounter = 0; - -var $idKey = function(x) { - if (x.$id === undefined) { - $idCounter++; - x.$id = $idCounter; - } - return String(x.$id); -}; - -var $newType = function(size, kind, string, named, pkg, exported, constructor) { - var typ; - switch(kind) { - case $kindBool: - case $kindInt: - case $kindInt8: - case $kindInt16: - case $kindInt32: - case $kindUint: - case $kindUint8: - case $kindUint16: - case $kindUint32: - case $kindUintptr: - case $kindUnsafePointer: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.keyFor = $identity; - break; - - case $kindString: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.keyFor = function(x) { return "$" + x; }; - break; - - case $kindFloat32: - case $kindFloat64: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.keyFor = function(x) { return $floatKey(x); }; - break; - - case $kindInt64: - typ = function(high, low) { - this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >> 0; - this.$low = low >>> 0; - this.$val = this; - }; - typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; - break; - - case $kindUint64: - typ = function(high, low) { - this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >>> 0; - this.$low = low >>> 0; - this.$val = this; - }; - typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; - break; - - case $kindComplex64: - typ = function(real, imag) { - this.$real = $fround(real); - this.$imag = $fround(imag); - this.$val = this; - }; - typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; - break; - - case $kindComplex128: - typ = function(real, imag) { - this.$real = real; - this.$imag = imag; - this.$val = this; - }; - typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; - break; - - case $kindArray: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.ptr = $newType(4, $kindPtr, "*" + string, false, "", false, function(array) { - this.$get = function() { return array; }; - this.$set = function(v) { typ.copy(this, v); }; - this.$val = array; - }); - typ.init = function(elem, len) { - typ.elem = elem; - typ.len = len; - typ.comparable = elem.comparable; - typ.keyFor = function(x) { - return Array.prototype.join.call($mapArray(x, function(e) { - return String(elem.keyFor(e)).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); - }), "$"); - }; - typ.copy = function(dst, src) { - $copyArray(dst, src, 0, 0, src.length, elem); - }; - typ.ptr.init(typ); - Object.defineProperty(typ.ptr.nil, "nilCheck", { get: $throwNilPointerError }); - }; - break; - - case $kindChan: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.keyFor = $idKey; - typ.init = function(elem, sendOnly, recvOnly) { - typ.elem = elem; - typ.sendOnly = sendOnly; - typ.recvOnly = recvOnly; - }; - break; - - case $kindFunc: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.init = function(params, results, variadic) { - typ.params = params; - typ.results = results; - typ.variadic = variadic; - typ.comparable = false; - }; - break; - - case $kindInterface: - typ = { implementedBy: {}, missingMethodFor: {} }; - typ.keyFor = $ifaceKeyFor; - typ.init = function(methods) { - typ.methods = methods; - methods.forEach(function(m) { - $ifaceNil[m.prop] = $throwNilPointerError; - }); - }; - break; - - case $kindMap: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.init = function(key, elem) { - typ.key = key; - typ.elem = elem; - typ.comparable = false; - }; - break; - - case $kindPtr: - typ = constructor || function(getter, setter, target) { - this.$get = getter; - this.$set = setter; - this.$target = target; - this.$val = this; - }; - typ.keyFor = $idKey; - typ.init = function(elem) { - typ.elem = elem; - typ.wrapped = (elem.kind === $kindArray); - typ.nil = new typ($throwNilPointerError, $throwNilPointerError); - }; - break; - - case $kindSlice: - typ = function(array) { - if (array.constructor !== typ.nativeArray) { - array = new typ.nativeArray(array); - } - this.$array = array; - this.$offset = 0; - this.$length = array.length; - this.$capacity = array.length; - this.$val = this; - }; - typ.init = function(elem) { - typ.elem = elem; - typ.comparable = false; - typ.nativeArray = $nativeArray(elem.kind); - typ.nil = new typ([]); - }; - break; - - case $kindStruct: - typ = function(v) { this.$val = v; }; - typ.wrapped = true; - typ.ptr = $newType(4, $kindPtr, "*" + string, false, pkg, exported, constructor); - typ.ptr.elem = typ; - typ.ptr.prototype.$get = function() { return this; }; - typ.ptr.prototype.$set = function(v) { typ.copy(this, v); }; - typ.init = function(pkgPath, fields) { - typ.pkgPath = pkgPath; - typ.fields = fields; - fields.forEach(function(f) { - if (!f.typ.comparable) { - typ.comparable = false; - } - }); - typ.keyFor = function(x) { - var val = x.$val; - return $mapArray(fields, function(f) { - return String(f.typ.keyFor(val[f.prop])).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); - }).join("$"); - }; - typ.copy = function(dst, src) { - for (var i = 0; i < fields.length; i++) { - var f = fields[i]; - switch (f.typ.kind) { - case $kindArray: - case $kindStruct: - f.typ.copy(dst[f.prop], src[f.prop]); - continue; - default: - dst[f.prop] = src[f.prop]; - continue; - } - } - }; - /* nil value */ - var properties = {}; - fields.forEach(function(f) { - properties[f.prop] = { get: $throwNilPointerError, set: $throwNilPointerError }; - }); - typ.ptr.nil = Object.create(constructor.prototype, properties); - typ.ptr.nil.$val = typ.ptr.nil; - /* methods for embedded fields */ - $addMethodSynthesizer(function() { - var synthesizeMethod = function(target, m, f) { - if (target.prototype[m.prop] !== undefined) { return; } - target.prototype[m.prop] = function() { - var v = this.$val[f.prop]; - if (f.typ === $jsObjectPtr) { - v = new $jsObjectPtr(v); - } - if (v.$val === undefined) { - v = new f.typ(v); - } - return v[m.prop].apply(v, arguments); - }; - }; - fields.forEach(function(f) { - if (f.embedded) { - $methodSet(f.typ).forEach(function(m) { - synthesizeMethod(typ, m, f); - synthesizeMethod(typ.ptr, m, f); - }); - $methodSet($ptrType(f.typ)).forEach(function(m) { - synthesizeMethod(typ.ptr, m, f); - }); - } - }); - }); - }; - break; - - default: - $panic(new $String("invalid kind: " + kind)); - } - - switch (kind) { - case $kindBool: - case $kindMap: - typ.zero = function() { return false; }; - break; - - case $kindInt: - case $kindInt8: - case $kindInt16: - case $kindInt32: - case $kindUint: - case $kindUint8 : - case $kindUint16: - case $kindUint32: - case $kindUintptr: - case $kindUnsafePointer: - case $kindFloat32: - case $kindFloat64: - typ.zero = function() { return 0; }; - break; - - case $kindString: - typ.zero = function() { return ""; }; - break; - - case $kindInt64: - case $kindUint64: - case $kindComplex64: - case $kindComplex128: - var zero = new typ(0, 0); - typ.zero = function() { return zero; }; - break; - - case $kindPtr: - case $kindSlice: - typ.zero = function() { return typ.nil; }; - break; - - case $kindChan: - typ.zero = function() { return $chanNil; }; - break; - - case $kindFunc: - typ.zero = function() { return $throwNilPointerError; }; - break; - - case $kindInterface: - typ.zero = function() { return $ifaceNil; }; - break; - - case $kindArray: - typ.zero = function() { - var arrayClass = $nativeArray(typ.elem.kind); - if (arrayClass !== Array) { - return new arrayClass(typ.len); - } - var array = new Array(typ.len); - for (var i = 0; i < typ.len; i++) { - array[i] = typ.elem.zero(); - } - return array; - }; - break; - - case $kindStruct: - typ.zero = function() { return new typ.ptr(); }; - break; - - default: - $panic(new $String("invalid kind: " + kind)); - } - - typ.id = $typeIDCounter; - $typeIDCounter++; - typ.size = size; - typ.kind = kind; - typ.string = string; - typ.named = named; - typ.pkg = pkg; - typ.exported = exported; - typ.methods = []; - typ.methodSetCache = null; - typ.comparable = true; - return typ; -}; - -var $methodSet = function(typ) { - if (typ.methodSetCache !== null) { - return typ.methodSetCache; - } - var base = {}; - - var isPtr = (typ.kind === $kindPtr); - if (isPtr && typ.elem.kind === $kindInterface) { - typ.methodSetCache = []; - return []; - } - - var current = [{typ: isPtr ? typ.elem : typ, indirect: isPtr}]; - - var seen = {}; - - while (current.length > 0) { - var next = []; - var mset = []; - - current.forEach(function(e) { - if (seen[e.typ.string]) { - return; - } - seen[e.typ.string] = true; - - if (e.typ.named) { - mset = mset.concat(e.typ.methods); - if (e.indirect) { - mset = mset.concat($ptrType(e.typ).methods); - } - } - - switch (e.typ.kind) { - case $kindStruct: - e.typ.fields.forEach(function(f) { - if (f.embedded) { - var fTyp = f.typ; - var fIsPtr = (fTyp.kind === $kindPtr); - next.push({typ: fIsPtr ? fTyp.elem : fTyp, indirect: e.indirect || fIsPtr}); - } - }); - break; - - case $kindInterface: - mset = mset.concat(e.typ.methods); - break; - } - }); - - mset.forEach(function(m) { - if (base[m.name] === undefined) { - base[m.name] = m; - } - }); - - current = next; - } - - typ.methodSetCache = []; - Object.keys(base).sort().forEach(function(name) { - typ.methodSetCache.push(base[name]); - }); - return typ.methodSetCache; -}; - -var $Bool = $newType( 1, $kindBool, "bool", true, "", false, null); -var $Int = $newType( 4, $kindInt, "int", true, "", false, null); -var $Int8 = $newType( 1, $kindInt8, "int8", true, "", false, null); -var $Int16 = $newType( 2, $kindInt16, "int16", true, "", false, null); -var $Int32 = $newType( 4, $kindInt32, "int32", true, "", false, null); -var $Int64 = $newType( 8, $kindInt64, "int64", true, "", false, null); -var $Uint = $newType( 4, $kindUint, "uint", true, "", false, null); -var $Uint8 = $newType( 1, $kindUint8, "uint8", true, "", false, null); -var $Uint16 = $newType( 2, $kindUint16, "uint16", true, "", false, null); -var $Uint32 = $newType( 4, $kindUint32, "uint32", true, "", false, null); -var $Uint64 = $newType( 8, $kindUint64, "uint64", true, "", false, null); -var $Uintptr = $newType( 4, $kindUintptr, "uintptr", true, "", false, null); -var $Float32 = $newType( 4, $kindFloat32, "float32", true, "", false, null); -var $Float64 = $newType( 8, $kindFloat64, "float64", true, "", false, null); -var $Complex64 = $newType( 8, $kindComplex64, "complex64", true, "", false, null); -var $Complex128 = $newType(16, $kindComplex128, "complex128", true, "", false, null); -var $String = $newType( 8, $kindString, "string", true, "", false, null); -var $UnsafePointer = $newType( 4, $kindUnsafePointer, "unsafe.Pointer", true, "", false, null); - -var $nativeArray = function(elemKind) { - switch (elemKind) { - case $kindInt: - return Int32Array; - case $kindInt8: - return Int8Array; - case $kindInt16: - return Int16Array; - case $kindInt32: - return Int32Array; - case $kindUint: - return Uint32Array; - case $kindUint8: - return Uint8Array; - case $kindUint16: - return Uint16Array; - case $kindUint32: - return Uint32Array; - case $kindUintptr: - return Uint32Array; - case $kindFloat32: - return Float32Array; - case $kindFloat64: - return Float64Array; - default: - return Array; - } -}; -var $toNativeArray = function(elemKind, array) { - var nativeArray = $nativeArray(elemKind); - if (nativeArray === Array) { - return array; - } - return new nativeArray(array); -}; -var $arrayTypes = {}; -var $arrayType = function(elem, len) { - var typeKey = elem.id + "$" + len; - var typ = $arrayTypes[typeKey]; - if (typ === undefined) { - typ = $newType(12, $kindArray, "[" + len + "]" + elem.string, false, "", false, null); - $arrayTypes[typeKey] = typ; - typ.init(elem, len); - } - return typ; -}; - -var $chanType = function(elem, sendOnly, recvOnly) { - var string = (recvOnly ? "<-" : "") + "chan" + (sendOnly ? "<- " : " ") + elem.string; - var field = sendOnly ? "SendChan" : (recvOnly ? "RecvChan" : "Chan"); - var typ = elem[field]; - if (typ === undefined) { - typ = $newType(4, $kindChan, string, false, "", false, null); - elem[field] = typ; - typ.init(elem, sendOnly, recvOnly); - } - return typ; -}; -var $Chan = function(elem, capacity) { - if (capacity < 0 || capacity > 2147483647) { - $throwRuntimeError("makechan: size out of range"); - } - this.$elem = elem; - this.$capacity = capacity; - this.$buffer = []; - this.$sendQueue = []; - this.$recvQueue = []; - this.$closed = false; -}; -var $chanNil = new $Chan(null, 0); -$chanNil.$sendQueue = $chanNil.$recvQueue = { length: 0, push: function() {}, shift: function() { return undefined; }, indexOf: function() { return -1; } }; - -var $funcTypes = {}; -var $funcType = function(params, results, variadic) { - var typeKey = $mapArray(params, function(p) { return p.id; }).join(",") + "$" + $mapArray(results, function(r) { return r.id; }).join(",") + "$" + variadic; - var typ = $funcTypes[typeKey]; - if (typ === undefined) { - var paramTypes = $mapArray(params, function(p) { return p.string; }); - if (variadic) { - paramTypes[paramTypes.length - 1] = "..." + paramTypes[paramTypes.length - 1].substr(2); - } - var string = "func(" + paramTypes.join(", ") + ")"; - if (results.length === 1) { - string += " " + results[0].string; - } else if (results.length > 1) { - string += " (" + $mapArray(results, function(r) { return r.string; }).join(", ") + ")"; - } - typ = $newType(4, $kindFunc, string, false, "", false, null); - $funcTypes[typeKey] = typ; - typ.init(params, results, variadic); - } - return typ; -}; - -var $interfaceTypes = {}; -var $interfaceType = function(methods) { - var typeKey = $mapArray(methods, function(m) { return m.pkg + "," + m.name + "," + m.typ.id; }).join("$"); - var typ = $interfaceTypes[typeKey]; - if (typ === undefined) { - var string = "interface {}"; - if (methods.length !== 0) { - string = "interface { " + $mapArray(methods, function(m) { - return (m.pkg !== "" ? m.pkg + "." : "") + m.name + m.typ.string.substr(4); - }).join("; ") + " }"; - } - typ = $newType(8, $kindInterface, string, false, "", false, null); - $interfaceTypes[typeKey] = typ; - typ.init(methods); - } - return typ; -}; -var $emptyInterface = $interfaceType([]); -var $ifaceNil = {}; -var $error = $newType(8, $kindInterface, "error", true, "", false, null); -$error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]); - -var $mapTypes = {}; -var $mapType = function(key, elem) { - var typeKey = key.id + "$" + elem.id; - var typ = $mapTypes[typeKey]; - if (typ === undefined) { - typ = $newType(4, $kindMap, "map[" + key.string + "]" + elem.string, false, "", false, null); - $mapTypes[typeKey] = typ; - typ.init(key, elem); - } - return typ; -}; -var $makeMap = function(keyForFunc, entries) { - var m = {}; - for (var i = 0; i < entries.length; i++) { - var e = entries[i]; - m[keyForFunc(e.k)] = e; - } - return m; -}; - -var $ptrType = function(elem) { - var typ = elem.ptr; - if (typ === undefined) { - typ = $newType(4, $kindPtr, "*" + elem.string, false, "", elem.exported, null); - elem.ptr = typ; - typ.init(elem); - } - return typ; -}; - -var $newDataPointer = function(data, constructor) { - if (constructor.elem.kind === $kindStruct) { - return data; - } - return new constructor(function() { return data; }, function(v) { data = v; }); -}; - -var $indexPtr = function(array, index, constructor) { - array.$ptr = array.$ptr || {}; - return array.$ptr[index] || (array.$ptr[index] = new constructor(function() { return array[index]; }, function(v) { array[index] = v; })); -}; - -var $sliceType = function(elem) { - var typ = elem.slice; - if (typ === undefined) { - typ = $newType(12, $kindSlice, "[]" + elem.string, false, "", false, null); - elem.slice = typ; - typ.init(elem); - } - return typ; -}; -var $makeSlice = function(typ, length, capacity) { - capacity = capacity || length; - if (length < 0 || length > 2147483647) { - $throwRuntimeError("makeslice: len out of range"); - } - if (capacity < 0 || capacity < length || capacity > 2147483647) { - $throwRuntimeError("makeslice: cap out of range"); - } - var array = new typ.nativeArray(capacity); - if (typ.nativeArray === Array) { - for (var i = 0; i < capacity; i++) { - array[i] = typ.elem.zero(); - } - } - var slice = new typ(array); - slice.$length = length; - return slice; -}; - -var $structTypes = {}; -var $structType = function(pkgPath, fields) { - var typeKey = $mapArray(fields, function(f) { return f.name + "," + f.typ.id + "," + f.tag; }).join("$"); - var typ = $structTypes[typeKey]; - if (typ === undefined) { - var string = "struct { " + $mapArray(fields, function(f) { - return f.name + " " + f.typ.string + (f.tag !== "" ? (" \"" + f.tag.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"") : ""); - }).join("; ") + " }"; - if (fields.length === 0) { - string = "struct {}"; - } - typ = $newType(0, $kindStruct, string, false, "", false, function() { - this.$val = this; - for (var i = 0; i < fields.length; i++) { - var f = fields[i]; - var arg = arguments[i]; - this[f.prop] = arg !== undefined ? arg : f.typ.zero(); - } - }); - $structTypes[typeKey] = typ; - typ.init(pkgPath, fields); - } - return typ; -}; - -var $assertType = function(value, type, returnTuple) { - var isInterface = (type.kind === $kindInterface), ok, missingMethod = ""; - if (value === $ifaceNil) { - ok = false; - } else if (!isInterface) { - ok = value.constructor === type; - } else { - var valueTypeString = value.constructor.string; - ok = type.implementedBy[valueTypeString]; - if (ok === undefined) { - ok = true; - var valueMethodSet = $methodSet(value.constructor); - var interfaceMethods = type.methods; - for (var i = 0; i < interfaceMethods.length; i++) { - var tm = interfaceMethods[i]; - var found = false; - for (var j = 0; j < valueMethodSet.length; j++) { - var vm = valueMethodSet[j]; - if (vm.name === tm.name && vm.pkg === tm.pkg && vm.typ === tm.typ) { - found = true; - break; - } - } - if (!found) { - ok = false; - type.missingMethodFor[valueTypeString] = tm.name; - break; - } - } - type.implementedBy[valueTypeString] = ok; - } - if (!ok) { - missingMethod = type.missingMethodFor[valueTypeString]; - } - } - - if (!ok) { - if (returnTuple) { - return [type.zero(), false]; - } - $panic(new $packages["runtime"].TypeAssertionError.ptr( - $packages["runtime"]._type.ptr.nil, - (value === $ifaceNil ? $packages["runtime"]._type.ptr.nil : new $packages["runtime"]._type.ptr(value.constructor.string)), - new $packages["runtime"]._type.ptr(type.string), - missingMethod)); - } - - if (!isInterface) { - value = value.$val; - } - if (type === $jsObjectPtr) { - value = value.object; - } - return returnTuple ? [value, true] : value; -}; - -var $stackDepthOffset = 0; -var $getStackDepth = function() { - var err = new Error(); - if (err.stack === undefined) { - return undefined; - } - return $stackDepthOffset + err.stack.split("\n").length; -}; - -var $panicStackDepth = null, $panicValue; -var $callDeferred = function(deferred, jsErr, fromPanic) { - if (!fromPanic && deferred !== null && deferred.index >= $curGoroutine.deferStack.length) { - throw jsErr; - } - if (jsErr !== null) { - var newErr = null; - try { - $curGoroutine.deferStack.push(deferred); - $panic(new $jsErrorPtr(jsErr)); - } catch (err) { - newErr = err; - } - $curGoroutine.deferStack.pop(); - $callDeferred(deferred, newErr); - return; - } - if ($curGoroutine.asleep) { - return; - } - - $stackDepthOffset--; - var outerPanicStackDepth = $panicStackDepth; - var outerPanicValue = $panicValue; - - var localPanicValue = $curGoroutine.panicStack.pop(); - if (localPanicValue !== undefined) { - $panicStackDepth = $getStackDepth(); - $panicValue = localPanicValue; - } - - try { - while (true) { - if (deferred === null) { - deferred = $curGoroutine.deferStack[$curGoroutine.deferStack.length - 1]; - if (deferred === undefined) { - /* The panic reached the top of the stack. Clear it and throw it as a JavaScript error. */ - $panicStackDepth = null; - if (localPanicValue.Object instanceof Error) { - throw localPanicValue.Object; - } - var msg; - if (localPanicValue.constructor === $String) { - msg = localPanicValue.$val; - } else if (localPanicValue.Error !== undefined) { - msg = localPanicValue.Error(); - } else if (localPanicValue.String !== undefined) { - msg = localPanicValue.String(); - } else { - msg = localPanicValue; - } - throw new Error(msg); - } - } - var call = deferred.pop(); - if (call === undefined) { - $curGoroutine.deferStack.pop(); - if (localPanicValue !== undefined) { - deferred = null; - continue; - } - return; - } - var r = call[0].apply(call[2], call[1]); - if (r && r.$blk !== undefined) { - deferred.push([r.$blk, [], r]); - if (fromPanic) { - throw null; - } - return; - } - - if (localPanicValue !== undefined && $panicStackDepth === null) { - throw null; /* error was recovered */ - } - } - } finally { - if (localPanicValue !== undefined) { - if ($panicStackDepth !== null) { - $curGoroutine.panicStack.push(localPanicValue); - } - $panicStackDepth = outerPanicStackDepth; - $panicValue = outerPanicValue; - } - $stackDepthOffset++; - } -}; - -var $panic = function(value) { - $curGoroutine.panicStack.push(value); - $callDeferred(null, null, true); -}; -var $recover = function() { - if ($panicStackDepth === null || ($panicStackDepth !== undefined && $panicStackDepth !== $getStackDepth() - 2)) { - return $ifaceNil; - } - $panicStackDepth = null; - return $panicValue; -}; -var $throw = function(err) { throw err; }; - -var $noGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [] }; -var $curGoroutine = $noGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true; -var $mainFinished = false; -var $go = function(fun, args) { - $totalGoroutines++; - $awakeGoroutines++; - var $goroutine = function() { - try { - $curGoroutine = $goroutine; - var r = fun.apply(undefined, args); - if (r && r.$blk !== undefined) { - fun = function() { return r.$blk(); }; - args = []; - return; - } - $goroutine.exit = true; - } catch (err) { - if (!$goroutine.exit) { - throw err; - } - } finally { - $curGoroutine = $noGoroutine; - if ($goroutine.exit) { /* also set by runtime.Goexit() */ - $totalGoroutines--; - $goroutine.asleep = true; - } - if ($goroutine.asleep) { - $awakeGoroutines--; - if (!$mainFinished && $awakeGoroutines === 0 && $checkForDeadlock) { - console.error("fatal error: all goroutines are asleep - deadlock!"); - if ($global.process !== undefined) { - $global.process.exit(2); - } - } - } - } - }; - $goroutine.asleep = false; - $goroutine.exit = false; - $goroutine.deferStack = []; - $goroutine.panicStack = []; - $schedule($goroutine); -}; - -var $scheduled = []; -var $runScheduled = function() { - try { - var r; - while ((r = $scheduled.shift()) !== undefined) { - r(); - } - } finally { - if ($scheduled.length > 0) { - setTimeout($runScheduled, 0); - } - } -}; - -var $schedule = function(goroutine) { - if (goroutine.asleep) { - goroutine.asleep = false; - $awakeGoroutines++; - } - $scheduled.push(goroutine); - if ($curGoroutine === $noGoroutine) { - $runScheduled(); - } -}; - -var $setTimeout = function(f, t) { - $awakeGoroutines++; - return setTimeout(function() { - $awakeGoroutines--; - f(); - }, t); -}; - -var $block = function() { - if ($curGoroutine === $noGoroutine) { - $throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine"); - } - $curGoroutine.asleep = true; -}; - -var $send = function(chan, value) { - if (chan.$closed) { - $throwRuntimeError("send on closed channel"); - } - var queuedRecv = chan.$recvQueue.shift(); - if (queuedRecv !== undefined) { - queuedRecv([value, true]); - return; - } - if (chan.$buffer.length < chan.$capacity) { - chan.$buffer.push(value); - return; - } - - var thisGoroutine = $curGoroutine; - var closedDuringSend; - chan.$sendQueue.push(function(closed) { - closedDuringSend = closed; - $schedule(thisGoroutine); - return value; - }); - $block(); - return { - $blk: function() { - if (closedDuringSend) { - $throwRuntimeError("send on closed channel"); - } - } - }; -}; -var $recv = function(chan) { - var queuedSend = chan.$sendQueue.shift(); - if (queuedSend !== undefined) { - chan.$buffer.push(queuedSend(false)); - } - var bufferedValue = chan.$buffer.shift(); - if (bufferedValue !== undefined) { - return [bufferedValue, true]; - } - if (chan.$closed) { - return [chan.$elem.zero(), false]; - } - - var thisGoroutine = $curGoroutine; - var f = { $blk: function() { return this.value; } }; - var queueEntry = function(v) { - f.value = v; - $schedule(thisGoroutine); - }; - chan.$recvQueue.push(queueEntry); - $block(); - return f; -}; -var $close = function(chan) { - if (chan.$closed) { - $throwRuntimeError("close of closed channel"); - } - chan.$closed = true; - while (true) { - var queuedSend = chan.$sendQueue.shift(); - if (queuedSend === undefined) { - break; - } - queuedSend(true); /* will panic */ - } - while (true) { - var queuedRecv = chan.$recvQueue.shift(); - if (queuedRecv === undefined) { - break; - } - queuedRecv([chan.$elem.zero(), false]); - } -}; -var $select = function(comms) { - var ready = []; - var selection = -1; - for (var i = 0; i < comms.length; i++) { - var comm = comms[i]; - var chan = comm[0]; - switch (comm.length) { - case 0: /* default */ - selection = i; - break; - case 1: /* recv */ - if (chan.$sendQueue.length !== 0 || chan.$buffer.length !== 0 || chan.$closed) { - ready.push(i); - } - break; - case 2: /* send */ - if (chan.$closed) { - $throwRuntimeError("send on closed channel"); - } - if (chan.$recvQueue.length !== 0 || chan.$buffer.length < chan.$capacity) { - ready.push(i); - } - break; - } - } - - if (ready.length !== 0) { - selection = ready[Math.floor(Math.random() * ready.length)]; - } - if (selection !== -1) { - var comm = comms[selection]; - switch (comm.length) { - case 0: /* default */ - return [selection]; - case 1: /* recv */ - return [selection, $recv(comm[0])]; - case 2: /* send */ - $send(comm[0], comm[1]); - return [selection]; - } - } - - var entries = []; - var thisGoroutine = $curGoroutine; - var f = { $blk: function() { return this.selection; } }; - var removeFromQueues = function() { - for (var i = 0; i < entries.length; i++) { - var entry = entries[i]; - var queue = entry[0]; - var index = queue.indexOf(entry[1]); - if (index !== -1) { - queue.splice(index, 1); - } - } - }; - for (var i = 0; i < comms.length; i++) { - (function(i) { - var comm = comms[i]; - switch (comm.length) { - case 1: /* recv */ - var queueEntry = function(value) { - f.selection = [i, value]; - removeFromQueues(); - $schedule(thisGoroutine); - }; - entries.push([comm[0].$recvQueue, queueEntry]); - comm[0].$recvQueue.push(queueEntry); - break; - case 2: /* send */ - var queueEntry = function() { - if (comm[0].$closed) { - $throwRuntimeError("send on closed channel"); - } - f.selection = [i]; - removeFromQueues(); - $schedule(thisGoroutine); - return comm[1]; - }; - entries.push([comm[0].$sendQueue, queueEntry]); - comm[0].$sendQueue.push(queueEntry); - break; - } - })(i); - } - $block(); - return f; -}; - -var $jsObjectPtr, $jsErrorPtr; - -var $needsExternalization = function(t) { - switch (t.kind) { - case $kindBool: - case $kindInt: - case $kindInt8: - case $kindInt16: - case $kindInt32: - case $kindUint: - case $kindUint8: - case $kindUint16: - case $kindUint32: - case $kindUintptr: - case $kindFloat32: - case $kindFloat64: - return false; - default: - return t !== $jsObjectPtr; - } -}; - -var $externalize = function(v, t) { - if (t === $jsObjectPtr) { - return v; - } - switch (t.kind) { - case $kindBool: - case $kindInt: - case $kindInt8: - case $kindInt16: - case $kindInt32: - case $kindUint: - case $kindUint8: - case $kindUint16: - case $kindUint32: - case $kindUintptr: - case $kindFloat32: - case $kindFloat64: - return v; - case $kindInt64: - case $kindUint64: - return $flatten64(v); - case $kindArray: - if ($needsExternalization(t.elem)) { - return $mapArray(v, function(e) { return $externalize(e, t.elem); }); - } - return v; - case $kindFunc: - return $externalizeFunction(v, t, false); - case $kindInterface: - if (v === $ifaceNil) { - return null; - } - if (v.constructor === $jsObjectPtr) { - return v.$val.object; - } - return $externalize(v.$val, v.constructor); - case $kindMap: - var m = {}; - var keys = $keys(v); - for (var i = 0; i < keys.length; i++) { - var entry = v[keys[i]]; - m[$externalize(entry.k, t.key)] = $externalize(entry.v, t.elem); - } - return m; - case $kindPtr: - if (v === t.nil) { - return null; - } - return $externalize(v.$get(), t.elem); - case $kindSlice: - if ($needsExternalization(t.elem)) { - return $mapArray($sliceToArray(v), function(e) { return $externalize(e, t.elem); }); - } - return $sliceToArray(v); - case $kindString: - if ($isASCII(v)) { - return v; - } - var s = "", r; - for (var i = 0; i < v.length; i += r[1]) { - r = $decodeRune(v, i); - var c = r[0]; - if (c > 0xFFFF) { - var h = Math.floor((c - 0x10000) / 0x400) + 0xD800; - var l = (c - 0x10000) % 0x400 + 0xDC00; - s += String.fromCharCode(h, l); - continue; - } - s += String.fromCharCode(c); - } - return s; - case $kindStruct: - var timePkg = $packages["time"]; - if (timePkg !== undefined && v.constructor === timePkg.Time.ptr) { - var milli = $div64(v.UnixNano(), new $Int64(0, 1000000)); - return new Date($flatten64(milli)); - } - - var noJsObject = {}; - var searchJsObject = function(v, t) { - if (t === $jsObjectPtr) { - return v; - } - switch (t.kind) { - case $kindPtr: - if (v === t.nil) { - return noJsObject; - } - return searchJsObject(v.$get(), t.elem); - case $kindStruct: - var f = t.fields[0]; - return searchJsObject(v[f.prop], f.typ); - case $kindInterface: - return searchJsObject(v.$val, v.constructor); - default: - return noJsObject; - } - }; - var o = searchJsObject(v, t); - if (o !== noJsObject) { - return o; - } - - o = {}; - for (var i = 0; i < t.fields.length; i++) { - var f = t.fields[i]; - if (!f.exported) { - continue; - } - o[f.name] = $externalize(v[f.prop], f.typ); - } - return o; - } - $throwRuntimeError("cannot externalize " + t.string); -}; - -var $externalizeFunction = function(v, t, passThis) { - if (v === $throwNilPointerError) { - return null; - } - if (v.$externalizeWrapper === undefined) { - $checkForDeadlock = false; - v.$externalizeWrapper = function() { - var args = []; - for (var i = 0; i < t.params.length; i++) { - if (t.variadic && i === t.params.length - 1) { - var vt = t.params[i].elem, varargs = []; - for (var j = i; j < arguments.length; j++) { - varargs.push($internalize(arguments[j], vt)); - } - args.push(new (t.params[i])(varargs)); - break; - } - args.push($internalize(arguments[i], t.params[i])); - } - var result = v.apply(passThis ? this : undefined, args); - switch (t.results.length) { - case 0: - return; - case 1: - return $externalize(result, t.results[0]); - default: - for (var i = 0; i < t.results.length; i++) { - result[i] = $externalize(result[i], t.results[i]); - } - return result; - } - }; - } - return v.$externalizeWrapper; -}; - -var $internalize = function(v, t, recv) { - if (t === $jsObjectPtr) { - return v; - } - if (t === $jsObjectPtr.elem) { - $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); - } - if (v && v.__internal_object__ !== undefined) { - return $assertType(v.__internal_object__, t, false); - } - var timePkg = $packages["time"]; - if (timePkg !== undefined && t === timePkg.Time) { - if (!(v !== null && v !== undefined && v.constructor === Date)) { - $throwRuntimeError("cannot internalize time.Time from " + typeof v + ", must be Date"); - } - return timePkg.Unix(new $Int64(0, 0), new $Int64(0, v.getTime() * 1000000)); - } - switch (t.kind) { - case $kindBool: - return !!v; - case $kindInt: - return parseInt(v); - case $kindInt8: - return parseInt(v) << 24 >> 24; - case $kindInt16: - return parseInt(v) << 16 >> 16; - case $kindInt32: - return parseInt(v) >> 0; - case $kindUint: - return parseInt(v); - case $kindUint8: - return parseInt(v) << 24 >>> 24; - case $kindUint16: - return parseInt(v) << 16 >>> 16; - case $kindUint32: - case $kindUintptr: - return parseInt(v) >>> 0; - case $kindInt64: - case $kindUint64: - return new t(0, v); - case $kindFloat32: - case $kindFloat64: - return parseFloat(v); - case $kindArray: - if (v.length !== t.len) { - $throwRuntimeError("got array with wrong size from JavaScript native"); - } - return $mapArray(v, function(e) { return $internalize(e, t.elem); }); - case $kindFunc: - return function() { - var args = []; - for (var i = 0; i < t.params.length; i++) { - if (t.variadic && i === t.params.length - 1) { - var vt = t.params[i].elem, varargs = arguments[i]; - for (var j = 0; j < varargs.$length; j++) { - args.push($externalize(varargs.$array[varargs.$offset + j], vt)); - } - break; - } - args.push($externalize(arguments[i], t.params[i])); - } - var result = v.apply(recv, args); - switch (t.results.length) { - case 0: - return; - case 1: - return $internalize(result, t.results[0]); - default: - for (var i = 0; i < t.results.length; i++) { - result[i] = $internalize(result[i], t.results[i]); - } - return result; - } - }; - case $kindInterface: - if (t.methods.length !== 0) { - $throwRuntimeError("cannot internalize " + t.string); - } - if (v === null) { - return $ifaceNil; - } - if (v === undefined) { - return new $jsObjectPtr(undefined); - } - switch (v.constructor) { - case Int8Array: - return new ($sliceType($Int8))(v); - case Int16Array: - return new ($sliceType($Int16))(v); - case Int32Array: - return new ($sliceType($Int))(v); - case Uint8Array: - return new ($sliceType($Uint8))(v); - case Uint16Array: - return new ($sliceType($Uint16))(v); - case Uint32Array: - return new ($sliceType($Uint))(v); - case Float32Array: - return new ($sliceType($Float32))(v); - case Float64Array: - return new ($sliceType($Float64))(v); - case Array: - return $internalize(v, $sliceType($emptyInterface)); - case Boolean: - return new $Bool(!!v); - case Date: - if (timePkg === undefined) { - /* time package is not present, internalize as &js.Object{Date} so it can be externalized into original Date. */ - return new $jsObjectPtr(v); - } - return new timePkg.Time($internalize(v, timePkg.Time)); - case Function: - var funcType = $funcType([$sliceType($emptyInterface)], [$jsObjectPtr], true); - return new funcType($internalize(v, funcType)); - case Number: - return new $Float64(parseFloat(v)); - case String: - return new $String($internalize(v, $String)); - default: - if ($global.Node && v instanceof $global.Node) { - return new $jsObjectPtr(v); - } - var mapType = $mapType($String, $emptyInterface); - return new mapType($internalize(v, mapType)); - } - case $kindMap: - var m = {}; - var keys = $keys(v); - for (var i = 0; i < keys.length; i++) { - var k = $internalize(keys[i], t.key); - m[t.key.keyFor(k)] = { k: k, v: $internalize(v[keys[i]], t.elem) }; - } - return m; - case $kindPtr: - if (t.elem.kind === $kindStruct) { - return $internalize(v, t.elem); - } - case $kindSlice: - return new t($mapArray(v, function(e) { return $internalize(e, t.elem); })); - case $kindString: - v = String(v); - if ($isASCII(v)) { - return v; - } - var s = ""; - var i = 0; - while (i < v.length) { - var h = v.charCodeAt(i); - if (0xD800 <= h && h <= 0xDBFF) { - var l = v.charCodeAt(i + 1); - var c = (h - 0xD800) * 0x400 + l - 0xDC00 + 0x10000; - s += $encodeRune(c); - i += 2; - continue; - } - s += $encodeRune(h); - i++; - } - return s; - case $kindStruct: - var noJsObject = {}; - var searchJsObject = function(t) { - if (t === $jsObjectPtr) { - return v; - } - if (t === $jsObjectPtr.elem) { - $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); - } - switch (t.kind) { - case $kindPtr: - return searchJsObject(t.elem); - case $kindStruct: - var f = t.fields[0]; - var o = searchJsObject(f.typ); - if (o !== noJsObject) { - var n = new t.ptr(); - n[f.prop] = o; - return n; - } - return noJsObject; - default: - return noJsObject; - } - }; - var o = searchJsObject(t); - if (o !== noJsObject) { - return o; - } - } - $throwRuntimeError("cannot internalize " + t.string); -}; - -/* $isASCII reports whether string s contains only ASCII characters. */ -var $isASCII = function(s) { - for (var i = 0; i < s.length; i++) { - if (s.charCodeAt(i) >= 128) { - return false; - } - } - return true; -}; - -$packages["github.com/gopherjs/gopherjs/js"] = (function() { - var $pkg = {}, $init, Object, Error, sliceType, ptrType, ptrType$1, MakeFunc, init; - Object = $pkg.Object = $newType(0, $kindStruct, "js.Object", true, "github.com/gopherjs/gopherjs/js", true, function(object_) { - this.$val = this; - if (arguments.length === 0) { - this.object = null; - return; - } - this.object = object_; - }); - Error = $pkg.Error = $newType(0, $kindStruct, "js.Error", true, "github.com/gopherjs/gopherjs/js", true, function(Object_) { - this.$val = this; - if (arguments.length === 0) { - this.Object = null; - return; - } - this.Object = Object_; - }); - sliceType = $sliceType($emptyInterface); - ptrType = $ptrType(Object); - ptrType$1 = $ptrType(Error); - Object.ptr.prototype.Get = function(key) { - var key, o; - o = this; - return o.object[$externalize(key, $String)]; - }; - Object.prototype.Get = function(key) { return this.$val.Get(key); }; - Object.ptr.prototype.Set = function(key, value) { - var key, o, value; - o = this; - o.object[$externalize(key, $String)] = $externalize(value, $emptyInterface); - }; - Object.prototype.Set = function(key, value) { return this.$val.Set(key, value); }; - Object.ptr.prototype.Delete = function(key) { - var key, o; - o = this; - delete o.object[$externalize(key, $String)]; - }; - Object.prototype.Delete = function(key) { return this.$val.Delete(key); }; - Object.ptr.prototype.Length = function() { - var o; - o = this; - return $parseInt(o.object.length); - }; - Object.prototype.Length = function() { return this.$val.Length(); }; - Object.ptr.prototype.Index = function(i) { - var i, o; - o = this; - return o.object[i]; - }; - Object.prototype.Index = function(i) { return this.$val.Index(i); }; - Object.ptr.prototype.SetIndex = function(i, value) { - var i, o, value; - o = this; - o.object[i] = $externalize(value, $emptyInterface); - }; - Object.prototype.SetIndex = function(i, value) { return this.$val.SetIndex(i, value); }; - Object.ptr.prototype.Call = function(name, args) { - var args, name, o, obj; - o = this; - return (obj = o.object, obj[$externalize(name, $String)].apply(obj, $externalize(args, sliceType))); - }; - Object.prototype.Call = function(name, args) { return this.$val.Call(name, args); }; - Object.ptr.prototype.Invoke = function(args) { - var args, o; - o = this; - return o.object.apply(undefined, $externalize(args, sliceType)); - }; - Object.prototype.Invoke = function(args) { return this.$val.Invoke(args); }; - Object.ptr.prototype.New = function(args) { - var args, o; - o = this; - return new ($global.Function.prototype.bind.apply(o.object, [undefined].concat($externalize(args, sliceType)))); - }; - Object.prototype.New = function(args) { return this.$val.New(args); }; - Object.ptr.prototype.Bool = function() { - var o; - o = this; - return !!(o.object); - }; - Object.prototype.Bool = function() { return this.$val.Bool(); }; - Object.ptr.prototype.String = function() { - var o; - o = this; - return $internalize(o.object, $String); - }; - Object.prototype.String = function() { return this.$val.String(); }; - Object.ptr.prototype.Int = function() { - var o; - o = this; - return $parseInt(o.object) >> 0; - }; - Object.prototype.Int = function() { return this.$val.Int(); }; - Object.ptr.prototype.Int64 = function() { - var o; - o = this; - return $internalize(o.object, $Int64); - }; - Object.prototype.Int64 = function() { return this.$val.Int64(); }; - Object.ptr.prototype.Uint64 = function() { - var o; - o = this; - return $internalize(o.object, $Uint64); - }; - Object.prototype.Uint64 = function() { return this.$val.Uint64(); }; - Object.ptr.prototype.Float = function() { - var o; - o = this; - return $parseFloat(o.object); - }; - Object.prototype.Float = function() { return this.$val.Float(); }; - Object.ptr.prototype.Interface = function() { - var o; - o = this; - return $internalize(o.object, $emptyInterface); - }; - Object.prototype.Interface = function() { return this.$val.Interface(); }; - Object.ptr.prototype.Unsafe = function() { - var o; - o = this; - return o.object; - }; - Object.prototype.Unsafe = function() { return this.$val.Unsafe(); }; - Error.ptr.prototype.Error = function() { - var err; - err = this; - return "JavaScript error: " + $internalize(err.Object.message, $String); - }; - Error.prototype.Error = function() { return this.$val.Error(); }; - Error.ptr.prototype.Stack = function() { - var err; - err = this; - return $internalize(err.Object.stack, $String); - }; - Error.prototype.Stack = function() { return this.$val.Stack(); }; - MakeFunc = function(fn) { - var fn; - return $makeFunc(fn); - }; - $pkg.MakeFunc = MakeFunc; - init = function() { - var e; - e = new Error.ptr(null); - $unused(e); - }; - ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $emptyInterface], [], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [ptrType], false)}, {prop: "SetIndex", name: "SetIndex", pkg: "", typ: $funcType([$Int, $emptyInterface], [], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([$String, sliceType], [ptrType], true)}, {prop: "Invoke", name: "Invoke", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "New", name: "New", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Unsafe", name: "Unsafe", pkg: "", typ: $funcType([], [$Uintptr], false)}]; - ptrType$1.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Stack", name: "Stack", pkg: "", typ: $funcType([], [$String], false)}]; - Object.init("github.com/gopherjs/gopherjs/js", [{prop: "object", name: "object", embedded: false, exported: false, typ: ptrType, tag: ""}]); - Error.init("", [{prop: "Object", name: "Object", embedded: true, exported: true, typ: ptrType, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/cpu"] = (function() { - var $pkg = {}, $init; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/bytealg"] = (function() { - var $pkg = {}, $init, cpu, Index, Cutover, IndexByteString; - cpu = $packages["internal/cpu"]; - Index = function(a, b) { - var a, b; - $panic(new $String("unimplemented")); - }; - $pkg.Index = Index; - Cutover = function(n) { - var n; - $panic(new $String("unimplemented")); - }; - $pkg.Cutover = Cutover; - IndexByteString = function(s, c) { - var c, i, s; - i = 0; - while (true) { - if (!(i < s.length)) { break; } - if (s.charCodeAt(i) === c) { - return i; - } - i = i + (1) >> 0; - } - return -1; - }; - $pkg.IndexByteString = IndexByteString; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = cpu.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.MaxLen = 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["runtime/internal/sys"] = (function() { - var $pkg = {}, $init; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["runtime"] = (function() { - var $pkg = {}, $init, js, bytealg, sys, _type, Func, TypeAssertionError, errorString, ptrType, ptrType$1, structType, ptrType$4, init, GOROOT, Caller, Goexit, SetFinalizer, FuncForPC, KeepAlive, throw$1; - js = $packages["github.com/gopherjs/gopherjs/js"]; - bytealg = $packages["internal/bytealg"]; - sys = $packages["runtime/internal/sys"]; - _type = $pkg._type = $newType(0, $kindStruct, "runtime._type", true, "runtime", false, function(str_) { - this.$val = this; - if (arguments.length === 0) { - this.str = ""; - return; - } - this.str = str_; - }); - Func = $pkg.Func = $newType(0, $kindStruct, "runtime.Func", true, "runtime", true, function(opaque_) { - this.$val = this; - if (arguments.length === 0) { - this.opaque = new structType.ptr(); - return; - } - this.opaque = opaque_; - }); - TypeAssertionError = $pkg.TypeAssertionError = $newType(0, $kindStruct, "runtime.TypeAssertionError", true, "runtime", true, function(_interface_, concrete_, asserted_, missingMethod_) { - this.$val = this; - if (arguments.length === 0) { - this._interface = ptrType.nil; - this.concrete = ptrType.nil; - this.asserted = ptrType.nil; - this.missingMethod = ""; - return; - } - this._interface = _interface_; - this.concrete = concrete_; - this.asserted = asserted_; - this.missingMethod = missingMethod_; - }); - errorString = $pkg.errorString = $newType(8, $kindString, "runtime.errorString", true, "runtime", false, null); - ptrType = $ptrType(_type); - ptrType$1 = $ptrType(Func); - structType = $structType("", []); - ptrType$4 = $ptrType(TypeAssertionError); - _type.ptr.prototype.string = function() { - var t; - t = this; - return t.str; - }; - _type.prototype.string = function() { return this.$val.string(); }; - _type.ptr.prototype.pkgpath = function() { - var t; - t = this; - return ""; - }; - _type.prototype.pkgpath = function() { return this.$val.pkgpath(); }; - init = function() { - var e, jsPkg; - jsPkg = $packages[$externalize("github.com/gopherjs/gopherjs/js", $String)]; - $jsObjectPtr = jsPkg.Object.ptr; - $jsErrorPtr = jsPkg.Error.ptr; - $throwRuntimeError = throw$1; - e = $ifaceNil; - e = new TypeAssertionError.ptr(ptrType.nil, ptrType.nil, ptrType.nil, ""); - $unused(e); - }; - GOROOT = function() { - var process, v, v$1; - process = $global.process; - if (process === undefined) { - return "/"; - } - v = process.env.GOPHERJS_GOROOT; - if (!(v === undefined)) { - return $internalize(v, $String); - } else { - v$1 = process.env.GOROOT; - if (!(v$1 === undefined)) { - return $internalize(v$1, $String); - } - } - return "/usr/local/go"; - }; - $pkg.GOROOT = GOROOT; - Caller = function(skip) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, file, info, line, ok, parts, pc, skip; - pc = 0; - file = ""; - line = 0; - ok = false; - info = new ($global.Error)().stack.split($externalize("\n", $String))[(skip + 2 >> 0)]; - if (info === undefined) { - _tmp = 0; - _tmp$1 = ""; - _tmp$2 = 0; - _tmp$3 = false; - pc = _tmp; - file = _tmp$1; - line = _tmp$2; - ok = _tmp$3; - return [pc, file, line, ok]; - } - parts = info.substring(($parseInt(info.indexOf($externalize("(", $String))) >> 0) + 1 >> 0, $parseInt(info.indexOf($externalize(")", $String))) >> 0).split($externalize(":", $String)); - _tmp$4 = 0; - _tmp$5 = $internalize(parts[0], $String); - _tmp$6 = $parseInt(parts[1]) >> 0; - _tmp$7 = true; - pc = _tmp$4; - file = _tmp$5; - line = _tmp$6; - ok = _tmp$7; - return [pc, file, line, ok]; - }; - $pkg.Caller = Caller; - Goexit = function() { - $curGoroutine.exit = $externalize(true, $Bool); - $throw(null); - }; - $pkg.Goexit = Goexit; - SetFinalizer = function(x, f) { - var f, x; - }; - $pkg.SetFinalizer = SetFinalizer; - Func.ptr.prototype.Entry = function() { - return 0; - }; - Func.prototype.Entry = function() { return this.$val.Entry(); }; - Func.ptr.prototype.FileLine = function(pc) { - var _tmp, _tmp$1, file, line, pc; - file = ""; - line = 0; - _tmp = ""; - _tmp$1 = 0; - file = _tmp; - line = _tmp$1; - return [file, line]; - }; - Func.prototype.FileLine = function(pc) { return this.$val.FileLine(pc); }; - Func.ptr.prototype.Name = function() { - return ""; - }; - Func.prototype.Name = function() { return this.$val.Name(); }; - FuncForPC = function(pc) { - var pc; - return ptrType$1.nil; - }; - $pkg.FuncForPC = FuncForPC; - KeepAlive = function(param) { - var param; - }; - $pkg.KeepAlive = KeepAlive; - throw$1 = function(s) { - var s; - $panic(new errorString((s))); - }; - TypeAssertionError.ptr.prototype.RuntimeError = function() { - }; - TypeAssertionError.prototype.RuntimeError = function() { return this.$val.RuntimeError(); }; - TypeAssertionError.ptr.prototype.Error = function() { - var as, cs, e, inter, msg; - e = this; - inter = "interface"; - if (!(e._interface === ptrType.nil)) { - inter = e._interface.string(); - } - as = e.asserted.string(); - if (e.concrete === ptrType.nil) { - return "interface conversion: " + inter + " is nil, not " + as; - } - cs = e.concrete.string(); - if (e.missingMethod === "") { - msg = "interface conversion: " + inter + " is " + cs + ", not " + as; - if (cs === as) { - if (!(e.concrete.pkgpath() === e.asserted.pkgpath())) { - msg = msg + (" (types from different packages)"); - } else { - msg = msg + (" (types from different scopes)"); - } - } - return msg; - } - return "interface conversion: " + cs + " is not " + as + ": missing method " + e.missingMethod; - }; - TypeAssertionError.prototype.Error = function() { return this.$val.Error(); }; - errorString.prototype.RuntimeError = function() { - var e; - e = this.$val; - }; - $ptrType(errorString).prototype.RuntimeError = function() { return new errorString(this.$get()).RuntimeError(); }; - errorString.prototype.Error = function() { - var e; - e = this.$val; - return "runtime error: " + (e); - }; - $ptrType(errorString).prototype.Error = function() { return new errorString(this.$get()).Error(); }; - ptrType.methods = [{prop: "string", name: "string", pkg: "runtime", typ: $funcType([], [$String], false)}, {prop: "pkgpath", name: "pkgpath", pkg: "runtime", typ: $funcType([], [$String], false)}]; - ptrType$1.methods = [{prop: "Entry", name: "Entry", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "FileLine", name: "FileLine", pkg: "", typ: $funcType([$Uintptr], [$String, $Int], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$4.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - errorString.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - _type.init("runtime", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); - Func.init("runtime", [{prop: "opaque", name: "opaque", embedded: false, exported: false, typ: structType, tag: ""}]); - TypeAssertionError.init("runtime", [{prop: "_interface", name: "_interface", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "concrete", name: "concrete", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "asserted", name: "asserted", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "missingMethod", name: "missingMethod", embedded: false, exported: false, typ: $String, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sys.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["errors"] = (function() { - var $pkg = {}, $init, errorString, ptrType, New; - errorString = $pkg.errorString = $newType(0, $kindStruct, "errors.errorString", true, "errors", false, function(s_) { - this.$val = this; - if (arguments.length === 0) { - this.s = ""; - return; - } - this.s = s_; - }); - ptrType = $ptrType(errorString); - New = function(text) { - var text; - return new errorString.ptr(text); - }; - $pkg.New = New; - errorString.ptr.prototype.Error = function() { - var e; - e = this; - return e.s; - }; - errorString.prototype.Error = function() { return this.$val.Error(); }; - ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - errorString.init("errors", [{prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/race"] = (function() { - var $pkg = {}, $init, Acquire, Release, ReleaseMerge, Disable, Enable, ReadRange, WriteRange; - Acquire = function(addr) { - var addr; - }; - $pkg.Acquire = Acquire; - Release = function(addr) { - var addr; - }; - $pkg.Release = Release; - ReleaseMerge = function(addr) { - var addr; - }; - $pkg.ReleaseMerge = ReleaseMerge; - Disable = function() { - }; - $pkg.Disable = Disable; - Enable = function() { - }; - $pkg.Enable = Enable; - ReadRange = function(addr, len) { - var addr, len; - }; - $pkg.ReadRange = ReadRange; - WriteRange = function(addr, len) { - var addr, len; - }; - $pkg.WriteRange = WriteRange; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["sync/atomic"] = (function() { - var $pkg = {}, $init, js, Value, ptrType, CompareAndSwapInt32, CompareAndSwapUint64, AddInt32, LoadInt32, LoadUint64, StoreInt32, StoreUint32; - js = $packages["github.com/gopherjs/gopherjs/js"]; - Value = $pkg.Value = $newType(0, $kindStruct, "atomic.Value", true, "sync/atomic", true, function(v_) { - this.$val = this; - if (arguments.length === 0) { - this.v = $ifaceNil; - return; - } - this.v = v_; - }); - ptrType = $ptrType(Value); - CompareAndSwapInt32 = function(addr, old, new$1) { - var addr, new$1, old; - if (addr.$get() === old) { - addr.$set(new$1); - return true; - } - return false; - }; - $pkg.CompareAndSwapInt32 = CompareAndSwapInt32; - CompareAndSwapUint64 = function(addr, old, new$1) { - var addr, new$1, old, x; - if ((x = addr.$get(), (x.$high === old.$high && x.$low === old.$low))) { - addr.$set(new$1); - return true; - } - return false; - }; - $pkg.CompareAndSwapUint64 = CompareAndSwapUint64; - AddInt32 = function(addr, delta) { - var addr, delta, new$1; - new$1 = addr.$get() + delta >> 0; - addr.$set(new$1); - return new$1; - }; - $pkg.AddInt32 = AddInt32; - LoadInt32 = function(addr) { - var addr; - return addr.$get(); - }; - $pkg.LoadInt32 = LoadInt32; - LoadUint64 = function(addr) { - var addr; - return addr.$get(); - }; - $pkg.LoadUint64 = LoadUint64; - StoreInt32 = function(addr, val) { - var addr, val; - addr.$set(val); - }; - $pkg.StoreInt32 = StoreInt32; - StoreUint32 = function(addr, val) { - var addr, val; - addr.$set(val); - }; - $pkg.StoreUint32 = StoreUint32; - Value.ptr.prototype.Load = function() { - var v, x; - x = $ifaceNil; - v = this; - x = v.v; - return x; - }; - Value.prototype.Load = function() { return this.$val.Load(); }; - Value.ptr.prototype.Store = function(x) { - var v, x; - v = this; - if ($interfaceIsEqual(x, $ifaceNil)) { - $panic(new $String("sync/atomic: store of nil value into Value")); - } - if (!($interfaceIsEqual(v.v, $ifaceNil)) && !(x.constructor === v.v.constructor)) { - $panic(new $String("sync/atomic: store of inconsistently typed value into Value")); - } - v.v = x; - }; - Value.prototype.Store = function(x) { return this.$val.Store(x); }; - ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface], [], false)}]; - Value.init("sync/atomic", [{prop: "v", name: "v", embedded: false, exported: false, typ: $emptyInterface, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["sync"] = (function() { - var $pkg = {}, $init, js, race, runtime, atomic, Pool, Mutex, Locker, poolLocalInternal, poolLocal, notifyList, RWMutex, rlocker, ptrType, sliceType, ptrType$1, chanType, sliceType$1, ptrType$6, ptrType$7, sliceType$4, ptrType$8, ptrType$9, funcType, ptrType$16, arrayType$2, semWaiters, semAwoken, expunged, allPools, runtime_registerPoolCleanup, runtime_SemacquireMutex, runtime_Semrelease, runtime_notifyListCheck, runtime_canSpin, runtime_nanotime, throw$1, poolCleanup, init, indexLocal, init$1, runtime_doSpin; - js = $packages["github.com/gopherjs/gopherjs/js"]; - race = $packages["internal/race"]; - runtime = $packages["runtime"]; - atomic = $packages["sync/atomic"]; - Pool = $pkg.Pool = $newType(0, $kindStruct, "sync.Pool", true, "sync", true, function(local_, localSize_, store_, New_) { - this.$val = this; - if (arguments.length === 0) { - this.local = 0; - this.localSize = 0; - this.store = sliceType$4.nil; - this.New = $throwNilPointerError; - return; - } - this.local = local_; - this.localSize = localSize_; - this.store = store_; - this.New = New_; - }); - Mutex = $pkg.Mutex = $newType(0, $kindStruct, "sync.Mutex", true, "sync", true, function(state_, sema_) { - this.$val = this; - if (arguments.length === 0) { - this.state = 0; - this.sema = 0; - return; - } - this.state = state_; - this.sema = sema_; - }); - Locker = $pkg.Locker = $newType(8, $kindInterface, "sync.Locker", true, "sync", true, null); - poolLocalInternal = $pkg.poolLocalInternal = $newType(0, $kindStruct, "sync.poolLocalInternal", true, "sync", false, function(private$0_, shared_, Mutex_) { - this.$val = this; - if (arguments.length === 0) { - this.private$0 = $ifaceNil; - this.shared = sliceType$4.nil; - this.Mutex = new Mutex.ptr(0, 0); - return; - } - this.private$0 = private$0_; - this.shared = shared_; - this.Mutex = Mutex_; - }); - poolLocal = $pkg.poolLocal = $newType(0, $kindStruct, "sync.poolLocal", true, "sync", false, function(poolLocalInternal_, pad_) { - this.$val = this; - if (arguments.length === 0) { - this.poolLocalInternal = new poolLocalInternal.ptr($ifaceNil, sliceType$4.nil, new Mutex.ptr(0, 0)); - this.pad = arrayType$2.zero(); - return; - } - this.poolLocalInternal = poolLocalInternal_; - this.pad = pad_; - }); - notifyList = $pkg.notifyList = $newType(0, $kindStruct, "sync.notifyList", true, "sync", false, function(wait_, notify_, lock_, head_, tail_) { - this.$val = this; - if (arguments.length === 0) { - this.wait = 0; - this.notify = 0; - this.lock = 0; - this.head = 0; - this.tail = 0; - return; - } - this.wait = wait_; - this.notify = notify_; - this.lock = lock_; - this.head = head_; - this.tail = tail_; - }); - RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "sync.RWMutex", true, "sync", true, function(w_, writerSem_, readerSem_, readerCount_, readerWait_) { - this.$val = this; - if (arguments.length === 0) { - this.w = new Mutex.ptr(0, 0); - this.writerSem = 0; - this.readerSem = 0; - this.readerCount = 0; - this.readerWait = 0; - return; - } - this.w = w_; - this.writerSem = writerSem_; - this.readerSem = readerSem_; - this.readerCount = readerCount_; - this.readerWait = readerWait_; - }); - rlocker = $pkg.rlocker = $newType(0, $kindStruct, "sync.rlocker", true, "sync", false, function(w_, writerSem_, readerSem_, readerCount_, readerWait_) { - this.$val = this; - if (arguments.length === 0) { - this.w = new Mutex.ptr(0, 0); - this.writerSem = 0; - this.readerSem = 0; - this.readerCount = 0; - this.readerWait = 0; - return; - } - this.w = w_; - this.writerSem = writerSem_; - this.readerSem = readerSem_; - this.readerCount = readerCount_; - this.readerWait = readerWait_; - }); - ptrType = $ptrType(Pool); - sliceType = $sliceType(ptrType); - ptrType$1 = $ptrType($Uint32); - chanType = $chanType($Bool, false, false); - sliceType$1 = $sliceType(chanType); - ptrType$6 = $ptrType($Int32); - ptrType$7 = $ptrType(poolLocal); - sliceType$4 = $sliceType($emptyInterface); - ptrType$8 = $ptrType(rlocker); - ptrType$9 = $ptrType(RWMutex); - funcType = $funcType([], [$emptyInterface], false); - ptrType$16 = $ptrType(Mutex); - arrayType$2 = $arrayType($Uint8, 100); - Pool.ptr.prototype.Get = function() { - var _r, p, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - /* */ if (p.store.$length === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (p.store.$length === 0) { */ case 1: - /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!(p.New === $throwNilPointerError)) { */ case 3: - _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 4: - $s = -1; return $ifaceNil; - /* } */ case 2: - x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); - $s = -1; return x$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Pool.prototype.Get = function() { return this.$val.Get(); }; - Pool.ptr.prototype.Put = function(x) { - var p, x; - p = this; - if ($interfaceIsEqual(x, $ifaceNil)) { - return; - } - p.store = $append(p.store, x); - }; - Pool.prototype.Put = function(x) { return this.$val.Put(x); }; - runtime_registerPoolCleanup = function(cleanup) { - var cleanup; - }; - runtime_SemacquireMutex = function(s, lifo) { - var _entry, _entry$1, _entry$2, _entry$3, _entry$4, _key, _key$1, _key$2, _r, ch, lifo, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _r = $f._r; ch = $f.ch; lifo = $f.lifo; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { */ case 1: - ch = new $Chan($Bool, 0); - if (lifo) { - _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: $appendSlice(new sliceType$1([ch]), (_entry$1 = semWaiters[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : sliceType$1.nil)) }; - } else { - _key$1 = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: $append((_entry$2 = semWaiters[ptrType$1.keyFor(s)], _entry$2 !== undefined ? _entry$2.v : sliceType$1.nil), ch) }; - } - _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r[0]; - _key$2 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$2)] = { k: _key$2, v: (_entry$3 = semAwoken[ptrType$1.keyFor(s)], _entry$3 !== undefined ? _entry$3.v : 0) - (1) >>> 0 }; - if ((_entry$4 = semAwoken[ptrType$1.keyFor(s)], _entry$4 !== undefined ? _entry$4.v : 0) === 0) { - delete semAwoken[ptrType$1.keyFor(s)]; - } - /* } */ case 2: - s.$set(s.$get() - (1) >>> 0); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_SemacquireMutex }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._r = _r; $f.ch = ch; $f.lifo = lifo; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - runtime_Semrelease = function(s, handoff) { - var _entry, _entry$1, _key, _key$1, ch, handoff, s, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _key = $f._key; _key$1 = $f._key$1; ch = $f.ch; handoff = $f.handoff; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s.$set(s.$get() + (1) >>> 0); - w = (_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil); - if (w.$length === 0) { - $s = -1; return; - } - ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); - w = $subslice(w, 1); - _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: w }; - if (w.$length === 0) { - delete semWaiters[ptrType$1.keyFor(s)]; - } - _key$1 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: (_entry$1 = semAwoken[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : 0) + (1) >>> 0 }; - $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._key = _key; $f._key$1 = _key$1; $f.ch = ch; $f.handoff = handoff; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - runtime_notifyListCheck = function(size) { - var size; - }; - runtime_canSpin = function(i) { - var i; - return false; - }; - runtime_nanotime = function() { - return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); - }; - throw$1 = function(s) { - var s; - $throwRuntimeError($externalize(s, $String)); - }; - Mutex.ptr.prototype.Lock = function() { - var awoke, delta, iter, m, new$1, old, queueLifo, starving, waitStartTime, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; awoke = $f.awoke; delta = $f.delta; iter = $f.iter; m = $f.m; new$1 = $f.new$1; old = $f.old; queueLifo = $f.queueLifo; starving = $f.starving; waitStartTime = $f.waitStartTime; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - m = this; - if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), 0, 1)) { - if (false) { - race.Acquire((m)); - } - $s = -1; return; - } - waitStartTime = new $Int64(0, 0); - starving = false; - awoke = false; - iter = 0; - old = m.state; - /* while (true) { */ case 1: - /* */ if (((old & 5) === 1) && runtime_canSpin(iter)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (((old & 5) === 1) && runtime_canSpin(iter)) { */ case 3: - if (!awoke && ((old & 2) === 0) && !(((old >> 3 >> 0) === 0)) && atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, old | 2)) { - awoke = true; - } - runtime_doSpin(); - iter = iter + (1) >> 0; - old = m.state; - /* continue; */ $s = 1; continue; - /* } */ case 4: - new$1 = old; - if ((old & 4) === 0) { - new$1 = new$1 | (1); - } - if (!(((old & 5) === 0))) { - new$1 = new$1 + (8) >> 0; - } - if (starving && !(((old & 1) === 0))) { - new$1 = new$1 | (4); - } - if (awoke) { - if ((new$1 & 2) === 0) { - throw$1("sync: inconsistent mutex state"); - } - new$1 = (new$1 & ~(2)) >> 0; - } - /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 5: - if ((old & 5) === 0) { - /* break; */ $s = 2; continue; - } - queueLifo = !((waitStartTime.$high === 0 && waitStartTime.$low === 0)); - if ((waitStartTime.$high === 0 && waitStartTime.$low === 0)) { - waitStartTime = runtime_nanotime(); - } - $r = runtime_SemacquireMutex((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), queueLifo); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - starving = starving || (x = (x$1 = runtime_nanotime(), new $Int64(x$1.$high - waitStartTime.$high, x$1.$low - waitStartTime.$low)), (x.$high > 0 || (x.$high === 0 && x.$low > 1000000))); - old = m.state; - if (!(((old & 4) === 0))) { - if (!(((old & 3) === 0)) || ((old >> 3 >> 0) === 0)) { - throw$1("sync: inconsistent mutex state"); - } - delta = -7; - if (!starving || ((old >> 3 >> 0) === 1)) { - delta = delta - (4) >> 0; - } - atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), delta); - /* break; */ $s = 2; continue; - } - awoke = true; - iter = 0; - $s = 7; continue; - /* } else { */ case 6: - old = m.state; - /* } */ case 7: - /* } */ $s = 1; continue; case 2: - if (false) { - race.Acquire((m)); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Lock }; } $f.awoke = awoke; $f.delta = delta; $f.iter = iter; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.queueLifo = queueLifo; $f.starving = starving; $f.waitStartTime = waitStartTime; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Mutex.prototype.Lock = function() { return this.$val.Lock(); }; - Mutex.ptr.prototype.Unlock = function() { - var m, new$1, old, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; m = $f.m; new$1 = $f.new$1; old = $f.old; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - m = this; - if (false) { - $unused(m.state); - race.Release((m)); - } - new$1 = atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), -1); - if ((((new$1 + 1 >> 0)) & 1) === 0) { - throw$1("sync: unlock of unlocked mutex"); - } - /* */ if ((new$1 & 4) === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((new$1 & 4) === 0) { */ case 1: - old = new$1; - /* while (true) { */ case 4: - if (((old >> 3 >> 0) === 0) || !(((old & 7) === 0))) { - $s = -1; return; - } - new$1 = ((old - 8 >> 0)) | 2; - /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 6: - $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), false); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 7: - old = m.state; - /* } */ $s = 4; continue; case 5: - $s = 3; continue; - /* } else { */ case 2: - $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), true); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 3: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Unlock }; } $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f; - }; - Mutex.prototype.Unlock = function() { return this.$val.Unlock(); }; - poolCleanup = function() { - var _i, _i$1, _ref, _ref$1, i, i$1, j, l, p, x; - _ref = allPools; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - p = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - ((i < 0 || i >= allPools.$length) ? ($throwRuntimeError("index out of range"), undefined) : allPools.$array[allPools.$offset + i] = ptrType.nil); - i$1 = 0; - while (true) { - if (!(i$1 < ((p.localSize >> 0)))) { break; } - l = indexLocal(p.local, i$1); - l.poolLocalInternal.private$0 = $ifaceNil; - _ref$1 = l.poolLocalInternal.shared; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - j = _i$1; - (x = l.poolLocalInternal.shared, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j] = $ifaceNil)); - _i$1++; - } - l.poolLocalInternal.shared = sliceType$4.nil; - i$1 = i$1 + (1) >> 0; - } - p.local = 0; - p.localSize = 0; - _i++; - } - allPools = new sliceType([]); - }; - init = function() { - runtime_registerPoolCleanup(poolCleanup); - }; - indexLocal = function(l, i) { - var i, l, lp; - lp = (((l) + ($imul(((i >>> 0)), 128) >>> 0) >>> 0)); - return ($pointerOfStructConversion(lp, ptrType$7)); - }; - init$1 = function() { - var n; - n = new notifyList.ptr(0, 0, 0, 0, 0); - runtime_notifyListCheck(20); - }; - runtime_doSpin = function() { - $throwRuntimeError("native function not implemented: sync.runtime_doSpin"); - }; - RWMutex.ptr.prototype.RLock = function() { - var rw, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - rw = this; - if (false) { - $unused(rw.w.state); - race.Disable(); - } - /* */ if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { */ case 1: - $r = runtime_SemacquireMutex((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))), false); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (false) { - race.Enable(); - race.Acquire(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RLock }; } $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; - }; - RWMutex.prototype.RLock = function() { return this.$val.RLock(); }; - RWMutex.ptr.prototype.RUnlock = function() { - var r, rw, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - rw = this; - if (false) { - $unused(rw.w.state); - race.ReleaseMerge(((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))))); - race.Disable(); - } - r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1); - /* */ if (r < 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (r < 0) { */ case 1: - if (((r + 1 >> 0) === 0) || ((r + 1 >> 0) === -1073741824)) { - race.Enable(); - throw$1("sync: RUnlock of unlocked RWMutex"); - } - /* */ if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { */ case 3: - $r = runtime_Semrelease((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))), false); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 4: - /* } */ case 2: - if (false) { - race.Enable(); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RUnlock }; } $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; - }; - RWMutex.prototype.RUnlock = function() { return this.$val.RUnlock(); }; - RWMutex.ptr.prototype.Lock = function() { - var r, rw, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - rw = this; - if (false) { - $unused(rw.w.state); - race.Disable(); - } - $r = rw.w.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1073741824) + 1073741824 >> 0; - /* */ if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$6(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { */ case 2: - $r = runtime_SemacquireMutex((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))), false); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 3: - if (false) { - race.Enable(); - race.Acquire(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); - race.Acquire(((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw))))); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Lock }; } $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; - }; - RWMutex.prototype.Lock = function() { return this.$val.Lock(); }; - RWMutex.ptr.prototype.Unlock = function() { - var i, r, rw, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; i = $f.i; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - rw = this; - if (false) { - $unused(rw.w.state); - race.Release(((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))))); - race.Disable(); - } - r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$6(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1073741824); - if (r >= 1073741824) { - race.Enable(); - throw$1("sync: Unlock of unlocked RWMutex"); - } - i = 0; - /* while (true) { */ case 1: - /* if (!(i < ((r >> 0)))) { break; } */ if(!(i < ((r >> 0)))) { $s = 2; continue; } - $r = runtime_Semrelease((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw))), false); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $r = rw.w.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - if (false) { - race.Enable(); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Unlock }; } $f.i = i; $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f; - }; - RWMutex.prototype.Unlock = function() { return this.$val.Unlock(); }; - RWMutex.ptr.prototype.RLocker = function() { - var rw; - rw = this; - return ($pointerOfStructConversion(rw, ptrType$8)); - }; - RWMutex.prototype.RLocker = function() { return this.$val.RLocker(); }; - rlocker.ptr.prototype.Lock = function() { - var r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - $r = ($pointerOfStructConversion(r, ptrType$9)).RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Lock }; } $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - rlocker.prototype.Lock = function() { return this.$val.Lock(); }; - rlocker.ptr.prototype.Unlock = function() { - var r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - $r = ($pointerOfStructConversion(r, ptrType$9)).RUnlock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Unlock }; } $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - rlocker.prototype.Unlock = function() { return this.$val.Unlock(); }; - ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "getSlow", name: "getSlow", pkg: "sync", typ: $funcType([], [$emptyInterface], false)}, {prop: "pin", name: "pin", pkg: "sync", typ: $funcType([], [ptrType$7], false)}, {prop: "pinSlow", name: "pinSlow", pkg: "sync", typ: $funcType([], [ptrType$7], false)}]; - ptrType$16.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; - ptrType$9.methods = [{prop: "RLock", name: "RLock", pkg: "", typ: $funcType([], [], false)}, {prop: "RUnlock", name: "RUnlock", pkg: "", typ: $funcType([], [], false)}, {prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}, {prop: "RLocker", name: "RLocker", pkg: "", typ: $funcType([], [Locker], false)}]; - ptrType$8.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; - Pool.init("sync", [{prop: "local", name: "local", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "localSize", name: "localSize", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "store", name: "store", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: funcType, tag: ""}]); - Mutex.init("sync", [{prop: "state", name: "state", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "sema", name: "sema", embedded: false, exported: false, typ: $Uint32, tag: ""}]); - Locker.init([{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]); - poolLocalInternal.init("sync", [{prop: "private$0", name: "private", embedded: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "shared", name: "shared", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: Mutex, tag: ""}]); - poolLocal.init("sync", [{prop: "poolLocalInternal", name: "poolLocalInternal", embedded: true, exported: false, typ: poolLocalInternal, tag: ""}, {prop: "pad", name: "pad", embedded: false, exported: false, typ: arrayType$2, tag: ""}]); - notifyList.init("sync", [{prop: "wait", name: "wait", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "notify", name: "notify", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "lock", name: "lock", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "head", name: "head", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "tail", name: "tail", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}]); - RWMutex.init("sync", [{prop: "w", name: "w", embedded: false, exported: false, typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", embedded: false, exported: false, typ: $Int32, tag: ""}]); - rlocker.init("sync", [{prop: "w", name: "w", embedded: false, exported: false, typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", embedded: false, exported: false, typ: $Int32, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - allPools = sliceType.nil; - semWaiters = {}; - semAwoken = {}; - expunged = (new Uint8Array(8)); - init(); - init$1(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["io"] = (function() { - var $pkg = {}, $init, errors, sync, atomic, Reader, Writer, ByteScanner, RuneReader, RuneScanner, StringWriter, sliceType, errWhence, errOffset, WriteString, ReadAtLeast, ReadFull; - errors = $packages["errors"]; - sync = $packages["sync"]; - atomic = $packages["sync/atomic"]; - Reader = $pkg.Reader = $newType(8, $kindInterface, "io.Reader", true, "io", true, null); - Writer = $pkg.Writer = $newType(8, $kindInterface, "io.Writer", true, "io", true, null); - ByteScanner = $pkg.ByteScanner = $newType(8, $kindInterface, "io.ByteScanner", true, "io", true, null); - RuneReader = $pkg.RuneReader = $newType(8, $kindInterface, "io.RuneReader", true, "io", true, null); - RuneScanner = $pkg.RuneScanner = $newType(8, $kindInterface, "io.RuneScanner", true, "io", true, null); - StringWriter = $pkg.StringWriter = $newType(8, $kindInterface, "io.StringWriter", true, "io", true, null); - sliceType = $sliceType($Uint8); - WriteString = function(w, s) { - var _r, _r$1, _tuple, _tuple$1, _tuple$2, err, n, ok, s, sw, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; n = $f.n; ok = $f.ok; s = $f.s; sw = $f.sw; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - _tuple = $assertType(w, StringWriter, true); - sw = _tuple[0]; - ok = _tuple[1]; - /* */ if (ok) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (ok) { */ case 1: - _r = sw.WriteString(s); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$1 = _r; - n = _tuple$1[0]; - err = _tuple$1[1]; - $s = -1; return [n, err]; - /* } */ case 2: - _r$1 = w.Write((new sliceType($stringToBytes(s)))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$2 = _r$1; - n = _tuple$2[0]; - err = _tuple$2[1]; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: WriteString }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.n = n; $f.ok = ok; $f.s = s; $f.sw = sw; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.WriteString = WriteString; - ReadAtLeast = function(r, buf, min) { - var _r, _tmp, _tmp$1, _tuple, buf, err, min, n, nn, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; buf = $f.buf; err = $f.err; min = $f.min; n = $f.n; nn = $f.nn; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - if (buf.$length < min) { - _tmp = 0; - _tmp$1 = $pkg.ErrShortBuffer; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - /* while (true) { */ case 1: - /* if (!(n < min && $interfaceIsEqual(err, $ifaceNil))) { break; } */ if(!(n < min && $interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } - nn = 0; - _r = r.Read($subslice(buf, n)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - nn = _tuple[0]; - err = _tuple[1]; - n = n + (nn) >> 0; - /* } */ $s = 1; continue; case 2: - if (n >= min) { - err = $ifaceNil; - } else if (n > 0 && $interfaceIsEqual(err, $pkg.EOF)) { - err = $pkg.ErrUnexpectedEOF; - } - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: ReadAtLeast }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.min = min; $f.n = n; $f.nn = nn; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.ReadAtLeast = ReadAtLeast; - ReadFull = function(r, buf) { - var _r, _tuple, buf, err, n, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; err = $f.err; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - _r = ReadAtLeast(r, buf, buf.$length); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: ReadFull }; } $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.ReadFull = ReadFull; - Reader.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); - Writer.init([{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); - ByteScanner.init([{prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}]); - RuneReader.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}]); - RuneScanner.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]); - StringWriter.init([{prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = atomic.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.ErrShortWrite = errors.New("short write"); - $pkg.ErrShortBuffer = errors.New("short buffer"); - $pkg.EOF = errors.New("EOF"); - $pkg.ErrUnexpectedEOF = errors.New("unexpected EOF"); - $pkg.ErrNoProgress = errors.New("multiple Read calls return no data or error"); - errWhence = errors.New("Seek: invalid whence"); - errOffset = errors.New("Seek: invalid offset"); - $pkg.ErrClosedPipe = errors.New("io: read/write on closed pipe"); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["hash"] = (function() { - var $pkg = {}, $init, io, Hash, sliceType; - io = $packages["io"]; - Hash = $pkg.Hash = $newType(8, $kindInterface, "hash.Hash", true, "hash", true, null); - sliceType = $sliceType($Uint8); - Hash.init([{prop: "BlockSize", name: "BlockSize", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Sum", name: "Sum", pkg: "", typ: $funcType([sliceType], [sliceType], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = io.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["math/bits"] = (function() { - var $pkg = {}, $init, deBruijn32tab, deBruijn64tab, len8tab, LeadingZeros, LeadingZeros64, TrailingZeros, TrailingZeros32, TrailingZeros64, Len, Len32, Len64; - LeadingZeros = function(x) { - var x; - return 32 - Len(x) >> 0; - }; - $pkg.LeadingZeros = LeadingZeros; - LeadingZeros64 = function(x) { - var x; - return 64 - Len64(x) >> 0; - }; - $pkg.LeadingZeros64 = LeadingZeros64; - TrailingZeros = function(x) { - var x; - if (true) { - return TrailingZeros32(((x >>> 0))); - } - return TrailingZeros64((new $Uint64(0, x))); - }; - $pkg.TrailingZeros = TrailingZeros; - TrailingZeros32 = function(x) { - var x, x$1; - if (x === 0) { - return 32; - } - return (((x$1 = ($imul((((x & (-x >>> 0)) >>> 0)), 125613361) >>> 0) >>> 27 >>> 0, ((x$1 < 0 || x$1 >= deBruijn32tab.length) ? ($throwRuntimeError("index out of range"), undefined) : deBruijn32tab[x$1])) >> 0)); - }; - $pkg.TrailingZeros32 = TrailingZeros32; - TrailingZeros64 = function(x) { - var x, x$1, x$2; - if ((x.$high === 0 && x.$low === 0)) { - return 64; - } - return (((x$1 = $shiftRightUint64($mul64(((x$2 = new $Uint64(-x.$high, -x.$low), new $Uint64(x.$high & x$2.$high, (x.$low & x$2.$low) >>> 0))), new $Uint64(66559345, 3033172745)), 58), (($flatten64(x$1) < 0 || $flatten64(x$1) >= deBruijn64tab.length) ? ($throwRuntimeError("index out of range"), undefined) : deBruijn64tab[$flatten64(x$1)])) >> 0)); - }; - $pkg.TrailingZeros64 = TrailingZeros64; - Len = function(x) { - var x; - if (true) { - return Len32(((x >>> 0))); - } - return Len64((new $Uint64(0, x))); - }; - $pkg.Len = Len; - Len32 = function(x) { - var n, x, y, y$1; - n = 0; - if (x >= 65536) { - x = (y = (16), y < 32 ? (x >>> y) : 0) >>> 0; - n = 16; - } - if (x >= 256) { - x = (y$1 = (8), y$1 < 32 ? (x >>> y$1) : 0) >>> 0; - n = n + (8) >> 0; - } - n = n + ((((x < 0 || x >= len8tab.length) ? ($throwRuntimeError("index out of range"), undefined) : len8tab[x]) >> 0)) >> 0; - return n; - }; - $pkg.Len32 = Len32; - Len64 = function(x) { - var n, x; - n = 0; - if ((x.$high > 1 || (x.$high === 1 && x.$low >= 0))) { - x = $shiftRightUint64(x, (32)); - n = 32; - } - if ((x.$high > 0 || (x.$high === 0 && x.$low >= 65536))) { - x = $shiftRightUint64(x, (16)); - n = n + (16) >> 0; - } - if ((x.$high > 0 || (x.$high === 0 && x.$low >= 256))) { - x = $shiftRightUint64(x, (8)); - n = n + (8) >> 0; - } - n = n + (((($flatten64(x) < 0 || $flatten64(x) >= len8tab.length) ? ($throwRuntimeError("index out of range"), undefined) : len8tab[$flatten64(x)]) >> 0)) >> 0; - return n; - }; - $pkg.Len64 = Len64; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - deBruijn32tab = $toNativeArray($kindUint8, [0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9]); - deBruijn64tab = $toNativeArray($kindUint8, [0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6]); - len8tab = $toNativeArray($kindUint8, [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["math"] = (function() { - var $pkg = {}, $init, js, bits, arrayType, arrayType$1, arrayType$2, structType, math, zero, posInf, negInf, nan, buf, Ceil, Copysign, Exp, Floor, Frexp, Inf, IsInf, IsNaN, Ldexp, Log, Log2, Max, NaN, Pow, Signbit, Sqrt, init, Float32bits, Float32frombits, Float64bits, Float64frombits, Abs, normalize, max, Round, frexp, ldexp, log2; - js = $packages["github.com/gopherjs/gopherjs/js"]; - bits = $packages["math/bits"]; - arrayType = $arrayType($Uint32, 2); - arrayType$1 = $arrayType($Float32, 2); - arrayType$2 = $arrayType($Float64, 1); - structType = $structType("math", [{prop: "uint32array", name: "uint32array", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "float32array", name: "float32array", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "float64array", name: "float64array", embedded: false, exported: false, typ: arrayType$2, tag: ""}]); - Ceil = function(x) { - var x; - return $parseFloat(math.ceil(x)); - }; - $pkg.Ceil = Ceil; - Copysign = function(x, y) { - var x, y; - if (!((x < 0 || (1 / x === negInf)) === (y < 0 || (1 / y === negInf)))) { - return -x; - } - return x; - }; - $pkg.Copysign = Copysign; - Exp = function(x) { - var x; - return $parseFloat(math.exp(x)); - }; - $pkg.Exp = Exp; - Floor = function(x) { - var x; - return $parseFloat(math.floor(x)); - }; - $pkg.Floor = Floor; - Frexp = function(f) { - var _tuple, exp$1, f, frac; - frac = 0; - exp$1 = 0; - _tuple = frexp(f); - frac = _tuple[0]; - exp$1 = _tuple[1]; - return [frac, exp$1]; - }; - $pkg.Frexp = Frexp; - Inf = function(sign) { - var sign; - if (sign >= 0) { - return posInf; - } else { - return negInf; - } - }; - $pkg.Inf = Inf; - IsInf = function(f, sign) { - var f, sign; - if (f === posInf) { - return sign >= 0; - } - if (f === negInf) { - return sign <= 0; - } - return false; - }; - $pkg.IsInf = IsInf; - IsNaN = function(f) { - var f, is; - is = false; - is = !((f === f)); - return is; - }; - $pkg.IsNaN = IsNaN; - Ldexp = function(frac, exp$1) { - var exp$1, frac; - if (-1024 < exp$1 && exp$1 < 1024) { - if (frac === 0) { - return frac; - } - return frac * $parseFloat(math.pow(2, exp$1)); - } - return ldexp(frac, exp$1); - }; - $pkg.Ldexp = Ldexp; - Log = function(x) { - var x; - if (!((x === x))) { - return nan; - } - return $parseFloat(math.log(x)); - }; - $pkg.Log = Log; - Log2 = function(x) { - var x; - return log2(x); - }; - $pkg.Log2 = Log2; - Max = function(x, y) { - var x, y; - return max(x, y); - }; - $pkg.Max = Max; - NaN = function() { - return nan; - }; - $pkg.NaN = NaN; - Pow = function(x, y) { - var x, y; - if ((x === 1) || ((x === -1) && ((y === posInf) || (y === negInf)))) { - return 1; - } - return $parseFloat(math.pow(x, y)); - }; - $pkg.Pow = Pow; - Signbit = function(x) { - var x; - return x < 0 || (1 / x === negInf); - }; - $pkg.Signbit = Signbit; - Sqrt = function(x) { - var x; - return $parseFloat(math.sqrt(x)); - }; - $pkg.Sqrt = Sqrt; - init = function() { - var ab; - ab = new ($global.ArrayBuffer)(8); - buf.uint32array = new ($global.Uint32Array)(ab); - buf.float32array = new ($global.Float32Array)(ab); - buf.float64array = new ($global.Float64Array)(ab); - }; - Float32bits = function(f) { - var f; - buf.float32array[0] = f; - return buf.uint32array[0]; - }; - $pkg.Float32bits = Float32bits; - Float32frombits = function(b) { - var b; - buf.uint32array[0] = b; - return buf.float32array[0]; - }; - $pkg.Float32frombits = Float32frombits; - Float64bits = function(f) { - var f, x, x$1; - buf.float64array[0] = f; - return (x = $shiftLeft64((new $Uint64(0, buf.uint32array[1])), 32), x$1 = (new $Uint64(0, buf.uint32array[0])), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); - }; - $pkg.Float64bits = Float64bits; - Float64frombits = function(b) { - var b; - buf.uint32array[0] = ((b.$low >>> 0)); - buf.uint32array[1] = (($shiftRightUint64(b, 32).$low >>> 0)); - return buf.float64array[0]; - }; - $pkg.Float64frombits = Float64frombits; - Abs = function(x) { - var x, x$1; - return Float64frombits((x$1 = Float64bits(x), new $Uint64(x$1.$high & ~2147483648, (x$1.$low & ~0) >>> 0))); - }; - $pkg.Abs = Abs; - normalize = function(x) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, exp$1, x, y; - y = 0; - exp$1 = 0; - if (Abs(x) < 2.2250738585072014e-308) { - _tmp = x * 4.503599627370496e+15; - _tmp$1 = -52; - y = _tmp; - exp$1 = _tmp$1; - return [y, exp$1]; - } - _tmp$2 = x; - _tmp$3 = 0; - y = _tmp$2; - exp$1 = _tmp$3; - return [y, exp$1]; - }; - max = function(x, y) { - var x, y; - if (IsInf(x, 1) || IsInf(y, 1)) { - return Inf(1); - } else if (IsNaN(x) || IsNaN(y)) { - return NaN(); - } else if ((x === 0) && (x === y)) { - if (Signbit(x)) { - return y; - } - return x; - } - if (x > y) { - return x; - } - return y; - }; - Round = function(x) { - var bits$1, e, x, x$1, x$2, x$3, x$4; - bits$1 = Float64bits(x); - e = ((($shiftRightUint64(bits$1, 52).$low >>> 0)) & 2047) >>> 0; - if (e < 1023) { - bits$1 = (x$1 = new $Uint64(2147483648, 0), new $Uint64(bits$1.$high & x$1.$high, (bits$1.$low & x$1.$low) >>> 0)); - if (e === 1022) { - bits$1 = (x$2 = new $Uint64(1072693248, 0), new $Uint64(bits$1.$high | x$2.$high, (bits$1.$low | x$2.$low) >>> 0)); - } - } else if (e < 1075) { - e = e - (1023) >>> 0; - bits$1 = (x$3 = $shiftRightUint64(new $Uint64(524288, 0), e), new $Uint64(bits$1.$high + x$3.$high, bits$1.$low + x$3.$low)); - bits$1 = (x$4 = $shiftRightUint64(new $Uint64(1048575, 4294967295), e), new $Uint64(bits$1.$high & ~x$4.$high, (bits$1.$low & ~x$4.$low) >>> 0)); - } - return Float64frombits(bits$1); - }; - $pkg.Round = Round; - frexp = function(f) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, exp$1, f, frac, x, x$1, x$2, x$3; - frac = 0; - exp$1 = 0; - if ((f === 0)) { - _tmp = f; - _tmp$1 = 0; - frac = _tmp; - exp$1 = _tmp$1; - return [frac, exp$1]; - } else if (IsInf(f, 0) || IsNaN(f)) { - _tmp$2 = f; - _tmp$3 = 0; - frac = _tmp$2; - exp$1 = _tmp$3; - return [frac, exp$1]; - } - _tuple = normalize(f); - f = _tuple[0]; - exp$1 = _tuple[1]; - x = Float64bits(f); - exp$1 = exp$1 + ((((((x$1 = $shiftRightUint64(x, 52), new $Uint64(x$1.$high & 0, (x$1.$low & 2047) >>> 0)).$low >> 0)) - 1023 >> 0) + 1 >> 0)) >> 0; - x = (x$2 = new $Uint64(2146435072, 0), new $Uint64(x.$high & ~x$2.$high, (x.$low & ~x$2.$low) >>> 0)); - x = (x$3 = new $Uint64(1071644672, 0), new $Uint64(x.$high | x$3.$high, (x.$low | x$3.$low) >>> 0)); - frac = Float64frombits(x); - return [frac, exp$1]; - }; - ldexp = function(frac, exp$1) { - var _tuple, e, exp$1, frac, m, x, x$1, x$2; - if ((frac === 0)) { - return frac; - } else if (IsInf(frac, 0) || IsNaN(frac)) { - return frac; - } - _tuple = normalize(frac); - frac = _tuple[0]; - e = _tuple[1]; - exp$1 = exp$1 + (e) >> 0; - x = Float64bits(frac); - exp$1 = exp$1 + ((((($shiftRightUint64(x, 52).$low >> 0)) & 2047) - 1023 >> 0)) >> 0; - if (exp$1 < -1075) { - return Copysign(0, frac); - } - if (exp$1 > 1023) { - if (frac < 0) { - return Inf(-1); - } - return Inf(1); - } - m = 1; - if (exp$1 < -1022) { - exp$1 = exp$1 + (53) >> 0; - m = 1.1102230246251565e-16; - } - x = (x$1 = new $Uint64(2146435072, 0), new $Uint64(x.$high & ~x$1.$high, (x.$low & ~x$1.$low) >>> 0)); - x = (x$2 = $shiftLeft64((new $Uint64(0, (exp$1 + 1023 >> 0))), 52), new $Uint64(x.$high | x$2.$high, (x.$low | x$2.$low) >>> 0)); - return m * Float64frombits(x); - }; - log2 = function(x) { - var _tuple, exp$1, frac, x; - _tuple = Frexp(x); - frac = _tuple[0]; - exp$1 = _tuple[1]; - if (frac === 0.5) { - return ((exp$1 - 1 >> 0)); - } - return Log(frac) * 1.4426950408889634 + (exp$1); - }; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bits.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - buf = new structType.ptr(arrayType.zero(), arrayType$1.zero(), arrayType$2.zero()); - math = $global.Math; - zero = 0; - posInf = 1 / zero; - negInf = -1 / zero; - nan = 0 / zero; - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["unicode/utf8"] = (function() { - var $pkg = {}, $init, acceptRange, first, acceptRanges, DecodeRune, DecodeRuneInString, DecodeLastRune, DecodeLastRuneInString, RuneLen, EncodeRune, RuneCount, RuneCountInString, RuneStart, ValidString, ValidRune; - acceptRange = $pkg.acceptRange = $newType(0, $kindStruct, "utf8.acceptRange", true, "unicode/utf8", false, function(lo_, hi_) { - this.$val = this; - if (arguments.length === 0) { - this.lo = 0; - this.hi = 0; - return; - } - this.lo = lo_; - this.hi = hi_; - }); - DecodeRune = function(p) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, accept, b1, b2, b3, mask, n, p, p0, r, size, sz, x, x$1; - r = 0; - size = 0; - n = p.$length; - if (n < 1) { - _tmp = 65533; - _tmp$1 = 0; - r = _tmp; - size = _tmp$1; - return [r, size]; - } - p0 = (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0]); - x = ((p0 < 0 || p0 >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[p0]); - if (x >= 240) { - mask = (((x >> 0)) << 31 >> 0) >> 31 >> 0; - _tmp$2 = (((((0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0]) >> 0)) & ~mask) >> 0) | (65533 & mask); - _tmp$3 = 1; - r = _tmp$2; - size = _tmp$3; - return [r, size]; - } - sz = (x & 7) >>> 0; - accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); - if (n < ((sz >> 0))) { - _tmp$4 = 65533; - _tmp$5 = 1; - r = _tmp$4; - size = _tmp$5; - return [r, size]; - } - b1 = (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1]); - if (b1 < accept.lo || accept.hi < b1) { - _tmp$6 = 65533; - _tmp$7 = 1; - r = _tmp$6; - size = _tmp$7; - return [r, size]; - } - if (sz === 2) { - _tmp$8 = (((((p0 & 31) >>> 0) >> 0)) << 6 >> 0) | ((((b1 & 63) >>> 0) >> 0)); - _tmp$9 = 2; - r = _tmp$8; - size = _tmp$9; - return [r, size]; - } - b2 = (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2]); - if (b2 < 128 || 191 < b2) { - _tmp$10 = 65533; - _tmp$11 = 1; - r = _tmp$10; - size = _tmp$11; - return [r, size]; - } - if (sz === 3) { - _tmp$12 = ((((((p0 & 15) >>> 0) >> 0)) << 12 >> 0) | (((((b1 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((b2 & 63) >>> 0) >> 0)); - _tmp$13 = 3; - r = _tmp$12; - size = _tmp$13; - return [r, size]; - } - b3 = (3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3]); - if (b3 < 128 || 191 < b3) { - _tmp$14 = 65533; - _tmp$15 = 1; - r = _tmp$14; - size = _tmp$15; - return [r, size]; - } - _tmp$16 = (((((((p0 & 7) >>> 0) >> 0)) << 18 >> 0) | (((((b1 & 63) >>> 0) >> 0)) << 12 >> 0)) | (((((b2 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((b3 & 63) >>> 0) >> 0)); - _tmp$17 = 4; - r = _tmp$16; - size = _tmp$17; - return [r, size]; - }; - $pkg.DecodeRune = DecodeRune; - DecodeRuneInString = function(s) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, accept, mask, n, r, s, s0, s1, s2, s3, size, sz, x, x$1; - r = 0; - size = 0; - n = s.length; - if (n < 1) { - _tmp = 65533; - _tmp$1 = 0; - r = _tmp; - size = _tmp$1; - return [r, size]; - } - s0 = s.charCodeAt(0); - x = ((s0 < 0 || s0 >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[s0]); - if (x >= 240) { - mask = (((x >> 0)) << 31 >> 0) >> 31 >> 0; - _tmp$2 = ((((s.charCodeAt(0) >> 0)) & ~mask) >> 0) | (65533 & mask); - _tmp$3 = 1; - r = _tmp$2; - size = _tmp$3; - return [r, size]; - } - sz = (x & 7) >>> 0; - accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); - if (n < ((sz >> 0))) { - _tmp$4 = 65533; - _tmp$5 = 1; - r = _tmp$4; - size = _tmp$5; - return [r, size]; - } - s1 = s.charCodeAt(1); - if (s1 < accept.lo || accept.hi < s1) { - _tmp$6 = 65533; - _tmp$7 = 1; - r = _tmp$6; - size = _tmp$7; - return [r, size]; - } - if (sz === 2) { - _tmp$8 = (((((s0 & 31) >>> 0) >> 0)) << 6 >> 0) | ((((s1 & 63) >>> 0) >> 0)); - _tmp$9 = 2; - r = _tmp$8; - size = _tmp$9; - return [r, size]; - } - s2 = s.charCodeAt(2); - if (s2 < 128 || 191 < s2) { - _tmp$10 = 65533; - _tmp$11 = 1; - r = _tmp$10; - size = _tmp$11; - return [r, size]; - } - if (sz === 3) { - _tmp$12 = ((((((s0 & 15) >>> 0) >> 0)) << 12 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s2 & 63) >>> 0) >> 0)); - _tmp$13 = 3; - r = _tmp$12; - size = _tmp$13; - return [r, size]; - } - s3 = s.charCodeAt(3); - if (s3 < 128 || 191 < s3) { - _tmp$14 = 65533; - _tmp$15 = 1; - r = _tmp$14; - size = _tmp$15; - return [r, size]; - } - _tmp$16 = (((((((s0 & 7) >>> 0) >> 0)) << 18 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 12 >> 0)) | (((((s2 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s3 & 63) >>> 0) >> 0)); - _tmp$17 = 4; - r = _tmp$16; - size = _tmp$17; - return [r, size]; - }; - $pkg.DecodeRuneInString = DecodeRuneInString; - DecodeLastRune = function(p) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, p, r, size, start; - r = 0; - size = 0; - end = p.$length; - if (end === 0) { - _tmp = 65533; - _tmp$1 = 0; - r = _tmp; - size = _tmp$1; - return [r, size]; - } - start = end - 1 >> 0; - r = ((((start < 0 || start >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + start]) >> 0)); - if (r < 128) { - _tmp$2 = r; - _tmp$3 = 1; - r = _tmp$2; - size = _tmp$3; - return [r, size]; - } - lim = end - 4 >> 0; - if (lim < 0) { - lim = 0; - } - start = start - (1) >> 0; - while (true) { - if (!(start >= lim)) { break; } - if (RuneStart(((start < 0 || start >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + start]))) { - break; - } - start = start - (1) >> 0; - } - if (start < 0) { - start = 0; - } - _tuple = DecodeRune($subslice(p, start, end)); - r = _tuple[0]; - size = _tuple[1]; - if (!(((start + size >> 0) === end))) { - _tmp$4 = 65533; - _tmp$5 = 1; - r = _tmp$4; - size = _tmp$5; - return [r, size]; - } - _tmp$6 = r; - _tmp$7 = size; - r = _tmp$6; - size = _tmp$7; - return [r, size]; - }; - $pkg.DecodeLastRune = DecodeLastRune; - DecodeLastRuneInString = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, r, s, size, start; - r = 0; - size = 0; - end = s.length; - if (end === 0) { - _tmp = 65533; - _tmp$1 = 0; - r = _tmp; - size = _tmp$1; - return [r, size]; - } - start = end - 1 >> 0; - r = ((s.charCodeAt(start) >> 0)); - if (r < 128) { - _tmp$2 = r; - _tmp$3 = 1; - r = _tmp$2; - size = _tmp$3; - return [r, size]; - } - lim = end - 4 >> 0; - if (lim < 0) { - lim = 0; - } - start = start - (1) >> 0; - while (true) { - if (!(start >= lim)) { break; } - if (RuneStart(s.charCodeAt(start))) { - break; - } - start = start - (1) >> 0; - } - if (start < 0) { - start = 0; - } - _tuple = DecodeRuneInString($substring(s, start, end)); - r = _tuple[0]; - size = _tuple[1]; - if (!(((start + size >> 0) === end))) { - _tmp$4 = 65533; - _tmp$5 = 1; - r = _tmp$4; - size = _tmp$5; - return [r, size]; - } - _tmp$6 = r; - _tmp$7 = size; - r = _tmp$6; - size = _tmp$7; - return [r, size]; - }; - $pkg.DecodeLastRuneInString = DecodeLastRuneInString; - RuneLen = function(r) { - var r; - if (r < 0) { - return -1; - } else if (r <= 127) { - return 1; - } else if (r <= 2047) { - return 2; - } else if (55296 <= r && r <= 57343) { - return -1; - } else if (r <= 65535) { - return 3; - } else if (r <= 1114111) { - return 4; - } - return -1; - }; - $pkg.RuneLen = RuneLen; - EncodeRune = function(p, r) { - var i, p, r; - i = ((r >>> 0)); - if (i <= 127) { - (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((r << 24 >>> 24))); - return 1; - } else if (i <= 2047) { - $unused((1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1])); - (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((192 | (((r >> 6 >> 0) << 24 >>> 24))) >>> 0)); - (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - return 2; - } else if ((i > 1114111) || (55296 <= i && i <= 57343)) { - r = 65533; - $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); - (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); - (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - return 3; - } else if (i <= 65535) { - $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); - (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); - (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - return 3; - } else { - $unused((3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3])); - (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((240 | (((r >> 18 >> 0) << 24 >>> 24))) >>> 0)); - (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 12 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - (3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); - return 4; - } - }; - $pkg.EncodeRune = EncodeRune; - RuneCount = function(p) { - var accept, c, c$1, c$2, c$3, i, n, np, p, size, x, x$1, x$2, x$3, x$4; - np = p.$length; - n = 0; - i = 0; - while (true) { - if (!(i < np)) { break; } - n = n + (1) >> 0; - c = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); - if (c < 128) { - i = i + (1) >> 0; - continue; - } - x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); - if (x === 241) { - i = i + (1) >> 0; - continue; - } - size = ((((x & 7) >>> 0) >> 0)); - if ((i + size >> 0) > np) { - i = i + (1) >> 0; - continue; - } - accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); - c$1 = (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2])); - if (c$1 < accept.lo || accept.hi < c$1) { - size = 1; - } else if (size === 2) { - } else { - c$2 = (x$3 = i + 2 >> 0, ((x$3 < 0 || x$3 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$3])); - if (c$2 < 128 || 191 < c$2) { - size = 1; - } else if (size === 3) { - } else { - c$3 = (x$4 = i + 3 >> 0, ((x$4 < 0 || x$4 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$4])); - if (c$3 < 128 || 191 < c$3) { - size = 1; - } - } - } - i = i + (size) >> 0; - } - return n; - }; - $pkg.RuneCount = RuneCount; - RuneCountInString = function(s) { - var accept, c, c$1, c$2, c$3, i, n, ns, s, size, x, x$1; - n = 0; - ns = s.length; - i = 0; - while (true) { - if (!(i < ns)) { break; } - c = s.charCodeAt(i); - if (c < 128) { - i = i + (1) >> 0; - n = n + (1) >> 0; - continue; - } - x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); - if (x === 241) { - i = i + (1) >> 0; - n = n + (1) >> 0; - continue; - } - size = ((((x & 7) >>> 0) >> 0)); - if ((i + size >> 0) > ns) { - i = i + (1) >> 0; - n = n + (1) >> 0; - continue; - } - accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); - c$1 = s.charCodeAt((i + 1 >> 0)); - if (c$1 < accept.lo || accept.hi < c$1) { - size = 1; - } else if (size === 2) { - } else { - c$2 = s.charCodeAt((i + 2 >> 0)); - if (c$2 < 128 || 191 < c$2) { - size = 1; - } else if (size === 3) { - } else { - c$3 = s.charCodeAt((i + 3 >> 0)); - if (c$3 < 128 || 191 < c$3) { - size = 1; - } - } - } - i = i + (size) >> 0; - n = n + (1) >> 0; - } - n = n; - return n; - }; - $pkg.RuneCountInString = RuneCountInString; - RuneStart = function(b) { - var b; - return !((((b & 192) >>> 0) === 128)); - }; - $pkg.RuneStart = RuneStart; - ValidString = function(s) { - var accept, c, c$1, c$2, i, n, s, si, size, x, x$1; - n = s.length; - i = 0; - while (true) { - if (!(i < n)) { break; } - si = s.charCodeAt(i); - if (si < 128) { - i = i + (1) >> 0; - continue; - } - x = ((si < 0 || si >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[si]); - if (x === 241) { - return false; - } - size = ((((x & 7) >>> 0) >> 0)); - if ((i + size >> 0) > n) { - return false; - } - accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); - c = s.charCodeAt((i + 1 >> 0)); - if (c < accept.lo || accept.hi < c) { - return false; - } else if (size === 2) { - } else { - c$1 = s.charCodeAt((i + 2 >> 0)); - if (c$1 < 128 || 191 < c$1) { - return false; - } else if (size === 3) { - } else { - c$2 = s.charCodeAt((i + 3 >> 0)); - if (c$2 < 128 || 191 < c$2) { - return false; - } - } - } - i = i + (size) >> 0; - } - return true; - }; - $pkg.ValidString = ValidString; - ValidRune = function(r) { - var r; - if (0 <= r && r < 55296) { - return true; - } else if (57343 < r && r <= 1114111) { - return true; - } - return false; - }; - $pkg.ValidRune = ValidRune; - acceptRange.init("unicode/utf8", [{prop: "lo", name: "lo", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "hi", name: "hi", embedded: false, exported: false, typ: $Uint8, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - first = $toNativeArray($kindUint8, [240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 19, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 35, 3, 3, 52, 4, 4, 4, 68, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241]); - acceptRanges = $toNativeArray($kindStruct, [new acceptRange.ptr(128, 191), new acceptRange.ptr(160, 191), new acceptRange.ptr(128, 159), new acceptRange.ptr(144, 191), new acceptRange.ptr(128, 143)]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["strconv"] = (function() { - var $pkg = {}, $init, errors, bytealg, math, bits, utf8, NumError, decimal, leftCheat, extFloat, floatInfo, decimalSlice, sliceType, sliceType$1, sliceType$2, sliceType$3, sliceType$4, sliceType$5, arrayType, sliceType$6, ptrType, arrayType$1, arrayType$2, ptrType$1, arrayType$3, arrayType$4, ptrType$2, ptrType$3, ptrType$4, optimize, powtab, float64pow10, float32pow10, leftcheats, smallPowersOfTen, powersOfTen, uint64pow10, float32info, float32info$24ptr, float64info, float64info$24ptr, isPrint16, isNotPrint16, isPrint32, isNotPrint32, isGraphic, equalIgnoreCase, special, readFloat, atof64exact, atof32exact, atof32, atof64, ParseFloat, syntaxError, rangeError, baseError, bitSizeError, ParseUint, ParseInt, digitZero, trim, rightShift, prefixIsLessThan, leftShift, shouldRoundUp, frexp10Many, adjustLastDigitFixed, adjustLastDigit, FormatFloat, AppendFloat, genericFtoa, bigFtoa, formatDigits, roundShortest, fmtE, fmtF, fmtB, min, max, FormatUint, FormatInt, Itoa, AppendInt, AppendUint, small, formatBits, isPowerOfTwo, quoteWith, appendQuotedWith, appendQuotedRuneWith, appendEscapedRune, Quote, AppendQuote, QuoteToASCII, AppendQuoteToASCII, AppendQuoteRune, AppendQuoteRuneToASCII, CanBackquote, unhex, UnquoteChar, Unquote, contains, bsearch16, bsearch32, IsPrint, isInGraphicList; - errors = $packages["errors"]; - bytealg = $packages["internal/bytealg"]; - math = $packages["math"]; - bits = $packages["math/bits"]; - utf8 = $packages["unicode/utf8"]; - NumError = $pkg.NumError = $newType(0, $kindStruct, "strconv.NumError", true, "strconv", true, function(Func_, Num_, Err_) { - this.$val = this; - if (arguments.length === 0) { - this.Func = ""; - this.Num = ""; - this.Err = $ifaceNil; - return; - } - this.Func = Func_; - this.Num = Num_; - this.Err = Err_; - }); - decimal = $pkg.decimal = $newType(0, $kindStruct, "strconv.decimal", true, "strconv", false, function(d_, nd_, dp_, neg_, trunc_) { - this.$val = this; - if (arguments.length === 0) { - this.d = arrayType.zero(); - this.nd = 0; - this.dp = 0; - this.neg = false; - this.trunc = false; - return; - } - this.d = d_; - this.nd = nd_; - this.dp = dp_; - this.neg = neg_; - this.trunc = trunc_; - }); - leftCheat = $pkg.leftCheat = $newType(0, $kindStruct, "strconv.leftCheat", true, "strconv", false, function(delta_, cutoff_) { - this.$val = this; - if (arguments.length === 0) { - this.delta = 0; - this.cutoff = ""; - return; - } - this.delta = delta_; - this.cutoff = cutoff_; - }); - extFloat = $pkg.extFloat = $newType(0, $kindStruct, "strconv.extFloat", true, "strconv", false, function(mant_, exp_, neg_) { - this.$val = this; - if (arguments.length === 0) { - this.mant = new $Uint64(0, 0); - this.exp = 0; - this.neg = false; - return; - } - this.mant = mant_; - this.exp = exp_; - this.neg = neg_; - }); - floatInfo = $pkg.floatInfo = $newType(0, $kindStruct, "strconv.floatInfo", true, "strconv", false, function(mantbits_, expbits_, bias_) { - this.$val = this; - if (arguments.length === 0) { - this.mantbits = 0; - this.expbits = 0; - this.bias = 0; - return; - } - this.mantbits = mantbits_; - this.expbits = expbits_; - this.bias = bias_; - }); - decimalSlice = $pkg.decimalSlice = $newType(0, $kindStruct, "strconv.decimalSlice", true, "strconv", false, function(d_, nd_, dp_, neg_) { - this.$val = this; - if (arguments.length === 0) { - this.d = sliceType$6.nil; - this.nd = 0; - this.dp = 0; - this.neg = false; - return; - } - this.d = d_; - this.nd = nd_; - this.dp = dp_; - this.neg = neg_; - }); - sliceType = $sliceType($Int); - sliceType$1 = $sliceType($Float64); - sliceType$2 = $sliceType($Float32); - sliceType$3 = $sliceType(leftCheat); - sliceType$4 = $sliceType($Uint16); - sliceType$5 = $sliceType($Uint32); - arrayType = $arrayType($Uint8, 800); - sliceType$6 = $sliceType($Uint8); - ptrType = $ptrType(NumError); - arrayType$1 = $arrayType($Uint8, 24); - arrayType$2 = $arrayType($Uint8, 32); - ptrType$1 = $ptrType(floatInfo); - arrayType$3 = $arrayType($Uint8, 65); - arrayType$4 = $arrayType($Uint8, 4); - ptrType$2 = $ptrType(decimal); - ptrType$3 = $ptrType(decimalSlice); - ptrType$4 = $ptrType(extFloat); - equalIgnoreCase = function(s1, s2) { - var c1, c2, i, s1, s2; - if (!((s1.length === s2.length))) { - return false; - } - i = 0; - while (true) { - if (!(i < s1.length)) { break; } - c1 = s1.charCodeAt(i); - if (65 <= c1 && c1 <= 90) { - c1 = c1 + (32) << 24 >>> 24; - } - c2 = s2.charCodeAt(i); - if (65 <= c2 && c2 <= 90) { - c2 = c2 + (32) << 24 >>> 24; - } - if (!((c1 === c2))) { - return false; - } - i = i + (1) >> 0; - } - return true; - }; - special = function(s) { - var _1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, f, ok, s; - f = 0; - ok = false; - if (s.length === 0) { - return [f, ok]; - } - _1 = s.charCodeAt(0); - if (_1 === (43)) { - if (equalIgnoreCase(s, "+inf") || equalIgnoreCase(s, "+infinity")) { - _tmp = math.Inf(1); - _tmp$1 = true; - f = _tmp; - ok = _tmp$1; - return [f, ok]; - } - } else if (_1 === (45)) { - if (equalIgnoreCase(s, "-inf") || equalIgnoreCase(s, "-infinity")) { - _tmp$2 = math.Inf(-1); - _tmp$3 = true; - f = _tmp$2; - ok = _tmp$3; - return [f, ok]; - } - } else if ((_1 === (110)) || (_1 === (78))) { - if (equalIgnoreCase(s, "nan")) { - _tmp$4 = math.NaN(); - _tmp$5 = true; - f = _tmp$4; - ok = _tmp$5; - return [f, ok]; - } - } else if ((_1 === (105)) || (_1 === (73))) { - if (equalIgnoreCase(s, "inf") || equalIgnoreCase(s, "infinity")) { - _tmp$6 = math.Inf(1); - _tmp$7 = true; - f = _tmp$6; - ok = _tmp$7; - return [f, ok]; - } - } else { - return [f, ok]; - } - return [f, ok]; - }; - decimal.ptr.prototype.set = function(s) { - var b, e, esign, i, ok, s, sawdigits, sawdot, x, x$1; - ok = false; - b = this; - i = 0; - b.neg = false; - b.trunc = false; - if (i >= s.length) { - return ok; - } - if ((s.charCodeAt(i) === 43)) { - i = i + (1) >> 0; - } else if ((s.charCodeAt(i) === 45)) { - b.neg = true; - i = i + (1) >> 0; - } - sawdot = false; - sawdigits = false; - while (true) { - if (!(i < s.length)) { break; } - if ((s.charCodeAt(i) === 46)) { - if (sawdot) { - return ok; - } - sawdot = true; - b.dp = b.nd; - i = i + (1) >> 0; - continue; - } else if (48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57) { - sawdigits = true; - if ((s.charCodeAt(i) === 48) && (b.nd === 0)) { - b.dp = b.dp - (1) >> 0; - i = i + (1) >> 0; - continue; - } - if (b.nd < 800) { - (x = b.d, x$1 = b.nd, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1] = s.charCodeAt(i))); - b.nd = b.nd + (1) >> 0; - } else if (!((s.charCodeAt(i) === 48))) { - b.trunc = true; - } - i = i + (1) >> 0; - continue; - } - break; - } - if (!sawdigits) { - return ok; - } - if (!sawdot) { - b.dp = b.nd; - } - if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) { - i = i + (1) >> 0; - if (i >= s.length) { - return ok; - } - esign = 1; - if (s.charCodeAt(i) === 43) { - i = i + (1) >> 0; - } else if (s.charCodeAt(i) === 45) { - i = i + (1) >> 0; - esign = -1; - } - if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) { - return ok; - } - e = 0; - while (true) { - if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; } - if (e < 10000) { - e = (($imul(e, 10)) + ((s.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; - } - i = i + (1) >> 0; - } - b.dp = b.dp + (($imul(e, esign))) >> 0; - } - if (!((i === s.length))) { - return ok; - } - ok = true; - return ok; - }; - decimal.prototype.set = function(s) { return this.$val.set(s); }; - readFloat = function(s) { - var _1, c, dp, e, esign, exp, i, mantissa, nd, ndMant, neg, ok, s, sawdigits, sawdot, trunc, x; - mantissa = new $Uint64(0, 0); - exp = 0; - neg = false; - trunc = false; - ok = false; - i = 0; - if (i >= s.length) { - return [mantissa, exp, neg, trunc, ok]; - } - if ((s.charCodeAt(i) === 43)) { - i = i + (1) >> 0; - } else if ((s.charCodeAt(i) === 45)) { - neg = true; - i = i + (1) >> 0; - } - sawdot = false; - sawdigits = false; - nd = 0; - ndMant = 0; - dp = 0; - while (true) { - if (!(i < s.length)) { break; } - c = s.charCodeAt(i); - _1 = true; - if (_1 === ((c === 46))) { - if (sawdot) { - return [mantissa, exp, neg, trunc, ok]; - } - sawdot = true; - dp = nd; - i = i + (1) >> 0; - continue; - } else if (_1 === (48 <= c && c <= 57)) { - sawdigits = true; - if ((c === 48) && (nd === 0)) { - dp = dp - (1) >> 0; - i = i + (1) >> 0; - continue; - } - nd = nd + (1) >> 0; - if (ndMant < 19) { - mantissa = $mul64(mantissa, (new $Uint64(0, 10))); - mantissa = (x = (new $Uint64(0, (c - 48 << 24 >>> 24))), new $Uint64(mantissa.$high + x.$high, mantissa.$low + x.$low)); - ndMant = ndMant + (1) >> 0; - } else if (!((s.charCodeAt(i) === 48))) { - trunc = true; - } - i = i + (1) >> 0; - continue; - } - break; - } - if (!sawdigits) { - return [mantissa, exp, neg, trunc, ok]; - } - if (!sawdot) { - dp = nd; - } - if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) { - i = i + (1) >> 0; - if (i >= s.length) { - return [mantissa, exp, neg, trunc, ok]; - } - esign = 1; - if (s.charCodeAt(i) === 43) { - i = i + (1) >> 0; - } else if (s.charCodeAt(i) === 45) { - i = i + (1) >> 0; - esign = -1; - } - if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) { - return [mantissa, exp, neg, trunc, ok]; - } - e = 0; - while (true) { - if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; } - if (e < 10000) { - e = (($imul(e, 10)) + ((s.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; - } - i = i + (1) >> 0; - } - dp = dp + (($imul(e, esign))) >> 0; - } - if (!((i === s.length))) { - return [mantissa, exp, neg, trunc, ok]; - } - if (!((mantissa.$high === 0 && mantissa.$low === 0))) { - exp = dp - ndMant >> 0; - } - ok = true; - return [mantissa, exp, neg, trunc, ok]; - }; - decimal.ptr.prototype.floatBits = function(flt) { - var _tmp, _tmp$1, b, bits$1, d, exp, flt, mant, n, n$1, n$2, overflow, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, y$1, y$2, y$3, $s; - /* */ $s = 0; s: while (true) { switch ($s) { case 0: - b = new $Uint64(0, 0); - overflow = false; - d = this; - exp = 0; - mant = new $Uint64(0, 0); - /* */ if (d.nd === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (d.nd === 0) { */ case 1: - mant = new $Uint64(0, 0); - exp = flt.bias; - /* goto out */ $s = 3; continue; - /* } */ case 2: - /* */ if (d.dp > 310) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (d.dp > 310) { */ case 4: - /* goto overflow */ $s = 6; continue; - /* } */ case 5: - /* */ if (d.dp < -330) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (d.dp < -330) { */ case 7: - mant = new $Uint64(0, 0); - exp = flt.bias; - /* goto out */ $s = 3; continue; - /* } */ case 8: - exp = 0; - while (true) { - if (!(d.dp > 0)) { break; } - n = 0; - if (d.dp >= powtab.$length) { - n = 27; - } else { - n = (x = d.dp, ((x < 0 || x >= powtab.$length) ? ($throwRuntimeError("index out of range"), undefined) : powtab.$array[powtab.$offset + x])); - } - d.Shift(-n); - exp = exp + (n) >> 0; - } - while (true) { - if (!(d.dp < 0 || (d.dp === 0) && d.d[0] < 53)) { break; } - n$1 = 0; - if (-d.dp >= powtab.$length) { - n$1 = 27; - } else { - n$1 = (x$1 = -d.dp, ((x$1 < 0 || x$1 >= powtab.$length) ? ($throwRuntimeError("index out of range"), undefined) : powtab.$array[powtab.$offset + x$1])); - } - d.Shift(n$1); - exp = exp - (n$1) >> 0; - } - exp = exp - (1) >> 0; - if (exp < (flt.bias + 1 >> 0)) { - n$2 = (flt.bias + 1 >> 0) - exp >> 0; - d.Shift(-n$2); - exp = exp + (n$2) >> 0; - } - /* */ if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { */ case 9: - /* goto overflow */ $s = 6; continue; - /* } */ case 10: - d.Shift((((1 + flt.mantbits >>> 0) >> 0))); - mant = d.RoundedInteger(); - /* */ if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { */ case 11: - mant = $shiftRightUint64(mant, (1)); - exp = exp + (1) >> 0; - /* */ if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { */ case 13: - /* goto overflow */ $s = 6; continue; - /* } */ case 14: - /* } */ case 12: - if ((x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$4.$high, (mant.$low & x$4.$low) >>> 0)), (x$3.$high === 0 && x$3.$low === 0))) { - exp = flt.bias; - } - /* goto out */ $s = 3; continue; - /* overflow: */ case 6: - mant = new $Uint64(0, 0); - exp = (((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0) + flt.bias >> 0; - overflow = true; - /* out: */ case 3: - bits$1 = (x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$6.$high - 0, x$6.$low - 1)), new $Uint64(mant.$high & x$5.$high, (mant.$low & x$5.$low) >>> 0)); - bits$1 = (x$7 = $shiftLeft64((new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$3 = flt.expbits, y$3 < 32 ? (1 << y$3) : 0) >> 0) - 1 >> 0))))), flt.mantbits), new $Uint64(bits$1.$high | x$7.$high, (bits$1.$low | x$7.$low) >>> 0)); - if (d.neg) { - bits$1 = (x$8 = $shiftLeft64($shiftLeft64(new $Uint64(0, 1), flt.mantbits), flt.expbits), new $Uint64(bits$1.$high | x$8.$high, (bits$1.$low | x$8.$low) >>> 0)); - } - _tmp = bits$1; - _tmp$1 = overflow; - b = _tmp; - overflow = _tmp$1; - $s = -1; return [b, overflow]; - /* */ } return; } - }; - decimal.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; - atof64exact = function(mantissa, exp, neg) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2; - f = 0; - ok = false; - if (!((x = $shiftRightUint64(mantissa, float64info.mantbits), (x.$high === 0 && x.$low === 0)))) { - return [f, ok]; - } - f = ($flatten64(mantissa)); - if (neg) { - f = -f; - } - if ((exp === 0)) { - _tmp = f; - _tmp$1 = true; - f = _tmp; - ok = _tmp$1; - return [f, ok]; - } else if (exp > 0 && exp <= 37) { - if (exp > 22) { - f = f * ((x$1 = exp - 22 >> 0, ((x$1 < 0 || x$1 >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + x$1]))); - exp = 22; - } - if (f > 1e+15 || f < -1e+15) { - return [f, ok]; - } - _tmp$2 = f * ((exp < 0 || exp >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + exp]); - _tmp$3 = true; - f = _tmp$2; - ok = _tmp$3; - return [f, ok]; - } else if (exp < 0 && exp >= -22) { - _tmp$4 = f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float64pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float64pow10.$array[float64pow10.$offset + x$2])); - _tmp$5 = true; - f = _tmp$4; - ok = _tmp$5; - return [f, ok]; - } - return [f, ok]; - }; - atof32exact = function(mantissa, exp, neg) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2; - f = 0; - ok = false; - if (!((x = $shiftRightUint64(mantissa, float32info.mantbits), (x.$high === 0 && x.$low === 0)))) { - return [f, ok]; - } - f = ($flatten64(mantissa)); - if (neg) { - f = -f; - } - if ((exp === 0)) { - _tmp = f; - _tmp$1 = true; - f = _tmp; - ok = _tmp$1; - return [f, ok]; - } else if (exp > 0 && exp <= 17) { - if (exp > 10) { - f = $fround(f * ((x$1 = exp - 10 >> 0, ((x$1 < 0 || x$1 >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + x$1])))); - exp = 10; - } - if (f > 1e+07 || f < -1e+07) { - return [f, ok]; - } - _tmp$2 = $fround(f * ((exp < 0 || exp >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + exp])); - _tmp$3 = true; - f = _tmp$2; - ok = _tmp$3; - return [f, ok]; - } else if (exp < 0 && exp >= -10) { - _tmp$4 = $fround(f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float32pow10.$length) ? ($throwRuntimeError("index out of range"), undefined) : float32pow10.$array[float32pow10.$offset + x$2]))); - _tmp$5 = true; - f = _tmp$4; - ok = _tmp$5; - return [f, ok]; - } - return [f, ok]; - }; - atof32 = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val; - f = 0; - err = $ifaceNil; - _tuple = special(s); - val = _tuple[0]; - ok = _tuple[1]; - if (ok) { - _tmp = ($fround(val)); - _tmp$1 = $ifaceNil; - f = _tmp; - err = _tmp$1; - return [f, err]; - } - if (optimize) { - _tuple$1 = readFloat(s); - mantissa = _tuple$1[0]; - exp = _tuple$1[1]; - neg = _tuple$1[2]; - trunc = _tuple$1[3]; - ok$1 = _tuple$1[4]; - if (ok$1) { - if (!trunc) { - _tuple$2 = atof32exact(mantissa, exp, neg); - f$1 = _tuple$2[0]; - ok$2 = _tuple$2[1]; - if (ok$2) { - _tmp$2 = f$1; - _tmp$3 = $ifaceNil; - f = _tmp$2; - err = _tmp$3; - return [f, err]; - } - } - ext = new extFloat.ptr(new $Uint64(0, 0), 0, false); - ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float32info); - if (ok$3) { - _tuple$3 = ext.floatBits(float32info); - b = _tuple$3[0]; - ovf = _tuple$3[1]; - f = math.Float32frombits(((b.$low >>> 0))); - if (ovf) { - err = rangeError("ParseFloat", s); - } - _tmp$4 = f; - _tmp$5 = err; - f = _tmp$4; - err = _tmp$5; - return [f, err]; - } - } - } - d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); - if (!d.set(s)) { - _tmp$6 = 0; - _tmp$7 = syntaxError("ParseFloat", s); - f = _tmp$6; - err = _tmp$7; - return [f, err]; - } - _tuple$4 = d.floatBits(float32info); - b$1 = _tuple$4[0]; - ovf$1 = _tuple$4[1]; - f = math.Float32frombits(((b$1.$low >>> 0))); - if (ovf$1) { - err = rangeError("ParseFloat", s); - } - _tmp$8 = f; - _tmp$9 = err; - f = _tmp$8; - err = _tmp$9; - return [f, err]; - }; - atof64 = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val; - f = 0; - err = $ifaceNil; - _tuple = special(s); - val = _tuple[0]; - ok = _tuple[1]; - if (ok) { - _tmp = val; - _tmp$1 = $ifaceNil; - f = _tmp; - err = _tmp$1; - return [f, err]; - } - if (optimize) { - _tuple$1 = readFloat(s); - mantissa = _tuple$1[0]; - exp = _tuple$1[1]; - neg = _tuple$1[2]; - trunc = _tuple$1[3]; - ok$1 = _tuple$1[4]; - if (ok$1) { - if (!trunc) { - _tuple$2 = atof64exact(mantissa, exp, neg); - f$1 = _tuple$2[0]; - ok$2 = _tuple$2[1]; - if (ok$2) { - _tmp$2 = f$1; - _tmp$3 = $ifaceNil; - f = _tmp$2; - err = _tmp$3; - return [f, err]; - } - } - ext = new extFloat.ptr(new $Uint64(0, 0), 0, false); - ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float64info); - if (ok$3) { - _tuple$3 = ext.floatBits(float64info); - b = _tuple$3[0]; - ovf = _tuple$3[1]; - f = math.Float64frombits(b); - if (ovf) { - err = rangeError("ParseFloat", s); - } - _tmp$4 = f; - _tmp$5 = err; - f = _tmp$4; - err = _tmp$5; - return [f, err]; - } - } - } - d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); - if (!d.set(s)) { - _tmp$6 = 0; - _tmp$7 = syntaxError("ParseFloat", s); - f = _tmp$6; - err = _tmp$7; - return [f, err]; - } - _tuple$4 = d.floatBits(float64info); - b$1 = _tuple$4[0]; - ovf$1 = _tuple$4[1]; - f = math.Float64frombits(b$1); - if (ovf$1) { - err = rangeError("ParseFloat", s); - } - _tmp$8 = f; - _tmp$9 = err; - f = _tmp$8; - err = _tmp$9; - return [f, err]; - }; - ParseFloat = function(s, bitSize) { - var _tuple, bitSize, err, f, s; - if (bitSize === 32) { - _tuple = atof32(s); - f = _tuple[0]; - err = _tuple[1]; - return [(f), err]; - } - return atof64(s); - }; - $pkg.ParseFloat = ParseFloat; - NumError.ptr.prototype.Error = function() { - var _r, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return "strconv." + e.Func + ": " + "parsing " + Quote(e.Num) + ": " + _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: NumError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - NumError.prototype.Error = function() { return this.$val.Error(); }; - syntaxError = function(fn, str) { - var fn, str; - return new NumError.ptr(fn, str, $pkg.ErrSyntax); - }; - rangeError = function(fn, str) { - var fn, str; - return new NumError.ptr(fn, str, $pkg.ErrRange); - }; - baseError = function(fn, str, base) { - var base, fn, str; - return new NumError.ptr(fn, str, errors.New("invalid base " + Itoa(base))); - }; - bitSizeError = function(fn, str, bitSize) { - var bitSize, fn, str; - return new NumError.ptr(fn, str, errors.New("invalid bit size " + Itoa(bitSize))); - }; - ParseUint = function(s, base, bitSize) { - var _1, _i, _ref, base, bitSize, c, cutoff, d, maxVal, n, n1, s, s0, x, x$1, x$2; - if (s.length === 0) { - return [new $Uint64(0, 0), syntaxError("ParseUint", s)]; - } - s0 = s; - if (2 <= base && base <= 36) { - } else if ((base === 0)) { - if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { - if (s.length < 3) { - return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; - } - base = 16; - s = $substring(s, 2); - } else if ((s.charCodeAt(0) === 48)) { - base = 8; - s = $substring(s, 1); - } else { - base = 10; - } - } else { - return [new $Uint64(0, 0), baseError("ParseUint", s0, base)]; - } - if (bitSize === 0) { - bitSize = 32; - } else if (bitSize < 0 || bitSize > 64) { - return [new $Uint64(0, 0), bitSizeError("ParseUint", s0, bitSize)]; - } - cutoff = new $Uint64(0, 0); - _1 = base; - if (_1 === (10)) { - cutoff = new $Uint64(429496729, 2576980378); - } else if (_1 === (16)) { - cutoff = new $Uint64(268435456, 0); - } else { - cutoff = (x = $div64(new $Uint64(4294967295, 4294967295), (new $Uint64(0, base)), false), new $Uint64(x.$high + 0, x.$low + 1)); - } - maxVal = (x$1 = $shiftLeft64(new $Uint64(0, 1), ((bitSize >>> 0))), new $Uint64(x$1.$high - 0, x$1.$low - 1)); - n = new $Uint64(0, 0); - _ref = (new sliceType$6($stringToBytes(s))); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - d = 0; - if (48 <= c && c <= 57) { - d = c - 48 << 24 >>> 24; - } else if (97 <= c && c <= 122) { - d = (c - 97 << 24 >>> 24) + 10 << 24 >>> 24; - } else if (65 <= c && c <= 90) { - d = (c - 65 << 24 >>> 24) + 10 << 24 >>> 24; - } else { - return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; - } - if (d >= ((base << 24 >>> 24))) { - return [new $Uint64(0, 0), syntaxError("ParseUint", s0)]; - } - if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { - return [maxVal, rangeError("ParseUint", s0)]; - } - n = $mul64(n, ((new $Uint64(0, base)))); - n1 = (x$2 = (new $Uint64(0, d)), new $Uint64(n.$high + x$2.$high, n.$low + x$2.$low)); - if ((n1.$high < n.$high || (n1.$high === n.$high && n1.$low < n.$low)) || (n1.$high > maxVal.$high || (n1.$high === maxVal.$high && n1.$low > maxVal.$low))) { - return [maxVal, rangeError("ParseUint", s0)]; - } - n = n1; - _i++; - } - return [n, $ifaceNil]; - }; - $pkg.ParseUint = ParseUint; - ParseInt = function(s, base, bitSize) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, base, bitSize, cutoff, err, i, n, neg, s, s0, un, x, x$1; - i = new $Int64(0, 0); - err = $ifaceNil; - if (s.length === 0) { - _tmp = new $Int64(0, 0); - _tmp$1 = syntaxError("ParseInt", s); - i = _tmp; - err = _tmp$1; - return [i, err]; - } - s0 = s; - neg = false; - if (s.charCodeAt(0) === 43) { - s = $substring(s, 1); - } else if (s.charCodeAt(0) === 45) { - neg = true; - s = $substring(s, 1); - } - un = new $Uint64(0, 0); - _tuple = ParseUint(s, base, bitSize); - un = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil)) && !($interfaceIsEqual($assertType(err, ptrType).Err, $pkg.ErrRange))) { - $assertType(err, ptrType).Func = "ParseInt"; - $assertType(err, ptrType).Num = s0; - _tmp$2 = new $Int64(0, 0); - _tmp$3 = err; - i = _tmp$2; - err = _tmp$3; - return [i, err]; - } - if (bitSize === 0) { - bitSize = 32; - } - cutoff = ($shiftLeft64(new $Uint64(0, 1), (((bitSize - 1 >> 0) >>> 0)))); - if (!neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low >= cutoff.$low))) { - _tmp$4 = ((x = new $Uint64(cutoff.$high - 0, cutoff.$low - 1), new $Int64(x.$high, x.$low))); - _tmp$5 = rangeError("ParseInt", s0); - i = _tmp$4; - err = _tmp$5; - return [i, err]; - } - if (neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low > cutoff.$low))) { - _tmp$6 = (x$1 = (new $Int64(cutoff.$high, cutoff.$low)), new $Int64(-x$1.$high, -x$1.$low)); - _tmp$7 = rangeError("ParseInt", s0); - i = _tmp$6; - err = _tmp$7; - return [i, err]; - } - n = (new $Int64(un.$high, un.$low)); - if (neg) { - n = new $Int64(-n.$high, -n.$low); - } - _tmp$8 = n; - _tmp$9 = $ifaceNil; - i = _tmp$8; - err = _tmp$9; - return [i, err]; - }; - $pkg.ParseInt = ParseInt; - decimal.ptr.prototype.String = function() { - var a, buf, n, w; - a = this; - n = 10 + a.nd >> 0; - if (a.dp > 0) { - n = n + (a.dp) >> 0; - } - if (a.dp < 0) { - n = n + (-a.dp) >> 0; - } - buf = $makeSlice(sliceType$6, n); - w = 0; - if ((a.nd === 0)) { - return "0"; - } else if (a.dp <= 0) { - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); - w = w + (1) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); - w = w + (1) >> 0; - w = w + (digitZero($subslice(buf, w, (w + -a.dp >> 0)))) >> 0; - w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; - } else if (a.dp < a.nd) { - w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.dp))) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); - w = w + (1) >> 0; - w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), a.dp, a.nd))) >> 0; - } else { - w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; - w = w + (digitZero($subslice(buf, w, ((w + a.dp >> 0) - a.nd >> 0)))) >> 0; - } - return ($bytesToString($subslice(buf, 0, w))); - }; - decimal.prototype.String = function() { return this.$val.String(); }; - digitZero = function(dst) { - var _i, _ref, dst, i; - _ref = dst; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - ((i < 0 || i >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + i] = 48); - _i++; - } - return dst.$length; - }; - trim = function(a) { - var a, x, x$1; - while (true) { - if (!(a.nd > 0 && ((x = a.d, x$1 = a.nd - 1 >> 0, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])) === 48))) { break; } - a.nd = a.nd - (1) >> 0; - } - if (a.nd === 0) { - a.dp = 0; - } - }; - decimal.ptr.prototype.Assign = function(v) { - var a, buf, n, v, v1, x, x$1, x$2; - a = this; - buf = arrayType$1.zero(); - n = 0; - while (true) { - if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } - v1 = $div64(v, new $Uint64(0, 10), false); - v = (x = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x.$high, v.$low - x.$low)); - ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); - n = n + (1) >> 0; - v = v1; - } - a.nd = 0; - n = n - (1) >> 0; - while (true) { - if (!(n >= 0)) { break; } - (x$1 = a.d, x$2 = a.nd, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2] = ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n]))); - a.nd = a.nd + (1) >> 0; - n = n - (1) >> 0; - } - a.dp = a.nd; - trim(a); - }; - decimal.prototype.Assign = function(v) { return this.$val.Assign(v); }; - rightShift = function(a, k) { - var a, c, c$1, dig, dig$1, k, mask, n, r, w, x, x$1, x$2, x$3, y, y$1, y$2, y$3, y$4; - r = 0; - w = 0; - n = 0; - while (true) { - if (!(((y = k, y < 32 ? (n >>> y) : 0) >>> 0) === 0)) { break; } - if (r >= a.nd) { - if (n === 0) { - a.nd = 0; - return; - } - while (true) { - if (!(((y$1 = k, y$1 < 32 ? (n >>> y$1) : 0) >>> 0) === 0)) { break; } - n = n * 10 >>> 0; - r = r + (1) >> 0; - } - break; - } - c = (((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)); - n = ((n * 10 >>> 0) + c >>> 0) - 48 >>> 0; - r = r + (1) >> 0; - } - a.dp = a.dp - ((r - 1 >> 0)) >> 0; - mask = (((y$2 = k, y$2 < 32 ? (1 << y$2) : 0) >>> 0)) - 1 >>> 0; - while (true) { - if (!(r < a.nd)) { break; } - c$1 = (((x$1 = a.d, ((r < 0 || r >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[r])) >>> 0)); - dig = (y$3 = k, y$3 < 32 ? (n >>> y$3) : 0) >>> 0; - n = (n & (mask)) >>> 0; - (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((dig + 48 >>> 0) << 24 >>> 24)))); - w = w + (1) >> 0; - n = ((n * 10 >>> 0) + c$1 >>> 0) - 48 >>> 0; - r = r + (1) >> 0; - } - while (true) { - if (!(n > 0)) { break; } - dig$1 = (y$4 = k, y$4 < 32 ? (n >>> y$4) : 0) >>> 0; - n = (n & (mask)) >>> 0; - if (w < 800) { - (x$3 = a.d, ((w < 0 || w >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[w] = (((dig$1 + 48 >>> 0) << 24 >>> 24)))); - w = w + (1) >> 0; - } else if (dig$1 > 0) { - a.trunc = true; - } - n = n * 10 >>> 0; - } - a.nd = w; - trim(a); - }; - prefixIsLessThan = function(b, s) { - var b, i, s; - i = 0; - while (true) { - if (!(i < s.length)) { break; } - if (i >= b.$length) { - return true; - } - if (!((((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) === s.charCodeAt(i)))) { - return ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) < s.charCodeAt(i); - } - i = i + (1) >> 0; - } - return false; - }; - leftShift = function(a, k) { - var _q, _q$1, a, delta, k, n, quo, quo$1, r, rem, rem$1, w, x, x$1, x$2, y; - delta = ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).delta; - if (prefixIsLessThan($subslice(new sliceType$6(a.d), 0, a.nd), ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).cutoff)) { - delta = delta - (1) >> 0; - } - r = a.nd; - w = a.nd + delta >> 0; - n = 0; - r = r - (1) >> 0; - while (true) { - if (!(r >= 0)) { break; } - n = n + (((y = k, y < 32 ? ((((((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)) - 48 >>> 0)) << y) : 0) >>> 0)) >>> 0; - quo = (_q = n / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - rem = n - (10 * quo >>> 0) >>> 0; - w = w - (1) >> 0; - if (w < 800) { - (x$1 = a.d, ((w < 0 || w >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[w] = (((rem + 48 >>> 0) << 24 >>> 24)))); - } else if (!((rem === 0))) { - a.trunc = true; - } - n = quo; - r = r - (1) >> 0; - } - while (true) { - if (!(n > 0)) { break; } - quo$1 = (_q$1 = n / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - rem$1 = n - (10 * quo$1 >>> 0) >>> 0; - w = w - (1) >> 0; - if (w < 800) { - (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((rem$1 + 48 >>> 0) << 24 >>> 24)))); - } else if (!((rem$1 === 0))) { - a.trunc = true; - } - n = quo$1; - } - a.nd = a.nd + (delta) >> 0; - if (a.nd >= 800) { - a.nd = 800; - } - a.dp = a.dp + (delta) >> 0; - trim(a); - }; - decimal.ptr.prototype.Shift = function(k) { - var a, k; - a = this; - if ((a.nd === 0)) { - } else if (k > 0) { - while (true) { - if (!(k > 28)) { break; } - leftShift(a, 28); - k = k - (28) >> 0; - } - leftShift(a, ((k >>> 0))); - } else if (k < 0) { - while (true) { - if (!(k < -28)) { break; } - rightShift(a, 28); - k = k + (28) >> 0; - } - rightShift(a, ((-k >>> 0))); - } - }; - decimal.prototype.Shift = function(k) { return this.$val.Shift(k); }; - shouldRoundUp = function(a, nd) { - var _r, a, nd, x, x$1, x$2, x$3; - if (nd < 0 || nd >= a.nd) { - return false; - } - if (((x = a.d, ((nd < 0 || nd >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[nd])) === 53) && ((nd + 1 >> 0) === a.nd)) { - if (a.trunc) { - return true; - } - return nd > 0 && !(((_r = (((x$1 = a.d, x$2 = nd - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2])) - 48 << 24 >>> 24)) % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0)); - } - return (x$3 = a.d, ((nd < 0 || nd >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[nd])) >= 53; - }; - decimal.ptr.prototype.Round = function(nd) { - var a, nd; - a = this; - if (nd < 0 || nd >= a.nd) { - return; - } - if (shouldRoundUp(a, nd)) { - a.RoundUp(nd); - } else { - a.RoundDown(nd); - } - }; - decimal.prototype.Round = function(nd) { return this.$val.Round(nd); }; - decimal.ptr.prototype.RoundDown = function(nd) { - var a, nd; - a = this; - if (nd < 0 || nd >= a.nd) { - return; - } - a.nd = nd; - trim(a); - }; - decimal.prototype.RoundDown = function(nd) { return this.$val.RoundDown(nd); }; - decimal.ptr.prototype.RoundUp = function(nd) { - var a, c, i, nd, x, x$1, x$2; - a = this; - if (nd < 0 || nd >= a.nd) { - return; - } - i = nd - 1 >> 0; - while (true) { - if (!(i >= 0)) { break; } - c = (x = a.d, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])); - if (c < 57) { - (x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = ((x$1 = a.d, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])) + (1) << 24 >>> 24))); - a.nd = i + 1 >> 0; - return; - } - i = i - (1) >> 0; - } - a.d[0] = 49; - a.nd = 1; - a.dp = a.dp + (1) >> 0; - }; - decimal.prototype.RoundUp = function(nd) { return this.$val.RoundUp(nd); }; - decimal.ptr.prototype.RoundedInteger = function() { - var a, i, n, x, x$1, x$2, x$3; - a = this; - if (a.dp > 20) { - return new $Uint64(4294967295, 4294967295); - } - i = 0; - n = new $Uint64(0, 0); - i = 0; - while (true) { - if (!(i < a.dp && i < a.nd)) { break; } - n = (x = $mul64(n, new $Uint64(0, 10)), x$1 = (new $Uint64(0, ((x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i])) - 48 << 24 >>> 24))), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); - i = i + (1) >> 0; - } - while (true) { - if (!(i < a.dp)) { break; } - n = $mul64(n, (new $Uint64(0, 10))); - i = i + (1) >> 0; - } - if (shouldRoundUp(a, a.dp)) { - n = (x$3 = new $Uint64(0, 1), new $Uint64(n.$high + x$3.$high, n.$low + x$3.$low)); - } - return n; - }; - decimal.prototype.RoundedInteger = function() { return this.$val.RoundedInteger(); }; - extFloat.ptr.prototype.floatBits = function(flt) { - var bits$1, exp, f, flt, mant, n, overflow, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2; - bits$1 = new $Uint64(0, 0); - overflow = false; - f = this; - f.Normalize(); - exp = f.exp + 63 >> 0; - if (exp < (flt.bias + 1 >> 0)) { - n = (flt.bias + 1 >> 0) - exp >> 0; - f.mant = $shiftRightUint64(f.mant, (((n >>> 0)))); - exp = exp + (n) >> 0; - } - mant = $shiftRightUint64(f.mant, ((63 - flt.mantbits >>> 0))); - if (!((x = (x$1 = f.mant, x$2 = $shiftLeft64(new $Uint64(0, 1), ((62 - flt.mantbits >>> 0))), new $Uint64(x$1.$high & x$2.$high, (x$1.$low & x$2.$low) >>> 0)), (x.$high === 0 && x.$low === 0)))) { - mant = (x$3 = new $Uint64(0, 1), new $Uint64(mant.$high + x$3.$high, mant.$low + x$3.$low)); - } - if ((x$4 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$4.$high && mant.$low === x$4.$low))) { - mant = $shiftRightUint64(mant, (1)); - exp = exp + (1) >> 0; - } - if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { - mant = new $Uint64(0, 0); - exp = (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0) + flt.bias >> 0; - overflow = true; - } else if ((x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$6.$high, (mant.$low & x$6.$low) >>> 0)), (x$5.$high === 0 && x$5.$low === 0))) { - exp = flt.bias; - } - bits$1 = (x$7 = (x$8 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$8.$high - 0, x$8.$low - 1)), new $Uint64(mant.$high & x$7.$high, (mant.$low & x$7.$low) >>> 0)); - bits$1 = (x$9 = $shiftLeft64((new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0))))), flt.mantbits), new $Uint64(bits$1.$high | x$9.$high, (bits$1.$low | x$9.$low) >>> 0)); - if (f.neg) { - bits$1 = (x$10 = $shiftLeft64(new $Uint64(0, 1), ((flt.mantbits + flt.expbits >>> 0))), new $Uint64(bits$1.$high | x$10.$high, (bits$1.$low | x$10.$low) >>> 0)); - } - return [bits$1, overflow]; - }; - extFloat.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; - extFloat.ptr.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { - var _tmp, _tmp$1, exp, expBiased, f, flt, lower, mant, neg, upper, x, x$1, x$2, x$3, x$4; - lower = new extFloat.ptr(new $Uint64(0, 0), 0, false); - upper = new extFloat.ptr(new $Uint64(0, 0), 0, false); - f = this; - f.mant = mant; - f.exp = exp - ((flt.mantbits >> 0)) >> 0; - f.neg = neg; - if (f.exp <= 0 && (x = $shiftLeft64(($shiftRightUint64(mant, ((-f.exp >>> 0)))), ((-f.exp >>> 0))), (mant.$high === x.$high && mant.$low === x.$low))) { - f.mant = $shiftRightUint64(f.mant, (((-f.exp >>> 0)))); - f.exp = 0; - _tmp = $clone(f, extFloat); - _tmp$1 = $clone(f, extFloat); - extFloat.copy(lower, _tmp); - extFloat.copy(upper, _tmp$1); - return [lower, upper]; - } - expBiased = exp - flt.bias >> 0; - extFloat.copy(upper, new extFloat.ptr((x$1 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$1.$high + 0, x$1.$low + 1)), f.exp - 1 >> 0, f.neg)); - if (!((x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) || (expBiased === 1)) { - extFloat.copy(lower, new extFloat.ptr((x$3 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$3.$high - 0, x$3.$low - 1)), f.exp - 1 >> 0, f.neg)); - } else { - extFloat.copy(lower, new extFloat.ptr((x$4 = $mul64(new $Uint64(0, 4), f.mant), new $Uint64(x$4.$high - 0, x$4.$low - 1)), f.exp - 2 >> 0, f.neg)); - } - return [lower, upper]; - }; - extFloat.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { return this.$val.AssignComputeBounds(mant, exp, neg, flt); }; - extFloat.ptr.prototype.Normalize = function() { - var f, shift, x; - f = this; - if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { - return 0; - } - shift = bits.LeadingZeros64(f.mant); - f.mant = $shiftLeft64(f.mant, (((shift >>> 0)))); - f.exp = f.exp - (shift) >> 0; - return ((shift >>> 0)); - }; - extFloat.prototype.Normalize = function() { return this.$val.Normalize(); }; - extFloat.ptr.prototype.Multiply = function(g) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, cross1, cross2, f, fhi, flo, g, ghi, glo, rem, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - f = this; - _tmp = $shiftRightUint64(f.mant, 32); - _tmp$1 = (new $Uint64(0, ((f.mant.$low >>> 0)))); - fhi = _tmp; - flo = _tmp$1; - _tmp$2 = $shiftRightUint64(g.mant, 32); - _tmp$3 = (new $Uint64(0, ((g.mant.$low >>> 0)))); - ghi = _tmp$2; - glo = _tmp$3; - cross1 = $mul64(fhi, glo); - cross2 = $mul64(flo, ghi); - f.mant = (x = (x$1 = $mul64(fhi, ghi), x$2 = $shiftRightUint64(cross1, 32), new $Uint64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)), x$3 = $shiftRightUint64(cross2, 32), new $Uint64(x.$high + x$3.$high, x.$low + x$3.$low)); - rem = (x$4 = (x$5 = (new $Uint64(0, ((cross1.$low >>> 0)))), x$6 = (new $Uint64(0, ((cross2.$low >>> 0)))), new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), x$7 = $shiftRightUint64(($mul64(flo, glo)), 32), new $Uint64(x$4.$high + x$7.$high, x$4.$low + x$7.$low)); - rem = (x$8 = new $Uint64(0, 2147483648), new $Uint64(rem.$high + x$8.$high, rem.$low + x$8.$low)); - f.mant = (x$9 = f.mant, x$10 = ($shiftRightUint64(rem, 32)), new $Uint64(x$9.$high + x$10.$high, x$9.$low + x$10.$low)); - f.exp = (f.exp + g.exp >> 0) + 64 >> 0; - }; - extFloat.prototype.Multiply = function(g) { return this.$val.Multiply(g); }; - extFloat.ptr.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { - var _q, _r, adjExp, denormalExp, errors$1, exp10, extrabits, f, flt, halfway, i, mant_extra, mantissa, neg, ok, shift, trunc, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y; - ok = false; - f = this; - errors$1 = 0; - if (trunc) { - errors$1 = errors$1 + (4) >> 0; - } - f.mant = mantissa; - f.exp = 0; - f.neg = neg; - i = (_q = ((exp10 - -348 >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - if (exp10 < -348 || i >= 87) { - ok = false; - return ok; - } - adjExp = (_r = ((exp10 - -348 >> 0)) % 8, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); - if (adjExp < 19 && (x = (x$1 = 19 - adjExp >> 0, ((x$1 < 0 || x$1 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$1])), (mantissa.$high < x.$high || (mantissa.$high === x.$high && mantissa.$low < x.$low)))) { - f.mant = $mul64(f.mant, (((adjExp < 0 || adjExp >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[adjExp]))); - f.Normalize(); - } else { - f.Normalize(); - f.Multiply($clone(((adjExp < 0 || adjExp >= smallPowersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : smallPowersOfTen[adjExp]), extFloat)); - errors$1 = errors$1 + (4) >> 0; - } - f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); - if (errors$1 > 0) { - errors$1 = errors$1 + (1) >> 0; - } - errors$1 = errors$1 + (4) >> 0; - shift = f.Normalize(); - errors$1 = (y = (shift), y < 32 ? (errors$1 << y) : 0) >> 0; - denormalExp = flt.bias - 63 >> 0; - extrabits = 0; - if (f.exp <= denormalExp) { - extrabits = ((63 - flt.mantbits >>> 0) + 1 >>> 0) + (((denormalExp - f.exp >> 0) >>> 0)) >>> 0; - } else { - extrabits = 63 - flt.mantbits >>> 0; - } - halfway = $shiftLeft64(new $Uint64(0, 1), ((extrabits - 1 >>> 0))); - mant_extra = (x$2 = f.mant, x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), extrabits), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); - if ((x$5 = (x$6 = (new $Int64(halfway.$high, halfway.$low)), x$7 = (new $Int64(0, errors$1)), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), x$8 = (new $Int64(mant_extra.$high, mant_extra.$low)), (x$5.$high < x$8.$high || (x$5.$high === x$8.$high && x$5.$low < x$8.$low))) && (x$9 = (new $Int64(mant_extra.$high, mant_extra.$low)), x$10 = (x$11 = (new $Int64(halfway.$high, halfway.$low)), x$12 = (new $Int64(0, errors$1)), new $Int64(x$11.$high + x$12.$high, x$11.$low + x$12.$low)), (x$9.$high < x$10.$high || (x$9.$high === x$10.$high && x$9.$low < x$10.$low)))) { - ok = false; - return ok; - } - ok = true; - return ok; - }; - extFloat.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { return this.$val.AssignDecimal(mantissa, exp10, neg, trunc, flt); }; - extFloat.ptr.prototype.frexp10 = function() { - var _q, _q$1, _tmp, _tmp$1, approxExp10, exp, exp10, f, i, index; - exp10 = 0; - index = 0; - f = this; - approxExp10 = (_q = ($imul(((-46 - f.exp >> 0)), 28)) / 93, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - i = (_q$1 = ((approxExp10 - -348 >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); - Loop: - while (true) { - exp = (f.exp + ((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]).exp >> 0) + 64 >> 0; - if (exp < -60) { - i = i + (1) >> 0; - } else if (exp > -32) { - i = i - (1) >> 0; - } else { - break Loop; - } - } - f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); - _tmp = -((-348 + ($imul(i, 8)) >> 0)); - _tmp$1 = i; - exp10 = _tmp; - index = _tmp$1; - return [exp10, index]; - }; - extFloat.prototype.frexp10 = function() { return this.$val.frexp10(); }; - frexp10Many = function(a, b, c) { - var _tuple, a, b, c, exp10, i; - exp10 = 0; - _tuple = c.frexp10(); - exp10 = _tuple[0]; - i = _tuple[1]; - a.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); - b.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); - return exp10; - }; - extFloat.ptr.prototype.FixedDecimal = function(d, n) { - var $CE$B5, _q, _q$1, _tmp, _tmp$1, _tuple, buf, d, digit, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, n, nd, needed, ok, pos, pow, pow10, rest, shift, v, v1, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - f = this; - if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { - d.nd = 0; - d.dp = 0; - d.neg = f.neg; - return true; - } - if (n === 0) { - $panic(new $String("strconv: internal error: extFloat.FixedDecimal called with n == 0")); - } - f.Normalize(); - _tuple = f.frexp10(); - exp10 = _tuple[0]; - shift = ((-f.exp >>> 0)); - integer = (($shiftRightUint64(f.mant, shift).$low >>> 0)); - fraction = (x$1 = f.mant, x$2 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - $CE$B5 = new $Uint64(0, 1); - needed = n; - integerDigits = 0; - pow10 = new $Uint64(0, 1); - _tmp = 0; - _tmp$1 = new $Uint64(0, 1); - i = _tmp; - pow = _tmp$1; - while (true) { - if (!(i < 20)) { break; } - if ((x$3 = (new $Uint64(0, integer)), (pow.$high > x$3.$high || (pow.$high === x$3.$high && pow.$low > x$3.$low)))) { - integerDigits = i; - break; - } - pow = $mul64(pow, (new $Uint64(0, 10))); - i = i + (1) >> 0; - } - rest = integer; - if (integerDigits > needed) { - pow10 = (x$4 = integerDigits - needed >> 0, ((x$4 < 0 || x$4 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$4])); - integer = (_q = integer / (((pow10.$low >>> 0))), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - rest = rest - (($imul(integer, ((pow10.$low >>> 0))) >>> 0)) >>> 0; - } else { - rest = 0; - } - buf = arrayType$2.zero(); - pos = 32; - v = integer; - while (true) { - if (!(v > 0)) { break; } - v1 = (_q$1 = v / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - v = v - (($imul(10, v1) >>> 0)) >>> 0; - pos = pos - (1) >> 0; - ((pos < 0 || pos >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[pos] = (((v + 48 >>> 0) << 24 >>> 24))); - v = v1; - } - i$1 = pos; - while (true) { - if (!(i$1 < 32)) { break; } - (x$5 = d.d, x$6 = i$1 - pos >> 0, ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6] = ((i$1 < 0 || i$1 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i$1]))); - i$1 = i$1 + (1) >> 0; - } - nd = 32 - pos >> 0; - d.nd = nd; - d.dp = integerDigits + exp10 >> 0; - needed = needed - (nd) >> 0; - if (needed > 0) { - if (!((rest === 0)) || !((pow10.$high === 0 && pow10.$low === 1))) { - $panic(new $String("strconv: internal error, rest != 0 but needed > 0")); - } - while (true) { - if (!(needed > 0)) { break; } - fraction = $mul64(fraction, (new $Uint64(0, 10))); - $CE$B5 = $mul64($CE$B5, (new $Uint64(0, 10))); - if ((x$7 = $mul64(new $Uint64(0, 2), $CE$B5), x$8 = $shiftLeft64(new $Uint64(0, 1), shift), (x$7.$high > x$8.$high || (x$7.$high === x$8.$high && x$7.$low > x$8.$low)))) { - return false; - } - digit = $shiftRightUint64(fraction, shift); - (x$9 = d.d, ((nd < 0 || nd >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + nd] = ((new $Uint64(digit.$high + 0, digit.$low + 48).$low << 24 >>> 24)))); - fraction = (x$10 = $shiftLeft64(digit, shift), new $Uint64(fraction.$high - x$10.$high, fraction.$low - x$10.$low)); - nd = nd + (1) >> 0; - needed = needed - (1) >> 0; - } - d.nd = nd; - } - ok = adjustLastDigitFixed(d, (x$11 = $shiftLeft64((new $Uint64(0, rest)), shift), new $Uint64(x$11.$high | fraction.$high, (x$11.$low | fraction.$low) >>> 0)), pow10, shift, $CE$B5); - if (!ok) { - return false; - } - i$2 = d.nd - 1 >> 0; - while (true) { - if (!(i$2 >= 0)) { break; } - if (!(((x$12 = d.d, ((i$2 < 0 || i$2 >= x$12.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + i$2])) === 48))) { - d.nd = i$2 + 1 >> 0; - break; - } - i$2 = i$2 - (1) >> 0; - } - return true; - }; - extFloat.prototype.FixedDecimal = function(d, n) { return this.$val.FixedDecimal(d, n); }; - adjustLastDigitFixed = function(d, num, den, shift, $CE$B5) { - var $CE$B5, d, den, i, num, shift, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - if ((x = $shiftLeft64(den, shift), (num.$high > x.$high || (num.$high === x.$high && num.$low > x.$low)))) { - $panic(new $String("strconv: num > den< x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { - $panic(new $String("strconv: \xCE\xB5 > (den< x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low)))) { - i = d.nd - 1 >> 0; - while (true) { - if (!(i >= 0)) { break; } - if ((x$7 = d.d, ((i < 0 || i >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + i])) === 57) { - d.nd = d.nd - (1) >> 0; - } else { - break; - } - i = i - (1) >> 0; - } - if (i < 0) { - (x$8 = d.d, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0] = 49)); - d.nd = 1; - d.dp = d.dp + (1) >> 0; - } else { - (x$10 = d.d, ((i < 0 || i >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + i] = ((x$9 = d.d, ((i < 0 || i >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + i])) + (1) << 24 >>> 24))); - } - return true; - } - return false; - }; - extFloat.ptr.prototype.ShortestDecimal = function(d, lower, upper) { - var _q, _tmp, _tmp$1, _tmp$2, _tmp$3, allowance, buf, currentDiff, d, digit, digit$1, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, lower, multiplier, n, nd, pow, pow$1, shift, targetDiff, upper, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - f = this; - if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { - d.nd = 0; - d.dp = 0; - d.neg = f.neg; - return true; - } - if ((f.exp === 0) && $equal(lower, f, extFloat) && $equal(lower, upper, extFloat)) { - buf = arrayType$1.zero(); - n = 23; - v = f.mant; - while (true) { - if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } - v1 = $div64(v, new $Uint64(0, 10), false); - v = (x$1 = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x$1.$high, v.$low - x$1.$low)); - ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); - n = n - (1) >> 0; - v = v1; - } - nd = (24 - n >> 0) - 1 >> 0; - i = 0; - while (true) { - if (!(i < nd)) { break; } - (x$3 = d.d, ((i < 0 || i >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i] = (x$2 = (n + 1 >> 0) + i >> 0, ((x$2 < 0 || x$2 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x$2])))); - i = i + (1) >> 0; - } - _tmp = nd; - _tmp$1 = nd; - d.nd = _tmp; - d.dp = _tmp$1; - while (true) { - if (!(d.nd > 0 && ((x$4 = d.d, x$5 = d.nd - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) === 48))) { break; } - d.nd = d.nd - (1) >> 0; - } - if (d.nd === 0) { - d.dp = 0; - } - d.neg = f.neg; - return true; - } - upper.Normalize(); - if (f.exp > upper.exp) { - f.mant = $shiftLeft64(f.mant, ((((f.exp - upper.exp >> 0) >>> 0)))); - f.exp = upper.exp; - } - if (lower.exp > upper.exp) { - lower.mant = $shiftLeft64(lower.mant, ((((lower.exp - upper.exp >> 0) >>> 0)))); - lower.exp = upper.exp; - } - exp10 = frexp10Many(lower, f, upper); - upper.mant = (x$6 = upper.mant, x$7 = new $Uint64(0, 1), new $Uint64(x$6.$high + x$7.$high, x$6.$low + x$7.$low)); - lower.mant = (x$8 = lower.mant, x$9 = new $Uint64(0, 1), new $Uint64(x$8.$high - x$9.$high, x$8.$low - x$9.$low)); - shift = ((-upper.exp >>> 0)); - integer = (($shiftRightUint64(upper.mant, shift).$low >>> 0)); - fraction = (x$10 = upper.mant, x$11 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$10.$high - x$11.$high, x$10.$low - x$11.$low)); - allowance = (x$12 = upper.mant, x$13 = lower.mant, new $Uint64(x$12.$high - x$13.$high, x$12.$low - x$13.$low)); - targetDiff = (x$14 = upper.mant, x$15 = f.mant, new $Uint64(x$14.$high - x$15.$high, x$14.$low - x$15.$low)); - integerDigits = 0; - _tmp$2 = 0; - _tmp$3 = new $Uint64(0, 1); - i$1 = _tmp$2; - pow = _tmp$3; - while (true) { - if (!(i$1 < 20)) { break; } - if ((x$16 = (new $Uint64(0, integer)), (pow.$high > x$16.$high || (pow.$high === x$16.$high && pow.$low > x$16.$low)))) { - integerDigits = i$1; - break; - } - pow = $mul64(pow, (new $Uint64(0, 10))); - i$1 = i$1 + (1) >> 0; - } - i$2 = 0; - while (true) { - if (!(i$2 < integerDigits)) { break; } - pow$1 = (x$17 = (integerDigits - i$2 >> 0) - 1 >> 0, ((x$17 < 0 || x$17 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$17])); - digit = (_q = integer / ((pow$1.$low >>> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - (x$18 = d.d, ((i$2 < 0 || i$2 >= x$18.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$18.$array[x$18.$offset + i$2] = (((digit + 48 >>> 0) << 24 >>> 24)))); - integer = integer - (($imul(digit, ((pow$1.$low >>> 0))) >>> 0)) >>> 0; - currentDiff = (x$19 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$19.$high + fraction.$high, x$19.$low + fraction.$low)); - if ((currentDiff.$high < allowance.$high || (currentDiff.$high === allowance.$high && currentDiff.$low < allowance.$low))) { - d.nd = i$2 + 1 >> 0; - d.dp = integerDigits + exp10 >> 0; - d.neg = f.neg; - return adjustLastDigit(d, currentDiff, targetDiff, allowance, $shiftLeft64(pow$1, shift), new $Uint64(0, 2)); - } - i$2 = i$2 + (1) >> 0; - } - d.nd = integerDigits; - d.dp = d.nd + exp10 >> 0; - d.neg = f.neg; - digit$1 = 0; - multiplier = new $Uint64(0, 1); - while (true) { - fraction = $mul64(fraction, (new $Uint64(0, 10))); - multiplier = $mul64(multiplier, (new $Uint64(0, 10))); - digit$1 = (($shiftRightUint64(fraction, shift).$low >> 0)); - (x$20 = d.d, x$21 = d.nd, ((x$21 < 0 || x$21 >= x$20.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$20.$array[x$20.$offset + x$21] = (((digit$1 + 48 >> 0) << 24 >>> 24)))); - d.nd = d.nd + (1) >> 0; - fraction = (x$22 = $shiftLeft64((new $Uint64(0, digit$1)), shift), new $Uint64(fraction.$high - x$22.$high, fraction.$low - x$22.$low)); - if ((x$23 = $mul64(allowance, multiplier), (fraction.$high < x$23.$high || (fraction.$high === x$23.$high && fraction.$low < x$23.$low)))) { - return adjustLastDigit(d, fraction, $mul64(targetDiff, multiplier), $mul64(allowance, multiplier), $shiftLeft64(new $Uint64(0, 1), shift), $mul64(multiplier, new $Uint64(0, 2))); - } - } - }; - extFloat.prototype.ShortestDecimal = function(d, lower, upper) { return this.$val.ShortestDecimal(d, lower, upper); }; - adjustLastDigit = function(d, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary) { - var _index, currentDiff, d, maxDiff, targetDiff, ulpBinary, ulpDecimal, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - if ((x = $mul64(new $Uint64(0, 2), ulpBinary), (ulpDecimal.$high < x.$high || (ulpDecimal.$high === x.$high && ulpDecimal.$low < x.$low)))) { - return false; - } - while (true) { - if (!((x$1 = (x$2 = (x$3 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(currentDiff.$high + x$3.$high, currentDiff.$low + x$3.$low)), new $Uint64(x$2.$high + ulpBinary.$high, x$2.$low + ulpBinary.$low)), (x$1.$high < targetDiff.$high || (x$1.$high === targetDiff.$high && x$1.$low < targetDiff.$low))))) { break; } - _index = d.nd - 1 >> 0; - (x$5 = d.d, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index] = ((x$4 = d.d, ((_index < 0 || _index >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + _index])) - (1) << 24 >>> 24))); - currentDiff = (x$6 = ulpDecimal, new $Uint64(currentDiff.$high + x$6.$high, currentDiff.$low + x$6.$low)); - } - if ((x$7 = new $Uint64(currentDiff.$high + ulpDecimal.$high, currentDiff.$low + ulpDecimal.$low), x$8 = (x$9 = (x$10 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(targetDiff.$high + x$10.$high, targetDiff.$low + x$10.$low)), new $Uint64(x$9.$high + ulpBinary.$high, x$9.$low + ulpBinary.$low)), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low <= x$8.$low)))) { - return false; - } - if ((currentDiff.$high < ulpBinary.$high || (currentDiff.$high === ulpBinary.$high && currentDiff.$low < ulpBinary.$low)) || (x$11 = new $Uint64(maxDiff.$high - ulpBinary.$high, maxDiff.$low - ulpBinary.$low), (currentDiff.$high > x$11.$high || (currentDiff.$high === x$11.$high && currentDiff.$low > x$11.$low)))) { - return false; - } - if ((d.nd === 1) && ((x$12 = d.d, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0])) === 48)) { - d.nd = 0; - d.dp = 0; - } - return true; - }; - FormatFloat = function(f, fmt, prec, bitSize) { - var bitSize, f, fmt, prec; - return ($bytesToString(genericFtoa($makeSlice(sliceType$6, 0, max(prec + 4 >> 0, 24)), f, fmt, prec, bitSize))); - }; - $pkg.FormatFloat = FormatFloat; - AppendFloat = function(dst, f, fmt, prec, bitSize) { - var bitSize, dst, f, fmt, prec; - return genericFtoa(dst, f, fmt, prec, bitSize); - }; - $pkg.AppendFloat = AppendFloat; - genericFtoa = function(dst, val, fmt, prec, bitSize) { - var _1, _2, _3, _4, _tuple, bitSize, bits$1, buf, buf$1, digits, digs, dst, exp, f, f$1, flt, fmt, lower, mant, neg, ok, prec, s, shortest, upper, val, x, x$1, x$2, x$3, y, y$1; - bits$1 = new $Uint64(0, 0); - flt = ptrType$1.nil; - _1 = bitSize; - if (_1 === (32)) { - bits$1 = (new $Uint64(0, math.Float32bits(($fround(val))))); - flt = float32info; - } else if (_1 === (64)) { - bits$1 = math.Float64bits(val); - flt = float64info; - } else { - $panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize")); - } - neg = !((x = $shiftRightUint64(bits$1, ((flt.expbits + flt.mantbits >>> 0))), (x.$high === 0 && x.$low === 0))); - exp = (($shiftRightUint64(bits$1, flt.mantbits).$low >> 0)) & ((((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)); - mant = (x$1 = (x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$2.$high - 0, x$2.$low - 1)), new $Uint64(bits$1.$high & x$1.$high, (bits$1.$low & x$1.$low) >>> 0)); - _2 = exp; - if (_2 === ((((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0))) { - s = ""; - if (!((mant.$high === 0 && mant.$low === 0))) { - s = "NaN"; - } else if (neg) { - s = "-Inf"; - } else { - s = "+Inf"; - } - return $appendSlice(dst, s); - } else if (_2 === (0)) { - exp = exp + (1) >> 0; - } else { - mant = (x$3 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high | x$3.$high, (mant.$low | x$3.$low) >>> 0)); - } - exp = exp + (flt.bias) >> 0; - if (fmt === 98) { - return fmtB(dst, neg, mant, exp, flt); - } - if (!optimize) { - return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); - } - digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); - ok = false; - shortest = prec < 0; - if (shortest) { - f = new extFloat.ptr(new $Uint64(0, 0), 0, false); - _tuple = f.AssignComputeBounds(mant, exp, neg, flt); - lower = $clone(_tuple[0], extFloat); - upper = $clone(_tuple[1], extFloat); - buf = arrayType$2.zero(); - digs.d = new sliceType$6(buf); - ok = f.ShortestDecimal(digs, lower, upper); - if (!ok) { - return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); - } - _3 = fmt; - if ((_3 === (101)) || (_3 === (69))) { - prec = max(digs.nd - 1 >> 0, 0); - } else if (_3 === (102)) { - prec = max(digs.nd - digs.dp >> 0, 0); - } else if ((_3 === (103)) || (_3 === (71))) { - prec = digs.nd; - } - } else if (!((fmt === 102))) { - digits = prec; - _4 = fmt; - if ((_4 === (101)) || (_4 === (69))) { - digits = digits + (1) >> 0; - } else if ((_4 === (103)) || (_4 === (71))) { - if (prec === 0) { - prec = 1; - } - digits = prec; - } - if (digits <= 15) { - buf$1 = arrayType$1.zero(); - digs.d = new sliceType$6(buf$1); - f$1 = new extFloat.ptr(mant, exp - ((flt.mantbits >> 0)) >> 0, neg); - ok = f$1.FixedDecimal(digs, digits); - } - } - if (!ok) { - return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); - } - return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); - }; - bigFtoa = function(dst, prec, fmt, neg, mant, exp, flt) { - var _1, _2, d, digs, dst, exp, flt, fmt, mant, neg, prec, shortest; - d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); - d.Assign(mant); - d.Shift(exp - ((flt.mantbits >> 0)) >> 0); - digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); - shortest = prec < 0; - if (shortest) { - roundShortest(d, mant, exp, flt); - decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); - _1 = fmt; - if ((_1 === (101)) || (_1 === (69))) { - prec = digs.nd - 1 >> 0; - } else if (_1 === (102)) { - prec = max(digs.nd - digs.dp >> 0, 0); - } else if ((_1 === (103)) || (_1 === (71))) { - prec = digs.nd; - } - } else { - _2 = fmt; - if ((_2 === (101)) || (_2 === (69))) { - d.Round(prec + 1 >> 0); - } else if (_2 === (102)) { - d.Round(d.dp + prec >> 0); - } else if ((_2 === (103)) || (_2 === (71))) { - if (prec === 0) { - prec = 1; - } - d.Round(prec); - } - decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); - } - return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); - }; - formatDigits = function(dst, shortest, neg, digs, prec, fmt) { - var _1, digs, dst, eprec, exp, fmt, neg, prec, shortest; - _1 = fmt; - if ((_1 === (101)) || (_1 === (69))) { - return fmtE(dst, neg, $clone(digs, decimalSlice), prec, fmt); - } else if (_1 === (102)) { - return fmtF(dst, neg, $clone(digs, decimalSlice), prec); - } else if ((_1 === (103)) || (_1 === (71))) { - eprec = prec; - if (eprec > digs.nd && digs.nd >= digs.dp) { - eprec = digs.nd; - } - if (shortest) { - eprec = 6; - } - exp = digs.dp - 1 >> 0; - if (exp < -4 || exp >= eprec) { - if (prec > digs.nd) { - prec = digs.nd; - } - return fmtE(dst, neg, $clone(digs, decimalSlice), prec - 1 >> 0, (fmt + 101 << 24 >>> 24) - 103 << 24 >>> 24); - } - if (prec > digs.dp) { - prec = digs.nd; - } - return fmtF(dst, neg, $clone(digs, decimalSlice), max(prec - digs.dp >> 0, 0)); - } - return $append(dst, 37, fmt); - }; - roundShortest = function(d, mant, exp, flt) { - var d, exp, explo, flt, i, inclusive, l, lower, m, mant, mantlo, minexp, okdown, okup, u, upper, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; - if ((mant.$high === 0 && mant.$low === 0)) { - d.nd = 0; - return; - } - minexp = flt.bias + 1 >> 0; - if (exp > minexp && ($imul(332, ((d.dp - d.nd >> 0)))) >= ($imul(100, ((exp - ((flt.mantbits >> 0)) >> 0))))) { - return; - } - upper = new decimal.ptr(arrayType.zero(), 0, 0, false, false); - upper.Assign((x = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x.$high + 0, x.$low + 1))); - upper.Shift((exp - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); - mantlo = new $Uint64(0, 0); - explo = 0; - if ((x$1 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high > x$1.$high || (mant.$high === x$1.$high && mant.$low > x$1.$low))) || (exp === minexp)) { - mantlo = new $Uint64(mant.$high - 0, mant.$low - 1); - explo = exp; - } else { - mantlo = (x$2 = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x$2.$high - 0, x$2.$low - 1)); - explo = exp - 1 >> 0; - } - lower = new decimal.ptr(arrayType.zero(), 0, 0, false, false); - lower.Assign((x$3 = $mul64(mantlo, new $Uint64(0, 2)), new $Uint64(x$3.$high + 0, x$3.$low + 1))); - lower.Shift((explo - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); - inclusive = (x$4 = $div64(mant, new $Uint64(0, 2), true), (x$4.$high === 0 && x$4.$low === 0)); - i = 0; - while (true) { - if (!(i < d.nd)) { break; } - l = 48; - if (i < lower.nd) { - l = (x$5 = lower.d, ((i < 0 || i >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i])); - } - m = (x$6 = d.d, ((i < 0 || i >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i])); - u = 48; - if (i < upper.nd) { - u = (x$7 = upper.d, ((i < 0 || i >= x$7.length) ? ($throwRuntimeError("index out of range"), undefined) : x$7[i])); - } - okdown = !((l === m)) || inclusive && ((i + 1 >> 0) === lower.nd); - okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.nd); - if (okdown && okup) { - d.Round(i + 1 >> 0); - return; - } else if (okdown) { - d.RoundDown(i + 1 >> 0); - return; - } else if (okup) { - d.RoundUp(i + 1 >> 0); - return; - } - i = i + (1) >> 0; - } - }; - fmtE = function(dst, neg, d, prec, fmt) { - var _q, _q$1, _q$2, _r, _r$1, _r$2, ch, d, dst, exp, fmt, i, m, neg, prec, x; - if (neg) { - dst = $append(dst, 45); - } - ch = 48; - if (!((d.nd === 0))) { - ch = (x = d.d, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - } - dst = $append(dst, ch); - if (prec > 0) { - dst = $append(dst, 46); - i = 1; - m = min(d.nd, prec + 1 >> 0); - if (i < m) { - dst = $appendSlice(dst, $subslice(d.d, i, m)); - i = m; - } - while (true) { - if (!(i <= prec)) { break; } - dst = $append(dst, 48); - i = i + (1) >> 0; - } - } - dst = $append(dst, fmt); - exp = d.dp - 1 >> 0; - if (d.nd === 0) { - exp = 0; - } - if (exp < 0) { - ch = 45; - exp = -exp; - } else { - ch = 43; - } - dst = $append(dst, ch); - if (exp < 10) { - dst = $append(dst, 48, ((exp << 24 >>> 24)) + 48 << 24 >>> 24); - } else if (exp < 100) { - dst = $append(dst, (((_q = exp / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (((_r = exp % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); - } else { - dst = $append(dst, (((_q$1 = exp / 100, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (_r$1 = (((_q$2 = exp / 10, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) % 10, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) + 48 << 24 >>> 24, (((_r$2 = exp % 10, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); - } - return dst; - }; - fmtF = function(dst, neg, d, prec) { - var ch, d, dst, i, j, m, neg, prec, x; - if (neg) { - dst = $append(dst, 45); - } - if (d.dp > 0) { - m = min(d.nd, d.dp); - dst = $appendSlice(dst, $subslice(d.d, 0, m)); - while (true) { - if (!(m < d.dp)) { break; } - dst = $append(dst, 48); - m = m + (1) >> 0; - } - } else { - dst = $append(dst, 48); - } - if (prec > 0) { - dst = $append(dst, 46); - i = 0; - while (true) { - if (!(i < prec)) { break; } - ch = 48; - j = d.dp + i >> 0; - if (0 <= j && j < d.nd) { - ch = (x = d.d, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); - } - dst = $append(dst, ch); - i = i + (1) >> 0; - } - } - return dst; - }; - fmtB = function(dst, neg, mant, exp, flt) { - var _tuple, _tuple$1, dst, exp, flt, mant, neg; - if (neg) { - dst = $append(dst, 45); - } - _tuple = formatBits(dst, mant, 10, false, true); - dst = _tuple[0]; - dst = $append(dst, 112); - exp = exp - (((flt.mantbits >> 0))) >> 0; - if (exp >= 0) { - dst = $append(dst, 43); - } - _tuple$1 = formatBits(dst, (new $Uint64(0, exp)), 10, exp < 0, true); - dst = _tuple$1[0]; - return dst; - }; - min = function(a, b) { - var a, b; - if (a < b) { - return a; - } - return b; - }; - max = function(a, b) { - var a, b; - if (a > b) { - return a; - } - return b; - }; - FormatUint = function(i, base) { - var _tuple, base, i, s; - if (true && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { - return small(((i.$low >> 0))); - } - _tuple = formatBits(sliceType$6.nil, i, base, false, false); - s = _tuple[1]; - return s; - }; - $pkg.FormatUint = FormatUint; - FormatInt = function(i, base) { - var _tuple, base, i, s; - if (true && (0 < i.$high || (0 === i.$high && 0 <= i.$low)) && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { - return small((((i.$low + ((i.$high >> 31) * 4294967296)) >> 0))); - } - _tuple = formatBits(sliceType$6.nil, (new $Uint64(i.$high, i.$low)), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), false); - s = _tuple[1]; - return s; - }; - $pkg.FormatInt = FormatInt; - Itoa = function(i) { - var i; - return FormatInt((new $Int64(0, i)), 10); - }; - $pkg.Itoa = Itoa; - AppendInt = function(dst, i, base) { - var _tuple, base, dst, i; - if (true && (0 < i.$high || (0 === i.$high && 0 <= i.$low)) && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { - return $appendSlice(dst, small((((i.$low + ((i.$high >> 31) * 4294967296)) >> 0)))); - } - _tuple = formatBits(dst, (new $Uint64(i.$high, i.$low)), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), true); - dst = _tuple[0]; - return dst; - }; - $pkg.AppendInt = AppendInt; - AppendUint = function(dst, i, base) { - var _tuple, base, dst, i; - if (true && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { - return $appendSlice(dst, small(((i.$low >> 0)))); - } - _tuple = formatBits(dst, i, base, false, true); - dst = _tuple[0]; - return dst; - }; - $pkg.AppendUint = AppendUint; - small = function(i) { - var i; - if (i < 10) { - return $substring("0123456789abcdefghijklmnopqrstuvwxyz", i, (i + 1 >> 0)); - } - return $substring("00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899", ($imul(i, 2)), (($imul(i, 2)) + 2 >> 0)); - }; - formatBits = function(dst, u, base, neg, append_) { - var _q, _q$1, _r, _r$1, a, append_, b, b$1, base, d, dst, i, is, is$1, is$2, j, m, neg, q, q$1, s, shift, u, us, us$1, x, x$1, x$2, x$3, x$4, x$5; - d = sliceType$6.nil; - s = ""; - if (base < 2 || base > 36) { - $panic(new $String("strconv: illegal AppendInt/FormatInt base")); - } - a = arrayType$3.zero(); - i = 65; - if (neg) { - u = new $Uint64(-u.$high, -u.$low); - } - if (base === 10) { - if (true) { - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 1000000000)))) { break; } - q = $div64(u, new $Uint64(0, 1000000000), false); - us = (((x = $mul64(q, new $Uint64(0, 1000000000)), new $Uint64(u.$high - x.$high, u.$low - x.$low)).$low >>> 0)); - j = 4; - while (true) { - if (!(j > 0)) { break; } - is = (_r = us % 100, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; - us = (_q = us / (100), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - i = i - (2) >> 0; - (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$1] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 1 >>> 0)))); - (x$2 = i + 0 >> 0, ((x$2 < 0 || x$2 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$2] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 0 >>> 0)))); - j = j - (1) >> 0; - } - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(((us * 2 >>> 0) + 1 >>> 0))); - u = q; - } - } - us$1 = ((u.$low >>> 0)); - while (true) { - if (!(us$1 >= 100)) { break; } - is$1 = (_r$1 = us$1 % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; - us$1 = (_q$1 = us$1 / (100), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - i = i - (2) >> 0; - (x$3 = i + 1 >> 0, ((x$3 < 0 || x$3 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$3] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 1 >>> 0)))); - (x$4 = i + 0 >> 0, ((x$4 < 0 || x$4 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$4] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 0 >>> 0)))); - } - is$2 = us$1 * 2 >>> 0; - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$2 + 1 >>> 0))); - if (us$1 >= 10) { - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(is$2)); - } - } else if (isPowerOfTwo(base)) { - shift = (((bits.TrailingZeros(((base >>> 0))) >>> 0)) & 7) >>> 0; - b = (new $Uint64(0, base)); - m = ((base >>> 0)) - 1 >>> 0; - while (true) { - if (!((u.$high > b.$high || (u.$high === b.$high && u.$low >= b.$low)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((((u.$low >>> 0)) & m) >>> 0))); - u = $shiftRightUint64(u, (shift)); - } - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); - } else { - b$1 = (new $Uint64(0, base)); - while (true) { - if (!((u.$high > b$1.$high || (u.$high === b$1.$high && u.$low >= b$1.$low)))) { break; } - i = i - (1) >> 0; - q$1 = $div64(u, b$1, false); - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((x$5 = $mul64(q$1, b$1), new $Uint64(u.$high - x$5.$high, u.$low - x$5.$low)).$low >>> 0)))); - u = q$1; - } - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); - } - if (neg) { - i = i - (1) >> 0; - ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = 45); - } - if (append_) { - d = $appendSlice(dst, $subslice(new sliceType$6(a), i)); - return [d, s]; - } - s = ($bytesToString($subslice(new sliceType$6(a), i))); - return [d, s]; - }; - isPowerOfTwo = function(x) { - var x; - return (x & ((x - 1 >> 0))) === 0; - }; - quoteWith = function(s, quote, ASCIIonly, graphicOnly) { - var ASCIIonly, _q, graphicOnly, quote, s; - return ($bytesToString(appendQuotedWith($makeSlice(sliceType$6, 0, (_q = ($imul(3, s.length)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))), s, quote, ASCIIonly, graphicOnly))); - }; - appendQuotedWith = function(buf, s, quote, ASCIIonly, graphicOnly) { - var ASCIIonly, _tuple, buf, graphicOnly, quote, r, s, width; - buf = $append(buf, quote); - width = 0; - while (true) { - if (!(s.length > 0)) { break; } - r = ((s.charCodeAt(0) >> 0)); - width = 1; - if (r >= 128) { - _tuple = utf8.DecodeRuneInString(s); - r = _tuple[0]; - width = _tuple[1]; - } - if ((width === 1) && (r === 65533)) { - buf = $appendSlice(buf, "\\x"); - buf = $append(buf, "0123456789abcdef".charCodeAt((s.charCodeAt(0) >>> 4 << 24 >>> 24))); - buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0))); - s = $substring(s, width); - continue; - } - buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); - s = $substring(s, width); - } - buf = $append(buf, quote); - return buf; - }; - appendQuotedRuneWith = function(buf, r, quote, ASCIIonly, graphicOnly) { - var ASCIIonly, buf, graphicOnly, quote, r; - buf = $append(buf, quote); - if (!utf8.ValidRune(r)) { - r = 65533; - } - buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); - buf = $append(buf, quote); - return buf; - }; - appendEscapedRune = function(buf, r, quote, ASCIIonly, graphicOnly) { - var ASCIIonly, _1, buf, graphicOnly, n, quote, r, runeTmp, s, s$1; - runeTmp = arrayType$4.zero(); - if ((r === ((quote >> 0))) || (r === 92)) { - buf = $append(buf, 92); - buf = $append(buf, ((r << 24 >>> 24))); - return buf; - } - if (ASCIIonly) { - if (r < 128 && IsPrint(r)) { - buf = $append(buf, ((r << 24 >>> 24))); - return buf; - } - } else if (IsPrint(r) || graphicOnly && isInGraphicList(r)) { - n = utf8.EncodeRune(new sliceType$6(runeTmp), r); - buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n)); - return buf; - } - _1 = r; - if (_1 === (7)) { - buf = $appendSlice(buf, "\\a"); - } else if (_1 === (8)) { - buf = $appendSlice(buf, "\\b"); - } else if (_1 === (12)) { - buf = $appendSlice(buf, "\\f"); - } else if (_1 === (10)) { - buf = $appendSlice(buf, "\\n"); - } else if (_1 === (13)) { - buf = $appendSlice(buf, "\\r"); - } else if (_1 === (9)) { - buf = $appendSlice(buf, "\\t"); - } else if (_1 === (11)) { - buf = $appendSlice(buf, "\\v"); - } else { - if (r < 32) { - buf = $appendSlice(buf, "\\x"); - buf = $append(buf, "0123456789abcdef".charCodeAt((((r << 24 >>> 24)) >>> 4 << 24 >>> 24))); - buf = $append(buf, "0123456789abcdef".charCodeAt(((((r << 24 >>> 24)) & 15) >>> 0))); - } else if (r > 1114111) { - r = 65533; - buf = $appendSlice(buf, "\\u"); - s = 12; - while (true) { - if (!(s >= 0)) { break; } - buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); - s = s - (4) >> 0; - } - } else if (r < 65536) { - buf = $appendSlice(buf, "\\u"); - s = 12; - while (true) { - if (!(s >= 0)) { break; } - buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); - s = s - (4) >> 0; - } - } else { - buf = $appendSlice(buf, "\\U"); - s$1 = 28; - while (true) { - if (!(s$1 >= 0)) { break; } - buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s$1 >>> 0)), 31)) >> 0) & 15))); - s$1 = s$1 - (4) >> 0; - } - } - } - return buf; - }; - Quote = function(s) { - var s; - return quoteWith(s, 34, false, false); - }; - $pkg.Quote = Quote; - AppendQuote = function(dst, s) { - var dst, s; - return appendQuotedWith(dst, s, 34, false, false); - }; - $pkg.AppendQuote = AppendQuote; - QuoteToASCII = function(s) { - var s; - return quoteWith(s, 34, true, false); - }; - $pkg.QuoteToASCII = QuoteToASCII; - AppendQuoteToASCII = function(dst, s) { - var dst, s; - return appendQuotedWith(dst, s, 34, true, false); - }; - $pkg.AppendQuoteToASCII = AppendQuoteToASCII; - AppendQuoteRune = function(dst, r) { - var dst, r; - return appendQuotedRuneWith(dst, r, 39, false, false); - }; - $pkg.AppendQuoteRune = AppendQuoteRune; - AppendQuoteRuneToASCII = function(dst, r) { - var dst, r; - return appendQuotedRuneWith(dst, r, 39, true, false); - }; - $pkg.AppendQuoteRuneToASCII = AppendQuoteRuneToASCII; - CanBackquote = function(s) { - var _tuple, r, s, wid; - while (true) { - if (!(s.length > 0)) { break; } - _tuple = utf8.DecodeRuneInString(s); - r = _tuple[0]; - wid = _tuple[1]; - s = $substring(s, wid); - if (wid > 1) { - if (r === 65279) { - return false; - } - continue; - } - if (r === 65533) { - return false; - } - if ((r < 32 && !((r === 9))) || (r === 96) || (r === 127)) { - return false; - } - } - return true; - }; - $pkg.CanBackquote = CanBackquote; - unhex = function(b) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, c, ok, v; - v = 0; - ok = false; - c = ((b >> 0)); - if (48 <= c && c <= 57) { - _tmp = c - 48 >> 0; - _tmp$1 = true; - v = _tmp; - ok = _tmp$1; - return [v, ok]; - } else if (97 <= c && c <= 102) { - _tmp$2 = (c - 97 >> 0) + 10 >> 0; - _tmp$3 = true; - v = _tmp$2; - ok = _tmp$3; - return [v, ok]; - } else if (65 <= c && c <= 70) { - _tmp$4 = (c - 65 >> 0) + 10 >> 0; - _tmp$5 = true; - v = _tmp$4; - ok = _tmp$5; - return [v, ok]; - } - return [v, ok]; - }; - UnquoteChar = function(s, quote) { - var _1, _2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, c, c$1, err, j, j$1, multibyte, n, ok, quote, r, s, size, tail, v, v$1, value, x, x$1; - value = 0; - multibyte = false; - tail = ""; - err = $ifaceNil; - if (s.length === 0) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - c = s.charCodeAt(0); - if ((c === quote) && ((quote === 39) || (quote === 34))) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } else if (c >= 128) { - _tuple = utf8.DecodeRuneInString(s); - r = _tuple[0]; - size = _tuple[1]; - _tmp = r; - _tmp$1 = true; - _tmp$2 = $substring(s, size); - _tmp$3 = $ifaceNil; - value = _tmp; - multibyte = _tmp$1; - tail = _tmp$2; - err = _tmp$3; - return [value, multibyte, tail, err]; - } else if (!((c === 92))) { - _tmp$4 = ((s.charCodeAt(0) >> 0)); - _tmp$5 = false; - _tmp$6 = $substring(s, 1); - _tmp$7 = $ifaceNil; - value = _tmp$4; - multibyte = _tmp$5; - tail = _tmp$6; - err = _tmp$7; - return [value, multibyte, tail, err]; - } - if (s.length <= 1) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - c$1 = s.charCodeAt(1); - s = $substring(s, 2); - switch (0) { default: - _1 = c$1; - if (_1 === (97)) { - value = 7; - } else if (_1 === (98)) { - value = 8; - } else if (_1 === (102)) { - value = 12; - } else if (_1 === (110)) { - value = 10; - } else if (_1 === (114)) { - value = 13; - } else if (_1 === (116)) { - value = 9; - } else if (_1 === (118)) { - value = 11; - } else if ((_1 === (120)) || (_1 === (117)) || (_1 === (85))) { - n = 0; - _2 = c$1; - if (_2 === (120)) { - n = 2; - } else if (_2 === (117)) { - n = 4; - } else if (_2 === (85)) { - n = 8; - } - v = 0; - if (s.length < n) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - j = 0; - while (true) { - if (!(j < n)) { break; } - _tuple$1 = unhex(s.charCodeAt(j)); - x = _tuple$1[0]; - ok = _tuple$1[1]; - if (!ok) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - v = (v << 4 >> 0) | x; - j = j + (1) >> 0; - } - s = $substring(s, n); - if (c$1 === 120) { - value = v; - break; - } - if (v > 1114111) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - value = v; - multibyte = true; - } else if ((_1 === (48)) || (_1 === (49)) || (_1 === (50)) || (_1 === (51)) || (_1 === (52)) || (_1 === (53)) || (_1 === (54)) || (_1 === (55))) { - v$1 = ((c$1 >> 0)) - 48 >> 0; - if (s.length < 2) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - j$1 = 0; - while (true) { - if (!(j$1 < 2)) { break; } - x$1 = ((s.charCodeAt(j$1) >> 0)) - 48 >> 0; - if (x$1 < 0 || x$1 > 7) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - v$1 = ((v$1 << 3 >> 0)) | x$1; - j$1 = j$1 + (1) >> 0; - } - s = $substring(s, 2); - if (v$1 > 255) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - value = v$1; - } else if (_1 === (92)) { - value = 92; - } else if ((_1 === (39)) || (_1 === (34))) { - if (!((c$1 === quote))) { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - value = ((c$1 >> 0)); - } else { - err = $pkg.ErrSyntax; - return [value, multibyte, tail, err]; - } - } - tail = s; - return [value, multibyte, tail, err]; - }; - $pkg.UnquoteChar = UnquoteChar; - Unquote = function(s) { - var _1, _q, _tuple, _tuple$1, buf, buf$1, c, err, i, multibyte, n, n$1, quote, r, runeTmp, s, size, ss; - n = s.length; - if (n < 2) { - return ["", $pkg.ErrSyntax]; - } - quote = s.charCodeAt(0); - if (!((quote === s.charCodeAt((n - 1 >> 0))))) { - return ["", $pkg.ErrSyntax]; - } - s = $substring(s, 1, (n - 1 >> 0)); - if (quote === 96) { - if (contains(s, 96)) { - return ["", $pkg.ErrSyntax]; - } - if (contains(s, 13)) { - buf = $makeSlice(sliceType$6, 0, (s.length - 1 >> 0)); - i = 0; - while (true) { - if (!(i < s.length)) { break; } - if (!((s.charCodeAt(i) === 13))) { - buf = $append(buf, s.charCodeAt(i)); - } - i = i + (1) >> 0; - } - return [($bytesToString(buf)), $ifaceNil]; - } - return [s, $ifaceNil]; - } - if (!((quote === 34)) && !((quote === 39))) { - return ["", $pkg.ErrSyntax]; - } - if (contains(s, 10)) { - return ["", $pkg.ErrSyntax]; - } - if (!contains(s, 92) && !contains(s, quote)) { - _1 = quote; - if (_1 === (34)) { - if (utf8.ValidString(s)) { - return [s, $ifaceNil]; - } - } else if (_1 === (39)) { - _tuple = utf8.DecodeRuneInString(s); - r = _tuple[0]; - size = _tuple[1]; - if ((size === s.length) && (!((r === 65533)) || !((size === 1)))) { - return [s, $ifaceNil]; - } - } - } - runeTmp = arrayType$4.zero(); - buf$1 = $makeSlice(sliceType$6, 0, (_q = ($imul(3, s.length)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); - while (true) { - if (!(s.length > 0)) { break; } - _tuple$1 = UnquoteChar(s, quote); - c = _tuple$1[0]; - multibyte = _tuple$1[1]; - ss = _tuple$1[2]; - err = _tuple$1[3]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return ["", err]; - } - s = ss; - if (c < 128 || !multibyte) { - buf$1 = $append(buf$1, ((c << 24 >>> 24))); - } else { - n$1 = utf8.EncodeRune(new sliceType$6(runeTmp), c); - buf$1 = $appendSlice(buf$1, $subslice(new sliceType$6(runeTmp), 0, n$1)); - } - if ((quote === 39) && !((s.length === 0))) { - return ["", $pkg.ErrSyntax]; - } - } - return [($bytesToString(buf$1)), $ifaceNil]; - }; - $pkg.Unquote = Unquote; - contains = function(s, c) { - var c, s; - return !((bytealg.IndexByteString(s, c) === -1)); - }; - bsearch16 = function(a, x) { - var _q, _tmp, _tmp$1, a, h, i, j, x; - _tmp = 0; - _tmp$1 = a.$length; - i = _tmp; - j = _tmp$1; - while (true) { - if (!(i < j)) { break; } - h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { - i = h + 1 >> 0; - } else { - j = h; - } - } - return i; - }; - bsearch32 = function(a, x) { - var _q, _tmp, _tmp$1, a, h, i, j, x; - _tmp = 0; - _tmp$1 = a.$length; - i = _tmp; - j = _tmp$1; - while (true) { - if (!(i < j)) { break; } - h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { - i = h + 1 >> 0; - } else { - j = h; - } - } - return i; - }; - IsPrint = function(r) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, i, i$1, isNotPrint, isNotPrint$1, isPrint, isPrint$1, j, j$1, r, rr, rr$1, x, x$1, x$2, x$3; - if (r <= 255) { - if (32 <= r && r <= 126) { - return true; - } - if (161 <= r && r <= 255) { - return !((r === 173)); - } - return false; - } - if (0 <= r && r < 65536) { - _tmp = ((r << 16 >>> 16)); - _tmp$1 = isPrint16; - _tmp$2 = isNotPrint16; - rr = _tmp; - isPrint = _tmp$1; - isNotPrint = _tmp$2; - i = bsearch16(isPrint, rr); - if (i >= isPrint.$length || rr < (x = (i & ~1) >> 0, ((x < 0 || x >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x])) || (x$1 = i | 1, ((x$1 < 0 || x$1 >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x$1])) < rr) { - return false; - } - j = bsearch16(isNotPrint, rr); - return j >= isNotPrint.$length || !((((j < 0 || j >= isNotPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint.$array[isNotPrint.$offset + j]) === rr)); - } - _tmp$3 = ((r >>> 0)); - _tmp$4 = isPrint32; - _tmp$5 = isNotPrint32; - rr$1 = _tmp$3; - isPrint$1 = _tmp$4; - isNotPrint$1 = _tmp$5; - i$1 = bsearch32(isPrint$1, rr$1); - if (i$1 >= isPrint$1.$length || rr$1 < (x$2 = (i$1 & ~1) >> 0, ((x$2 < 0 || x$2 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$2])) || (x$3 = i$1 | 1, ((x$3 < 0 || x$3 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$3])) < rr$1) { - return false; - } - if (r >= 131072) { - return true; - } - r = r - (65536) >> 0; - j$1 = bsearch16(isNotPrint$1, ((r << 16 >>> 16))); - return j$1 >= isNotPrint$1.$length || !((((j$1 < 0 || j$1 >= isNotPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint$1.$array[isNotPrint$1.$offset + j$1]) === ((r << 16 >>> 16)))); - }; - $pkg.IsPrint = IsPrint; - isInGraphicList = function(r) { - var i, r, rr; - if (r > 65535) { - return false; - } - rr = ((r << 16 >>> 16)); - i = bsearch16(isGraphic, rr); - return i < isGraphic.$length && (rr === ((i < 0 || i >= isGraphic.$length) ? ($throwRuntimeError("index out of range"), undefined) : isGraphic.$array[isGraphic.$offset + i])); - }; - ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$2.methods = [{prop: "set", name: "set", pkg: "strconv", typ: $funcType([$String], [$Bool], false)}, {prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Assign", name: "Assign", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "Shift", name: "Shift", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundDown", name: "RoundDown", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundUp", name: "RoundUp", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundedInteger", name: "RoundedInteger", pkg: "", typ: $funcType([], [$Uint64], false)}]; - ptrType$4.methods = [{prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "AssignComputeBounds", name: "AssignComputeBounds", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, ptrType$1], [extFloat, extFloat], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([extFloat], [], false)}, {prop: "AssignDecimal", name: "AssignDecimal", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, $Bool, ptrType$1], [$Bool], false)}, {prop: "frexp10", name: "frexp10", pkg: "strconv", typ: $funcType([], [$Int, $Int], false)}, {prop: "FixedDecimal", name: "FixedDecimal", pkg: "", typ: $funcType([ptrType$3, $Int], [$Bool], false)}, {prop: "ShortestDecimal", name: "ShortestDecimal", pkg: "", typ: $funcType([ptrType$3, ptrType$4, ptrType$4], [$Bool], false)}]; - NumError.init("", [{prop: "Func", name: "Func", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Num", name: "Num", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); - decimal.init("strconv", [{prop: "d", name: "d", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "nd", name: "nd", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "trunc", name: "trunc", embedded: false, exported: false, typ: $Bool, tag: ""}]); - leftCheat.init("strconv", [{prop: "delta", name: "delta", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cutoff", name: "cutoff", embedded: false, exported: false, typ: $String, tag: ""}]); - extFloat.init("strconv", [{prop: "mant", name: "mant", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}]); - floatInfo.init("strconv", [{prop: "mantbits", name: "mantbits", embedded: false, exported: false, typ: $Uint, tag: ""}, {prop: "expbits", name: "expbits", embedded: false, exported: false, typ: $Uint, tag: ""}, {prop: "bias", name: "bias", embedded: false, exported: false, typ: $Int, tag: ""}]); - decimalSlice.init("strconv", [{prop: "d", name: "d", embedded: false, exported: false, typ: sliceType$6, tag: ""}, {prop: "nd", name: "nd", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bits.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - optimize = true; - powtab = new sliceType([1, 3, 6, 9, 13, 16, 19, 23, 26]); - float64pow10 = new sliceType$1([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 1e+21, 1e+22]); - float32pow10 = new sliceType$2([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10]); - $pkg.ErrRange = errors.New("value out of range"); - $pkg.ErrSyntax = errors.New("invalid syntax"); - leftcheats = new sliceType$3([new leftCheat.ptr(0, ""), new leftCheat.ptr(1, "5"), new leftCheat.ptr(1, "25"), new leftCheat.ptr(1, "125"), new leftCheat.ptr(2, "625"), new leftCheat.ptr(2, "3125"), new leftCheat.ptr(2, "15625"), new leftCheat.ptr(3, "78125"), new leftCheat.ptr(3, "390625"), new leftCheat.ptr(3, "1953125"), new leftCheat.ptr(4, "9765625"), new leftCheat.ptr(4, "48828125"), new leftCheat.ptr(4, "244140625"), new leftCheat.ptr(4, "1220703125"), new leftCheat.ptr(5, "6103515625"), new leftCheat.ptr(5, "30517578125"), new leftCheat.ptr(5, "152587890625"), new leftCheat.ptr(6, "762939453125"), new leftCheat.ptr(6, "3814697265625"), new leftCheat.ptr(6, "19073486328125"), new leftCheat.ptr(7, "95367431640625"), new leftCheat.ptr(7, "476837158203125"), new leftCheat.ptr(7, "2384185791015625"), new leftCheat.ptr(7, "11920928955078125"), new leftCheat.ptr(8, "59604644775390625"), new leftCheat.ptr(8, "298023223876953125"), new leftCheat.ptr(8, "1490116119384765625"), new leftCheat.ptr(9, "7450580596923828125"), new leftCheat.ptr(9, "37252902984619140625"), new leftCheat.ptr(9, "186264514923095703125"), new leftCheat.ptr(10, "931322574615478515625"), new leftCheat.ptr(10, "4656612873077392578125"), new leftCheat.ptr(10, "23283064365386962890625"), new leftCheat.ptr(10, "116415321826934814453125"), new leftCheat.ptr(11, "582076609134674072265625"), new leftCheat.ptr(11, "2910383045673370361328125"), new leftCheat.ptr(11, "14551915228366851806640625"), new leftCheat.ptr(12, "72759576141834259033203125"), new leftCheat.ptr(12, "363797880709171295166015625"), new leftCheat.ptr(12, "1818989403545856475830078125"), new leftCheat.ptr(13, "9094947017729282379150390625"), new leftCheat.ptr(13, "45474735088646411895751953125"), new leftCheat.ptr(13, "227373675443232059478759765625"), new leftCheat.ptr(13, "1136868377216160297393798828125"), new leftCheat.ptr(14, "5684341886080801486968994140625"), new leftCheat.ptr(14, "28421709430404007434844970703125"), new leftCheat.ptr(14, "142108547152020037174224853515625"), new leftCheat.ptr(15, "710542735760100185871124267578125"), new leftCheat.ptr(15, "3552713678800500929355621337890625"), new leftCheat.ptr(15, "17763568394002504646778106689453125"), new leftCheat.ptr(16, "88817841970012523233890533447265625"), new leftCheat.ptr(16, "444089209850062616169452667236328125"), new leftCheat.ptr(16, "2220446049250313080847263336181640625"), new leftCheat.ptr(16, "11102230246251565404236316680908203125"), new leftCheat.ptr(17, "55511151231257827021181583404541015625"), new leftCheat.ptr(17, "277555756156289135105907917022705078125"), new leftCheat.ptr(17, "1387778780781445675529539585113525390625"), new leftCheat.ptr(18, "6938893903907228377647697925567626953125"), new leftCheat.ptr(18, "34694469519536141888238489627838134765625"), new leftCheat.ptr(18, "173472347597680709441192448139190673828125"), new leftCheat.ptr(19, "867361737988403547205962240695953369140625")]); - smallPowersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(2147483648, 0), -63, false), new extFloat.ptr(new $Uint64(2684354560, 0), -60, false), new extFloat.ptr(new $Uint64(3355443200, 0), -57, false), new extFloat.ptr(new $Uint64(4194304000, 0), -54, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3276800000, 0), -47, false), new extFloat.ptr(new $Uint64(4096000000, 0), -44, false), new extFloat.ptr(new $Uint64(2560000000, 0), -40, false)]); - powersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(4203730336, 136053384), -1220, false), new extFloat.ptr(new $Uint64(3132023167, 2722021238), -1193, false), new extFloat.ptr(new $Uint64(2333539104, 810921078), -1166, false), new extFloat.ptr(new $Uint64(3477244234, 1573795306), -1140, false), new extFloat.ptr(new $Uint64(2590748842, 1432697645), -1113, false), new extFloat.ptr(new $Uint64(3860516611, 1025131999), -1087, false), new extFloat.ptr(new $Uint64(2876309015, 3348809418), -1060, false), new extFloat.ptr(new $Uint64(4286034428, 3200048207), -1034, false), new extFloat.ptr(new $Uint64(3193344495, 1097586188), -1007, false), new extFloat.ptr(new $Uint64(2379227053, 2424306748), -980, false), new extFloat.ptr(new $Uint64(3545324584, 827693699), -954, false), new extFloat.ptr(new $Uint64(2641472655, 2913388981), -927, false), new extFloat.ptr(new $Uint64(3936100983, 602835915), -901, false), new extFloat.ptr(new $Uint64(2932623761, 1081627501), -874, false), new extFloat.ptr(new $Uint64(2184974969, 1572261463), -847, false), new extFloat.ptr(new $Uint64(3255866422, 1308317239), -821, false), new extFloat.ptr(new $Uint64(2425809519, 944281679), -794, false), new extFloat.ptr(new $Uint64(3614737867, 629291719), -768, false), new extFloat.ptr(new $Uint64(2693189581, 2545915892), -741, false), new extFloat.ptr(new $Uint64(4013165208, 388672741), -715, false), new extFloat.ptr(new $Uint64(2990041083, 708162190), -688, false), new extFloat.ptr(new $Uint64(2227754207, 3536207675), -661, false), new extFloat.ptr(new $Uint64(3319612455, 450088378), -635, false), new extFloat.ptr(new $Uint64(2473304014, 3139815830), -608, false), new extFloat.ptr(new $Uint64(3685510180, 2103616900), -582, false), new extFloat.ptr(new $Uint64(2745919064, 224385782), -555, false), new extFloat.ptr(new $Uint64(4091738259, 3737383206), -529, false), new extFloat.ptr(new $Uint64(3048582568, 2868871352), -502, false), new extFloat.ptr(new $Uint64(2271371013, 1820084875), -475, false), new extFloat.ptr(new $Uint64(3384606560, 885076051), -449, false), new extFloat.ptr(new $Uint64(2521728396, 2444895829), -422, false), new extFloat.ptr(new $Uint64(3757668132, 1881767613), -396, false), new extFloat.ptr(new $Uint64(2799680927, 3102062735), -369, false), new extFloat.ptr(new $Uint64(4171849679, 2289335700), -343, false), new extFloat.ptr(new $Uint64(3108270227, 2410191823), -316, false), new extFloat.ptr(new $Uint64(2315841784, 3205436779), -289, false), new extFloat.ptr(new $Uint64(3450873173, 1697722806), -263, false), new extFloat.ptr(new $Uint64(2571100870, 3497754540), -236, false), new extFloat.ptr(new $Uint64(3831238852, 707476230), -210, false), new extFloat.ptr(new $Uint64(2854495385, 1769181907), -183, false), new extFloat.ptr(new $Uint64(4253529586, 2197867022), -157, false), new extFloat.ptr(new $Uint64(3169126500, 2450594539), -130, false), new extFloat.ptr(new $Uint64(2361183241, 1867548876), -103, false), new extFloat.ptr(new $Uint64(3518437208, 3793315116), -77, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3906250000, 0), -24, false), new extFloat.ptr(new $Uint64(2910383045, 2892103680), 3, false), new extFloat.ptr(new $Uint64(2168404344, 4170451332), 30, false), new extFloat.ptr(new $Uint64(3231174267, 3372684723), 56, false), new extFloat.ptr(new $Uint64(2407412430, 2078956656), 83, false), new extFloat.ptr(new $Uint64(3587324068, 2884206696), 109, false), new extFloat.ptr(new $Uint64(2672764710, 395977285), 136, false), new extFloat.ptr(new $Uint64(3982729777, 3569679143), 162, false), new extFloat.ptr(new $Uint64(2967364920, 2361961896), 189, false), new extFloat.ptr(new $Uint64(2210859150, 447440347), 216, false), new extFloat.ptr(new $Uint64(3294436857, 1114709402), 242, false), new extFloat.ptr(new $Uint64(2454546732, 2786846552), 269, false), new extFloat.ptr(new $Uint64(3657559652, 443583978), 295, false), new extFloat.ptr(new $Uint64(2725094297, 2599384906), 322, false), new extFloat.ptr(new $Uint64(4060706939, 3028118405), 348, false), new extFloat.ptr(new $Uint64(3025462433, 2044532855), 375, false), new extFloat.ptr(new $Uint64(2254145170, 1536935362), 402, false), new extFloat.ptr(new $Uint64(3358938053, 3365297469), 428, false), new extFloat.ptr(new $Uint64(2502603868, 4204241075), 455, false), new extFloat.ptr(new $Uint64(3729170365, 2577424355), 481, false), new extFloat.ptr(new $Uint64(2778448436, 3677981733), 508, false), new extFloat.ptr(new $Uint64(4140210802, 2744688476), 534, false), new extFloat.ptr(new $Uint64(3084697427, 1424604878), 561, false), new extFloat.ptr(new $Uint64(2298278679, 4062331362), 588, false), new extFloat.ptr(new $Uint64(3424702107, 3546052773), 614, false), new extFloat.ptr(new $Uint64(2551601907, 2065781727), 641, false), new extFloat.ptr(new $Uint64(3802183132, 2535403578), 667, false), new extFloat.ptr(new $Uint64(2832847187, 1558426518), 694, false), new extFloat.ptr(new $Uint64(4221271257, 2762425404), 720, false), new extFloat.ptr(new $Uint64(3145092172, 2812560400), 747, false), new extFloat.ptr(new $Uint64(2343276271, 3057687578), 774, false), new extFloat.ptr(new $Uint64(3491753744, 2790753324), 800, false), new extFloat.ptr(new $Uint64(2601559269, 3918606633), 827, false), new extFloat.ptr(new $Uint64(3876625403, 2711358621), 853, false), new extFloat.ptr(new $Uint64(2888311001, 1648096297), 880, false), new extFloat.ptr(new $Uint64(2151959390, 2057817989), 907, false), new extFloat.ptr(new $Uint64(3206669376, 61660461), 933, false), new extFloat.ptr(new $Uint64(2389154863, 1581580175), 960, false), new extFloat.ptr(new $Uint64(3560118173, 2626467905), 986, false), new extFloat.ptr(new $Uint64(2652494738, 3034782633), 1013, false), new extFloat.ptr(new $Uint64(3952525166, 3135207385), 1039, false), new extFloat.ptr(new $Uint64(2944860731, 2616258155), 1066, false)]); - uint64pow10 = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 10), new $Uint64(0, 100), new $Uint64(0, 1000), new $Uint64(0, 10000), new $Uint64(0, 100000), new $Uint64(0, 1000000), new $Uint64(0, 10000000), new $Uint64(0, 100000000), new $Uint64(0, 1000000000), new $Uint64(2, 1410065408), new $Uint64(23, 1215752192), new $Uint64(232, 3567587328), new $Uint64(2328, 1316134912), new $Uint64(23283, 276447232), new $Uint64(232830, 2764472320), new $Uint64(2328306, 1874919424), new $Uint64(23283064, 1569325056), new $Uint64(232830643, 2808348672), new $Uint64(2328306436, 2313682944)]); - float32info = new floatInfo.ptr(23, 8, -127); - float64info = new floatInfo.ptr(52, 11, -1023); - isPrint16 = new sliceType$4([32, 126, 161, 887, 890, 895, 900, 1366, 1369, 1418, 1421, 1479, 1488, 1514, 1520, 1524, 1542, 1563, 1566, 1805, 1808, 1866, 1869, 1969, 1984, 2042, 2048, 2093, 2096, 2139, 2142, 2154, 2208, 2237, 2260, 2444, 2447, 2448, 2451, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2531, 2534, 2557, 2561, 2570, 2575, 2576, 2579, 2617, 2620, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2654, 2662, 2677, 2689, 2745, 2748, 2765, 2768, 2768, 2784, 2787, 2790, 2801, 2809, 2828, 2831, 2832, 2835, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2915, 2918, 2935, 2946, 2954, 2958, 2965, 2969, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3021, 3024, 3024, 3031, 3031, 3046, 3066, 3072, 3129, 3133, 3149, 3157, 3162, 3168, 3171, 3174, 3183, 3192, 3257, 3260, 3277, 3285, 3286, 3294, 3299, 3302, 3314, 3328, 3407, 3412, 3427, 3430, 3455, 3458, 3478, 3482, 3517, 3520, 3526, 3530, 3530, 3535, 3551, 3558, 3567, 3570, 3572, 3585, 3642, 3647, 3675, 3713, 3716, 3719, 3722, 3725, 3725, 3732, 3751, 3754, 3773, 3776, 3789, 3792, 3801, 3804, 3807, 3840, 3948, 3953, 4058, 4096, 4295, 4301, 4301, 4304, 4685, 4688, 4701, 4704, 4749, 4752, 4789, 4792, 4805, 4808, 4885, 4888, 4954, 4957, 4988, 4992, 5017, 5024, 5109, 5112, 5117, 5120, 5788, 5792, 5880, 5888, 5908, 5920, 5942, 5952, 5971, 5984, 6003, 6016, 6109, 6112, 6121, 6128, 6137, 6144, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6443, 6448, 6459, 6464, 6464, 6468, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6622, 6683, 6686, 6780, 6783, 6793, 6800, 6809, 6816, 6829, 6832, 6846, 6912, 6987, 6992, 7036, 7040, 7155, 7164, 7223, 7227, 7241, 7245, 7304, 7360, 7367, 7376, 7417, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8061, 8064, 8147, 8150, 8175, 8178, 8190, 8208, 8231, 8240, 8286, 8304, 8305, 8308, 8348, 8352, 8383, 8400, 8432, 8448, 8587, 8592, 9254, 9280, 9290, 9312, 11123, 11126, 11157, 11160, 11193, 11197, 11218, 11244, 11247, 11264, 11507, 11513, 11559, 11565, 11565, 11568, 11623, 11631, 11632, 11647, 11670, 11680, 11849, 11904, 12019, 12032, 12245, 12272, 12283, 12289, 12438, 12441, 12543, 12549, 12590, 12593, 12730, 12736, 12771, 12784, 19893, 19904, 40938, 40960, 42124, 42128, 42182, 42192, 42539, 42560, 42743, 42752, 42935, 42999, 43051, 43056, 43065, 43072, 43127, 43136, 43205, 43214, 43225, 43232, 43261, 43264, 43347, 43359, 43388, 43392, 43481, 43486, 43574, 43584, 43597, 43600, 43609, 43612, 43714, 43739, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43877, 43888, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64449, 64467, 64831, 64848, 64911, 64914, 64967, 65008, 65021, 65024, 65049, 65056, 65131, 65136, 65276, 65281, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65504, 65518, 65532, 65533]); - isNotPrint16 = new sliceType$4([173, 907, 909, 930, 1328, 1376, 1416, 1424, 1757, 2111, 2143, 2229, 2274, 2436, 2473, 2481, 2526, 2564, 2601, 2609, 2612, 2615, 2621, 2653, 2692, 2702, 2706, 2729, 2737, 2740, 2758, 2762, 2816, 2820, 2857, 2865, 2868, 2910, 2948, 2961, 2971, 2973, 3017, 3076, 3085, 3089, 3113, 3141, 3145, 3159, 3204, 3213, 3217, 3241, 3252, 3269, 3273, 3295, 3312, 3332, 3341, 3345, 3397, 3401, 3460, 3506, 3516, 3541, 3543, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3770, 3781, 3783, 3912, 3992, 4029, 4045, 4294, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823, 4881, 5760, 5901, 5997, 6001, 6431, 6751, 7674, 8024, 8026, 8028, 8030, 8117, 8133, 8156, 8181, 8335, 11209, 11311, 11359, 11558, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 11743, 11930, 12352, 12687, 12831, 13055, 42927, 43470, 43519, 43815, 43823, 64311, 64317, 64319, 64322, 64325, 65107, 65127, 65141, 65511]); - isPrint32 = new sliceType$5([65536, 65613, 65616, 65629, 65664, 65786, 65792, 65794, 65799, 65843, 65847, 65947, 65952, 65952, 66000, 66045, 66176, 66204, 66208, 66256, 66272, 66299, 66304, 66339, 66349, 66378, 66384, 66426, 66432, 66499, 66504, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66927, 66927, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67640, 67644, 67644, 67647, 67742, 67751, 67759, 67808, 67829, 67835, 67867, 67871, 67897, 67903, 67903, 67968, 68023, 68028, 68047, 68050, 68102, 68108, 68147, 68152, 68154, 68159, 68167, 68176, 68184, 68192, 68255, 68288, 68326, 68331, 68342, 68352, 68405, 68409, 68437, 68440, 68466, 68472, 68497, 68505, 68508, 68521, 68527, 68608, 68680, 68736, 68786, 68800, 68850, 68858, 68863, 69216, 69246, 69632, 69709, 69714, 69743, 69759, 69825, 69840, 69864, 69872, 69881, 69888, 69955, 69968, 70006, 70016, 70093, 70096, 70132, 70144, 70206, 70272, 70313, 70320, 70378, 70384, 70393, 70400, 70412, 70415, 70416, 70419, 70457, 70460, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70749, 70784, 70855, 70864, 70873, 71040, 71093, 71096, 71133, 71168, 71236, 71248, 71257, 71264, 71276, 71296, 71351, 71360, 71369, 71424, 71449, 71453, 71467, 71472, 71487, 71840, 71922, 71935, 71935, 72192, 72263, 72272, 72323, 72326, 72354, 72384, 72440, 72704, 72773, 72784, 72812, 72816, 72847, 72850, 72886, 72960, 73014, 73018, 73031, 73040, 73049, 73728, 74649, 74752, 74868, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92777, 92782, 92783, 92880, 92909, 92912, 92917, 92928, 92997, 93008, 93047, 93053, 93071, 93952, 94020, 94032, 94078, 94095, 94111, 94176, 94177, 94208, 100332, 100352, 101106, 110592, 110878, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113820, 113823, 118784, 119029, 119040, 119078, 119081, 119154, 119163, 119272, 119296, 119365, 119552, 119638, 119648, 119665, 119808, 119967, 119970, 119970, 119973, 119974, 119977, 120074, 120077, 120134, 120138, 120485, 120488, 120779, 120782, 121483, 121499, 121519, 122880, 122904, 122907, 122922, 124928, 125124, 125127, 125142, 125184, 125258, 125264, 125273, 125278, 125279, 126464, 126500, 126503, 126523, 126530, 126530, 126535, 126548, 126551, 126564, 126567, 126619, 126625, 126651, 126704, 126705, 126976, 127019, 127024, 127123, 127136, 127150, 127153, 127221, 127232, 127244, 127248, 127339, 127344, 127404, 127462, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 128724, 128736, 128748, 128752, 128760, 128768, 128883, 128896, 128980, 129024, 129035, 129040, 129095, 129104, 129113, 129120, 129159, 129168, 129197, 129280, 129291, 129296, 129356, 129360, 129387, 129408, 129431, 129472, 129472, 129488, 129510, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]); - isNotPrint32 = new sliceType$4([12, 39, 59, 62, 399, 926, 2057, 2102, 2134, 2291, 2564, 2580, 2584, 4285, 4405, 4576, 4626, 4743, 4745, 4750, 4766, 4868, 4905, 4913, 4916, 5210, 5212, 6813, 7177, 7223, 7336, 7431, 7434, 7483, 7486, 9327, 27231, 27482, 27490, 54357, 54429, 54445, 54458, 54460, 54468, 54534, 54549, 54557, 54586, 54591, 54597, 54609, 55968, 57351, 57378, 57381, 60932, 60960, 60963, 60968, 60979, 60984, 60986, 61000, 61002, 61004, 61008, 61011, 61016, 61018, 61020, 61022, 61024, 61027, 61035, 61043, 61048, 61053, 61055, 61066, 61092, 61098, 61632, 61648, 61743, 63807]); - isGraphic = new sliceType$4([160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["crypto"] = (function() { - var $pkg = {}, $init, hash, io, strconv, funcType, sliceType$1, hashes, RegisterHash; - hash = $packages["hash"]; - io = $packages["io"]; - strconv = $packages["strconv"]; - funcType = $funcType([], [hash.Hash], false); - sliceType$1 = $sliceType(funcType); - RegisterHash = function(h, f) { - var f, h; - if (h >= 20) { - $panic(new $String("crypto: RegisterHash of unknown hash function")); - } - ((h < 0 || h >= hashes.$length) ? ($throwRuntimeError("index out of range"), undefined) : hashes.$array[hashes.$offset + h] = f); - }; - $pkg.RegisterHash = RegisterHash; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = hash.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - hashes = $makeSlice(sliceType$1, 20); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["crypto/sha256"] = (function() { - var $pkg = {}, $init, crypto, errors, hash, digest, sliceType, sliceType$1, arrayType, arrayType$1, arrayType$2, arrayType$3, arrayType$4, arrayType$6, ptrType, _K, block, init, putUint32, putUint64, appendUint64, appendUint32, consumeUint64, consumeUint32, New, New224, Sum256, blockGeneric; - crypto = $packages["crypto"]; - errors = $packages["errors"]; - hash = $packages["hash"]; - digest = $pkg.digest = $newType(0, $kindStruct, "sha256.digest", true, "crypto/sha256", false, function(h_, x_, nx_, len_, is224_) { - this.$val = this; - if (arguments.length === 0) { - this.h = arrayType$2.zero(); - this.x = arrayType$3.zero(); - this.nx = 0; - this.len = new $Uint64(0, 0); - this.is224 = false; - return; - } - this.h = h_; - this.x = x_; - this.nx = nx_; - this.len = len_; - this.is224 = is224_; - }); - sliceType = $sliceType($Uint32); - sliceType$1 = $sliceType($Uint8); - arrayType = $arrayType($Uint8, 8); - arrayType$1 = $arrayType($Uint8, 4); - arrayType$2 = $arrayType($Uint32, 8); - arrayType$3 = $arrayType($Uint8, 64); - arrayType$4 = $arrayType($Uint8, 32); - arrayType$6 = $arrayType($Uint32, 64); - ptrType = $ptrType(digest); - init = function() { - crypto.RegisterHash(4, New224); - crypto.RegisterHash(5, New); - }; - digest.ptr.prototype.MarshalBinary = function() { - var b, d; - d = this; - b = $makeSlice(sliceType$1, 0, 108); - if (d.is224) { - b = $appendSlice(b, "sha\x02"); - } else { - b = $appendSlice(b, "sha\x03"); - } - b = appendUint32(b, d.h[0]); - b = appendUint32(b, d.h[1]); - b = appendUint32(b, d.h[2]); - b = appendUint32(b, d.h[3]); - b = appendUint32(b, d.h[4]); - b = appendUint32(b, d.h[5]); - b = appendUint32(b, d.h[6]); - b = appendUint32(b, d.h[7]); - b = $appendSlice(b, $subslice(new sliceType$1(d.x), 0, d.nx)); - b = $subslice(b, 0, ((b.$length + 64 >> 0) - (d.nx) >> 0)); - b = appendUint64(b, d.len); - return [b, $ifaceNil]; - }; - digest.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); }; - digest.ptr.prototype.UnmarshalBinary = function(b) { - var _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, b, d; - d = this; - if (b.$length < 4 || (d.is224 && !(($bytesToString($subslice(b, 0, 4))) === "sha\x02")) || (!d.is224 && !(($bytesToString($subslice(b, 0, 4))) === "sha\x03"))) { - return errors.New("crypto/sha256: invalid hash state identifier"); - } - if (!((b.$length === 108))) { - return errors.New("crypto/sha256: invalid hash state size"); - } - b = $subslice(b, 4); - _tuple = consumeUint32(b); - b = _tuple[0]; - d.h[0] = _tuple[1]; - _tuple$1 = consumeUint32(b); - b = _tuple$1[0]; - d.h[1] = _tuple$1[1]; - _tuple$2 = consumeUint32(b); - b = _tuple$2[0]; - d.h[2] = _tuple$2[1]; - _tuple$3 = consumeUint32(b); - b = _tuple$3[0]; - d.h[3] = _tuple$3[1]; - _tuple$4 = consumeUint32(b); - b = _tuple$4[0]; - d.h[4] = _tuple$4[1]; - _tuple$5 = consumeUint32(b); - b = _tuple$5[0]; - d.h[5] = _tuple$5[1]; - _tuple$6 = consumeUint32(b); - b = _tuple$6[0]; - d.h[6] = _tuple$6[1]; - _tuple$7 = consumeUint32(b); - b = _tuple$7[0]; - d.h[7] = _tuple$7[1]; - b = $subslice(b, $copySlice(new sliceType$1(d.x), b)); - _tuple$8 = consumeUint64(b); - b = _tuple$8[0]; - d.len = _tuple$8[1]; - d.nx = (($div64(d.len, new $Uint64(0, 64), true).$low >> 0)); - return $ifaceNil; - }; - digest.prototype.UnmarshalBinary = function(b) { return this.$val.UnmarshalBinary(b); }; - putUint32 = function(x, s) { - var s, x; - $unused((3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3])); - (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = (((s >>> 24 >>> 0) << 24 >>> 24))); - (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1] = (((s >>> 16 >>> 0) << 24 >>> 24))); - (2 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 2] = (((s >>> 8 >>> 0) << 24 >>> 24))); - (3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3] = ((s << 24 >>> 24))); - }; - putUint64 = function(x, s) { - var s, x; - $unused((7 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 7])); - (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = (($shiftRightUint64(s, 56).$low << 24 >>> 24))); - (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1] = (($shiftRightUint64(s, 48).$low << 24 >>> 24))); - (2 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 2] = (($shiftRightUint64(s, 40).$low << 24 >>> 24))); - (3 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 3] = (($shiftRightUint64(s, 32).$low << 24 >>> 24))); - (4 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 4] = (($shiftRightUint64(s, 24).$low << 24 >>> 24))); - (5 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 5] = (($shiftRightUint64(s, 16).$low << 24 >>> 24))); - (6 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 6] = (($shiftRightUint64(s, 8).$low << 24 >>> 24))); - (7 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 7] = ((s.$low << 24 >>> 24))); - }; - appendUint64 = function(b, x) { - var a, b, x; - a = arrayType.zero(); - putUint64(new sliceType$1(a), x); - return $appendSlice(b, new sliceType$1(a)); - }; - appendUint32 = function(b, x) { - var a, b, x; - a = arrayType$1.zero(); - putUint32(new sliceType$1(a), x); - return $appendSlice(b, new sliceType$1(a)); - }; - consumeUint64 = function(b) { - var b, x, x$1, x$10, x$11, x$12, x$13, x$14, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - x$14 = (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$7 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); - return [$subslice(b, 8), x$14]; - }; - consumeUint32 = function(b) { - var b, x; - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - x = ((((((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) << 24 >>> 0)) >>> 0; - return [$subslice(b, 4), x]; - }; - digest.ptr.prototype.Reset = function() { - var d; - d = this; - if (!d.is224) { - d.h[0] = 1779033703; - d.h[1] = 3144134277; - d.h[2] = 1013904242; - d.h[3] = 2773480762; - d.h[4] = 1359893119; - d.h[5] = 2600822924; - d.h[6] = 528734635; - d.h[7] = 1541459225; - } else { - d.h[0] = 3238371032; - d.h[1] = 914150663; - d.h[2] = 812702999; - d.h[3] = 4144912697; - d.h[4] = 4290775857; - d.h[5] = 1750603025; - d.h[6] = 1694076839; - d.h[7] = 3204075428; - } - d.nx = 0; - d.len = new $Uint64(0, 0); - }; - digest.prototype.Reset = function() { return this.$val.Reset(); }; - New = function() { - var d; - d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); - d.Reset(); - return d; - }; - $pkg.New = New; - New224 = function() { - var d; - d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); - d.is224 = true; - d.Reset(); - return d; - }; - $pkg.New224 = New224; - digest.ptr.prototype.Size = function() { - var d; - d = this; - if (!d.is224) { - return 32; - } - return 28; - }; - digest.prototype.Size = function() { return this.$val.Size(); }; - digest.ptr.prototype.BlockSize = function() { - var d; - d = this; - return 64; - }; - digest.prototype.BlockSize = function() { return this.$val.BlockSize(); }; - digest.ptr.prototype.Write = function(p) { - var d, err, n, n$1, nn, p, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; d = $f.d; err = $f.err; n = $f.n; n$1 = $f.n$1; nn = $f.nn; p = $f.p; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - nn = 0; - err = $ifaceNil; - d = this; - nn = p.$length; - d.len = (x = d.len, x$1 = (new $Uint64(0, nn)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); - /* */ if (d.nx > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (d.nx > 0) { */ case 1: - n = $copySlice($subslice(new sliceType$1(d.x), d.nx), p); - d.nx = d.nx + (n) >> 0; - /* */ if (d.nx === 64) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (d.nx === 64) { */ case 3: - $r = block(d, new sliceType$1(d.x)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - d.nx = 0; - /* } */ case 4: - p = $subslice(p, n); - /* } */ case 2: - /* */ if (p.$length >= 64) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (p.$length >= 64) { */ case 6: - n$1 = (p.$length & ~63) >> 0; - $r = block(d, $subslice(p, 0, n$1)); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - p = $subslice(p, n$1); - /* } */ case 7: - if (p.$length > 0) { - d.nx = $copySlice(new sliceType$1(d.x), p); - } - $s = -1; return [nn, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.Write }; } $f.d = d; $f.err = err; $f.n = n; $f.n$1 = n$1; $f.nn = nn; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - digest.prototype.Write = function(p) { return this.$val.Write(p); }; - digest.ptr.prototype.Sum = function(in$1) { - var _r, d, d0, hash$1, in$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; d = $f.d; d0 = $f.d0; hash$1 = $f.hash$1; in$1 = $f.in$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - d = this; - d0 = $clone(d, digest); - _r = d0.checkSum(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - hash$1 = $clone(_r, arrayType$4); - if (d0.is224) { - $s = -1; return $appendSlice(in$1, $subslice(new sliceType$1(hash$1), 0, 28)); - } - $s = -1; return $appendSlice(in$1, new sliceType$1(hash$1)); - /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.Sum }; } $f._r = _r; $f.d = d; $f.d0 = d0; $f.hash$1 = hash$1; $f.in$1 = in$1; $f.$s = $s; $f.$r = $r; return $f; - }; - digest.prototype.Sum = function(in$1) { return this.$val.Sum(in$1); }; - digest.ptr.prototype.checkSum = function() { - var _r, _r$1, _r$2, d, digest$1, len, tmp, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; d = $f.d; digest$1 = $f.digest$1; len = $f.len; tmp = $f.tmp; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - d = this; - len = d.len; - tmp = arrayType$3.zero(); - tmp[0] = 128; - /* */ if ((x = $div64(len, new $Uint64(0, 64), true), (x.$high < 0 || (x.$high === 0 && x.$low < 56)))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((x = $div64(len, new $Uint64(0, 64), true), (x.$high < 0 || (x.$high === 0 && x.$low < 56)))) { */ case 1: - _r = d.Write($subslice(new sliceType$1(tmp), 0, $flatten64((x$1 = $div64(len, new $Uint64(0, 64), true), new $Uint64(0 - x$1.$high, 56 - x$1.$low))))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - $s = 3; continue; - /* } else { */ case 2: - _r$1 = d.Write($subslice(new sliceType$1(tmp), 0, $flatten64((x$2 = $div64(len, new $Uint64(0, 64), true), new $Uint64(0 - x$2.$high, 120 - x$2.$low))))); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - /* } */ case 3: - len = $shiftLeft64(len, (3)); - putUint64(new sliceType$1(tmp), len); - _r$2 = d.Write($subslice(new sliceType$1(tmp), 0, 8)); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - if (!((d.nx === 0))) { - $panic(new $String("d.nx != 0")); - } - digest$1 = arrayType$4.zero(); - putUint32($subslice(new sliceType$1(digest$1), 0), d.h[0]); - putUint32($subslice(new sliceType$1(digest$1), 4), d.h[1]); - putUint32($subslice(new sliceType$1(digest$1), 8), d.h[2]); - putUint32($subslice(new sliceType$1(digest$1), 12), d.h[3]); - putUint32($subslice(new sliceType$1(digest$1), 16), d.h[4]); - putUint32($subslice(new sliceType$1(digest$1), 20), d.h[5]); - putUint32($subslice(new sliceType$1(digest$1), 24), d.h[6]); - if (!d.is224) { - putUint32($subslice(new sliceType$1(digest$1), 28), d.h[7]); - } - $s = -1; return digest$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: digest.ptr.prototype.checkSum }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.d = d; $f.digest$1 = digest$1; $f.len = len; $f.tmp = tmp; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - digest.prototype.checkSum = function() { return this.$val.checkSum(); }; - Sum256 = function(data) { - var _r, _r$1, d, data, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; d = $f.d; data = $f.data; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - d = new digest.ptr(arrayType$2.zero(), arrayType$3.zero(), 0, new $Uint64(0, 0), false); - d.Reset(); - _r = d.Write(data); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - _r$1 = d.checkSum(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sum256 }; } $f._r = _r; $f._r$1 = _r$1; $f.d = d; $f.data = data; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sum256 = Sum256; - blockGeneric = function(dig, p) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, a, b, c, d, dig, e, f, g, h, h0, h1, h2, h3, h4, h5, h6, h7, i, i$1, i$2, j, p, t1, t1$1, t2, t2$1, v1, v2, w, x, x$1, x$2, x$3, x$4, x$5, x$6; - w = arrayType$6.zero(); - _tmp = dig.h[0]; - _tmp$1 = dig.h[1]; - _tmp$2 = dig.h[2]; - _tmp$3 = dig.h[3]; - _tmp$4 = dig.h[4]; - _tmp$5 = dig.h[5]; - _tmp$6 = dig.h[6]; - _tmp$7 = dig.h[7]; - h0 = _tmp; - h1 = _tmp$1; - h2 = _tmp$2; - h3 = _tmp$3; - h4 = _tmp$4; - h5 = _tmp$5; - h6 = _tmp$6; - h7 = _tmp$7; - while (true) { - if (!(p.$length >= 64)) { break; } - i = 0; - while (true) { - if (!(i < 16)) { break; } - j = $imul(i, 4); - ((i < 0 || i >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i] = (((((((((((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]) >>> 0)) << 24 >>> 0) | ((((x = j + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])) >>> 0)) << 16 >>> 0)) >>> 0) | ((((x$1 = j + 2 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])) >>> 0)) << 8 >>> 0)) >>> 0) | (((x$2 = j + 3 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2])) >>> 0))) >>> 0)); - i = i + (1) >> 0; - } - i$1 = 16; - while (true) { - if (!(i$1 < 64)) { break; } - v1 = (x$3 = i$1 - 2 >> 0, ((x$3 < 0 || x$3 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$3])); - t1 = (((((((v1 >>> 17 >>> 0) | (v1 << 15 >>> 0)) >>> 0)) ^ ((((v1 >>> 19 >>> 0) | (v1 << 13 >>> 0)) >>> 0))) >>> 0) ^ ((v1 >>> 10 >>> 0))) >>> 0; - v2 = (x$4 = i$1 - 15 >> 0, ((x$4 < 0 || x$4 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$4])); - t2 = (((((((v2 >>> 7 >>> 0) | (v2 << 25 >>> 0)) >>> 0)) ^ ((((v2 >>> 18 >>> 0) | (v2 << 14 >>> 0)) >>> 0))) >>> 0) ^ ((v2 >>> 3 >>> 0))) >>> 0; - ((i$1 < 0 || i$1 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i$1] = (((t1 + (x$5 = i$1 - 7 >> 0, ((x$5 < 0 || x$5 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$5])) >>> 0) + t2 >>> 0) + (x$6 = i$1 - 16 >> 0, ((x$6 < 0 || x$6 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[x$6])) >>> 0)); - i$1 = i$1 + (1) >> 0; - } - _tmp$8 = h0; - _tmp$9 = h1; - _tmp$10 = h2; - _tmp$11 = h3; - _tmp$12 = h4; - _tmp$13 = h5; - _tmp$14 = h6; - _tmp$15 = h7; - a = _tmp$8; - b = _tmp$9; - c = _tmp$10; - d = _tmp$11; - e = _tmp$12; - f = _tmp$13; - g = _tmp$14; - h = _tmp$15; - i$2 = 0; - while (true) { - if (!(i$2 < 64)) { break; } - t1$1 = (((h + (((((((((e >>> 6 >>> 0) | (e << 26 >>> 0)) >>> 0)) ^ ((((e >>> 11 >>> 0) | (e << 21 >>> 0)) >>> 0))) >>> 0) ^ ((((e >>> 25 >>> 0) | (e << 7 >>> 0)) >>> 0))) >>> 0)) >>> 0) + ((((((e & f) >>> 0)) ^ ((((~e >>> 0) & g) >>> 0))) >>> 0)) >>> 0) + ((i$2 < 0 || i$2 >= _K.$length) ? ($throwRuntimeError("index out of range"), undefined) : _K.$array[_K.$offset + i$2]) >>> 0) + ((i$2 < 0 || i$2 >= w.length) ? ($throwRuntimeError("index out of range"), undefined) : w[i$2]) >>> 0; - t2$1 = (((((((((a >>> 2 >>> 0) | (a << 30 >>> 0)) >>> 0)) ^ ((((a >>> 13 >>> 0) | (a << 19 >>> 0)) >>> 0))) >>> 0) ^ ((((a >>> 22 >>> 0) | (a << 10 >>> 0)) >>> 0))) >>> 0)) + ((((((((a & b) >>> 0)) ^ (((a & c) >>> 0))) >>> 0) ^ (((b & c) >>> 0))) >>> 0)) >>> 0; - h = g; - g = f; - f = e; - e = d + t1$1 >>> 0; - d = c; - c = b; - b = a; - a = t1$1 + t2$1 >>> 0; - i$2 = i$2 + (1) >> 0; - } - h0 = h0 + (a) >>> 0; - h1 = h1 + (b) >>> 0; - h2 = h2 + (c) >>> 0; - h3 = h3 + (d) >>> 0; - h4 = h4 + (e) >>> 0; - h5 = h5 + (f) >>> 0; - h6 = h6 + (g) >>> 0; - h7 = h7 + (h) >>> 0; - p = $subslice(p, 64); - } - _tmp$16 = h0; - _tmp$17 = h1; - _tmp$18 = h2; - _tmp$19 = h3; - _tmp$20 = h4; - _tmp$21 = h5; - _tmp$22 = h6; - _tmp$23 = h7; - dig.h[0] = _tmp$16; - dig.h[1] = _tmp$17; - dig.h[2] = _tmp$18; - dig.h[3] = _tmp$19; - dig.h[4] = _tmp$20; - dig.h[5] = _tmp$21; - dig.h[6] = _tmp$22; - dig.h[7] = _tmp$23; - }; - ptrType.methods = [{prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "BlockSize", name: "BlockSize", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "Sum", name: "Sum", pkg: "", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "checkSum", name: "checkSum", pkg: "crypto/sha256", typ: $funcType([], [arrayType$4], false)}]; - digest.init("crypto/sha256", [{prop: "h", name: "h", embedded: false, exported: false, typ: arrayType$2, tag: ""}, {prop: "x", name: "x", embedded: false, exported: false, typ: arrayType$3, tag: ""}, {prop: "nx", name: "nx", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "is224", name: "is224", embedded: false, exported: false, typ: $Bool, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = crypto.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = hash.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _K = new sliceType([1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298]); - block = blockGeneric; - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["unicode"] = (function() { - var $pkg = {}, $init, RangeTable, Range16, Range32, CaseRange, d, foldPair, arrayType, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, sliceType$4, _C, _Cc, _Cf, _Co, _Cs, _L, _Ll, _Lm, _Lo, _Lt, _Lu, _M, _Mc, _Me, _Mn, _N, _Nd, _Nl, _No, _P, _Pc, _Pd, _Pe, _Pf, _Pi, _Po, _Ps, _S, _Sc, _Sk, _Sm, _So, _Z, _Zl, _Zp, _Zs, _Adlam, _Ahom, _Anatolian_Hieroglyphs, _Arabic, _Armenian, _Avestan, _Balinese, _Bamum, _Bassa_Vah, _Batak, _Bengali, _Bhaiksuki, _Bopomofo, _Brahmi, _Braille, _Buginese, _Buhid, _Canadian_Aboriginal, _Carian, _Caucasian_Albanian, _Chakma, _Cham, _Cherokee, _Common, _Coptic, _Cuneiform, _Cypriot, _Cyrillic, _Deseret, _Devanagari, _Duployan, _Egyptian_Hieroglyphs, _Elbasan, _Ethiopic, _Georgian, _Glagolitic, _Gothic, _Grantha, _Greek, _Gujarati, _Gurmukhi, _Han, _Hangul, _Hanunoo, _Hatran, _Hebrew, _Hiragana, _Imperial_Aramaic, _Inherited, _Inscriptional_Pahlavi, _Inscriptional_Parthian, _Javanese, _Kaithi, _Kannada, _Katakana, _Kayah_Li, _Kharoshthi, _Khmer, _Khojki, _Khudawadi, _Lao, _Latin, _Lepcha, _Limbu, _Linear_A, _Linear_B, _Lisu, _Lycian, _Lydian, _Mahajani, _Malayalam, _Mandaic, _Manichaean, _Marchen, _Masaram_Gondi, _Meetei_Mayek, _Mende_Kikakui, _Meroitic_Cursive, _Meroitic_Hieroglyphs, _Miao, _Modi, _Mongolian, _Mro, _Multani, _Myanmar, _Nabataean, _New_Tai_Lue, _Newa, _Nko, _Nushu, _Ogham, _Ol_Chiki, _Old_Hungarian, _Old_Italic, _Old_North_Arabian, _Old_Permic, _Old_Persian, _Old_South_Arabian, _Old_Turkic, _Oriya, _Osage, _Osmanya, _Pahawh_Hmong, _Palmyrene, _Pau_Cin_Hau, _Phags_Pa, _Phoenician, _Psalter_Pahlavi, _Rejang, _Runic, _Samaritan, _Saurashtra, _Sharada, _Shavian, _Siddham, _SignWriting, _Sinhala, _Sora_Sompeng, _Soyombo, _Sundanese, _Syloti_Nagri, _Syriac, _Tagalog, _Tagbanwa, _Tai_Le, _Tai_Tham, _Tai_Viet, _Takri, _Tamil, _Tangut, _Telugu, _Thaana, _Thai, _Tibetan, _Tifinagh, _Tirhuta, _Ugaritic, _Vai, _Warang_Citi, _Yi, _Zanabazar_Square, _CaseRanges, properties, asciiFold, caseOrbit, foldL, foldLl, foldLt, foldLu, foldM, foldMn, foldCommon, foldGreek, foldInherited, to, IsDigit, IsPrint, In, IsLetter, is16, is32, Is, isExcludingLatin, To, ToUpper, ToLower, SimpleFold; - RangeTable = $pkg.RangeTable = $newType(0, $kindStruct, "unicode.RangeTable", true, "unicode", true, function(R16_, R32_, LatinOffset_) { - this.$val = this; - if (arguments.length === 0) { - this.R16 = sliceType.nil; - this.R32 = sliceType$1.nil; - this.LatinOffset = 0; - return; - } - this.R16 = R16_; - this.R32 = R32_; - this.LatinOffset = LatinOffset_; - }); - Range16 = $pkg.Range16 = $newType(0, $kindStruct, "unicode.Range16", true, "unicode", true, function(Lo_, Hi_, Stride_) { - this.$val = this; - if (arguments.length === 0) { - this.Lo = 0; - this.Hi = 0; - this.Stride = 0; - return; - } - this.Lo = Lo_; - this.Hi = Hi_; - this.Stride = Stride_; - }); - Range32 = $pkg.Range32 = $newType(0, $kindStruct, "unicode.Range32", true, "unicode", true, function(Lo_, Hi_, Stride_) { - this.$val = this; - if (arguments.length === 0) { - this.Lo = 0; - this.Hi = 0; - this.Stride = 0; - return; - } - this.Lo = Lo_; - this.Hi = Hi_; - this.Stride = Stride_; - }); - CaseRange = $pkg.CaseRange = $newType(0, $kindStruct, "unicode.CaseRange", true, "unicode", true, function(Lo_, Hi_, Delta_) { - this.$val = this; - if (arguments.length === 0) { - this.Lo = 0; - this.Hi = 0; - this.Delta = arrayType.zero(); - return; - } - this.Lo = Lo_; - this.Hi = Hi_; - this.Delta = Delta_; - }); - d = $pkg.d = $newType(12, $kindArray, "unicode.d", true, "unicode", false, null); - foldPair = $pkg.foldPair = $newType(0, $kindStruct, "unicode.foldPair", true, "unicode", false, function(From_, To_) { - this.$val = this; - if (arguments.length === 0) { - this.From = 0; - this.To = 0; - return; - } - this.From = From_; - this.To = To_; - }); - arrayType = $arrayType($Int32, 3); - sliceType = $sliceType(Range16); - sliceType$1 = $sliceType(Range32); - ptrType = $ptrType(RangeTable); - sliceType$2 = $sliceType(ptrType); - sliceType$3 = $sliceType(CaseRange); - sliceType$4 = $sliceType(foldPair); - to = function(_case, r, caseRange) { - var _case, _q, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, caseRange, cr, delta, foundMapping, hi, lo, m, mappedRune, r, x; - mappedRune = 0; - foundMapping = false; - if (_case < 0 || 3 <= _case) { - _tmp = 65533; - _tmp$1 = false; - mappedRune = _tmp; - foundMapping = _tmp$1; - return [mappedRune, foundMapping]; - } - lo = 0; - hi = caseRange.$length; - while (true) { - if (!(lo < hi)) { break; } - m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - cr = ((m < 0 || m >= caseRange.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseRange.$array[caseRange.$offset + m]); - if (((cr.Lo >> 0)) <= r && r <= ((cr.Hi >> 0))) { - delta = ((x = cr.Delta, ((_case < 0 || _case >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[_case]))); - if (delta > 1114111) { - _tmp$2 = ((cr.Lo >> 0)) + ((((((r - ((cr.Lo >> 0)) >> 0)) & ~1) >> 0) | (((_case & 1) >> 0)))) >> 0; - _tmp$3 = true; - mappedRune = _tmp$2; - foundMapping = _tmp$3; - return [mappedRune, foundMapping]; - } - _tmp$4 = r + delta >> 0; - _tmp$5 = true; - mappedRune = _tmp$4; - foundMapping = _tmp$5; - return [mappedRune, foundMapping]; - } - if (r < ((cr.Lo >> 0))) { - hi = m; - } else { - lo = m + 1 >> 0; - } - } - _tmp$6 = r; - _tmp$7 = false; - mappedRune = _tmp$6; - foundMapping = _tmp$7; - return [mappedRune, foundMapping]; - }; - IsDigit = function(r) { - var r; - if (r <= 255) { - return 48 <= r && r <= 57; - } - return isExcludingLatin($pkg.Digit, r); - }; - $pkg.IsDigit = IsDigit; - IsPrint = function(r) { - var r, x; - if (((r >>> 0)) <= 255) { - return !(((((x = ((r << 24 >>> 24)), ((x < 0 || x >= properties.length) ? ($throwRuntimeError("index out of range"), undefined) : properties[x])) & 128) >>> 0) === 0)); - } - return In(r, $pkg.PrintRanges); - }; - $pkg.IsPrint = IsPrint; - In = function(r, ranges) { - var _i, _ref, inside, r, ranges; - _ref = ranges; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - inside = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (Is(inside, r)) { - return true; - } - _i++; - } - return false; - }; - $pkg.In = In; - IsLetter = function(r) { - var r, x; - if (((r >>> 0)) <= 255) { - return !(((((x = ((r << 24 >>> 24)), ((x < 0 || x >= properties.length) ? ($throwRuntimeError("index out of range"), undefined) : properties[x])) & 96) >>> 0) === 0)); - } - return isExcludingLatin($pkg.Letter, r); - }; - $pkg.IsLetter = IsLetter; - is16 = function(ranges, r) { - var _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges; - if (ranges.$length <= 18 || r <= 255) { - _ref = ranges; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - range_ = ((i < 0 || i >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + i]); - if (r < range_.Lo) { - return false; - } - if (r <= range_.Hi) { - return (range_.Stride === 1) || ((_r = ((r - range_.Lo << 16 >>> 16)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0); - } - _i++; - } - return false; - } - lo = 0; - hi = ranges.$length; - while (true) { - if (!(lo < hi)) { break; } - m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - range_$1 = ((m < 0 || m >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + m]); - if (range_$1.Lo <= r && r <= range_$1.Hi) { - return (range_$1.Stride === 1) || ((_r$1 = ((r - range_$1.Lo << 16 >>> 16)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0); - } - if (r < range_$1.Lo) { - hi = m; - } else { - lo = m + 1 >> 0; - } - } - return false; - }; - is32 = function(ranges, r) { - var _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges; - if (ranges.$length <= 18) { - _ref = ranges; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - range_ = ((i < 0 || i >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + i]); - if (r < range_.Lo) { - return false; - } - if (r <= range_.Hi) { - return (range_.Stride === 1) || ((_r = ((r - range_.Lo >>> 0)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0); - } - _i++; - } - return false; - } - lo = 0; - hi = ranges.$length; - while (true) { - if (!(lo < hi)) { break; } - m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - range_$1 = $clone(((m < 0 || m >= ranges.$length) ? ($throwRuntimeError("index out of range"), undefined) : ranges.$array[ranges.$offset + m]), Range32); - if (range_$1.Lo <= r && r <= range_$1.Hi) { - return (range_$1.Stride === 1) || ((_r$1 = ((r - range_$1.Lo >>> 0)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0); - } - if (r < range_$1.Lo) { - hi = m; - } else { - lo = m + 1 >> 0; - } - } - return false; - }; - Is = function(rangeTab, r) { - var r, r16, r32, rangeTab, x; - r16 = rangeTab.R16; - if (r16.$length > 0 && r <= (((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? ($throwRuntimeError("index out of range"), undefined) : r16.$array[r16.$offset + x])).Hi >> 0))) { - return is16(r16, ((r << 16 >>> 16))); - } - r32 = rangeTab.R32; - if (r32.$length > 0 && r >= (((0 >= r32.$length ? ($throwRuntimeError("index out of range"), undefined) : r32.$array[r32.$offset + 0]).Lo >> 0))) { - return is32(r32, ((r >>> 0))); - } - return false; - }; - $pkg.Is = Is; - isExcludingLatin = function(rangeTab, r) { - var off, r, r16, r32, rangeTab, x; - r16 = rangeTab.R16; - off = rangeTab.LatinOffset; - if (r16.$length > off && r <= (((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? ($throwRuntimeError("index out of range"), undefined) : r16.$array[r16.$offset + x])).Hi >> 0))) { - return is16($subslice(r16, off), ((r << 16 >>> 16))); - } - r32 = rangeTab.R32; - if (r32.$length > 0 && r >= (((0 >= r32.$length ? ($throwRuntimeError("index out of range"), undefined) : r32.$array[r32.$offset + 0]).Lo >> 0))) { - return is32(r32, ((r >>> 0))); - } - return false; - }; - To = function(_case, r) { - var _case, _tuple, r; - _tuple = to(_case, r, $pkg.CaseRanges); - r = _tuple[0]; - return r; - }; - $pkg.To = To; - ToUpper = function(r) { - var r; - if (r <= 127) { - if (97 <= r && r <= 122) { - r = r - (32) >> 0; - } - return r; - } - return To(0, r); - }; - $pkg.ToUpper = ToUpper; - ToLower = function(r) { - var r; - if (r <= 127) { - if (65 <= r && r <= 90) { - r = r + (32) >> 0; - } - return r; - } - return To(1, r); - }; - $pkg.ToLower = ToLower; - SimpleFold = function(r) { - var _q, hi, l, lo, m, r; - if (r < 0 || r > 1114111) { - return r; - } - if (((r >> 0)) < 128) { - return ((((r < 0 || r >= asciiFold.length) ? ($throwRuntimeError("index out of range"), undefined) : asciiFold[r]) >> 0)); - } - lo = 0; - hi = caseOrbit.$length; - while (true) { - if (!(lo < hi)) { break; } - m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - if (((((m < 0 || m >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + m]).From >> 0)) < r) { - lo = m + 1 >> 0; - } else { - hi = m; - } - } - if (lo < caseOrbit.$length && (((((lo < 0 || lo >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + lo]).From >> 0)) === r)) { - return ((((lo < 0 || lo >= caseOrbit.$length) ? ($throwRuntimeError("index out of range"), undefined) : caseOrbit.$array[caseOrbit.$offset + lo]).To >> 0)); - } - l = ToLower(r); - if (!((l === r))) { - return l; - } - return ToUpper(r); - }; - $pkg.SimpleFold = SimpleFold; - RangeTable.init("", [{prop: "R16", name: "R16", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "R32", name: "R32", embedded: false, exported: true, typ: sliceType$1, tag: ""}, {prop: "LatinOffset", name: "LatinOffset", embedded: false, exported: true, typ: $Int, tag: ""}]); - Range16.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Stride", name: "Stride", embedded: false, exported: true, typ: $Uint16, tag: ""}]); - Range32.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Stride", name: "Stride", embedded: false, exported: true, typ: $Uint32, tag: ""}]); - CaseRange.init("", [{prop: "Lo", name: "Lo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Delta", name: "Delta", embedded: false, exported: true, typ: d, tag: ""}]); - d.init($Int32, 3); - foldPair.init("", [{prop: "From", name: "From", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "To", name: "To", embedded: false, exported: true, typ: $Uint16, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _C = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 31, 1), new Range16.ptr(127, 159, 1), new Range16.ptr(173, 1536, 1363), new Range16.ptr(1537, 1541, 1), new Range16.ptr(1564, 1757, 193), new Range16.ptr(1807, 2274, 467), new Range16.ptr(6158, 8203, 2045), new Range16.ptr(8204, 8207, 1), new Range16.ptr(8234, 8238, 1), new Range16.ptr(8288, 8292, 1), new Range16.ptr(8294, 8303, 1), new Range16.ptr(55296, 63743, 1), new Range16.ptr(65279, 65529, 250), new Range16.ptr(65530, 65531, 1)]), new sliceType$1([new Range32.ptr(69821, 113824, 44003), new Range32.ptr(113825, 113827, 1), new Range32.ptr(119155, 119162, 1), new Range32.ptr(917505, 917536, 31), new Range32.ptr(917537, 917631, 1), new Range32.ptr(983040, 1048573, 1), new Range32.ptr(1048576, 1114109, 1)]), 2); - _Cc = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 31, 1), new Range16.ptr(127, 159, 1)]), sliceType$1.nil, 2); - _Cf = new RangeTable.ptr(new sliceType([new Range16.ptr(173, 1536, 1363), new Range16.ptr(1537, 1541, 1), new Range16.ptr(1564, 1757, 193), new Range16.ptr(1807, 2274, 467), new Range16.ptr(6158, 8203, 2045), new Range16.ptr(8204, 8207, 1), new Range16.ptr(8234, 8238, 1), new Range16.ptr(8288, 8292, 1), new Range16.ptr(8294, 8303, 1), new Range16.ptr(65279, 65529, 250), new Range16.ptr(65530, 65531, 1)]), new sliceType$1([new Range32.ptr(69821, 113824, 44003), new Range32.ptr(113825, 113827, 1), new Range32.ptr(119155, 119162, 1), new Range32.ptr(917505, 917536, 31), new Range32.ptr(917537, 917631, 1)]), 0); - _Co = new RangeTable.ptr(new sliceType([new Range16.ptr(57344, 63743, 1)]), new sliceType$1([new Range32.ptr(983040, 1048573, 1), new Range32.ptr(1048576, 1114109, 1)]), 0); - _Cs = new RangeTable.ptr(new sliceType([new Range16.ptr(55296, 57343, 1)]), sliceType$1.nil, 0); - _L = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(97, 122, 1), new Range16.ptr(170, 181, 11), new Range16.ptr(186, 192, 6), new Range16.ptr(193, 214, 1), new Range16.ptr(216, 246, 1), new Range16.ptr(248, 705, 1), new Range16.ptr(710, 721, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(748, 750, 2), new Range16.ptr(880, 884, 1), new Range16.ptr(886, 887, 1), new Range16.ptr(890, 893, 1), new Range16.ptr(895, 902, 7), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 929, 1), new Range16.ptr(931, 1013, 1), new Range16.ptr(1015, 1153, 1), new Range16.ptr(1162, 1327, 1), new Range16.ptr(1329, 1366, 1), new Range16.ptr(1369, 1377, 8), new Range16.ptr(1378, 1415, 1), new Range16.ptr(1488, 1514, 1), new Range16.ptr(1520, 1522, 1), new Range16.ptr(1568, 1610, 1), new Range16.ptr(1646, 1647, 1), new Range16.ptr(1649, 1747, 1), new Range16.ptr(1749, 1765, 16), new Range16.ptr(1766, 1774, 8), new Range16.ptr(1775, 1786, 11), new Range16.ptr(1787, 1788, 1), new Range16.ptr(1791, 1808, 17), new Range16.ptr(1810, 1839, 1), new Range16.ptr(1869, 1957, 1), new Range16.ptr(1969, 1994, 25), new Range16.ptr(1995, 2026, 1), new Range16.ptr(2036, 2037, 1), new Range16.ptr(2042, 2048, 6), new Range16.ptr(2049, 2069, 1), new Range16.ptr(2074, 2084, 10), new Range16.ptr(2088, 2112, 24), new Range16.ptr(2113, 2136, 1), new Range16.ptr(2144, 2154, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2308, 2361, 1), new Range16.ptr(2365, 2384, 19), new Range16.ptr(2392, 2401, 1), new Range16.ptr(2417, 2432, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2486, 4), new Range16.ptr(2487, 2489, 1), new Range16.ptr(2493, 2510, 17), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2529, 1), new Range16.ptr(2544, 2545, 1), new Range16.ptr(2556, 2565, 9), new Range16.ptr(2566, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2674, 20), new Range16.ptr(2675, 2676, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2749, 2768, 19), new Range16.ptr(2784, 2785, 1), new Range16.ptr(2809, 2821, 12), new Range16.ptr(2822, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2877, 2908, 31), new Range16.ptr(2909, 2911, 2), new Range16.ptr(2912, 2913, 1), new Range16.ptr(2929, 2947, 18), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2974, 2), new Range16.ptr(2975, 2979, 4), new Range16.ptr(2980, 2984, 4), new Range16.ptr(2985, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3024, 3077, 53), new Range16.ptr(3078, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3160, 27), new Range16.ptr(3161, 3162, 1), new Range16.ptr(3168, 3169, 1), new Range16.ptr(3200, 3205, 5), new Range16.ptr(3206, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3261, 3294, 33), new Range16.ptr(3296, 3297, 1), new Range16.ptr(3313, 3314, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3386, 1), new Range16.ptr(3389, 3406, 17), new Range16.ptr(3412, 3414, 1), new Range16.ptr(3423, 3425, 1), new Range16.ptr(3450, 3455, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3520, 3), new Range16.ptr(3521, 3526, 1), new Range16.ptr(3585, 3632, 1), new Range16.ptr(3634, 3635, 1), new Range16.ptr(3648, 3654, 1), new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3719, 3), new Range16.ptr(3720, 3722, 2), new Range16.ptr(3725, 3732, 7), new Range16.ptr(3733, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3751, 2), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3760, 1), new Range16.ptr(3762, 3763, 1), new Range16.ptr(3773, 3776, 3), new Range16.ptr(3777, 3780, 1), new Range16.ptr(3782, 3804, 22), new Range16.ptr(3805, 3807, 1), new Range16.ptr(3840, 3904, 64), new Range16.ptr(3905, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3976, 3980, 1), new Range16.ptr(4096, 4138, 1), new Range16.ptr(4159, 4176, 17), new Range16.ptr(4177, 4181, 1), new Range16.ptr(4186, 4189, 1), new Range16.ptr(4193, 4197, 4), new Range16.ptr(4198, 4206, 8), new Range16.ptr(4207, 4208, 1), new Range16.ptr(4213, 4225, 1), new Range16.ptr(4238, 4256, 18), new Range16.ptr(4257, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(4304, 4346, 1), new Range16.ptr(4348, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4698, 2), new Range16.ptr(4699, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4802, 2), new Range16.ptr(4803, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4992, 5007, 1), new Range16.ptr(5024, 5109, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(5121, 5740, 1), new Range16.ptr(5743, 5759, 1), new Range16.ptr(5761, 5786, 1), new Range16.ptr(5792, 5866, 1), new Range16.ptr(5873, 5880, 1), new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5905, 1), new Range16.ptr(5920, 5937, 1), new Range16.ptr(5952, 5969, 1), new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6016, 6067, 1), new Range16.ptr(6103, 6108, 5), new Range16.ptr(6176, 6263, 1), new Range16.ptr(6272, 6276, 1), new Range16.ptr(6279, 6312, 1), new Range16.ptr(6314, 6320, 6), new Range16.ptr(6321, 6389, 1), new Range16.ptr(6400, 6430, 1), new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1), new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6656, 6678, 1), new Range16.ptr(6688, 6740, 1), new Range16.ptr(6823, 6917, 94), new Range16.ptr(6918, 6963, 1), new Range16.ptr(6981, 6987, 1), new Range16.ptr(7043, 7072, 1), new Range16.ptr(7086, 7087, 1), new Range16.ptr(7098, 7141, 1), new Range16.ptr(7168, 7203, 1), new Range16.ptr(7245, 7247, 1), new Range16.ptr(7258, 7293, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7409, 1), new Range16.ptr(7413, 7414, 1), new Range16.ptr(7424, 7615, 1), new Range16.ptr(7680, 7957, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7968, 8005, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8032, 8061, 1), new Range16.ptr(8064, 8116, 1), new Range16.ptr(8118, 8124, 1), new Range16.ptr(8126, 8130, 4), new Range16.ptr(8131, 8132, 1), new Range16.ptr(8134, 8140, 1), new Range16.ptr(8144, 8147, 1), new Range16.ptr(8150, 8155, 1), new Range16.ptr(8160, 8172, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8188, 1), new Range16.ptr(8305, 8319, 14), new Range16.ptr(8336, 8348, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8458, 8467, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8495, 8505, 1), new Range16.ptr(8508, 8511, 1), new Range16.ptr(8517, 8521, 1), new Range16.ptr(8526, 8579, 53), new Range16.ptr(8580, 11264, 2684), new Range16.ptr(11265, 11310, 1), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11360, 11492, 1), new Range16.ptr(11499, 11502, 1), new Range16.ptr(11506, 11507, 1), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(11568, 11623, 1), new Range16.ptr(11631, 11648, 17), new Range16.ptr(11649, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(11823, 12293, 470), new Range16.ptr(12294, 12337, 43), new Range16.ptr(12338, 12341, 1), new Range16.ptr(12347, 12348, 1), new Range16.ptr(12353, 12438, 1), new Range16.ptr(12445, 12447, 1), new Range16.ptr(12449, 12538, 1), new Range16.ptr(12540, 12543, 1), new Range16.ptr(12549, 12590, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12704, 12730, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(40960, 42124, 1), new Range16.ptr(42192, 42237, 1), new Range16.ptr(42240, 42508, 1), new Range16.ptr(42512, 42527, 1), new Range16.ptr(42538, 42539, 1), new Range16.ptr(42560, 42606, 1), new Range16.ptr(42623, 42653, 1), new Range16.ptr(42656, 42725, 1), new Range16.ptr(42775, 42783, 1), new Range16.ptr(42786, 42888, 1), new Range16.ptr(42891, 42926, 1), new Range16.ptr(42928, 42935, 1), new Range16.ptr(42999, 43009, 1), new Range16.ptr(43011, 43013, 1), new Range16.ptr(43015, 43018, 1), new Range16.ptr(43020, 43042, 1), new Range16.ptr(43072, 43123, 1), new Range16.ptr(43138, 43187, 1), new Range16.ptr(43250, 43255, 1), new Range16.ptr(43259, 43261, 2), new Range16.ptr(43274, 43301, 1), new Range16.ptr(43312, 43334, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(43396, 43442, 1), new Range16.ptr(43471, 43488, 17), new Range16.ptr(43489, 43492, 1), new Range16.ptr(43494, 43503, 1), new Range16.ptr(43514, 43518, 1), new Range16.ptr(43520, 43560, 1), new Range16.ptr(43584, 43586, 1), new Range16.ptr(43588, 43595, 1), new Range16.ptr(43616, 43638, 1), new Range16.ptr(43642, 43646, 4), new Range16.ptr(43647, 43695, 1), new Range16.ptr(43697, 43701, 4), new Range16.ptr(43702, 43705, 3), new Range16.ptr(43706, 43709, 1), new Range16.ptr(43712, 43714, 2), new Range16.ptr(43739, 43741, 1), new Range16.ptr(43744, 43754, 1), new Range16.ptr(43762, 43764, 1), new Range16.ptr(43777, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1), new Range16.ptr(43824, 43866, 1), new Range16.ptr(43868, 43877, 1), new Range16.ptr(43888, 44002, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(64275, 64279, 1), new Range16.ptr(64285, 64287, 2), new Range16.ptr(64288, 64296, 1), new Range16.ptr(64298, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64320, 2), new Range16.ptr(64321, 64323, 2), new Range16.ptr(64324, 64326, 2), new Range16.ptr(64327, 64433, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65019, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1), new Range16.ptr(65313, 65338, 1), new Range16.ptr(65345, 65370, 1), new Range16.ptr(65382, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1), new Range32.ptr(66176, 66204, 1), new Range32.ptr(66208, 66256, 1), new Range32.ptr(66304, 66335, 1), new Range32.ptr(66349, 66368, 1), new Range32.ptr(66370, 66377, 1), new Range32.ptr(66384, 66421, 1), new Range32.ptr(66432, 66461, 1), new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66511, 1), new Range32.ptr(66560, 66717, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(66816, 66855, 1), new Range32.ptr(66864, 66915, 1), new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1), new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67594, 2), new Range32.ptr(67595, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67647, 3), new Range32.ptr(67648, 67669, 1), new Range32.ptr(67680, 67702, 1), new Range32.ptr(67712, 67742, 1), new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67840, 67861, 1), new Range32.ptr(67872, 67897, 1), new Range32.ptr(67968, 68023, 1), new Range32.ptr(68030, 68031, 1), new Range32.ptr(68096, 68112, 16), new Range32.ptr(68113, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68192, 68220, 1), new Range32.ptr(68224, 68252, 1), new Range32.ptr(68288, 68295, 1), new Range32.ptr(68297, 68324, 1), new Range32.ptr(68352, 68405, 1), new Range32.ptr(68416, 68437, 1), new Range32.ptr(68448, 68466, 1), new Range32.ptr(68480, 68497, 1), new Range32.ptr(68608, 68680, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(69635, 69687, 1), new Range32.ptr(69763, 69807, 1), new Range32.ptr(69840, 69864, 1), new Range32.ptr(69891, 69926, 1), new Range32.ptr(69968, 70002, 1), new Range32.ptr(70006, 70019, 13), new Range32.ptr(70020, 70066, 1), new Range32.ptr(70081, 70084, 1), new Range32.ptr(70106, 70108, 2), new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70187, 1), new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70282, 2), new Range32.ptr(70283, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70312, 1), new Range32.ptr(70320, 70366, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70461, 70480, 19), new Range32.ptr(70493, 70497, 1), new Range32.ptr(70656, 70708, 1), new Range32.ptr(70727, 70730, 1), new Range32.ptr(70784, 70831, 1), new Range32.ptr(70852, 70853, 1), new Range32.ptr(70855, 71040, 185), new Range32.ptr(71041, 71086, 1), new Range32.ptr(71128, 71131, 1), new Range32.ptr(71168, 71215, 1), new Range32.ptr(71236, 71296, 60), new Range32.ptr(71297, 71338, 1), new Range32.ptr(71424, 71449, 1), new Range32.ptr(71840, 71903, 1), new Range32.ptr(71935, 72192, 257), new Range32.ptr(72203, 72242, 1), new Range32.ptr(72250, 72272, 22), new Range32.ptr(72284, 72323, 1), new Range32.ptr(72326, 72329, 1), new Range32.ptr(72384, 72440, 1), new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72750, 1), new Range32.ptr(72768, 72818, 50), new Range32.ptr(72819, 72847, 1), new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73008, 1), new Range32.ptr(73030, 73728, 698), new Range32.ptr(73729, 74649, 1), new Range32.ptr(74880, 75075, 1), new Range32.ptr(77824, 78894, 1), new Range32.ptr(82944, 83526, 1), new Range32.ptr(92160, 92728, 1), new Range32.ptr(92736, 92766, 1), new Range32.ptr(92880, 92909, 1), new Range32.ptr(92928, 92975, 1), new Range32.ptr(92992, 92995, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1), new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94099, 67), new Range32.ptr(94100, 94111, 1), new Range32.ptr(94176, 94177, 1), new Range32.ptr(94208, 100332, 1), new Range32.ptr(100352, 101106, 1), new Range32.ptr(110592, 110878, 1), new Range32.ptr(110960, 111355, 1), new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(119808, 119892, 1), new Range32.ptr(119894, 119964, 1), new Range32.ptr(119966, 119967, 1), new Range32.ptr(119970, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119993, 1), new Range32.ptr(119995, 119997, 2), new Range32.ptr(119998, 120003, 1), new Range32.ptr(120005, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120094, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120146, 120485, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120514, 120538, 1), new Range32.ptr(120540, 120570, 1), new Range32.ptr(120572, 120596, 1), new Range32.ptr(120598, 120628, 1), new Range32.ptr(120630, 120654, 1), new Range32.ptr(120656, 120686, 1), new Range32.ptr(120688, 120712, 1), new Range32.ptr(120714, 120744, 1), new Range32.ptr(120746, 120770, 1), new Range32.ptr(120772, 120779, 1), new Range32.ptr(124928, 125124, 1), new Range32.ptr(125184, 125251, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126503, 3), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126523, 2), new Range32.ptr(126530, 126535, 5), new Range32.ptr(126537, 126541, 2), new Range32.ptr(126542, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126551, 3), new Range32.ptr(126553, 126561, 2), new Range32.ptr(126562, 126564, 2), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126592, 2), new Range32.ptr(126593, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 6); - _Ll = new RangeTable.ptr(new sliceType([new Range16.ptr(97, 122, 1), new Range16.ptr(181, 223, 42), new Range16.ptr(224, 246, 1), new Range16.ptr(248, 255, 1), new Range16.ptr(257, 311, 2), new Range16.ptr(312, 328, 2), new Range16.ptr(329, 375, 2), new Range16.ptr(378, 382, 2), new Range16.ptr(383, 384, 1), new Range16.ptr(387, 389, 2), new Range16.ptr(392, 396, 4), new Range16.ptr(397, 402, 5), new Range16.ptr(405, 409, 4), new Range16.ptr(410, 411, 1), new Range16.ptr(414, 417, 3), new Range16.ptr(419, 421, 2), new Range16.ptr(424, 426, 2), new Range16.ptr(427, 429, 2), new Range16.ptr(432, 436, 4), new Range16.ptr(438, 441, 3), new Range16.ptr(442, 445, 3), new Range16.ptr(446, 447, 1), new Range16.ptr(454, 460, 3), new Range16.ptr(462, 476, 2), new Range16.ptr(477, 495, 2), new Range16.ptr(496, 499, 3), new Range16.ptr(501, 505, 4), new Range16.ptr(507, 563, 2), new Range16.ptr(564, 569, 1), new Range16.ptr(572, 575, 3), new Range16.ptr(576, 578, 2), new Range16.ptr(583, 591, 2), new Range16.ptr(592, 659, 1), new Range16.ptr(661, 687, 1), new Range16.ptr(881, 883, 2), new Range16.ptr(887, 891, 4), new Range16.ptr(892, 893, 1), new Range16.ptr(912, 940, 28), new Range16.ptr(941, 974, 1), new Range16.ptr(976, 977, 1), new Range16.ptr(981, 983, 1), new Range16.ptr(985, 1007, 2), new Range16.ptr(1008, 1011, 1), new Range16.ptr(1013, 1019, 3), new Range16.ptr(1020, 1072, 52), new Range16.ptr(1073, 1119, 1), new Range16.ptr(1121, 1153, 2), new Range16.ptr(1163, 1215, 2), new Range16.ptr(1218, 1230, 2), new Range16.ptr(1231, 1327, 2), new Range16.ptr(1377, 1415, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7424, 7467, 1), new Range16.ptr(7531, 7543, 1), new Range16.ptr(7545, 7578, 1), new Range16.ptr(7681, 7829, 2), new Range16.ptr(7830, 7837, 1), new Range16.ptr(7839, 7935, 2), new Range16.ptr(7936, 7943, 1), new Range16.ptr(7952, 7957, 1), new Range16.ptr(7968, 7975, 1), new Range16.ptr(7984, 7991, 1), new Range16.ptr(8000, 8005, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8032, 8039, 1), new Range16.ptr(8048, 8061, 1), new Range16.ptr(8064, 8071, 1), new Range16.ptr(8080, 8087, 1), new Range16.ptr(8096, 8103, 1), new Range16.ptr(8112, 8116, 1), new Range16.ptr(8118, 8119, 1), new Range16.ptr(8126, 8130, 4), new Range16.ptr(8131, 8132, 1), new Range16.ptr(8134, 8135, 1), new Range16.ptr(8144, 8147, 1), new Range16.ptr(8150, 8151, 1), new Range16.ptr(8160, 8167, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8183, 1), new Range16.ptr(8458, 8462, 4), new Range16.ptr(8463, 8467, 4), new Range16.ptr(8495, 8505, 5), new Range16.ptr(8508, 8509, 1), new Range16.ptr(8518, 8521, 1), new Range16.ptr(8526, 8580, 54), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11361, 11365, 4), new Range16.ptr(11366, 11372, 2), new Range16.ptr(11377, 11379, 2), new Range16.ptr(11380, 11382, 2), new Range16.ptr(11383, 11387, 1), new Range16.ptr(11393, 11491, 2), new Range16.ptr(11492, 11500, 8), new Range16.ptr(11502, 11507, 5), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(42561, 42605, 2), new Range16.ptr(42625, 42651, 2), new Range16.ptr(42787, 42799, 2), new Range16.ptr(42800, 42801, 1), new Range16.ptr(42803, 42865, 2), new Range16.ptr(42866, 42872, 1), new Range16.ptr(42874, 42876, 2), new Range16.ptr(42879, 42887, 2), new Range16.ptr(42892, 42894, 2), new Range16.ptr(42897, 42899, 2), new Range16.ptr(42900, 42901, 1), new Range16.ptr(42903, 42921, 2), new Range16.ptr(42933, 42935, 2), new Range16.ptr(43002, 43824, 822), new Range16.ptr(43825, 43866, 1), new Range16.ptr(43872, 43877, 1), new Range16.ptr(43888, 43967, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(64275, 64279, 1), new Range16.ptr(65345, 65370, 1)]), new sliceType$1([new Range32.ptr(66600, 66639, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(71872, 71903, 1), new Range32.ptr(119834, 119859, 1), new Range32.ptr(119886, 119892, 1), new Range32.ptr(119894, 119911, 1), new Range32.ptr(119938, 119963, 1), new Range32.ptr(119990, 119993, 1), new Range32.ptr(119995, 119997, 2), new Range32.ptr(119998, 120003, 1), new Range32.ptr(120005, 120015, 1), new Range32.ptr(120042, 120067, 1), new Range32.ptr(120094, 120119, 1), new Range32.ptr(120146, 120171, 1), new Range32.ptr(120198, 120223, 1), new Range32.ptr(120250, 120275, 1), new Range32.ptr(120302, 120327, 1), new Range32.ptr(120354, 120379, 1), new Range32.ptr(120406, 120431, 1), new Range32.ptr(120458, 120485, 1), new Range32.ptr(120514, 120538, 1), new Range32.ptr(120540, 120545, 1), new Range32.ptr(120572, 120596, 1), new Range32.ptr(120598, 120603, 1), new Range32.ptr(120630, 120654, 1), new Range32.ptr(120656, 120661, 1), new Range32.ptr(120688, 120712, 1), new Range32.ptr(120714, 120719, 1), new Range32.ptr(120746, 120770, 1), new Range32.ptr(120772, 120777, 1), new Range32.ptr(120779, 125218, 4439), new Range32.ptr(125219, 125251, 1)]), 4); - _Lm = new RangeTable.ptr(new sliceType([new Range16.ptr(688, 705, 1), new Range16.ptr(710, 721, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(748, 750, 2), new Range16.ptr(884, 890, 6), new Range16.ptr(1369, 1600, 231), new Range16.ptr(1765, 1766, 1), new Range16.ptr(2036, 2037, 1), new Range16.ptr(2042, 2074, 32), new Range16.ptr(2084, 2088, 4), new Range16.ptr(2417, 3654, 1237), new Range16.ptr(3782, 4348, 566), new Range16.ptr(6103, 6211, 108), new Range16.ptr(6823, 7288, 465), new Range16.ptr(7289, 7293, 1), new Range16.ptr(7468, 7530, 1), new Range16.ptr(7544, 7579, 35), new Range16.ptr(7580, 7615, 1), new Range16.ptr(8305, 8319, 14), new Range16.ptr(8336, 8348, 1), new Range16.ptr(11388, 11389, 1), new Range16.ptr(11631, 11823, 192), new Range16.ptr(12293, 12337, 44), new Range16.ptr(12338, 12341, 1), new Range16.ptr(12347, 12445, 98), new Range16.ptr(12446, 12540, 94), new Range16.ptr(12541, 12542, 1), new Range16.ptr(40981, 42232, 1251), new Range16.ptr(42233, 42237, 1), new Range16.ptr(42508, 42623, 115), new Range16.ptr(42652, 42653, 1), new Range16.ptr(42775, 42783, 1), new Range16.ptr(42864, 42888, 24), new Range16.ptr(43000, 43001, 1), new Range16.ptr(43471, 43494, 23), new Range16.ptr(43632, 43741, 109), new Range16.ptr(43763, 43764, 1), new Range16.ptr(43868, 43871, 1), new Range16.ptr(65392, 65438, 46), new Range16.ptr(65439, 65439, 1)]), new sliceType$1([new Range32.ptr(92992, 92992, 1), new Range32.ptr(92993, 92995, 1), new Range32.ptr(94099, 94111, 1), new Range32.ptr(94176, 94177, 1)]), 0); - _Lo = new RangeTable.ptr(new sliceType([new Range16.ptr(170, 186, 16), new Range16.ptr(443, 448, 5), new Range16.ptr(449, 451, 1), new Range16.ptr(660, 1488, 828), new Range16.ptr(1489, 1514, 1), new Range16.ptr(1520, 1522, 1), new Range16.ptr(1568, 1599, 1), new Range16.ptr(1601, 1610, 1), new Range16.ptr(1646, 1647, 1), new Range16.ptr(1649, 1747, 1), new Range16.ptr(1749, 1774, 25), new Range16.ptr(1775, 1786, 11), new Range16.ptr(1787, 1788, 1), new Range16.ptr(1791, 1808, 17), new Range16.ptr(1810, 1839, 1), new Range16.ptr(1869, 1957, 1), new Range16.ptr(1969, 1994, 25), new Range16.ptr(1995, 2026, 1), new Range16.ptr(2048, 2069, 1), new Range16.ptr(2112, 2136, 1), new Range16.ptr(2144, 2154, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2308, 2361, 1), new Range16.ptr(2365, 2384, 19), new Range16.ptr(2392, 2401, 1), new Range16.ptr(2418, 2432, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2486, 4), new Range16.ptr(2487, 2489, 1), new Range16.ptr(2493, 2510, 17), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2529, 1), new Range16.ptr(2544, 2545, 1), new Range16.ptr(2556, 2565, 9), new Range16.ptr(2566, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2674, 20), new Range16.ptr(2675, 2676, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2749, 2768, 19), new Range16.ptr(2784, 2785, 1), new Range16.ptr(2809, 2821, 12), new Range16.ptr(2822, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2877, 2908, 31), new Range16.ptr(2909, 2911, 2), new Range16.ptr(2912, 2913, 1), new Range16.ptr(2929, 2947, 18), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2974, 2), new Range16.ptr(2975, 2979, 4), new Range16.ptr(2980, 2984, 4), new Range16.ptr(2985, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3024, 3077, 53), new Range16.ptr(3078, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3160, 27), new Range16.ptr(3161, 3162, 1), new Range16.ptr(3168, 3169, 1), new Range16.ptr(3200, 3205, 5), new Range16.ptr(3206, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3261, 3294, 33), new Range16.ptr(3296, 3297, 1), new Range16.ptr(3313, 3314, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3386, 1), new Range16.ptr(3389, 3406, 17), new Range16.ptr(3412, 3414, 1), new Range16.ptr(3423, 3425, 1), new Range16.ptr(3450, 3455, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3520, 3), new Range16.ptr(3521, 3526, 1), new Range16.ptr(3585, 3632, 1), new Range16.ptr(3634, 3635, 1), new Range16.ptr(3648, 3653, 1), new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3719, 3), new Range16.ptr(3720, 3722, 2), new Range16.ptr(3725, 3732, 7), new Range16.ptr(3733, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3751, 2), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3760, 1), new Range16.ptr(3762, 3763, 1), new Range16.ptr(3773, 3776, 3), new Range16.ptr(3777, 3780, 1), new Range16.ptr(3804, 3807, 1), new Range16.ptr(3840, 3904, 64), new Range16.ptr(3905, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3976, 3980, 1), new Range16.ptr(4096, 4138, 1), new Range16.ptr(4159, 4176, 17), new Range16.ptr(4177, 4181, 1), new Range16.ptr(4186, 4189, 1), new Range16.ptr(4193, 4197, 4), new Range16.ptr(4198, 4206, 8), new Range16.ptr(4207, 4208, 1), new Range16.ptr(4213, 4225, 1), new Range16.ptr(4238, 4304, 66), new Range16.ptr(4305, 4346, 1), new Range16.ptr(4349, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4698, 2), new Range16.ptr(4699, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4802, 2), new Range16.ptr(4803, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4992, 5007, 1), new Range16.ptr(5121, 5740, 1), new Range16.ptr(5743, 5759, 1), new Range16.ptr(5761, 5786, 1), new Range16.ptr(5792, 5866, 1), new Range16.ptr(5873, 5880, 1), new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5905, 1), new Range16.ptr(5920, 5937, 1), new Range16.ptr(5952, 5969, 1), new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6016, 6067, 1), new Range16.ptr(6108, 6176, 68), new Range16.ptr(6177, 6210, 1), new Range16.ptr(6212, 6263, 1), new Range16.ptr(6272, 6276, 1), new Range16.ptr(6279, 6312, 1), new Range16.ptr(6314, 6320, 6), new Range16.ptr(6321, 6389, 1), new Range16.ptr(6400, 6430, 1), new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1), new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6656, 6678, 1), new Range16.ptr(6688, 6740, 1), new Range16.ptr(6917, 6963, 1), new Range16.ptr(6981, 6987, 1), new Range16.ptr(7043, 7072, 1), new Range16.ptr(7086, 7087, 1), new Range16.ptr(7098, 7141, 1), new Range16.ptr(7168, 7203, 1), new Range16.ptr(7245, 7247, 1), new Range16.ptr(7258, 7287, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7409, 1), new Range16.ptr(7413, 7414, 1), new Range16.ptr(8501, 8504, 1), new Range16.ptr(11568, 11623, 1), new Range16.ptr(11648, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(12294, 12348, 54), new Range16.ptr(12353, 12438, 1), new Range16.ptr(12447, 12449, 2), new Range16.ptr(12450, 12538, 1), new Range16.ptr(12543, 12549, 6), new Range16.ptr(12550, 12590, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12704, 12730, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(40960, 40980, 1), new Range16.ptr(40982, 42124, 1), new Range16.ptr(42192, 42231, 1), new Range16.ptr(42240, 42507, 1), new Range16.ptr(42512, 42527, 1), new Range16.ptr(42538, 42539, 1), new Range16.ptr(42606, 42656, 50), new Range16.ptr(42657, 42725, 1), new Range16.ptr(42895, 42999, 104), new Range16.ptr(43003, 43009, 1), new Range16.ptr(43011, 43013, 1), new Range16.ptr(43015, 43018, 1), new Range16.ptr(43020, 43042, 1), new Range16.ptr(43072, 43123, 1), new Range16.ptr(43138, 43187, 1), new Range16.ptr(43250, 43255, 1), new Range16.ptr(43259, 43261, 2), new Range16.ptr(43274, 43301, 1), new Range16.ptr(43312, 43334, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(43396, 43442, 1), new Range16.ptr(43488, 43492, 1), new Range16.ptr(43495, 43503, 1), new Range16.ptr(43514, 43518, 1), new Range16.ptr(43520, 43560, 1), new Range16.ptr(43584, 43586, 1), new Range16.ptr(43588, 43595, 1), new Range16.ptr(43616, 43631, 1), new Range16.ptr(43633, 43638, 1), new Range16.ptr(43642, 43646, 4), new Range16.ptr(43647, 43695, 1), new Range16.ptr(43697, 43701, 4), new Range16.ptr(43702, 43705, 3), new Range16.ptr(43706, 43709, 1), new Range16.ptr(43712, 43714, 2), new Range16.ptr(43739, 43740, 1), new Range16.ptr(43744, 43754, 1), new Range16.ptr(43762, 43777, 15), new Range16.ptr(43778, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1), new Range16.ptr(43968, 44002, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1), new Range16.ptr(64285, 64287, 2), new Range16.ptr(64288, 64296, 1), new Range16.ptr(64298, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64320, 2), new Range16.ptr(64321, 64323, 2), new Range16.ptr(64324, 64326, 2), new Range16.ptr(64327, 64433, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65019, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1), new Range16.ptr(65382, 65391, 1), new Range16.ptr(65393, 65437, 1), new Range16.ptr(65440, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1), new Range32.ptr(66176, 66204, 1), new Range32.ptr(66208, 66256, 1), new Range32.ptr(66304, 66335, 1), new Range32.ptr(66349, 66368, 1), new Range32.ptr(66370, 66377, 1), new Range32.ptr(66384, 66421, 1), new Range32.ptr(66432, 66461, 1), new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66511, 1), new Range32.ptr(66640, 66717, 1), new Range32.ptr(66816, 66855, 1), new Range32.ptr(66864, 66915, 1), new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1), new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67594, 2), new Range32.ptr(67595, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67647, 3), new Range32.ptr(67648, 67669, 1), new Range32.ptr(67680, 67702, 1), new Range32.ptr(67712, 67742, 1), new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67840, 67861, 1), new Range32.ptr(67872, 67897, 1), new Range32.ptr(67968, 68023, 1), new Range32.ptr(68030, 68031, 1), new Range32.ptr(68096, 68112, 16), new Range32.ptr(68113, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68192, 68220, 1), new Range32.ptr(68224, 68252, 1), new Range32.ptr(68288, 68295, 1), new Range32.ptr(68297, 68324, 1), new Range32.ptr(68352, 68405, 1), new Range32.ptr(68416, 68437, 1), new Range32.ptr(68448, 68466, 1), new Range32.ptr(68480, 68497, 1), new Range32.ptr(68608, 68680, 1), new Range32.ptr(69635, 69687, 1), new Range32.ptr(69763, 69807, 1), new Range32.ptr(69840, 69864, 1), new Range32.ptr(69891, 69926, 1), new Range32.ptr(69968, 70002, 1), new Range32.ptr(70006, 70019, 13), new Range32.ptr(70020, 70066, 1), new Range32.ptr(70081, 70084, 1), new Range32.ptr(70106, 70108, 2), new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70187, 1), new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70282, 2), new Range32.ptr(70283, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70312, 1), new Range32.ptr(70320, 70366, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70461, 70480, 19), new Range32.ptr(70493, 70497, 1), new Range32.ptr(70656, 70708, 1), new Range32.ptr(70727, 70730, 1), new Range32.ptr(70784, 70831, 1), new Range32.ptr(70852, 70853, 1), new Range32.ptr(70855, 71040, 185), new Range32.ptr(71041, 71086, 1), new Range32.ptr(71128, 71131, 1), new Range32.ptr(71168, 71215, 1), new Range32.ptr(71236, 71296, 60), new Range32.ptr(71297, 71338, 1), new Range32.ptr(71424, 71449, 1), new Range32.ptr(71935, 72192, 257), new Range32.ptr(72203, 72242, 1), new Range32.ptr(72250, 72272, 22), new Range32.ptr(72284, 72323, 1), new Range32.ptr(72326, 72329, 1), new Range32.ptr(72384, 72440, 1), new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72750, 1), new Range32.ptr(72768, 72818, 50), new Range32.ptr(72819, 72847, 1), new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73008, 1), new Range32.ptr(73030, 73728, 698), new Range32.ptr(73729, 74649, 1), new Range32.ptr(74880, 75075, 1), new Range32.ptr(77824, 78894, 1), new Range32.ptr(82944, 83526, 1), new Range32.ptr(92160, 92728, 1), new Range32.ptr(92736, 92766, 1), new Range32.ptr(92880, 92909, 1), new Range32.ptr(92928, 92975, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1), new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94208, 176), new Range32.ptr(94209, 100332, 1), new Range32.ptr(100352, 101106, 1), new Range32.ptr(110592, 110878, 1), new Range32.ptr(110960, 111355, 1), new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(124928, 125124, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126503, 3), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126523, 2), new Range32.ptr(126530, 126535, 5), new Range32.ptr(126537, 126541, 2), new Range32.ptr(126542, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126551, 3), new Range32.ptr(126553, 126561, 2), new Range32.ptr(126562, 126564, 2), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126592, 2), new Range32.ptr(126593, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 1); - _Lt = new RangeTable.ptr(new sliceType([new Range16.ptr(453, 459, 3), new Range16.ptr(498, 8072, 7574), new Range16.ptr(8073, 8079, 1), new Range16.ptr(8088, 8095, 1), new Range16.ptr(8104, 8111, 1), new Range16.ptr(8124, 8140, 16), new Range16.ptr(8188, 8188, 1)]), sliceType$1.nil, 0); - _Lu = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 222, 1), new Range16.ptr(256, 310, 2), new Range16.ptr(313, 327, 2), new Range16.ptr(330, 376, 2), new Range16.ptr(377, 381, 2), new Range16.ptr(385, 386, 1), new Range16.ptr(388, 390, 2), new Range16.ptr(391, 393, 2), new Range16.ptr(394, 395, 1), new Range16.ptr(398, 401, 1), new Range16.ptr(403, 404, 1), new Range16.ptr(406, 408, 1), new Range16.ptr(412, 413, 1), new Range16.ptr(415, 416, 1), new Range16.ptr(418, 422, 2), new Range16.ptr(423, 425, 2), new Range16.ptr(428, 430, 2), new Range16.ptr(431, 433, 2), new Range16.ptr(434, 435, 1), new Range16.ptr(437, 439, 2), new Range16.ptr(440, 444, 4), new Range16.ptr(452, 461, 3), new Range16.ptr(463, 475, 2), new Range16.ptr(478, 494, 2), new Range16.ptr(497, 500, 3), new Range16.ptr(502, 504, 1), new Range16.ptr(506, 562, 2), new Range16.ptr(570, 571, 1), new Range16.ptr(573, 574, 1), new Range16.ptr(577, 579, 2), new Range16.ptr(580, 582, 1), new Range16.ptr(584, 590, 2), new Range16.ptr(880, 882, 2), new Range16.ptr(886, 895, 9), new Range16.ptr(902, 904, 2), new Range16.ptr(905, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 913, 2), new Range16.ptr(914, 929, 1), new Range16.ptr(931, 939, 1), new Range16.ptr(975, 978, 3), new Range16.ptr(979, 980, 1), new Range16.ptr(984, 1006, 2), new Range16.ptr(1012, 1015, 3), new Range16.ptr(1017, 1018, 1), new Range16.ptr(1021, 1071, 1), new Range16.ptr(1120, 1152, 2), new Range16.ptr(1162, 1216, 2), new Range16.ptr(1217, 1229, 2), new Range16.ptr(1232, 1326, 2), new Range16.ptr(1329, 1366, 1), new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(5024, 5109, 1), new Range16.ptr(7680, 7828, 2), new Range16.ptr(7838, 7934, 2), new Range16.ptr(7944, 7951, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7976, 7983, 1), new Range16.ptr(7992, 7999, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8040, 8047, 1), new Range16.ptr(8120, 8123, 1), new Range16.ptr(8136, 8139, 1), new Range16.ptr(8152, 8155, 1), new Range16.ptr(8168, 8172, 1), new Range16.ptr(8184, 8187, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8459, 8461, 1), new Range16.ptr(8464, 8466, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8496, 8499, 1), new Range16.ptr(8510, 8511, 1), new Range16.ptr(8517, 8579, 62), new Range16.ptr(11264, 11310, 1), new Range16.ptr(11360, 11362, 2), new Range16.ptr(11363, 11364, 1), new Range16.ptr(11367, 11373, 2), new Range16.ptr(11374, 11376, 1), new Range16.ptr(11378, 11381, 3), new Range16.ptr(11390, 11392, 1), new Range16.ptr(11394, 11490, 2), new Range16.ptr(11499, 11501, 2), new Range16.ptr(11506, 42560, 31054), new Range16.ptr(42562, 42604, 2), new Range16.ptr(42624, 42650, 2), new Range16.ptr(42786, 42798, 2), new Range16.ptr(42802, 42862, 2), new Range16.ptr(42873, 42877, 2), new Range16.ptr(42878, 42886, 2), new Range16.ptr(42891, 42893, 2), new Range16.ptr(42896, 42898, 2), new Range16.ptr(42902, 42922, 2), new Range16.ptr(42923, 42926, 1), new Range16.ptr(42928, 42932, 1), new Range16.ptr(42934, 65313, 22379), new Range16.ptr(65314, 65338, 1)]), new sliceType$1([new Range32.ptr(66560, 66599, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(71840, 71871, 1), new Range32.ptr(119808, 119833, 1), new Range32.ptr(119860, 119885, 1), new Range32.ptr(119912, 119937, 1), new Range32.ptr(119964, 119966, 2), new Range32.ptr(119967, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119989, 1), new Range32.ptr(120016, 120041, 1), new Range32.ptr(120068, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120120, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120172, 120197, 1), new Range32.ptr(120224, 120249, 1), new Range32.ptr(120276, 120301, 1), new Range32.ptr(120328, 120353, 1), new Range32.ptr(120380, 120405, 1), new Range32.ptr(120432, 120457, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120546, 120570, 1), new Range32.ptr(120604, 120628, 1), new Range32.ptr(120662, 120686, 1), new Range32.ptr(120720, 120744, 1), new Range32.ptr(120778, 125184, 4406), new Range32.ptr(125185, 125217, 1)]), 3); - _M = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1155, 1161, 1), new Range16.ptr(1425, 1469, 1), new Range16.ptr(1471, 1473, 2), new Range16.ptr(1474, 1476, 2), new Range16.ptr(1477, 1479, 2), new Range16.ptr(1552, 1562, 1), new Range16.ptr(1611, 1631, 1), new Range16.ptr(1648, 1750, 102), new Range16.ptr(1751, 1756, 1), new Range16.ptr(1759, 1764, 1), new Range16.ptr(1767, 1768, 1), new Range16.ptr(1770, 1773, 1), new Range16.ptr(1809, 1840, 31), new Range16.ptr(1841, 1866, 1), new Range16.ptr(1958, 1968, 1), new Range16.ptr(2027, 2035, 1), new Range16.ptr(2070, 2073, 1), new Range16.ptr(2075, 2083, 1), new Range16.ptr(2085, 2087, 1), new Range16.ptr(2089, 2093, 1), new Range16.ptr(2137, 2139, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2307, 1), new Range16.ptr(2362, 2364, 1), new Range16.ptr(2366, 2383, 1), new Range16.ptr(2385, 2391, 1), new Range16.ptr(2402, 2403, 1), new Range16.ptr(2433, 2435, 1), new Range16.ptr(2492, 2494, 2), new Range16.ptr(2495, 2500, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2509, 1), new Range16.ptr(2519, 2530, 11), new Range16.ptr(2531, 2561, 30), new Range16.ptr(2562, 2563, 1), new Range16.ptr(2620, 2622, 2), new Range16.ptr(2623, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2672, 31), new Range16.ptr(2673, 2677, 4), new Range16.ptr(2689, 2691, 1), new Range16.ptr(2748, 2750, 2), new Range16.ptr(2751, 2757, 1), new Range16.ptr(2759, 2761, 1), new Range16.ptr(2763, 2765, 1), new Range16.ptr(2786, 2787, 1), new Range16.ptr(2810, 2815, 1), new Range16.ptr(2817, 2819, 1), new Range16.ptr(2876, 2878, 2), new Range16.ptr(2879, 2884, 1), new Range16.ptr(2887, 2888, 1), new Range16.ptr(2891, 2893, 1), new Range16.ptr(2902, 2903, 1), new Range16.ptr(2914, 2915, 1), new Range16.ptr(2946, 3006, 60), new Range16.ptr(3007, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3021, 1), new Range16.ptr(3031, 3072, 41), new Range16.ptr(3073, 3075, 1), new Range16.ptr(3134, 3140, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3170, 3171, 1), new Range16.ptr(3201, 3203, 1), new Range16.ptr(3260, 3262, 2), new Range16.ptr(3263, 3268, 1), new Range16.ptr(3270, 3272, 1), new Range16.ptr(3274, 3277, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3298, 3299, 1), new Range16.ptr(3328, 3331, 1), new Range16.ptr(3387, 3388, 1), new Range16.ptr(3390, 3396, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3405, 1), new Range16.ptr(3415, 3426, 11), new Range16.ptr(3427, 3458, 31), new Range16.ptr(3459, 3530, 71), new Range16.ptr(3535, 3540, 1), new Range16.ptr(3542, 3544, 2), new Range16.ptr(3545, 3551, 1), new Range16.ptr(3570, 3571, 1), new Range16.ptr(3633, 3636, 3), new Range16.ptr(3637, 3642, 1), new Range16.ptr(3655, 3662, 1), new Range16.ptr(3761, 3764, 3), new Range16.ptr(3765, 3769, 1), new Range16.ptr(3771, 3772, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3864, 3865, 1), new Range16.ptr(3893, 3897, 2), new Range16.ptr(3902, 3903, 1), new Range16.ptr(3953, 3972, 1), new Range16.ptr(3974, 3975, 1), new Range16.ptr(3981, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4038, 4139, 101), new Range16.ptr(4140, 4158, 1), new Range16.ptr(4182, 4185, 1), new Range16.ptr(4190, 4192, 1), new Range16.ptr(4194, 4196, 1), new Range16.ptr(4199, 4205, 1), new Range16.ptr(4209, 4212, 1), new Range16.ptr(4226, 4237, 1), new Range16.ptr(4239, 4250, 11), new Range16.ptr(4251, 4253, 1), new Range16.ptr(4957, 4959, 1), new Range16.ptr(5906, 5908, 1), new Range16.ptr(5938, 5940, 1), new Range16.ptr(5970, 5971, 1), new Range16.ptr(6002, 6003, 1), new Range16.ptr(6068, 6099, 1), new Range16.ptr(6109, 6155, 46), new Range16.ptr(6156, 6157, 1), new Range16.ptr(6277, 6278, 1), new Range16.ptr(6313, 6432, 119), new Range16.ptr(6433, 6443, 1), new Range16.ptr(6448, 6459, 1), new Range16.ptr(6679, 6683, 1), new Range16.ptr(6741, 6750, 1), new Range16.ptr(6752, 6780, 1), new Range16.ptr(6783, 6832, 49), new Range16.ptr(6833, 6846, 1), new Range16.ptr(6912, 6916, 1), new Range16.ptr(6964, 6980, 1), new Range16.ptr(7019, 7027, 1), new Range16.ptr(7040, 7042, 1), new Range16.ptr(7073, 7085, 1), new Range16.ptr(7142, 7155, 1), new Range16.ptr(7204, 7223, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7400, 1), new Range16.ptr(7405, 7410, 5), new Range16.ptr(7411, 7412, 1), new Range16.ptr(7415, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8400, 8432, 1), new Range16.ptr(11503, 11505, 1), new Range16.ptr(11647, 11744, 97), new Range16.ptr(11745, 11775, 1), new Range16.ptr(12330, 12335, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(42607, 42610, 1), new Range16.ptr(42612, 42621, 1), new Range16.ptr(42654, 42655, 1), new Range16.ptr(42736, 42737, 1), new Range16.ptr(43010, 43014, 4), new Range16.ptr(43019, 43043, 24), new Range16.ptr(43044, 43047, 1), new Range16.ptr(43136, 43137, 1), new Range16.ptr(43188, 43205, 1), new Range16.ptr(43232, 43249, 1), new Range16.ptr(43302, 43309, 1), new Range16.ptr(43335, 43347, 1), new Range16.ptr(43392, 43395, 1), new Range16.ptr(43443, 43456, 1), new Range16.ptr(43493, 43561, 68), new Range16.ptr(43562, 43574, 1), new Range16.ptr(43587, 43596, 9), new Range16.ptr(43597, 43643, 46), new Range16.ptr(43644, 43645, 1), new Range16.ptr(43696, 43698, 2), new Range16.ptr(43699, 43700, 1), new Range16.ptr(43703, 43704, 1), new Range16.ptr(43710, 43711, 1), new Range16.ptr(43713, 43755, 42), new Range16.ptr(43756, 43759, 1), new Range16.ptr(43765, 43766, 1), new Range16.ptr(44003, 44010, 1), new Range16.ptr(44012, 44013, 1), new Range16.ptr(64286, 65024, 738), new Range16.ptr(65025, 65039, 1), new Range16.ptr(65056, 65071, 1)]), new sliceType$1([new Range32.ptr(66045, 66272, 227), new Range32.ptr(66422, 66426, 1), new Range32.ptr(68097, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68111, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68325, 166), new Range32.ptr(68326, 69632, 1306), new Range32.ptr(69633, 69634, 1), new Range32.ptr(69688, 69702, 1), new Range32.ptr(69759, 69762, 1), new Range32.ptr(69808, 69818, 1), new Range32.ptr(69888, 69890, 1), new Range32.ptr(69927, 69940, 1), new Range32.ptr(70003, 70016, 13), new Range32.ptr(70017, 70018, 1), new Range32.ptr(70067, 70080, 1), new Range32.ptr(70090, 70092, 1), new Range32.ptr(70188, 70199, 1), new Range32.ptr(70206, 70367, 161), new Range32.ptr(70368, 70378, 1), new Range32.ptr(70400, 70403, 1), new Range32.ptr(70460, 70462, 2), new Range32.ptr(70463, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70487, 70498, 11), new Range32.ptr(70499, 70502, 3), new Range32.ptr(70503, 70508, 1), new Range32.ptr(70512, 70516, 1), new Range32.ptr(70709, 70726, 1), new Range32.ptr(70832, 70851, 1), new Range32.ptr(71087, 71093, 1), new Range32.ptr(71096, 71104, 1), new Range32.ptr(71132, 71133, 1), new Range32.ptr(71216, 71232, 1), new Range32.ptr(71339, 71351, 1), new Range32.ptr(71453, 71467, 1), new Range32.ptr(72193, 72202, 1), new Range32.ptr(72243, 72249, 1), new Range32.ptr(72251, 72254, 1), new Range32.ptr(72263, 72273, 10), new Range32.ptr(72274, 72283, 1), new Range32.ptr(72330, 72345, 1), new Range32.ptr(72751, 72758, 1), new Range32.ptr(72760, 72767, 1), new Range32.ptr(72850, 72871, 1), new Range32.ptr(72873, 72886, 1), new Range32.ptr(73009, 73014, 1), new Range32.ptr(73018, 73020, 2), new Range32.ptr(73021, 73023, 2), new Range32.ptr(73024, 73029, 1), new Range32.ptr(73031, 92912, 19881), new Range32.ptr(92913, 92916, 1), new Range32.ptr(92976, 92982, 1), new Range32.ptr(94033, 94078, 1), new Range32.ptr(94095, 94098, 1), new Range32.ptr(113821, 113822, 1), new Range32.ptr(119141, 119145, 1), new Range32.ptr(119149, 119154, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(119362, 119364, 1), new Range32.ptr(121344, 121398, 1), new Range32.ptr(121403, 121452, 1), new Range32.ptr(121461, 121476, 15), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1), new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1), new Range32.ptr(125136, 125142, 1), new Range32.ptr(125252, 125258, 1), new Range32.ptr(917760, 917999, 1)]), 0); - _Mc = new RangeTable.ptr(new sliceType([new Range16.ptr(2307, 2363, 56), new Range16.ptr(2366, 2368, 1), new Range16.ptr(2377, 2380, 1), new Range16.ptr(2382, 2383, 1), new Range16.ptr(2434, 2435, 1), new Range16.ptr(2494, 2496, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2508, 1), new Range16.ptr(2519, 2563, 44), new Range16.ptr(2622, 2624, 1), new Range16.ptr(2691, 2750, 59), new Range16.ptr(2751, 2752, 1), new Range16.ptr(2761, 2763, 2), new Range16.ptr(2764, 2818, 54), new Range16.ptr(2819, 2878, 59), new Range16.ptr(2880, 2887, 7), new Range16.ptr(2888, 2891, 3), new Range16.ptr(2892, 2903, 11), new Range16.ptr(3006, 3007, 1), new Range16.ptr(3009, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3020, 1), new Range16.ptr(3031, 3073, 42), new Range16.ptr(3074, 3075, 1), new Range16.ptr(3137, 3140, 1), new Range16.ptr(3202, 3203, 1), new Range16.ptr(3262, 3264, 2), new Range16.ptr(3265, 3268, 1), new Range16.ptr(3271, 3272, 1), new Range16.ptr(3274, 3275, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3330, 3331, 1), new Range16.ptr(3390, 3392, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3404, 1), new Range16.ptr(3415, 3458, 43), new Range16.ptr(3459, 3535, 76), new Range16.ptr(3536, 3537, 1), new Range16.ptr(3544, 3551, 1), new Range16.ptr(3570, 3571, 1), new Range16.ptr(3902, 3903, 1), new Range16.ptr(3967, 4139, 172), new Range16.ptr(4140, 4145, 5), new Range16.ptr(4152, 4155, 3), new Range16.ptr(4156, 4182, 26), new Range16.ptr(4183, 4194, 11), new Range16.ptr(4195, 4196, 1), new Range16.ptr(4199, 4205, 1), new Range16.ptr(4227, 4228, 1), new Range16.ptr(4231, 4236, 1), new Range16.ptr(4239, 4250, 11), new Range16.ptr(4251, 4252, 1), new Range16.ptr(6070, 6078, 8), new Range16.ptr(6079, 6085, 1), new Range16.ptr(6087, 6088, 1), new Range16.ptr(6435, 6438, 1), new Range16.ptr(6441, 6443, 1), new Range16.ptr(6448, 6449, 1), new Range16.ptr(6451, 6456, 1), new Range16.ptr(6681, 6682, 1), new Range16.ptr(6741, 6743, 2), new Range16.ptr(6753, 6755, 2), new Range16.ptr(6756, 6765, 9), new Range16.ptr(6766, 6770, 1), new Range16.ptr(6916, 6965, 49), new Range16.ptr(6971, 6973, 2), new Range16.ptr(6974, 6977, 1), new Range16.ptr(6979, 6980, 1), new Range16.ptr(7042, 7073, 31), new Range16.ptr(7078, 7079, 1), new Range16.ptr(7082, 7143, 61), new Range16.ptr(7146, 7148, 1), new Range16.ptr(7150, 7154, 4), new Range16.ptr(7155, 7204, 49), new Range16.ptr(7205, 7211, 1), new Range16.ptr(7220, 7221, 1), new Range16.ptr(7393, 7410, 17), new Range16.ptr(7411, 7415, 4), new Range16.ptr(12334, 12335, 1), new Range16.ptr(43043, 43044, 1), new Range16.ptr(43047, 43136, 89), new Range16.ptr(43137, 43188, 51), new Range16.ptr(43189, 43203, 1), new Range16.ptr(43346, 43347, 1), new Range16.ptr(43395, 43444, 49), new Range16.ptr(43445, 43450, 5), new Range16.ptr(43451, 43453, 2), new Range16.ptr(43454, 43456, 1), new Range16.ptr(43567, 43568, 1), new Range16.ptr(43571, 43572, 1), new Range16.ptr(43597, 43643, 46), new Range16.ptr(43645, 43755, 110), new Range16.ptr(43758, 43759, 1), new Range16.ptr(43765, 44003, 238), new Range16.ptr(44004, 44006, 2), new Range16.ptr(44007, 44009, 2), new Range16.ptr(44010, 44012, 2)]), new sliceType$1([new Range32.ptr(69632, 69634, 2), new Range32.ptr(69762, 69808, 46), new Range32.ptr(69809, 69810, 1), new Range32.ptr(69815, 69816, 1), new Range32.ptr(69932, 70018, 86), new Range32.ptr(70067, 70069, 1), new Range32.ptr(70079, 70080, 1), new Range32.ptr(70188, 70190, 1), new Range32.ptr(70194, 70195, 1), new Range32.ptr(70197, 70368, 171), new Range32.ptr(70369, 70370, 1), new Range32.ptr(70402, 70403, 1), new Range32.ptr(70462, 70463, 1), new Range32.ptr(70465, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70487, 70498, 11), new Range32.ptr(70499, 70709, 210), new Range32.ptr(70710, 70711, 1), new Range32.ptr(70720, 70721, 1), new Range32.ptr(70725, 70832, 107), new Range32.ptr(70833, 70834, 1), new Range32.ptr(70841, 70843, 2), new Range32.ptr(70844, 70846, 1), new Range32.ptr(70849, 71087, 238), new Range32.ptr(71088, 71089, 1), new Range32.ptr(71096, 71099, 1), new Range32.ptr(71102, 71216, 114), new Range32.ptr(71217, 71218, 1), new Range32.ptr(71227, 71228, 1), new Range32.ptr(71230, 71340, 110), new Range32.ptr(71342, 71343, 1), new Range32.ptr(71350, 71456, 106), new Range32.ptr(71457, 71462, 5), new Range32.ptr(72199, 72200, 1), new Range32.ptr(72249, 72279, 30), new Range32.ptr(72280, 72343, 63), new Range32.ptr(72751, 72766, 15), new Range32.ptr(72873, 72881, 8), new Range32.ptr(72884, 94033, 21149), new Range32.ptr(94034, 94078, 1), new Range32.ptr(119141, 119142, 1), new Range32.ptr(119149, 119154, 1)]), 0); - _Me = new RangeTable.ptr(new sliceType([new Range16.ptr(1160, 1161, 1), new Range16.ptr(6846, 8413, 1567), new Range16.ptr(8414, 8416, 1), new Range16.ptr(8418, 8420, 1), new Range16.ptr(42608, 42610, 1)]), sliceType$1.nil, 0); - _Mn = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1155, 1159, 1), new Range16.ptr(1425, 1469, 1), new Range16.ptr(1471, 1473, 2), new Range16.ptr(1474, 1476, 2), new Range16.ptr(1477, 1479, 2), new Range16.ptr(1552, 1562, 1), new Range16.ptr(1611, 1631, 1), new Range16.ptr(1648, 1750, 102), new Range16.ptr(1751, 1756, 1), new Range16.ptr(1759, 1764, 1), new Range16.ptr(1767, 1768, 1), new Range16.ptr(1770, 1773, 1), new Range16.ptr(1809, 1840, 31), new Range16.ptr(1841, 1866, 1), new Range16.ptr(1958, 1968, 1), new Range16.ptr(2027, 2035, 1), new Range16.ptr(2070, 2073, 1), new Range16.ptr(2075, 2083, 1), new Range16.ptr(2085, 2087, 1), new Range16.ptr(2089, 2093, 1), new Range16.ptr(2137, 2139, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2306, 1), new Range16.ptr(2362, 2364, 2), new Range16.ptr(2369, 2376, 1), new Range16.ptr(2381, 2385, 4), new Range16.ptr(2386, 2391, 1), new Range16.ptr(2402, 2403, 1), new Range16.ptr(2433, 2492, 59), new Range16.ptr(2497, 2500, 1), new Range16.ptr(2509, 2530, 21), new Range16.ptr(2531, 2561, 30), new Range16.ptr(2562, 2620, 58), new Range16.ptr(2625, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2672, 31), new Range16.ptr(2673, 2677, 4), new Range16.ptr(2689, 2690, 1), new Range16.ptr(2748, 2753, 5), new Range16.ptr(2754, 2757, 1), new Range16.ptr(2759, 2760, 1), new Range16.ptr(2765, 2786, 21), new Range16.ptr(2787, 2810, 23), new Range16.ptr(2811, 2815, 1), new Range16.ptr(2817, 2876, 59), new Range16.ptr(2879, 2881, 2), new Range16.ptr(2882, 2884, 1), new Range16.ptr(2893, 2902, 9), new Range16.ptr(2914, 2915, 1), new Range16.ptr(2946, 3008, 62), new Range16.ptr(3021, 3072, 51), new Range16.ptr(3134, 3136, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3170, 3171, 1), new Range16.ptr(3201, 3260, 59), new Range16.ptr(3263, 3270, 7), new Range16.ptr(3276, 3277, 1), new Range16.ptr(3298, 3299, 1), new Range16.ptr(3328, 3329, 1), new Range16.ptr(3387, 3388, 1), new Range16.ptr(3393, 3396, 1), new Range16.ptr(3405, 3426, 21), new Range16.ptr(3427, 3530, 103), new Range16.ptr(3538, 3540, 1), new Range16.ptr(3542, 3633, 91), new Range16.ptr(3636, 3642, 1), new Range16.ptr(3655, 3662, 1), new Range16.ptr(3761, 3764, 3), new Range16.ptr(3765, 3769, 1), new Range16.ptr(3771, 3772, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3864, 3865, 1), new Range16.ptr(3893, 3897, 2), new Range16.ptr(3953, 3966, 1), new Range16.ptr(3968, 3972, 1), new Range16.ptr(3974, 3975, 1), new Range16.ptr(3981, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4038, 4141, 103), new Range16.ptr(4142, 4144, 1), new Range16.ptr(4146, 4151, 1), new Range16.ptr(4153, 4154, 1), new Range16.ptr(4157, 4158, 1), new Range16.ptr(4184, 4185, 1), new Range16.ptr(4190, 4192, 1), new Range16.ptr(4209, 4212, 1), new Range16.ptr(4226, 4229, 3), new Range16.ptr(4230, 4237, 7), new Range16.ptr(4253, 4957, 704), new Range16.ptr(4958, 4959, 1), new Range16.ptr(5906, 5908, 1), new Range16.ptr(5938, 5940, 1), new Range16.ptr(5970, 5971, 1), new Range16.ptr(6002, 6003, 1), new Range16.ptr(6068, 6069, 1), new Range16.ptr(6071, 6077, 1), new Range16.ptr(6086, 6089, 3), new Range16.ptr(6090, 6099, 1), new Range16.ptr(6109, 6155, 46), new Range16.ptr(6156, 6157, 1), new Range16.ptr(6277, 6278, 1), new Range16.ptr(6313, 6432, 119), new Range16.ptr(6433, 6434, 1), new Range16.ptr(6439, 6440, 1), new Range16.ptr(6450, 6457, 7), new Range16.ptr(6458, 6459, 1), new Range16.ptr(6679, 6680, 1), new Range16.ptr(6683, 6742, 59), new Range16.ptr(6744, 6750, 1), new Range16.ptr(6752, 6754, 2), new Range16.ptr(6757, 6764, 1), new Range16.ptr(6771, 6780, 1), new Range16.ptr(6783, 6832, 49), new Range16.ptr(6833, 6845, 1), new Range16.ptr(6912, 6915, 1), new Range16.ptr(6964, 6966, 2), new Range16.ptr(6967, 6970, 1), new Range16.ptr(6972, 6978, 6), new Range16.ptr(7019, 7027, 1), new Range16.ptr(7040, 7041, 1), new Range16.ptr(7074, 7077, 1), new Range16.ptr(7080, 7081, 1), new Range16.ptr(7083, 7085, 1), new Range16.ptr(7142, 7144, 2), new Range16.ptr(7145, 7149, 4), new Range16.ptr(7151, 7153, 1), new Range16.ptr(7212, 7219, 1), new Range16.ptr(7222, 7223, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7392, 1), new Range16.ptr(7394, 7400, 1), new Range16.ptr(7405, 7412, 7), new Range16.ptr(7416, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8400, 8412, 1), new Range16.ptr(8417, 8421, 4), new Range16.ptr(8422, 8432, 1), new Range16.ptr(11503, 11505, 1), new Range16.ptr(11647, 11744, 97), new Range16.ptr(11745, 11775, 1), new Range16.ptr(12330, 12333, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(42607, 42612, 5), new Range16.ptr(42613, 42621, 1), new Range16.ptr(42654, 42655, 1), new Range16.ptr(42736, 42737, 1), new Range16.ptr(43010, 43014, 4), new Range16.ptr(43019, 43045, 26), new Range16.ptr(43046, 43204, 158), new Range16.ptr(43205, 43232, 27), new Range16.ptr(43233, 43249, 1), new Range16.ptr(43302, 43309, 1), new Range16.ptr(43335, 43345, 1), new Range16.ptr(43392, 43394, 1), new Range16.ptr(43443, 43446, 3), new Range16.ptr(43447, 43449, 1), new Range16.ptr(43452, 43493, 41), new Range16.ptr(43561, 43566, 1), new Range16.ptr(43569, 43570, 1), new Range16.ptr(43573, 43574, 1), new Range16.ptr(43587, 43596, 9), new Range16.ptr(43644, 43696, 52), new Range16.ptr(43698, 43700, 1), new Range16.ptr(43703, 43704, 1), new Range16.ptr(43710, 43711, 1), new Range16.ptr(43713, 43756, 43), new Range16.ptr(43757, 43766, 9), new Range16.ptr(44005, 44008, 3), new Range16.ptr(44013, 64286, 20273), new Range16.ptr(65024, 65039, 1), new Range16.ptr(65056, 65071, 1)]), new sliceType$1([new Range32.ptr(66045, 66272, 227), new Range32.ptr(66422, 66426, 1), new Range32.ptr(68097, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68111, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68325, 166), new Range32.ptr(68326, 69633, 1307), new Range32.ptr(69688, 69702, 1), new Range32.ptr(69759, 69761, 1), new Range32.ptr(69811, 69814, 1), new Range32.ptr(69817, 69818, 1), new Range32.ptr(69888, 69890, 1), new Range32.ptr(69927, 69931, 1), new Range32.ptr(69933, 69940, 1), new Range32.ptr(70003, 70016, 13), new Range32.ptr(70017, 70070, 53), new Range32.ptr(70071, 70078, 1), new Range32.ptr(70090, 70092, 1), new Range32.ptr(70191, 70193, 1), new Range32.ptr(70196, 70198, 2), new Range32.ptr(70199, 70206, 7), new Range32.ptr(70367, 70371, 4), new Range32.ptr(70372, 70378, 1), new Range32.ptr(70400, 70401, 1), new Range32.ptr(70460, 70464, 4), new Range32.ptr(70502, 70508, 1), new Range32.ptr(70512, 70516, 1), new Range32.ptr(70712, 70719, 1), new Range32.ptr(70722, 70724, 1), new Range32.ptr(70726, 70835, 109), new Range32.ptr(70836, 70840, 1), new Range32.ptr(70842, 70847, 5), new Range32.ptr(70848, 70850, 2), new Range32.ptr(70851, 71090, 239), new Range32.ptr(71091, 71093, 1), new Range32.ptr(71100, 71101, 1), new Range32.ptr(71103, 71104, 1), new Range32.ptr(71132, 71133, 1), new Range32.ptr(71219, 71226, 1), new Range32.ptr(71229, 71231, 2), new Range32.ptr(71232, 71339, 107), new Range32.ptr(71341, 71344, 3), new Range32.ptr(71345, 71349, 1), new Range32.ptr(71351, 71453, 102), new Range32.ptr(71454, 71455, 1), new Range32.ptr(71458, 71461, 1), new Range32.ptr(71463, 71467, 1), new Range32.ptr(72193, 72198, 1), new Range32.ptr(72201, 72202, 1), new Range32.ptr(72243, 72248, 1), new Range32.ptr(72251, 72254, 1), new Range32.ptr(72263, 72273, 10), new Range32.ptr(72274, 72278, 1), new Range32.ptr(72281, 72283, 1), new Range32.ptr(72330, 72342, 1), new Range32.ptr(72344, 72345, 1), new Range32.ptr(72752, 72758, 1), new Range32.ptr(72760, 72765, 1), new Range32.ptr(72767, 72850, 83), new Range32.ptr(72851, 72871, 1), new Range32.ptr(72874, 72880, 1), new Range32.ptr(72882, 72883, 1), new Range32.ptr(72885, 72886, 1), new Range32.ptr(73009, 73014, 1), new Range32.ptr(73018, 73020, 2), new Range32.ptr(73021, 73023, 2), new Range32.ptr(73024, 73029, 1), new Range32.ptr(73031, 92912, 19881), new Range32.ptr(92913, 92916, 1), new Range32.ptr(92976, 92982, 1), new Range32.ptr(94095, 94098, 1), new Range32.ptr(113821, 113822, 1), new Range32.ptr(119143, 119145, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(119362, 119364, 1), new Range32.ptr(121344, 121398, 1), new Range32.ptr(121403, 121452, 1), new Range32.ptr(121461, 121476, 15), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1), new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1), new Range32.ptr(125136, 125142, 1), new Range32.ptr(125252, 125258, 1), new Range32.ptr(917760, 917999, 1)]), 0); - _N = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(178, 179, 1), new Range16.ptr(185, 188, 3), new Range16.ptr(189, 190, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2548, 2553, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(2930, 2935, 1), new Range16.ptr(3046, 3058, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3192, 3198, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3416, 3422, 1), new Range16.ptr(3430, 3448, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3891, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(4969, 4988, 1), new Range16.ptr(5870, 5872, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6618, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(8304, 8308, 4), new Range16.ptr(8309, 8313, 1), new Range16.ptr(8320, 8329, 1), new Range16.ptr(8528, 8578, 1), new Range16.ptr(8581, 8585, 1), new Range16.ptr(9312, 9371, 1), new Range16.ptr(9450, 9471, 1), new Range16.ptr(10102, 10131, 1), new Range16.ptr(11517, 12295, 778), new Range16.ptr(12321, 12329, 1), new Range16.ptr(12344, 12346, 1), new Range16.ptr(12690, 12693, 1), new Range16.ptr(12832, 12841, 1), new Range16.ptr(12872, 12879, 1), new Range16.ptr(12881, 12895, 1), new Range16.ptr(12928, 12937, 1), new Range16.ptr(12977, 12991, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(42726, 42735, 1), new Range16.ptr(43056, 43061, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(65799, 65843, 1), new Range32.ptr(65856, 65912, 1), new Range32.ptr(65930, 65931, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(66336, 66339, 1), new Range32.ptr(66369, 66378, 9), new Range32.ptr(66513, 66517, 1), new Range32.ptr(66720, 66729, 1), new Range32.ptr(67672, 67679, 1), new Range32.ptr(67705, 67711, 1), new Range32.ptr(67751, 67759, 1), new Range32.ptr(67835, 67839, 1), new Range32.ptr(67862, 67867, 1), new Range32.ptr(68028, 68029, 1), new Range32.ptr(68032, 68047, 1), new Range32.ptr(68050, 68095, 1), new Range32.ptr(68160, 68167, 1), new Range32.ptr(68221, 68222, 1), new Range32.ptr(68253, 68255, 1), new Range32.ptr(68331, 68335, 1), new Range32.ptr(68440, 68447, 1), new Range32.ptr(68472, 68479, 1), new Range32.ptr(68521, 68527, 1), new Range32.ptr(68858, 68863, 1), new Range32.ptr(69216, 69246, 1), new Range32.ptr(69714, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70113, 70132, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70736, 70745, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71472, 71483, 1), new Range32.ptr(71904, 71922, 1), new Range32.ptr(72784, 72812, 1), new Range32.ptr(73040, 73049, 1), new Range32.ptr(74752, 74862, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(125127, 125135, 1), new Range32.ptr(125264, 125273, 1), new Range32.ptr(127232, 127244, 1)]), 4); - _Nd = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(3046, 3055, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3430, 3439, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3881, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6617, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(66720, 66729, 1), new Range32.ptr(69734, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70736, 70745, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71472, 71481, 1), new Range32.ptr(71904, 71913, 1), new Range32.ptr(72784, 72793, 1), new Range32.ptr(73040, 73049, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(125264, 125273, 1)]), 1); - _Nl = new RangeTable.ptr(new sliceType([new Range16.ptr(5870, 5872, 1), new Range16.ptr(8544, 8578, 1), new Range16.ptr(8581, 8584, 1), new Range16.ptr(12295, 12321, 26), new Range16.ptr(12322, 12329, 1), new Range16.ptr(12344, 12346, 1), new Range16.ptr(42726, 42735, 1)]), new sliceType$1([new Range32.ptr(65856, 65908, 1), new Range32.ptr(66369, 66378, 9), new Range32.ptr(66513, 66517, 1), new Range32.ptr(74752, 74862, 1)]), 0); - _No = new RangeTable.ptr(new sliceType([new Range16.ptr(178, 179, 1), new Range16.ptr(185, 188, 3), new Range16.ptr(189, 190, 1), new Range16.ptr(2548, 2553, 1), new Range16.ptr(2930, 2935, 1), new Range16.ptr(3056, 3058, 1), new Range16.ptr(3192, 3198, 1), new Range16.ptr(3416, 3422, 1), new Range16.ptr(3440, 3448, 1), new Range16.ptr(3882, 3891, 1), new Range16.ptr(4969, 4988, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6618, 8304, 1686), new Range16.ptr(8308, 8313, 1), new Range16.ptr(8320, 8329, 1), new Range16.ptr(8528, 8543, 1), new Range16.ptr(8585, 9312, 727), new Range16.ptr(9313, 9371, 1), new Range16.ptr(9450, 9471, 1), new Range16.ptr(10102, 10131, 1), new Range16.ptr(11517, 12690, 1173), new Range16.ptr(12691, 12693, 1), new Range16.ptr(12832, 12841, 1), new Range16.ptr(12872, 12879, 1), new Range16.ptr(12881, 12895, 1), new Range16.ptr(12928, 12937, 1), new Range16.ptr(12977, 12991, 1), new Range16.ptr(43056, 43061, 1)]), new sliceType$1([new Range32.ptr(65799, 65843, 1), new Range32.ptr(65909, 65912, 1), new Range32.ptr(65930, 65931, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(66336, 66339, 1), new Range32.ptr(67672, 67679, 1), new Range32.ptr(67705, 67711, 1), new Range32.ptr(67751, 67759, 1), new Range32.ptr(67835, 67839, 1), new Range32.ptr(67862, 67867, 1), new Range32.ptr(68028, 68029, 1), new Range32.ptr(68032, 68047, 1), new Range32.ptr(68050, 68095, 1), new Range32.ptr(68160, 68167, 1), new Range32.ptr(68221, 68222, 1), new Range32.ptr(68253, 68255, 1), new Range32.ptr(68331, 68335, 1), new Range32.ptr(68440, 68447, 1), new Range32.ptr(68472, 68479, 1), new Range32.ptr(68521, 68527, 1), new Range32.ptr(68858, 68863, 1), new Range32.ptr(69216, 69246, 1), new Range32.ptr(69714, 69733, 1), new Range32.ptr(70113, 70132, 1), new Range32.ptr(71482, 71483, 1), new Range32.ptr(71914, 71922, 1), new Range32.ptr(72794, 72812, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(125127, 125135, 1), new Range32.ptr(127232, 127244, 1)]), 3); - _P = new RangeTable.ptr(new sliceType([new Range16.ptr(33, 35, 1), new Range16.ptr(37, 42, 1), new Range16.ptr(44, 47, 1), new Range16.ptr(58, 59, 1), new Range16.ptr(63, 64, 1), new Range16.ptr(91, 93, 1), new Range16.ptr(95, 123, 28), new Range16.ptr(125, 161, 36), new Range16.ptr(167, 171, 4), new Range16.ptr(182, 183, 1), new Range16.ptr(187, 191, 4), new Range16.ptr(894, 903, 9), new Range16.ptr(1370, 1375, 1), new Range16.ptr(1417, 1418, 1), new Range16.ptr(1470, 1472, 2), new Range16.ptr(1475, 1478, 3), new Range16.ptr(1523, 1524, 1), new Range16.ptr(1545, 1546, 1), new Range16.ptr(1548, 1549, 1), new Range16.ptr(1563, 1566, 3), new Range16.ptr(1567, 1642, 75), new Range16.ptr(1643, 1645, 1), new Range16.ptr(1748, 1792, 44), new Range16.ptr(1793, 1805, 1), new Range16.ptr(2039, 2041, 1), new Range16.ptr(2096, 2110, 1), new Range16.ptr(2142, 2404, 262), new Range16.ptr(2405, 2416, 11), new Range16.ptr(2557, 2800, 243), new Range16.ptr(3572, 3663, 91), new Range16.ptr(3674, 3675, 1), new Range16.ptr(3844, 3858, 1), new Range16.ptr(3860, 3898, 38), new Range16.ptr(3899, 3901, 1), new Range16.ptr(3973, 4048, 75), new Range16.ptr(4049, 4052, 1), new Range16.ptr(4057, 4058, 1), new Range16.ptr(4170, 4175, 1), new Range16.ptr(4347, 4960, 613), new Range16.ptr(4961, 4968, 1), new Range16.ptr(5120, 5741, 621), new Range16.ptr(5742, 5787, 45), new Range16.ptr(5788, 5867, 79), new Range16.ptr(5868, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6100, 6102, 1), new Range16.ptr(6104, 6106, 1), new Range16.ptr(6144, 6154, 1), new Range16.ptr(6468, 6469, 1), new Range16.ptr(6686, 6687, 1), new Range16.ptr(6816, 6822, 1), new Range16.ptr(6824, 6829, 1), new Range16.ptr(7002, 7008, 1), new Range16.ptr(7164, 7167, 1), new Range16.ptr(7227, 7231, 1), new Range16.ptr(7294, 7295, 1), new Range16.ptr(7360, 7367, 1), new Range16.ptr(7379, 8208, 829), new Range16.ptr(8209, 8231, 1), new Range16.ptr(8240, 8259, 1), new Range16.ptr(8261, 8273, 1), new Range16.ptr(8275, 8286, 1), new Range16.ptr(8317, 8318, 1), new Range16.ptr(8333, 8334, 1), new Range16.ptr(8968, 8971, 1), new Range16.ptr(9001, 9002, 1), new Range16.ptr(10088, 10101, 1), new Range16.ptr(10181, 10182, 1), new Range16.ptr(10214, 10223, 1), new Range16.ptr(10627, 10648, 1), new Range16.ptr(10712, 10715, 1), new Range16.ptr(10748, 10749, 1), new Range16.ptr(11513, 11516, 1), new Range16.ptr(11518, 11519, 1), new Range16.ptr(11632, 11776, 144), new Range16.ptr(11777, 11822, 1), new Range16.ptr(11824, 11849, 1), new Range16.ptr(12289, 12291, 1), new Range16.ptr(12296, 12305, 1), new Range16.ptr(12308, 12319, 1), new Range16.ptr(12336, 12349, 13), new Range16.ptr(12448, 12539, 91), new Range16.ptr(42238, 42239, 1), new Range16.ptr(42509, 42511, 1), new Range16.ptr(42611, 42622, 11), new Range16.ptr(42738, 42743, 1), new Range16.ptr(43124, 43127, 1), new Range16.ptr(43214, 43215, 1), new Range16.ptr(43256, 43258, 1), new Range16.ptr(43260, 43310, 50), new Range16.ptr(43311, 43359, 48), new Range16.ptr(43457, 43469, 1), new Range16.ptr(43486, 43487, 1), new Range16.ptr(43612, 43615, 1), new Range16.ptr(43742, 43743, 1), new Range16.ptr(43760, 43761, 1), new Range16.ptr(44011, 64830, 20819), new Range16.ptr(64831, 65040, 209), new Range16.ptr(65041, 65049, 1), new Range16.ptr(65072, 65106, 1), new Range16.ptr(65108, 65121, 1), new Range16.ptr(65123, 65128, 5), new Range16.ptr(65130, 65131, 1), new Range16.ptr(65281, 65283, 1), new Range16.ptr(65285, 65290, 1), new Range16.ptr(65292, 65295, 1), new Range16.ptr(65306, 65307, 1), new Range16.ptr(65311, 65312, 1), new Range16.ptr(65339, 65341, 1), new Range16.ptr(65343, 65371, 28), new Range16.ptr(65373, 65375, 2), new Range16.ptr(65376, 65381, 1)]), new sliceType$1([new Range32.ptr(65792, 65794, 1), new Range32.ptr(66463, 66512, 49), new Range32.ptr(66927, 67671, 744), new Range32.ptr(67871, 67903, 32), new Range32.ptr(68176, 68184, 1), new Range32.ptr(68223, 68336, 113), new Range32.ptr(68337, 68342, 1), new Range32.ptr(68409, 68415, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(69703, 69709, 1), new Range32.ptr(69819, 69820, 1), new Range32.ptr(69822, 69825, 1), new Range32.ptr(69952, 69955, 1), new Range32.ptr(70004, 70005, 1), new Range32.ptr(70085, 70089, 1), new Range32.ptr(70093, 70107, 14), new Range32.ptr(70109, 70111, 1), new Range32.ptr(70200, 70205, 1), new Range32.ptr(70313, 70731, 418), new Range32.ptr(70732, 70735, 1), new Range32.ptr(70747, 70749, 2), new Range32.ptr(70854, 71105, 251), new Range32.ptr(71106, 71127, 1), new Range32.ptr(71233, 71235, 1), new Range32.ptr(71264, 71276, 1), new Range32.ptr(71484, 71486, 1), new Range32.ptr(72255, 72262, 1), new Range32.ptr(72346, 72348, 1), new Range32.ptr(72350, 72354, 1), new Range32.ptr(72769, 72773, 1), new Range32.ptr(72816, 72817, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(92782, 92783, 1), new Range32.ptr(92917, 92983, 66), new Range32.ptr(92984, 92987, 1), new Range32.ptr(92996, 113823, 20827), new Range32.ptr(121479, 121483, 1), new Range32.ptr(125278, 125279, 1)]), 11); - _Pc = new RangeTable.ptr(new sliceType([new Range16.ptr(95, 8255, 8160), new Range16.ptr(8256, 8276, 20), new Range16.ptr(65075, 65076, 1), new Range16.ptr(65101, 65103, 1), new Range16.ptr(65343, 65343, 1)]), sliceType$1.nil, 0); - _Pd = new RangeTable.ptr(new sliceType([new Range16.ptr(45, 1418, 1373), new Range16.ptr(1470, 5120, 3650), new Range16.ptr(6150, 8208, 2058), new Range16.ptr(8209, 8213, 1), new Range16.ptr(11799, 11802, 3), new Range16.ptr(11834, 11835, 1), new Range16.ptr(11840, 12316, 476), new Range16.ptr(12336, 12448, 112), new Range16.ptr(65073, 65074, 1), new Range16.ptr(65112, 65123, 11), new Range16.ptr(65293, 65293, 1)]), sliceType$1.nil, 0); - _Pe = new RangeTable.ptr(new sliceType([new Range16.ptr(41, 93, 52), new Range16.ptr(125, 3899, 3774), new Range16.ptr(3901, 5788, 1887), new Range16.ptr(8262, 8318, 56), new Range16.ptr(8334, 8969, 635), new Range16.ptr(8971, 9002, 31), new Range16.ptr(10089, 10101, 2), new Range16.ptr(10182, 10215, 33), new Range16.ptr(10217, 10223, 2), new Range16.ptr(10628, 10648, 2), new Range16.ptr(10713, 10715, 2), new Range16.ptr(10749, 11811, 1062), new Range16.ptr(11813, 11817, 2), new Range16.ptr(12297, 12305, 2), new Range16.ptr(12309, 12315, 2), new Range16.ptr(12318, 12319, 1), new Range16.ptr(64830, 65048, 218), new Range16.ptr(65078, 65092, 2), new Range16.ptr(65096, 65114, 18), new Range16.ptr(65116, 65118, 2), new Range16.ptr(65289, 65341, 52), new Range16.ptr(65373, 65379, 3)]), sliceType$1.nil, 1); - _Pf = new RangeTable.ptr(new sliceType([new Range16.ptr(187, 8217, 8030), new Range16.ptr(8221, 8250, 29), new Range16.ptr(11779, 11781, 2), new Range16.ptr(11786, 11789, 3), new Range16.ptr(11805, 11809, 4)]), sliceType$1.nil, 0); - _Pi = new RangeTable.ptr(new sliceType([new Range16.ptr(171, 8216, 8045), new Range16.ptr(8219, 8220, 1), new Range16.ptr(8223, 8249, 26), new Range16.ptr(11778, 11780, 2), new Range16.ptr(11785, 11788, 3), new Range16.ptr(11804, 11808, 4)]), sliceType$1.nil, 0); - _Po = new RangeTable.ptr(new sliceType([new Range16.ptr(33, 35, 1), new Range16.ptr(37, 39, 1), new Range16.ptr(42, 46, 2), new Range16.ptr(47, 58, 11), new Range16.ptr(59, 63, 4), new Range16.ptr(64, 92, 28), new Range16.ptr(161, 167, 6), new Range16.ptr(182, 183, 1), new Range16.ptr(191, 894, 703), new Range16.ptr(903, 1370, 467), new Range16.ptr(1371, 1375, 1), new Range16.ptr(1417, 1472, 55), new Range16.ptr(1475, 1478, 3), new Range16.ptr(1523, 1524, 1), new Range16.ptr(1545, 1546, 1), new Range16.ptr(1548, 1549, 1), new Range16.ptr(1563, 1566, 3), new Range16.ptr(1567, 1642, 75), new Range16.ptr(1643, 1645, 1), new Range16.ptr(1748, 1792, 44), new Range16.ptr(1793, 1805, 1), new Range16.ptr(2039, 2041, 1), new Range16.ptr(2096, 2110, 1), new Range16.ptr(2142, 2404, 262), new Range16.ptr(2405, 2416, 11), new Range16.ptr(2557, 2800, 243), new Range16.ptr(3572, 3663, 91), new Range16.ptr(3674, 3675, 1), new Range16.ptr(3844, 3858, 1), new Range16.ptr(3860, 3973, 113), new Range16.ptr(4048, 4052, 1), new Range16.ptr(4057, 4058, 1), new Range16.ptr(4170, 4175, 1), new Range16.ptr(4347, 4960, 613), new Range16.ptr(4961, 4968, 1), new Range16.ptr(5741, 5742, 1), new Range16.ptr(5867, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6100, 6102, 1), new Range16.ptr(6104, 6106, 1), new Range16.ptr(6144, 6149, 1), new Range16.ptr(6151, 6154, 1), new Range16.ptr(6468, 6469, 1), new Range16.ptr(6686, 6687, 1), new Range16.ptr(6816, 6822, 1), new Range16.ptr(6824, 6829, 1), new Range16.ptr(7002, 7008, 1), new Range16.ptr(7164, 7167, 1), new Range16.ptr(7227, 7231, 1), new Range16.ptr(7294, 7295, 1), new Range16.ptr(7360, 7367, 1), new Range16.ptr(7379, 8214, 835), new Range16.ptr(8215, 8224, 9), new Range16.ptr(8225, 8231, 1), new Range16.ptr(8240, 8248, 1), new Range16.ptr(8251, 8254, 1), new Range16.ptr(8257, 8259, 1), new Range16.ptr(8263, 8273, 1), new Range16.ptr(8275, 8277, 2), new Range16.ptr(8278, 8286, 1), new Range16.ptr(11513, 11516, 1), new Range16.ptr(11518, 11519, 1), new Range16.ptr(11632, 11776, 144), new Range16.ptr(11777, 11782, 5), new Range16.ptr(11783, 11784, 1), new Range16.ptr(11787, 11790, 3), new Range16.ptr(11791, 11798, 1), new Range16.ptr(11800, 11801, 1), new Range16.ptr(11803, 11806, 3), new Range16.ptr(11807, 11818, 11), new Range16.ptr(11819, 11822, 1), new Range16.ptr(11824, 11833, 1), new Range16.ptr(11836, 11839, 1), new Range16.ptr(11841, 11843, 2), new Range16.ptr(11844, 11849, 1), new Range16.ptr(12289, 12291, 1), new Range16.ptr(12349, 12539, 190), new Range16.ptr(42238, 42239, 1), new Range16.ptr(42509, 42511, 1), new Range16.ptr(42611, 42622, 11), new Range16.ptr(42738, 42743, 1), new Range16.ptr(43124, 43127, 1), new Range16.ptr(43214, 43215, 1), new Range16.ptr(43256, 43258, 1), new Range16.ptr(43260, 43310, 50), new Range16.ptr(43311, 43359, 48), new Range16.ptr(43457, 43469, 1), new Range16.ptr(43486, 43487, 1), new Range16.ptr(43612, 43615, 1), new Range16.ptr(43742, 43743, 1), new Range16.ptr(43760, 43761, 1), new Range16.ptr(44011, 65040, 21029), new Range16.ptr(65041, 65046, 1), new Range16.ptr(65049, 65072, 23), new Range16.ptr(65093, 65094, 1), new Range16.ptr(65097, 65100, 1), new Range16.ptr(65104, 65106, 1), new Range16.ptr(65108, 65111, 1), new Range16.ptr(65119, 65121, 1), new Range16.ptr(65128, 65130, 2), new Range16.ptr(65131, 65281, 150), new Range16.ptr(65282, 65283, 1), new Range16.ptr(65285, 65287, 1), new Range16.ptr(65290, 65294, 2), new Range16.ptr(65295, 65306, 11), new Range16.ptr(65307, 65311, 4), new Range16.ptr(65312, 65340, 28), new Range16.ptr(65377, 65380, 3), new Range16.ptr(65381, 65381, 1)]), new sliceType$1([new Range32.ptr(65792, 65792, 1), new Range32.ptr(65793, 65794, 1), new Range32.ptr(66463, 66512, 49), new Range32.ptr(66927, 67671, 744), new Range32.ptr(67871, 67903, 32), new Range32.ptr(68176, 68184, 1), new Range32.ptr(68223, 68336, 113), new Range32.ptr(68337, 68342, 1), new Range32.ptr(68409, 68415, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(69703, 69709, 1), new Range32.ptr(69819, 69820, 1), new Range32.ptr(69822, 69825, 1), new Range32.ptr(69952, 69955, 1), new Range32.ptr(70004, 70005, 1), new Range32.ptr(70085, 70089, 1), new Range32.ptr(70093, 70107, 14), new Range32.ptr(70109, 70111, 1), new Range32.ptr(70200, 70205, 1), new Range32.ptr(70313, 70731, 418), new Range32.ptr(70732, 70735, 1), new Range32.ptr(70747, 70749, 2), new Range32.ptr(70854, 71105, 251), new Range32.ptr(71106, 71127, 1), new Range32.ptr(71233, 71235, 1), new Range32.ptr(71264, 71276, 1), new Range32.ptr(71484, 71486, 1), new Range32.ptr(72255, 72262, 1), new Range32.ptr(72346, 72348, 1), new Range32.ptr(72350, 72354, 1), new Range32.ptr(72769, 72773, 1), new Range32.ptr(72816, 72817, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(92782, 92783, 1), new Range32.ptr(92917, 92983, 66), new Range32.ptr(92984, 92987, 1), new Range32.ptr(92996, 113823, 20827), new Range32.ptr(121479, 121483, 1), new Range32.ptr(125278, 125279, 1)]), 8); - _Ps = new RangeTable.ptr(new sliceType([new Range16.ptr(40, 91, 51), new Range16.ptr(123, 3898, 3775), new Range16.ptr(3900, 5787, 1887), new Range16.ptr(8218, 8222, 4), new Range16.ptr(8261, 8317, 56), new Range16.ptr(8333, 8968, 635), new Range16.ptr(8970, 9001, 31), new Range16.ptr(10088, 10100, 2), new Range16.ptr(10181, 10214, 33), new Range16.ptr(10216, 10222, 2), new Range16.ptr(10627, 10647, 2), new Range16.ptr(10712, 10714, 2), new Range16.ptr(10748, 11810, 1062), new Range16.ptr(11812, 11816, 2), new Range16.ptr(11842, 12296, 454), new Range16.ptr(12298, 12304, 2), new Range16.ptr(12308, 12314, 2), new Range16.ptr(12317, 64831, 52514), new Range16.ptr(65047, 65077, 30), new Range16.ptr(65079, 65091, 2), new Range16.ptr(65095, 65113, 18), new Range16.ptr(65115, 65117, 2), new Range16.ptr(65288, 65339, 51), new Range16.ptr(65371, 65375, 4), new Range16.ptr(65378, 65378, 1)]), sliceType$1.nil, 1); - _S = new RangeTable.ptr(new sliceType([new Range16.ptr(36, 43, 7), new Range16.ptr(60, 62, 1), new Range16.ptr(94, 96, 2), new Range16.ptr(124, 126, 2), new Range16.ptr(162, 166, 1), new Range16.ptr(168, 169, 1), new Range16.ptr(172, 174, 2), new Range16.ptr(175, 177, 1), new Range16.ptr(180, 184, 4), new Range16.ptr(215, 247, 32), new Range16.ptr(706, 709, 1), new Range16.ptr(722, 735, 1), new Range16.ptr(741, 747, 1), new Range16.ptr(749, 751, 2), new Range16.ptr(752, 767, 1), new Range16.ptr(885, 900, 15), new Range16.ptr(901, 1014, 113), new Range16.ptr(1154, 1421, 267), new Range16.ptr(1422, 1423, 1), new Range16.ptr(1542, 1544, 1), new Range16.ptr(1547, 1550, 3), new Range16.ptr(1551, 1758, 207), new Range16.ptr(1769, 1789, 20), new Range16.ptr(1790, 2038, 248), new Range16.ptr(2546, 2547, 1), new Range16.ptr(2554, 2555, 1), new Range16.ptr(2801, 2928, 127), new Range16.ptr(3059, 3066, 1), new Range16.ptr(3199, 3407, 208), new Range16.ptr(3449, 3647, 198), new Range16.ptr(3841, 3843, 1), new Range16.ptr(3859, 3861, 2), new Range16.ptr(3862, 3863, 1), new Range16.ptr(3866, 3871, 1), new Range16.ptr(3892, 3896, 2), new Range16.ptr(4030, 4037, 1), new Range16.ptr(4039, 4044, 1), new Range16.ptr(4046, 4047, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4254, 4255, 1), new Range16.ptr(5008, 5017, 1), new Range16.ptr(6107, 6464, 357), new Range16.ptr(6622, 6655, 1), new Range16.ptr(7009, 7018, 1), new Range16.ptr(7028, 7036, 1), new Range16.ptr(8125, 8127, 2), new Range16.ptr(8128, 8129, 1), new Range16.ptr(8141, 8143, 1), new Range16.ptr(8157, 8159, 1), new Range16.ptr(8173, 8175, 1), new Range16.ptr(8189, 8190, 1), new Range16.ptr(8260, 8274, 14), new Range16.ptr(8314, 8316, 1), new Range16.ptr(8330, 8332, 1), new Range16.ptr(8352, 8383, 1), new Range16.ptr(8448, 8449, 1), new Range16.ptr(8451, 8454, 1), new Range16.ptr(8456, 8457, 1), new Range16.ptr(8468, 8470, 2), new Range16.ptr(8471, 8472, 1), new Range16.ptr(8478, 8483, 1), new Range16.ptr(8485, 8489, 2), new Range16.ptr(8494, 8506, 12), new Range16.ptr(8507, 8512, 5), new Range16.ptr(8513, 8516, 1), new Range16.ptr(8522, 8525, 1), new Range16.ptr(8527, 8586, 59), new Range16.ptr(8587, 8592, 5), new Range16.ptr(8593, 8967, 1), new Range16.ptr(8972, 9000, 1), new Range16.ptr(9003, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9372, 9449, 1), new Range16.ptr(9472, 10087, 1), new Range16.ptr(10132, 10180, 1), new Range16.ptr(10183, 10213, 1), new Range16.ptr(10224, 10626, 1), new Range16.ptr(10649, 10711, 1), new Range16.ptr(10716, 10747, 1), new Range16.ptr(10750, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11493, 11498, 1), new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12292, 12306, 14), new Range16.ptr(12307, 12320, 13), new Range16.ptr(12342, 12343, 1), new Range16.ptr(12350, 12351, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(12688, 12689, 1), new Range16.ptr(12694, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12842, 12871, 1), new Range16.ptr(12880, 12896, 16), new Range16.ptr(12897, 12927, 1), new Range16.ptr(12938, 12976, 1), new Range16.ptr(12992, 13054, 1), new Range16.ptr(13056, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42128, 42182, 1), new Range16.ptr(42752, 42774, 1), new Range16.ptr(42784, 42785, 1), new Range16.ptr(42889, 42890, 1), new Range16.ptr(43048, 43051, 1), new Range16.ptr(43062, 43065, 1), new Range16.ptr(43639, 43641, 1), new Range16.ptr(43867, 64297, 20430), new Range16.ptr(64434, 64449, 1), new Range16.ptr(65020, 65021, 1), new Range16.ptr(65122, 65124, 2), new Range16.ptr(65125, 65126, 1), new Range16.ptr(65129, 65284, 155), new Range16.ptr(65291, 65308, 17), new Range16.ptr(65309, 65310, 1), new Range16.ptr(65342, 65344, 2), new Range16.ptr(65372, 65374, 2), new Range16.ptr(65504, 65510, 1), new Range16.ptr(65512, 65518, 1), new Range16.ptr(65532, 65533, 1)]), new sliceType$1([new Range32.ptr(65847, 65855, 1), new Range32.ptr(65913, 65929, 1), new Range32.ptr(65932, 65934, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(65952, 66000, 48), new Range32.ptr(66001, 66044, 1), new Range32.ptr(67703, 67704, 1), new Range32.ptr(68296, 71487, 3191), new Range32.ptr(92988, 92991, 1), new Range32.ptr(92997, 113820, 20823), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119140, 1), new Range32.ptr(119146, 119148, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119296, 119361, 1), new Range32.ptr(119365, 119552, 187), new Range32.ptr(119553, 119638, 1), new Range32.ptr(120513, 120539, 26), new Range32.ptr(120571, 120597, 26), new Range32.ptr(120629, 120655, 26), new Range32.ptr(120687, 120713, 26), new Range32.ptr(120745, 120771, 26), new Range32.ptr(120832, 121343, 1), new Range32.ptr(121399, 121402, 1), new Range32.ptr(121453, 121460, 1), new Range32.ptr(121462, 121475, 1), new Range32.ptr(121477, 121478, 1), new Range32.ptr(126704, 126705, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129488, 16), new Range32.ptr(129489, 129510, 1)]), 10); - _Sc = new RangeTable.ptr(new sliceType([new Range16.ptr(36, 162, 126), new Range16.ptr(163, 165, 1), new Range16.ptr(1423, 1547, 124), new Range16.ptr(2546, 2547, 1), new Range16.ptr(2555, 2801, 246), new Range16.ptr(3065, 3647, 582), new Range16.ptr(6107, 8352, 2245), new Range16.ptr(8353, 8383, 1), new Range16.ptr(43064, 65020, 21956), new Range16.ptr(65129, 65284, 155), new Range16.ptr(65504, 65505, 1), new Range16.ptr(65509, 65510, 1)]), sliceType$1.nil, 2); - _Sk = new RangeTable.ptr(new sliceType([new Range16.ptr(94, 96, 2), new Range16.ptr(168, 175, 7), new Range16.ptr(180, 184, 4), new Range16.ptr(706, 709, 1), new Range16.ptr(722, 735, 1), new Range16.ptr(741, 747, 1), new Range16.ptr(749, 751, 2), new Range16.ptr(752, 767, 1), new Range16.ptr(885, 900, 15), new Range16.ptr(901, 8125, 7224), new Range16.ptr(8127, 8129, 1), new Range16.ptr(8141, 8143, 1), new Range16.ptr(8157, 8159, 1), new Range16.ptr(8173, 8175, 1), new Range16.ptr(8189, 8190, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(42752, 42774, 1), new Range16.ptr(42784, 42785, 1), new Range16.ptr(42889, 42890, 1), new Range16.ptr(43867, 64434, 20567), new Range16.ptr(64435, 64449, 1), new Range16.ptr(65342, 65344, 2), new Range16.ptr(65507, 65507, 1)]), new sliceType$1([new Range32.ptr(127995, 127995, 1), new Range32.ptr(127996, 127999, 1)]), 3); - _Sm = new RangeTable.ptr(new sliceType([new Range16.ptr(43, 60, 17), new Range16.ptr(61, 62, 1), new Range16.ptr(124, 126, 2), new Range16.ptr(172, 177, 5), new Range16.ptr(215, 247, 32), new Range16.ptr(1014, 1542, 528), new Range16.ptr(1543, 1544, 1), new Range16.ptr(8260, 8274, 14), new Range16.ptr(8314, 8316, 1), new Range16.ptr(8330, 8332, 1), new Range16.ptr(8472, 8512, 40), new Range16.ptr(8513, 8516, 1), new Range16.ptr(8523, 8592, 69), new Range16.ptr(8593, 8596, 1), new Range16.ptr(8602, 8603, 1), new Range16.ptr(8608, 8614, 3), new Range16.ptr(8622, 8654, 32), new Range16.ptr(8655, 8658, 3), new Range16.ptr(8660, 8692, 32), new Range16.ptr(8693, 8959, 1), new Range16.ptr(8992, 8993, 1), new Range16.ptr(9084, 9115, 31), new Range16.ptr(9116, 9139, 1), new Range16.ptr(9180, 9185, 1), new Range16.ptr(9655, 9665, 10), new Range16.ptr(9720, 9727, 1), new Range16.ptr(9839, 10176, 337), new Range16.ptr(10177, 10180, 1), new Range16.ptr(10183, 10213, 1), new Range16.ptr(10224, 10239, 1), new Range16.ptr(10496, 10626, 1), new Range16.ptr(10649, 10711, 1), new Range16.ptr(10716, 10747, 1), new Range16.ptr(10750, 11007, 1), new Range16.ptr(11056, 11076, 1), new Range16.ptr(11079, 11084, 1), new Range16.ptr(64297, 65122, 825), new Range16.ptr(65124, 65126, 1), new Range16.ptr(65291, 65308, 17), new Range16.ptr(65309, 65310, 1), new Range16.ptr(65372, 65374, 2), new Range16.ptr(65506, 65513, 7), new Range16.ptr(65514, 65516, 1)]), new sliceType$1([new Range32.ptr(120513, 120539, 26), new Range32.ptr(120571, 120597, 26), new Range32.ptr(120629, 120655, 26), new Range32.ptr(120687, 120713, 26), new Range32.ptr(120745, 120771, 26), new Range32.ptr(126704, 126705, 1)]), 5); - _So = new RangeTable.ptr(new sliceType([new Range16.ptr(166, 169, 3), new Range16.ptr(174, 176, 2), new Range16.ptr(1154, 1421, 267), new Range16.ptr(1422, 1550, 128), new Range16.ptr(1551, 1758, 207), new Range16.ptr(1769, 1789, 20), new Range16.ptr(1790, 2038, 248), new Range16.ptr(2554, 2928, 374), new Range16.ptr(3059, 3064, 1), new Range16.ptr(3066, 3199, 133), new Range16.ptr(3407, 3449, 42), new Range16.ptr(3841, 3843, 1), new Range16.ptr(3859, 3861, 2), new Range16.ptr(3862, 3863, 1), new Range16.ptr(3866, 3871, 1), new Range16.ptr(3892, 3896, 2), new Range16.ptr(4030, 4037, 1), new Range16.ptr(4039, 4044, 1), new Range16.ptr(4046, 4047, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4254, 4255, 1), new Range16.ptr(5008, 5017, 1), new Range16.ptr(6464, 6622, 158), new Range16.ptr(6623, 6655, 1), new Range16.ptr(7009, 7018, 1), new Range16.ptr(7028, 7036, 1), new Range16.ptr(8448, 8449, 1), new Range16.ptr(8451, 8454, 1), new Range16.ptr(8456, 8457, 1), new Range16.ptr(8468, 8470, 2), new Range16.ptr(8471, 8478, 7), new Range16.ptr(8479, 8483, 1), new Range16.ptr(8485, 8489, 2), new Range16.ptr(8494, 8506, 12), new Range16.ptr(8507, 8522, 15), new Range16.ptr(8524, 8525, 1), new Range16.ptr(8527, 8586, 59), new Range16.ptr(8587, 8597, 10), new Range16.ptr(8598, 8601, 1), new Range16.ptr(8604, 8607, 1), new Range16.ptr(8609, 8610, 1), new Range16.ptr(8612, 8613, 1), new Range16.ptr(8615, 8621, 1), new Range16.ptr(8623, 8653, 1), new Range16.ptr(8656, 8657, 1), new Range16.ptr(8659, 8661, 2), new Range16.ptr(8662, 8691, 1), new Range16.ptr(8960, 8967, 1), new Range16.ptr(8972, 8991, 1), new Range16.ptr(8994, 9000, 1), new Range16.ptr(9003, 9083, 1), new Range16.ptr(9085, 9114, 1), new Range16.ptr(9140, 9179, 1), new Range16.ptr(9186, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9372, 9449, 1), new Range16.ptr(9472, 9654, 1), new Range16.ptr(9656, 9664, 1), new Range16.ptr(9666, 9719, 1), new Range16.ptr(9728, 9838, 1), new Range16.ptr(9840, 10087, 1), new Range16.ptr(10132, 10175, 1), new Range16.ptr(10240, 10495, 1), new Range16.ptr(11008, 11055, 1), new Range16.ptr(11077, 11078, 1), new Range16.ptr(11085, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11493, 11498, 1), new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12292, 12306, 14), new Range16.ptr(12307, 12320, 13), new Range16.ptr(12342, 12343, 1), new Range16.ptr(12350, 12351, 1), new Range16.ptr(12688, 12689, 1), new Range16.ptr(12694, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12842, 12871, 1), new Range16.ptr(12880, 12896, 16), new Range16.ptr(12897, 12927, 1), new Range16.ptr(12938, 12976, 1), new Range16.ptr(12992, 13054, 1), new Range16.ptr(13056, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42128, 42182, 1), new Range16.ptr(43048, 43051, 1), new Range16.ptr(43062, 43063, 1), new Range16.ptr(43065, 43639, 574), new Range16.ptr(43640, 43641, 1), new Range16.ptr(65021, 65508, 487), new Range16.ptr(65512, 65517, 5), new Range16.ptr(65518, 65532, 14), new Range16.ptr(65533, 65533, 1)]), new sliceType$1([new Range32.ptr(65847, 65847, 1), new Range32.ptr(65848, 65855, 1), new Range32.ptr(65913, 65929, 1), new Range32.ptr(65932, 65934, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(65952, 66000, 48), new Range32.ptr(66001, 66044, 1), new Range32.ptr(67703, 67704, 1), new Range32.ptr(68296, 71487, 3191), new Range32.ptr(92988, 92991, 1), new Range32.ptr(92997, 113820, 20823), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119140, 1), new Range32.ptr(119146, 119148, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119296, 119361, 1), new Range32.ptr(119365, 119552, 187), new Range32.ptr(119553, 119638, 1), new Range32.ptr(120832, 121343, 1), new Range32.ptr(121399, 121402, 1), new Range32.ptr(121453, 121460, 1), new Range32.ptr(121462, 121475, 1), new Range32.ptr(121477, 121478, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 127994, 1), new Range32.ptr(128000, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129488, 16), new Range32.ptr(129489, 129510, 1)]), 2); - _Z = new RangeTable.ptr(new sliceType([new Range16.ptr(32, 160, 128), new Range16.ptr(5760, 8192, 2432), new Range16.ptr(8193, 8202, 1), new Range16.ptr(8232, 8233, 1), new Range16.ptr(8239, 8287, 48), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 1); - _Zl = new RangeTable.ptr(new sliceType([new Range16.ptr(8232, 8232, 1)]), sliceType$1.nil, 0); - _Zp = new RangeTable.ptr(new sliceType([new Range16.ptr(8233, 8233, 1)]), sliceType$1.nil, 0); - _Zs = new RangeTable.ptr(new sliceType([new Range16.ptr(32, 160, 128), new Range16.ptr(5760, 8192, 2432), new Range16.ptr(8193, 8202, 1), new Range16.ptr(8239, 8287, 48), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 1); - $pkg.Cc = _Cc; - $pkg.Cf = _Cf; - $pkg.Co = _Co; - $pkg.Cs = _Cs; - $pkg.Digit = _Nd; - $pkg.Nd = _Nd; - $pkg.Letter = _L; - $pkg.L = _L; - $pkg.Lm = _Lm; - $pkg.Lo = _Lo; - $pkg.Ll = _Ll; - $pkg.M = _M; - $pkg.Mc = _Mc; - $pkg.Me = _Me; - $pkg.Mn = _Mn; - $pkg.Nl = _Nl; - $pkg.No = _No; - $pkg.N = _N; - $pkg.C = _C; - $pkg.Pc = _Pc; - $pkg.Pd = _Pd; - $pkg.Pe = _Pe; - $pkg.Pf = _Pf; - $pkg.Pi = _Pi; - $pkg.Po = _Po; - $pkg.Ps = _Ps; - $pkg.P = _P; - $pkg.Sc = _Sc; - $pkg.Sk = _Sk; - $pkg.Sm = _Sm; - $pkg.So = _So; - $pkg.Z = _Z; - $pkg.S = _S; - $pkg.PrintRanges = new sliceType$2([$pkg.L, $pkg.M, $pkg.N, $pkg.P, $pkg.S]); - $pkg.Lt = _Lt; - $pkg.Lu = _Lu; - $pkg.Zl = _Zl; - $pkg.Zp = _Zp; - $pkg.Zs = _Zs; - $pkg.Categories = $makeMap($String.keyFor, [{ k: "C", v: $pkg.C }, { k: "Cc", v: $pkg.Cc }, { k: "Cf", v: $pkg.Cf }, { k: "Co", v: $pkg.Co }, { k: "Cs", v: $pkg.Cs }, { k: "L", v: $pkg.L }, { k: "Ll", v: $pkg.Ll }, { k: "Lm", v: $pkg.Lm }, { k: "Lo", v: $pkg.Lo }, { k: "Lt", v: $pkg.Lt }, { k: "Lu", v: $pkg.Lu }, { k: "M", v: $pkg.M }, { k: "Mc", v: $pkg.Mc }, { k: "Me", v: $pkg.Me }, { k: "Mn", v: $pkg.Mn }, { k: "N", v: $pkg.N }, { k: "Nd", v: $pkg.Nd }, { k: "Nl", v: $pkg.Nl }, { k: "No", v: $pkg.No }, { k: "P", v: $pkg.P }, { k: "Pc", v: $pkg.Pc }, { k: "Pd", v: $pkg.Pd }, { k: "Pe", v: $pkg.Pe }, { k: "Pf", v: $pkg.Pf }, { k: "Pi", v: $pkg.Pi }, { k: "Po", v: $pkg.Po }, { k: "Ps", v: $pkg.Ps }, { k: "S", v: $pkg.S }, { k: "Sc", v: $pkg.Sc }, { k: "Sk", v: $pkg.Sk }, { k: "Sm", v: $pkg.Sm }, { k: "So", v: $pkg.So }, { k: "Z", v: $pkg.Z }, { k: "Zl", v: $pkg.Zl }, { k: "Zp", v: $pkg.Zp }, { k: "Zs", v: $pkg.Zs }]); - _Adlam = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(125184, 125258, 1), new Range32.ptr(125264, 125273, 1), new Range32.ptr(125278, 125279, 1)]), 0); - _Ahom = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71424, 71449, 1), new Range32.ptr(71453, 71467, 1), new Range32.ptr(71472, 71487, 1)]), 0); - _Anatolian_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(82944, 83526, 1)]), 0); - _Arabic = new RangeTable.ptr(new sliceType([new Range16.ptr(1536, 1540, 1), new Range16.ptr(1542, 1547, 1), new Range16.ptr(1549, 1562, 1), new Range16.ptr(1564, 1564, 1), new Range16.ptr(1566, 1566, 1), new Range16.ptr(1568, 1599, 1), new Range16.ptr(1601, 1610, 1), new Range16.ptr(1622, 1647, 1), new Range16.ptr(1649, 1756, 1), new Range16.ptr(1758, 1791, 1), new Range16.ptr(1872, 1919, 1), new Range16.ptr(2208, 2228, 1), new Range16.ptr(2230, 2237, 1), new Range16.ptr(2260, 2273, 1), new Range16.ptr(2275, 2303, 1), new Range16.ptr(64336, 64449, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65021, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1)]), new sliceType$1([new Range32.ptr(69216, 69246, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126500, 1), new Range32.ptr(126503, 126503, 1), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126521, 1), new Range32.ptr(126523, 126523, 1), new Range32.ptr(126530, 126530, 1), new Range32.ptr(126535, 126535, 1), new Range32.ptr(126537, 126537, 1), new Range32.ptr(126539, 126539, 1), new Range32.ptr(126541, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126548, 1), new Range32.ptr(126551, 126551, 1), new Range32.ptr(126553, 126553, 1), new Range32.ptr(126555, 126555, 1), new Range32.ptr(126557, 126557, 1), new Range32.ptr(126559, 126559, 1), new Range32.ptr(126561, 126562, 1), new Range32.ptr(126564, 126564, 1), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126590, 1), new Range32.ptr(126592, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(126704, 126705, 1)]), 0); - _Armenian = new RangeTable.ptr(new sliceType([new Range16.ptr(1329, 1366, 1), new Range16.ptr(1369, 1375, 1), new Range16.ptr(1377, 1415, 1), new Range16.ptr(1418, 1418, 1), new Range16.ptr(1421, 1423, 1), new Range16.ptr(64275, 64279, 1)]), sliceType$1.nil, 0); - _Avestan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68352, 68405, 1), new Range32.ptr(68409, 68415, 1)]), 0); - _Balinese = new RangeTable.ptr(new sliceType([new Range16.ptr(6912, 6987, 1), new Range16.ptr(6992, 7036, 1)]), sliceType$1.nil, 0); - _Bamum = new RangeTable.ptr(new sliceType([new Range16.ptr(42656, 42743, 1)]), new sliceType$1([new Range32.ptr(92160, 92728, 1)]), 0); - _Bassa_Vah = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92880, 92909, 1), new Range32.ptr(92912, 92917, 1)]), 0); - _Batak = new RangeTable.ptr(new sliceType([new Range16.ptr(7104, 7155, 1), new Range16.ptr(7164, 7167, 1)]), sliceType$1.nil, 0); - _Bengali = new RangeTable.ptr(new sliceType([new Range16.ptr(2432, 2435, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2482, 1), new Range16.ptr(2486, 2489, 1), new Range16.ptr(2492, 2500, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2510, 1), new Range16.ptr(2519, 2519, 1), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2531, 1), new Range16.ptr(2534, 2557, 1)]), sliceType$1.nil, 0); - _Bhaiksuki = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72704, 72712, 1), new Range32.ptr(72714, 72758, 1), new Range32.ptr(72760, 72773, 1), new Range32.ptr(72784, 72812, 1)]), 0); - _Bopomofo = new RangeTable.ptr(new sliceType([new Range16.ptr(746, 747, 1), new Range16.ptr(12549, 12590, 1), new Range16.ptr(12704, 12730, 1)]), sliceType$1.nil, 0); - _Brahmi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69632, 69709, 1), new Range32.ptr(69714, 69743, 1), new Range32.ptr(69759, 69759, 1)]), 0); - _Braille = new RangeTable.ptr(new sliceType([new Range16.ptr(10240, 10495, 1)]), sliceType$1.nil, 0); - _Buginese = new RangeTable.ptr(new sliceType([new Range16.ptr(6656, 6683, 1), new Range16.ptr(6686, 6687, 1)]), sliceType$1.nil, 0); - _Buhid = new RangeTable.ptr(new sliceType([new Range16.ptr(5952, 5971, 1)]), sliceType$1.nil, 0); - _Canadian_Aboriginal = new RangeTable.ptr(new sliceType([new Range16.ptr(5120, 5759, 1), new Range16.ptr(6320, 6389, 1)]), sliceType$1.nil, 0); - _Carian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66208, 66256, 1)]), 0); - _Caucasian_Albanian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66864, 66915, 1), new Range32.ptr(66927, 66927, 1)]), 0); - _Chakma = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69888, 69940, 1), new Range32.ptr(69942, 69955, 1)]), 0); - _Cham = new RangeTable.ptr(new sliceType([new Range16.ptr(43520, 43574, 1), new Range16.ptr(43584, 43597, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(43612, 43615, 1)]), sliceType$1.nil, 0); - _Cherokee = new RangeTable.ptr(new sliceType([new Range16.ptr(5024, 5109, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(43888, 43967, 1)]), sliceType$1.nil, 0); - _Common = new RangeTable.ptr(new sliceType([new Range16.ptr(0, 64, 1), new Range16.ptr(91, 96, 1), new Range16.ptr(123, 169, 1), new Range16.ptr(171, 185, 1), new Range16.ptr(187, 191, 1), new Range16.ptr(215, 215, 1), new Range16.ptr(247, 247, 1), new Range16.ptr(697, 735, 1), new Range16.ptr(741, 745, 1), new Range16.ptr(748, 767, 1), new Range16.ptr(884, 884, 1), new Range16.ptr(894, 894, 1), new Range16.ptr(901, 901, 1), new Range16.ptr(903, 903, 1), new Range16.ptr(1417, 1417, 1), new Range16.ptr(1541, 1541, 1), new Range16.ptr(1548, 1548, 1), new Range16.ptr(1563, 1563, 1), new Range16.ptr(1567, 1567, 1), new Range16.ptr(1600, 1600, 1), new Range16.ptr(1757, 1757, 1), new Range16.ptr(2274, 2274, 1), new Range16.ptr(2404, 2405, 1), new Range16.ptr(3647, 3647, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4347, 4347, 1), new Range16.ptr(5867, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6146, 6147, 1), new Range16.ptr(6149, 6149, 1), new Range16.ptr(7379, 7379, 1), new Range16.ptr(7393, 7393, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7411, 1), new Range16.ptr(7413, 7415, 1), new Range16.ptr(8192, 8203, 1), new Range16.ptr(8206, 8292, 1), new Range16.ptr(8294, 8304, 1), new Range16.ptr(8308, 8318, 1), new Range16.ptr(8320, 8334, 1), new Range16.ptr(8352, 8383, 1), new Range16.ptr(8448, 8485, 1), new Range16.ptr(8487, 8489, 1), new Range16.ptr(8492, 8497, 1), new Range16.ptr(8499, 8525, 1), new Range16.ptr(8527, 8543, 1), new Range16.ptr(8585, 8587, 1), new Range16.ptr(8592, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9312, 10239, 1), new Range16.ptr(10496, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11218, 1), new Range16.ptr(11244, 11247, 1), new Range16.ptr(11776, 11849, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12288, 12292, 1), new Range16.ptr(12294, 12294, 1), new Range16.ptr(12296, 12320, 1), new Range16.ptr(12336, 12343, 1), new Range16.ptr(12348, 12351, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(12448, 12448, 1), new Range16.ptr(12539, 12540, 1), new Range16.ptr(12688, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12832, 12895, 1), new Range16.ptr(12927, 13007, 1), new Range16.ptr(13144, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42752, 42785, 1), new Range16.ptr(42888, 42890, 1), new Range16.ptr(43056, 43065, 1), new Range16.ptr(43310, 43310, 1), new Range16.ptr(43471, 43471, 1), new Range16.ptr(43867, 43867, 1), new Range16.ptr(64830, 64831, 1), new Range16.ptr(65040, 65049, 1), new Range16.ptr(65072, 65106, 1), new Range16.ptr(65108, 65126, 1), new Range16.ptr(65128, 65131, 1), new Range16.ptr(65279, 65279, 1), new Range16.ptr(65281, 65312, 1), new Range16.ptr(65339, 65344, 1), new Range16.ptr(65371, 65381, 1), new Range16.ptr(65392, 65392, 1), new Range16.ptr(65438, 65439, 1), new Range16.ptr(65504, 65510, 1), new Range16.ptr(65512, 65518, 1), new Range16.ptr(65529, 65533, 1)]), new sliceType$1([new Range32.ptr(65792, 65794, 1), new Range32.ptr(65799, 65843, 1), new Range32.ptr(65847, 65855, 1), new Range32.ptr(65936, 65947, 1), new Range32.ptr(66000, 66044, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(113824, 113827, 1), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119142, 1), new Range32.ptr(119146, 119162, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119272, 1), new Range32.ptr(119552, 119638, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(119808, 119892, 1), new Range32.ptr(119894, 119964, 1), new Range32.ptr(119966, 119967, 1), new Range32.ptr(119970, 119970, 1), new Range32.ptr(119973, 119974, 1), new Range32.ptr(119977, 119980, 1), new Range32.ptr(119982, 119993, 1), new Range32.ptr(119995, 119995, 1), new Range32.ptr(119997, 120003, 1), new Range32.ptr(120005, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120094, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120134, 1), new Range32.ptr(120138, 120144, 1), new Range32.ptr(120146, 120485, 1), new Range32.ptr(120488, 120779, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127232, 127244, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127404, 1), new Range32.ptr(127462, 127487, 1), new Range32.ptr(127489, 127490, 1), new Range32.ptr(127504, 127547, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127584, 127589, 1), new Range32.ptr(127744, 128724, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128760, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1), new Range32.ptr(129280, 129291, 1), new Range32.ptr(129296, 129342, 1), new Range32.ptr(129344, 129356, 1), new Range32.ptr(129360, 129387, 1), new Range32.ptr(129408, 129431, 1), new Range32.ptr(129472, 129472, 1), new Range32.ptr(129488, 129510, 1), new Range32.ptr(917505, 917505, 1), new Range32.ptr(917536, 917631, 1)]), 7); - _Coptic = new RangeTable.ptr(new sliceType([new Range16.ptr(994, 1007, 1), new Range16.ptr(11392, 11507, 1), new Range16.ptr(11513, 11519, 1)]), sliceType$1.nil, 0); - _Cuneiform = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(73728, 74649, 1), new Range32.ptr(74752, 74862, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(74880, 75075, 1)]), 0); - _Cypriot = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67592, 1), new Range32.ptr(67594, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67644, 1), new Range32.ptr(67647, 67647, 1)]), 0); - _Cyrillic = new RangeTable.ptr(new sliceType([new Range16.ptr(1024, 1156, 1), new Range16.ptr(1159, 1327, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7467, 7467, 1), new Range16.ptr(7544, 7544, 1), new Range16.ptr(11744, 11775, 1), new Range16.ptr(42560, 42655, 1), new Range16.ptr(65070, 65071, 1)]), sliceType$1.nil, 0); - _Deseret = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66560, 66639, 1)]), 0); - _Devanagari = new RangeTable.ptr(new sliceType([new Range16.ptr(2304, 2384, 1), new Range16.ptr(2387, 2403, 1), new Range16.ptr(2406, 2431, 1), new Range16.ptr(43232, 43261, 1)]), sliceType$1.nil, 0); - _Duployan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(113820, 113823, 1)]), 0); - _Egyptian_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(77824, 78894, 1)]), 0); - _Elbasan = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66816, 66855, 1)]), 0); - _Ethiopic = new RangeTable.ptr(new sliceType([new Range16.ptr(4608, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4696, 1), new Range16.ptr(4698, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4800, 1), new Range16.ptr(4802, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4957, 4988, 1), new Range16.ptr(4992, 5017, 1), new Range16.ptr(11648, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(43777, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1)]), sliceType$1.nil, 0); - _Georgian = new RangeTable.ptr(new sliceType([new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4295, 1), new Range16.ptr(4301, 4301, 1), new Range16.ptr(4304, 4346, 1), new Range16.ptr(4348, 4351, 1), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11559, 1), new Range16.ptr(11565, 11565, 1)]), sliceType$1.nil, 0); - _Glagolitic = new RangeTable.ptr(new sliceType([new Range16.ptr(11264, 11310, 1), new Range16.ptr(11312, 11358, 1)]), new sliceType$1([new Range32.ptr(122880, 122886, 1), new Range32.ptr(122888, 122904, 1), new Range32.ptr(122907, 122913, 1), new Range32.ptr(122915, 122916, 1), new Range32.ptr(122918, 122922, 1)]), 0); - _Gothic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66352, 66378, 1)]), 0); - _Grantha = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70400, 70403, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70460, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70480, 70480, 1), new Range32.ptr(70487, 70487, 1), new Range32.ptr(70493, 70499, 1), new Range32.ptr(70502, 70508, 1), new Range32.ptr(70512, 70516, 1)]), 0); - _Greek = new RangeTable.ptr(new sliceType([new Range16.ptr(880, 883, 1), new Range16.ptr(885, 887, 1), new Range16.ptr(890, 893, 1), new Range16.ptr(895, 895, 1), new Range16.ptr(900, 900, 1), new Range16.ptr(902, 902, 1), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 908, 1), new Range16.ptr(910, 929, 1), new Range16.ptr(931, 993, 1), new Range16.ptr(1008, 1023, 1), new Range16.ptr(7462, 7466, 1), new Range16.ptr(7517, 7521, 1), new Range16.ptr(7526, 7530, 1), new Range16.ptr(7615, 7615, 1), new Range16.ptr(7936, 7957, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7968, 8005, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8025, 8025, 1), new Range16.ptr(8027, 8027, 1), new Range16.ptr(8029, 8029, 1), new Range16.ptr(8031, 8061, 1), new Range16.ptr(8064, 8116, 1), new Range16.ptr(8118, 8132, 1), new Range16.ptr(8134, 8147, 1), new Range16.ptr(8150, 8155, 1), new Range16.ptr(8157, 8175, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8190, 1), new Range16.ptr(8486, 8486, 1), new Range16.ptr(43877, 43877, 1)]), new sliceType$1([new Range32.ptr(65856, 65934, 1), new Range32.ptr(65952, 65952, 1), new Range32.ptr(119296, 119365, 1)]), 0); - _Gujarati = new RangeTable.ptr(new sliceType([new Range16.ptr(2689, 2691, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2748, 2757, 1), new Range16.ptr(2759, 2761, 1), new Range16.ptr(2763, 2765, 1), new Range16.ptr(2768, 2768, 1), new Range16.ptr(2784, 2787, 1), new Range16.ptr(2790, 2801, 1), new Range16.ptr(2809, 2815, 1)]), sliceType$1.nil, 0); - _Gurmukhi = new RangeTable.ptr(new sliceType([new Range16.ptr(2561, 2563, 1), new Range16.ptr(2565, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2620, 2620, 1), new Range16.ptr(2622, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2641, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2654, 1), new Range16.ptr(2662, 2677, 1)]), sliceType$1.nil, 0); - _Han = new RangeTable.ptr(new sliceType([new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12293, 12293, 1), new Range16.ptr(12295, 12295, 1), new Range16.ptr(12321, 12329, 1), new Range16.ptr(12344, 12347, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40938, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1)]), new sliceType$1([new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(178208, 183969, 1), new Range32.ptr(183984, 191456, 1), new Range32.ptr(194560, 195101, 1)]), 0); - _Hangul = new RangeTable.ptr(new sliceType([new Range16.ptr(4352, 4607, 1), new Range16.ptr(12334, 12335, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12896, 12926, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(65440, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), sliceType$1.nil, 0); - _Hanunoo = new RangeTable.ptr(new sliceType([new Range16.ptr(5920, 5940, 1)]), sliceType$1.nil, 0); - _Hatran = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67808, 67826, 1), new Range32.ptr(67828, 67829, 1), new Range32.ptr(67835, 67839, 1)]), 0); - _Hebrew = new RangeTable.ptr(new sliceType([new Range16.ptr(1425, 1479, 1), new Range16.ptr(1488, 1514, 1), new Range16.ptr(1520, 1524, 1), new Range16.ptr(64285, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64318, 1), new Range16.ptr(64320, 64321, 1), new Range16.ptr(64323, 64324, 1), new Range16.ptr(64326, 64335, 1)]), sliceType$1.nil, 0); - _Hiragana = new RangeTable.ptr(new sliceType([new Range16.ptr(12353, 12438, 1), new Range16.ptr(12445, 12447, 1)]), new sliceType$1([new Range32.ptr(110593, 110878, 1), new Range32.ptr(127488, 127488, 1)]), 0); - _Imperial_Aramaic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67648, 67669, 1), new Range32.ptr(67671, 67679, 1)]), 0); - _Inherited = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1157, 1158, 1), new Range16.ptr(1611, 1621, 1), new Range16.ptr(1648, 1648, 1), new Range16.ptr(2385, 2386, 1), new Range16.ptr(6832, 6846, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7392, 1), new Range16.ptr(7394, 7400, 1), new Range16.ptr(7405, 7405, 1), new Range16.ptr(7412, 7412, 1), new Range16.ptr(7416, 7417, 1), new Range16.ptr(7616, 7673, 1), new Range16.ptr(7675, 7679, 1), new Range16.ptr(8204, 8205, 1), new Range16.ptr(8400, 8432, 1), new Range16.ptr(12330, 12333, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(65024, 65039, 1), new Range16.ptr(65056, 65069, 1)]), new sliceType$1([new Range32.ptr(66045, 66045, 1), new Range32.ptr(66272, 66272, 1), new Range32.ptr(119143, 119145, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(917760, 917999, 1)]), 0); - _Inscriptional_Pahlavi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68448, 68466, 1), new Range32.ptr(68472, 68479, 1)]), 0); - _Inscriptional_Parthian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68416, 68437, 1), new Range32.ptr(68440, 68447, 1)]), 0); - _Javanese = new RangeTable.ptr(new sliceType([new Range16.ptr(43392, 43469, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43486, 43487, 1)]), sliceType$1.nil, 0); - _Kaithi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69760, 69825, 1)]), 0); - _Kannada = new RangeTable.ptr(new sliceType([new Range16.ptr(3200, 3203, 1), new Range16.ptr(3205, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3260, 3268, 1), new Range16.ptr(3270, 3272, 1), new Range16.ptr(3274, 3277, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3294, 3294, 1), new Range16.ptr(3296, 3299, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3313, 3314, 1)]), sliceType$1.nil, 0); - _Katakana = new RangeTable.ptr(new sliceType([new Range16.ptr(12449, 12538, 1), new Range16.ptr(12541, 12543, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13008, 13054, 1), new Range16.ptr(13056, 13143, 1), new Range16.ptr(65382, 65391, 1), new Range16.ptr(65393, 65437, 1)]), new sliceType$1([new Range32.ptr(110592, 110592, 1)]), 0); - _Kayah_Li = new RangeTable.ptr(new sliceType([new Range16.ptr(43264, 43309, 1), new Range16.ptr(43311, 43311, 1)]), sliceType$1.nil, 0); - _Kharoshthi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68096, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68167, 1), new Range32.ptr(68176, 68184, 1)]), 0); - _Khmer = new RangeTable.ptr(new sliceType([new Range16.ptr(6016, 6109, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6624, 6655, 1)]), sliceType$1.nil, 0); - _Khojki = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70144, 70161, 1), new Range32.ptr(70163, 70206, 1)]), 0); - _Khudawadi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70320, 70378, 1), new Range32.ptr(70384, 70393, 1)]), 0); - _Lao = new RangeTable.ptr(new sliceType([new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3716, 1), new Range16.ptr(3719, 3720, 1), new Range16.ptr(3722, 3722, 1), new Range16.ptr(3725, 3725, 1), new Range16.ptr(3732, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3749, 1), new Range16.ptr(3751, 3751, 1), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3769, 1), new Range16.ptr(3771, 3773, 1), new Range16.ptr(3776, 3780, 1), new Range16.ptr(3782, 3782, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3804, 3807, 1)]), sliceType$1.nil, 0); - _Latin = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(97, 122, 1), new Range16.ptr(170, 170, 1), new Range16.ptr(186, 186, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 246, 1), new Range16.ptr(248, 696, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(7424, 7461, 1), new Range16.ptr(7468, 7516, 1), new Range16.ptr(7522, 7525, 1), new Range16.ptr(7531, 7543, 1), new Range16.ptr(7545, 7614, 1), new Range16.ptr(7680, 7935, 1), new Range16.ptr(8305, 8305, 1), new Range16.ptr(8319, 8319, 1), new Range16.ptr(8336, 8348, 1), new Range16.ptr(8490, 8491, 1), new Range16.ptr(8498, 8498, 1), new Range16.ptr(8526, 8526, 1), new Range16.ptr(8544, 8584, 1), new Range16.ptr(11360, 11391, 1), new Range16.ptr(42786, 42887, 1), new Range16.ptr(42891, 42926, 1), new Range16.ptr(42928, 42935, 1), new Range16.ptr(42999, 43007, 1), new Range16.ptr(43824, 43866, 1), new Range16.ptr(43868, 43876, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(65313, 65338, 1), new Range16.ptr(65345, 65370, 1)]), sliceType$1.nil, 6); - _Lepcha = new RangeTable.ptr(new sliceType([new Range16.ptr(7168, 7223, 1), new Range16.ptr(7227, 7241, 1), new Range16.ptr(7245, 7247, 1)]), sliceType$1.nil, 0); - _Limbu = new RangeTable.ptr(new sliceType([new Range16.ptr(6400, 6430, 1), new Range16.ptr(6432, 6443, 1), new Range16.ptr(6448, 6459, 1), new Range16.ptr(6464, 6464, 1), new Range16.ptr(6468, 6479, 1)]), sliceType$1.nil, 0); - _Linear_A = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1)]), 0); - _Linear_B = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1)]), 0); - _Lisu = new RangeTable.ptr(new sliceType([new Range16.ptr(42192, 42239, 1)]), sliceType$1.nil, 0); - _Lycian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66176, 66204, 1)]), 0); - _Lydian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67872, 67897, 1), new Range32.ptr(67903, 67903, 1)]), 0); - _Mahajani = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69968, 70006, 1)]), 0); - _Malayalam = new RangeTable.ptr(new sliceType([new Range16.ptr(3328, 3331, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3396, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3407, 1), new Range16.ptr(3412, 3427, 1), new Range16.ptr(3430, 3455, 1)]), sliceType$1.nil, 0); - _Mandaic = new RangeTable.ptr(new sliceType([new Range16.ptr(2112, 2139, 1), new Range16.ptr(2142, 2142, 1)]), sliceType$1.nil, 0); - _Manichaean = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68288, 68326, 1), new Range32.ptr(68331, 68342, 1)]), 0); - _Marchen = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72816, 72847, 1), new Range32.ptr(72850, 72871, 1), new Range32.ptr(72873, 72886, 1)]), 0); - _Masaram_Gondi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72960, 72966, 1), new Range32.ptr(72968, 72969, 1), new Range32.ptr(72971, 73014, 1), new Range32.ptr(73018, 73018, 1), new Range32.ptr(73020, 73021, 1), new Range32.ptr(73023, 73031, 1), new Range32.ptr(73040, 73049, 1)]), 0); - _Meetei_Mayek = new RangeTable.ptr(new sliceType([new Range16.ptr(43744, 43766, 1), new Range16.ptr(43968, 44013, 1), new Range16.ptr(44016, 44025, 1)]), sliceType$1.nil, 0); - _Mende_Kikakui = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(124928, 125124, 1), new Range32.ptr(125127, 125142, 1)]), 0); - _Meroitic_Cursive = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68000, 68023, 1), new Range32.ptr(68028, 68047, 1), new Range32.ptr(68050, 68095, 1)]), 0); - _Meroitic_Hieroglyphs = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67968, 67999, 1)]), 0); - _Miao = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94078, 1), new Range32.ptr(94095, 94111, 1)]), 0); - _Modi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71168, 71236, 1), new Range32.ptr(71248, 71257, 1)]), 0); - _Mongolian = new RangeTable.ptr(new sliceType([new Range16.ptr(6144, 6145, 1), new Range16.ptr(6148, 6148, 1), new Range16.ptr(6150, 6158, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6176, 6263, 1), new Range16.ptr(6272, 6314, 1)]), new sliceType$1([new Range32.ptr(71264, 71276, 1)]), 0); - _Mro = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92736, 92766, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(92782, 92783, 1)]), 0); - _Multani = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70272, 70278, 1), new Range32.ptr(70280, 70280, 1), new Range32.ptr(70282, 70285, 1), new Range32.ptr(70287, 70301, 1), new Range32.ptr(70303, 70313, 1)]), 0); - _Myanmar = new RangeTable.ptr(new sliceType([new Range16.ptr(4096, 4255, 1), new Range16.ptr(43488, 43518, 1), new Range16.ptr(43616, 43647, 1)]), sliceType$1.nil, 0); - _Nabataean = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67712, 67742, 1), new Range32.ptr(67751, 67759, 1)]), 0); - _New_Tai_Lue = new RangeTable.ptr(new sliceType([new Range16.ptr(6528, 6571, 1), new Range16.ptr(6576, 6601, 1), new Range16.ptr(6608, 6618, 1), new Range16.ptr(6622, 6623, 1)]), sliceType$1.nil, 0); - _Newa = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70656, 70745, 1), new Range32.ptr(70747, 70747, 1), new Range32.ptr(70749, 70749, 1)]), 0); - _Nko = new RangeTable.ptr(new sliceType([new Range16.ptr(1984, 2042, 1)]), sliceType$1.nil, 0); - _Nushu = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(94177, 94177, 1), new Range32.ptr(110960, 111355, 1)]), 0); - _Ogham = new RangeTable.ptr(new sliceType([new Range16.ptr(5760, 5788, 1)]), sliceType$1.nil, 0); - _Ol_Chiki = new RangeTable.ptr(new sliceType([new Range16.ptr(7248, 7295, 1)]), sliceType$1.nil, 0); - _Old_Hungarian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68736, 68786, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(68858, 68863, 1)]), 0); - _Old_Italic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66304, 66339, 1), new Range32.ptr(66349, 66351, 1)]), 0); - _Old_North_Arabian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68224, 68255, 1)]), 0); - _Old_Permic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66384, 66426, 1)]), 0); - _Old_Persian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66517, 1)]), 0); - _Old_South_Arabian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68192, 68223, 1)]), 0); - _Old_Turkic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68608, 68680, 1)]), 0); - _Oriya = new RangeTable.ptr(new sliceType([new Range16.ptr(2817, 2819, 1), new Range16.ptr(2821, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2876, 2884, 1), new Range16.ptr(2887, 2888, 1), new Range16.ptr(2891, 2893, 1), new Range16.ptr(2902, 2903, 1), new Range16.ptr(2908, 2909, 1), new Range16.ptr(2911, 2915, 1), new Range16.ptr(2918, 2935, 1)]), sliceType$1.nil, 0); - _Osage = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66736, 66771, 1), new Range32.ptr(66776, 66811, 1)]), 0); - _Osmanya = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66688, 66717, 1), new Range32.ptr(66720, 66729, 1)]), 0); - _Pahawh_Hmong = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(92928, 92997, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1)]), 0); - _Palmyrene = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67680, 67711, 1)]), 0); - _Pau_Cin_Hau = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72384, 72440, 1)]), 0); - _Phags_Pa = new RangeTable.ptr(new sliceType([new Range16.ptr(43072, 43127, 1)]), sliceType$1.nil, 0); - _Phoenician = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(67840, 67867, 1), new Range32.ptr(67871, 67871, 1)]), 0); - _Psalter_Pahlavi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(68480, 68497, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(68521, 68527, 1)]), 0); - _Rejang = new RangeTable.ptr(new sliceType([new Range16.ptr(43312, 43347, 1), new Range16.ptr(43359, 43359, 1)]), sliceType$1.nil, 0); - _Runic = new RangeTable.ptr(new sliceType([new Range16.ptr(5792, 5866, 1), new Range16.ptr(5870, 5880, 1)]), sliceType$1.nil, 0); - _Samaritan = new RangeTable.ptr(new sliceType([new Range16.ptr(2048, 2093, 1), new Range16.ptr(2096, 2110, 1)]), sliceType$1.nil, 0); - _Saurashtra = new RangeTable.ptr(new sliceType([new Range16.ptr(43136, 43205, 1), new Range16.ptr(43214, 43225, 1)]), sliceType$1.nil, 0); - _Sharada = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70016, 70093, 1), new Range32.ptr(70096, 70111, 1)]), 0); - _Shavian = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66640, 66687, 1)]), 0); - _Siddham = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71040, 71093, 1), new Range32.ptr(71096, 71133, 1)]), 0); - _SignWriting = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(120832, 121483, 1), new Range32.ptr(121499, 121503, 1), new Range32.ptr(121505, 121519, 1)]), 0); - _Sinhala = new RangeTable.ptr(new sliceType([new Range16.ptr(3458, 3459, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3517, 1), new Range16.ptr(3520, 3526, 1), new Range16.ptr(3530, 3530, 1), new Range16.ptr(3535, 3540, 1), new Range16.ptr(3542, 3542, 1), new Range16.ptr(3544, 3551, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3570, 3572, 1)]), new sliceType$1([new Range32.ptr(70113, 70132, 1)]), 0); - _Sora_Sompeng = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(69840, 69864, 1), new Range32.ptr(69872, 69881, 1)]), 0); - _Soyombo = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72272, 72323, 1), new Range32.ptr(72326, 72348, 1), new Range32.ptr(72350, 72354, 1)]), 0); - _Sundanese = new RangeTable.ptr(new sliceType([new Range16.ptr(7040, 7103, 1), new Range16.ptr(7360, 7367, 1)]), sliceType$1.nil, 0); - _Syloti_Nagri = new RangeTable.ptr(new sliceType([new Range16.ptr(43008, 43051, 1)]), sliceType$1.nil, 0); - _Syriac = new RangeTable.ptr(new sliceType([new Range16.ptr(1792, 1805, 1), new Range16.ptr(1807, 1866, 1), new Range16.ptr(1869, 1871, 1), new Range16.ptr(2144, 2154, 1)]), sliceType$1.nil, 0); - _Tagalog = new RangeTable.ptr(new sliceType([new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5908, 1)]), sliceType$1.nil, 0); - _Tagbanwa = new RangeTable.ptr(new sliceType([new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6002, 6003, 1)]), sliceType$1.nil, 0); - _Tai_Le = new RangeTable.ptr(new sliceType([new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1)]), sliceType$1.nil, 0); - _Tai_Tham = new RangeTable.ptr(new sliceType([new Range16.ptr(6688, 6750, 1), new Range16.ptr(6752, 6780, 1), new Range16.ptr(6783, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6816, 6829, 1)]), sliceType$1.nil, 0); - _Tai_Viet = new RangeTable.ptr(new sliceType([new Range16.ptr(43648, 43714, 1), new Range16.ptr(43739, 43743, 1)]), sliceType$1.nil, 0); - _Takri = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71296, 71351, 1), new Range32.ptr(71360, 71369, 1)]), 0); - _Tamil = new RangeTable.ptr(new sliceType([new Range16.ptr(2946, 2947, 1), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2972, 1), new Range16.ptr(2974, 2975, 1), new Range16.ptr(2979, 2980, 1), new Range16.ptr(2984, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3006, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3021, 1), new Range16.ptr(3024, 3024, 1), new Range16.ptr(3031, 3031, 1), new Range16.ptr(3046, 3066, 1)]), sliceType$1.nil, 0); - _Tangut = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(94176, 94176, 1), new Range32.ptr(94208, 100332, 1), new Range32.ptr(100352, 101106, 1)]), 0); - _Telugu = new RangeTable.ptr(new sliceType([new Range16.ptr(3072, 3075, 1), new Range16.ptr(3077, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3140, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3160, 3162, 1), new Range16.ptr(3168, 3171, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3192, 3199, 1)]), sliceType$1.nil, 0); - _Thaana = new RangeTable.ptr(new sliceType([new Range16.ptr(1920, 1969, 1)]), sliceType$1.nil, 0); - _Thai = new RangeTable.ptr(new sliceType([new Range16.ptr(3585, 3642, 1), new Range16.ptr(3648, 3675, 1)]), sliceType$1.nil, 0); - _Tibetan = new RangeTable.ptr(new sliceType([new Range16.ptr(3840, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3953, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4030, 4044, 1), new Range16.ptr(4046, 4052, 1), new Range16.ptr(4057, 4058, 1)]), sliceType$1.nil, 0); - _Tifinagh = new RangeTable.ptr(new sliceType([new Range16.ptr(11568, 11623, 1), new Range16.ptr(11631, 11632, 1), new Range16.ptr(11647, 11647, 1)]), sliceType$1.nil, 0); - _Tirhuta = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(70784, 70855, 1), new Range32.ptr(70864, 70873, 1)]), 0); - _Ugaritic = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(66432, 66461, 1), new Range32.ptr(66463, 66463, 1)]), 0); - _Vai = new RangeTable.ptr(new sliceType([new Range16.ptr(42240, 42539, 1)]), sliceType$1.nil, 0); - _Warang_Citi = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(71840, 71922, 1), new Range32.ptr(71935, 71935, 1)]), 0); - _Yi = new RangeTable.ptr(new sliceType([new Range16.ptr(40960, 42124, 1), new Range16.ptr(42128, 42182, 1)]), sliceType$1.nil, 0); - _Zanabazar_Square = new RangeTable.ptr(new sliceType([]), new sliceType$1([new Range32.ptr(72192, 72263, 1)]), 0); - $pkg.Adlam = _Adlam; - $pkg.Ahom = _Ahom; - $pkg.Anatolian_Hieroglyphs = _Anatolian_Hieroglyphs; - $pkg.Arabic = _Arabic; - $pkg.Armenian = _Armenian; - $pkg.Avestan = _Avestan; - $pkg.Balinese = _Balinese; - $pkg.Bamum = _Bamum; - $pkg.Bassa_Vah = _Bassa_Vah; - $pkg.Batak = _Batak; - $pkg.Bengali = _Bengali; - $pkg.Bhaiksuki = _Bhaiksuki; - $pkg.Bopomofo = _Bopomofo; - $pkg.Brahmi = _Brahmi; - $pkg.Braille = _Braille; - $pkg.Buginese = _Buginese; - $pkg.Buhid = _Buhid; - $pkg.Canadian_Aboriginal = _Canadian_Aboriginal; - $pkg.Carian = _Carian; - $pkg.Caucasian_Albanian = _Caucasian_Albanian; - $pkg.Chakma = _Chakma; - $pkg.Cham = _Cham; - $pkg.Cherokee = _Cherokee; - $pkg.Common = _Common; - $pkg.Coptic = _Coptic; - $pkg.Cuneiform = _Cuneiform; - $pkg.Cypriot = _Cypriot; - $pkg.Cyrillic = _Cyrillic; - $pkg.Deseret = _Deseret; - $pkg.Devanagari = _Devanagari; - $pkg.Duployan = _Duployan; - $pkg.Egyptian_Hieroglyphs = _Egyptian_Hieroglyphs; - $pkg.Elbasan = _Elbasan; - $pkg.Ethiopic = _Ethiopic; - $pkg.Georgian = _Georgian; - $pkg.Glagolitic = _Glagolitic; - $pkg.Gothic = _Gothic; - $pkg.Grantha = _Grantha; - $pkg.Greek = _Greek; - $pkg.Gujarati = _Gujarati; - $pkg.Gurmukhi = _Gurmukhi; - $pkg.Han = _Han; - $pkg.Hangul = _Hangul; - $pkg.Hanunoo = _Hanunoo; - $pkg.Hatran = _Hatran; - $pkg.Hebrew = _Hebrew; - $pkg.Hiragana = _Hiragana; - $pkg.Imperial_Aramaic = _Imperial_Aramaic; - $pkg.Inherited = _Inherited; - $pkg.Inscriptional_Pahlavi = _Inscriptional_Pahlavi; - $pkg.Inscriptional_Parthian = _Inscriptional_Parthian; - $pkg.Javanese = _Javanese; - $pkg.Kaithi = _Kaithi; - $pkg.Kannada = _Kannada; - $pkg.Katakana = _Katakana; - $pkg.Kayah_Li = _Kayah_Li; - $pkg.Kharoshthi = _Kharoshthi; - $pkg.Khmer = _Khmer; - $pkg.Khojki = _Khojki; - $pkg.Khudawadi = _Khudawadi; - $pkg.Lao = _Lao; - $pkg.Latin = _Latin; - $pkg.Lepcha = _Lepcha; - $pkg.Limbu = _Limbu; - $pkg.Linear_A = _Linear_A; - $pkg.Linear_B = _Linear_B; - $pkg.Lisu = _Lisu; - $pkg.Lycian = _Lycian; - $pkg.Lydian = _Lydian; - $pkg.Mahajani = _Mahajani; - $pkg.Malayalam = _Malayalam; - $pkg.Mandaic = _Mandaic; - $pkg.Manichaean = _Manichaean; - $pkg.Marchen = _Marchen; - $pkg.Masaram_Gondi = _Masaram_Gondi; - $pkg.Meetei_Mayek = _Meetei_Mayek; - $pkg.Mende_Kikakui = _Mende_Kikakui; - $pkg.Meroitic_Cursive = _Meroitic_Cursive; - $pkg.Meroitic_Hieroglyphs = _Meroitic_Hieroglyphs; - $pkg.Miao = _Miao; - $pkg.Modi = _Modi; - $pkg.Mongolian = _Mongolian; - $pkg.Mro = _Mro; - $pkg.Multani = _Multani; - $pkg.Myanmar = _Myanmar; - $pkg.Nabataean = _Nabataean; - $pkg.New_Tai_Lue = _New_Tai_Lue; - $pkg.Newa = _Newa; - $pkg.Nko = _Nko; - $pkg.Nushu = _Nushu; - $pkg.Ogham = _Ogham; - $pkg.Ol_Chiki = _Ol_Chiki; - $pkg.Old_Hungarian = _Old_Hungarian; - $pkg.Old_Italic = _Old_Italic; - $pkg.Old_North_Arabian = _Old_North_Arabian; - $pkg.Old_Permic = _Old_Permic; - $pkg.Old_Persian = _Old_Persian; - $pkg.Old_South_Arabian = _Old_South_Arabian; - $pkg.Old_Turkic = _Old_Turkic; - $pkg.Oriya = _Oriya; - $pkg.Osage = _Osage; - $pkg.Osmanya = _Osmanya; - $pkg.Pahawh_Hmong = _Pahawh_Hmong; - $pkg.Palmyrene = _Palmyrene; - $pkg.Pau_Cin_Hau = _Pau_Cin_Hau; - $pkg.Phags_Pa = _Phags_Pa; - $pkg.Phoenician = _Phoenician; - $pkg.Psalter_Pahlavi = _Psalter_Pahlavi; - $pkg.Rejang = _Rejang; - $pkg.Runic = _Runic; - $pkg.Samaritan = _Samaritan; - $pkg.Saurashtra = _Saurashtra; - $pkg.Sharada = _Sharada; - $pkg.Shavian = _Shavian; - $pkg.Siddham = _Siddham; - $pkg.SignWriting = _SignWriting; - $pkg.Sinhala = _Sinhala; - $pkg.Sora_Sompeng = _Sora_Sompeng; - $pkg.Soyombo = _Soyombo; - $pkg.Sundanese = _Sundanese; - $pkg.Syloti_Nagri = _Syloti_Nagri; - $pkg.Syriac = _Syriac; - $pkg.Tagalog = _Tagalog; - $pkg.Tagbanwa = _Tagbanwa; - $pkg.Tai_Le = _Tai_Le; - $pkg.Tai_Tham = _Tai_Tham; - $pkg.Tai_Viet = _Tai_Viet; - $pkg.Takri = _Takri; - $pkg.Tamil = _Tamil; - $pkg.Tangut = _Tangut; - $pkg.Telugu = _Telugu; - $pkg.Thaana = _Thaana; - $pkg.Thai = _Thai; - $pkg.Tibetan = _Tibetan; - $pkg.Tifinagh = _Tifinagh; - $pkg.Tirhuta = _Tirhuta; - $pkg.Ugaritic = _Ugaritic; - $pkg.Vai = _Vai; - $pkg.Warang_Citi = _Warang_Citi; - $pkg.Yi = _Yi; - $pkg.Zanabazar_Square = _Zanabazar_Square; - $pkg.Scripts = $makeMap($String.keyFor, [{ k: "Adlam", v: $pkg.Adlam }, { k: "Ahom", v: $pkg.Ahom }, { k: "Anatolian_Hieroglyphs", v: $pkg.Anatolian_Hieroglyphs }, { k: "Arabic", v: $pkg.Arabic }, { k: "Armenian", v: $pkg.Armenian }, { k: "Avestan", v: $pkg.Avestan }, { k: "Balinese", v: $pkg.Balinese }, { k: "Bamum", v: $pkg.Bamum }, { k: "Bassa_Vah", v: $pkg.Bassa_Vah }, { k: "Batak", v: $pkg.Batak }, { k: "Bengali", v: $pkg.Bengali }, { k: "Bhaiksuki", v: $pkg.Bhaiksuki }, { k: "Bopomofo", v: $pkg.Bopomofo }, { k: "Brahmi", v: $pkg.Brahmi }, { k: "Braille", v: $pkg.Braille }, { k: "Buginese", v: $pkg.Buginese }, { k: "Buhid", v: $pkg.Buhid }, { k: "Canadian_Aboriginal", v: $pkg.Canadian_Aboriginal }, { k: "Carian", v: $pkg.Carian }, { k: "Caucasian_Albanian", v: $pkg.Caucasian_Albanian }, { k: "Chakma", v: $pkg.Chakma }, { k: "Cham", v: $pkg.Cham }, { k: "Cherokee", v: $pkg.Cherokee }, { k: "Common", v: $pkg.Common }, { k: "Coptic", v: $pkg.Coptic }, { k: "Cuneiform", v: $pkg.Cuneiform }, { k: "Cypriot", v: $pkg.Cypriot }, { k: "Cyrillic", v: $pkg.Cyrillic }, { k: "Deseret", v: $pkg.Deseret }, { k: "Devanagari", v: $pkg.Devanagari }, { k: "Duployan", v: $pkg.Duployan }, { k: "Egyptian_Hieroglyphs", v: $pkg.Egyptian_Hieroglyphs }, { k: "Elbasan", v: $pkg.Elbasan }, { k: "Ethiopic", v: $pkg.Ethiopic }, { k: "Georgian", v: $pkg.Georgian }, { k: "Glagolitic", v: $pkg.Glagolitic }, { k: "Gothic", v: $pkg.Gothic }, { k: "Grantha", v: $pkg.Grantha }, { k: "Greek", v: $pkg.Greek }, { k: "Gujarati", v: $pkg.Gujarati }, { k: "Gurmukhi", v: $pkg.Gurmukhi }, { k: "Han", v: $pkg.Han }, { k: "Hangul", v: $pkg.Hangul }, { k: "Hanunoo", v: $pkg.Hanunoo }, { k: "Hatran", v: $pkg.Hatran }, { k: "Hebrew", v: $pkg.Hebrew }, { k: "Hiragana", v: $pkg.Hiragana }, { k: "Imperial_Aramaic", v: $pkg.Imperial_Aramaic }, { k: "Inherited", v: $pkg.Inherited }, { k: "Inscriptional_Pahlavi", v: $pkg.Inscriptional_Pahlavi }, { k: "Inscriptional_Parthian", v: $pkg.Inscriptional_Parthian }, { k: "Javanese", v: $pkg.Javanese }, { k: "Kaithi", v: $pkg.Kaithi }, { k: "Kannada", v: $pkg.Kannada }, { k: "Katakana", v: $pkg.Katakana }, { k: "Kayah_Li", v: $pkg.Kayah_Li }, { k: "Kharoshthi", v: $pkg.Kharoshthi }, { k: "Khmer", v: $pkg.Khmer }, { k: "Khojki", v: $pkg.Khojki }, { k: "Khudawadi", v: $pkg.Khudawadi }, { k: "Lao", v: $pkg.Lao }, { k: "Latin", v: $pkg.Latin }, { k: "Lepcha", v: $pkg.Lepcha }, { k: "Limbu", v: $pkg.Limbu }, { k: "Linear_A", v: $pkg.Linear_A }, { k: "Linear_B", v: $pkg.Linear_B }, { k: "Lisu", v: $pkg.Lisu }, { k: "Lycian", v: $pkg.Lycian }, { k: "Lydian", v: $pkg.Lydian }, { k: "Mahajani", v: $pkg.Mahajani }, { k: "Malayalam", v: $pkg.Malayalam }, { k: "Mandaic", v: $pkg.Mandaic }, { k: "Manichaean", v: $pkg.Manichaean }, { k: "Marchen", v: $pkg.Marchen }, { k: "Masaram_Gondi", v: $pkg.Masaram_Gondi }, { k: "Meetei_Mayek", v: $pkg.Meetei_Mayek }, { k: "Mende_Kikakui", v: $pkg.Mende_Kikakui }, { k: "Meroitic_Cursive", v: $pkg.Meroitic_Cursive }, { k: "Meroitic_Hieroglyphs", v: $pkg.Meroitic_Hieroglyphs }, { k: "Miao", v: $pkg.Miao }, { k: "Modi", v: $pkg.Modi }, { k: "Mongolian", v: $pkg.Mongolian }, { k: "Mro", v: $pkg.Mro }, { k: "Multani", v: $pkg.Multani }, { k: "Myanmar", v: $pkg.Myanmar }, { k: "Nabataean", v: $pkg.Nabataean }, { k: "New_Tai_Lue", v: $pkg.New_Tai_Lue }, { k: "Newa", v: $pkg.Newa }, { k: "Nko", v: $pkg.Nko }, { k: "Nushu", v: $pkg.Nushu }, { k: "Ogham", v: $pkg.Ogham }, { k: "Ol_Chiki", v: $pkg.Ol_Chiki }, { k: "Old_Hungarian", v: $pkg.Old_Hungarian }, { k: "Old_Italic", v: $pkg.Old_Italic }, { k: "Old_North_Arabian", v: $pkg.Old_North_Arabian }, { k: "Old_Permic", v: $pkg.Old_Permic }, { k: "Old_Persian", v: $pkg.Old_Persian }, { k: "Old_South_Arabian", v: $pkg.Old_South_Arabian }, { k: "Old_Turkic", v: $pkg.Old_Turkic }, { k: "Oriya", v: $pkg.Oriya }, { k: "Osage", v: $pkg.Osage }, { k: "Osmanya", v: $pkg.Osmanya }, { k: "Pahawh_Hmong", v: $pkg.Pahawh_Hmong }, { k: "Palmyrene", v: $pkg.Palmyrene }, { k: "Pau_Cin_Hau", v: $pkg.Pau_Cin_Hau }, { k: "Phags_Pa", v: $pkg.Phags_Pa }, { k: "Phoenician", v: $pkg.Phoenician }, { k: "Psalter_Pahlavi", v: $pkg.Psalter_Pahlavi }, { k: "Rejang", v: $pkg.Rejang }, { k: "Runic", v: $pkg.Runic }, { k: "Samaritan", v: $pkg.Samaritan }, { k: "Saurashtra", v: $pkg.Saurashtra }, { k: "Sharada", v: $pkg.Sharada }, { k: "Shavian", v: $pkg.Shavian }, { k: "Siddham", v: $pkg.Siddham }, { k: "SignWriting", v: $pkg.SignWriting }, { k: "Sinhala", v: $pkg.Sinhala }, { k: "Sora_Sompeng", v: $pkg.Sora_Sompeng }, { k: "Soyombo", v: $pkg.Soyombo }, { k: "Sundanese", v: $pkg.Sundanese }, { k: "Syloti_Nagri", v: $pkg.Syloti_Nagri }, { k: "Syriac", v: $pkg.Syriac }, { k: "Tagalog", v: $pkg.Tagalog }, { k: "Tagbanwa", v: $pkg.Tagbanwa }, { k: "Tai_Le", v: $pkg.Tai_Le }, { k: "Tai_Tham", v: $pkg.Tai_Tham }, { k: "Tai_Viet", v: $pkg.Tai_Viet }, { k: "Takri", v: $pkg.Takri }, { k: "Tamil", v: $pkg.Tamil }, { k: "Tangut", v: $pkg.Tangut }, { k: "Telugu", v: $pkg.Telugu }, { k: "Thaana", v: $pkg.Thaana }, { k: "Thai", v: $pkg.Thai }, { k: "Tibetan", v: $pkg.Tibetan }, { k: "Tifinagh", v: $pkg.Tifinagh }, { k: "Tirhuta", v: $pkg.Tirhuta }, { k: "Ugaritic", v: $pkg.Ugaritic }, { k: "Vai", v: $pkg.Vai }, { k: "Warang_Citi", v: $pkg.Warang_Citi }, { k: "Yi", v: $pkg.Yi }, { k: "Zanabazar_Square", v: $pkg.Zanabazar_Square }]); - _CaseRanges = new sliceType$3([new CaseRange.ptr(65, 90, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(97, 122, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(181, 181, $toNativeArray($kindInt32, [743, 0, 743])), new CaseRange.ptr(192, 214, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(216, 222, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(224, 246, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(248, 254, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(255, 255, $toNativeArray($kindInt32, [121, 0, 121])), new CaseRange.ptr(256, 303, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(304, 304, $toNativeArray($kindInt32, [0, -199, 0])), new CaseRange.ptr(305, 305, $toNativeArray($kindInt32, [-232, 0, -232])), new CaseRange.ptr(306, 311, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(313, 328, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(330, 375, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(376, 376, $toNativeArray($kindInt32, [0, -121, 0])), new CaseRange.ptr(377, 382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(383, 383, $toNativeArray($kindInt32, [-300, 0, -300])), new CaseRange.ptr(384, 384, $toNativeArray($kindInt32, [195, 0, 195])), new CaseRange.ptr(385, 385, $toNativeArray($kindInt32, [0, 210, 0])), new CaseRange.ptr(386, 389, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(390, 390, $toNativeArray($kindInt32, [0, 206, 0])), new CaseRange.ptr(391, 392, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(393, 394, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(395, 396, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(398, 398, $toNativeArray($kindInt32, [0, 79, 0])), new CaseRange.ptr(399, 399, $toNativeArray($kindInt32, [0, 202, 0])), new CaseRange.ptr(400, 400, $toNativeArray($kindInt32, [0, 203, 0])), new CaseRange.ptr(401, 402, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(403, 403, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(404, 404, $toNativeArray($kindInt32, [0, 207, 0])), new CaseRange.ptr(405, 405, $toNativeArray($kindInt32, [97, 0, 97])), new CaseRange.ptr(406, 406, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(407, 407, $toNativeArray($kindInt32, [0, 209, 0])), new CaseRange.ptr(408, 409, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(410, 410, $toNativeArray($kindInt32, [163, 0, 163])), new CaseRange.ptr(412, 412, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(413, 413, $toNativeArray($kindInt32, [0, 213, 0])), new CaseRange.ptr(414, 414, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(415, 415, $toNativeArray($kindInt32, [0, 214, 0])), new CaseRange.ptr(416, 421, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(422, 422, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(423, 424, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(425, 425, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(428, 429, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(430, 430, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(431, 432, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(433, 434, $toNativeArray($kindInt32, [0, 217, 0])), new CaseRange.ptr(435, 438, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(439, 439, $toNativeArray($kindInt32, [0, 219, 0])), new CaseRange.ptr(440, 441, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(444, 445, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(447, 447, $toNativeArray($kindInt32, [56, 0, 56])), new CaseRange.ptr(452, 452, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(453, 453, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(454, 454, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(455, 455, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(456, 456, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(457, 457, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(458, 458, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(459, 459, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(460, 460, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(461, 476, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(477, 477, $toNativeArray($kindInt32, [-79, 0, -79])), new CaseRange.ptr(478, 495, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(497, 497, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(498, 498, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(499, 499, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(500, 501, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(502, 502, $toNativeArray($kindInt32, [0, -97, 0])), new CaseRange.ptr(503, 503, $toNativeArray($kindInt32, [0, -56, 0])), new CaseRange.ptr(504, 543, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(544, 544, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(546, 563, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(570, 570, $toNativeArray($kindInt32, [0, 10795, 0])), new CaseRange.ptr(571, 572, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(573, 573, $toNativeArray($kindInt32, [0, -163, 0])), new CaseRange.ptr(574, 574, $toNativeArray($kindInt32, [0, 10792, 0])), new CaseRange.ptr(575, 576, $toNativeArray($kindInt32, [10815, 0, 10815])), new CaseRange.ptr(577, 578, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(579, 579, $toNativeArray($kindInt32, [0, -195, 0])), new CaseRange.ptr(580, 580, $toNativeArray($kindInt32, [0, 69, 0])), new CaseRange.ptr(581, 581, $toNativeArray($kindInt32, [0, 71, 0])), new CaseRange.ptr(582, 591, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(592, 592, $toNativeArray($kindInt32, [10783, 0, 10783])), new CaseRange.ptr(593, 593, $toNativeArray($kindInt32, [10780, 0, 10780])), new CaseRange.ptr(594, 594, $toNativeArray($kindInt32, [10782, 0, 10782])), new CaseRange.ptr(595, 595, $toNativeArray($kindInt32, [-210, 0, -210])), new CaseRange.ptr(596, 596, $toNativeArray($kindInt32, [-206, 0, -206])), new CaseRange.ptr(598, 599, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(601, 601, $toNativeArray($kindInt32, [-202, 0, -202])), new CaseRange.ptr(603, 603, $toNativeArray($kindInt32, [-203, 0, -203])), new CaseRange.ptr(604, 604, $toNativeArray($kindInt32, [42319, 0, 42319])), new CaseRange.ptr(608, 608, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(609, 609, $toNativeArray($kindInt32, [42315, 0, 42315])), new CaseRange.ptr(611, 611, $toNativeArray($kindInt32, [-207, 0, -207])), new CaseRange.ptr(613, 613, $toNativeArray($kindInt32, [42280, 0, 42280])), new CaseRange.ptr(614, 614, $toNativeArray($kindInt32, [42308, 0, 42308])), new CaseRange.ptr(616, 616, $toNativeArray($kindInt32, [-209, 0, -209])), new CaseRange.ptr(617, 617, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(618, 618, $toNativeArray($kindInt32, [42308, 0, 42308])), new CaseRange.ptr(619, 619, $toNativeArray($kindInt32, [10743, 0, 10743])), new CaseRange.ptr(620, 620, $toNativeArray($kindInt32, [42305, 0, 42305])), new CaseRange.ptr(623, 623, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(625, 625, $toNativeArray($kindInt32, [10749, 0, 10749])), new CaseRange.ptr(626, 626, $toNativeArray($kindInt32, [-213, 0, -213])), new CaseRange.ptr(629, 629, $toNativeArray($kindInt32, [-214, 0, -214])), new CaseRange.ptr(637, 637, $toNativeArray($kindInt32, [10727, 0, 10727])), new CaseRange.ptr(640, 640, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(643, 643, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(647, 647, $toNativeArray($kindInt32, [42282, 0, 42282])), new CaseRange.ptr(648, 648, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(649, 649, $toNativeArray($kindInt32, [-69, 0, -69])), new CaseRange.ptr(650, 651, $toNativeArray($kindInt32, [-217, 0, -217])), new CaseRange.ptr(652, 652, $toNativeArray($kindInt32, [-71, 0, -71])), new CaseRange.ptr(658, 658, $toNativeArray($kindInt32, [-219, 0, -219])), new CaseRange.ptr(669, 669, $toNativeArray($kindInt32, [42261, 0, 42261])), new CaseRange.ptr(670, 670, $toNativeArray($kindInt32, [42258, 0, 42258])), new CaseRange.ptr(837, 837, $toNativeArray($kindInt32, [84, 0, 84])), new CaseRange.ptr(880, 883, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(886, 887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(891, 893, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(895, 895, $toNativeArray($kindInt32, [0, 116, 0])), new CaseRange.ptr(902, 902, $toNativeArray($kindInt32, [0, 38, 0])), new CaseRange.ptr(904, 906, $toNativeArray($kindInt32, [0, 37, 0])), new CaseRange.ptr(908, 908, $toNativeArray($kindInt32, [0, 64, 0])), new CaseRange.ptr(910, 911, $toNativeArray($kindInt32, [0, 63, 0])), new CaseRange.ptr(913, 929, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(931, 939, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(940, 940, $toNativeArray($kindInt32, [-38, 0, -38])), new CaseRange.ptr(941, 943, $toNativeArray($kindInt32, [-37, 0, -37])), new CaseRange.ptr(945, 961, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(962, 962, $toNativeArray($kindInt32, [-31, 0, -31])), new CaseRange.ptr(963, 971, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(972, 972, $toNativeArray($kindInt32, [-64, 0, -64])), new CaseRange.ptr(973, 974, $toNativeArray($kindInt32, [-63, 0, -63])), new CaseRange.ptr(975, 975, $toNativeArray($kindInt32, [0, 8, 0])), new CaseRange.ptr(976, 976, $toNativeArray($kindInt32, [-62, 0, -62])), new CaseRange.ptr(977, 977, $toNativeArray($kindInt32, [-57, 0, -57])), new CaseRange.ptr(981, 981, $toNativeArray($kindInt32, [-47, 0, -47])), new CaseRange.ptr(982, 982, $toNativeArray($kindInt32, [-54, 0, -54])), new CaseRange.ptr(983, 983, $toNativeArray($kindInt32, [-8, 0, -8])), new CaseRange.ptr(984, 1007, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1008, 1008, $toNativeArray($kindInt32, [-86, 0, -86])), new CaseRange.ptr(1009, 1009, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1010, 1010, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(1011, 1011, $toNativeArray($kindInt32, [-116, 0, -116])), new CaseRange.ptr(1012, 1012, $toNativeArray($kindInt32, [0, -60, 0])), new CaseRange.ptr(1013, 1013, $toNativeArray($kindInt32, [-96, 0, -96])), new CaseRange.ptr(1015, 1016, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1017, 1017, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(1018, 1019, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1021, 1023, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(1024, 1039, $toNativeArray($kindInt32, [0, 80, 0])), new CaseRange.ptr(1040, 1071, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(1072, 1103, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(1104, 1119, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1120, 1153, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1162, 1215, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1216, 1216, $toNativeArray($kindInt32, [0, 15, 0])), new CaseRange.ptr(1217, 1230, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1231, 1231, $toNativeArray($kindInt32, [-15, 0, -15])), new CaseRange.ptr(1232, 1327, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1329, 1366, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(1377, 1414, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(4256, 4293, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4295, 4295, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4301, 4301, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(5024, 5103, $toNativeArray($kindInt32, [0, 38864, 0])), new CaseRange.ptr(5104, 5109, $toNativeArray($kindInt32, [0, 8, 0])), new CaseRange.ptr(5112, 5117, $toNativeArray($kindInt32, [-8, 0, -8])), new CaseRange.ptr(7296, 7296, $toNativeArray($kindInt32, [-6254, 0, -6254])), new CaseRange.ptr(7297, 7297, $toNativeArray($kindInt32, [-6253, 0, -6253])), new CaseRange.ptr(7298, 7298, $toNativeArray($kindInt32, [-6244, 0, -6244])), new CaseRange.ptr(7299, 7300, $toNativeArray($kindInt32, [-6242, 0, -6242])), new CaseRange.ptr(7301, 7301, $toNativeArray($kindInt32, [-6243, 0, -6243])), new CaseRange.ptr(7302, 7302, $toNativeArray($kindInt32, [-6236, 0, -6236])), new CaseRange.ptr(7303, 7303, $toNativeArray($kindInt32, [-6181, 0, -6181])), new CaseRange.ptr(7304, 7304, $toNativeArray($kindInt32, [35266, 0, 35266])), new CaseRange.ptr(7545, 7545, $toNativeArray($kindInt32, [35332, 0, 35332])), new CaseRange.ptr(7549, 7549, $toNativeArray($kindInt32, [3814, 0, 3814])), new CaseRange.ptr(7680, 7829, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7835, 7835, $toNativeArray($kindInt32, [-59, 0, -59])), new CaseRange.ptr(7838, 7838, $toNativeArray($kindInt32, [0, -7615, 0])), new CaseRange.ptr(7840, 7935, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7936, 7943, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7944, 7951, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7952, 7957, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7960, 7965, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7968, 7975, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7976, 7983, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7984, 7991, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7992, 7999, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8000, 8005, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8008, 8013, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8017, 8017, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8019, 8019, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8021, 8021, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8023, 8023, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8025, 8025, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8027, 8027, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8029, 8029, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8031, 8031, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8032, 8039, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8040, 8047, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8048, 8049, $toNativeArray($kindInt32, [74, 0, 74])), new CaseRange.ptr(8050, 8053, $toNativeArray($kindInt32, [86, 0, 86])), new CaseRange.ptr(8054, 8055, $toNativeArray($kindInt32, [100, 0, 100])), new CaseRange.ptr(8056, 8057, $toNativeArray($kindInt32, [128, 0, 128])), new CaseRange.ptr(8058, 8059, $toNativeArray($kindInt32, [112, 0, 112])), new CaseRange.ptr(8060, 8061, $toNativeArray($kindInt32, [126, 0, 126])), new CaseRange.ptr(8064, 8071, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8072, 8079, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8080, 8087, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8088, 8095, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8096, 8103, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8104, 8111, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8112, 8113, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8115, 8115, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8120, 8121, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8122, 8123, $toNativeArray($kindInt32, [0, -74, 0])), new CaseRange.ptr(8124, 8124, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8126, 8126, $toNativeArray($kindInt32, [-7205, 0, -7205])), new CaseRange.ptr(8131, 8131, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8136, 8139, $toNativeArray($kindInt32, [0, -86, 0])), new CaseRange.ptr(8140, 8140, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8144, 8145, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8152, 8153, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8154, 8155, $toNativeArray($kindInt32, [0, -100, 0])), new CaseRange.ptr(8160, 8161, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8165, 8165, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(8168, 8169, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8170, 8171, $toNativeArray($kindInt32, [0, -112, 0])), new CaseRange.ptr(8172, 8172, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(8179, 8179, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8184, 8185, $toNativeArray($kindInt32, [0, -128, 0])), new CaseRange.ptr(8186, 8187, $toNativeArray($kindInt32, [0, -126, 0])), new CaseRange.ptr(8188, 8188, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8486, 8486, $toNativeArray($kindInt32, [0, -7517, 0])), new CaseRange.ptr(8490, 8490, $toNativeArray($kindInt32, [0, -8383, 0])), new CaseRange.ptr(8491, 8491, $toNativeArray($kindInt32, [0, -8262, 0])), new CaseRange.ptr(8498, 8498, $toNativeArray($kindInt32, [0, 28, 0])), new CaseRange.ptr(8526, 8526, $toNativeArray($kindInt32, [-28, 0, -28])), new CaseRange.ptr(8544, 8559, $toNativeArray($kindInt32, [0, 16, 0])), new CaseRange.ptr(8560, 8575, $toNativeArray($kindInt32, [-16, 0, -16])), new CaseRange.ptr(8579, 8580, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(9398, 9423, $toNativeArray($kindInt32, [0, 26, 0])), new CaseRange.ptr(9424, 9449, $toNativeArray($kindInt32, [-26, 0, -26])), new CaseRange.ptr(11264, 11310, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(11312, 11358, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(11360, 11361, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11362, 11362, $toNativeArray($kindInt32, [0, -10743, 0])), new CaseRange.ptr(11363, 11363, $toNativeArray($kindInt32, [0, -3814, 0])), new CaseRange.ptr(11364, 11364, $toNativeArray($kindInt32, [0, -10727, 0])), new CaseRange.ptr(11365, 11365, $toNativeArray($kindInt32, [-10795, 0, -10795])), new CaseRange.ptr(11366, 11366, $toNativeArray($kindInt32, [-10792, 0, -10792])), new CaseRange.ptr(11367, 11372, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11373, 11373, $toNativeArray($kindInt32, [0, -10780, 0])), new CaseRange.ptr(11374, 11374, $toNativeArray($kindInt32, [0, -10749, 0])), new CaseRange.ptr(11375, 11375, $toNativeArray($kindInt32, [0, -10783, 0])), new CaseRange.ptr(11376, 11376, $toNativeArray($kindInt32, [0, -10782, 0])), new CaseRange.ptr(11378, 11379, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11381, 11382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11390, 11391, $toNativeArray($kindInt32, [0, -10815, 0])), new CaseRange.ptr(11392, 11491, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11499, 11502, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11506, 11507, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11520, 11557, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11559, 11559, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11565, 11565, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(42560, 42605, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42624, 42651, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42786, 42799, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42802, 42863, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42873, 42876, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42877, 42877, $toNativeArray($kindInt32, [0, -35332, 0])), new CaseRange.ptr(42878, 42887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42891, 42892, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42893, 42893, $toNativeArray($kindInt32, [0, -42280, 0])), new CaseRange.ptr(42896, 42899, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42902, 42921, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42922, 42922, $toNativeArray($kindInt32, [0, -42308, 0])), new CaseRange.ptr(42923, 42923, $toNativeArray($kindInt32, [0, -42319, 0])), new CaseRange.ptr(42924, 42924, $toNativeArray($kindInt32, [0, -42315, 0])), new CaseRange.ptr(42925, 42925, $toNativeArray($kindInt32, [0, -42305, 0])), new CaseRange.ptr(42926, 42926, $toNativeArray($kindInt32, [0, -42308, 0])), new CaseRange.ptr(42928, 42928, $toNativeArray($kindInt32, [0, -42258, 0])), new CaseRange.ptr(42929, 42929, $toNativeArray($kindInt32, [0, -42282, 0])), new CaseRange.ptr(42930, 42930, $toNativeArray($kindInt32, [0, -42261, 0])), new CaseRange.ptr(42931, 42931, $toNativeArray($kindInt32, [0, 928, 0])), new CaseRange.ptr(42932, 42935, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(43859, 43859, $toNativeArray($kindInt32, [-928, 0, -928])), new CaseRange.ptr(43888, 43967, $toNativeArray($kindInt32, [-38864, 0, -38864])), new CaseRange.ptr(65313, 65338, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(65345, 65370, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(66560, 66599, $toNativeArray($kindInt32, [0, 40, 0])), new CaseRange.ptr(66600, 66639, $toNativeArray($kindInt32, [-40, 0, -40])), new CaseRange.ptr(66736, 66771, $toNativeArray($kindInt32, [0, 40, 0])), new CaseRange.ptr(66776, 66811, $toNativeArray($kindInt32, [-40, 0, -40])), new CaseRange.ptr(68736, 68786, $toNativeArray($kindInt32, [0, 64, 0])), new CaseRange.ptr(68800, 68850, $toNativeArray($kindInt32, [-64, 0, -64])), new CaseRange.ptr(71840, 71871, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(71872, 71903, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(125184, 125217, $toNativeArray($kindInt32, [0, 34, 0])), new CaseRange.ptr(125218, 125251, $toNativeArray($kindInt32, [-34, 0, -34]))]); - $pkg.CaseRanges = _CaseRanges; - properties = $toNativeArray($kindUint8, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 144, 130, 130, 130, 136, 130, 130, 130, 130, 130, 130, 136, 130, 130, 130, 130, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 130, 130, 136, 136, 136, 130, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 130, 130, 130, 136, 130, 136, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 130, 136, 130, 136, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 130, 136, 136, 136, 136, 136, 130, 136, 136, 224, 130, 136, 0, 136, 136, 136, 136, 132, 132, 136, 192, 130, 130, 136, 132, 224, 130, 132, 132, 132, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 136, 160, 160, 160, 160, 160, 160, 160, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 136, 192, 192, 192, 192, 192, 192, 192, 192]); - asciiFold = $toNativeArray($kindUint16, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95, 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 8490, 76, 77, 78, 79, 80, 81, 82, 383, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127]); - caseOrbit = new sliceType$4([new foldPair.ptr(75, 107), new foldPair.ptr(83, 115), new foldPair.ptr(107, 8490), new foldPair.ptr(115, 383), new foldPair.ptr(181, 924), new foldPair.ptr(197, 229), new foldPair.ptr(223, 7838), new foldPair.ptr(229, 8491), new foldPair.ptr(304, 304), new foldPair.ptr(305, 305), new foldPair.ptr(383, 83), new foldPair.ptr(452, 453), new foldPair.ptr(453, 454), new foldPair.ptr(454, 452), new foldPair.ptr(455, 456), new foldPair.ptr(456, 457), new foldPair.ptr(457, 455), new foldPair.ptr(458, 459), new foldPair.ptr(459, 460), new foldPair.ptr(460, 458), new foldPair.ptr(497, 498), new foldPair.ptr(498, 499), new foldPair.ptr(499, 497), new foldPair.ptr(837, 921), new foldPair.ptr(914, 946), new foldPair.ptr(917, 949), new foldPair.ptr(920, 952), new foldPair.ptr(921, 953), new foldPair.ptr(922, 954), new foldPair.ptr(924, 956), new foldPair.ptr(928, 960), new foldPair.ptr(929, 961), new foldPair.ptr(931, 962), new foldPair.ptr(934, 966), new foldPair.ptr(937, 969), new foldPair.ptr(946, 976), new foldPair.ptr(949, 1013), new foldPair.ptr(952, 977), new foldPair.ptr(953, 8126), new foldPair.ptr(954, 1008), new foldPair.ptr(956, 181), new foldPair.ptr(960, 982), new foldPair.ptr(961, 1009), new foldPair.ptr(962, 963), new foldPair.ptr(963, 931), new foldPair.ptr(966, 981), new foldPair.ptr(969, 8486), new foldPair.ptr(976, 914), new foldPair.ptr(977, 1012), new foldPair.ptr(981, 934), new foldPair.ptr(982, 928), new foldPair.ptr(1008, 922), new foldPair.ptr(1009, 929), new foldPair.ptr(1012, 920), new foldPair.ptr(1013, 917), new foldPair.ptr(1042, 1074), new foldPair.ptr(1044, 1076), new foldPair.ptr(1054, 1086), new foldPair.ptr(1057, 1089), new foldPair.ptr(1058, 1090), new foldPair.ptr(1066, 1098), new foldPair.ptr(1074, 7296), new foldPair.ptr(1076, 7297), new foldPair.ptr(1086, 7298), new foldPair.ptr(1089, 7299), new foldPair.ptr(1090, 7300), new foldPair.ptr(1098, 7302), new foldPair.ptr(1122, 1123), new foldPair.ptr(1123, 7303), new foldPair.ptr(7296, 1042), new foldPair.ptr(7297, 1044), new foldPair.ptr(7298, 1054), new foldPair.ptr(7299, 1057), new foldPair.ptr(7300, 7301), new foldPair.ptr(7301, 1058), new foldPair.ptr(7302, 1066), new foldPair.ptr(7303, 1122), new foldPair.ptr(7304, 42570), new foldPair.ptr(7776, 7777), new foldPair.ptr(7777, 7835), new foldPair.ptr(7835, 7776), new foldPair.ptr(7838, 223), new foldPair.ptr(8126, 837), new foldPair.ptr(8486, 937), new foldPair.ptr(8490, 75), new foldPair.ptr(8491, 197), new foldPair.ptr(42570, 42571), new foldPair.ptr(42571, 7304)]); - foldL = new RangeTable.ptr(new sliceType([new Range16.ptr(837, 837, 1)]), sliceType$1.nil, 0); - foldLl = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 222, 1), new Range16.ptr(256, 302, 2), new Range16.ptr(306, 310, 2), new Range16.ptr(313, 327, 2), new Range16.ptr(330, 376, 2), new Range16.ptr(377, 381, 2), new Range16.ptr(385, 386, 1), new Range16.ptr(388, 390, 2), new Range16.ptr(391, 393, 2), new Range16.ptr(394, 395, 1), new Range16.ptr(398, 401, 1), new Range16.ptr(403, 404, 1), new Range16.ptr(406, 408, 1), new Range16.ptr(412, 413, 1), new Range16.ptr(415, 416, 1), new Range16.ptr(418, 422, 2), new Range16.ptr(423, 425, 2), new Range16.ptr(428, 430, 2), new Range16.ptr(431, 433, 2), new Range16.ptr(434, 435, 1), new Range16.ptr(437, 439, 2), new Range16.ptr(440, 444, 4), new Range16.ptr(452, 453, 1), new Range16.ptr(455, 456, 1), new Range16.ptr(458, 459, 1), new Range16.ptr(461, 475, 2), new Range16.ptr(478, 494, 2), new Range16.ptr(497, 498, 1), new Range16.ptr(500, 502, 2), new Range16.ptr(503, 504, 1), new Range16.ptr(506, 562, 2), new Range16.ptr(570, 571, 1), new Range16.ptr(573, 574, 1), new Range16.ptr(577, 579, 2), new Range16.ptr(580, 582, 1), new Range16.ptr(584, 590, 2), new Range16.ptr(837, 880, 43), new Range16.ptr(882, 886, 4), new Range16.ptr(895, 902, 7), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 913, 2), new Range16.ptr(914, 929, 1), new Range16.ptr(931, 939, 1), new Range16.ptr(975, 984, 9), new Range16.ptr(986, 1006, 2), new Range16.ptr(1012, 1015, 3), new Range16.ptr(1017, 1018, 1), new Range16.ptr(1021, 1071, 1), new Range16.ptr(1120, 1152, 2), new Range16.ptr(1162, 1216, 2), new Range16.ptr(1217, 1229, 2), new Range16.ptr(1232, 1326, 2), new Range16.ptr(1329, 1366, 1), new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(5024, 5109, 1), new Range16.ptr(7680, 7828, 2), new Range16.ptr(7838, 7934, 2), new Range16.ptr(7944, 7951, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7976, 7983, 1), new Range16.ptr(7992, 7999, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8040, 8047, 1), new Range16.ptr(8072, 8079, 1), new Range16.ptr(8088, 8095, 1), new Range16.ptr(8104, 8111, 1), new Range16.ptr(8120, 8124, 1), new Range16.ptr(8136, 8140, 1), new Range16.ptr(8152, 8155, 1), new Range16.ptr(8168, 8172, 1), new Range16.ptr(8184, 8188, 1), new Range16.ptr(8486, 8490, 4), new Range16.ptr(8491, 8498, 7), new Range16.ptr(8579, 11264, 2685), new Range16.ptr(11265, 11310, 1), new Range16.ptr(11360, 11362, 2), new Range16.ptr(11363, 11364, 1), new Range16.ptr(11367, 11373, 2), new Range16.ptr(11374, 11376, 1), new Range16.ptr(11378, 11381, 3), new Range16.ptr(11390, 11392, 1), new Range16.ptr(11394, 11490, 2), new Range16.ptr(11499, 11501, 2), new Range16.ptr(11506, 42560, 31054), new Range16.ptr(42562, 42604, 2), new Range16.ptr(42624, 42650, 2), new Range16.ptr(42786, 42798, 2), new Range16.ptr(42802, 42862, 2), new Range16.ptr(42873, 42877, 2), new Range16.ptr(42878, 42886, 2), new Range16.ptr(42891, 42893, 2), new Range16.ptr(42896, 42898, 2), new Range16.ptr(42902, 42922, 2), new Range16.ptr(42923, 42926, 1), new Range16.ptr(42928, 42932, 1), new Range16.ptr(42934, 65313, 22379), new Range16.ptr(65314, 65338, 1)]), new sliceType$1([new Range32.ptr(66560, 66599, 1), new Range32.ptr(66736, 66771, 1), new Range32.ptr(68736, 68786, 1), new Range32.ptr(71840, 71871, 1), new Range32.ptr(125184, 125217, 1)]), 3); - foldLt = new RangeTable.ptr(new sliceType([new Range16.ptr(452, 454, 2), new Range16.ptr(455, 457, 2), new Range16.ptr(458, 460, 2), new Range16.ptr(497, 499, 2), new Range16.ptr(8064, 8071, 1), new Range16.ptr(8080, 8087, 1), new Range16.ptr(8096, 8103, 1), new Range16.ptr(8115, 8131, 16), new Range16.ptr(8179, 8179, 1)]), sliceType$1.nil, 0); - foldLu = new RangeTable.ptr(new sliceType([new Range16.ptr(97, 122, 1), new Range16.ptr(181, 223, 42), new Range16.ptr(224, 246, 1), new Range16.ptr(248, 255, 1), new Range16.ptr(257, 303, 2), new Range16.ptr(307, 311, 2), new Range16.ptr(314, 328, 2), new Range16.ptr(331, 375, 2), new Range16.ptr(378, 382, 2), new Range16.ptr(383, 384, 1), new Range16.ptr(387, 389, 2), new Range16.ptr(392, 396, 4), new Range16.ptr(402, 405, 3), new Range16.ptr(409, 410, 1), new Range16.ptr(414, 417, 3), new Range16.ptr(419, 421, 2), new Range16.ptr(424, 429, 5), new Range16.ptr(432, 436, 4), new Range16.ptr(438, 441, 3), new Range16.ptr(445, 447, 2), new Range16.ptr(453, 454, 1), new Range16.ptr(456, 457, 1), new Range16.ptr(459, 460, 1), new Range16.ptr(462, 476, 2), new Range16.ptr(477, 495, 2), new Range16.ptr(498, 499, 1), new Range16.ptr(501, 505, 4), new Range16.ptr(507, 543, 2), new Range16.ptr(547, 563, 2), new Range16.ptr(572, 575, 3), new Range16.ptr(576, 578, 2), new Range16.ptr(583, 591, 2), new Range16.ptr(592, 596, 1), new Range16.ptr(598, 599, 1), new Range16.ptr(601, 603, 2), new Range16.ptr(604, 608, 4), new Range16.ptr(609, 613, 2), new Range16.ptr(614, 616, 2), new Range16.ptr(617, 620, 1), new Range16.ptr(623, 625, 2), new Range16.ptr(626, 629, 3), new Range16.ptr(637, 643, 3), new Range16.ptr(647, 652, 1), new Range16.ptr(658, 669, 11), new Range16.ptr(670, 837, 167), new Range16.ptr(881, 883, 2), new Range16.ptr(887, 891, 4), new Range16.ptr(892, 893, 1), new Range16.ptr(940, 943, 1), new Range16.ptr(945, 974, 1), new Range16.ptr(976, 977, 1), new Range16.ptr(981, 983, 1), new Range16.ptr(985, 1007, 2), new Range16.ptr(1008, 1011, 1), new Range16.ptr(1013, 1019, 3), new Range16.ptr(1072, 1119, 1), new Range16.ptr(1121, 1153, 2), new Range16.ptr(1163, 1215, 2), new Range16.ptr(1218, 1230, 2), new Range16.ptr(1231, 1327, 2), new Range16.ptr(1377, 1414, 1), new Range16.ptr(5112, 5117, 1), new Range16.ptr(7296, 7304, 1), new Range16.ptr(7545, 7549, 4), new Range16.ptr(7681, 7829, 2), new Range16.ptr(7835, 7841, 6), new Range16.ptr(7843, 7935, 2), new Range16.ptr(7936, 7943, 1), new Range16.ptr(7952, 7957, 1), new Range16.ptr(7968, 7975, 1), new Range16.ptr(7984, 7991, 1), new Range16.ptr(8000, 8005, 1), new Range16.ptr(8017, 8023, 2), new Range16.ptr(8032, 8039, 1), new Range16.ptr(8048, 8061, 1), new Range16.ptr(8112, 8113, 1), new Range16.ptr(8126, 8144, 18), new Range16.ptr(8145, 8160, 15), new Range16.ptr(8161, 8165, 4), new Range16.ptr(8526, 8580, 54), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11361, 11365, 4), new Range16.ptr(11366, 11372, 2), new Range16.ptr(11379, 11382, 3), new Range16.ptr(11393, 11491, 2), new Range16.ptr(11500, 11502, 2), new Range16.ptr(11507, 11520, 13), new Range16.ptr(11521, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(42561, 42605, 2), new Range16.ptr(42625, 42651, 2), new Range16.ptr(42787, 42799, 2), new Range16.ptr(42803, 42863, 2), new Range16.ptr(42874, 42876, 2), new Range16.ptr(42879, 42887, 2), new Range16.ptr(42892, 42897, 5), new Range16.ptr(42899, 42903, 4), new Range16.ptr(42905, 42921, 2), new Range16.ptr(42933, 42935, 2), new Range16.ptr(43859, 43888, 29), new Range16.ptr(43889, 43967, 1), new Range16.ptr(65345, 65370, 1)]), new sliceType$1([new Range32.ptr(66600, 66639, 1), new Range32.ptr(66776, 66811, 1), new Range32.ptr(68800, 68850, 1), new Range32.ptr(71872, 71903, 1), new Range32.ptr(125218, 125251, 1)]), 4); - foldM = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); - foldMn = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); - $pkg.FoldCategory = $makeMap($String.keyFor, [{ k: "L", v: foldL }, { k: "Ll", v: foldLl }, { k: "Lt", v: foldLt }, { k: "Lu", v: foldLu }, { k: "M", v: foldM }, { k: "Mn", v: foldMn }]); - foldCommon = new RangeTable.ptr(new sliceType([new Range16.ptr(924, 956, 32)]), sliceType$1.nil, 0); - foldGreek = new RangeTable.ptr(new sliceType([new Range16.ptr(181, 837, 656)]), sliceType$1.nil, 0); - foldInherited = new RangeTable.ptr(new sliceType([new Range16.ptr(921, 953, 32), new Range16.ptr(8126, 8126, 1)]), sliceType$1.nil, 0); - $pkg.FoldScript = $makeMap($String.keyFor, [{ k: "Common", v: foldCommon }, { k: "Greek", v: foldGreek }, { k: "Inherited", v: foldInherited }]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["reflect"] = (function() { - var $pkg = {}, $init, errors, js, math, runtime, strconv, sync, unicode, utf8, uncommonType, funcType, name, nameData, mapIter, Type, Kind, tflag, rtype, typeAlg, method, ChanDir, arrayType, chanType, imethod, interfaceType, mapType, ptrType, sliceType, structField, structType, Method, nameOff, typeOff, textOff, StructField, StructTag, fieldScan, Value, flag, ValueError, MapIter, sliceType$1, ptrType$1, sliceType$2, sliceType$3, ptrType$2, funcType$1, sliceType$4, ptrType$3, ptrType$4, sliceType$5, sliceType$6, sliceType$7, ptrType$5, ptrType$6, structType$3, sliceType$8, sliceType$9, ptrType$7, ptrType$8, sliceType$10, sliceType$11, ptrType$9, ptrType$10, sliceType$13, sliceType$14, ptrType$11, sliceType$15, ptrType$17, sliceType$18, funcType$3, funcType$4, funcType$5, ptrType$18, arrayType$8, ptrType$19, ptrType$20, initialized, uncommonTypeMap, nameMap, nameOffList, typeOffList, callHelper, jsObjectPtr, selectHelper, kindNames, uint8Type, init, jsType, reflectType, setKindType, newName, newNameOff, newTypeOff, internalStr, isWrapped, copyStruct, makeValue, MakeSlice, TypeOf, ValueOf, FuncOf, SliceOf, Zero, unsafe_New, makeInt, typedmemmove, keyFor, mapaccess, mapassign, mapdelete, mapiterinit, mapiterkey, mapitervalue, mapiternext, maplen, cvtDirect, methodReceiver, valueInterface, ifaceE2I, methodName, makeMethodValue, wrapJsObject, unwrapJsObject, getJsTag, chanrecv, chansend, Swapper, PtrTo, implements$1, directlyAssignable, haveIdenticalType, haveIdenticalUnderlyingType, toType, ifaceIndir, copyVal, overflowFloat32, New, convertOp, makeFloat, makeComplex, makeString, makeBytes, makeRunes, cvtInt, cvtUint, cvtFloatInt, cvtFloatUint, cvtIntFloat, cvtUintFloat, cvtFloat, cvtComplex, cvtIntString, cvtUintString, cvtBytesString, cvtStringBytes, cvtRunesString, cvtStringRunes, cvtT2I, cvtI2I; - errors = $packages["errors"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - math = $packages["math"]; - runtime = $packages["runtime"]; - strconv = $packages["strconv"]; - sync = $packages["sync"]; - unicode = $packages["unicode"]; - utf8 = $packages["unicode/utf8"]; - uncommonType = $pkg.uncommonType = $newType(0, $kindStruct, "reflect.uncommonType", true, "reflect", false, function(pkgPath_, mcount_, xcount_, moff_, _methods_) { - this.$val = this; - if (arguments.length === 0) { - this.pkgPath = 0; - this.mcount = 0; - this.xcount = 0; - this.moff = 0; - this._methods = sliceType$5.nil; - return; - } - this.pkgPath = pkgPath_; - this.mcount = mcount_; - this.xcount = xcount_; - this.moff = moff_; - this._methods = _methods_; - }); - funcType = $pkg.funcType = $newType(0, $kindStruct, "reflect.funcType", true, "reflect", false, function(rtype_, inCount_, outCount_, _in_, _out_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.inCount = 0; - this.outCount = 0; - this._in = sliceType$2.nil; - this._out = sliceType$2.nil; - return; - } - this.rtype = rtype_; - this.inCount = inCount_; - this.outCount = outCount_; - this._in = _in_; - this._out = _out_; - }); - name = $pkg.name = $newType(0, $kindStruct, "reflect.name", true, "reflect", false, function(bytes_) { - this.$val = this; - if (arguments.length === 0) { - this.bytes = ptrType$4.nil; - return; - } - this.bytes = bytes_; - }); - nameData = $pkg.nameData = $newType(0, $kindStruct, "reflect.nameData", true, "reflect", false, function(name_, tag_, exported_) { - this.$val = this; - if (arguments.length === 0) { - this.name = ""; - this.tag = ""; - this.exported = false; - return; - } - this.name = name_; - this.tag = tag_; - this.exported = exported_; - }); - mapIter = $pkg.mapIter = $newType(0, $kindStruct, "reflect.mapIter", true, "reflect", false, function(t_, m_, keys_, i_, last_) { - this.$val = this; - if (arguments.length === 0) { - this.t = $ifaceNil; - this.m = null; - this.keys = null; - this.i = 0; - this.last = null; - return; - } - this.t = t_; - this.m = m_; - this.keys = keys_; - this.i = i_; - this.last = last_; - }); - Type = $pkg.Type = $newType(8, $kindInterface, "reflect.Type", true, "reflect", true, null); - Kind = $pkg.Kind = $newType(4, $kindUint, "reflect.Kind", true, "reflect", true, null); - tflag = $pkg.tflag = $newType(1, $kindUint8, "reflect.tflag", true, "reflect", false, null); - rtype = $pkg.rtype = $newType(0, $kindStruct, "reflect.rtype", true, "reflect", false, function(size_, ptrdata_, hash_, tflag_, align_, fieldAlign_, kind_, alg_, gcdata_, str_, ptrToThis_) { - this.$val = this; - if (arguments.length === 0) { - this.size = 0; - this.ptrdata = 0; - this.hash = 0; - this.tflag = 0; - this.align = 0; - this.fieldAlign = 0; - this.kind = 0; - this.alg = ptrType$3.nil; - this.gcdata = ptrType$4.nil; - this.str = 0; - this.ptrToThis = 0; - return; - } - this.size = size_; - this.ptrdata = ptrdata_; - this.hash = hash_; - this.tflag = tflag_; - this.align = align_; - this.fieldAlign = fieldAlign_; - this.kind = kind_; - this.alg = alg_; - this.gcdata = gcdata_; - this.str = str_; - this.ptrToThis = ptrToThis_; - }); - typeAlg = $pkg.typeAlg = $newType(0, $kindStruct, "reflect.typeAlg", true, "reflect", false, function(hash_, equal_) { - this.$val = this; - if (arguments.length === 0) { - this.hash = $throwNilPointerError; - this.equal = $throwNilPointerError; - return; - } - this.hash = hash_; - this.equal = equal_; - }); - method = $pkg.method = $newType(0, $kindStruct, "reflect.method", true, "reflect", false, function(name_, mtyp_, ifn_, tfn_) { - this.$val = this; - if (arguments.length === 0) { - this.name = 0; - this.mtyp = 0; - this.ifn = 0; - this.tfn = 0; - return; - } - this.name = name_; - this.mtyp = mtyp_; - this.ifn = ifn_; - this.tfn = tfn_; - }); - ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "reflect.ChanDir", true, "reflect", true, null); - arrayType = $pkg.arrayType = $newType(0, $kindStruct, "reflect.arrayType", true, "reflect", false, function(rtype_, elem_, slice_, len_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.elem = ptrType$1.nil; - this.slice = ptrType$1.nil; - this.len = 0; - return; - } - this.rtype = rtype_; - this.elem = elem_; - this.slice = slice_; - this.len = len_; - }); - chanType = $pkg.chanType = $newType(0, $kindStruct, "reflect.chanType", true, "reflect", false, function(rtype_, elem_, dir_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.elem = ptrType$1.nil; - this.dir = 0; - return; - } - this.rtype = rtype_; - this.elem = elem_; - this.dir = dir_; - }); - imethod = $pkg.imethod = $newType(0, $kindStruct, "reflect.imethod", true, "reflect", false, function(name_, typ_) { - this.$val = this; - if (arguments.length === 0) { - this.name = 0; - this.typ = 0; - return; - } - this.name = name_; - this.typ = typ_; - }); - interfaceType = $pkg.interfaceType = $newType(0, $kindStruct, "reflect.interfaceType", true, "reflect", false, function(rtype_, pkgPath_, methods_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.pkgPath = new name.ptr(ptrType$4.nil); - this.methods = sliceType$6.nil; - return; - } - this.rtype = rtype_; - this.pkgPath = pkgPath_; - this.methods = methods_; - }); - mapType = $pkg.mapType = $newType(0, $kindStruct, "reflect.mapType", true, "reflect", false, function(rtype_, key_, elem_, bucket_, keysize_, valuesize_, bucketsize_, flags_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.key = ptrType$1.nil; - this.elem = ptrType$1.nil; - this.bucket = ptrType$1.nil; - this.keysize = 0; - this.valuesize = 0; - this.bucketsize = 0; - this.flags = 0; - return; - } - this.rtype = rtype_; - this.key = key_; - this.elem = elem_; - this.bucket = bucket_; - this.keysize = keysize_; - this.valuesize = valuesize_; - this.bucketsize = bucketsize_; - this.flags = flags_; - }); - ptrType = $pkg.ptrType = $newType(0, $kindStruct, "reflect.ptrType", true, "reflect", false, function(rtype_, elem_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.elem = ptrType$1.nil; - return; - } - this.rtype = rtype_; - this.elem = elem_; - }); - sliceType = $pkg.sliceType = $newType(0, $kindStruct, "reflect.sliceType", true, "reflect", false, function(rtype_, elem_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.elem = ptrType$1.nil; - return; - } - this.rtype = rtype_; - this.elem = elem_; - }); - structField = $pkg.structField = $newType(0, $kindStruct, "reflect.structField", true, "reflect", false, function(name_, typ_, offsetEmbed_) { - this.$val = this; - if (arguments.length === 0) { - this.name = new name.ptr(ptrType$4.nil); - this.typ = ptrType$1.nil; - this.offsetEmbed = 0; - return; - } - this.name = name_; - this.typ = typ_; - this.offsetEmbed = offsetEmbed_; - }); - structType = $pkg.structType = $newType(0, $kindStruct, "reflect.structType", true, "reflect", false, function(rtype_, pkgPath_, fields_) { - this.$val = this; - if (arguments.length === 0) { - this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - this.pkgPath = new name.ptr(ptrType$4.nil); - this.fields = sliceType$7.nil; - return; - } - this.rtype = rtype_; - this.pkgPath = pkgPath_; - this.fields = fields_; - }); - Method = $pkg.Method = $newType(0, $kindStruct, "reflect.Method", true, "reflect", true, function(Name_, PkgPath_, Type_, Func_, Index_) { - this.$val = this; - if (arguments.length === 0) { - this.Name = ""; - this.PkgPath = ""; - this.Type = $ifaceNil; - this.Func = new Value.ptr(ptrType$1.nil, 0, 0); - this.Index = 0; - return; - } - this.Name = Name_; - this.PkgPath = PkgPath_; - this.Type = Type_; - this.Func = Func_; - this.Index = Index_; - }); - nameOff = $pkg.nameOff = $newType(4, $kindInt32, "reflect.nameOff", true, "reflect", false, null); - typeOff = $pkg.typeOff = $newType(4, $kindInt32, "reflect.typeOff", true, "reflect", false, null); - textOff = $pkg.textOff = $newType(4, $kindInt32, "reflect.textOff", true, "reflect", false, null); - StructField = $pkg.StructField = $newType(0, $kindStruct, "reflect.StructField", true, "reflect", true, function(Name_, PkgPath_, Type_, Tag_, Offset_, Index_, Anonymous_) { - this.$val = this; - if (arguments.length === 0) { - this.Name = ""; - this.PkgPath = ""; - this.Type = $ifaceNil; - this.Tag = ""; - this.Offset = 0; - this.Index = sliceType$13.nil; - this.Anonymous = false; - return; - } - this.Name = Name_; - this.PkgPath = PkgPath_; - this.Type = Type_; - this.Tag = Tag_; - this.Offset = Offset_; - this.Index = Index_; - this.Anonymous = Anonymous_; - }); - StructTag = $pkg.StructTag = $newType(8, $kindString, "reflect.StructTag", true, "reflect", true, null); - fieldScan = $pkg.fieldScan = $newType(0, $kindStruct, "reflect.fieldScan", true, "reflect", false, function(typ_, index_) { - this.$val = this; - if (arguments.length === 0) { - this.typ = ptrType$11.nil; - this.index = sliceType$13.nil; - return; - } - this.typ = typ_; - this.index = index_; - }); - Value = $pkg.Value = $newType(0, $kindStruct, "reflect.Value", true, "reflect", true, function(typ_, ptr_, flag_) { - this.$val = this; - if (arguments.length === 0) { - this.typ = ptrType$1.nil; - this.ptr = 0; - this.flag = 0; - return; - } - this.typ = typ_; - this.ptr = ptr_; - this.flag = flag_; - }); - flag = $pkg.flag = $newType(4, $kindUintptr, "reflect.flag", true, "reflect", false, null); - ValueError = $pkg.ValueError = $newType(0, $kindStruct, "reflect.ValueError", true, "reflect", true, function(Method_, Kind_) { - this.$val = this; - if (arguments.length === 0) { - this.Method = ""; - this.Kind = 0; - return; - } - this.Method = Method_; - this.Kind = Kind_; - }); - MapIter = $pkg.MapIter = $newType(0, $kindStruct, "reflect.MapIter", true, "reflect", true, function(m_, it_) { - this.$val = this; - if (arguments.length === 0) { - this.m = new Value.ptr(ptrType$1.nil, 0, 0); - this.it = 0; - return; - } - this.m = m_; - this.it = it_; - }); - sliceType$1 = $sliceType(name); - ptrType$1 = $ptrType(rtype); - sliceType$2 = $sliceType(ptrType$1); - sliceType$3 = $sliceType($emptyInterface); - ptrType$2 = $ptrType(js.Object); - funcType$1 = $funcType([sliceType$3], [ptrType$2], true); - sliceType$4 = $sliceType($String); - ptrType$3 = $ptrType(typeAlg); - ptrType$4 = $ptrType($Uint8); - sliceType$5 = $sliceType(method); - sliceType$6 = $sliceType(imethod); - sliceType$7 = $sliceType(structField); - ptrType$5 = $ptrType(uncommonType); - ptrType$6 = $ptrType(nameData); - structType$3 = $structType("reflect", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); - sliceType$8 = $sliceType(ptrType$2); - sliceType$9 = $sliceType(Value); - ptrType$7 = $ptrType(mapIter); - ptrType$8 = $ptrType(funcType); - sliceType$10 = $sliceType(Type); - sliceType$11 = $sliceType(sliceType$8); - ptrType$9 = $ptrType(interfaceType); - ptrType$10 = $ptrType(imethod); - sliceType$13 = $sliceType($Int); - sliceType$14 = $sliceType(fieldScan); - ptrType$11 = $ptrType(structType); - sliceType$15 = $sliceType($Uint8); - ptrType$17 = $ptrType($UnsafePointer); - sliceType$18 = $sliceType($Int32); - funcType$3 = $funcType([$String], [$Bool], false); - funcType$4 = $funcType([$UnsafePointer, $Uintptr], [$Uintptr], false); - funcType$5 = $funcType([$UnsafePointer, $UnsafePointer], [$Bool], false); - ptrType$18 = $ptrType(structField); - arrayType$8 = $arrayType($Uintptr, 2); - ptrType$19 = $ptrType(MapIter); - ptrType$20 = $ptrType(ValueError); - init = function() { - var used, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; used = $f.used; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - used = (function(i) { - var i; - }); - $r = used((x = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$1 = new uncommonType.ptr(0, 0, 0, 0, sliceType$5.nil), new x$1.constructor.elem(x$1))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$2 = new method.ptr(0, 0, 0, 0), new x$2.constructor.elem(x$2))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$3 = new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, 0), new x$3.constructor.elem(x$3))); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$4 = new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, 0), new x$4.constructor.elem(x$4))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$5 = new funcType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), 0, 0, sliceType$2.nil, sliceType$2.nil), new x$5.constructor.elem(x$5))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$6 = new interfaceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$6.nil), new x$6.constructor.elem(x$6))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$7 = new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0), new x$7.constructor.elem(x$7))); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$8 = new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$8.constructor.elem(x$8))); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$9 = new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$9.constructor.elem(x$9))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$10 = new structType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$7.nil), new x$10.constructor.elem(x$10))); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$11 = new imethod.ptr(0, 0), new x$11.constructor.elem(x$11))); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = used((x$12 = new structField.ptr(new name.ptr(ptrType$4.nil), ptrType$1.nil, 0), new x$12.constructor.elem(x$12))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - initialized = true; - uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: init }; } $f.used = used; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; - }; - jsType = function(typ) { - var typ; - return typ.jsType; - }; - reflectType = function(typ) { - var _1, _i, _i$1, _i$2, _i$3, _key, _ref, _ref$1, _ref$2, _ref$3, dir, exported, exported$1, f, fields, i, i$1, i$2, i$3, i$4, i$5, imethods, in$1, m, m$1, m$2, methodSet, methods, offsetEmbed, out, outCount, params, reflectFields, reflectMethods, results, rt, typ, ut, xcount; - if (typ.reflectType === undefined) { - rt = new rtype.ptr(((($parseInt(typ.size) >> 0) >>> 0)), 0, 0, 0, 0, 0, ((($parseInt(typ.kind) >> 0) << 24 >>> 24)), ptrType$3.nil, ptrType$4.nil, newNameOff($clone(newName(internalStr(typ.string), "", !!(typ.exported)), name)), 0); - rt.jsType = typ; - typ.reflectType = rt; - methodSet = $methodSet(typ); - if (!(($parseInt(methodSet.length) === 0)) || !!(typ.named)) { - rt.tflag = (rt.tflag | (1)) >>> 0; - if (!!(typ.named)) { - rt.tflag = (rt.tflag | (4)) >>> 0; - } - reflectMethods = sliceType$5.nil; - i = 0; - while (true) { - if (!(i < $parseInt(methodSet.length))) { break; } - m = methodSet[i]; - exported = internalStr(m.pkg) === ""; - if (!exported) { - i = i + (1) >> 0; - continue; - } - reflectMethods = $append(reflectMethods, new method.ptr(newNameOff($clone(newName(internalStr(m.name), "", exported), name)), newTypeOff(reflectType(m.typ)), 0, 0)); - i = i + (1) >> 0; - } - xcount = ((reflectMethods.$length << 16 >>> 16)); - i$1 = 0; - while (true) { - if (!(i$1 < $parseInt(methodSet.length))) { break; } - m$1 = methodSet[i$1]; - exported$1 = internalStr(m$1.pkg) === ""; - if (exported$1) { - i$1 = i$1 + (1) >> 0; - continue; - } - reflectMethods = $append(reflectMethods, new method.ptr(newNameOff($clone(newName(internalStr(m$1.name), "", exported$1), name)), newTypeOff(reflectType(m$1.typ)), 0, 0)); - i$1 = i$1 + (1) >> 0; - } - ut = new uncommonType.ptr(newNameOff($clone(newName(internalStr(typ.pkg), "", false), name)), (($parseInt(methodSet.length) << 16 >>> 16)), xcount, 0, reflectMethods); - _key = rt; (uncommonTypeMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: ut }; - ut.jsType = typ; - } - _1 = rt.Kind(); - if (_1 === (17)) { - setKindType(rt, new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ptrType$1.nil, ((($parseInt(typ.len) >> 0) >>> 0)))); - } else if (_1 === (18)) { - dir = 3; - if (!!(typ.sendOnly)) { - dir = 2; - } - if (!!(typ.recvOnly)) { - dir = 1; - } - setKindType(rt, new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ((dir >>> 0)))); - } else if (_1 === (19)) { - params = typ.params; - in$1 = $makeSlice(sliceType$2, $parseInt(params.length)); - _ref = in$1; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i$2 = _i; - ((i$2 < 0 || i$2 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i$2] = reflectType(params[i$2])); - _i++; - } - results = typ.results; - out = $makeSlice(sliceType$2, $parseInt(results.length)); - _ref$1 = out; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$3 = _i$1; - ((i$3 < 0 || i$3 >= out.$length) ? ($throwRuntimeError("index out of range"), undefined) : out.$array[out.$offset + i$3] = reflectType(results[i$3])); - _i$1++; - } - outCount = (($parseInt(results.length) << 16 >>> 16)); - if (!!(typ.variadic)) { - outCount = (outCount | (32768)) >>> 0; - } - setKindType(rt, new funcType.ptr($clone(rt, rtype), (($parseInt(params.length) << 16 >>> 16)), outCount, in$1, out)); - } else if (_1 === (20)) { - methods = typ.methods; - imethods = $makeSlice(sliceType$6, $parseInt(methods.length)); - _ref$2 = imethods; - _i$2 = 0; - while (true) { - if (!(_i$2 < _ref$2.$length)) { break; } - i$4 = _i$2; - m$2 = methods[i$4]; - imethod.copy(((i$4 < 0 || i$4 >= imethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : imethods.$array[imethods.$offset + i$4]), new imethod.ptr(newNameOff($clone(newName(internalStr(m$2.name), "", internalStr(m$2.pkg) === ""), name)), newTypeOff(reflectType(m$2.typ)))); - _i$2++; - } - setKindType(rt, new interfaceType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkg), "", false), name), imethods)); - } else if (_1 === (21)) { - setKindType(rt, new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.key), reflectType(typ.elem), ptrType$1.nil, 0, 0, 0, 0)); - } else if (_1 === (22)) { - setKindType(rt, new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); - } else if (_1 === (23)) { - setKindType(rt, new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); - } else if (_1 === (25)) { - fields = typ.fields; - reflectFields = $makeSlice(sliceType$7, $parseInt(fields.length)); - _ref$3 = reflectFields; - _i$3 = 0; - while (true) { - if (!(_i$3 < _ref$3.$length)) { break; } - i$5 = _i$3; - f = fields[i$5]; - offsetEmbed = ((i$5 >>> 0)) << 1 >>> 0; - if (!!(f.embedded)) { - offsetEmbed = (offsetEmbed | (1)) >>> 0; - } - structField.copy(((i$5 < 0 || i$5 >= reflectFields.$length) ? ($throwRuntimeError("index out of range"), undefined) : reflectFields.$array[reflectFields.$offset + i$5]), new structField.ptr($clone(newName(internalStr(f.name), internalStr(f.tag), !!(f.exported)), name), reflectType(f.typ), offsetEmbed)); - _i$3++; - } - setKindType(rt, new structType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkgPath), "", false), name), reflectFields)); - } - } - return ((typ.reflectType)); - }; - setKindType = function(rt, kindType) { - var kindType, rt; - rt.kindType = kindType; - kindType.rtype = rt; - }; - uncommonType.ptr.prototype.methods = function() { - var t; - t = this; - return t._methods; - }; - uncommonType.prototype.methods = function() { return this.$val.methods(); }; - uncommonType.ptr.prototype.exportedMethods = function() { - var t; - t = this; - return $subslice(t._methods, 0, t.xcount, t.xcount); - }; - uncommonType.prototype.exportedMethods = function() { return this.$val.exportedMethods(); }; - rtype.ptr.prototype.uncommon = function() { - var _entry, t; - t = this; - return (_entry = uncommonTypeMap[ptrType$1.keyFor(t)], _entry !== undefined ? _entry.v : ptrType$5.nil); - }; - rtype.prototype.uncommon = function() { return this.$val.uncommon(); }; - funcType.ptr.prototype.in$ = function() { - var t; - t = this; - return t._in; - }; - funcType.prototype.in$ = function() { return this.$val.in$(); }; - funcType.ptr.prototype.out = function() { - var t; - t = this; - return t._out; - }; - funcType.prototype.out = function() { return this.$val.out(); }; - name.ptr.prototype.name = function() { - var _entry, n, s; - s = ""; - n = this; - s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).name; - return s; - }; - name.prototype.name = function() { return this.$val.name(); }; - name.ptr.prototype.tag = function() { - var _entry, n, s; - s = ""; - n = this; - s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).tag; - return s; - }; - name.prototype.tag = function() { return this.$val.tag(); }; - name.ptr.prototype.pkgPath = function() { - var n; - n = this; - return ""; - }; - name.prototype.pkgPath = function() { return this.$val.pkgPath(); }; - name.ptr.prototype.isExported = function() { - var _entry, n; - n = this; - return (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).exported; - }; - name.prototype.isExported = function() { return this.$val.isExported(); }; - newName = function(n, tag, exported) { - var _key, b, exported, n, tag; - b = $newDataPointer(0, ptrType$4); - _key = b; (nameMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$4.keyFor(_key)] = { k: _key, v: new nameData.ptr(n, tag, exported) }; - return new name.ptr(b); - }; - rtype.ptr.prototype.nameOff = function(off) { - var off, t, x; - t = this; - return (x = ((off >> 0)), ((x < 0 || x >= nameOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : nameOffList.$array[nameOffList.$offset + x])); - }; - rtype.prototype.nameOff = function(off) { return this.$val.nameOff(off); }; - newNameOff = function(n) { - var i, n; - i = nameOffList.$length; - nameOffList = $append(nameOffList, n); - return ((i >> 0)); - }; - rtype.ptr.prototype.typeOff = function(off) { - var off, t, x; - t = this; - return (x = ((off >> 0)), ((x < 0 || x >= typeOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : typeOffList.$array[typeOffList.$offset + x])); - }; - rtype.prototype.typeOff = function(off) { return this.$val.typeOff(off); }; - newTypeOff = function(t) { - var i, t; - i = typeOffList.$length; - typeOffList = $append(typeOffList, t); - return ((i >> 0)); - }; - internalStr = function(strObj) { - var c, strObj; - c = new structType$3.ptr(""); - c.str = strObj; - return c.str; - }; - isWrapped = function(typ) { - var typ; - return !!(jsType(typ).wrapped); - }; - copyStruct = function(dst, src, typ) { - var dst, fields, i, prop, src, typ; - fields = jsType(typ).fields; - i = 0; - while (true) { - if (!(i < $parseInt(fields.length))) { break; } - prop = $internalize(fields[i].prop, $String); - dst[$externalize(prop, $String)] = src[$externalize(prop, $String)]; - i = i + (1) >> 0; - } - }; - makeValue = function(t, v, fl) { - var _r, _r$1, _r$2, _r$3, _r$4, _r$5, _v, _v$1, fl, rt, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _v = $f._v; _v$1 = $f._v$1; fl = $f.fl; rt = $f.rt; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - rt = _r; - _r$1 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - if (_r$1 === 17) { _v$1 = true; $s = 5; continue s; } - _r$2 = t.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v$1 = _r$2 === 25; case 5: - if (_v$1) { _v = true; $s = 4; continue s; } - _r$3 = t.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _v = _r$3 === 22; case 4: - /* */ if (_v) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (_v) { */ case 2: - _r$4 = t.Kind(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return new Value.ptr(rt, (v), (fl | ((_r$4 >>> 0))) >>> 0); - /* } */ case 3: - _r$5 = t.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return new Value.ptr(rt, ($newDataPointer(v, jsType(rt.ptrTo()))), (((fl | ((_r$5 >>> 0))) >>> 0) | 128) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: makeValue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._v = _v; $f._v$1 = _v$1; $f.fl = fl; $f.rt = rt; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - MakeSlice = function(typ, len, cap) { - var _r, _r$1, cap, len, typ, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; len = $f.len; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - typ = [typ]; - _r = typ[0].Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 23))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 23))) { */ case 1: - $panic(new $String("reflect.MakeSlice of non-slice type")); - /* } */ case 2: - if (len < 0) { - $panic(new $String("reflect.MakeSlice: negative len")); - } - if (cap < 0) { - $panic(new $String("reflect.MakeSlice: negative cap")); - } - if (len > cap) { - $panic(new $String("reflect.MakeSlice: len > cap")); - } - _r$1 = makeValue(typ[0], $makeSlice(jsType(typ[0]), len, cap, (function(typ) { return function $b() { - var _r$1, _r$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$1 = typ[0].Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = jsType(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2.zero(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.$s = $s; $f.$r = $r; return $f; - }; })(typ)), 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: MakeSlice }; } $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.len = len; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.MakeSlice = MakeSlice; - TypeOf = function(i) { - var i; - if (!initialized) { - return new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); - } - if ($interfaceIsEqual(i, $ifaceNil)) { - return $ifaceNil; - } - return reflectType(i.constructor); - }; - $pkg.TypeOf = TypeOf; - ValueOf = function(i) { - var _r, i, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if ($interfaceIsEqual(i, $ifaceNil)) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - _r = makeValue(reflectType(i.constructor), i.$val, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: ValueOf }; } $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.ValueOf = ValueOf; - FuncOf = function(in$1, out, variadic) { - var _i, _i$1, _r, _ref, _ref$1, _v, _v$1, i, i$1, in$1, jsIn, jsOut, out, v, v$1, variadic, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; _v$1 = $f._v$1; i = $f.i; i$1 = $f.i$1; in$1 = $f.in$1; jsIn = $f.jsIn; jsOut = $f.jsOut; out = $f.out; v = $f.v; v$1 = $f.v$1; variadic = $f.variadic; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (!(variadic)) { _v = false; $s = 3; continue s; } - if (in$1.$length === 0) { _v$1 = true; $s = 4; continue s; } - _r = (x = in$1.$length - 1 >> 0, ((x < 0 || x >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x])).Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v$1 = !((_r === 23)); case 4: - _v = _v$1; case 3: - /* */ if (_v) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_v) { */ case 1: - $panic(new $String("reflect.FuncOf: last arg of variadic func must be slice")); - /* } */ case 2: - jsIn = $makeSlice(sliceType$8, in$1.$length); - _ref = in$1; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - ((i < 0 || i >= jsIn.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsIn.$array[jsIn.$offset + i] = jsType(v)); - _i++; - } - jsOut = $makeSlice(sliceType$8, out.$length); - _ref$1 = out; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - v$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - ((i$1 < 0 || i$1 >= jsOut.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsOut.$array[jsOut.$offset + i$1] = jsType(v$1)); - _i$1++; - } - $s = -1; return reflectType($funcType($externalize(jsIn, sliceType$8), $externalize(jsOut, sliceType$8), $externalize(variadic, $Bool))); - /* */ } return; } if ($f === undefined) { $f = { $blk: FuncOf }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f._v$1 = _v$1; $f.i = i; $f.i$1 = i$1; $f.in$1 = in$1; $f.jsIn = jsIn; $f.jsOut = jsOut; $f.out = out; $f.v = v; $f.v$1 = v$1; $f.variadic = variadic; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.FuncOf = FuncOf; - rtype.ptr.prototype.ptrTo = function() { - var t; - t = this; - return reflectType($ptrType(jsType(t))); - }; - rtype.prototype.ptrTo = function() { return this.$val.ptrTo(); }; - SliceOf = function(t) { - var t; - return reflectType($sliceType(jsType(t))); - }; - $pkg.SliceOf = SliceOf; - Zero = function(typ) { - var _r, typ, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeValue(typ, jsType(typ).zero(), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Zero }; } $f._r = _r; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Zero = Zero; - unsafe_New = function(typ) { - var _1, typ; - _1 = typ.Kind(); - if (_1 === (25)) { - return (new (jsType(typ).ptr)()); - } else if (_1 === (17)) { - return (jsType(typ).zero()); - } else { - return ($newDataPointer(jsType(typ).zero(), jsType(typ.ptrTo()))); - } - }; - makeInt = function(f, bits, t) { - var _1, _r, bits, f, ptr, t, typ, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; bits = $f.bits; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - typ = _r; - ptr = unsafe_New(typ); - _1 = typ.Kind(); - if (_1 === (3)) { - (ptr).$set(((bits.$low << 24 >> 24))); - } else if (_1 === (4)) { - (ptr).$set(((bits.$low << 16 >> 16))); - } else if ((_1 === (2)) || (_1 === (5))) { - (ptr).$set(((bits.$low >> 0))); - } else if (_1 === (6)) { - (ptr).$set((new $Int64(bits.$high, bits.$low))); - } else if (_1 === (8)) { - (ptr).$set(((bits.$low << 24 >>> 24))); - } else if (_1 === (9)) { - (ptr).$set(((bits.$low << 16 >>> 16))); - } else if ((_1 === (7)) || (_1 === (10)) || (_1 === (12))) { - (ptr).$set(((bits.$low >>> 0))); - } else if (_1 === (11)) { - (ptr).$set((bits)); - } - $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: makeInt }; } $f._1 = _1; $f._r = _r; $f.bits = bits; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; - }; - typedmemmove = function(t, dst, src) { - var dst, src, t; - dst.$set(src.$get()); - }; - keyFor = function(t, key) { - var k, key, kv, t; - kv = key; - if (!(kv.$get === undefined)) { - kv = kv.$get(); - } - k = $internalize(jsType(t.Key()).keyFor(kv), $String); - return [kv, k]; - }; - mapaccess = function(t, m, key) { - var _tuple, entry, k, key, m, t; - _tuple = keyFor(t, key); - k = _tuple[1]; - entry = m[$externalize(k, $String)]; - if (entry === undefined) { - return 0; - } - return ($newDataPointer(entry.v, jsType(PtrTo(t.Elem())))); - }; - mapassign = function(t, m, key, val) { - var _r, _tuple, entry, et, jsVal, k, key, kv, m, newVal, t, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; entry = $f.entry; et = $f.et; jsVal = $f.jsVal; k = $f.k; key = $f.key; kv = $f.kv; m = $f.m; newVal = $f.newVal; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _tuple = keyFor(t, key); - kv = _tuple[0]; - k = _tuple[1]; - jsVal = val.$get(); - et = t.Elem(); - _r = et.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r === 25) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r === 25) { */ case 1: - newVal = jsType(et).zero(); - copyStruct(newVal, jsVal, et); - jsVal = newVal; - /* } */ case 2: - entry = new ($global.Object)(); - entry.k = kv; - entry.v = jsVal; - m[$externalize(k, $String)] = entry; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: mapassign }; } $f._r = _r; $f._tuple = _tuple; $f.entry = entry; $f.et = et; $f.jsVal = jsVal; $f.k = k; $f.key = key; $f.kv = kv; $f.m = m; $f.newVal = newVal; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - mapdelete = function(t, m, key) { - var _tuple, k, key, m, t; - _tuple = keyFor(t, key); - k = _tuple[1]; - delete m[$externalize(k, $String)]; - }; - mapIter.ptr.prototype.skipUntilValidKey = function() { - var iter, k; - iter = this; - while (true) { - if (!(iter.i < $parseInt(iter.keys.length))) { break; } - k = iter.keys[iter.i]; - if (!(iter.m[$externalize($internalize(k, $String), $String)] === undefined)) { - break; - } - iter.i = iter.i + (1) >> 0; - } - }; - mapIter.prototype.skipUntilValidKey = function() { return this.$val.skipUntilValidKey(); }; - mapiterinit = function(t, m) { - var m, t; - return (new mapIter.ptr(t, m, $keys(m), 0, null)); - }; - mapiterkey = function(it) { - var _r, _r$1, _r$2, it, iter, k, kv, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; kv = $f.kv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - iter = ($pointerOfStructConversion(it, ptrType$7)); - kv = null; - if (!(iter.last === null)) { - kv = iter.last; - } else { - iter.skipUntilValidKey(); - if (iter.i === $parseInt(iter.keys.length)) { - $s = -1; return 0; - } - k = iter.keys[iter.i]; - kv = iter.m[$externalize($internalize(k, $String), $String)]; - iter.last = kv; - } - _r = iter.t.Key(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return ($newDataPointer(kv.k, _r$2)); - /* */ } return; } if ($f === undefined) { $f = { $blk: mapiterkey }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.kv = kv; $f.$s = $s; $f.$r = $r; return $f; - }; - mapitervalue = function(it) { - var _r, _r$1, _r$2, it, iter, k, kv, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; kv = $f.kv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - iter = ($pointerOfStructConversion(it, ptrType$7)); - kv = null; - if (!(iter.last === null)) { - kv = iter.last; - } else { - iter.skipUntilValidKey(); - if (iter.i === $parseInt(iter.keys.length)) { - $s = -1; return 0; - } - k = iter.keys[iter.i]; - kv = iter.m[$externalize($internalize(k, $String), $String)]; - iter.last = kv; - } - _r = iter.t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return ($newDataPointer(kv.v, _r$2)); - /* */ } return; } if ($f === undefined) { $f = { $blk: mapitervalue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.kv = kv; $f.$s = $s; $f.$r = $r; return $f; - }; - mapiternext = function(it) { - var it, iter; - iter = ($pointerOfStructConversion(it, ptrType$7)); - iter.last = null; - iter.i = iter.i + (1) >> 0; - }; - maplen = function(m) { - var m; - return $parseInt($keys(m).length); - }; - cvtDirect = function(v, typ) { - var _1, _arg, _arg$1, _arg$2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, k, slice, srcVal, typ, v, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; k = $f.k; slice = $f.slice; srcVal = $f.srcVal; typ = $f.typ; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - srcVal = $clone(v, Value).object(); - /* */ if (srcVal === jsType(v.typ).nil) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (srcVal === jsType(v.typ).nil) { */ case 1: - _r = makeValue(typ, jsType(typ).nil, v.flag); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 2: - val = null; - _r$1 = typ.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - k = _r$1; - _1 = k; - /* */ if (_1 === (23)) { $s = 6; continue; } - /* */ if (_1 === (22)) { $s = 7; continue; } - /* */ if (_1 === (25)) { $s = 8; continue; } - /* */ if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (_1 === (23)) { */ case 6: - slice = new (jsType(typ))(srcVal.$array); - slice.$offset = srcVal.$offset; - slice.$length = srcVal.$length; - slice.$capacity = srcVal.$capacity; - val = $newDataPointer(slice, jsType(PtrTo(typ))); - $s = 11; continue; - /* } else if (_1 === (22)) { */ case 7: - _r$2 = typ.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$3 = _r$2.Kind(); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3 === 25) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (_r$3 === 25) { */ case 12: - _r$4 = typ.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if ($interfaceIsEqual(_r$4, v.typ.Elem())) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if ($interfaceIsEqual(_r$4, v.typ.Elem())) { */ case 16: - val = srcVal; - /* break; */ $s = 4; continue; - /* } */ case 17: - val = new (jsType(typ))(); - _arg = val; - _arg$1 = srcVal; - _r$5 = typ.Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$2 = _r$5; - $r = copyStruct(_arg, _arg$1, _arg$2); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* break; */ $s = 4; continue; - /* } */ case 13: - val = new (jsType(typ))(srcVal.$get, srcVal.$set); - $s = 11; continue; - /* } else if (_1 === (25)) { */ case 8: - val = new (jsType(typ).ptr)(); - copyStruct(val, srcVal, typ); - $s = 11; continue; - /* } else if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { */ case 9: - val = v.ptr; - $s = 11; continue; - /* } else { */ case 10: - $panic(new ValueError.ptr("reflect.Convert", k)); - /* } */ case 11: - case 4: - _r$6 = typ.common(); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$7 = typ.Kind(); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $s = -1; return new Value.ptr(_r$6, (val), (((new flag(v.flag).ro() | ((v.flag & 128) >>> 0)) >>> 0) | ((_r$7 >>> 0))) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtDirect }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.k = k; $f.slice = slice; $f.srcVal = srcVal; $f.typ = typ; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - methodReceiver = function(op, v, i) { - var _$39, fn, i, m, m$1, ms, op, prop, rcvr, t, tt, v, x; - _$39 = ptrType$1.nil; - t = ptrType$8.nil; - fn = 0; - prop = ""; - if (v.typ.Kind() === 20) { - tt = (v.typ.kindType); - if (i < 0 || i >= tt.methods.$length) { - $panic(new $String("reflect: internal error: invalid method index")); - } - m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - if (!$clone(tt.rtype.nameOff(m.name), name).isExported()) { - $panic(new $String("reflect: " + op + " of unexported method")); - } - t = (tt.rtype.typeOff(m.typ).kindType); - prop = $clone(tt.rtype.nameOff(m.name), name).name(); - } else { - ms = v.typ.exportedMethods(); - if (((i >>> 0)) >= ((ms.$length >>> 0))) { - $panic(new $String("reflect: internal error: invalid method index")); - } - m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); - if (!$clone(v.typ.nameOff(m$1.name), name).isExported()) { - $panic(new $String("reflect: " + op + " of unexported method")); - } - t = (v.typ.typeOff(m$1.mtyp).kindType); - prop = $internalize($methodSet(jsType(v.typ))[i].prop, $String); - } - rcvr = $clone(v, Value).object(); - if (isWrapped(v.typ)) { - rcvr = new (jsType(v.typ))(rcvr); - } - fn = (rcvr[$externalize(prop, $String)]); - return [_$39, t, fn]; - }; - valueInterface = function(v, safe) { - var _r, safe, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; safe = $f.safe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (v.flag === 0) { - $panic(new ValueError.ptr("reflect.Value.Interface", 0)); - } - if (safe && !((((v.flag & 96) >>> 0) === 0))) { - $panic(new $String("reflect.Value.Interface: cannot return value obtained from unexported field or method")); - } - /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: - _r = makeMethodValue("Interface", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - /* } */ case 2: - if (isWrapped(v.typ)) { - $s = -1; return ((new (jsType(v.typ))($clone(v, Value).object()))); - } - $s = -1; return (($clone(v, Value).object())); - /* */ } return; } if ($f === undefined) { $f = { $blk: valueInterface }; } $f._r = _r; $f.safe = safe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - ifaceE2I = function(t, src, dst) { - var dst, src, t; - dst.$set(src); - }; - methodName = function() { - return "?FIXME?"; - }; - makeMethodValue = function(op, v) { - var _r, _tuple, fn, fv, op, rcvr, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; fn = $f.fn; fv = $f.fv; op = $f.op; rcvr = $f.rcvr; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fn = [fn]; - rcvr = [rcvr]; - if (((v.flag & 512) >>> 0) === 0) { - $panic(new $String("reflect: internal error: invalid use of makePartialFunc")); - } - _tuple = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); - fn[0] = _tuple[2]; - rcvr[0] = $clone(v, Value).object(); - if (isWrapped(v.typ)) { - rcvr[0] = new (jsType(v.typ))(rcvr[0]); - } - fv = js.MakeFunc((function(fn, rcvr) { return function(this$1, arguments$1) { - var arguments$1, this$1; - return new $jsObjectPtr(fn[0].apply(rcvr[0], $externalize(arguments$1, sliceType$8))); - }; })(fn, rcvr)); - _r = $clone(v, Value).Type().common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return new Value.ptr(_r, (fv), (new flag(v.flag).ro() | 19) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: makeMethodValue }; } $f._r = _r; $f._tuple = _tuple; $f.fn = fn; $f.fv = fv; $f.op = op; $f.rcvr = rcvr; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.ptr.prototype.pointers = function() { - var _1, t; - t = this; - _1 = t.Kind(); - if ((_1 === (22)) || (_1 === (21)) || (_1 === (18)) || (_1 === (19)) || (_1 === (25)) || (_1 === (17))) { - return true; - } else { - return false; - } - }; - rtype.prototype.pointers = function() { return this.$val.pointers(); }; - rtype.ptr.prototype.Comparable = function() { - var _1, _r, _r$1, i, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; i = $f.i; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _1 = t.Kind(); - /* */ if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { $s = 2; continue; } - /* */ if (_1 === (17)) { $s = 3; continue; } - /* */ if (_1 === (25)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { */ case 2: - $s = -1; return false; - /* } else if (_1 === (17)) { */ case 3: - _r = t.Elem().Comparable(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } else if (_1 === (25)) { */ case 4: - i = 0; - /* while (true) { */ case 7: - /* if (!(i < t.NumField())) { break; } */ if(!(i < t.NumField())) { $s = 8; continue; } - _r$1 = t.Field(i).Type.Comparable(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (!_r$1) { */ case 9: - $s = -1; return false; - /* } */ case 10: - i = i + (1) >> 0; - /* } */ $s = 7; continue; case 8: - /* } */ case 5: - case 1: - $s = -1; return true; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Comparable }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.Comparable = function() { return this.$val.Comparable(); }; - rtype.ptr.prototype.Method = function(i) { - var _i, _i$1, _r, _ref, _ref$1, arg, fl, fn, ft, i, in$1, m, methods, mt, mtyp, out, p, pname, prop, ret, t, tt, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; arg = $f.arg; fl = $f.fl; fn = $f.fn; ft = $f.ft; i = $f.i; in$1 = $f.in$1; m = $f.m; methods = $f.methods; mt = $f.mt; mtyp = $f.mtyp; out = $f.out; p = $f.p; pname = $f.pname; prop = $f.prop; ret = $f.ret; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - prop = [prop]; - m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - t = this; - if (t.Kind() === 20) { - tt = (t.kindType); - Method.copy(m, tt.Method(i)); - $s = -1; return m; - } - methods = t.exportedMethods(); - if (i < 0 || i >= methods.$length) { - $panic(new $String("reflect: Method index out of range")); - } - p = $clone(((i < 0 || i >= methods.$length) ? ($throwRuntimeError("index out of range"), undefined) : methods.$array[methods.$offset + i]), method); - pname = $clone(t.nameOff(p.name), name); - m.Name = $clone(pname, name).name(); - fl = 19; - mtyp = t.typeOff(p.mtyp); - ft = (mtyp.kindType); - in$1 = $makeSlice(sliceType$10, 0, (1 + ft.in$().$length >> 0)); - in$1 = $append(in$1, t); - _ref = ft.in$(); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - in$1 = $append(in$1, arg); - _i++; - } - out = $makeSlice(sliceType$10, 0, ft.out().$length); - _ref$1 = ft.out(); - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - ret = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - out = $append(out, ret); - _i$1++; - } - _r = FuncOf(in$1, out, ft.rtype.IsVariadic()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - mt = _r; - m.Type = mt; - prop[0] = $internalize($methodSet(t.jsType)[i].prop, $String); - fn = js.MakeFunc((function(prop) { return function(this$1, arguments$1) { - var arguments$1, rcvr, this$1; - rcvr = (0 >= arguments$1.$length ? ($throwRuntimeError("index out of range"), undefined) : arguments$1.$array[arguments$1.$offset + 0]); - return new $jsObjectPtr(rcvr[$externalize(prop[0], $String)].apply(rcvr, $externalize($subslice(arguments$1, 1), sliceType$8))); - }; })(prop)); - m.Func = new Value.ptr($assertType(mt, ptrType$1), (fn), fl); - m.Index = i; - Method.copy(m, m); - $s = -1; return m; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Method }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.arg = arg; $f.fl = fl; $f.fn = fn; $f.ft = ft; $f.i = i; $f.in$1 = in$1; $f.m = m; $f.methods = methods; $f.mt = mt; $f.mtyp = mtyp; $f.out = out; $f.p = p; $f.pname = pname; $f.prop = prop; $f.ret = ret; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.Method = function(i) { return this.$val.Method(i); }; - Value.ptr.prototype.object = function() { - var _1, newVal, v, val; - v = this; - if ((v.typ.Kind() === 17) || (v.typ.Kind() === 25)) { - return v.ptr; - } - if (!((((v.flag & 128) >>> 0) === 0))) { - val = v.ptr.$get(); - if (!(val === $ifaceNil) && !(val.constructor === jsType(v.typ))) { - switch (0) { default: - _1 = v.typ.Kind(); - if ((_1 === (11)) || (_1 === (6))) { - val = new (jsType(v.typ))(val.$high, val.$low); - } else if ((_1 === (15)) || (_1 === (16))) { - val = new (jsType(v.typ))(val.$real, val.$imag); - } else if (_1 === (23)) { - if (val === val.constructor.nil) { - val = jsType(v.typ).nil; - break; - } - newVal = new (jsType(v.typ))(val.$array); - newVal.$offset = val.$offset; - newVal.$length = val.$length; - newVal.$capacity = val.$capacity; - val = newVal; - } - } - } - return val; - } - return v.ptr; - }; - Value.prototype.object = function() { return this.$val.object(); }; - Value.ptr.prototype.assignTo = function(context, dst, target) { - var _r, _r$1, _r$2, context, dst, fl, target, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; context = $f.context; dst = $f.dst; fl = $f.fl; target = $f.target; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: - _r = makeMethodValue(context, $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - /* } */ case 2: - _r$1 = directlyAssignable(dst, v.typ); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 5; continue; } - /* */ if (implements$1(dst, v.typ)) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (_r$1) { */ case 5: - fl = (((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0; - fl = (fl | (((dst.Kind() >>> 0)))) >>> 0; - $s = -1; return new Value.ptr(dst, v.ptr, fl); - /* } else if (implements$1(dst, v.typ)) { */ case 6: - if (target === 0) { - target = unsafe_New(dst); - } - _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = _r$2; - if (dst.NumMethod() === 0) { - (target).$set(x); - } else { - ifaceE2I(dst, x, target); - } - $s = -1; return new Value.ptr(dst, target, 148); - /* } */ case 7: - case 4: - $panic(new $String(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())); - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.assignTo }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.context = context; $f.dst = dst; $f.fl = fl; $f.target = target; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.assignTo = function(context, dst, target) { return this.$val.assignTo(context, dst, target); }; - Value.ptr.prototype.call = function(op, in$1) { - var _1, _arg, _arg$1, _arg$2, _arg$3, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tuple, arg, argsArray, elem, fn, i, i$1, i$2, i$3, in$1, isSlice, m, n, nin, nout, op, origIn, rcvr, results, ret, slice, t, targ, v, x, x$1, x$2, xt, xt$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; arg = $f.arg; argsArray = $f.argsArray; elem = $f.elem; fn = $f.fn; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; in$1 = $f.in$1; isSlice = $f.isSlice; m = $f.m; n = $f.n; nin = $f.nin; nout = $f.nout; op = $f.op; origIn = $f.origIn; rcvr = $f.rcvr; results = $f.results; ret = $f.ret; slice = $f.slice; t = $f.t; targ = $f.targ; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; xt = $f.xt; xt$1 = $f.xt$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - t = ptrType$8.nil; - fn = 0; - rcvr = null; - if (!((((v.flag & 512) >>> 0) === 0))) { - _tuple = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); - t = _tuple[1]; - fn = _tuple[2]; - rcvr = $clone(v, Value).object(); - if (isWrapped(v.typ)) { - rcvr = new (jsType(v.typ))(rcvr); - } - } else { - t = (v.typ.kindType); - fn = ($clone(v, Value).object()); - rcvr = undefined; - } - if (fn === 0) { - $panic(new $String("reflect.Value.Call: call of nil function")); - } - isSlice = op === "CallSlice"; - n = t.rtype.NumIn(); - if (isSlice) { - if (!t.rtype.IsVariadic()) { - $panic(new $String("reflect: CallSlice of non-variadic function")); - } - if (in$1.$length < n) { - $panic(new $String("reflect: CallSlice with too few input arguments")); - } - if (in$1.$length > n) { - $panic(new $String("reflect: CallSlice with too many input arguments")); - } - } else { - if (t.rtype.IsVariadic()) { - n = n - (1) >> 0; - } - if (in$1.$length < n) { - $panic(new $String("reflect: Call with too few input arguments")); - } - if (!t.rtype.IsVariadic() && in$1.$length > n) { - $panic(new $String("reflect: Call with too many input arguments")); - } - } - _ref = in$1; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if ($clone(x, Value).Kind() === 0) { - $panic(new $String("reflect: " + op + " using zero Value argument")); - } - _i++; - } - i = 0; - /* while (true) { */ case 1: - /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } - _tmp = $clone(((i < 0 || i >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i]), Value).Type(); - _tmp$1 = t.rtype.In(i); - xt = _tmp; - targ = _tmp$1; - _r = xt.AssignableTo(targ); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!_r) { */ case 3: - _r$1 = xt.String(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = targ.String(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $panic(new $String("reflect: " + op + " using " + _r$1 + " as type " + _r$2)); - /* } */ case 4: - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - /* */ if (!isSlice && t.rtype.IsVariadic()) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (!isSlice && t.rtype.IsVariadic()) { */ case 8: - m = in$1.$length - n >> 0; - _r$3 = MakeSlice(t.rtype.In(n), m, m); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - slice = _r$3; - _r$4 = t.rtype.In(n).Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - elem = _r$4; - i$1 = 0; - /* while (true) { */ case 12: - /* if (!(i$1 < m)) { break; } */ if(!(i$1 < m)) { $s = 13; continue; } - x$2 = (x$1 = n + i$1 >> 0, ((x$1 < 0 || x$1 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x$1])); - xt$1 = $clone(x$2, Value).Type(); - _r$5 = xt$1.AssignableTo(elem); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (!_r$5) { $s = 14; continue; } - /* */ $s = 15; continue; - /* if (!_r$5) { */ case 14: - _r$6 = xt$1.String(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$7 = elem.String(); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $panic(new $String("reflect: cannot use " + _r$6 + " as type " + _r$7 + " in " + op)); - /* } */ case 15: - _r$8 = $clone(slice, Value).Index(i$1); /* */ $s = 19; case 19: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - $r = $clone(_r$8, Value).Set($clone(x$2, Value)); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$1 = i$1 + (1) >> 0; - /* } */ $s = 12; continue; case 13: - origIn = in$1; - in$1 = $makeSlice(sliceType$9, (n + 1 >> 0)); - $copySlice($subslice(in$1, 0, n), origIn); - ((n < 0 || n >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + n] = slice); - /* } */ case 9: - nin = in$1.$length; - if (!((nin === t.rtype.NumIn()))) { - $panic(new $String("reflect.Value.Call: wrong argument count")); - } - nout = t.rtype.NumOut(); - argsArray = new ($global.Array)(t.rtype.NumIn()); - _ref$1 = in$1; - _i$1 = 0; - /* while (true) { */ case 21: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 22; continue; } - i$2 = _i$1; - arg = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - _arg = t.rtype.In(i$2); - _r$9 = t.rtype.In(i$2).common(); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _arg$1 = _r$9; - _arg$2 = 0; - _r$10 = $clone(arg, Value).assignTo("reflect.Value.Call", _arg$1, _arg$2); /* */ $s = 24; case 24: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - _r$11 = $clone(_r$10, Value).object(); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - _arg$3 = _r$11; - _r$12 = unwrapJsObject(_arg, _arg$3); /* */ $s = 26; case 26: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - argsArray[i$2] = _r$12; - _i$1++; - /* } */ $s = 21; continue; case 22: - _r$13 = callHelper(new sliceType$3([new $jsObjectPtr(fn), new $jsObjectPtr(rcvr), new $jsObjectPtr(argsArray)])); /* */ $s = 27; case 27: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - results = _r$13; - _1 = nout; - /* */ if (_1 === (0)) { $s = 29; continue; } - /* */ if (_1 === (1)) { $s = 30; continue; } - /* */ $s = 31; continue; - /* if (_1 === (0)) { */ case 29: - $s = -1; return sliceType$9.nil; - /* } else if (_1 === (1)) { */ case 30: - _r$14 = makeValue(t.rtype.Out(0), wrapJsObject(t.rtype.Out(0), results), 0); /* */ $s = 33; case 33: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } - $s = -1; return new sliceType$9([$clone(_r$14, Value)]); - /* } else { */ case 31: - ret = $makeSlice(sliceType$9, nout); - _ref$2 = ret; - _i$2 = 0; - /* while (true) { */ case 34: - /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 35; continue; } - i$3 = _i$2; - _r$15 = makeValue(t.rtype.Out(i$3), wrapJsObject(t.rtype.Out(i$3), results[i$3]), 0); /* */ $s = 36; case 36: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } - ((i$3 < 0 || i$3 >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i$3] = _r$15); - _i$2++; - /* } */ $s = 34; continue; case 35: - $s = -1; return ret; - /* } */ case 32: - case 28: - $s = -1; return sliceType$9.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.call }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.arg = arg; $f.argsArray = argsArray; $f.elem = elem; $f.fn = fn; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.in$1 = in$1; $f.isSlice = isSlice; $f.m = m; $f.n = n; $f.nin = nin; $f.nout = nout; $f.op = op; $f.origIn = origIn; $f.rcvr = rcvr; $f.results = results; $f.ret = ret; $f.slice = slice; $f.t = t; $f.targ = targ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.xt = xt; $f.xt$1 = xt$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.call = function(op, in$1) { return this.$val.call(op, in$1); }; - Value.ptr.prototype.Cap = function() { - var _1, k, v; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (17)) { - return v.typ.Len(); - } else if ((_1 === (18)) || (_1 === (23))) { - return $parseInt($clone(v, Value).object().$capacity) >> 0; - } - $panic(new ValueError.ptr("reflect.Value.Cap", k)); - }; - Value.prototype.Cap = function() { return this.$val.Cap(); }; - wrapJsObject = function(typ, val) { - var typ, val; - if ($interfaceIsEqual(typ, jsObjectPtr)) { - return new (jsType(jsObjectPtr))(val); - } - return val; - }; - unwrapJsObject = function(typ, val) { - var typ, val; - if ($interfaceIsEqual(typ, jsObjectPtr)) { - return val.object; - } - return val; - }; - Value.ptr.prototype.Elem = function() { - var _1, _r, fl, k, tt, typ, v, val, val$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; fl = $f.fl; k = $f.k; tt = $f.tt; typ = $f.typ; v = $f.v; val = $f.val; val$1 = $f.val$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - k = new flag(v.flag).kind(); - _1 = k; - /* */ if (_1 === (20)) { $s = 2; continue; } - /* */ if (_1 === (22)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_1 === (20)) { */ case 2: - val = $clone(v, Value).object(); - if (val === $ifaceNil) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - typ = reflectType(val.constructor); - _r = makeValue(typ, val.$val, new flag(v.flag).ro()); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } else if (_1 === (22)) { */ case 3: - if ($clone(v, Value).IsNil()) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - val$1 = $clone(v, Value).object(); - tt = (v.typ.kindType); - fl = (((((v.flag & 96) >>> 0) | 128) >>> 0) | 256) >>> 0; - fl = (fl | (((tt.elem.Kind() >>> 0)))) >>> 0; - $s = -1; return new Value.ptr(tt.elem, (wrapJsObject(tt.elem, val$1)), fl); - /* } else { */ case 4: - $panic(new ValueError.ptr("reflect.Value.Elem", k)); - /* } */ case 5: - case 1: - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Elem }; } $f._1 = _1; $f._r = _r; $f.fl = fl; $f.k = k; $f.tt = tt; $f.typ = typ; $f.v = v; $f.val = val; $f.val$1 = val$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Elem = function() { return this.$val.Elem(); }; - Value.ptr.prototype.Field = function(i) { - var _r, _r$1, _r$2, field, fl, i, jsTag, o, prop, s, tag, tt, typ, v, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; field = $f.field; fl = $f.fl; i = $f.i; jsTag = $f.jsTag; o = $f.o; prop = $f.prop; s = $f.s; tag = $f.tag; tt = $f.tt; typ = $f.typ; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - jsTag = [jsTag]; - prop = [prop]; - s = [s]; - typ = [typ]; - v = this; - if (!((new flag(v.flag).kind() === 25))) { - $panic(new ValueError.ptr("reflect.Value.Field", new flag(v.flag).kind())); - } - tt = (v.typ.kindType); - if (((i >>> 0)) >= ((tt.fields.$length >>> 0))) { - $panic(new $String("reflect: Field index out of range")); - } - prop[0] = $internalize(jsType(v.typ).fields[i].prop, $String); - field = (x = tt.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - typ[0] = field.typ; - fl = (((v.flag & 416) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; - if (!$clone(field.name, name).isExported()) { - if (field.embedded()) { - fl = (fl | (64)) >>> 0; - } else { - fl = (fl | (32)) >>> 0; - } - } - tag = $clone((x$1 = tt.fields, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])).name, name).tag(); - /* */ if (!(tag === "") && !((i === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(tag === "") && !((i === 0))) { */ case 1: - jsTag[0] = getJsTag(tag); - /* */ if (!(jsTag[0] === "")) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!(jsTag[0] === "")) { */ case 3: - /* while (true) { */ case 5: - o = [o]; - _r = $clone(v, Value).Field(0); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - /* */ if (v.typ === jsObjectPtr) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (v.typ === jsObjectPtr) { */ case 8: - o[0] = $clone(v, Value).object().object; - $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, o, prop, s, typ) { return function() { - return $internalize(o[0][$externalize(jsTag[0], $String)], jsType(typ[0])); - }; })(jsTag, o, prop, s, typ), (function(jsTag, o, prop, s, typ) { return function(x$2) { - var x$2; - o[0][$externalize(jsTag[0], $String)] = $externalize(x$2, jsType(typ[0])); - }; })(jsTag, o, prop, s, typ))), fl); - /* } */ case 9: - /* */ if (v.typ.Kind() === 22) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (v.typ.Kind() === 22) { */ case 10: - _r$1 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - v = _r$1; - /* } */ case 11: - /* } */ $s = 5; continue; case 6: - /* } */ case 4: - /* } */ case 2: - s[0] = v.ptr; - /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 13: - $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, prop, s, typ) { return function() { - return wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]); - }; })(jsTag, prop, s, typ), (function(jsTag, prop, s, typ) { return function(x$2) { - var x$2; - s[0][$externalize(prop[0], $String)] = unwrapJsObject(typ[0], x$2); - }; })(jsTag, prop, s, typ))), fl); - /* } */ case 14: - _r$2 = makeValue(typ[0], wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]), fl); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Field }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.field = field; $f.fl = fl; $f.i = i; $f.jsTag = jsTag; $f.o = o; $f.prop = prop; $f.s = s; $f.tag = tag; $f.tt = tt; $f.typ = typ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Field = function(i) { return this.$val.Field(i); }; - getJsTag = function(tag) { - var _tuple, i, name$1, qvalue, tag, value; - while (true) { - if (!(!(tag === ""))) { break; } - i = 0; - while (true) { - if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } - i = i + (1) >> 0; - } - tag = $substring(tag, i); - if (tag === "") { - break; - } - i = 0; - while (true) { - if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; } - i = i + (1) >> 0; - } - if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { - break; - } - name$1 = ($substring(tag, 0, i)); - tag = $substring(tag, (i + 1 >> 0)); - i = 1; - while (true) { - if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } - if (tag.charCodeAt(i) === 92) { - i = i + (1) >> 0; - } - i = i + (1) >> 0; - } - if (i >= tag.length) { - break; - } - qvalue = ($substring(tag, 0, (i + 1 >> 0))); - tag = $substring(tag, (i + 1 >> 0)); - if (name$1 === "js") { - _tuple = strconv.Unquote(qvalue); - value = _tuple[0]; - return value; - } - } - return ""; - }; - Value.ptr.prototype.Index = function(i) { - var _1, _r, _r$1, a, a$1, c, fl, fl$1, fl$2, i, k, s, str, tt, tt$1, typ, typ$1, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; a = $f.a; a$1 = $f.a$1; c = $f.c; fl = $f.fl; fl$1 = $f.fl$1; fl$2 = $f.fl$2; i = $f.i; k = $f.k; s = $f.s; str = $f.str; tt = $f.tt; tt$1 = $f.tt$1; typ = $f.typ; typ$1 = $f.typ$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - a$1 = [a$1]; - c = [c]; - i = [i]; - typ = [typ]; - typ$1 = [typ$1]; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - /* */ if (_1 === (17)) { $s = 2; continue; } - /* */ if (_1 === (23)) { $s = 3; continue; } - /* */ if (_1 === (24)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_1 === (17)) { */ case 2: - tt = (v.typ.kindType); - if (i[0] < 0 || i[0] > ((tt.len >> 0))) { - $panic(new $String("reflect: array index out of range")); - } - typ[0] = tt.elem; - fl = (((((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; - a[0] = v.ptr; - /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 7: - $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { - return wrapJsObject(typ[0], a[0][i[0]]); - }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { - var x; - a[0][i[0]] = unwrapJsObject(typ[0], x); - }; })(a, a$1, c, i, typ, typ$1))), fl); - /* } */ case 8: - _r = makeValue(typ[0], wrapJsObject(typ[0], a[0][i[0]]), fl); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } else if (_1 === (23)) { */ case 3: - s = $clone(v, Value).object(); - if (i[0] < 0 || i[0] >= ($parseInt(s.$length) >> 0)) { - $panic(new $String("reflect: slice index out of range")); - } - tt$1 = (v.typ.kindType); - typ$1[0] = tt$1.elem; - fl$1 = (((384 | new flag(v.flag).ro()) >>> 0) | ((typ$1[0].Kind() >>> 0))) >>> 0; - i[0] = i[0] + (($parseInt(s.$offset) >> 0)) >> 0; - a$1[0] = s.$array; - /* */ if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { */ case 10: - $s = -1; return new Value.ptr(typ$1[0], (new (jsType(PtrTo(typ$1[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { - return wrapJsObject(typ$1[0], a$1[0][i[0]]); - }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { - var x; - a$1[0][i[0]] = unwrapJsObject(typ$1[0], x); - }; })(a, a$1, c, i, typ, typ$1))), fl$1); - /* } */ case 11: - _r$1 = makeValue(typ$1[0], wrapJsObject(typ$1[0], a$1[0][i[0]]), fl$1); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } else if (_1 === (24)) { */ case 4: - str = (v.ptr).$get(); - if (i[0] < 0 || i[0] >= str.length) { - $panic(new $String("reflect: string index out of range")); - } - fl$2 = (((new flag(v.flag).ro() | 8) >>> 0) | 128) >>> 0; - c[0] = str.charCodeAt(i[0]); - $s = -1; return new Value.ptr(uint8Type, ((c.$ptr || (c.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, c)))), fl$2); - /* } else { */ case 5: - $panic(new ValueError.ptr("reflect.Value.Index", k)); - /* } */ case 6: - case 1: - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Index }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.a$1 = a$1; $f.c = c; $f.fl = fl; $f.fl$1 = fl$1; $f.fl$2 = fl$2; $f.i = i; $f.k = k; $f.s = s; $f.str = str; $f.tt = tt; $f.tt$1 = tt$1; $f.typ = typ; $f.typ$1 = typ$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Index = function(i) { return this.$val.Index(i); }; - Value.ptr.prototype.InterfaceData = function() { - var v; - v = this; - $panic(errors.New("InterfaceData is not supported by GopherJS")); - }; - Value.prototype.InterfaceData = function() { return this.$val.InterfaceData(); }; - Value.ptr.prototype.IsNil = function() { - var _1, k, v; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if ((_1 === (22)) || (_1 === (23))) { - return $clone(v, Value).object() === jsType(v.typ).nil; - } else if (_1 === (18)) { - return $clone(v, Value).object() === $chanNil; - } else if (_1 === (19)) { - return $clone(v, Value).object() === $throwNilPointerError; - } else if (_1 === (21)) { - return $clone(v, Value).object() === false; - } else if (_1 === (20)) { - return $clone(v, Value).object() === $ifaceNil; - } else if (_1 === (26)) { - return $clone(v, Value).object() === 0; - } else { - $panic(new ValueError.ptr("reflect.Value.IsNil", k)); - } - }; - Value.prototype.IsNil = function() { return this.$val.IsNil(); }; - Value.ptr.prototype.Len = function() { - var _1, k, v; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if ((_1 === (17)) || (_1 === (24))) { - return $parseInt($clone(v, Value).object().length); - } else if (_1 === (23)) { - return $parseInt($clone(v, Value).object().$length) >> 0; - } else if (_1 === (18)) { - return $parseInt($clone(v, Value).object().$buffer.length) >> 0; - } else if (_1 === (21)) { - return $parseInt($keys($clone(v, Value).object()).length); - } else { - $panic(new ValueError.ptr("reflect.Value.Len", k)); - } - }; - Value.prototype.Len = function() { return this.$val.Len(); }; - Value.ptr.prototype.Pointer = function() { - var _1, k, v; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if ((_1 === (18)) || (_1 === (21)) || (_1 === (22)) || (_1 === (26))) { - if ($clone(v, Value).IsNil()) { - return 0; - } - return $clone(v, Value).object(); - } else if (_1 === (19)) { - if ($clone(v, Value).IsNil()) { - return 0; - } - return 1; - } else if (_1 === (23)) { - if ($clone(v, Value).IsNil()) { - return 0; - } - return $clone(v, Value).object().$array; - } else { - $panic(new ValueError.ptr("reflect.Value.Pointer", k)); - } - }; - Value.prototype.Pointer = function() { return this.$val.Pointer(); }; - Value.ptr.prototype.Set = function(x) { - var _1, _r, _r$1, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(x.flag).mustBeExported(); - _r = $clone(x, Value).assignTo("reflect.Set", v.typ, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x = _r; - /* */ if (!((((v.flag & 128) >>> 0) === 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((((v.flag & 128) >>> 0) === 0))) { */ case 2: - _1 = v.typ.Kind(); - /* */ if (_1 === (17)) { $s = 5; continue; } - /* */ if (_1 === (20)) { $s = 6; continue; } - /* */ if (_1 === (25)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_1 === (17)) { */ case 5: - jsType(v.typ).copy(v.ptr, x.ptr); - $s = 9; continue; - /* } else if (_1 === (20)) { */ case 6: - _r$1 = valueInterface($clone(x, Value), false); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - v.ptr.$set(_r$1); - $s = 9; continue; - /* } else if (_1 === (25)) { */ case 7: - copyStruct(v.ptr, x.ptr, v.typ); - $s = 9; continue; - /* } else { */ case 8: - v.ptr.$set($clone(x, Value).object()); - /* } */ case 9: - case 4: - $s = -1; return; - /* } */ case 3: - v.ptr = x.ptr; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Set }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Set = function(x) { return this.$val.Set(x); }; - Value.ptr.prototype.SetBytes = function(x) { - var _r, _r$1, _v, slice, typedSlice, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; slice = $f.slice; typedSlice = $f.typedSlice; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(23); - _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 8))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 8))) { */ case 1: - $panic(new $String("reflect.Value.SetBytes of non-byte slice")); - /* } */ case 2: - slice = x; - if (!(v.typ.Name() === "")) { _v = true; $s = 6; continue s; } - _r$1 = v.typ.Elem().Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v = !(_r$1 === ""); case 6: - /* */ if (_v) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_v) { */ case 4: - typedSlice = new (jsType(v.typ))(slice.$array); - typedSlice.$offset = slice.$offset; - typedSlice.$length = slice.$length; - typedSlice.$capacity = slice.$capacity; - slice = typedSlice; - /* } */ case 5: - v.ptr.$set(slice); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetBytes }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.slice = slice; $f.typedSlice = typedSlice; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.SetBytes = function(x) { return this.$val.SetBytes(x); }; - Value.ptr.prototype.SetCap = function(n) { - var n, newSlice, s, v; - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(23); - s = v.ptr.$get(); - if (n < ($parseInt(s.$length) >> 0) || n > ($parseInt(s.$capacity) >> 0)) { - $panic(new $String("reflect: slice capacity out of range in SetCap")); - } - newSlice = new (jsType(v.typ))(s.$array); - newSlice.$offset = s.$offset; - newSlice.$length = s.$length; - newSlice.$capacity = n; - v.ptr.$set(newSlice); - }; - Value.prototype.SetCap = function(n) { return this.$val.SetCap(n); }; - Value.ptr.prototype.SetLen = function(n) { - var n, newSlice, s, v; - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(23); - s = v.ptr.$get(); - if (n < 0 || n > ($parseInt(s.$capacity) >> 0)) { - $panic(new $String("reflect: slice length out of range in SetLen")); - } - newSlice = new (jsType(v.typ))(s.$array); - newSlice.$offset = s.$offset; - newSlice.$length = n; - newSlice.$capacity = s.$capacity; - v.ptr.$set(newSlice); - }; - Value.prototype.SetLen = function(n) { return this.$val.SetLen(n); }; - Value.ptr.prototype.Slice = function(i, j) { - var _1, _r, _r$1, cap, i, j, kind, s, str, tt, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; i = $f.i; j = $f.j; kind = $f.kind; s = $f.s; str = $f.str; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - cap = 0; - typ = $ifaceNil; - s = null; - kind = new flag(v.flag).kind(); - _1 = kind; - /* */ if (_1 === (17)) { $s = 2; continue; } - /* */ if (_1 === (23)) { $s = 3; continue; } - /* */ if (_1 === (24)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_1 === (17)) { */ case 2: - if (((v.flag & 256) >>> 0) === 0) { - $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); - } - tt = (v.typ.kindType); - cap = ((tt.len >> 0)); - typ = SliceOf(tt.elem); - s = new (jsType(typ))($clone(v, Value).object()); - $s = 6; continue; - /* } else if (_1 === (23)) { */ case 3: - typ = v.typ; - s = $clone(v, Value).object(); - cap = $parseInt(s.$capacity) >> 0; - $s = 6; continue; - /* } else if (_1 === (24)) { */ case 4: - str = (v.ptr).$get(); - if (i < 0 || j < i || j > str.length) { - $panic(new $String("reflect.Value.Slice: string slice index out of bounds")); - } - _r = ValueOf(new $String($substring(str, i, j))); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } else { */ case 5: - $panic(new ValueError.ptr("reflect.Value.Slice", kind)); - /* } */ case 6: - case 1: - if (i < 0 || j < i || j > cap) { - $panic(new $String("reflect.Value.Slice: slice index out of bounds")); - } - _r$1 = makeValue(typ, $subslice(s, i, j), new flag(v.flag).ro()); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.i = i; $f.j = j; $f.kind = kind; $f.s = s; $f.str = str; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Slice = function(i, j) { return this.$val.Slice(i, j); }; - Value.ptr.prototype.Slice3 = function(i, j, k) { - var _1, _r, cap, i, j, k, kind, s, tt, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; cap = $f.cap; i = $f.i; j = $f.j; k = $f.k; kind = $f.kind; s = $f.s; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - cap = 0; - typ = $ifaceNil; - s = null; - kind = new flag(v.flag).kind(); - _1 = kind; - if (_1 === (17)) { - if (((v.flag & 256) >>> 0) === 0) { - $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); - } - tt = (v.typ.kindType); - cap = ((tt.len >> 0)); - typ = SliceOf(tt.elem); - s = new (jsType(typ))($clone(v, Value).object()); - } else if (_1 === (23)) { - typ = v.typ; - s = $clone(v, Value).object(); - cap = $parseInt(s.$capacity) >> 0; - } else { - $panic(new ValueError.ptr("reflect.Value.Slice3", kind)); - } - if (i < 0 || j < i || k < j || k > cap) { - $panic(new $String("reflect.Value.Slice3: slice index out of bounds")); - } - _r = makeValue(typ, $subslice(s, i, j, k), new flag(v.flag).ro()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice3 }; } $f._1 = _1; $f._r = _r; $f.cap = cap; $f.i = i; $f.j = j; $f.k = k; $f.kind = kind; $f.s = s; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Slice3 = function(i, j, k) { return this.$val.Slice3(i, j, k); }; - Value.ptr.prototype.Close = function() { - var v; - v = this; - new flag(v.flag).mustBe(18); - new flag(v.flag).mustBeExported(); - $close($clone(v, Value).object()); - }; - Value.prototype.Close = function() { return this.$val.Close(); }; - chanrecv = function(ch, nb, val) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, ch, comms, nb, received, recvRes, selectRes, selected, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; ch = $f.ch; comms = $f.comms; nb = $f.nb; received = $f.received; recvRes = $f.recvRes; selectRes = $f.selectRes; selected = $f.selected; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - selected = false; - received = false; - comms = new sliceType$11([new sliceType$8([ch])]); - if (nb) { - comms = $append(comms, new sliceType$8([])); - } - _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - selectRes = _r; - if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { - _tmp = false; - _tmp$1 = false; - selected = _tmp; - received = _tmp$1; - $s = -1; return [selected, received]; - } - recvRes = selectRes[1]; - val.$set(recvRes[0]); - _tmp$2 = true; - _tmp$3 = !!(recvRes[1]); - selected = _tmp$2; - received = _tmp$3; - $s = -1; return [selected, received]; - /* */ } return; } if ($f === undefined) { $f = { $blk: chanrecv }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.received = received; $f.recvRes = recvRes; $f.selectRes = selectRes; $f.selected = selected; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - chansend = function(ch, val, nb) { - var _r, ch, comms, nb, selectRes, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; ch = $f.ch; comms = $f.comms; nb = $f.nb; selectRes = $f.selectRes; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - comms = new sliceType$11([new sliceType$8([ch, val.$get()])]); - if (nb) { - comms = $append(comms, new sliceType$8([])); - } - _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - selectRes = _r; - if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { - $s = -1; return false; - } - $s = -1; return true; - /* */ } return; } if ($f === undefined) { $f = { $blk: chansend }; } $f._r = _r; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.selectRes = selectRes; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - Swapper = function(slice) { - var _1, _r, a, off, slice, v, vLen, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; a = $f.a; off = $f.off; slice = $f.slice; v = $f.v; vLen = $f.vLen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - off = [off]; - vLen = [vLen]; - _r = ValueOf(slice); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - if (!(($clone(v, Value).Kind() === 23))) { - $panic(new ValueError.ptr("Swapper", $clone(v, Value).Kind())); - } - vLen[0] = (($clone(v, Value).Len() >>> 0)); - _1 = vLen[0]; - if (_1 === (0)) { - $s = -1; return (function(a, off, vLen) { return function(i, j) { - var i, j; - $panic(new $String("reflect: slice index out of range")); - }; })(a, off, vLen); - } else if (_1 === (1)) { - $s = -1; return (function(a, off, vLen) { return function(i, j) { - var i, j; - if (!((i === 0)) || !((j === 0))) { - $panic(new $String("reflect: slice index out of range")); - } - }; })(a, off, vLen); - } - a[0] = slice.$array; - off[0] = $parseInt(slice.$offset) >> 0; - $s = -1; return (function(a, off, vLen) { return function(i, j) { - var i, j, tmp; - if (((i >>> 0)) >= vLen[0] || ((j >>> 0)) >= vLen[0]) { - $panic(new $String("reflect: slice index out of range")); - } - i = i + (off[0]) >> 0; - j = j + (off[0]) >> 0; - tmp = a[0][i]; - a[0][i] = a[0][j]; - a[0][j] = tmp; - }; })(a, off, vLen); - /* */ } return; } if ($f === undefined) { $f = { $blk: Swapper }; } $f._1 = _1; $f._r = _r; $f.a = a; $f.off = off; $f.slice = slice; $f.v = v; $f.vLen = vLen; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Swapper = Swapper; - structField.ptr.prototype.offset = function() { - var f; - f = this; - return f.offsetEmbed >>> 1 >>> 0; - }; - structField.prototype.offset = function() { return this.$val.offset(); }; - structField.ptr.prototype.embedded = function() { - var f; - f = this; - return !((((f.offsetEmbed & 1) >>> 0) === 0)); - }; - structField.prototype.embedded = function() { return this.$val.embedded(); }; - Kind.prototype.String = function() { - var k; - k = this.$val; - if (((k >> 0)) < kindNames.$length) { - return ((k < 0 || k >= kindNames.$length) ? ($throwRuntimeError("index out of range"), undefined) : kindNames.$array[kindNames.$offset + k]); - } - return "kind" + strconv.Itoa(((k >> 0))); - }; - $ptrType(Kind).prototype.String = function() { return new Kind(this.$get()).String(); }; - rtype.ptr.prototype.String = function() { - var s, t; - t = this; - s = $clone(t.nameOff(t.str), name).name(); - if (!((((t.tflag & 2) >>> 0) === 0))) { - return $substring(s, 1); - } - return s; - }; - rtype.prototype.String = function() { return this.$val.String(); }; - rtype.ptr.prototype.Size = function() { - var t; - t = this; - return t.size; - }; - rtype.prototype.Size = function() { return this.$val.Size(); }; - rtype.ptr.prototype.Bits = function() { - var k, t; - t = this; - if (t === ptrType$1.nil) { - $panic(new $String("reflect: Bits of nil Type")); - } - k = t.Kind(); - if (k < 2 || k > 16) { - $panic(new $String("reflect: Bits of non-arithmetic Type " + t.String())); - } - return $imul(((t.size >> 0)), 8); - }; - rtype.prototype.Bits = function() { return this.$val.Bits(); }; - rtype.ptr.prototype.Align = function() { - var t; - t = this; - return ((t.align >> 0)); - }; - rtype.prototype.Align = function() { return this.$val.Align(); }; - rtype.ptr.prototype.FieldAlign = function() { - var t; - t = this; - return ((t.fieldAlign >> 0)); - }; - rtype.prototype.FieldAlign = function() { return this.$val.FieldAlign(); }; - rtype.ptr.prototype.Kind = function() { - var t; - t = this; - return ((((t.kind & 31) >>> 0) >>> 0)); - }; - rtype.prototype.Kind = function() { return this.$val.Kind(); }; - rtype.ptr.prototype.common = function() { - var t; - t = this; - return t; - }; - rtype.prototype.common = function() { return this.$val.common(); }; - rtype.ptr.prototype.exportedMethods = function() { - var t, ut; - t = this; - ut = t.uncommon(); - if (ut === ptrType$5.nil) { - return sliceType$5.nil; - } - return ut.exportedMethods(); - }; - rtype.prototype.exportedMethods = function() { return this.$val.exportedMethods(); }; - rtype.ptr.prototype.NumMethod = function() { - var t, tt; - t = this; - if (t.Kind() === 20) { - tt = (t.kindType); - return tt.NumMethod(); - } - return t.exportedMethods().$length; - }; - rtype.prototype.NumMethod = function() { return this.$val.NumMethod(); }; - rtype.ptr.prototype.MethodByName = function(name$1) { - var _i, _r, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, i, m, name$1, ok, p, t, tt, ut, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; i = $f.i; m = $f.m; name$1 = $f.name$1; ok = $f.ok; p = $f.p; t = $f.t; tt = $f.tt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - ok = false; - t = this; - if (t.Kind() === 20) { - tt = (t.kindType); - _tuple = tt.MethodByName(name$1); - Method.copy(m, _tuple[0]); - ok = _tuple[1]; - $s = -1; return [m, ok]; - } - ut = t.uncommon(); - if (ut === ptrType$5.nil) { - _tmp = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - _tmp$1 = false; - Method.copy(m, _tmp); - ok = _tmp$1; - $s = -1; return [m, ok]; - } - _ref = ut.exportedMethods(); - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - i = _i; - p = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), method); - /* */ if ($clone(t.nameOff(p.name), name).name() === name$1) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if ($clone(t.nameOff(p.name), name).name() === name$1) { */ case 3: - _r = t.Method(i); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tmp$2 = $clone(_r, Method); - _tmp$3 = true; - Method.copy(m, _tmp$2); - ok = _tmp$3; - $s = -1; return [m, ok]; - /* } */ case 4: - _i++; - /* } */ $s = 1; continue; case 2: - _tmp$4 = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - _tmp$5 = false; - Method.copy(m, _tmp$4); - ok = _tmp$5; - $s = -1; return [m, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.MethodByName }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.i = i; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.p = p; $f.t = t; $f.tt = tt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; - rtype.ptr.prototype.PkgPath = function() { - var t, ut; - t = this; - if (((t.tflag & 4) >>> 0) === 0) { - return ""; - } - ut = t.uncommon(); - if (ut === ptrType$5.nil) { - return ""; - } - return $clone(t.nameOff(ut.pkgPath), name).name(); - }; - rtype.prototype.PkgPath = function() { return this.$val.PkgPath(); }; - rtype.ptr.prototype.Name = function() { - var i, s, t; - t = this; - if (((t.tflag & 4) >>> 0) === 0) { - return ""; - } - s = t.String(); - i = s.length - 1 >> 0; - while (true) { - if (!(i >= 0)) { break; } - if (s.charCodeAt(i) === 46) { - break; - } - i = i - (1) >> 0; - } - return $substring(s, (i + 1 >> 0)); - }; - rtype.prototype.Name = function() { return this.$val.Name(); }; - rtype.ptr.prototype.ChanDir = function() { - var t, tt; - t = this; - if (!((t.Kind() === 18))) { - $panic(new $String("reflect: ChanDir of non-chan type")); - } - tt = (t.kindType); - return ((tt.dir >> 0)); - }; - rtype.prototype.ChanDir = function() { return this.$val.ChanDir(); }; - rtype.ptr.prototype.IsVariadic = function() { - var t, tt; - t = this; - if (!((t.Kind() === 19))) { - $panic(new $String("reflect: IsVariadic of non-func type")); - } - tt = (t.kindType); - return !((((tt.outCount & 32768) >>> 0) === 0)); - }; - rtype.prototype.IsVariadic = function() { return this.$val.IsVariadic(); }; - rtype.ptr.prototype.Elem = function() { - var _1, t, tt, tt$1, tt$2, tt$3, tt$4; - t = this; - _1 = t.Kind(); - if (_1 === (17)) { - tt = (t.kindType); - return toType(tt.elem); - } else if (_1 === (18)) { - tt$1 = (t.kindType); - return toType(tt$1.elem); - } else if (_1 === (21)) { - tt$2 = (t.kindType); - return toType(tt$2.elem); - } else if (_1 === (22)) { - tt$3 = (t.kindType); - return toType(tt$3.elem); - } else if (_1 === (23)) { - tt$4 = (t.kindType); - return toType(tt$4.elem); - } - $panic(new $String("reflect: Elem of invalid type")); - }; - rtype.prototype.Elem = function() { return this.$val.Elem(); }; - rtype.ptr.prototype.Field = function(i) { - var i, t, tt; - t = this; - if (!((t.Kind() === 25))) { - $panic(new $String("reflect: Field of non-struct type")); - } - tt = (t.kindType); - return tt.Field(i); - }; - rtype.prototype.Field = function(i) { return this.$val.Field(i); }; - rtype.ptr.prototype.FieldByIndex = function(index) { - var _r, index, t, tt, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; index = $f.index; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if (!((t.Kind() === 25))) { - $panic(new $String("reflect: FieldByIndex of non-struct type")); - } - tt = (t.kindType); - _r = tt.FieldByIndex(index); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByIndex }; } $f._r = _r; $f.index = index; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; - rtype.ptr.prototype.FieldByName = function(name$1) { - var _r, name$1, t, tt, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; name$1 = $f.name$1; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if (!((t.Kind() === 25))) { - $panic(new $String("reflect: FieldByName of non-struct type")); - } - tt = (t.kindType); - _r = tt.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByName }; } $f._r = _r; $f.name$1 = name$1; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; - rtype.ptr.prototype.FieldByNameFunc = function(match) { - var _r, match, t, tt, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; match = $f.match; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if (!((t.Kind() === 25))) { - $panic(new $String("reflect: FieldByNameFunc of non-struct type")); - } - tt = (t.kindType); - _r = tt.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f.match = match; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; - rtype.ptr.prototype.In = function(i) { - var i, t, tt, x; - t = this; - if (!((t.Kind() === 19))) { - $panic(new $String("reflect: In of non-func type")); - } - tt = (t.kindType); - return toType((x = tt.in$(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); - }; - rtype.prototype.In = function(i) { return this.$val.In(i); }; - rtype.ptr.prototype.Key = function() { - var t, tt; - t = this; - if (!((t.Kind() === 21))) { - $panic(new $String("reflect: Key of non-map type")); - } - tt = (t.kindType); - return toType(tt.key); - }; - rtype.prototype.Key = function() { return this.$val.Key(); }; - rtype.ptr.prototype.Len = function() { - var t, tt; - t = this; - if (!((t.Kind() === 17))) { - $panic(new $String("reflect: Len of non-array type")); - } - tt = (t.kindType); - return ((tt.len >> 0)); - }; - rtype.prototype.Len = function() { return this.$val.Len(); }; - rtype.ptr.prototype.NumField = function() { - var t, tt; - t = this; - if (!((t.Kind() === 25))) { - $panic(new $String("reflect: NumField of non-struct type")); - } - tt = (t.kindType); - return tt.fields.$length; - }; - rtype.prototype.NumField = function() { return this.$val.NumField(); }; - rtype.ptr.prototype.NumIn = function() { - var t, tt; - t = this; - if (!((t.Kind() === 19))) { - $panic(new $String("reflect: NumIn of non-func type")); - } - tt = (t.kindType); - return ((tt.inCount >> 0)); - }; - rtype.prototype.NumIn = function() { return this.$val.NumIn(); }; - rtype.ptr.prototype.NumOut = function() { - var t, tt; - t = this; - if (!((t.Kind() === 19))) { - $panic(new $String("reflect: NumOut of non-func type")); - } - tt = (t.kindType); - return tt.out().$length; - }; - rtype.prototype.NumOut = function() { return this.$val.NumOut(); }; - rtype.ptr.prototype.Out = function(i) { - var i, t, tt, x; - t = this; - if (!((t.Kind() === 19))) { - $panic(new $String("reflect: Out of non-func type")); - } - tt = (t.kindType); - return toType((x = tt.out(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); - }; - rtype.prototype.Out = function(i) { return this.$val.Out(i); }; - ChanDir.prototype.String = function() { - var _1, d; - d = this.$val; - _1 = d; - if (_1 === (2)) { - return "chan<-"; - } else if (_1 === (1)) { - return "<-chan"; - } else if (_1 === (3)) { - return "chan"; - } - return "ChanDir" + strconv.Itoa(((d >> 0))); - }; - $ptrType(ChanDir).prototype.String = function() { return new ChanDir(this.$get()).String(); }; - interfaceType.ptr.prototype.Method = function(i) { - var i, m, p, pname, t, x; - m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - t = this; - if (i < 0 || i >= t.methods.$length) { - return m; - } - p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - pname = $clone(t.rtype.nameOff(p.name), name); - m.Name = $clone(pname, name).name(); - if (!$clone(pname, name).isExported()) { - m.PkgPath = $clone(pname, name).pkgPath(); - if (m.PkgPath === "") { - m.PkgPath = $clone(t.pkgPath, name).name(); - } - } - m.Type = toType(t.rtype.typeOff(p.typ)); - m.Index = i; - return m; - }; - interfaceType.prototype.Method = function(i) { return this.$val.Method(i); }; - interfaceType.ptr.prototype.NumMethod = function() { - var t; - t = this; - return t.methods.$length; - }; - interfaceType.prototype.NumMethod = function() { return this.$val.NumMethod(); }; - interfaceType.ptr.prototype.MethodByName = function(name$1) { - var _i, _ref, _tmp, _tmp$1, i, m, name$1, ok, p, t, x; - m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); - ok = false; - t = this; - if (t === ptrType$9.nil) { - return [m, ok]; - } - p = ptrType$10.nil; - _ref = t.methods; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - if ($clone(t.rtype.nameOff(p.name), name).name() === name$1) { - _tmp = $clone(t.Method(i), Method); - _tmp$1 = true; - Method.copy(m, _tmp); - ok = _tmp$1; - return [m, ok]; - } - _i++; - } - return [m, ok]; - }; - interfaceType.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; - StructTag.prototype.Get = function(key) { - var _tuple, key, tag, v; - tag = this.$val; - _tuple = new StructTag(tag).Lookup(key); - v = _tuple[0]; - return v; - }; - $ptrType(StructTag).prototype.Get = function(key) { return new StructTag(this.$get()).Get(key); }; - StructTag.prototype.Lookup = function(key) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, i, key, name$1, ok, qvalue, tag, value, value$1; - value = ""; - ok = false; - tag = this.$val; - while (true) { - if (!(!(tag === ""))) { break; } - i = 0; - while (true) { - if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } - i = i + (1) >> 0; - } - tag = $substring(tag, i); - if (tag === "") { - break; - } - i = 0; - while (true) { - if (!(i < tag.length && tag.charCodeAt(i) > 32 && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)) && !((tag.charCodeAt(i) === 127)))) { break; } - i = i + (1) >> 0; - } - if ((i === 0) || (i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { - break; - } - name$1 = ($substring(tag, 0, i)); - tag = $substring(tag, (i + 1 >> 0)); - i = 1; - while (true) { - if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } - if (tag.charCodeAt(i) === 92) { - i = i + (1) >> 0; - } - i = i + (1) >> 0; - } - if (i >= tag.length) { - break; - } - qvalue = ($substring(tag, 0, (i + 1 >> 0))); - tag = $substring(tag, (i + 1 >> 0)); - if (key === name$1) { - _tuple = strconv.Unquote(qvalue); - value$1 = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - break; - } - _tmp = value$1; - _tmp$1 = true; - value = _tmp; - ok = _tmp$1; - return [value, ok]; - } - } - _tmp$2 = ""; - _tmp$3 = false; - value = _tmp$2; - ok = _tmp$3; - return [value, ok]; - }; - $ptrType(StructTag).prototype.Lookup = function(key) { return new StructTag(this.$get()).Lookup(key); }; - structType.ptr.prototype.Field = function(i) { - var f, i, p, t, tag, x; - f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); - t = this; - if (i < 0 || i >= t.fields.$length) { - $panic(new $String("reflect: Field index out of bounds")); - } - p = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - f.Type = toType(p.typ); - f.Name = $clone(p.name, name).name(); - f.Anonymous = p.embedded(); - if (!$clone(p.name, name).isExported()) { - f.PkgPath = $clone(t.pkgPath, name).name(); - } - tag = $clone(p.name, name).tag(); - if (!(tag === "")) { - f.Tag = (tag); - } - f.Offset = p.offset(); - f.Index = new sliceType$13([i]); - return f; - }; - structType.prototype.Field = function(i) { return this.$val.Field(i); }; - structType.ptr.prototype.FieldByIndex = function(index) { - var _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _v, f, ft, i, index, t, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _v = $f._v; f = $f.f; ft = $f.ft; i = $f.i; index = $f.index; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); - t = this; - f.Type = toType(t.rtype); - _ref = index; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - i = _i; - x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - /* */ if (i > 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (i > 0) { */ case 3: - ft = f.Type; - _r = ft.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - if (!(_r === 22)) { _v = false; $s = 7; continue s; } - _r$1 = ft.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = _r$1.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v = _r$2 === 25; case 7: - /* */ if (_v) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_v) { */ case 5: - _r$3 = ft.Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - ft = _r$3; - /* } */ case 6: - f.Type = ft; - /* } */ case 4: - _r$4 = f.Type.Field(x); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - StructField.copy(f, _r$4); - _i++; - /* } */ $s = 1; continue; case 2: - $s = -1; return f; - /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._v = _v; $f.f = f; $f.ft = ft; $f.i = i; $f.index = index; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - structType.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; - structType.ptr.prototype.FieldByNameFunc = function(match) { - var _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _key$2, _key$3, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, count, current, f, fname, i, index, match, next, nextCount, ntyp, ok, result, scan, styp, t, t$1, visited, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; count = $f.count; current = $f.current; f = $f.f; fname = $f.fname; i = $f.i; index = $f.index; match = $f.match; next = $f.next; nextCount = $f.nextCount; ntyp = $f.ntyp; ok = $f.ok; result = $f.result; scan = $f.scan; styp = $f.styp; t = $f.t; t$1 = $f.t$1; visited = $f.visited; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); - ok = false; - t = this; - current = new sliceType$14([]); - next = new sliceType$14([new fieldScan.ptr(t, sliceType$13.nil)]); - nextCount = false; - visited = $makeMap(ptrType$11.keyFor, []); - /* while (true) { */ case 1: - /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; } - _tmp = next; - _tmp$1 = $subslice(current, 0, 0); - current = _tmp; - next = _tmp$1; - count = nextCount; - nextCount = false; - _ref = current; - _i = 0; - /* while (true) { */ case 3: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } - scan = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), fieldScan); - t$1 = scan.typ; - /* */ if ((_entry = visited[ptrType$11.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((_entry = visited[ptrType$11.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { */ case 5: - _i++; - /* continue; */ $s = 3; continue; - /* } */ case 6: - _key = t$1; (visited || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key)] = { k: _key, v: true }; - _ref$1 = t$1.fields; - _i$1 = 0; - /* while (true) { */ case 7: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; } - i = _i$1; - f = (x = t$1.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - fname = $clone(f.name, name).name(); - ntyp = ptrType$1.nil; - /* */ if (f.embedded()) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (f.embedded()) { */ case 9: - ntyp = f.typ; - /* */ if (ntyp.Kind() === 22) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (ntyp.Kind() === 22) { */ case 11: - _r = ntyp.Elem().common(); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ntyp = _r; - /* } */ case 12: - /* } */ case 10: - _r$1 = match(fname); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 14; continue; } - /* */ $s = 15; continue; - /* if (_r$1) { */ case 14: - if ((_entry$1 = count[ptrType$11.keyFor(t$1)], _entry$1 !== undefined ? _entry$1.v : 0) > 1 || ok) { - _tmp$2 = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); - _tmp$3 = false; - StructField.copy(result, _tmp$2); - ok = _tmp$3; - $s = -1; return [result, ok]; - } - StructField.copy(result, t$1.Field(i)); - result.Index = sliceType$13.nil; - result.Index = $appendSlice(result.Index, scan.index); - result.Index = $append(result.Index, i); - ok = true; - _i$1++; - /* continue; */ $s = 7; continue; - /* } */ case 15: - if (ok || ntyp === ptrType$1.nil || !((ntyp.Kind() === 25))) { - _i$1++; - /* continue; */ $s = 7; continue; - } - styp = (ntyp.kindType); - if ((_entry$2 = nextCount[ptrType$11.keyFor(styp)], _entry$2 !== undefined ? _entry$2.v : 0) > 0) { - _key$1 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$1)] = { k: _key$1, v: 2 }; - _i$1++; - /* continue; */ $s = 7; continue; - } - if (nextCount === false) { - nextCount = $makeMap(ptrType$11.keyFor, []); - } - _key$2 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$2)] = { k: _key$2, v: 1 }; - if ((_entry$3 = count[ptrType$11.keyFor(t$1)], _entry$3 !== undefined ? _entry$3.v : 0) > 1) { - _key$3 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$3)] = { k: _key$3, v: 2 }; - } - index = sliceType$13.nil; - index = $appendSlice(index, scan.index); - index = $append(index, i); - next = $append(next, new fieldScan.ptr(styp, index)); - _i$1++; - /* } */ $s = 7; continue; case 8: - _i++; - /* } */ $s = 3; continue; case 4: - if (ok) { - /* break; */ $s = 2; continue; - } - /* } */ $s = 1; continue; case 2: - $s = -1; return [result, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByNameFunc }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.count = count; $f.current = current; $f.f = f; $f.fname = fname; $f.i = i; $f.index = index; $f.match = match; $f.next = next; $f.nextCount = nextCount; $f.ntyp = ntyp; $f.ok = ok; $f.result = result; $f.scan = scan; $f.styp = styp; $f.t = t; $f.t$1 = t$1; $f.visited = visited; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - structType.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; - structType.ptr.prototype.FieldByName = function(name$1) { - var _i, _r, _ref, _tmp, _tmp$1, _tuple, f, hasEmbeds, i, name$1, present, t, tf, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; hasEmbeds = $f.hasEmbeds; i = $f.i; name$1 = $f.name$1; present = $f.present; t = $f.t; tf = $f.tf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - name$1 = [name$1]; - f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); - present = false; - t = this; - hasEmbeds = false; - if (!(name$1[0] === "")) { - _ref = t.fields; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - tf = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - if ($clone(tf.name, name).name() === name$1[0]) { - _tmp = $clone(t.Field(i), StructField); - _tmp$1 = true; - StructField.copy(f, _tmp); - present = _tmp$1; - $s = -1; return [f, present]; - } - if (tf.embedded()) { - hasEmbeds = true; - } - _i++; - } - } - if (!hasEmbeds) { - $s = -1; return [f, present]; - } - _r = t.FieldByNameFunc((function(name$1) { return function(s) { - var s; - return s === name$1[0]; - }; })(name$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - StructField.copy(f, _tuple[0]); - present = _tuple[1]; - $s = -1; return [f, present]; - /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByName }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.hasEmbeds = hasEmbeds; $f.i = i; $f.name$1 = name$1; $f.present = present; $f.t = t; $f.tf = tf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - structType.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; - PtrTo = function(t) { - var t; - return $assertType(t, ptrType$1).ptrTo(); - }; - $pkg.PtrTo = PtrTo; - rtype.ptr.prototype.Implements = function(u) { - var _r, t, u, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if ($interfaceIsEqual(u, $ifaceNil)) { - $panic(new $String("reflect: nil type passed to Type.Implements")); - } - _r = u.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 20))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 20))) { */ case 1: - $panic(new $String("reflect: non-interface type passed to Type.Implements")); - /* } */ case 2: - $s = -1; return implements$1($assertType(u, ptrType$1), t); - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Implements }; } $f._r = _r; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.Implements = function(u) { return this.$val.Implements(u); }; - rtype.ptr.prototype.AssignableTo = function(u) { - var _r, t, u, uu, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if ($interfaceIsEqual(u, $ifaceNil)) { - $panic(new $String("reflect: nil type passed to Type.AssignableTo")); - } - uu = $assertType(u, ptrType$1); - _r = directlyAssignable(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r || implements$1(uu, t); - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.AssignableTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.AssignableTo = function(u) { return this.$val.AssignableTo(u); }; - rtype.ptr.prototype.ConvertibleTo = function(u) { - var _r, t, u, uu, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if ($interfaceIsEqual(u, $ifaceNil)) { - $panic(new $String("reflect: nil type passed to Type.ConvertibleTo")); - } - uu = $assertType(u, ptrType$1); - _r = convertOp(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return !(_r === $throwNilPointerError); - /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.ConvertibleTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; - }; - rtype.prototype.ConvertibleTo = function(u) { return this.$val.ConvertibleTo(u); }; - implements$1 = function(T, V) { - var T, V, i, i$1, j, j$1, t, tm, tm$1, tmName, tmName$1, tmPkgPath, tmPkgPath$1, v, v$1, vm, vm$1, vmName, vmName$1, vmPkgPath, vmPkgPath$1, vmethods, x, x$1, x$2; - if (!((T.Kind() === 20))) { - return false; - } - t = (T.kindType); - if (t.methods.$length === 0) { - return true; - } - if (V.Kind() === 20) { - v = (V.kindType); - i = 0; - j = 0; - while (true) { - if (!(j < v.methods.$length)) { break; } - tm = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - tmName = $clone(t.rtype.nameOff(tm.name), name); - vm = (x$1 = v.methods, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])); - vmName = $clone(V.nameOff(vm.name), name); - if ($clone(vmName, name).name() === $clone(tmName, name).name() && V.typeOff(vm.typ) === t.rtype.typeOff(tm.typ)) { - if (!$clone(tmName, name).isExported()) { - tmPkgPath = $clone(tmName, name).pkgPath(); - if (tmPkgPath === "") { - tmPkgPath = $clone(t.pkgPath, name).name(); - } - vmPkgPath = $clone(vmName, name).pkgPath(); - if (vmPkgPath === "") { - vmPkgPath = $clone(v.pkgPath, name).name(); - } - if (!(tmPkgPath === vmPkgPath)) { - j = j + (1) >> 0; - continue; - } - } - i = i + (1) >> 0; - if (i >= t.methods.$length) { - return true; - } - } - j = j + (1) >> 0; - } - return false; - } - v$1 = V.uncommon(); - if (v$1 === ptrType$5.nil) { - return false; - } - i$1 = 0; - vmethods = v$1.methods(); - j$1 = 0; - while (true) { - if (!(j$1 < ((v$1.mcount >> 0)))) { break; } - tm$1 = (x$2 = t.methods, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])); - tmName$1 = $clone(t.rtype.nameOff(tm$1.name), name); - vm$1 = $clone(((j$1 < 0 || j$1 >= vmethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : vmethods.$array[vmethods.$offset + j$1]), method); - vmName$1 = $clone(V.nameOff(vm$1.name), name); - if ($clone(vmName$1, name).name() === $clone(tmName$1, name).name() && V.typeOff(vm$1.mtyp) === t.rtype.typeOff(tm$1.typ)) { - if (!$clone(tmName$1, name).isExported()) { - tmPkgPath$1 = $clone(tmName$1, name).pkgPath(); - if (tmPkgPath$1 === "") { - tmPkgPath$1 = $clone(t.pkgPath, name).name(); - } - vmPkgPath$1 = $clone(vmName$1, name).pkgPath(); - if (vmPkgPath$1 === "") { - vmPkgPath$1 = $clone(V.nameOff(v$1.pkgPath), name).name(); - } - if (!(tmPkgPath$1 === vmPkgPath$1)) { - j$1 = j$1 + (1) >> 0; - continue; - } - } - i$1 = i$1 + (1) >> 0; - if (i$1 >= t.methods.$length) { - return true; - } - } - j$1 = j$1 + (1) >> 0; - } - return false; - }; - directlyAssignable = function(T, V) { - var T, V, _r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _r = $f._r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (T === V) { - $s = -1; return true; - } - if (!(T.Name() === "") && !(V.Name() === "") || !((T.Kind() === V.Kind()))) { - $s = -1; return false; - } - _r = haveIdenticalUnderlyingType(T, V, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: directlyAssignable }; } $f.T = T; $f.V = V; $f._r = _r; $f.$s = $s; $f.$r = $r; return $f; - }; - haveIdenticalType = function(T, V, cmpTags) { - var T, V, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _v, cmpTags, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _v = $f._v; cmpTags = $f.cmpTags; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (cmpTags) { - $s = -1; return $interfaceIsEqual(T, V); - } - _r = T.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = V.Name(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - if (!(_r === _r$1)) { _v = true; $s = 3; continue s; } - _r$2 = T.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$3 = V.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _v = !((_r$2 === _r$3)); case 3: - /* */ if (_v) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_v) { */ case 1: - $s = -1; return false; - /* } */ case 2: - _r$4 = T.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _arg = _r$4; - _r$5 = V.common(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$1 = _r$5; - _r$6 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - $s = -1; return _r$6; - /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalType }; } $f.T = T; $f.V = V; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._v = _v; $f.cmpTags = cmpTags; $f.$s = $s; $f.$r = $r; return $f; - }; - haveIdenticalUnderlyingType = function(T, V, cmpTags) { - var T, V, _1, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _v, _v$1, _v$2, _v$3, cmpTags, i, i$1, i$2, kind, t, t$1, t$2, tf, v, v$1, v$2, vf, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; cmpTags = $f.cmpTags; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; kind = $f.kind; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; tf = $f.tf; v = $f.v; v$1 = $f.v$1; v$2 = $f.v$2; vf = $f.vf; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (T === V) { - $s = -1; return true; - } - kind = T.Kind(); - if (!((kind === V.Kind()))) { - $s = -1; return false; - } - if (1 <= kind && kind <= 16 || (kind === 24) || (kind === 26)) { - $s = -1; return true; - } - _1 = kind; - /* */ if (_1 === (17)) { $s = 2; continue; } - /* */ if (_1 === (18)) { $s = 3; continue; } - /* */ if (_1 === (19)) { $s = 4; continue; } - /* */ if (_1 === (20)) { $s = 5; continue; } - /* */ if (_1 === (21)) { $s = 6; continue; } - /* */ if ((_1 === (22)) || (_1 === (23))) { $s = 7; continue; } - /* */ if (_1 === (25)) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (_1 === (17)) { */ case 2: - if (!(T.Len() === V.Len())) { _v = false; $s = 10; continue s; } - _r = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 10: - $s = -1; return _v; - /* } else if (_1 === (18)) { */ case 3: - if (!(V.ChanDir() === 3)) { _v$1 = false; $s = 14; continue s; } - _r$1 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v$1 = _r$1; case 14: - /* */ if (_v$1) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (_v$1) { */ case 12: - $s = -1; return true; - /* } */ case 13: - if (!(V.ChanDir() === T.ChanDir())) { _v$2 = false; $s = 16; continue s; } - _r$2 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v$2 = _r$2; case 16: - $s = -1; return _v$2; - /* } else if (_1 === (19)) { */ case 4: - t = (T.kindType); - v = (V.kindType); - if (!((t.outCount === v.outCount)) || !((t.inCount === v.inCount))) { - $s = -1; return false; - } - i = 0; - /* while (true) { */ case 18: - /* if (!(i < t.rtype.NumIn())) { break; } */ if(!(i < t.rtype.NumIn())) { $s = 19; continue; } - _r$3 = haveIdenticalType(t.rtype.In(i), v.rtype.In(i), cmpTags); /* */ $s = 22; case 22: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (!_r$3) { $s = 20; continue; } - /* */ $s = 21; continue; - /* if (!_r$3) { */ case 20: - $s = -1; return false; - /* } */ case 21: - i = i + (1) >> 0; - /* } */ $s = 18; continue; case 19: - i$1 = 0; - /* while (true) { */ case 23: - /* if (!(i$1 < t.rtype.NumOut())) { break; } */ if(!(i$1 < t.rtype.NumOut())) { $s = 24; continue; } - _r$4 = haveIdenticalType(t.rtype.Out(i$1), v.rtype.Out(i$1), cmpTags); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (!_r$4) { $s = 25; continue; } - /* */ $s = 26; continue; - /* if (!_r$4) { */ case 25: - $s = -1; return false; - /* } */ case 26: - i$1 = i$1 + (1) >> 0; - /* } */ $s = 23; continue; case 24: - $s = -1; return true; - /* } else if (_1 === (20)) { */ case 5: - t$1 = (T.kindType); - v$1 = (V.kindType); - if ((t$1.methods.$length === 0) && (v$1.methods.$length === 0)) { - $s = -1; return true; - } - $s = -1; return false; - /* } else if (_1 === (21)) { */ case 6: - _r$5 = haveIdenticalType(T.Key(), V.Key(), cmpTags); /* */ $s = 29; case 29: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - if (!(_r$5)) { _v$3 = false; $s = 28; continue s; } - _r$6 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 30; case 30: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _v$3 = _r$6; case 28: - $s = -1; return _v$3; - /* } else if ((_1 === (22)) || (_1 === (23))) { */ case 7: - _r$7 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 31; case 31: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $s = -1; return _r$7; - /* } else if (_1 === (25)) { */ case 8: - t$2 = (T.kindType); - v$2 = (V.kindType); - if (!((t$2.fields.$length === v$2.fields.$length))) { - $s = -1; return false; - } - if (!($clone(t$2.pkgPath, name).name() === $clone(v$2.pkgPath, name).name())) { - $s = -1; return false; - } - _ref = t$2.fields; - _i = 0; - /* while (true) { */ case 32: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 33; continue; } - i$2 = _i; - tf = (x = t$2.fields, ((i$2 < 0 || i$2 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i$2])); - vf = (x$1 = v$2.fields, ((i$2 < 0 || i$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i$2])); - if (!($clone(tf.name, name).name() === $clone(vf.name, name).name())) { - $s = -1; return false; - } - _r$8 = haveIdenticalType(tf.typ, vf.typ, cmpTags); /* */ $s = 36; case 36: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - /* */ if (!_r$8) { $s = 34; continue; } - /* */ $s = 35; continue; - /* if (!_r$8) { */ case 34: - $s = -1; return false; - /* } */ case 35: - if (cmpTags && !($clone(tf.name, name).tag() === $clone(vf.name, name).tag())) { - $s = -1; return false; - } - if (!((tf.offsetEmbed === vf.offsetEmbed))) { - $s = -1; return false; - } - _i++; - /* } */ $s = 32; continue; case 33: - $s = -1; return true; - /* } */ case 9: - case 1: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalUnderlyingType }; } $f.T = T; $f.V = V; $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.cmpTags = cmpTags; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.kind = kind; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.tf = tf; $f.v = v; $f.v$1 = v$1; $f.v$2 = v$2; $f.vf = vf; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - toType = function(t) { - var t; - if (t === ptrType$1.nil) { - return $ifaceNil; - } - return t; - }; - ifaceIndir = function(t) { - var t; - return ((t.kind & 32) >>> 0) === 0; - }; - flag.prototype.kind = function() { - var f; - f = this.$val; - return ((((f & 31) >>> 0) >>> 0)); - }; - $ptrType(flag).prototype.kind = function() { return new flag(this.$get()).kind(); }; - flag.prototype.ro = function() { - var f; - f = this.$val; - if (!((((f & 96) >>> 0) === 0))) { - return 32; - } - return 0; - }; - $ptrType(flag).prototype.ro = function() { return new flag(this.$get()).ro(); }; - Value.ptr.prototype.pointer = function() { - var v; - v = this; - if (!((v.typ.size === 4)) || !v.typ.pointers()) { - $panic(new $String("can't call pointer on a non-pointer Value")); - } - if (!((((v.flag & 128) >>> 0) === 0))) { - return (v.ptr).$get(); - } - return v.ptr; - }; - Value.prototype.pointer = function() { return this.$val.pointer(); }; - ValueError.ptr.prototype.Error = function() { - var e; - e = this; - if (e.Kind === 0) { - return "reflect: call of " + e.Method + " on zero Value"; - } - return "reflect: call of " + e.Method + " on " + new Kind(e.Kind).String() + " Value"; - }; - ValueError.prototype.Error = function() { return this.$val.Error(); }; - flag.prototype.mustBe = function(expected) { - var expected, f; - f = this.$val; - if (!((new flag(f).kind() === expected))) { - $panic(new ValueError.ptr(methodName(), new flag(f).kind())); - } - }; - $ptrType(flag).prototype.mustBe = function(expected) { return new flag(this.$get()).mustBe(expected); }; - flag.prototype.mustBeExported = function() { - var f; - f = this.$val; - if (f === 0) { - $panic(new ValueError.ptr(methodName(), 0)); - } - if (!((((f & 96) >>> 0) === 0))) { - $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); - } - }; - $ptrType(flag).prototype.mustBeExported = function() { return new flag(this.$get()).mustBeExported(); }; - flag.prototype.mustBeAssignable = function() { - var f; - f = this.$val; - if (f === 0) { - $panic(new ValueError.ptr(methodName(), 0)); - } - if (!((((f & 96) >>> 0) === 0))) { - $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); - } - if (((f & 256) >>> 0) === 0) { - $panic(new $String("reflect: " + methodName() + " using unaddressable value")); - } - }; - $ptrType(flag).prototype.mustBeAssignable = function() { return new flag(this.$get()).mustBeAssignable(); }; - Value.ptr.prototype.Addr = function() { - var v; - v = this; - if (((v.flag & 256) >>> 0) === 0) { - $panic(new $String("reflect.Value.Addr of unaddressable value")); - } - return new Value.ptr(v.typ.ptrTo(), v.ptr, (new flag(v.flag).ro() | 22) >>> 0); - }; - Value.prototype.Addr = function() { return this.$val.Addr(); }; - Value.ptr.prototype.Bool = function() { - var v; - v = this; - new flag(v.flag).mustBe(1); - return (v.ptr).$get(); - }; - Value.prototype.Bool = function() { return this.$val.Bool(); }; - Value.ptr.prototype.Bytes = function() { - var _r, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(23); - _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 8))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 8))) { */ case 1: - $panic(new $String("reflect.Value.Bytes of non-byte slice")); - /* } */ case 2: - $s = -1; return (v.ptr).$get(); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Bytes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Bytes = function() { return this.$val.Bytes(); }; - Value.ptr.prototype.runes = function() { - var _r, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(23); - _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 5))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 5))) { */ case 1: - $panic(new $String("reflect.Value.Bytes of non-rune slice")); - /* } */ case 2: - $s = -1; return (v.ptr).$get(); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.runes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.runes = function() { return this.$val.runes(); }; - Value.ptr.prototype.CanAddr = function() { - var v; - v = this; - return !((((v.flag & 256) >>> 0) === 0)); - }; - Value.prototype.CanAddr = function() { return this.$val.CanAddr(); }; - Value.ptr.prototype.CanSet = function() { - var v; - v = this; - return ((v.flag & 352) >>> 0) === 256; - }; - Value.prototype.CanSet = function() { return this.$val.CanSet(); }; - Value.ptr.prototype.Call = function(in$1) { - var _r, in$1, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(19); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).call("Call", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Call }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Call = function(in$1) { return this.$val.Call(in$1); }; - Value.ptr.prototype.CallSlice = function(in$1) { - var _r, in$1, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(19); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).call("CallSlice", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.CallSlice }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.CallSlice = function(in$1) { return this.$val.CallSlice(in$1); }; - Value.ptr.prototype.Complex = function() { - var _1, k, v, x; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (15)) { - return ((x = (v.ptr).$get(), new $Complex128(x.$real, x.$imag))); - } else if (_1 === (16)) { - return (v.ptr).$get(); - } - $panic(new ValueError.ptr("reflect.Value.Complex", new flag(v.flag).kind())); - }; - Value.prototype.Complex = function() { return this.$val.Complex(); }; - Value.ptr.prototype.FieldByIndex = function(index) { - var _i, _r, _r$1, _r$2, _r$3, _ref, _v, i, index, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _v = $f._v; i = $f.i; index = $f.index; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - /* */ if (index.$length === 1) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (index.$length === 1) { */ case 1: - _r = $clone(v, Value).Field((0 >= index.$length ? ($throwRuntimeError("index out of range"), undefined) : index.$array[index.$offset + 0])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 2: - new flag(v.flag).mustBe(25); - _ref = index; - _i = 0; - /* while (true) { */ case 4: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } - i = _i; - x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - /* */ if (i > 0) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (i > 0) { */ case 6: - if (!($clone(v, Value).Kind() === 22)) { _v = false; $s = 10; continue s; } - _r$1 = v.typ.Elem().Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v = _r$1 === 25; case 10: - /* */ if (_v) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (_v) { */ case 8: - if ($clone(v, Value).IsNil()) { - $panic(new $String("reflect: indirection through nil pointer to embedded struct")); - } - _r$2 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - v = _r$2; - /* } */ case 9: - /* } */ case 7: - _r$3 = $clone(v, Value).Field(x); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - v = _r$3; - _i++; - /* } */ $s = 4; continue; case 5: - $s = -1; return v; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._v = _v; $f.i = i; $f.index = index; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; - Value.ptr.prototype.FieldByName = function(name$1) { - var _r, _r$1, _tuple, f, name$1, ok, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(25); - _r = v.typ.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - f = $clone(_tuple[0], StructField); - ok = _tuple[1]; - /* */ if (ok) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (ok) { */ case 2: - _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 3: - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByName }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; - Value.ptr.prototype.FieldByNameFunc = function(match) { - var _r, _r$1, _tuple, f, match, ok, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; match = $f.match; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - _r = v.typ.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - f = $clone(_tuple[0], StructField); - ok = _tuple[1]; - /* */ if (ok) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (ok) { */ case 2: - _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 3: - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.match = match; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; - Value.ptr.prototype.Float = function() { - var _1, k, v; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (13)) { - return ((v.ptr).$get()); - } else if (_1 === (14)) { - return (v.ptr).$get(); - } - $panic(new ValueError.ptr("reflect.Value.Float", new flag(v.flag).kind())); - }; - Value.prototype.Float = function() { return this.$val.Float(); }; - Value.ptr.prototype.Int = function() { - var _1, k, p, v; - v = this; - k = new flag(v.flag).kind(); - p = v.ptr; - _1 = k; - if (_1 === (2)) { - return (new $Int64(0, (p).$get())); - } else if (_1 === (3)) { - return (new $Int64(0, (p).$get())); - } else if (_1 === (4)) { - return (new $Int64(0, (p).$get())); - } else if (_1 === (5)) { - return (new $Int64(0, (p).$get())); - } else if (_1 === (6)) { - return (p).$get(); - } - $panic(new ValueError.ptr("reflect.Value.Int", new flag(v.flag).kind())); - }; - Value.prototype.Int = function() { return this.$val.Int(); }; - Value.ptr.prototype.CanInterface = function() { - var v; - v = this; - if (v.flag === 0) { - $panic(new ValueError.ptr("reflect.Value.CanInterface", 0)); - } - return ((v.flag & 96) >>> 0) === 0; - }; - Value.prototype.CanInterface = function() { return this.$val.CanInterface(); }; - Value.ptr.prototype.Interface = function() { - var _r, i, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = $ifaceNil; - v = this; - _r = valueInterface($clone(v, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - i = _r; - $s = -1; return i; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Interface }; } $f._r = _r; $f.i = i; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Interface = function() { return this.$val.Interface(); }; - Value.ptr.prototype.IsValid = function() { - var v; - v = this; - return !((v.flag === 0)); - }; - Value.prototype.IsValid = function() { return this.$val.IsValid(); }; - Value.ptr.prototype.Kind = function() { - var v; - v = this; - return new flag(v.flag).kind(); - }; - Value.prototype.Kind = function() { return this.$val.Kind(); }; - Value.ptr.prototype.MapIndex = function(key) { - var _r, e, fl, k, key, tt, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; fl = $f.fl; k = $f.k; key = $f.key; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(21); - tt = (v.typ.kindType); - _r = $clone(key, Value).assignTo("reflect.Value.MapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - key = _r; - k = 0; - if (!((((key.flag & 128) >>> 0) === 0))) { - k = key.ptr; - } else { - k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); - } - e = mapaccess(v.typ, $clone(v, Value).pointer(), k); - if (e === 0) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - typ = tt.elem; - fl = new flag((((v.flag | key.flag) >>> 0))).ro(); - fl = (fl | (((typ.Kind() >>> 0)))) >>> 0; - $s = -1; return copyVal(typ, fl, e); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapIndex }; } $f._r = _r; $f.e = e; $f.fl = fl; $f.k = k; $f.key = key; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.MapIndex = function(key) { return this.$val.MapIndex(key); }; - Value.ptr.prototype.MapKeys = function() { - var _r, a, fl, i, it, key, keyType, m, mlen, tt, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; fl = $f.fl; i = $f.i; it = $f.it; key = $f.key; keyType = $f.keyType; m = $f.m; mlen = $f.mlen; tt = $f.tt; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(21); - tt = (v.typ.kindType); - keyType = tt.key; - fl = (new flag(v.flag).ro() | ((keyType.Kind() >>> 0))) >>> 0; - m = $clone(v, Value).pointer(); - mlen = 0; - if (!(m === 0)) { - mlen = maplen(m); - } - it = mapiterinit(v.typ, m); - a = $makeSlice(sliceType$9, mlen); - i = 0; - i = 0; - /* while (true) { */ case 1: - /* if (!(i < a.$length)) { break; } */ if(!(i < a.$length)) { $s = 2; continue; } - _r = mapiterkey(it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - key = _r; - if (key === 0) { - /* break; */ $s = 2; continue; - } - ((i < 0 || i >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + i] = copyVal(keyType, fl, key)); - mapiternext(it); - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return $subslice(a, 0, i); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapKeys }; } $f._r = _r; $f.a = a; $f.fl = fl; $f.i = i; $f.it = it; $f.key = key; $f.keyType = keyType; $f.m = m; $f.mlen = mlen; $f.tt = tt; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.MapKeys = function() { return this.$val.MapKeys(); }; - MapIter.ptr.prototype.Key = function() { - var _arg, _arg$1, _arg$2, _r, _r$1, _r$2, it, ktype, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; ktype = $f.ktype; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - it = this; - if (it.it === 0) { - $panic(new $String("MapIter.Key called before Next")); - } - _r = mapiterkey(it.it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r === 0) { */ case 1: - $panic(new $String("MapIter.Key called on exhausted iterator")); - /* } */ case 2: - t = (it.m.typ.kindType); - ktype = t.key; - _arg = ktype; - _arg$1 = (new flag(it.m.flag).ro() | ((ktype.Kind() >>> 0))) >>> 0; - _r$1 = mapiterkey(it.it); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$2 = _r$1; - _r$2 = copyVal(_arg, _arg$1, _arg$2); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Key }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.ktype = ktype; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - MapIter.prototype.Key = function() { return this.$val.Key(); }; - MapIter.ptr.prototype.Value = function() { - var _arg, _arg$1, _arg$2, _r, _r$1, _r$2, it, t, vtype, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; t = $f.t; vtype = $f.vtype; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - it = this; - if (it.it === 0) { - $panic(new $String("MapIter.Value called before Next")); - } - _r = mapiterkey(it.it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r === 0) { */ case 1: - $panic(new $String("MapIter.Value called on exhausted iterator")); - /* } */ case 2: - t = (it.m.typ.kindType); - vtype = t.elem; - _arg = vtype; - _arg$1 = (new flag(it.m.flag).ro() | ((vtype.Kind() >>> 0))) >>> 0; - _r$1 = mapitervalue(it.it); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$2 = _r$1; - _r$2 = copyVal(_arg, _arg$1, _arg$2); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Value }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.t = t; $f.vtype = vtype; $f.$s = $s; $f.$r = $r; return $f; - }; - MapIter.prototype.Value = function() { return this.$val.Value(); }; - MapIter.ptr.prototype.Next = function() { - var _r, _r$1, it, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; it = $f.it; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - it = this; - /* */ if (it.it === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (it.it === 0) { */ case 1: - it.it = mapiterinit(it.m.typ, $clone(it.m, Value).pointer()); - $s = 3; continue; - /* } else { */ case 2: - _r = mapiterkey(it.it); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r === 0) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r === 0) { */ case 4: - $panic(new $String("MapIter.Next called on exhausted iterator")); - /* } */ case 5: - mapiternext(it.it); - /* } */ case 3: - _r$1 = mapiterkey(it.it); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return !(_r$1 === 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: MapIter.ptr.prototype.Next }; } $f._r = _r; $f._r$1 = _r$1; $f.it = it; $f.$s = $s; $f.$r = $r; return $f; - }; - MapIter.prototype.Next = function() { return this.$val.Next(); }; - Value.ptr.prototype.MapRange = function() { - var v; - v = this; - new flag(v.flag).mustBe(21); - return new MapIter.ptr($clone(v, Value), 0); - }; - Value.prototype.MapRange = function() { return this.$val.MapRange(); }; - copyVal = function(typ, fl, ptr) { - var c, fl, ptr, typ; - if (ifaceIndir(typ)) { - c = unsafe_New(typ); - typedmemmove(typ, c, ptr); - return new Value.ptr(typ, c, (fl | 128) >>> 0); - } - return new Value.ptr(typ, (ptr).$get(), fl); - }; - Value.ptr.prototype.Method = function(i) { - var fl, i, v; - v = this; - if (v.typ === ptrType$1.nil) { - $panic(new ValueError.ptr("reflect.Value.Method", 0)); - } - if (!((((v.flag & 512) >>> 0) === 0)) || ((i >>> 0)) >= ((v.typ.NumMethod() >>> 0))) { - $panic(new $String("reflect: Method index out of range")); - } - if ((v.typ.Kind() === 20) && $clone(v, Value).IsNil()) { - $panic(new $String("reflect: Method on nil interface value")); - } - fl = (v.flag & 160) >>> 0; - fl = (fl | (19)) >>> 0; - fl = (fl | ((((((i >>> 0)) << 10 >>> 0) | 512) >>> 0))) >>> 0; - return new Value.ptr(v.typ, v.ptr, fl); - }; - Value.prototype.Method = function(i) { return this.$val.Method(i); }; - Value.ptr.prototype.NumMethod = function() { - var v; - v = this; - if (v.typ === ptrType$1.nil) { - $panic(new ValueError.ptr("reflect.Value.NumMethod", 0)); - } - if (!((((v.flag & 512) >>> 0) === 0))) { - return 0; - } - return v.typ.NumMethod(); - }; - Value.prototype.NumMethod = function() { return this.$val.NumMethod(); }; - Value.ptr.prototype.MethodByName = function(name$1) { - var _r, _tuple, m, name$1, ok, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; m = $f.m; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - if (v.typ === ptrType$1.nil) { - $panic(new ValueError.ptr("reflect.Value.MethodByName", 0)); - } - if (!((((v.flag & 512) >>> 0) === 0))) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - _r = v.typ.MethodByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = $clone(_tuple[0], Method); - ok = _tuple[1]; - if (!ok) { - $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); - } - $s = -1; return $clone(v, Value).Method(m.Index); - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MethodByName }; } $f._r = _r; $f._tuple = _tuple; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; - Value.ptr.prototype.NumField = function() { - var tt, v; - v = this; - new flag(v.flag).mustBe(25); - tt = (v.typ.kindType); - return tt.fields.$length; - }; - Value.prototype.NumField = function() { return this.$val.NumField(); }; - Value.ptr.prototype.OverflowComplex = function(x) { - var _1, k, v, x; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (15)) { - return overflowFloat32(x.$real) || overflowFloat32(x.$imag); - } else if (_1 === (16)) { - return false; - } - $panic(new ValueError.ptr("reflect.Value.OverflowComplex", new flag(v.flag).kind())); - }; - Value.prototype.OverflowComplex = function(x) { return this.$val.OverflowComplex(x); }; - Value.ptr.prototype.OverflowFloat = function(x) { - var _1, k, v, x; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (13)) { - return overflowFloat32(x); - } else if (_1 === (14)) { - return false; - } - $panic(new ValueError.ptr("reflect.Value.OverflowFloat", new flag(v.flag).kind())); - }; - Value.prototype.OverflowFloat = function(x) { return this.$val.OverflowFloat(x); }; - overflowFloat32 = function(x) { - var x; - if (x < 0) { - x = -x; - } - return 3.4028234663852886e+38 < x && x <= 1.7976931348623157e+308; - }; - Value.ptr.prototype.OverflowInt = function(x) { - var _1, bitSize, k, trunc, v, x; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { - bitSize = $imul(v.typ.size, 8) >>> 0; - trunc = $shiftRightInt64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); - return !((x.$high === trunc.$high && x.$low === trunc.$low)); - } - $panic(new ValueError.ptr("reflect.Value.OverflowInt", new flag(v.flag).kind())); - }; - Value.prototype.OverflowInt = function(x) { return this.$val.OverflowInt(x); }; - Value.ptr.prototype.OverflowUint = function(x) { - var _1, bitSize, k, trunc, v, x; - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if ((_1 === (7)) || (_1 === (12)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11))) { - bitSize = $imul(v.typ.size, 8) >>> 0; - trunc = $shiftRightUint64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); - return !((x.$high === trunc.$high && x.$low === trunc.$low)); - } - $panic(new ValueError.ptr("reflect.Value.OverflowUint", new flag(v.flag).kind())); - }; - Value.prototype.OverflowUint = function(x) { return this.$val.OverflowUint(x); }; - Value.ptr.prototype.Recv = function() { - var _r, _tuple, ok, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = new Value.ptr(ptrType$1.nil, 0, 0); - ok = false; - v = this; - new flag(v.flag).mustBe(18); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).recv(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - x = _tuple[0]; - ok = _tuple[1]; - $s = -1; return [x, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Recv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Recv = function() { return this.$val.Recv(); }; - Value.ptr.prototype.recv = function(nb) { - var _r, _tuple, nb, ok, p, selected, t, tt, v, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; nb = $f.nb; ok = $f.ok; p = $f.p; selected = $f.selected; t = $f.t; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - val = new Value.ptr(ptrType$1.nil, 0, 0); - ok = false; - v = this; - tt = (v.typ.kindType); - if ((((tt.dir >> 0)) & 1) === 0) { - $panic(new $String("reflect: recv on send-only channel")); - } - t = tt.elem; - val = new Value.ptr(t, 0, ((t.Kind() >>> 0))); - p = 0; - if (ifaceIndir(t)) { - p = unsafe_New(t); - val.ptr = p; - val.flag = (val.flag | (128)) >>> 0; - } else { - p = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); - } - _r = chanrecv($clone(v, Value).pointer(), nb, p); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - selected = _tuple[0]; - ok = _tuple[1]; - if (!selected) { - val = new Value.ptr(ptrType$1.nil, 0, 0); - } - $s = -1; return [val, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.recv }; } $f._r = _r; $f._tuple = _tuple; $f.nb = nb; $f.ok = ok; $f.p = p; $f.selected = selected; $f.t = t; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.recv = function(nb) { return this.$val.recv(nb); }; - Value.ptr.prototype.Send = function(x) { - var _r, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(18); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).send($clone(x, Value), false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Send }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Send = function(x) { return this.$val.Send(x); }; - Value.ptr.prototype.send = function(x, nb) { - var _r, _r$1, nb, p, selected, tt, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; nb = $f.nb; p = $f.p; selected = $f.selected; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - selected = false; - v = this; - tt = (v.typ.kindType); - if ((((tt.dir >> 0)) & 2) === 0) { - $panic(new $String("reflect: send on recv-only channel")); - } - new flag(x.flag).mustBeExported(); - _r = $clone(x, Value).assignTo("reflect.Value.Send", tt.elem, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x = _r; - p = 0; - if (!((((x.flag & 128) >>> 0) === 0))) { - p = x.ptr; - } else { - p = ((x.$ptr_ptr || (x.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, x)))); - } - _r$1 = chansend($clone(v, Value).pointer(), p, nb); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - selected = _r$1; - $s = -1; return selected; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.send }; } $f._r = _r; $f._r$1 = _r$1; $f.nb = nb; $f.p = p; $f.selected = selected; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.send = function(x, nb) { return this.$val.send(x, nb); }; - Value.ptr.prototype.SetBool = function(x) { - var v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(1); - (v.ptr).$set(x); - }; - Value.prototype.SetBool = function(x) { return this.$val.SetBool(x); }; - Value.ptr.prototype.setRunes = function(x) { - var _r, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(23); - _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 5))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 5))) { */ case 1: - $panic(new $String("reflect.Value.setRunes of non-rune slice")); - /* } */ case 2: - (v.ptr).$set(x); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.setRunes }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.setRunes = function(x) { return this.$val.setRunes(x); }; - Value.ptr.prototype.SetComplex = function(x) { - var _1, k, v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (15)) { - (v.ptr).$set((new $Complex64(x.$real, x.$imag))); - } else if (_1 === (16)) { - (v.ptr).$set(x); - } else { - $panic(new ValueError.ptr("reflect.Value.SetComplex", new flag(v.flag).kind())); - } - }; - Value.prototype.SetComplex = function(x) { return this.$val.SetComplex(x); }; - Value.ptr.prototype.SetFloat = function(x) { - var _1, k, v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (13)) { - (v.ptr).$set(($fround(x))); - } else if (_1 === (14)) { - (v.ptr).$set(x); - } else { - $panic(new ValueError.ptr("reflect.Value.SetFloat", new flag(v.flag).kind())); - } - }; - Value.prototype.SetFloat = function(x) { return this.$val.SetFloat(x); }; - Value.ptr.prototype.SetInt = function(x) { - var _1, k, v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (2)) { - (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); - } else if (_1 === (3)) { - (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24))); - } else if (_1 === (4)) { - (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 16 >> 16))); - } else if (_1 === (5)) { - (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); - } else if (_1 === (6)) { - (v.ptr).$set(x); - } else { - $panic(new ValueError.ptr("reflect.Value.SetInt", new flag(v.flag).kind())); - } - }; - Value.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; - Value.ptr.prototype.SetMapIndex = function(key, val) { - var _r, _r$1, e, k, key, tt, v, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; e = $f.e; k = $f.k; key = $f.key; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(21); - new flag(v.flag).mustBeExported(); - new flag(key.flag).mustBeExported(); - tt = (v.typ.kindType); - _r = $clone(key, Value).assignTo("reflect.Value.SetMapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - key = _r; - k = 0; - if (!((((key.flag & 128) >>> 0) === 0))) { - k = key.ptr; - } else { - k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); - } - if (val.typ === ptrType$1.nil) { - mapdelete(v.typ, $clone(v, Value).pointer(), k); - $s = -1; return; - } - new flag(val.flag).mustBeExported(); - _r$1 = $clone(val, Value).assignTo("reflect.Value.SetMapIndex", tt.elem, 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - val = _r$1; - e = 0; - if (!((((val.flag & 128) >>> 0) === 0))) { - e = val.ptr; - } else { - e = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$17(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); - } - $r = mapassign(v.typ, $clone(v, Value).pointer(), k, e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetMapIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.e = e; $f.k = k; $f.key = key; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.SetMapIndex = function(key, val) { return this.$val.SetMapIndex(key, val); }; - Value.ptr.prototype.SetUint = function(x) { - var _1, k, v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (7)) { - (v.ptr).$set(((x.$low >>> 0))); - } else if (_1 === (8)) { - (v.ptr).$set(((x.$low << 24 >>> 24))); - } else if (_1 === (9)) { - (v.ptr).$set(((x.$low << 16 >>> 16))); - } else if (_1 === (10)) { - (v.ptr).$set(((x.$low >>> 0))); - } else if (_1 === (11)) { - (v.ptr).$set(x); - } else if (_1 === (12)) { - (v.ptr).$set(((x.$low >>> 0))); - } else { - $panic(new ValueError.ptr("reflect.Value.SetUint", new flag(v.flag).kind())); - } - }; - Value.prototype.SetUint = function(x) { return this.$val.SetUint(x); }; - Value.ptr.prototype.SetPointer = function(x) { - var v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(26); - (v.ptr).$set(x); - }; - Value.prototype.SetPointer = function(x) { return this.$val.SetPointer(x); }; - Value.ptr.prototype.SetString = function(x) { - var v, x; - v = this; - new flag(v.flag).mustBeAssignable(); - new flag(v.flag).mustBe(24); - (v.ptr).$set(x); - }; - Value.prototype.SetString = function(x) { return this.$val.SetString(x); }; - Value.ptr.prototype.String = function() { - var _1, _r, k, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; k = $f.k; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - k = new flag(v.flag).kind(); - _1 = k; - if (_1 === (0)) { - $s = -1; return ""; - } else if (_1 === (24)) { - $s = -1; return (v.ptr).$get(); - } - _r = $clone(v, Value).Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return "<" + _r + " Value>"; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.String }; } $f._1 = _1; $f._r = _r; $f.k = k; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.String = function() { return this.$val.String(); }; - Value.ptr.prototype.TryRecv = function() { - var _r, _tuple, ok, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = new Value.ptr(ptrType$1.nil, 0, 0); - ok = false; - v = this; - new flag(v.flag).mustBe(18); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).recv(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - x = _tuple[0]; - ok = _tuple[1]; - $s = -1; return [x, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TryRecv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.TryRecv = function() { return this.$val.TryRecv(); }; - Value.ptr.prototype.TrySend = function(x) { - var _r, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - new flag(v.flag).mustBe(18); - new flag(v.flag).mustBeExported(); - _r = $clone(v, Value).send($clone(x, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TrySend }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.TrySend = function(x) { return this.$val.TrySend(x); }; - Value.ptr.prototype.Type = function() { - var f, i, m, m$1, ms, tt, v, x; - v = this; - f = v.flag; - if (f === 0) { - $panic(new ValueError.ptr("reflect.Value.Type", 0)); - } - if (((f & 512) >>> 0) === 0) { - return v.typ; - } - i = ((v.flag >> 0)) >> 10 >> 0; - if (v.typ.Kind() === 20) { - tt = (v.typ.kindType); - if (((i >>> 0)) >= ((tt.methods.$length >>> 0))) { - $panic(new $String("reflect: internal error: invalid method index")); - } - m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - return v.typ.typeOff(m.typ); - } - ms = v.typ.exportedMethods(); - if (((i >>> 0)) >= ((ms.$length >>> 0))) { - $panic(new $String("reflect: internal error: invalid method index")); - } - m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); - return v.typ.typeOff(m$1.mtyp); - }; - Value.prototype.Type = function() { return this.$val.Type(); }; - Value.ptr.prototype.Uint = function() { - var _1, k, p, v, x; - v = this; - k = new flag(v.flag).kind(); - p = v.ptr; - _1 = k; - if (_1 === (7)) { - return (new $Uint64(0, (p).$get())); - } else if (_1 === (8)) { - return (new $Uint64(0, (p).$get())); - } else if (_1 === (9)) { - return (new $Uint64(0, (p).$get())); - } else if (_1 === (10)) { - return (new $Uint64(0, (p).$get())); - } else if (_1 === (11)) { - return (p).$get(); - } else if (_1 === (12)) { - return ((x = (p).$get(), new $Uint64(0, x.constructor === Number ? x : 1))); - } - $panic(new ValueError.ptr("reflect.Value.Uint", new flag(v.flag).kind())); - }; - Value.prototype.Uint = function() { return this.$val.Uint(); }; - Value.ptr.prototype.UnsafeAddr = function() { - var v; - v = this; - if (v.typ === ptrType$1.nil) { - $panic(new ValueError.ptr("reflect.Value.UnsafeAddr", 0)); - } - if (((v.flag & 256) >>> 0) === 0) { - $panic(new $String("reflect.Value.UnsafeAddr of unaddressable value")); - } - return (v.ptr); - }; - Value.prototype.UnsafeAddr = function() { return this.$val.UnsafeAddr(); }; - New = function(typ) { - var fl, ptr, t, typ; - if ($interfaceIsEqual(typ, $ifaceNil)) { - $panic(new $String("reflect: New(nil)")); - } - t = $assertType(typ, ptrType$1); - ptr = unsafe_New(t); - fl = 22; - return new Value.ptr(t.ptrTo(), ptr, fl); - }; - $pkg.New = New; - Value.ptr.prototype.Convert = function(t) { - var _r, _r$1, _r$2, _r$3, _r$4, op, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; op = $f.op; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this; - /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: - _r = makeMethodValue("Convert", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - /* } */ case 2: - _r$1 = t.common(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = convertOp(_r$1, v.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - op = _r$2; - /* */ if (op === $throwNilPointerError) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (op === $throwNilPointerError) { */ case 6: - _r$3 = t.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $panic(new $String("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + _r$3)); - /* } */ case 7: - _r$4 = op($clone(v, Value), t); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return _r$4; - /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Convert }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.op = op; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Value.prototype.Convert = function(t) { return this.$val.Convert(t); }; - convertOp = function(dst, src) { - var _1, _2, _3, _4, _5, _6, _7, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _v, _v$1, _v$2, dst, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _5 = $f._5; _6 = $f._6; _7 = $f._7; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; dst = $f.dst; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _1 = src.Kind(); - /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 2; continue; } - /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 3; continue; } - /* */ if ((_1 === (13)) || (_1 === (14))) { $s = 4; continue; } - /* */ if ((_1 === (15)) || (_1 === (16))) { $s = 5; continue; } - /* */ if (_1 === (24)) { $s = 6; continue; } - /* */ if (_1 === (23)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 2: - _2 = dst.Kind(); - if ((_2 === (2)) || (_2 === (3)) || (_2 === (4)) || (_2 === (5)) || (_2 === (6)) || (_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10)) || (_2 === (11)) || (_2 === (12))) { - $s = -1; return cvtInt; - } else if ((_2 === (13)) || (_2 === (14))) { - $s = -1; return cvtIntFloat; - } else if (_2 === (24)) { - $s = -1; return cvtIntString; - } - $s = 8; continue; - /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 3: - _3 = dst.Kind(); - if ((_3 === (2)) || (_3 === (3)) || (_3 === (4)) || (_3 === (5)) || (_3 === (6)) || (_3 === (7)) || (_3 === (8)) || (_3 === (9)) || (_3 === (10)) || (_3 === (11)) || (_3 === (12))) { - $s = -1; return cvtUint; - } else if ((_3 === (13)) || (_3 === (14))) { - $s = -1; return cvtUintFloat; - } else if (_3 === (24)) { - $s = -1; return cvtUintString; - } - $s = 8; continue; - /* } else if ((_1 === (13)) || (_1 === (14))) { */ case 4: - _4 = dst.Kind(); - if ((_4 === (2)) || (_4 === (3)) || (_4 === (4)) || (_4 === (5)) || (_4 === (6))) { - $s = -1; return cvtFloatInt; - } else if ((_4 === (7)) || (_4 === (8)) || (_4 === (9)) || (_4 === (10)) || (_4 === (11)) || (_4 === (12))) { - $s = -1; return cvtFloatUint; - } else if ((_4 === (13)) || (_4 === (14))) { - $s = -1; return cvtFloat; - } - $s = 8; continue; - /* } else if ((_1 === (15)) || (_1 === (16))) { */ case 5: - _5 = dst.Kind(); - if ((_5 === (15)) || (_5 === (16))) { - $s = -1; return cvtComplex; - } - $s = 8; continue; - /* } else if (_1 === (24)) { */ case 6: - if (!(dst.Kind() === 23)) { _v = false; $s = 11; continue s; } - _r = dst.Elem().PkgPath(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r === ""; case 11: - /* */ if (_v) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (_v) { */ case 9: - _r$1 = dst.Elem().Kind(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _6 = _r$1; - if (_6 === (8)) { - $s = -1; return cvtStringBytes; - } else if (_6 === (5)) { - $s = -1; return cvtStringRunes; - } - case 13: - /* } */ case 10: - $s = 8; continue; - /* } else if (_1 === (23)) { */ case 7: - if (!(dst.Kind() === 24)) { _v$1 = false; $s = 17; continue s; } - _r$2 = src.Elem().PkgPath(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v$1 = _r$2 === ""; case 17: - /* */ if (_v$1) { $s = 15; continue; } - /* */ $s = 16; continue; - /* if (_v$1) { */ case 15: - _r$3 = src.Elem().Kind(); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _7 = _r$3; - if (_7 === (8)) { - $s = -1; return cvtBytesString; - } else if (_7 === (5)) { - $s = -1; return cvtRunesString; - } - case 19: - /* } */ case 16: - /* } */ case 8: - case 1: - _r$4 = haveIdenticalUnderlyingType(dst, src, false); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (_r$4) { $s = 21; continue; } - /* */ $s = 22; continue; - /* if (_r$4) { */ case 21: - $s = -1; return cvtDirect; - /* } */ case 22: - if (!((dst.Kind() === 22) && dst.Name() === "" && (src.Kind() === 22) && src.Name() === "")) { _v$2 = false; $s = 26; continue s; } - _r$5 = dst.Elem().common(); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg = _r$5; - _r$6 = src.Elem().common(); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _arg$1 = _r$6; - _r$7 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 29; case 29: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _v$2 = _r$7; case 26: - /* */ if (_v$2) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (_v$2) { */ case 24: - $s = -1; return cvtDirect; - /* } */ case 25: - if (implements$1(dst, src)) { - if (src.Kind() === 20) { - $s = -1; return cvtI2I; - } - $s = -1; return cvtT2I; - } - $s = -1; return $throwNilPointerError; - /* */ } return; } if ($f === undefined) { $f = { $blk: convertOp }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._5 = _5; $f._6 = _6; $f._7 = _7; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.dst = dst; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - makeFloat = function(f, v, t) { - var _1, _r, f, ptr, t, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - typ = _r; - ptr = unsafe_New(typ); - _1 = typ.size; - if (_1 === (4)) { - (ptr).$set(($fround(v))); - } else if (_1 === (8)) { - (ptr).$set(v); - } - $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: makeFloat }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - makeComplex = function(f, v, t) { - var _1, _r, f, ptr, t, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - typ = _r; - ptr = unsafe_New(typ); - _1 = typ.size; - if (_1 === (8)) { - (ptr).$set((new $Complex64(v.$real, v.$imag))); - } else if (_1 === (16)) { - (ptr).$set(v); - } - $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: makeComplex }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - makeString = function(f, v, t) { - var _r, f, ret, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ret = _r; - $clone(ret, Value).SetString(v); - ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; - $s = -1; return ret; - /* */ } return; } if ($f === undefined) { $f = { $blk: makeString }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - makeBytes = function(f, v, t) { - var _r, f, ret, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ret = _r; - $r = $clone(ret, Value).SetBytes(v); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; - $s = -1; return ret; - /* */ } return; } if ($f === undefined) { $f = { $blk: makeBytes }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - makeRunes = function(f, v, t) { - var _r, f, ret, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $clone(New(t), Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ret = _r; - $r = $clone(ret, Value).setRunes(v); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; - $s = -1; return ret; - /* */ } return; } if ($f === undefined) { $f = { $blk: makeRunes }; } $f._r = _r; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtInt = function(v, t) { - var _r, t, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeInt(new flag(v.flag).ro(), ((x = $clone(v, Value).Int(), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtUint = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeInt(new flag(v.flag).ro(), $clone(v, Value).Uint(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtFloatInt = function(v, t) { - var _r, t, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeInt(new flag(v.flag).ro(), ((x = (new $Int64(0, $clone(v, Value).Float())), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtFloatUint = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeInt(new flag(v.flag).ro(), (new $Uint64(0, $clone(v, Value).Float())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtIntFloat = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Int())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtUintFloat = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Uint())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtFloat = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeFloat(new flag(v.flag).ro(), $clone(v, Value).Float(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtComplex = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeComplex(new flag(v.flag).ro(), $clone(v, Value).Complex(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtComplex }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtIntString = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Int().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtUintString = function(v, t) { - var _r, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Uint().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtBytesString = function(v, t) { - var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = new flag(v.flag).ro(); - _r = $clone(v, Value).Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = ($bytesToString(_r)); - _arg$2 = t; - _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtBytesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtStringBytes = function(v, t) { - var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = new flag(v.flag).ro(); - _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = (new sliceType$15($stringToBytes(_r))); - _arg$2 = t; - _r$1 = makeBytes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringBytes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtRunesString = function(v, t) { - var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = new flag(v.flag).ro(); - _r = $clone(v, Value).runes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = ($runesToString(_r)); - _arg$2 = t; - _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtRunesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtStringRunes = function(v, t) { - var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = new flag(v.flag).ro(); - _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = (new sliceType$18($stringToRunes(_r))); - _arg$2 = t; - _r$1 = makeRunes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringRunes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtT2I = function(v, typ) { - var _r, _r$1, _r$2, _r$3, _r$4, target, typ, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; target = $f.target; typ = $f.typ; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = unsafe_New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - target = _r$1; - _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = _r$2; - _r$3 = typ.NumMethod(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3 === 0) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$3 === 0) { */ case 4: - (target).$set(x); - $s = 6; continue; - /* } else { */ case 5: - ifaceE2I($assertType(typ, ptrType$1), x, target); - /* } */ case 6: - _r$4 = typ.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return new Value.ptr(_r$4, target, (((new flag(v.flag).ro() | 128) >>> 0) | 20) >>> 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtT2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.target = target; $f.typ = typ; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - cvtI2I = function(v, typ) { - var _r, _r$1, _r$2, ret, typ, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; ret = $f.ret; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if ($clone(v, Value).IsNil()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($clone(v, Value).IsNil()) { */ case 1: - _r = Zero(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ret = _r; - ret.flag = (ret.flag | (new flag(v.flag).ro())) >>> 0; - $s = -1; return ret; - /* } */ case 2: - _r$1 = $clone(v, Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = cvtT2I($clone(_r$1, Value), typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: cvtI2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.ret = ret; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - ptrType$5.methods = [{prop: "methods", name: "methods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}, {prop: "exportedMethods", name: "exportedMethods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}]; - ptrType$8.methods = [{prop: "in$", name: "in", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}, {prop: "out", name: "out", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}]; - name.methods = [{prop: "name", name: "name", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "tag", name: "tag", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "isExported", name: "isExported", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "data", name: "data", pkg: "reflect", typ: $funcType([$Int, $String], [ptrType$4], false)}, {prop: "nameLen", name: "nameLen", pkg: "reflect", typ: $funcType([], [$Int], false)}, {prop: "tagLen", name: "tagLen", pkg: "reflect", typ: $funcType([], [$Int], false)}]; - ptrType$7.methods = [{prop: "skipUntilValidKey", name: "skipUntilValidKey", pkg: "reflect", typ: $funcType([], [], false)}]; - Kind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$1.methods = [{prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}, {prop: "nameOff", name: "nameOff", pkg: "reflect", typ: $funcType([nameOff], [name], false)}, {prop: "typeOff", name: "typeOff", pkg: "reflect", typ: $funcType([typeOff], [ptrType$1], false)}, {prop: "ptrTo", name: "ptrTo", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "pointers", name: "pointers", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "textOff", name: "textOff", pkg: "reflect", typ: $funcType([textOff], [$UnsafePointer], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "exportedMethods", name: "exportedMethods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}]; - ChanDir.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$9.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}]; - ptrType$18.methods = [{prop: "offset", name: "offset", pkg: "reflect", typ: $funcType([], [$Uintptr], false)}, {prop: "embedded", name: "embedded", pkg: "reflect", typ: $funcType([], [$Bool], false)}]; - ptrType$11.methods = [{prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}]; - StructTag.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [$String, $Bool], false)}]; - Value.methods = [{prop: "object", name: "object", pkg: "reflect", typ: $funcType([], [ptrType$2], false)}, {prop: "assignTo", name: "assignTo", pkg: "reflect", typ: $funcType([$String, ptrType$1, $UnsafePointer], [Value], false)}, {prop: "call", name: "call", pkg: "reflect", typ: $funcType([$String, sliceType$9], [sliceType$9], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "InterfaceData", name: "InterfaceData", pkg: "", typ: $funcType([], [arrayType$8], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Pointer", name: "Pointer", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([Value], [], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$15], [], false)}, {prop: "SetCap", name: "SetCap", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Slice", name: "Slice", pkg: "", typ: $funcType([$Int, $Int], [Value], false)}, {prop: "Slice3", name: "Slice3", pkg: "", typ: $funcType([$Int, $Int, $Int], [Value], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "pointer", name: "pointer", pkg: "reflect", typ: $funcType([], [$UnsafePointer], false)}, {prop: "Addr", name: "Addr", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$15], false)}, {prop: "runes", name: "runes", pkg: "reflect", typ: $funcType([], [sliceType$18], false)}, {prop: "CanAddr", name: "CanAddr", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CanSet", name: "CanSet", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "CallSlice", name: "CallSlice", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "Complex", name: "Complex", pkg: "", typ: $funcType([], [$Complex128], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [Value], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [Value], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "CanInterface", name: "CanInterface", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "MapIndex", name: "MapIndex", pkg: "", typ: $funcType([Value], [Value], false)}, {prop: "MapKeys", name: "MapKeys", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "MapRange", name: "MapRange", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OverflowComplex", name: "OverflowComplex", pkg: "", typ: $funcType([$Complex128], [$Bool], false)}, {prop: "OverflowFloat", name: "OverflowFloat", pkg: "", typ: $funcType([$Float64], [$Bool], false)}, {prop: "OverflowInt", name: "OverflowInt", pkg: "", typ: $funcType([$Int64], [$Bool], false)}, {prop: "OverflowUint", name: "OverflowUint", pkg: "", typ: $funcType([$Uint64], [$Bool], false)}, {prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "recv", name: "recv", pkg: "reflect", typ: $funcType([$Bool], [Value, $Bool], false)}, {prop: "Send", name: "Send", pkg: "", typ: $funcType([Value], [], false)}, {prop: "send", name: "send", pkg: "reflect", typ: $funcType([Value, $Bool], [$Bool], false)}, {prop: "SetBool", name: "SetBool", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "setRunes", name: "setRunes", pkg: "reflect", typ: $funcType([sliceType$18], [], false)}, {prop: "SetComplex", name: "SetComplex", pkg: "", typ: $funcType([$Complex128], [], false)}, {prop: "SetFloat", name: "SetFloat", pkg: "", typ: $funcType([$Float64], [], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "SetMapIndex", name: "SetMapIndex", pkg: "", typ: $funcType([Value, Value], [], false)}, {prop: "SetUint", name: "SetUint", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "SetPointer", name: "SetPointer", pkg: "", typ: $funcType([$UnsafePointer], [], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TryRecv", name: "TryRecv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "TrySend", name: "TrySend", pkg: "", typ: $funcType([Value], [$Bool], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "UnsafeAddr", name: "UnsafeAddr", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Convert", name: "Convert", pkg: "", typ: $funcType([Type], [Value], false)}]; - flag.methods = [{prop: "kind", name: "kind", pkg: "reflect", typ: $funcType([], [Kind], false)}, {prop: "ro", name: "ro", pkg: "reflect", typ: $funcType([], [flag], false)}, {prop: "mustBe", name: "mustBe", pkg: "reflect", typ: $funcType([Kind], [], false)}, {prop: "mustBeExported", name: "mustBeExported", pkg: "reflect", typ: $funcType([], [], false)}, {prop: "mustBeAssignable", name: "mustBeAssignable", pkg: "reflect", typ: $funcType([], [], false)}]; - ptrType$20.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$19.methods = [{prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([], [$Bool], false)}]; - uncommonType.init("reflect", [{prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "mcount", name: "mcount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "xcount", name: "xcount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "moff", name: "moff", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "_methods", name: "_methods", embedded: false, exported: false, typ: sliceType$5, tag: ""}]); - funcType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: "reflect:\"func\""}, {prop: "inCount", name: "inCount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "outCount", name: "outCount", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "_in", name: "_in", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "_out", name: "_out", embedded: false, exported: false, typ: sliceType$2, tag: ""}]); - name.init("reflect", [{prop: "bytes", name: "bytes", embedded: false, exported: false, typ: ptrType$4, tag: ""}]); - nameData.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tag", name: "tag", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "exported", name: "exported", embedded: false, exported: false, typ: $Bool, tag: ""}]); - mapIter.init("reflect", [{prop: "t", name: "t", embedded: false, exported: false, typ: Type, tag: ""}, {prop: "m", name: "m", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "keys", name: "keys", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "last", name: "last", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); - Type.init([{prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}]); - rtype.init("reflect", [{prop: "size", name: "size", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "ptrdata", name: "ptrdata", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "hash", name: "hash", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "tflag", name: "tflag", embedded: false, exported: false, typ: tflag, tag: ""}, {prop: "align", name: "align", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "fieldAlign", name: "fieldAlign", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "kind", name: "kind", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "alg", name: "alg", embedded: false, exported: false, typ: ptrType$3, tag: ""}, {prop: "gcdata", name: "gcdata", embedded: false, exported: false, typ: ptrType$4, tag: ""}, {prop: "str", name: "str", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "ptrToThis", name: "ptrToThis", embedded: false, exported: false, typ: typeOff, tag: ""}]); - typeAlg.init("reflect", [{prop: "hash", name: "hash", embedded: false, exported: false, typ: funcType$4, tag: ""}, {prop: "equal", name: "equal", embedded: false, exported: false, typ: funcType$5, tag: ""}]); - method.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "mtyp", name: "mtyp", embedded: false, exported: false, typ: typeOff, tag: ""}, {prop: "ifn", name: "ifn", embedded: false, exported: false, typ: textOff, tag: ""}, {prop: "tfn", name: "tfn", embedded: false, exported: false, typ: textOff, tag: ""}]); - arrayType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "slice", name: "slice", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); - chanType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "dir", name: "dir", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); - imethod.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: nameOff, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: typeOff, tag: ""}]); - interfaceType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: name, tag: ""}, {prop: "methods", name: "methods", embedded: false, exported: false, typ: sliceType$6, tag: ""}]); - mapType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "key", name: "key", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "bucket", name: "bucket", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "keysize", name: "keysize", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "valuesize", name: "valuesize", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "bucketsize", name: "bucketsize", embedded: false, exported: false, typ: $Uint16, tag: ""}, {prop: "flags", name: "flags", embedded: false, exported: false, typ: $Uint32, tag: ""}]); - ptrType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); - sliceType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "elem", name: "elem", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); - structField.init("reflect", [{prop: "name", name: "name", embedded: false, exported: false, typ: name, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "offsetEmbed", name: "offsetEmbed", embedded: false, exported: false, typ: $Uintptr, tag: ""}]); - structType.init("reflect", [{prop: "rtype", name: "rtype", embedded: true, exported: false, typ: rtype, tag: ""}, {prop: "pkgPath", name: "pkgPath", embedded: false, exported: false, typ: name, tag: ""}, {prop: "fields", name: "fields", embedded: false, exported: false, typ: sliceType$7, tag: ""}]); - Method.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", embedded: false, exported: true, typ: Type, tag: ""}, {prop: "Func", name: "Func", embedded: false, exported: true, typ: Value, tag: ""}, {prop: "Index", name: "Index", embedded: false, exported: true, typ: $Int, tag: ""}]); - StructField.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", embedded: false, exported: true, typ: Type, tag: ""}, {prop: "Tag", name: "Tag", embedded: false, exported: true, typ: StructTag, tag: ""}, {prop: "Offset", name: "Offset", embedded: false, exported: true, typ: $Uintptr, tag: ""}, {prop: "Index", name: "Index", embedded: false, exported: true, typ: sliceType$13, tag: ""}, {prop: "Anonymous", name: "Anonymous", embedded: false, exported: true, typ: $Bool, tag: ""}]); - fieldScan.init("reflect", [{prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$11, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: sliceType$13, tag: ""}]); - Value.init("reflect", [{prop: "typ", name: "typ", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "ptr", name: "ptr", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "flag", name: "flag", embedded: true, exported: false, typ: flag, tag: ""}]); - ValueError.init("", [{prop: "Method", name: "Method", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Kind", name: "Kind", embedded: false, exported: true, typ: Kind, tag: ""}]); - MapIter.init("reflect", [{prop: "m", name: "m", embedded: false, exported: false, typ: Value, tag: ""}, {prop: "it", name: "it", embedded: false, exported: false, typ: $UnsafePointer, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - nameOffList = sliceType$1.nil; - typeOffList = sliceType$2.nil; - initialized = false; - uncommonTypeMap = {}; - nameMap = {}; - callHelper = $assertType($internalize($call, $emptyInterface), funcType$1); - selectHelper = $assertType($internalize($select, $emptyInterface), funcType$1); - jsObjectPtr = reflectType($jsObjectPtr); - kindNames = new sliceType$4(["invalid", "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "array", "chan", "func", "interface", "map", "ptr", "slice", "string", "struct", "unsafe.Pointer"]); - uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); - $r = init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["sort"] = (function() { - var $pkg = {}, $init, reflect, lessSwap, IntSlice, sliceType, funcType, funcType$1, Search, SearchInts, Slice, insertionSort, siftDown, heapSort, medianOfThree, swapRange, doPivot, quickSort, Sort, maxDepth, Ints, Stable, stable, symMerge, rotate, insertionSort_func, siftDown_func, heapSort_func, medianOfThree_func, doPivot_func, quickSort_func; - reflect = $packages["reflect"]; - lessSwap = $pkg.lessSwap = $newType(0, $kindStruct, "sort.lessSwap", true, "sort", false, function(Less_, Swap_) { - this.$val = this; - if (arguments.length === 0) { - this.Less = $throwNilPointerError; - this.Swap = $throwNilPointerError; - return; - } - this.Less = Less_; - this.Swap = Swap_; - }); - IntSlice = $pkg.IntSlice = $newType(12, $kindSlice, "sort.IntSlice", true, "sort", true, null); - sliceType = $sliceType($Int); - funcType = $funcType([$Int, $Int], [$Bool], false); - funcType$1 = $funcType([$Int, $Int], [], false); - Search = function(n, f) { - var _r, _tmp, _tmp$1, f, h, i, j, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; f = $f.f; h = $f.h; i = $f.i; j = $f.j; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _tmp = 0; - _tmp$1 = n; - i = _tmp; - j = _tmp$1; - /* while (true) { */ case 1: - /* if (!(i < j)) { break; } */ if(!(i < j)) { $s = 2; continue; } - h = ((((((i + j >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - _r = f(h); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!_r) { */ case 3: - i = h + 1 >> 0; - $s = 5; continue; - /* } else { */ case 4: - j = h; - /* } */ case 5: - /* } */ $s = 1; continue; case 2: - $s = -1; return i; - /* */ } return; } if ($f === undefined) { $f = { $blk: Search }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.f = f; $f.h = h; $f.i = i; $f.j = j; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Search = Search; - SearchInts = function(a, x) { - var _r, a, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - x = [x]; - _r = Search(a[0].$length, (function(a, x) { return function(i) { - var i; - return ((i < 0 || i >= a[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : a[0].$array[a[0].$offset + i]) >= x[0]; - }; })(a, x)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: SearchInts }; } $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.SearchInts = SearchInts; - IntSlice.prototype.Search = function(x) { - var _r, p, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _r = SearchInts($subslice(new sliceType(p.$array), p.$offset, p.$offset + p.$length), x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: IntSlice.prototype.Search }; } $f._r = _r; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(IntSlice).prototype.Search = function(x) { return this.$get().Search(x); }; - Slice = function(slice, less) { - var _r, _r$1, length, less, rv, slice, swap, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; length = $f.length; less = $f.less; rv = $f.rv; slice = $f.slice; swap = $f.swap; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = reflect.ValueOf(slice); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - rv = _r; - _r$1 = reflect.Swapper(slice); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - swap = _r$1; - length = $clone(rv, reflect.Value).Len(); - $r = quickSort_func(new lessSwap.ptr(less, swap), 0, length, maxDepth(length)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Slice }; } $f._r = _r; $f._r$1 = _r$1; $f.length = length; $f.less = less; $f.rv = rv; $f.slice = slice; $f.swap = swap; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Slice = Slice; - insertionSort = function(data, a, b) { - var _r, _v, a, b, data, i, j, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _v = $f._v; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = a + 1 >> 0; - /* while (true) { */ case 1: - /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 2; continue; } - j = i; - /* while (true) { */ case 3: - if (!(j > a)) { _v = false; $s = 5; continue s; } - _r = data.Less(j, j - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 5: - /* if (!(_v)) { break; } */ if(!(_v)) { $s = 4; continue; } - $r = data.Swap(j, j - 1 >> 0); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - j = j - (1) >> 0; - /* } */ $s = 3; continue; case 4: - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: insertionSort }; } $f._r = _r; $f._v = _v; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f; - }; - siftDown = function(data, lo, hi, first) { - var _r, _r$1, _v, child, data, first, hi, lo, root, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; child = $f.child; data = $f.data; first = $f.first; hi = $f.hi; lo = $f.lo; root = $f.root; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - root = lo; - /* while (true) { */ case 1: - child = ($imul(2, root)) + 1 >> 0; - if (child >= hi) { - /* break; */ $s = 2; continue; - } - if (!((child + 1 >> 0) < hi)) { _v = false; $s = 5; continue s; } - _r = data.Less(first + child >> 0, (first + child >> 0) + 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 5: - /* */ if (_v) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_v) { */ case 3: - child = child + (1) >> 0; - /* } */ case 4: - _r$1 = data.Less(first + root >> 0, first + child >> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!_r$1) { */ case 7: - $s = -1; return; - /* } */ case 8: - $r = data.Swap(first + root >> 0, first + child >> 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - root = child; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: siftDown }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.child = child; $f.data = data; $f.first = first; $f.hi = hi; $f.lo = lo; $f.root = root; $f.$s = $s; $f.$r = $r; return $f; - }; - heapSort = function(data, a, b) { - var _q, a, b, data, first, hi, i, i$1, lo, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; a = $f.a; b = $f.b; data = $f.data; first = $f.first; hi = $f.hi; i = $f.i; i$1 = $f.i$1; lo = $f.lo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - first = a; - lo = 0; - hi = b - a >> 0; - i = (_q = ((hi - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - /* while (true) { */ case 1: - /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 2; continue; } - $r = siftDown(data, i, hi, first); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i - (1) >> 0; - /* } */ $s = 1; continue; case 2: - i$1 = hi - 1 >> 0; - /* while (true) { */ case 4: - /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 5; continue; } - $r = data.Swap(first, first + i$1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = siftDown(data, lo, i$1, first); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$1 = i$1 - (1) >> 0; - /* } */ $s = 4; continue; case 5: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: heapSort }; } $f._q = _q; $f.a = a; $f.b = b; $f.data = data; $f.first = first; $f.hi = hi; $f.i = i; $f.i$1 = i$1; $f.lo = lo; $f.$s = $s; $f.$r = $r; return $f; - }; - medianOfThree = function(data, m1, m0, m2) { - var _r, _r$1, _r$2, data, m0, m1, m2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; data = $f.data; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = data.Less(m1, m0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r) { */ case 1: - $r = data.Swap(m1, m0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _r$1 = data.Less(m2, m1); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_r$1) { */ case 5: - $r = data.Swap(m2, m1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$2 = data.Less(m1, m0); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - /* */ if (_r$2) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (_r$2) { */ case 9: - $r = data.Swap(m1, m0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 10: - /* } */ case 6: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: medianOfThree }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.data = data; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.$s = $s; $f.$r = $r; return $f; - }; - swapRange = function(data, a, b, n) { - var a, b, data, i, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; b = $f.b; data = $f.data; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = 0; - /* while (true) { */ case 1: - /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } - $r = data.Swap(a + i >> 0, b + i >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: swapRange }; } $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - doPivot = function(data, lo, hi) { - var _q, _q$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$2, _tmp$3, _v, _v$1, _v$2, _v$3, _v$4, a, b, c, data, dups, hi, lo, m, midhi, midlo, pivot, protect, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; a = $f.a; b = $f.b; c = $f.c; data = $f.data; dups = $f.dups; hi = $f.hi; lo = $f.lo; m = $f.m; midhi = $f.midhi; midlo = $f.midlo; pivot = $f.pivot; protect = $f.protect; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - midlo = 0; - midhi = 0; - m = ((((((lo + hi >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((hi - lo >> 0) > 40) { */ case 1: - s = (_q = ((hi - lo >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - $r = medianOfThree(data, lo, lo + s >> 0, lo + ($imul(2, s)) >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = medianOfThree(data, m, m - s >> 0, m + s >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = medianOfThree(data, hi - 1 >> 0, (hi - 1 >> 0) - s >> 0, (hi - 1 >> 0) - ($imul(2, s)) >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $r = medianOfThree(data, lo, m, hi - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - pivot = lo; - _tmp = lo + 1 >> 0; - _tmp$1 = hi - 1 >> 0; - a = _tmp; - c = _tmp$1; - /* while (true) { */ case 7: - if (!(a < c)) { _v = false; $s = 9; continue s; } - _r = data.Less(a, pivot); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 9: - /* if (!(_v)) { break; } */ if(!(_v)) { $s = 8; continue; } - a = a + (1) >> 0; - /* } */ $s = 7; continue; case 8: - b = a; - /* while (true) { */ case 11: - /* while (true) { */ case 13: - if (!(b < c)) { _v$1 = false; $s = 15; continue s; } - _r$1 = data.Less(pivot, b); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v$1 = !_r$1; case 15: - /* if (!(_v$1)) { break; } */ if(!(_v$1)) { $s = 14; continue; } - b = b + (1) >> 0; - /* } */ $s = 13; continue; case 14: - /* while (true) { */ case 17: - if (!(b < c)) { _v$2 = false; $s = 19; continue s; } - _r$2 = data.Less(pivot, c - 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v$2 = _r$2; case 19: - /* if (!(_v$2)) { break; } */ if(!(_v$2)) { $s = 18; continue; } - c = c - (1) >> 0; - /* } */ $s = 17; continue; case 18: - if (b >= c) { - /* break; */ $s = 12; continue; - } - $r = data.Swap(b, c - 1 >> 0); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = b + (1) >> 0; - c = c - (1) >> 0; - /* } */ $s = 11; continue; case 12: - protect = (hi - c >> 0) < 5; - /* */ if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { */ case 22: - dups = 0; - _r$3 = data.Less(pivot, hi - 1 >> 0); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (!_r$3) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (!_r$3) { */ case 24: - $r = data.Swap(c, hi - 1 >> 0); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - c = c + (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 25: - _r$4 = data.Less(b - 1 >> 0, pivot); /* */ $s = 30; case 30: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (!_r$4) { $s = 28; continue; } - /* */ $s = 29; continue; - /* if (!_r$4) { */ case 28: - b = b - (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 29: - _r$5 = data.Less(m, pivot); /* */ $s = 33; case 33: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (!_r$5) { $s = 31; continue; } - /* */ $s = 32; continue; - /* if (!_r$5) { */ case 31: - $r = data.Swap(m, b - 1 >> 0); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = b - (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 32: - protect = dups > 1; - /* } */ case 23: - /* */ if (protect) { $s = 35; continue; } - /* */ $s = 36; continue; - /* if (protect) { */ case 35: - /* while (true) { */ case 37: - /* while (true) { */ case 39: - if (!(a < b)) { _v$3 = false; $s = 41; continue s; } - _r$6 = data.Less(b - 1 >> 0, pivot); /* */ $s = 42; case 42: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _v$3 = !_r$6; case 41: - /* if (!(_v$3)) { break; } */ if(!(_v$3)) { $s = 40; continue; } - b = b - (1) >> 0; - /* } */ $s = 39; continue; case 40: - /* while (true) { */ case 43: - if (!(a < b)) { _v$4 = false; $s = 45; continue s; } - _r$7 = data.Less(a, pivot); /* */ $s = 46; case 46: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _v$4 = _r$7; case 45: - /* if (!(_v$4)) { break; } */ if(!(_v$4)) { $s = 44; continue; } - a = a + (1) >> 0; - /* } */ $s = 43; continue; case 44: - if (a >= b) { - /* break; */ $s = 38; continue; - } - $r = data.Swap(a, b - 1 >> 0); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = a + (1) >> 0; - b = b - (1) >> 0; - /* } */ $s = 37; continue; case 38: - /* } */ case 36: - $r = data.Swap(pivot, b - 1 >> 0); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _tmp$2 = b - 1 >> 0; - _tmp$3 = c; - midlo = _tmp$2; - midhi = _tmp$3; - $s = -1; return [midlo, midhi]; - /* */ } return; } if ($f === undefined) { $f = { $blk: doPivot }; } $f._q = _q; $f._q$1 = _q$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.dups = dups; $f.hi = hi; $f.lo = lo; $f.m = m; $f.midhi = midhi; $f.midlo = midlo; $f.pivot = pivot; $f.protect = protect; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - quickSort = function(data, a, b, maxDepth$1) { - var _r, _r$1, _tuple, a, b, data, i, maxDepth$1, mhi, mlo, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; i = $f.i; maxDepth$1 = $f.maxDepth$1; mhi = $f.mhi; mlo = $f.mlo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* while (true) { */ case 1: - /* if (!((b - a >> 0) > 12)) { break; } */ if(!((b - a >> 0) > 12)) { $s = 2; continue; } - /* */ if (maxDepth$1 === 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (maxDepth$1 === 0) { */ case 3: - $r = heapSort(data, a, b); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 4: - maxDepth$1 = maxDepth$1 - (1) >> 0; - _r = doPivot(data, a, b); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - mlo = _tuple[0]; - mhi = _tuple[1]; - /* */ if ((mlo - a >> 0) < (b - mhi >> 0)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if ((mlo - a >> 0) < (b - mhi >> 0)) { */ case 7: - $r = quickSort(data, a, mlo, maxDepth$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = mhi; - $s = 9; continue; - /* } else { */ case 8: - $r = quickSort(data, mhi, b, maxDepth$1); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = mlo; - /* } */ case 9: - /* } */ $s = 1; continue; case 2: - /* */ if ((b - a >> 0) > 1) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((b - a >> 0) > 1) { */ case 12: - i = a + 6 >> 0; - /* while (true) { */ case 14: - /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 15; continue; } - _r$1 = data.Less(i, i - 6 >> 0); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (_r$1) { */ case 16: - $r = data.Swap(i, i - 6 >> 0); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 17: - i = i + (1) >> 0; - /* } */ $s = 14; continue; case 15: - $r = insertionSort(data, a, b); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 13: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: quickSort }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.maxDepth$1 = maxDepth$1; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f; - }; - Sort = function(data) { - var _r, data, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; data = $f.data; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - n = _r; - $r = quickSort(data, 0, n, maxDepth(n)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f._r = _r; $f.data = data; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sort = Sort; - maxDepth = function(n) { - var depth, i, n; - depth = 0; - i = n; - while (true) { - if (!(i > 0)) { break; } - depth = depth + (1) >> 0; - i = (i >> $min((1), 31)) >> 0; - } - return $imul(depth, 2); - }; - IntSlice.prototype.Len = function() { - var p; - p = this; - return p.$length; - }; - $ptrType(IntSlice).prototype.Len = function() { return this.$get().Len(); }; - IntSlice.prototype.Less = function(i, j) { - var i, j, p; - p = this; - return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); - }; - $ptrType(IntSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; - IntSlice.prototype.Swap = function(i, j) { - var _tmp, _tmp$1, i, j, p; - p = this; - _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); - _tmp$1 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); - ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); - ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$1); - }; - $ptrType(IntSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; - IntSlice.prototype.Sort = function() { - var p, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - $r = Sort(p); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: IntSlice.prototype.Sort }; } $f.p = p; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(IntSlice).prototype.Sort = function() { return this.$get().Sort(); }; - Ints = function(a) { - var a, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = Sort(($subslice(new IntSlice(a.$array), a.$offset, a.$offset + a.$length))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Ints }; } $f.a = a; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Ints = Ints; - Stable = function(data) { - var _arg, _arg$1, _r, data, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; data = $f.data; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = data; - _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = _r; - $r = stable(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Stable }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.data = data; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Stable = Stable; - stable = function(data, n) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, a, b, blockSize, data, m, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; a = $f.a; b = $f.b; blockSize = $f.blockSize; data = $f.data; m = $f.m; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - blockSize = 20; - _tmp = 0; - _tmp$1 = blockSize; - a = _tmp; - b = _tmp$1; - /* while (true) { */ case 1: - /* if (!(b <= n)) { break; } */ if(!(b <= n)) { $s = 2; continue; } - $r = insertionSort(data, a, b); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = b; - b = b + (blockSize) >> 0; - /* } */ $s = 1; continue; case 2: - $r = insertionSort(data, a, n); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* while (true) { */ case 5: - /* if (!(blockSize < n)) { break; } */ if(!(blockSize < n)) { $s = 6; continue; } - _tmp$2 = 0; - _tmp$3 = $imul(2, blockSize); - a = _tmp$2; - b = _tmp$3; - /* while (true) { */ case 7: - /* if (!(b <= n)) { break; } */ if(!(b <= n)) { $s = 8; continue; } - $r = symMerge(data, a, a + blockSize >> 0, b); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = b; - b = b + (($imul(2, blockSize))) >> 0; - /* } */ $s = 7; continue; case 8: - m = a + blockSize >> 0; - /* */ if (m < n) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (m < n) { */ case 10: - $r = symMerge(data, a, m, n); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 11: - blockSize = $imul(blockSize, (2)); - /* } */ $s = 5; continue; case 6: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: stable }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.a = a; $f.b = b; $f.blockSize = blockSize; $f.data = data; $f.m = m; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - symMerge = function(data, a, m, b) { - var _r, _r$1, _r$2, _tmp, _tmp$1, a, b, c, data, end, h, h$1, i, i$1, j, j$1, k, k$1, m, mid, n, p, r, start, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; c = $f.c; data = $f.data; end = $f.end; h = $f.h; h$1 = $f.h$1; i = $f.i; i$1 = $f.i$1; j = $f.j; j$1 = $f.j$1; k = $f.k; k$1 = $f.k$1; m = $f.m; mid = $f.mid; n = $f.n; p = $f.p; r = $f.r; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if ((m - a >> 0) === 1) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((m - a >> 0) === 1) { */ case 1: - i = m; - j = b; - /* while (true) { */ case 3: - /* if (!(i < j)) { break; } */ if(!(i < j)) { $s = 4; continue; } - h = ((((((i + j >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - _r = data.Less(h, a); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_r) { */ case 5: - i = h + 1 >> 0; - $s = 7; continue; - /* } else { */ case 6: - j = h; - /* } */ case 7: - /* } */ $s = 3; continue; case 4: - k = a; - /* while (true) { */ case 9: - /* if (!(k < (i - 1 >> 0))) { break; } */ if(!(k < (i - 1 >> 0))) { $s = 10; continue; } - $r = data.Swap(k, k + 1 >> 0); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - k = k + (1) >> 0; - /* } */ $s = 9; continue; case 10: - $s = -1; return; - /* } */ case 2: - /* */ if ((b - m >> 0) === 1) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((b - m >> 0) === 1) { */ case 12: - i$1 = a; - j$1 = m; - /* while (true) { */ case 14: - /* if (!(i$1 < j$1)) { break; } */ if(!(i$1 < j$1)) { $s = 15; continue; } - h$1 = ((((((i$1 + j$1 >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - _r$1 = data.Less(m, h$1); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (!_r$1) { */ case 16: - i$1 = h$1 + 1 >> 0; - $s = 18; continue; - /* } else { */ case 17: - j$1 = h$1; - /* } */ case 18: - /* } */ $s = 14; continue; case 15: - k$1 = m; - /* while (true) { */ case 20: - /* if (!(k$1 > i$1)) { break; } */ if(!(k$1 > i$1)) { $s = 21; continue; } - $r = data.Swap(k$1, k$1 - 1 >> 0); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - k$1 = k$1 - (1) >> 0; - /* } */ $s = 20; continue; case 21: - $s = -1; return; - /* } */ case 13: - mid = ((((((a + b >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - n = mid + m >> 0; - _tmp = 0; - _tmp$1 = 0; - start = _tmp; - r = _tmp$1; - if (m > mid) { - start = n - b >> 0; - r = mid; - } else { - start = a; - r = m; - } - p = n - 1 >> 0; - /* while (true) { */ case 23: - /* if (!(start < r)) { break; } */ if(!(start < r)) { $s = 24; continue; } - c = ((((((start + r >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - _r$2 = data.Less(p - c >> 0, c); /* */ $s = 28; case 28: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - /* */ if (!_r$2) { $s = 25; continue; } - /* */ $s = 26; continue; - /* if (!_r$2) { */ case 25: - start = c + 1 >> 0; - $s = 27; continue; - /* } else { */ case 26: - r = c; - /* } */ case 27: - /* } */ $s = 23; continue; case 24: - end = n - start >> 0; - /* */ if (start < m && m < end) { $s = 29; continue; } - /* */ $s = 30; continue; - /* if (start < m && m < end) { */ case 29: - $r = rotate(data, start, m, end); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 30: - /* */ if (a < start && start < mid) { $s = 32; continue; } - /* */ $s = 33; continue; - /* if (a < start && start < mid) { */ case 32: - $r = symMerge(data, a, start, mid); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 33: - /* */ if (mid < end && end < b) { $s = 35; continue; } - /* */ $s = 36; continue; - /* if (mid < end && end < b) { */ case 35: - $r = symMerge(data, mid, end, b); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 36: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: symMerge }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.end = end; $f.h = h; $f.h$1 = h$1; $f.i = i; $f.i$1 = i$1; $f.j = j; $f.j$1 = j$1; $f.k = k; $f.k$1 = k$1; $f.m = m; $f.mid = mid; $f.n = n; $f.p = p; $f.r = r; $f.start = start; $f.$s = $s; $f.$r = $r; return $f; - }; - rotate = function(data, a, m, b) { - var a, b, data, i, j, m, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = m - a >> 0; - j = b - m >> 0; - /* while (true) { */ case 1: - /* if (!(!((i === j)))) { break; } */ if(!(!((i === j)))) { $s = 2; continue; } - /* */ if (i > j) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (i > j) { */ case 3: - $r = swapRange(data, m - i >> 0, m, j); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i - (j) >> 0; - $s = 5; continue; - /* } else { */ case 4: - $r = swapRange(data, m - i >> 0, (m + j >> 0) - i >> 0, i); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - j = j - (i) >> 0; - /* } */ case 5: - /* } */ $s = 1; continue; case 2: - $r = swapRange(data, m - i >> 0, m, i); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: rotate }; } $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.m = m; $f.$s = $s; $f.$r = $r; return $f; - }; - insertionSort_func = function(data, a, b) { - var _r, _v, a, b, data, i, j, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _v = $f._v; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = a + 1 >> 0; - /* while (true) { */ case 1: - /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 2; continue; } - j = i; - /* while (true) { */ case 3: - if (!(j > a)) { _v = false; $s = 5; continue s; } - _r = data.Less(j, j - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 5: - /* if (!(_v)) { break; } */ if(!(_v)) { $s = 4; continue; } - $r = data.Swap(j, j - 1 >> 0); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - j = j - (1) >> 0; - /* } */ $s = 3; continue; case 4: - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: insertionSort_func }; } $f._r = _r; $f._v = _v; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f; - }; - siftDown_func = function(data, lo, hi, first) { - var _r, _r$1, _v, child, data, first, hi, lo, root, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; child = $f.child; data = $f.data; first = $f.first; hi = $f.hi; lo = $f.lo; root = $f.root; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - root = lo; - /* while (true) { */ case 1: - child = ($imul(2, root)) + 1 >> 0; - if (child >= hi) { - /* break; */ $s = 2; continue; - } - if (!((child + 1 >> 0) < hi)) { _v = false; $s = 5; continue s; } - _r = data.Less(first + child >> 0, (first + child >> 0) + 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 5: - /* */ if (_v) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_v) { */ case 3: - child = child + (1) >> 0; - /* } */ case 4: - _r$1 = data.Less(first + root >> 0, first + child >> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!_r$1) { */ case 7: - $s = -1; return; - /* } */ case 8: - $r = data.Swap(first + root >> 0, first + child >> 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - root = child; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: siftDown_func }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.child = child; $f.data = data; $f.first = first; $f.hi = hi; $f.lo = lo; $f.root = root; $f.$s = $s; $f.$r = $r; return $f; - }; - heapSort_func = function(data, a, b) { - var _q, a, b, data, first, hi, i, i$1, lo, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; a = $f.a; b = $f.b; data = $f.data; first = $f.first; hi = $f.hi; i = $f.i; i$1 = $f.i$1; lo = $f.lo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - first = a; - lo = 0; - hi = b - a >> 0; - i = (_q = ((hi - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - /* while (true) { */ case 1: - /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 2; continue; } - $r = siftDown_func($clone(data, lessSwap), i, hi, first); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i - (1) >> 0; - /* } */ $s = 1; continue; case 2: - i$1 = hi - 1 >> 0; - /* while (true) { */ case 4: - /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 5; continue; } - $r = data.Swap(first, first + i$1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = siftDown_func($clone(data, lessSwap), lo, i$1, first); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$1 = i$1 - (1) >> 0; - /* } */ $s = 4; continue; case 5: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: heapSort_func }; } $f._q = _q; $f.a = a; $f.b = b; $f.data = data; $f.first = first; $f.hi = hi; $f.i = i; $f.i$1 = i$1; $f.lo = lo; $f.$s = $s; $f.$r = $r; return $f; - }; - medianOfThree_func = function(data, m1, m0, m2) { - var _r, _r$1, _r$2, data, m0, m1, m2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; data = $f.data; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = data.Less(m1, m0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r) { */ case 1: - $r = data.Swap(m1, m0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _r$1 = data.Less(m2, m1); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_r$1) { */ case 5: - $r = data.Swap(m2, m1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$2 = data.Less(m1, m0); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - /* */ if (_r$2) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (_r$2) { */ case 9: - $r = data.Swap(m1, m0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 10: - /* } */ case 6: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: medianOfThree_func }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.data = data; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.$s = $s; $f.$r = $r; return $f; - }; - doPivot_func = function(data, lo, hi) { - var _q, _q$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$2, _tmp$3, _v, _v$1, _v$2, _v$3, _v$4, a, b, c, data, dups, hi, lo, m, midhi, midlo, pivot, protect, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; a = $f.a; b = $f.b; c = $f.c; data = $f.data; dups = $f.dups; hi = $f.hi; lo = $f.lo; m = $f.m; midhi = $f.midhi; midlo = $f.midlo; pivot = $f.pivot; protect = $f.protect; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - midlo = 0; - midhi = 0; - m = ((((((lo + hi >> 0) >>> 0)) >>> 1 >>> 0) >> 0)); - /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((hi - lo >> 0) > 40) { */ case 1: - s = (_q = ((hi - lo >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - $r = medianOfThree_func($clone(data, lessSwap), lo, lo + s >> 0, lo + ($imul(2, s)) >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = medianOfThree_func($clone(data, lessSwap), m, m - s >> 0, m + s >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = medianOfThree_func($clone(data, lessSwap), hi - 1 >> 0, (hi - 1 >> 0) - s >> 0, (hi - 1 >> 0) - ($imul(2, s)) >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $r = medianOfThree_func($clone(data, lessSwap), lo, m, hi - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - pivot = lo; - _tmp = lo + 1 >> 0; - _tmp$1 = hi - 1 >> 0; - a = _tmp; - c = _tmp$1; - /* while (true) { */ case 7: - if (!(a < c)) { _v = false; $s = 9; continue s; } - _r = data.Less(a, pivot); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 9: - /* if (!(_v)) { break; } */ if(!(_v)) { $s = 8; continue; } - a = a + (1) >> 0; - /* } */ $s = 7; continue; case 8: - b = a; - /* while (true) { */ case 11: - /* while (true) { */ case 13: - if (!(b < c)) { _v$1 = false; $s = 15; continue s; } - _r$1 = data.Less(pivot, b); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v$1 = !_r$1; case 15: - /* if (!(_v$1)) { break; } */ if(!(_v$1)) { $s = 14; continue; } - b = b + (1) >> 0; - /* } */ $s = 13; continue; case 14: - /* while (true) { */ case 17: - if (!(b < c)) { _v$2 = false; $s = 19; continue s; } - _r$2 = data.Less(pivot, c - 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _v$2 = _r$2; case 19: - /* if (!(_v$2)) { break; } */ if(!(_v$2)) { $s = 18; continue; } - c = c - (1) >> 0; - /* } */ $s = 17; continue; case 18: - if (b >= c) { - /* break; */ $s = 12; continue; - } - $r = data.Swap(b, c - 1 >> 0); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = b + (1) >> 0; - c = c - (1) >> 0; - /* } */ $s = 11; continue; case 12: - protect = (hi - c >> 0) < 5; - /* */ if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (!protect && (hi - c >> 0) < (_q$1 = ((hi - lo >> 0)) / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))) { */ case 22: - dups = 0; - _r$3 = data.Less(pivot, hi - 1 >> 0); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (!_r$3) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (!_r$3) { */ case 24: - $r = data.Swap(c, hi - 1 >> 0); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - c = c + (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 25: - _r$4 = data.Less(b - 1 >> 0, pivot); /* */ $s = 30; case 30: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (!_r$4) { $s = 28; continue; } - /* */ $s = 29; continue; - /* if (!_r$4) { */ case 28: - b = b - (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 29: - _r$5 = data.Less(m, pivot); /* */ $s = 33; case 33: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (!_r$5) { $s = 31; continue; } - /* */ $s = 32; continue; - /* if (!_r$5) { */ case 31: - $r = data.Swap(m, b - 1 >> 0); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = b - (1) >> 0; - dups = dups + (1) >> 0; - /* } */ case 32: - protect = dups > 1; - /* } */ case 23: - /* */ if (protect) { $s = 35; continue; } - /* */ $s = 36; continue; - /* if (protect) { */ case 35: - /* while (true) { */ case 37: - /* while (true) { */ case 39: - if (!(a < b)) { _v$3 = false; $s = 41; continue s; } - _r$6 = data.Less(b - 1 >> 0, pivot); /* */ $s = 42; case 42: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _v$3 = !_r$6; case 41: - /* if (!(_v$3)) { break; } */ if(!(_v$3)) { $s = 40; continue; } - b = b - (1) >> 0; - /* } */ $s = 39; continue; case 40: - /* while (true) { */ case 43: - if (!(a < b)) { _v$4 = false; $s = 45; continue s; } - _r$7 = data.Less(a, pivot); /* */ $s = 46; case 46: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _v$4 = _r$7; case 45: - /* if (!(_v$4)) { break; } */ if(!(_v$4)) { $s = 44; continue; } - a = a + (1) >> 0; - /* } */ $s = 43; continue; case 44: - if (a >= b) { - /* break; */ $s = 38; continue; - } - $r = data.Swap(a, b - 1 >> 0); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = a + (1) >> 0; - b = b - (1) >> 0; - /* } */ $s = 37; continue; case 38: - /* } */ case 36: - $r = data.Swap(pivot, b - 1 >> 0); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _tmp$2 = b - 1 >> 0; - _tmp$3 = c; - midlo = _tmp$2; - midhi = _tmp$3; - $s = -1; return [midlo, midhi]; - /* */ } return; } if ($f === undefined) { $f = { $blk: doPivot_func }; } $f._q = _q; $f._q$1 = _q$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.dups = dups; $f.hi = hi; $f.lo = lo; $f.m = m; $f.midhi = midhi; $f.midlo = midlo; $f.pivot = pivot; $f.protect = protect; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - quickSort_func = function(data, a, b, maxDepth$1) { - var _r, _r$1, _tuple, a, b, data, i, maxDepth$1, mhi, mlo, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; i = $f.i; maxDepth$1 = $f.maxDepth$1; mhi = $f.mhi; mlo = $f.mlo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* while (true) { */ case 1: - /* if (!((b - a >> 0) > 12)) { break; } */ if(!((b - a >> 0) > 12)) { $s = 2; continue; } - /* */ if (maxDepth$1 === 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (maxDepth$1 === 0) { */ case 3: - $r = heapSort_func($clone(data, lessSwap), a, b); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 4: - maxDepth$1 = maxDepth$1 - (1) >> 0; - _r = doPivot_func($clone(data, lessSwap), a, b); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - mlo = _tuple[0]; - mhi = _tuple[1]; - /* */ if ((mlo - a >> 0) < (b - mhi >> 0)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if ((mlo - a >> 0) < (b - mhi >> 0)) { */ case 7: - $r = quickSort_func($clone(data, lessSwap), a, mlo, maxDepth$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - a = mhi; - $s = 9; continue; - /* } else { */ case 8: - $r = quickSort_func($clone(data, lessSwap), mhi, b, maxDepth$1); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - b = mlo; - /* } */ case 9: - /* } */ $s = 1; continue; case 2: - /* */ if ((b - a >> 0) > 1) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((b - a >> 0) > 1) { */ case 12: - i = a + 6 >> 0; - /* while (true) { */ case 14: - /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 15; continue; } - _r$1 = data.Less(i, i - 6 >> 0); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (_r$1) { */ case 16: - $r = data.Swap(i, i - 6 >> 0); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 17: - i = i + (1) >> 0; - /* } */ $s = 14; continue; case 15: - $r = insertionSort_func($clone(data, lessSwap), a, b); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 13: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: quickSort_func }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.maxDepth$1 = maxDepth$1; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f; - }; - IntSlice.methods = [{prop: "Search", name: "Search", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Sort", name: "Sort", pkg: "", typ: $funcType([], [], false)}]; - lessSwap.init("", [{prop: "Less", name: "Less", embedded: false, exported: true, typ: funcType, tag: ""}, {prop: "Swap", name: "Swap", embedded: false, exported: true, typ: funcType$1, tag: ""}]); - IntSlice.init($Int); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = reflect.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/fmtsort"] = (function() { - var $pkg = {}, $init, reflect, sort, SortedMap, ptrType, sliceType, Sort, compare, nilCompare, floatCompare, isNaN; - reflect = $packages["reflect"]; - sort = $packages["sort"]; - SortedMap = $pkg.SortedMap = $newType(0, $kindStruct, "fmtsort.SortedMap", true, "internal/fmtsort", true, function(Key_, Value_) { - this.$val = this; - if (arguments.length === 0) { - this.Key = sliceType.nil; - this.Value = sliceType.nil; - return; - } - this.Key = Key_; - this.Value = Value_; - }); - ptrType = $ptrType(SortedMap); - sliceType = $sliceType(reflect.Value); - SortedMap.ptr.prototype.Len = function() { - var o; - o = this; - return o.Key.$length; - }; - SortedMap.prototype.Len = function() { return this.$val.Len(); }; - SortedMap.ptr.prototype.Less = function(i, j) { - var _r, i, j, o, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; j = $f.j; o = $f.o; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - o = this; - _r = compare($clone((x = o.Key, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])), reflect.Value), $clone((x$1 = o.Key, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])), reflect.Value)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r < 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: SortedMap.ptr.prototype.Less }; } $f._r = _r; $f.i = i; $f.j = j; $f.o = o; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - SortedMap.prototype.Less = function(i, j) { return this.$val.Less(i, j); }; - SortedMap.ptr.prototype.Swap = function(i, j) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, i, j, o, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; - o = this; - _tmp = (x = o.Key, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); - _tmp$1 = (x$1 = o.Key, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); - (x$2 = o.Key, ((i < 0 || i >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i] = _tmp)); - (x$3 = o.Key, ((j < 0 || j >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + j] = _tmp$1)); - _tmp$2 = (x$4 = o.Value, ((j < 0 || j >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + j])); - _tmp$3 = (x$5 = o.Value, ((i < 0 || i >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + i])); - (x$6 = o.Value, ((i < 0 || i >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i] = _tmp$2)); - (x$7 = o.Value, ((j < 0 || j >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + j] = _tmp$3)); - }; - SortedMap.prototype.Swap = function(i, j) { return this.$val.Swap(i, j); }; - Sort = function(mapValue) { - var _r, _r$1, _r$2, _r$3, i, iter, key, mapValue, sorted, value, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; iter = $f.iter; key = $f.key; mapValue = $f.mapValue; sorted = $f.sorted; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $clone(mapValue, reflect.Value).Type().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!((_r === 21))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!((_r === 21))) { */ case 1: - $s = -1; return ptrType.nil; - /* } */ case 2: - key = $makeSlice(sliceType, $clone(mapValue, reflect.Value).Len()); - value = $makeSlice(sliceType, key.$length); - iter = $clone(mapValue, reflect.Value).MapRange(); - i = 0; - /* while (true) { */ case 4: - _r$1 = iter.Next(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* if (!(_r$1)) { break; } */ if(!(_r$1)) { $s = 5; continue; } - _r$2 = iter.Key(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - ((i < 0 || i >= key.$length) ? ($throwRuntimeError("index out of range"), undefined) : key.$array[key.$offset + i] = _r$2); - _r$3 = iter.Value(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - ((i < 0 || i >= value.$length) ? ($throwRuntimeError("index out of range"), undefined) : value.$array[value.$offset + i] = _r$3); - i = i + (1) >> 0; - /* } */ $s = 4; continue; case 5: - sorted = new SortedMap.ptr(key, value); - $r = sort.Stable(sorted); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return sorted; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.iter = iter; $f.key = key; $f.mapValue = mapValue; $f.sorted = sorted; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sort = Sort; - compare = function(aVal, bVal) { - var _1, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, a, a$1, a$2, a$3, a$4, a$5, aType, aVal, ap, b, b$1, b$2, b$3, b$4, b$5, bType, bVal, bp, c, c$1, c$2, c$3, c$4, c$5, i, i$1, ok, ok$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; a$1 = $f.a$1; a$2 = $f.a$2; a$3 = $f.a$3; a$4 = $f.a$4; a$5 = $f.a$5; aType = $f.aType; aVal = $f.aVal; ap = $f.ap; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; b$3 = $f.b$3; b$4 = $f.b$4; b$5 = $f.b$5; bType = $f.bType; bVal = $f.bVal; bp = $f.bp; c = $f.c; c$1 = $f.c$1; c$2 = $f.c$2; c$3 = $f.c$3; c$4 = $f.c$4; c$5 = $f.c$5; i = $f.i; i$1 = $f.i$1; ok = $f.ok; ok$1 = $f.ok$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _tmp = $clone(aVal, reflect.Value).Type(); - _tmp$1 = $clone(bVal, reflect.Value).Type(); - aType = _tmp; - bType = _tmp$1; - if (!($interfaceIsEqual(aType, bType))) { - $s = -1; return -1; - } - _1 = $clone(aVal, reflect.Value).Kind(); - /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 2; continue; } - /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 3; continue; } - /* */ if (_1 === (24)) { $s = 4; continue; } - /* */ if ((_1 === (13)) || (_1 === (14))) { $s = 5; continue; } - /* */ if ((_1 === (15)) || (_1 === (16))) { $s = 6; continue; } - /* */ if (_1 === (1)) { $s = 7; continue; } - /* */ if (_1 === (22)) { $s = 8; continue; } - /* */ if (_1 === (18)) { $s = 9; continue; } - /* */ if (_1 === (25)) { $s = 10; continue; } - /* */ if (_1 === (17)) { $s = 11; continue; } - /* */ if (_1 === (20)) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 2: - _tmp$2 = $clone(aVal, reflect.Value).Int(); - _tmp$3 = $clone(bVal, reflect.Value).Int(); - a = _tmp$2; - b = _tmp$3; - if ((a.$high < b.$high || (a.$high === b.$high && a.$low < b.$low))) { - $s = -1; return -1; - } else if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { - $s = -1; return 1; - } else { - $s = -1; return 0; - } - $s = 14; continue; - /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 3: - _tmp$4 = $clone(aVal, reflect.Value).Uint(); - _tmp$5 = $clone(bVal, reflect.Value).Uint(); - a$1 = _tmp$4; - b$1 = _tmp$5; - if ((a$1.$high < b$1.$high || (a$1.$high === b$1.$high && a$1.$low < b$1.$low))) { - $s = -1; return -1; - } else if ((a$1.$high > b$1.$high || (a$1.$high === b$1.$high && a$1.$low > b$1.$low))) { - $s = -1; return 1; - } else { - $s = -1; return 0; - } - $s = 14; continue; - /* } else if (_1 === (24)) { */ case 4: - _r = $clone(aVal, reflect.Value).String(); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tmp$6 = _r; - _r$1 = $clone(bVal, reflect.Value).String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tmp$7 = _r$1; - a$2 = _tmp$6; - b$2 = _tmp$7; - if (a$2 < b$2) { - $s = -1; return -1; - } else if (a$2 > b$2) { - $s = -1; return 1; - } else { - $s = -1; return 0; - } - $s = 14; continue; - /* } else if ((_1 === (13)) || (_1 === (14))) { */ case 5: - $s = -1; return floatCompare($clone(aVal, reflect.Value).Float(), $clone(bVal, reflect.Value).Float()); - /* } else if ((_1 === (15)) || (_1 === (16))) { */ case 6: - _tmp$8 = $clone(aVal, reflect.Value).Complex(); - _tmp$9 = $clone(bVal, reflect.Value).Complex(); - a$3 = _tmp$8; - b$3 = _tmp$9; - c = floatCompare(a$3.$real, b$3.$real); - if (!((c === 0))) { - $s = -1; return c; - } - $s = -1; return floatCompare(a$3.$imag, b$3.$imag); - /* } else if (_1 === (1)) { */ case 7: - _tmp$10 = $clone(aVal, reflect.Value).Bool(); - _tmp$11 = $clone(bVal, reflect.Value).Bool(); - a$4 = _tmp$10; - b$4 = _tmp$11; - if (a$4 === b$4) { - $s = -1; return 0; - } else if (a$4) { - $s = -1; return 1; - } else { - $s = -1; return -1; - } - $s = 14; continue; - /* } else if (_1 === (22)) { */ case 8: - _tmp$12 = $clone(aVal, reflect.Value).Pointer(); - _tmp$13 = $clone(bVal, reflect.Value).Pointer(); - a$5 = _tmp$12; - b$5 = _tmp$13; - if (a$5 < b$5) { - $s = -1; return -1; - } else if (a$5 > b$5) { - $s = -1; return 1; - } else { - $s = -1; return 0; - } - $s = 14; continue; - /* } else if (_1 === (18)) { */ case 9: - _tuple = nilCompare($clone(aVal, reflect.Value), $clone(bVal, reflect.Value)); - c$1 = _tuple[0]; - ok = _tuple[1]; - if (ok) { - $s = -1; return c$1; - } - _tmp$14 = $clone(aVal, reflect.Value).Pointer(); - _tmp$15 = $clone(bVal, reflect.Value).Pointer(); - ap = _tmp$14; - bp = _tmp$15; - if (ap < bp) { - $s = -1; return -1; - } else if (ap > bp) { - $s = -1; return 1; - } else { - $s = -1; return 0; - } - $s = 14; continue; - /* } else if (_1 === (25)) { */ case 10: - i = 0; - /* while (true) { */ case 17: - /* if (!(i < $clone(aVal, reflect.Value).NumField())) { break; } */ if(!(i < $clone(aVal, reflect.Value).NumField())) { $s = 18; continue; } - _r$2 = $clone(aVal, reflect.Value).Field(i); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _arg = $clone(_r$2, reflect.Value); - _r$3 = $clone(bVal, reflect.Value).Field(i); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _arg$1 = $clone(_r$3, reflect.Value); - _r$4 = compare(_arg, _arg$1); /* */ $s = 21; case 21: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - c$2 = _r$4; - if (!((c$2 === 0))) { - $s = -1; return c$2; - } - i = i + (1) >> 0; - /* } */ $s = 17; continue; case 18: - $s = -1; return 0; - /* } else if (_1 === (17)) { */ case 11: - i$1 = 0; - /* while (true) { */ case 22: - /* if (!(i$1 < $clone(aVal, reflect.Value).Len())) { break; } */ if(!(i$1 < $clone(aVal, reflect.Value).Len())) { $s = 23; continue; } - _r$5 = $clone(aVal, reflect.Value).Index(i$1); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$2 = $clone(_r$5, reflect.Value); - _r$6 = $clone(bVal, reflect.Value).Index(i$1); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _arg$3 = $clone(_r$6, reflect.Value); - _r$7 = compare(_arg$2, _arg$3); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - c$3 = _r$7; - if (!((c$3 === 0))) { - $s = -1; return c$3; - } - i$1 = i$1 + (1) >> 0; - /* } */ $s = 22; continue; case 23: - $s = -1; return 0; - /* } else if (_1 === (20)) { */ case 12: - _tuple$1 = nilCompare($clone(aVal, reflect.Value), $clone(bVal, reflect.Value)); - c$4 = _tuple$1[0]; - ok$1 = _tuple$1[1]; - if (ok$1) { - $s = -1; return c$4; - } - _r$8 = $clone(aVal, reflect.Value).Elem(); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _r$9 = $clone(_r$8, reflect.Value).Type(); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _r$10 = reflect.ValueOf(_r$9); /* */ $s = 29; case 29: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - _arg$4 = $clone(_r$10, reflect.Value); - _r$11 = $clone(bVal, reflect.Value).Elem(); /* */ $s = 30; case 30: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - _r$12 = $clone(_r$11, reflect.Value).Type(); /* */ $s = 31; case 31: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - _r$13 = reflect.ValueOf(_r$12); /* */ $s = 32; case 32: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - _arg$5 = $clone(_r$13, reflect.Value); - _r$14 = compare(_arg$4, _arg$5); /* */ $s = 33; case 33: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } - c$5 = _r$14; - if (!((c$5 === 0))) { - $s = -1; return c$5; - } - _r$15 = $clone(aVal, reflect.Value).Elem(); /* */ $s = 34; case 34: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } - _arg$6 = $clone(_r$15, reflect.Value); - _r$16 = $clone(bVal, reflect.Value).Elem(); /* */ $s = 35; case 35: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } - _arg$7 = $clone(_r$16, reflect.Value); - _r$17 = compare(_arg$6, _arg$7); /* */ $s = 36; case 36: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } - $s = -1; return _r$17; - /* } else { */ case 13: - _r$18 = aType.String(); /* */ $s = 37; case 37: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } - $panic(new $String("bad type in compare: " + _r$18)); - /* } */ case 14: - case 1: - $s = -1; return 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: compare }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.a$1 = a$1; $f.a$2 = a$2; $f.a$3 = a$3; $f.a$4 = a$4; $f.a$5 = a$5; $f.aType = aType; $f.aVal = aVal; $f.ap = ap; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.b$3 = b$3; $f.b$4 = b$4; $f.b$5 = b$5; $f.bType = bType; $f.bVal = bVal; $f.bp = bp; $f.c = c; $f.c$1 = c$1; $f.c$2 = c$2; $f.c$3 = c$3; $f.c$4 = c$4; $f.c$5 = c$5; $f.i = i; $f.i$1 = i$1; $f.ok = ok; $f.ok$1 = ok$1; $f.$s = $s; $f.$r = $r; return $f; - }; - nilCompare = function(aVal, bVal) { - var aVal, bVal; - if ($clone(aVal, reflect.Value).IsNil()) { - if ($clone(bVal, reflect.Value).IsNil()) { - return [0, true]; - } - return [-1, true]; - } - if ($clone(bVal, reflect.Value).IsNil()) { - return [1, true]; - } - return [0, false]; - }; - floatCompare = function(a, b) { - var a, b; - if (isNaN(a)) { - return -1; - } else if (isNaN(b)) { - return 1; - } else if (a < b) { - return -1; - } else if (a > b) { - return 1; - } - return 0; - }; - isNaN = function(a) { - var a; - return !((a === a)); - }; - ptrType.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; - SortedMap.init("", [{prop: "Key", name: "Key", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "Value", name: "Value", embedded: false, exported: true, typ: sliceType, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = reflect.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sort.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["syscall"] = (function() { - var $pkg = {}, $init, js, race, runtime, sync, RawConn, SockaddrLinklayer, SockaddrNetlink, mmapper, Errno, Sockaddr, SockaddrInet4, SockaddrInet6, SockaddrUnix, Timespec, Stat_t, RawSockaddrInet4, RawSockaddrInet6, RawSockaddrUnix, RawSockaddrLinklayer, RawSockaddrNetlink, RawSockaddr, RawSockaddrAny, _Socklen, Linger, Iovec, IPMreq, IPMreqn, IPv6Mreq, Msghdr, sliceType, sliceType$1, ptrType$2, ptrType$4, arrayType$1, ptrType$9, arrayType$2, ptrType$12, arrayType$4, arrayType$5, arrayType$8, arrayType$9, arrayType$10, arrayType$11, ptrType$19, ptrType$20, structType, ptrType$23, funcType, funcType$1, ptrType$25, ptrType$26, mapType, funcType$2, funcType$3, ptrType$27, ptrType$28, ptrType$29, ptrType$30, ptrType$32, warningPrinted, lineBuffer, syscallModule, alreadyTriedToLoad, minusOne, envs, mapper, errEAGAIN, errEINVAL, errENOENT, ioSync, ioSync$24ptr, errors, init, printWarning, printToConsole, Exit, indexByte, runtime_envs, syscallByName, Syscall, Syscall6, BytePtrFromString, readInt, readIntBE, readIntLE, ParseDirent, CloseOnExec, SetNonblock, msanRead, msanWrite, itoa, uitoa, anyToSockaddr, Accept, Accept4, SetsockoptIPMreqn, Recvmsg, SendmsgN, ReadDirent, direntIno, direntReclen, direntNamlen, Lstat, errnoErr, Read, Write, GetsockoptInt, Recvfrom, Sendto, SetsockoptByte, SetsockoptInt, SetsockoptInet4Addr, SetsockoptIPMreq, SetsockoptIPv6Mreq, SetsockoptLinger, Close, Dup, Fchdir, Fchmod, fcntl, Fsync, Getdents, read, write, munmap, Fchown, Fstat, Ftruncate, Pread, Pwrite, Seek, Shutdown, accept, accept4, fstatat, getsockopt, setsockopt, recvfrom, sendto, recvmsg, sendmsg, mmap; - js = $packages["github.com/gopherjs/gopherjs/js"]; - race = $packages["internal/race"]; - runtime = $packages["runtime"]; - sync = $packages["sync"]; - RawConn = $pkg.RawConn = $newType(8, $kindInterface, "syscall.RawConn", true, "syscall", true, null); - SockaddrLinklayer = $pkg.SockaddrLinklayer = $newType(0, $kindStruct, "syscall.SockaddrLinklayer", true, "syscall", true, function(Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_, raw_) { - this.$val = this; - if (arguments.length === 0) { - this.Protocol = 0; - this.Ifindex = 0; - this.Hatype = 0; - this.Pkttype = 0; - this.Halen = 0; - this.Addr = arrayType$1.zero(); - this.raw = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()); - return; - } - this.Protocol = Protocol_; - this.Ifindex = Ifindex_; - this.Hatype = Hatype_; - this.Pkttype = Pkttype_; - this.Halen = Halen_; - this.Addr = Addr_; - this.raw = raw_; - }); - SockaddrNetlink = $pkg.SockaddrNetlink = $newType(0, $kindStruct, "syscall.SockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_, raw_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Pad = 0; - this.Pid = 0; - this.Groups = 0; - this.raw = new RawSockaddrNetlink.ptr(0, 0, 0, 0); - return; - } - this.Family = Family_; - this.Pad = Pad_; - this.Pid = Pid_; - this.Groups = Groups_; - this.raw = raw_; - }); - mmapper = $pkg.mmapper = $newType(0, $kindStruct, "syscall.mmapper", true, "syscall", false, function(Mutex_, active_, mmap_, munmap_) { - this.$val = this; - if (arguments.length === 0) { - this.Mutex = new sync.Mutex.ptr(0, 0); - this.active = false; - this.mmap = $throwNilPointerError; - this.munmap = $throwNilPointerError; - return; - } - this.Mutex = Mutex_; - this.active = active_; - this.mmap = mmap_; - this.munmap = munmap_; - }); - Errno = $pkg.Errno = $newType(4, $kindUintptr, "syscall.Errno", true, "syscall", true, null); - Sockaddr = $pkg.Sockaddr = $newType(8, $kindInterface, "syscall.Sockaddr", true, "syscall", true, null); - SockaddrInet4 = $pkg.SockaddrInet4 = $newType(0, $kindStruct, "syscall.SockaddrInet4", true, "syscall", true, function(Port_, Addr_, raw_) { - this.$val = this; - if (arguments.length === 0) { - this.Port = 0; - this.Addr = arrayType$9.zero(); - this.raw = new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero()); - return; - } - this.Port = Port_; - this.Addr = Addr_; - this.raw = raw_; - }); - SockaddrInet6 = $pkg.SockaddrInet6 = $newType(0, $kindStruct, "syscall.SockaddrInet6", true, "syscall", true, function(Port_, ZoneId_, Addr_, raw_) { - this.$val = this; - if (arguments.length === 0) { - this.Port = 0; - this.ZoneId = 0; - this.Addr = arrayType$2.zero(); - this.raw = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0); - return; - } - this.Port = Port_; - this.ZoneId = ZoneId_; - this.Addr = Addr_; - this.raw = raw_; - }); - SockaddrUnix = $pkg.SockaddrUnix = $newType(0, $kindStruct, "syscall.SockaddrUnix", true, "syscall", true, function(Name_, raw_) { - this.$val = this; - if (arguments.length === 0) { - this.Name = ""; - this.raw = new RawSockaddrUnix.ptr(0, arrayType$8.zero()); - return; - } - this.Name = Name_; - this.raw = raw_; - }); - Timespec = $pkg.Timespec = $newType(0, $kindStruct, "syscall.Timespec", true, "syscall", true, function(Sec_, Nsec_) { - this.$val = this; - if (arguments.length === 0) { - this.Sec = new $Int64(0, 0); - this.Nsec = new $Int64(0, 0); - return; - } - this.Sec = Sec_; - this.Nsec = Nsec_; - }); - Stat_t = $pkg.Stat_t = $newType(0, $kindStruct, "syscall.Stat_t", true, "syscall", true, function(Dev_, Ino_, Nlink_, Mode_, Uid_, Gid_, X__pad0_, Rdev_, Size_, Blksize_, Blocks_, Atim_, Mtim_, Ctim_, X__unused_) { - this.$val = this; - if (arguments.length === 0) { - this.Dev = new $Uint64(0, 0); - this.Ino = new $Uint64(0, 0); - this.Nlink = new $Uint64(0, 0); - this.Mode = 0; - this.Uid = 0; - this.Gid = 0; - this.X__pad0 = 0; - this.Rdev = new $Uint64(0, 0); - this.Size = new $Int64(0, 0); - this.Blksize = new $Int64(0, 0); - this.Blocks = new $Int64(0, 0); - this.Atim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); - this.Mtim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); - this.Ctim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); - this.X__unused = arrayType$5.zero(); - return; - } - this.Dev = Dev_; - this.Ino = Ino_; - this.Nlink = Nlink_; - this.Mode = Mode_; - this.Uid = Uid_; - this.Gid = Gid_; - this.X__pad0 = X__pad0_; - this.Rdev = Rdev_; - this.Size = Size_; - this.Blksize = Blksize_; - this.Blocks = Blocks_; - this.Atim = Atim_; - this.Mtim = Mtim_; - this.Ctim = Ctim_; - this.X__unused = X__unused_; - }); - RawSockaddrInet4 = $pkg.RawSockaddrInet4 = $newType(0, $kindStruct, "syscall.RawSockaddrInet4", true, "syscall", true, function(Family_, Port_, Addr_, Zero_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Port = 0; - this.Addr = arrayType$9.zero(); - this.Zero = arrayType$1.zero(); - return; - } - this.Family = Family_; - this.Port = Port_; - this.Addr = Addr_; - this.Zero = Zero_; - }); - RawSockaddrInet6 = $pkg.RawSockaddrInet6 = $newType(0, $kindStruct, "syscall.RawSockaddrInet6", true, "syscall", true, function(Family_, Port_, Flowinfo_, Addr_, Scope_id_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Port = 0; - this.Flowinfo = 0; - this.Addr = arrayType$2.zero(); - this.Scope_id = 0; - return; - } - this.Family = Family_; - this.Port = Port_; - this.Flowinfo = Flowinfo_; - this.Addr = Addr_; - this.Scope_id = Scope_id_; - }); - RawSockaddrUnix = $pkg.RawSockaddrUnix = $newType(0, $kindStruct, "syscall.RawSockaddrUnix", true, "syscall", true, function(Family_, Path_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Path = arrayType$8.zero(); - return; - } - this.Family = Family_; - this.Path = Path_; - }); - RawSockaddrLinklayer = $pkg.RawSockaddrLinklayer = $newType(0, $kindStruct, "syscall.RawSockaddrLinklayer", true, "syscall", true, function(Family_, Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Protocol = 0; - this.Ifindex = 0; - this.Hatype = 0; - this.Pkttype = 0; - this.Halen = 0; - this.Addr = arrayType$1.zero(); - return; - } - this.Family = Family_; - this.Protocol = Protocol_; - this.Ifindex = Ifindex_; - this.Hatype = Hatype_; - this.Pkttype = Pkttype_; - this.Halen = Halen_; - this.Addr = Addr_; - }); - RawSockaddrNetlink = $pkg.RawSockaddrNetlink = $newType(0, $kindStruct, "syscall.RawSockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Pad = 0; - this.Pid = 0; - this.Groups = 0; - return; - } - this.Family = Family_; - this.Pad = Pad_; - this.Pid = Pid_; - this.Groups = Groups_; - }); - RawSockaddr = $pkg.RawSockaddr = $newType(0, $kindStruct, "syscall.RawSockaddr", true, "syscall", true, function(Family_, Data_) { - this.$val = this; - if (arguments.length === 0) { - this.Family = 0; - this.Data = arrayType$10.zero(); - return; - } - this.Family = Family_; - this.Data = Data_; - }); - RawSockaddrAny = $pkg.RawSockaddrAny = $newType(0, $kindStruct, "syscall.RawSockaddrAny", true, "syscall", true, function(Addr_, Pad_) { - this.$val = this; - if (arguments.length === 0) { - this.Addr = new RawSockaddr.ptr(0, arrayType$10.zero()); - this.Pad = arrayType$11.zero(); - return; - } - this.Addr = Addr_; - this.Pad = Pad_; - }); - _Socklen = $pkg._Socklen = $newType(4, $kindUint32, "syscall._Socklen", true, "syscall", false, null); - Linger = $pkg.Linger = $newType(0, $kindStruct, "syscall.Linger", true, "syscall", true, function(Onoff_, Linger_) { - this.$val = this; - if (arguments.length === 0) { - this.Onoff = 0; - this.Linger = 0; - return; - } - this.Onoff = Onoff_; - this.Linger = Linger_; - }); - Iovec = $pkg.Iovec = $newType(0, $kindStruct, "syscall.Iovec", true, "syscall", true, function(Base_, Len_) { - this.$val = this; - if (arguments.length === 0) { - this.Base = ptrType$2.nil; - this.Len = new $Uint64(0, 0); - return; - } - this.Base = Base_; - this.Len = Len_; - }); - IPMreq = $pkg.IPMreq = $newType(0, $kindStruct, "syscall.IPMreq", true, "syscall", true, function(Multiaddr_, Interface_) { - this.$val = this; - if (arguments.length === 0) { - this.Multiaddr = arrayType$9.zero(); - this.Interface = arrayType$9.zero(); - return; - } - this.Multiaddr = Multiaddr_; - this.Interface = Interface_; - }); - IPMreqn = $pkg.IPMreqn = $newType(0, $kindStruct, "syscall.IPMreqn", true, "syscall", true, function(Multiaddr_, Address_, Ifindex_) { - this.$val = this; - if (arguments.length === 0) { - this.Multiaddr = arrayType$9.zero(); - this.Address = arrayType$9.zero(); - this.Ifindex = 0; - return; - } - this.Multiaddr = Multiaddr_; - this.Address = Address_; - this.Ifindex = Ifindex_; - }); - IPv6Mreq = $pkg.IPv6Mreq = $newType(0, $kindStruct, "syscall.IPv6Mreq", true, "syscall", true, function(Multiaddr_, Interface_) { - this.$val = this; - if (arguments.length === 0) { - this.Multiaddr = arrayType$2.zero(); - this.Interface = 0; - return; - } - this.Multiaddr = Multiaddr_; - this.Interface = Interface_; - }); - Msghdr = $pkg.Msghdr = $newType(0, $kindStruct, "syscall.Msghdr", true, "syscall", true, function(Name_, Namelen_, Pad_cgo_0_, Iov_, Iovlen_, Control_, Controllen_, Flags_, Pad_cgo_1_) { - this.$val = this; - if (arguments.length === 0) { - this.Name = ptrType$2.nil; - this.Namelen = 0; - this.Pad_cgo_0 = arrayType$9.zero(); - this.Iov = ptrType$20.nil; - this.Iovlen = new $Uint64(0, 0); - this.Control = ptrType$2.nil; - this.Controllen = new $Uint64(0, 0); - this.Flags = 0; - this.Pad_cgo_1 = arrayType$9.zero(); - return; - } - this.Name = Name_; - this.Namelen = Namelen_; - this.Pad_cgo_0 = Pad_cgo_0_; - this.Iov = Iov_; - this.Iovlen = Iovlen_; - this.Control = Control_; - this.Controllen = Controllen_; - this.Flags = Flags_; - this.Pad_cgo_1 = Pad_cgo_1_; - }); - sliceType = $sliceType($Uint8); - sliceType$1 = $sliceType($String); - ptrType$2 = $ptrType($Uint8); - ptrType$4 = $ptrType($Int32); - arrayType$1 = $arrayType($Uint8, 8); - ptrType$9 = $ptrType($Uint16); - arrayType$2 = $arrayType($Uint8, 16); - ptrType$12 = $ptrType(SockaddrNetlink); - arrayType$4 = $arrayType($Uint8, 32); - arrayType$5 = $arrayType($Int64, 3); - arrayType$8 = $arrayType($Int8, 108); - arrayType$9 = $arrayType($Uint8, 4); - arrayType$10 = $arrayType($Int8, 14); - arrayType$11 = $arrayType($Int8, 96); - ptrType$19 = $ptrType(_Socklen); - ptrType$20 = $ptrType(Iovec); - structType = $structType("syscall", [{prop: "addr", name: "addr", embedded: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "len", name: "len", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: $Int, tag: ""}]); - ptrType$23 = $ptrType($Int64); - funcType = $funcType([$Uintptr], [], false); - funcType$1 = $funcType([$Uintptr], [$Bool], false); - ptrType$25 = $ptrType(SockaddrLinklayer); - ptrType$26 = $ptrType(mmapper); - mapType = $mapType(ptrType$2, sliceType); - funcType$2 = $funcType([$Uintptr, $Uintptr, $Int, $Int, $Int, $Int64], [$Uintptr, $error], false); - funcType$3 = $funcType([$Uintptr, $Uintptr], [$error], false); - ptrType$27 = $ptrType(SockaddrInet4); - ptrType$28 = $ptrType(SockaddrInet6); - ptrType$29 = $ptrType(SockaddrUnix); - ptrType$30 = $ptrType(Timespec); - ptrType$32 = $ptrType(Msghdr); - init = function() { - $flushConsole = (function() { - if (!((lineBuffer.$length === 0))) { - $global.console.log($externalize(($bytesToString(lineBuffer)), $String)); - lineBuffer = sliceType.nil; - } - }); - }; - printWarning = function() { - if (!warningPrinted) { - $global.console.error($externalize("warning: system calls not available, see https://github.com/gopherjs/gopherjs/blob/master/doc/syscalls.md", $String)); - } - warningPrinted = true; - }; - printToConsole = function(b) { - var b, goPrintToConsole, i; - goPrintToConsole = $global.goPrintToConsole; - if (!(goPrintToConsole === undefined)) { - goPrintToConsole(b); - return; - } - lineBuffer = $appendSlice(lineBuffer, b); - while (true) { - i = indexByte(lineBuffer, 10); - if (i === -1) { - break; - } - $global.console.log($externalize(($bytesToString($subslice(lineBuffer, 0, i))), $String)); - lineBuffer = $subslice(lineBuffer, (i + 1 >> 0)); - } - }; - Exit = function(code) { - var code; - Syscall(231, ((code >>> 0)), 0, 0); - }; - $pkg.Exit = Exit; - indexByte = function(s, c) { - var _i, _ref, b, c, i, s; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (b === c) { - return i; - } - _i++; - } - return -1; - }; - runtime_envs = function() { - var envkeys, envs$1, i, jsEnv, key, process; - process = $global.process; - if (process === undefined) { - return sliceType$1.nil; - } - jsEnv = process.env; - envkeys = $global.Object.keys(jsEnv); - envs$1 = $makeSlice(sliceType$1, $parseInt(envkeys.length)); - i = 0; - while (true) { - if (!(i < $parseInt(envkeys.length))) { break; } - key = $internalize(envkeys[i], $String); - ((i < 0 || i >= envs$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : envs$1.$array[envs$1.$offset + i] = key + "=" + $internalize(jsEnv[$externalize(key, $String)], $String)); - i = i + (1) >> 0; - } - return envs$1; - }; - syscallByName = function(name) { - var name, require, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - $deferred.push([(function() { - $recover(); - }), []]); - if (syscallModule === null) { - if (alreadyTriedToLoad) { - return null; - } - alreadyTriedToLoad = true; - require = $global.require; - if (require === undefined) { - $panic(new $String("")); - } - syscallModule = require($externalize("syscall", $String)); - } - return syscallModule[$externalize(name, $String)]; - /* */ } catch(err) { $err = err; return null; } finally { $callDeferred($deferred, $err); } - }; - Syscall = function(trap, a1, a2, a3) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, a1, a2, a3, array, err, f, r, r1, r2, slice, trap; - r1 = 0; - r2 = 0; - err = 0; - f = syscallByName("Syscall"); - if (!(f === null)) { - r = f(trap, a1, a2, a3); - _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); - _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); - _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); - r1 = _tmp; - r2 = _tmp$1; - err = _tmp$2; - return [r1, r2, err]; - } - if ((trap === 1) && ((a1 === 1) || (a1 === 2))) { - array = a2; - slice = $makeSlice(sliceType, $parseInt(array.length)); - slice.$array = array; - printToConsole(slice); - _tmp$3 = (($parseInt(array.length) >>> 0)); - _tmp$4 = 0; - _tmp$5 = 0; - r1 = _tmp$3; - r2 = _tmp$4; - err = _tmp$5; - return [r1, r2, err]; - } - if (trap === 231) { - runtime.Goexit(); - } - printWarning(); - _tmp$6 = ((minusOne >>> 0)); - _tmp$7 = 0; - _tmp$8 = 13; - r1 = _tmp$6; - r2 = _tmp$7; - err = _tmp$8; - return [r1, r2, err]; - }; - $pkg.Syscall = Syscall; - Syscall6 = function(trap, a1, a2, a3, a4, a5, a6) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a1, a2, a3, a4, a5, a6, err, f, r, r1, r2, trap; - r1 = 0; - r2 = 0; - err = 0; - f = syscallByName("Syscall6"); - if (!(f === null)) { - r = f(trap, a1, a2, a3, a4, a5, a6); - _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); - _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); - _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); - r1 = _tmp; - r2 = _tmp$1; - err = _tmp$2; - return [r1, r2, err]; - } - if (!((trap === 202))) { - printWarning(); - } - _tmp$3 = ((minusOne >>> 0)); - _tmp$4 = 0; - _tmp$5 = 13; - r1 = _tmp$3; - r2 = _tmp$4; - err = _tmp$5; - return [r1, r2, err]; - }; - $pkg.Syscall6 = Syscall6; - BytePtrFromString = function(s) { - var _i, _ref, array, b, i, s; - array = new ($global.Uint8Array)(s.length + 1 >> 0); - _ref = (new sliceType($stringToBytes(s))); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (b === 0) { - return [ptrType$2.nil, new Errno(22)]; - } - array[i] = b; - _i++; - } - array[s.length] = 0; - return [((array)), $ifaceNil]; - }; - $pkg.BytePtrFromString = BytePtrFromString; - readInt = function(b, off, size) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, off, ok, size, u; - u = new $Uint64(0, 0); - ok = false; - if (b.$length < (((off + size >>> 0) >> 0))) { - _tmp = new $Uint64(0, 0); - _tmp$1 = false; - u = _tmp; - ok = _tmp$1; - return [u, ok]; - } - if (false) { - _tmp$2 = readIntBE($subslice(b, off), size); - _tmp$3 = true; - u = _tmp$2; - ok = _tmp$3; - return [u, ok]; - } - _tmp$4 = readIntLE($subslice(b, off), size); - _tmp$5 = true; - u = _tmp$4; - ok = _tmp$5; - return [u, ok]; - }; - readIntBE = function(b, size) { - var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - _1 = size; - if (_1 === (1)) { - return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); - } else if (_1 === (2)) { - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - return (x = (new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), x$1 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); - } else if (_1 === (4)) { - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), x$5 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); - } else if (_1 === (8)) { - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$15 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); - } else { - $panic(new $String("syscall: readInt with unsupported size")); - } - }; - readIntLE = function(b, size) { - var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - _1 = size; - if (_1 === (1)) { - return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); - } else if (_1 === (2)) { - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - return (x = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$1 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); - } else if (_1 === (4)) { - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$5 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); - } else if (_1 === (8)) { - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$15 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); - } else { - $panic(new $String("syscall: readInt with unsupported size")); - } - }; - ParseDirent = function(buf, max, names) { - var _i, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, buf, c, consumed, count, i, ino, max, name, names, namlen, newnames, ok, origlen, rec, reclen, x, x$1, x$2; - consumed = 0; - count = 0; - newnames = sliceType$1.nil; - origlen = buf.$length; - count = 0; - while (true) { - if (!(!((max === 0)) && buf.$length > 0)) { break; } - _tuple = direntReclen(buf); - reclen = _tuple[0]; - ok = _tuple[1]; - if (!ok || (x = (new $Uint64(0, buf.$length)), (reclen.$high > x.$high || (reclen.$high === x.$high && reclen.$low > x.$low)))) { - _tmp = origlen; - _tmp$1 = count; - _tmp$2 = names; - consumed = _tmp; - count = _tmp$1; - newnames = _tmp$2; - return [consumed, count, newnames]; - } - rec = $subslice(buf, 0, $flatten64(reclen)); - buf = $subslice(buf, $flatten64(reclen)); - _tuple$1 = direntIno(rec); - ino = _tuple$1[0]; - ok = _tuple$1[1]; - if (!ok) { - break; - } - if ((ino.$high === 0 && ino.$low === 0)) { - continue; - } - _tuple$2 = direntNamlen(rec); - namlen = _tuple$2[0]; - ok = _tuple$2[1]; - if (!ok || (x$1 = new $Uint64(0 + namlen.$high, 19 + namlen.$low), x$2 = (new $Uint64(0, rec.$length)), (x$1.$high > x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { - break; - } - name = $subslice(rec, 19, $flatten64(new $Uint64(0 + namlen.$high, 19 + namlen.$low))); - _ref = name; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (c === 0) { - name = $subslice(name, 0, i); - break; - } - _i++; - } - if (($bytesToString(name)) === "." || ($bytesToString(name)) === "..") { - continue; - } - max = max - (1) >> 0; - count = count + (1) >> 0; - names = $append(names, ($bytesToString(name))); - } - _tmp$3 = origlen - buf.$length >> 0; - _tmp$4 = count; - _tmp$5 = names; - consumed = _tmp$3; - count = _tmp$4; - newnames = _tmp$5; - return [consumed, count, newnames]; - }; - $pkg.ParseDirent = ParseDirent; - CloseOnExec = function(fd) { - var fd; - fcntl(fd, 2, 1); - }; - $pkg.CloseOnExec = CloseOnExec; - SetNonblock = function(fd, nonblocking) { - var _tuple, _tuple$1, err, fd, flag, nonblocking; - err = $ifaceNil; - _tuple = fcntl(fd, 3, 0); - flag = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - err = err; - return err; - } - if (nonblocking) { - flag = flag | (2048); - } else { - flag = (flag & ~(2048)) >> 0; - } - _tuple$1 = fcntl(fd, 4, flag); - err = _tuple$1[1]; - err = err; - return err; - }; - $pkg.SetNonblock = SetNonblock; - msanRead = function(addr, len) { - var addr, len; - }; - msanWrite = function(addr, len) { - var addr, len; - }; - itoa = function(val) { - var val; - if (val < 0) { - return "-" + uitoa(((-val >>> 0))); - } - return uitoa(((val >>> 0))); - }; - uitoa = function(val) { - var _q, _r, buf, i, val; - buf = arrayType$4.zero(); - i = 31; - while (true) { - if (!(val >= 10)) { break; } - ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((_r = val % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); - i = i - (1) >> 0; - val = (_q = val / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - } - ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((val + 48 >>> 0) << 24 >>> 24))); - return ($bytesToString($subslice(new sliceType(buf), i))); - }; - Timespec.ptr.prototype.Unix = function() { - var _tmp, _tmp$1, nsec, sec, ts; - sec = new $Int64(0, 0); - nsec = new $Int64(0, 0); - ts = this; - _tmp = (ts.Sec); - _tmp$1 = (ts.Nsec); - sec = _tmp; - nsec = _tmp$1; - return [sec, nsec]; - }; - Timespec.prototype.Unix = function() { return this.$val.Unix(); }; - Timespec.ptr.prototype.Nano = function() { - var ts, x, x$1; - ts = this; - return (x = $mul64((ts.Sec), new $Int64(0, 1000000000)), x$1 = (ts.Nsec), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); - }; - Timespec.prototype.Nano = function() { return this.$val.Nano(); }; - SockaddrInet4.ptr.prototype.sockaddr = function() { - var _array, _struct, _view, i, p, sa, x, x$1, x$2; - sa = this; - if (sa.Port < 0 || sa.Port > 65535) { - return [0, 0, new Errno(22)]; - } - sa.raw.Family = 2; - p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); - p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); - p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); - i = 0; - while (true) { - if (!(i < 4)) { break; } - (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); - i = i + (1) >> 0; - } - _array = new Uint8Array(16); - return [(_array), 16, $ifaceNil]; - }; - SockaddrInet4.prototype.sockaddr = function() { return this.$val.sockaddr(); }; - SockaddrInet6.ptr.prototype.sockaddr = function() { - var _array, _struct, _view, i, p, sa, x, x$1, x$2; - sa = this; - if (sa.Port < 0 || sa.Port > 65535) { - return [0, 0, new Errno(22)]; - } - sa.raw.Family = 10; - p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); - p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); - p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); - sa.raw.Scope_id = sa.ZoneId; - i = 0; - while (true) { - if (!(i < 16)) { break; } - (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); - i = i + (1) >> 0; - } - _array = new Uint8Array(28); - return [(_array), 28, $ifaceNil]; - }; - SockaddrInet6.prototype.sockaddr = function() { return this.$val.sockaddr(); }; - SockaddrUnix.ptr.prototype.sockaddr = function() { - var _array, _struct, _view, i, n, name, sa, sl, x; - sa = this; - name = sa.Name; - n = name.length; - if (n > 108) { - return [0, 0, new Errno(22)]; - } - if ((n === 108) && !((name.charCodeAt(0) === 64))) { - return [0, 0, new Errno(22)]; - } - sa.raw.Family = 1; - i = 0; - while (true) { - if (!(i < n)) { break; } - (x = sa.raw.Path, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i] = ((name.charCodeAt(i) << 24 >> 24)))); - i = i + (1) >> 0; - } - sl = 2; - if (n > 0) { - sl = sl + ((((n >>> 0)) + 1 >>> 0)) >>> 0; - } - if (sa.raw.Path[0] === 64) { - sa.raw.Path[0] = 0; - sl = sl - (1) >>> 0; - } - _array = new Uint8Array(110); - return [(_array), sl, $ifaceNil]; - }; - SockaddrUnix.prototype.sockaddr = function() { return this.$val.sockaddr(); }; - SockaddrLinklayer.ptr.prototype.sockaddr = function() { - var _array, _struct, _view, i, sa, x, x$1; - sa = this; - if (sa.Ifindex < 0 || sa.Ifindex > 2147483647) { - return [0, 0, new Errno(22)]; - } - sa.raw.Family = 17; - sa.raw.Protocol = sa.Protocol; - sa.raw.Ifindex = ((sa.Ifindex >> 0)); - sa.raw.Hatype = sa.Hatype; - sa.raw.Pkttype = sa.Pkttype; - sa.raw.Halen = sa.Halen; - i = 0; - while (true) { - if (!(i < 8)) { break; } - (x$1 = sa.raw.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = sa.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); - i = i + (1) >> 0; - } - _array = new Uint8Array(20); - return [(_array), 20, $ifaceNil]; - }; - SockaddrLinklayer.prototype.sockaddr = function() { return this.$val.sockaddr(); }; - SockaddrNetlink.ptr.prototype.sockaddr = function() { - var _array, _struct, _view, sa; - sa = this; - sa.raw.Family = 16; - sa.raw.Pad = sa.Pad; - sa.raw.Pid = sa.Pid; - sa.raw.Groups = sa.Groups; - _array = new Uint8Array(12); - return [(_array), 12, $ifaceNil]; - }; - SockaddrNetlink.prototype.sockaddr = function() { return this.$val.sockaddr(); }; - anyToSockaddr = function(rsa) { - var _1, _array, _array$1, _array$2, _array$3, _array$4, _array$5, _array$6, _array$7, _array$8, _array$9, _struct, _struct$1, _struct$2, _struct$3, _struct$4, _struct$5, _struct$6, _struct$7, _struct$8, _struct$9, _view, _view$1, _view$2, _view$3, _view$4, _view$5, _view$6, _view$7, _view$8, _view$9, bytes, i, i$1, i$2, n, p, p$1, pp, pp$1, pp$2, pp$3, pp$4, rsa, sa, sa$1, sa$2, sa$3, sa$4, x, x$1, x$2, x$3, x$4, x$5, x$6; - _1 = rsa.Addr.Family; - if (_1 === (16)) { - _array$1 = new Uint8Array(112); - pp = ((_array = (_array$1), _struct = new RawSockaddrNetlink.ptr(0, 0, 0, 0), _view = new DataView(_array.buffer, _array.byteOffset), _struct.Family = _view.getUint16(0, true), _struct.Pad = _view.getUint16(2, true), _struct.Pid = _view.getUint32(4, true), _struct.Groups = _view.getUint32(8, true), _struct)); - _struct$1 = rsa, _view$1 = new DataView(_array$1.buffer, _array$1.byteOffset), _struct$1.Addr.Family = _view$1.getUint16(0, true), _struct$1.Addr.Data = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 2, _array$1.buffer.byteLength)), _struct$1.Pad = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 16, _array$1.buffer.byteLength)); - sa = new SockaddrNetlink.ptr(0, 0, 0, 0, new RawSockaddrNetlink.ptr(0, 0, 0, 0)); - sa.Family = pp.Family; - sa.Pad = pp.Pad; - sa.Pid = pp.Pid; - sa.Groups = pp.Groups; - return [sa, $ifaceNil]; - } else if (_1 === (17)) { - _array$3 = new Uint8Array(112); - pp$1 = ((_array$2 = (_array$3), _struct$2 = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()), _view$2 = new DataView(_array$2.buffer, _array$2.byteOffset), _struct$2.Family = _view$2.getUint16(0, true), _struct$2.Protocol = _view$2.getUint16(2, true), _struct$2.Ifindex = _view$2.getInt32(4, true), _struct$2.Hatype = _view$2.getUint16(8, true), _struct$2.Pkttype = _view$2.getUint8(10, true), _struct$2.Halen = _view$2.getUint8(11, true), _struct$2.Addr = new ($nativeArray($kindUint8))(_array$2.buffer, $min(_array$2.byteOffset + 12, _array$2.buffer.byteLength)), _struct$2)); - _struct$3 = rsa, _view$3 = new DataView(_array$3.buffer, _array$3.byteOffset), _struct$3.Addr.Family = _view$3.getUint16(0, true), _struct$3.Addr.Data = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 2, _array$3.buffer.byteLength)), _struct$3.Pad = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 16, _array$3.buffer.byteLength)); - sa$1 = new SockaddrLinklayer.ptr(0, 0, 0, 0, 0, arrayType$1.zero(), new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero())); - sa$1.Protocol = pp$1.Protocol; - sa$1.Ifindex = ((pp$1.Ifindex >> 0)); - sa$1.Hatype = pp$1.Hatype; - sa$1.Pkttype = pp$1.Pkttype; - sa$1.Halen = pp$1.Halen; - i = 0; - while (true) { - if (!(i < 8)) { break; } - (x$1 = sa$1.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = pp$1.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); - i = i + (1) >> 0; - } - return [sa$1, $ifaceNil]; - } else if (_1 === (1)) { - _array$5 = new Uint8Array(112); - pp$2 = ((_array$4 = (_array$5), _struct$4 = new RawSockaddrUnix.ptr(0, arrayType$8.zero()), _view$4 = new DataView(_array$4.buffer, _array$4.byteOffset), _struct$4.Family = _view$4.getUint16(0, true), _struct$4.Path = new ($nativeArray($kindInt8))(_array$4.buffer, $min(_array$4.byteOffset + 2, _array$4.buffer.byteLength)), _struct$4)); - _struct$5 = rsa, _view$5 = new DataView(_array$5.buffer, _array$5.byteOffset), _struct$5.Addr.Family = _view$5.getUint16(0, true), _struct$5.Addr.Data = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 2, _array$5.buffer.byteLength)), _struct$5.Pad = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 16, _array$5.buffer.byteLength)); - sa$2 = new SockaddrUnix.ptr("", new RawSockaddrUnix.ptr(0, arrayType$8.zero())); - if (pp$2.Path[0] === 0) { - pp$2.Path[0] = 64; - } - n = 0; - while (true) { - if (!(n < 108 && !(((x$2 = pp$2.Path, ((n < 0 || n >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[n])) === 0)))) { break; } - n = n + (1) >> 0; - } - bytes = $subslice(new sliceType((($sliceToArray(new sliceType(pp$2.Path))))), 0, n); - sa$2.Name = ($bytesToString(bytes)); - return [sa$2, $ifaceNil]; - } else if (_1 === (2)) { - _array$7 = new Uint8Array(112); - pp$3 = ((_array$6 = (_array$7), _struct$6 = new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero()), _view$6 = new DataView(_array$6.buffer, _array$6.byteOffset), _struct$6.Family = _view$6.getUint16(0, true), _struct$6.Port = _view$6.getUint16(2, true), _struct$6.Addr = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 4, _array$6.buffer.byteLength)), _struct$6.Zero = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 8, _array$6.buffer.byteLength)), _struct$6)); - _struct$7 = rsa, _view$7 = new DataView(_array$7.buffer, _array$7.byteOffset), _struct$7.Addr.Family = _view$7.getUint16(0, true), _struct$7.Addr.Data = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 2, _array$7.buffer.byteLength)), _struct$7.Pad = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 16, _array$7.buffer.byteLength)); - sa$3 = new SockaddrInet4.ptr(0, arrayType$9.zero(), new RawSockaddrInet4.ptr(0, 0, arrayType$9.zero(), arrayType$1.zero())); - p = (((pp$3.$ptr_Port || (pp$3.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$3))))); - sa$3.Port = ((((p.nilCheck, p[0]) >> 0)) << 8 >> 0) + (((p.nilCheck, p[1]) >> 0)) >> 0; - i$1 = 0; - while (true) { - if (!(i$1 < 4)) { break; } - (x$4 = sa$3.Addr, ((i$1 < 0 || i$1 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[i$1] = (x$3 = pp$3.Addr, ((i$1 < 0 || i$1 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[i$1])))); - i$1 = i$1 + (1) >> 0; - } - return [sa$3, $ifaceNil]; - } else if (_1 === (10)) { - _array$9 = new Uint8Array(112); - pp$4 = ((_array$8 = (_array$9), _struct$8 = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0), _view$8 = new DataView(_array$8.buffer, _array$8.byteOffset), _struct$8.Family = _view$8.getUint16(0, true), _struct$8.Port = _view$8.getUint16(2, true), _struct$8.Flowinfo = _view$8.getUint32(4, true), _struct$8.Addr = new ($nativeArray($kindUint8))(_array$8.buffer, $min(_array$8.byteOffset + 8, _array$8.buffer.byteLength)), _struct$8.Scope_id = _view$8.getUint32(24, true), _struct$8)); - _struct$9 = rsa, _view$9 = new DataView(_array$9.buffer, _array$9.byteOffset), _struct$9.Addr.Family = _view$9.getUint16(0, true), _struct$9.Addr.Data = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 2, _array$9.buffer.byteLength)), _struct$9.Pad = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 16, _array$9.buffer.byteLength)); - sa$4 = new SockaddrInet6.ptr(0, 0, arrayType$2.zero(), new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0)); - p$1 = (((pp$4.$ptr_Port || (pp$4.$ptr_Port = new ptrType$9(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$4))))); - sa$4.Port = ((((p$1.nilCheck, p$1[0]) >> 0)) << 8 >> 0) + (((p$1.nilCheck, p$1[1]) >> 0)) >> 0; - sa$4.ZoneId = pp$4.Scope_id; - i$2 = 0; - while (true) { - if (!(i$2 < 16)) { break; } - (x$6 = sa$4.Addr, ((i$2 < 0 || i$2 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i$2] = (x$5 = pp$4.Addr, ((i$2 < 0 || i$2 >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i$2])))); - i$2 = i$2 + (1) >> 0; - } - return [sa$4, $ifaceNil]; - } - return [$ifaceNil, new Errno(97)]; - }; - Accept = function(fd) { - var _tuple, _tuple$1, err, fd, len, len$24ptr, nfd, rsa, sa; - nfd = 0; - sa = $ifaceNil; - err = $ifaceNil; - rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); - len = 112; - _tuple = accept(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; })))); - nfd = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [nfd, sa, err]; - } - _tuple$1 = anyToSockaddr(rsa); - sa = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - Close(nfd); - nfd = 0; - } - return [nfd, sa, err]; - }; - $pkg.Accept = Accept; - Accept4 = function(fd, flags) { - var _tuple, _tuple$1, err, fd, flags, len, len$24ptr, nfd, rsa, sa; - nfd = 0; - sa = $ifaceNil; - err = $ifaceNil; - rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); - len = 112; - _tuple = accept4(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; }))), flags); - nfd = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [nfd, sa, err]; - } - if (len > 112) { - $panic(new $String("RawSockaddrAny too small")); - } - _tuple$1 = anyToSockaddr(rsa); - sa = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - Close(nfd); - nfd = 0; - } - return [nfd, sa, err]; - }; - $pkg.Accept4 = Accept4; - SetsockoptIPMreqn = function(fd, level, opt, mreq) { - var _array, _struct, _view, err, fd, level, mreq, opt; - err = $ifaceNil; - _array = new Uint8Array(12); - err = setsockopt(fd, level, opt, (_array), 12); - _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Address = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)), _struct.Ifindex = _view.getInt32(8, true); - return err; - }; - $pkg.SetsockoptIPMreqn = SetsockoptIPMreqn; - Recvmsg = function(fd, p, oob, flags) { - var _array, _struct, _tuple, _tuple$1, _tuple$2, _view, dummy, dummy$24ptr, err, fd, flags, from, iov, msg, n, oob, oobn, p, recvflags, rsa, sockType; - n = 0; - oobn = 0; - recvflags = 0; - from = $ifaceNil; - err = $ifaceNil; - msg = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$9.zero(), ptrType$20.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$9.zero()); - rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); - _array = new Uint8Array(112); - msg.Name = ((_array)); - _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); - msg.Namelen = 112; - iov = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); - if (p.$length > 0) { - iov.Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); - iov.SetLen(p.$length); - } - dummy = 0; - if (oob.$length > 0) { - if (p.$length === 0) { - sockType = 0; - _tuple = GetsockoptInt(fd, 1, 3); - sockType = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [n, oobn, recvflags, from, err]; - } - if (!((sockType === 2))) { - iov.Base = (dummy$24ptr || (dummy$24ptr = new ptrType$2(function() { return dummy; }, function($v) { dummy = $v; }))); - iov.SetLen(1); - } - } - msg.Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); - msg.SetControllen(oob.$length); - } - msg.Iov = iov; - msg.Iovlen = new $Uint64(0, 1); - _tuple$1 = recvmsg(fd, msg, flags); - n = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [n, oobn, recvflags, from, err]; - } - oobn = ((msg.Controllen.$low >> 0)); - recvflags = ((msg.Flags >> 0)); - if (!((rsa.Addr.Family === 0))) { - _tuple$2 = anyToSockaddr(rsa); - from = _tuple$2[0]; - err = _tuple$2[1]; - } - return [n, oobn, recvflags, from, err]; - }; - $pkg.Recvmsg = Recvmsg; - SendmsgN = function(fd, p, oob, to, flags) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, dummy, err, err$1, fd, flags, iov, msg, n, oob, p, ptr, salen, sockType, to, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; dummy = $f.dummy; err = $f.err; err$1 = $f.err$1; fd = $f.fd; flags = $f.flags; iov = $f.iov; msg = $f.msg; n = $f.n; oob = $f.oob; p = $f.p; ptr = $f.ptr; salen = $f.salen; sockType = $f.sockType; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - dummy = [dummy]; - iov = [iov]; - msg = [msg]; - n = 0; - err = $ifaceNil; - ptr = 0; - salen = 0; - /* */ if (!($interfaceIsEqual(to, $ifaceNil))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!($interfaceIsEqual(to, $ifaceNil))) { */ case 1: - err$1 = $ifaceNil; - _r = to.sockaddr(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - ptr = _tuple[0]; - salen = _tuple[1]; - err$1 = _tuple[2]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = 0; - _tmp$1 = err$1; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - /* } */ case 2: - msg[0] = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$9.zero(), ptrType$20.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$9.zero()); - msg[0].Name = (ptr); - msg[0].Namelen = ((salen >>> 0)); - iov[0] = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); - if (p.$length > 0) { - iov[0].Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); - iov[0].SetLen(p.$length); - } - dummy[0] = 0; - if (oob.$length > 0) { - if (p.$length === 0) { - sockType = 0; - _tuple$1 = GetsockoptInt(fd, 1, 3); - sockType = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$2 = 0; - _tmp$3 = err; - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - if (!((sockType === 2))) { - iov[0].Base = (dummy.$ptr || (dummy.$ptr = new ptrType$2(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, dummy))); - iov[0].SetLen(1); - } - } - msg[0].Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); - msg[0].SetControllen(oob.$length); - } - msg[0].Iov = iov[0]; - msg[0].Iovlen = new $Uint64(0, 1); - _tuple$2 = sendmsg(fd, msg[0], flags); - n = _tuple$2[0]; - err = _tuple$2[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$4 = 0; - _tmp$5 = err; - n = _tmp$4; - err = _tmp$5; - $s = -1; return [n, err]; - } - if (oob.$length > 0 && (p.$length === 0)) { - n = 0; - } - _tmp$6 = n; - _tmp$7 = $ifaceNil; - n = _tmp$6; - err = _tmp$7; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: SendmsgN }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.dummy = dummy; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.flags = flags; $f.iov = iov; $f.msg = msg; $f.n = n; $f.oob = oob; $f.p = p; $f.ptr = ptr; $f.salen = salen; $f.sockType = sockType; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.SendmsgN = SendmsgN; - ReadDirent = function(fd, buf) { - var _tuple, buf, err, fd, n; - n = 0; - err = $ifaceNil; - _tuple = Getdents(fd, buf); - n = _tuple[0]; - err = _tuple[1]; - return [n, err]; - }; - $pkg.ReadDirent = ReadDirent; - direntIno = function(buf) { - var buf; - return readInt(buf, 0, 8); - }; - direntReclen = function(buf) { - var buf; - return readInt(buf, 16, 2); - }; - direntNamlen = function(buf) { - var _tuple, buf, ok, reclen; - _tuple = direntReclen(buf); - reclen = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - return [new $Uint64(0, 0), false]; - } - return [new $Uint64(reclen.$high - 0, reclen.$low - 19), true]; - }; - Lstat = function(path, stat) { - var err, path, stat; - err = $ifaceNil; - err = fstatat(-100, path, stat, 256); - return err; - }; - $pkg.Lstat = Lstat; - Iovec.ptr.prototype.SetLen = function(length) { - var iov, length; - iov = this; - iov.Len = (new $Uint64(0, length)); - }; - Iovec.prototype.SetLen = function(length) { return this.$val.SetLen(length); }; - Msghdr.ptr.prototype.SetControllen = function(length) { - var length, msghdr; - msghdr = this; - msghdr.Controllen = (new $Uint64(0, length)); - }; - Msghdr.prototype.SetControllen = function(length) { return this.$val.SetControllen(length); }; - mmapper.ptr.prototype.Mmap = function(fd, offset, length, prot, flags) { - var _key, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, addr, b, data, err, errno, fd, flags, length, m, offset, p, prot, sl, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _key = $f._key; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; addr = $f.addr; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; fd = $f.fd; flags = $f.flags; length = $f.length; m = $f.m; offset = $f.offset; p = $f.p; prot = $f.prot; sl = $f.sl; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - sl = [sl]; - data = sliceType.nil; - err = $ifaceNil; - m = this; - if (length <= 0) { - _tmp = sliceType.nil; - _tmp$1 = new Errno(22); - data = _tmp; - err = _tmp$1; - $s = -1; return [data, err]; - } - _r = m.mmap(0, ((length >>> 0)), prot, flags, fd, offset); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - addr = _tuple[0]; - errno = _tuple[1]; - if (!($interfaceIsEqual(errno, $ifaceNil))) { - _tmp$2 = sliceType.nil; - _tmp$3 = errno; - data = _tmp$2; - err = _tmp$3; - $s = -1; return [data, err]; - } - sl[0] = new structType.ptr(addr, length, length); - b = sl[0]; - p = $indexPtr(b.$array, b.$offset + (b.$capacity - 1 >> 0), ptrType$2); - $r = m.Mutex.Lock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); - _key = p; (m.active || $throwRuntimeError("assignment to entry in nil map"))[ptrType$2.keyFor(_key)] = { k: _key, v: b }; - _tmp$4 = b; - _tmp$5 = $ifaceNil; - data = _tmp$4; - err = _tmp$5; - $s = -1; return [data, err]; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [data, err]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Mmap }; } $f._key = _key; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.addr = addr; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.fd = fd; $f.flags = flags; $f.length = length; $f.m = m; $f.offset = offset; $f.p = p; $f.prot = prot; $f.sl = sl; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - mmapper.prototype.Mmap = function(fd, offset, length, prot, flags) { return this.$val.Mmap(fd, offset, length, prot, flags); }; - mmapper.ptr.prototype.Munmap = function(data) { - var _entry, _r, b, data, err, errno, m, p, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; m = $f.m; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - err = $ifaceNil; - m = this; - if ((data.$length === 0) || !((data.$length === data.$capacity))) { - err = new Errno(22); - $s = -1; return err; - } - p = $indexPtr(data.$array, data.$offset + (data.$capacity - 1 >> 0), ptrType$2); - $r = m.Mutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); - b = (_entry = m.active[ptrType$2.keyFor(p)], _entry !== undefined ? _entry.v : sliceType.nil); - if (b === sliceType.nil || !($indexPtr(b.$array, b.$offset + 0, ptrType$2) === $indexPtr(data.$array, data.$offset + 0, ptrType$2))) { - err = new Errno(22); - $s = -1; return err; - } - _r = m.munmap((($sliceToArray(b))), ((b.$length >>> 0))); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - errno = _r; - if (!($interfaceIsEqual(errno, $ifaceNil))) { - err = errno; - $s = -1; return err; - } - delete m.active[ptrType$2.keyFor(p)]; - err = $ifaceNil; - $s = -1; return err; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Munmap }; } $f._entry = _entry; $f._r = _r; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.m = m; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - mmapper.prototype.Munmap = function(data) { return this.$val.Munmap(data); }; - Errno.prototype.Error = function() { - var e, s; - e = this.$val; - if (0 <= ((e >> 0)) && ((e >> 0)) < 133) { - s = ((e < 0 || e >= errors.length) ? ($throwRuntimeError("index out of range"), undefined) : errors[e]); - if (!(s === "")) { - return s; - } - } - return "errno " + itoa(((e >> 0))); - }; - $ptrType(Errno).prototype.Error = function() { return new Errno(this.$get()).Error(); }; - Errno.prototype.Temporary = function() { - var e; - e = this.$val; - return (e === 4) || (e === 24) || new Errno(e).Timeout(); - }; - $ptrType(Errno).prototype.Temporary = function() { return new Errno(this.$get()).Temporary(); }; - Errno.prototype.Timeout = function() { - var e; - e = this.$val; - return (e === 11) || (e === 11) || (e === 110); - }; - $ptrType(Errno).prototype.Timeout = function() { return new Errno(this.$get()).Timeout(); }; - errnoErr = function(e) { - var _1, e; - _1 = e; - if (_1 === (0)) { - return $ifaceNil; - } else if (_1 === (11)) { - return errEAGAIN; - } else if (_1 === (22)) { - return errEINVAL; - } else if (_1 === (2)) { - return errENOENT; - } - return new Errno(e); - }; - Read = function(fd, p) { - var _tuple, err, fd, n, p; - n = 0; - err = $ifaceNil; - _tuple = read(fd, p); - n = _tuple[0]; - err = _tuple[1]; - if (false) { - if (n > 0) { - race.WriteRange(($sliceToArray(p)), n); - } - if ($interfaceIsEqual(err, $ifaceNil)) { - race.Acquire(((ioSync$24ptr || (ioSync$24ptr = new ptrType$23(function() { return ioSync; }, function($v) { ioSync = $v; }))))); - } - } - if (false && n > 0) { - msanWrite(($sliceToArray(p)), n); - } - return [n, err]; - }; - $pkg.Read = Read; - Write = function(fd, p) { - var _tuple, err, fd, n, p; - n = 0; - err = $ifaceNil; - if (false) { - race.ReleaseMerge(((ioSync$24ptr || (ioSync$24ptr = new ptrType$23(function() { return ioSync; }, function($v) { ioSync = $v; }))))); - } - _tuple = write(fd, p); - n = _tuple[0]; - err = _tuple[1]; - if (false && n > 0) { - race.ReadRange(($sliceToArray(p)), n); - } - if (false && n > 0) { - msanRead(($sliceToArray(p)), n); - } - return [n, err]; - }; - $pkg.Write = Write; - GetsockoptInt = function(fd, level, opt) { - var _tmp, _tmp$1, err, fd, level, n, n$24ptr, opt, vallen, vallen$24ptr, value; - value = 0; - err = $ifaceNil; - n = 0; - vallen = 4; - err = getsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), (vallen$24ptr || (vallen$24ptr = new ptrType$19(function() { return vallen; }, function($v) { vallen = $v; })))); - _tmp = ((n >> 0)); - _tmp$1 = err; - value = _tmp; - err = _tmp$1; - return [value, err]; - }; - $pkg.GetsockoptInt = GetsockoptInt; - Recvfrom = function(fd, p, flags) { - var _tuple, _tuple$1, err, fd, flags, from, len, len$24ptr, n, p, rsa; - n = 0; - from = $ifaceNil; - err = $ifaceNil; - rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$10.zero()), arrayType$11.zero()); - len = 112; - _tuple = recvfrom(fd, p, flags, rsa, (len$24ptr || (len$24ptr = new ptrType$19(function() { return len; }, function($v) { len = $v; })))); - n = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [n, from, err]; - } - if (!((rsa.Addr.Family === 0))) { - _tuple$1 = anyToSockaddr(rsa); - from = _tuple$1[0]; - err = _tuple$1[1]; - } - return [n, from, err]; - }; - $pkg.Recvfrom = Recvfrom; - Sendto = function(fd, p, flags, to) { - var _r, _tuple, err, fd, flags, n, p, ptr, to, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; fd = $f.fd; flags = $f.flags; n = $f.n; p = $f.p; ptr = $f.ptr; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - err = $ifaceNil; - _r = to.sockaddr(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - ptr = _tuple[0]; - n = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - err = err; - $s = -1; return err; - } - err = sendto(fd, p, flags, ptr, n); - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sendto }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.fd = fd; $f.flags = flags; $f.n = n; $f.p = p; $f.ptr = ptr; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sendto = Sendto; - SetsockoptByte = function(fd, level, opt, value) { - var err, fd, level, opt, value, value$24ptr; - err = $ifaceNil; - err = setsockopt(fd, level, opt, ((value$24ptr || (value$24ptr = new ptrType$2(function() { return value; }, function($v) { value = $v; })))), 1); - return err; - }; - $pkg.SetsockoptByte = SetsockoptByte; - SetsockoptInt = function(fd, level, opt, value) { - var err, fd, level, n, n$24ptr, opt, value; - err = $ifaceNil; - n = ((value >> 0)); - err = setsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), 4); - return err; - }; - $pkg.SetsockoptInt = SetsockoptInt; - SetsockoptInet4Addr = function(fd, level, opt, value) { - var err, fd, level, opt, value; - err = $ifaceNil; - err = setsockopt(fd, level, opt, ($sliceToArray(new sliceType(value))), 4); - return err; - }; - $pkg.SetsockoptInet4Addr = SetsockoptInet4Addr; - SetsockoptIPMreq = function(fd, level, opt, mreq) { - var _array, _struct, _view, err, fd, level, mreq, opt; - err = $ifaceNil; - _array = new Uint8Array(8); - err = setsockopt(fd, level, opt, (_array), 8); - _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)); - return err; - }; - $pkg.SetsockoptIPMreq = SetsockoptIPMreq; - SetsockoptIPv6Mreq = function(fd, level, opt, mreq) { - var _array, _struct, _view, err, fd, level, mreq, opt; - err = $ifaceNil; - _array = new Uint8Array(20); - err = setsockopt(fd, level, opt, (_array), 20); - _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = _view.getUint32(16, true); - return err; - }; - $pkg.SetsockoptIPv6Mreq = SetsockoptIPv6Mreq; - SetsockoptLinger = function(fd, level, opt, l) { - var _array, _struct, _view, err, fd, l, level, opt; - err = $ifaceNil; - _array = new Uint8Array(8); - err = setsockopt(fd, level, opt, (_array), 8); - _struct = l, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Onoff = _view.getInt32(0, true), _struct.Linger = _view.getInt32(4, true); - return err; - }; - $pkg.SetsockoptLinger = SetsockoptLinger; - Close = function(fd) { - var _tuple, e1, err, fd; - err = $ifaceNil; - _tuple = Syscall(3, ((fd >>> 0)), 0, 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Close = Close; - Dup = function(oldfd) { - var _tuple, e1, err, fd, oldfd, r0; - fd = 0; - err = $ifaceNil; - _tuple = Syscall(32, ((oldfd >>> 0)), 0, 0); - r0 = _tuple[0]; - e1 = _tuple[2]; - fd = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [fd, err]; - }; - $pkg.Dup = Dup; - Fchdir = function(fd) { - var _tuple, e1, err, fd; - err = $ifaceNil; - _tuple = Syscall(81, ((fd >>> 0)), 0, 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Fchdir = Fchdir; - Fchmod = function(fd, mode) { - var _tuple, e1, err, fd, mode; - err = $ifaceNil; - _tuple = Syscall(91, ((fd >>> 0)), ((mode >>> 0)), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Fchmod = Fchmod; - fcntl = function(fd, cmd, arg) { - var _tuple, arg, cmd, e1, err, fd, r0, val; - val = 0; - err = $ifaceNil; - _tuple = Syscall(72, ((fd >>> 0)), ((cmd >>> 0)), ((arg >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - val = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [val, err]; - }; - Fsync = function(fd) { - var _tuple, e1, err, fd; - err = $ifaceNil; - _tuple = Syscall(74, ((fd >>> 0)), 0, 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Fsync = Fsync; - Getdents = function(fd, buf) { - var _p0, _tuple, buf, e1, err, fd, n, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (buf.$length > 0) { - _p0 = ($sliceToArray(buf)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall(217, ((fd >>> 0)), (_p0), ((buf.$length >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - $pkg.Getdents = Getdents; - read = function(fd, p) { - var _p0, _tuple, e1, err, fd, n, p, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (p.$length > 0) { - _p0 = ($sliceToArray(p)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall(0, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - write = function(fd, p) { - var _p0, _tuple, e1, err, fd, n, p, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (p.$length > 0) { - _p0 = ($sliceToArray(p)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall(1, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - munmap = function(addr, length) { - var _tuple, addr, e1, err, length; - err = $ifaceNil; - _tuple = Syscall(11, (addr), (length), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - Fchown = function(fd, uid, gid) { - var _tuple, e1, err, fd, gid, uid; - err = $ifaceNil; - _tuple = Syscall(93, ((fd >>> 0)), ((uid >>> 0)), ((gid >>> 0))); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Fchown = Fchown; - Fstat = function(fd, stat) { - var _array, _struct, _tuple, _view, e1, err, fd, stat; - err = $ifaceNil; - _array = new Uint8Array(144); - _tuple = Syscall(5, ((fd >>> 0)), ((_array)), 0); - _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Fstat = Fstat; - Ftruncate = function(fd, length) { - var _tuple, e1, err, fd, length; - err = $ifaceNil; - _tuple = Syscall(77, ((fd >>> 0)), ((length.$low >>> 0)), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Ftruncate = Ftruncate; - Pread = function(fd, p, offset) { - var _p0, _tuple, e1, err, fd, n, offset, p, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (p.$length > 0) { - _p0 = ($sliceToArray(p)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall6(17, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - $pkg.Pread = Pread; - Pwrite = function(fd, p, offset) { - var _p0, _tuple, e1, err, fd, n, offset, p, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (p.$length > 0) { - _p0 = ($sliceToArray(p)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall6(18, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - $pkg.Pwrite = Pwrite; - Seek = function(fd, offset, whence) { - var _tuple, e1, err, fd, off, offset, r0, whence; - off = new $Int64(0, 0); - err = $ifaceNil; - _tuple = Syscall(8, ((fd >>> 0)), ((offset.$low >>> 0)), ((whence >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - off = (new $Int64(0, r0.constructor === Number ? r0 : 1)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [off, err]; - }; - $pkg.Seek = Seek; - Shutdown = function(fd, how) { - var _tuple, e1, err, fd, how; - err = $ifaceNil; - _tuple = Syscall(48, ((fd >>> 0)), ((how >>> 0)), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - $pkg.Shutdown = Shutdown; - accept = function(s, rsa, addrlen) { - var _array, _struct, _tuple, _view, addrlen, e1, err, fd, r0, rsa, s; - fd = 0; - err = $ifaceNil; - _array = new Uint8Array(112); - _tuple = Syscall(43, ((s >>> 0)), ((_array)), ((addrlen))); - _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); - r0 = _tuple[0]; - e1 = _tuple[2]; - fd = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [fd, err]; - }; - accept4 = function(s, rsa, addrlen, flags) { - var _array, _struct, _tuple, _view, addrlen, e1, err, fd, flags, r0, rsa, s; - fd = 0; - err = $ifaceNil; - _array = new Uint8Array(112); - _tuple = Syscall6(288, ((s >>> 0)), ((_array)), ((addrlen)), ((flags >>> 0)), 0, 0); - _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); - r0 = _tuple[0]; - e1 = _tuple[2]; - fd = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [fd, err]; - }; - fstatat = function(fd, path, stat, flags) { - var _array, _p0, _struct, _tuple, _tuple$1, _view, e1, err, fd, flags, path, stat; - err = $ifaceNil; - _p0 = ptrType$2.nil; - _tuple = BytePtrFromString(path); - _p0 = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - _array = new Uint8Array(144); - _tuple$1 = Syscall6(262, ((fd >>> 0)), ((_p0)), ((_array)), ((flags >>> 0)), 0, 0); - _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); - e1 = _tuple$1[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - getsockopt = function(s, level, name, val, vallen) { - var _tuple, e1, err, level, name, s, val, vallen; - err = $ifaceNil; - _tuple = Syscall6(55, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), ((vallen)), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - setsockopt = function(s, level, name, val, vallen) { - var _tuple, e1, err, level, name, s, val, vallen; - err = $ifaceNil; - _tuple = Syscall6(54, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), (vallen), 0); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - recvfrom = function(fd, p, flags, from, fromlen) { - var _array, _p0, _struct, _tuple, _view, e1, err, fd, flags, from, fromlen, n, p, r0; - n = 0; - err = $ifaceNil; - _p0 = 0; - if (p.$length > 0) { - _p0 = ($sliceToArray(p)); - } else { - _p0 = (new Uint8Array(0)); - } - _array = new Uint8Array(112); - _tuple = Syscall6(45, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((flags >>> 0)), ((_array)), ((fromlen))); - _struct = from, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - sendto = function(s, buf, flags, to, addrlen) { - var _p0, _tuple, addrlen, buf, e1, err, flags, s, to; - err = $ifaceNil; - _p0 = 0; - if (buf.$length > 0) { - _p0 = ($sliceToArray(buf)); - } else { - _p0 = (new Uint8Array(0)); - } - _tuple = Syscall6(44, ((s >>> 0)), (_p0), ((buf.$length >>> 0)), ((flags >>> 0)), (to), ((addrlen >>> 0))); - e1 = _tuple[2]; - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return err; - }; - recvmsg = function(s, msg, flags) { - var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; - n = 0; - err = $ifaceNil; - _array = new Uint8Array(48); - _tuple = Syscall(47, ((s >>> 0)), ((_array)), ((flags >>> 0))); - _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - sendmsg = function(s, msg, flags) { - var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; - n = 0; - err = $ifaceNil; - _array = new Uint8Array(48); - _tuple = Syscall(46, ((s >>> 0)), ((_array)), ((flags >>> 0))); - _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); - r0 = _tuple[0]; - e1 = _tuple[2]; - n = ((r0 >> 0)); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [n, err]; - }; - mmap = function(addr, length, prot, flags, fd, offset) { - var _tuple, addr, e1, err, fd, flags, length, offset, prot, r0, xaddr; - xaddr = 0; - err = $ifaceNil; - _tuple = Syscall6(9, (addr), (length), ((prot >>> 0)), ((flags >>> 0)), ((fd >>> 0)), ((offset.$low >>> 0))); - r0 = _tuple[0]; - e1 = _tuple[2]; - xaddr = (r0); - if (!((e1 === 0))) { - err = errnoErr(e1); - } - return [xaddr, err]; - }; - ptrType$25.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; - ptrType$12.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; - ptrType$26.methods = [{prop: "Mmap", name: "Mmap", pkg: "", typ: $funcType([$Int, $Int64, $Int, $Int, $Int], [sliceType, $error], false)}, {prop: "Munmap", name: "Munmap", pkg: "", typ: $funcType([sliceType], [$error], false)}]; - Errno.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; - ptrType$27.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; - ptrType$28.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; - ptrType$29.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; - ptrType$30.methods = [{prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64, $Int64], false)}, {prop: "Nano", name: "Nano", pkg: "", typ: $funcType([], [$Int64], false)}]; - ptrType$20.methods = [{prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}]; - ptrType$32.methods = [{prop: "SetControllen", name: "SetControllen", pkg: "", typ: $funcType([$Int], [], false)}]; - RawConn.init([{prop: "Control", name: "Control", pkg: "", typ: $funcType([funcType], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([funcType$1], [$error], false)}]); - SockaddrLinklayer.init("syscall", [{prop: "Protocol", name: "Protocol", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Hatype", name: "Hatype", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$1, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrLinklayer, tag: ""}]); - SockaddrNetlink.init("syscall", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrNetlink, tag: ""}]); - mmapper.init("syscall", [{prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: sync.Mutex, tag: ""}, {prop: "active", name: "active", embedded: false, exported: false, typ: mapType, tag: ""}, {prop: "mmap", name: "mmap", embedded: false, exported: false, typ: funcType$2, tag: ""}, {prop: "munmap", name: "munmap", embedded: false, exported: false, typ: funcType$3, tag: ""}]); - Sockaddr.init([{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]); - SockaddrInet4.init("syscall", [{prop: "Port", name: "Port", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrInet4, tag: ""}]); - SockaddrInet6.init("syscall", [{prop: "Port", name: "Port", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "ZoneId", name: "ZoneId", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrInet6, tag: ""}]); - SockaddrUnix.init("syscall", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "raw", name: "raw", embedded: false, exported: false, typ: RawSockaddrUnix, tag: ""}]); - Timespec.init("", [{prop: "Sec", name: "Sec", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Nsec", name: "Nsec", embedded: false, exported: true, typ: $Int64, tag: ""}]); - Stat_t.init("", [{prop: "Dev", name: "Dev", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Ino", name: "Ino", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Nlink", name: "Nlink", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Mode", name: "Mode", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Uid", name: "Uid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Gid", name: "Gid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "X__pad0", name: "X__pad0", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Rdev", name: "Rdev", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Size", name: "Size", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blksize", name: "Blksize", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blocks", name: "Blocks", embedded: false, exported: true, typ: $Int64, tag: ""}, {prop: "Atim", name: "Atim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "Mtim", name: "Mtim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "Ctim", name: "Ctim", embedded: false, exported: true, typ: Timespec, tag: ""}, {prop: "X__unused", name: "X__unused", embedded: false, exported: true, typ: arrayType$5, tag: ""}]); - RawSockaddrInet4.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Zero", name: "Zero", embedded: false, exported: true, typ: arrayType$1, tag: ""}]); - RawSockaddrInet6.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Flowinfo", name: "Flowinfo", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Scope_id", name: "Scope_id", embedded: false, exported: true, typ: $Uint32, tag: ""}]); - RawSockaddrUnix.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Path", name: "Path", embedded: false, exported: true, typ: arrayType$8, tag: ""}]); - RawSockaddrLinklayer.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Protocol", name: "Protocol", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Hatype", name: "Hatype", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", embedded: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", embedded: false, exported: true, typ: arrayType$1, tag: ""}]); - RawSockaddrNetlink.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", embedded: false, exported: true, typ: $Uint32, tag: ""}]); - RawSockaddr.init("", [{prop: "Family", name: "Family", embedded: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Data", name: "Data", embedded: false, exported: true, typ: arrayType$10, tag: ""}]); - RawSockaddrAny.init("", [{prop: "Addr", name: "Addr", embedded: false, exported: true, typ: RawSockaddr, tag: ""}, {prop: "Pad", name: "Pad", embedded: false, exported: true, typ: arrayType$11, tag: ""}]); - Linger.init("", [{prop: "Onoff", name: "Onoff", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Linger", name: "Linger", embedded: false, exported: true, typ: $Int32, tag: ""}]); - Iovec.init("", [{prop: "Base", name: "Base", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Len", name: "Len", embedded: false, exported: true, typ: $Uint64, tag: ""}]); - IPMreq.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Interface", name: "Interface", embedded: false, exported: true, typ: arrayType$9, tag: ""}]); - IPMreqn.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Address", name: "Address", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Ifindex", name: "Ifindex", embedded: false, exported: true, typ: $Int32, tag: ""}]); - IPv6Mreq.init("", [{prop: "Multiaddr", name: "Multiaddr", embedded: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Interface", name: "Interface", embedded: false, exported: true, typ: $Uint32, tag: ""}]); - Msghdr.init("", [{prop: "Name", name: "Name", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Namelen", name: "Namelen", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", embedded: false, exported: true, typ: arrayType$9, tag: ""}, {prop: "Iov", name: "Iov", embedded: false, exported: true, typ: ptrType$20, tag: ""}, {prop: "Iovlen", name: "Iovlen", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Control", name: "Control", embedded: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Controllen", name: "Controllen", embedded: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Flags", name: "Flags", embedded: false, exported: true, typ: $Int32, tag: ""}, {prop: "Pad_cgo_1", name: "Pad_cgo_1", embedded: false, exported: true, typ: arrayType$9, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - lineBuffer = sliceType.nil; - syscallModule = null; - $pkg.ForkLock = new sync.RWMutex.ptr(new sync.Mutex.ptr(0, 0), 0, 0, 0, 0); - ioSync = new $Int64(0, 0); - warningPrinted = false; - alreadyTriedToLoad = false; - minusOne = -1; - envs = runtime_envs(); - $pkg.Stdin = 0; - $pkg.Stdout = 1; - $pkg.Stderr = 2; - errEAGAIN = new Errno(11); - errEINVAL = new Errno(22); - errENOENT = new Errno(2); - errors = $toNativeArray($kindString, ["", "operation not permitted", "no such file or directory", "no such process", "interrupted system call", "input/output error", "no such device or address", "argument list too long", "exec format error", "bad file descriptor", "no child processes", "resource temporarily unavailable", "cannot allocate memory", "permission denied", "bad address", "block device required", "device or resource busy", "file exists", "invalid cross-device link", "no such device", "not a directory", "is a directory", "invalid argument", "too many open files in system", "too many open files", "inappropriate ioctl for device", "text file busy", "file too large", "no space left on device", "illegal seek", "read-only file system", "too many links", "broken pipe", "numerical argument out of domain", "numerical result out of range", "resource deadlock avoided", "file name too long", "no locks available", "function not implemented", "directory not empty", "too many levels of symbolic links", "", "no message of desired type", "identifier removed", "channel number out of range", "level 2 not synchronized", "level 3 halted", "level 3 reset", "link number out of range", "protocol driver not attached", "no CSI structure available", "level 2 halted", "invalid exchange", "invalid request descriptor", "exchange full", "no anode", "invalid request code", "invalid slot", "", "bad font file format", "device not a stream", "no data available", "timer expired", "out of streams resources", "machine is not on the network", "package not installed", "object is remote", "link has been severed", "advertise error", "srmount error", "communication error on send", "protocol error", "multihop attempted", "RFS specific error", "bad message", "value too large for defined data type", "name not unique on network", "file descriptor in bad state", "remote address changed", "can not access a needed shared library", "accessing a corrupted shared library", ".lib section in a.out corrupted", "attempting to link in too many shared libraries", "cannot exec a shared library directly", "invalid or incomplete multibyte or wide character", "interrupted system call should be restarted", "streams pipe error", "too many users", "socket operation on non-socket", "destination address required", "message too long", "protocol wrong type for socket", "protocol not available", "protocol not supported", "socket type not supported", "operation not supported", "protocol family not supported", "address family not supported by protocol", "address already in use", "cannot assign requested address", "network is down", "network is unreachable", "network dropped connection on reset", "software caused connection abort", "connection reset by peer", "no buffer space available", "transport endpoint is already connected", "transport endpoint is not connected", "cannot send after transport endpoint shutdown", "too many references: cannot splice", "connection timed out", "connection refused", "host is down", "no route to host", "operation already in progress", "operation now in progress", "stale NFS file handle", "structure needs cleaning", "not a XENIX named type file", "no XENIX semaphores available", "is a named type file", "remote I/O error", "disk quota exceeded", "no medium found", "wrong medium type", "operation canceled", "required key not available", "key has expired", "key has been revoked", "key was rejected by service", "owner died", "state not recoverable", "operation not possible due to RF-kill"]); - mapper = new mmapper.ptr(new sync.Mutex.ptr(0, 0), {}, mmap, munmap); - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["github.com/gopherjs/gopherjs/nosync"] = (function() { - var $pkg = {}, $init, Map, Mutex, WaitGroup, Once, Pool, funcType, ptrType, mapType, ptrType$1, ptrType$3, funcType$1, ptrType$4, sliceType, ptrType$5, funcType$2; - Map = $pkg.Map = $newType(0, $kindStruct, "nosync.Map", true, "github.com/gopherjs/gopherjs/nosync", true, function(m_) { - this.$val = this; - if (arguments.length === 0) { - this.m = false; - return; - } - this.m = m_; - }); - Mutex = $pkg.Mutex = $newType(0, $kindStruct, "nosync.Mutex", true, "github.com/gopherjs/gopherjs/nosync", true, function(locked_) { - this.$val = this; - if (arguments.length === 0) { - this.locked = false; - return; - } - this.locked = locked_; - }); - WaitGroup = $pkg.WaitGroup = $newType(0, $kindStruct, "nosync.WaitGroup", true, "github.com/gopherjs/gopherjs/nosync", true, function(counter_) { - this.$val = this; - if (arguments.length === 0) { - this.counter = 0; - return; - } - this.counter = counter_; - }); - Once = $pkg.Once = $newType(0, $kindStruct, "nosync.Once", true, "github.com/gopherjs/gopherjs/nosync", true, function(doing_, done_) { - this.$val = this; - if (arguments.length === 0) { - this.doing = false; - this.done = false; - return; - } - this.doing = doing_; - this.done = done_; - }); - Pool = $pkg.Pool = $newType(0, $kindStruct, "nosync.Pool", true, "github.com/gopherjs/gopherjs/nosync", true, function(store_, New_) { - this.$val = this; - if (arguments.length === 0) { - this.store = sliceType.nil; - this.New = $throwNilPointerError; - return; - } - this.store = store_; - this.New = New_; - }); - funcType = $funcType([$emptyInterface, $emptyInterface], [$Bool], false); - ptrType = $ptrType(Map); - mapType = $mapType($emptyInterface, $emptyInterface); - ptrType$1 = $ptrType(Mutex); - ptrType$3 = $ptrType(WaitGroup); - funcType$1 = $funcType([], [], false); - ptrType$4 = $ptrType(Once); - sliceType = $sliceType($emptyInterface); - ptrType$5 = $ptrType(Pool); - funcType$2 = $funcType([], [$emptyInterface], false); - Map.ptr.prototype.Load = function(key) { - var _entry, _tmp, _tmp$1, _tuple, key, m, ok, value; - value = $ifaceNil; - ok = false; - m = this; - _tuple = (_entry = m.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); - value = _tuple[0]; - ok = _tuple[1]; - _tmp = value; - _tmp$1 = ok; - value = _tmp; - ok = _tmp$1; - return [value, ok]; - }; - Map.prototype.Load = function(key) { return this.$val.Load(key); }; - Map.ptr.prototype.Store = function(key, value) { - var _key, key, m, value; - m = this; - if (m.m === false) { - m.m = {}; - } - _key = key; (m.m || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: value }; - }; - Map.prototype.Store = function(key, value) { return this.$val.Store(key, value); }; - Map.ptr.prototype.LoadOrStore = function(key, value) { - var _entry, _key, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, actual, key, loaded, m, ok, value, value$1; - actual = $ifaceNil; - loaded = false; - m = this; - _tuple = (_entry = m.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); - value$1 = _tuple[0]; - ok = _tuple[1]; - if (ok) { - _tmp = value$1; - _tmp$1 = true; - actual = _tmp; - loaded = _tmp$1; - return [actual, loaded]; - } - if (m.m === false) { - m.m = {}; - } - _key = key; (m.m || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: value }; - _tmp$2 = value; - _tmp$3 = false; - actual = _tmp$2; - loaded = _tmp$3; - return [actual, loaded]; - }; - Map.prototype.LoadOrStore = function(key, value) { return this.$val.LoadOrStore(key, value); }; - Map.ptr.prototype.Delete = function(key) { - var key, m; - m = this; - if (m.m === false) { - return; - } - delete m.m[$emptyInterface.keyFor(key)]; - }; - Map.prototype.Delete = function(key) { return this.$val.Delete(key); }; - Map.ptr.prototype.Range = function(f) { - var _entry, _i, _keys, _r, _ref, f, k, m, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _r = $f._r; _ref = $f._ref; f = $f.f; k = $f.k; m = $f.m; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - m = this; - _ref = m.m; - _i = 0; - _keys = $keys(_ref); - /* while (true) { */ case 1: - /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 2; continue; } - _entry = _ref[_keys[_i]]; - if (_entry === undefined) { - _i++; - /* continue; */ $s = 1; continue; - } - k = _entry.k; - v = _entry.v; - _r = f(k, v); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!_r) { */ case 3: - /* break; */ $s = 2; continue; - /* } */ case 4: - _i++; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Range }; } $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._r = _r; $f._ref = _ref; $f.f = f; $f.k = k; $f.m = m; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Map.prototype.Range = function(f) { return this.$val.Range(f); }; - Mutex.ptr.prototype.Lock = function() { - var m; - m = this; - if (m.locked) { - $panic(new $String("nosync: mutex is already locked")); - } - m.locked = true; - }; - Mutex.prototype.Lock = function() { return this.$val.Lock(); }; - Mutex.ptr.prototype.Unlock = function() { - var m; - m = this; - if (!m.locked) { - $panic(new $String("nosync: unlock of unlocked mutex")); - } - m.locked = false; - }; - Mutex.prototype.Unlock = function() { return this.$val.Unlock(); }; - WaitGroup.ptr.prototype.Add = function(delta) { - var delta, wg; - wg = this; - wg.counter = wg.counter + (delta) >> 0; - if (wg.counter < 0) { - $panic(new $String("sync: negative WaitGroup counter")); - } - }; - WaitGroup.prototype.Add = function(delta) { return this.$val.Add(delta); }; - WaitGroup.ptr.prototype.Done = function() { - var wg; - wg = this; - wg.Add(-1); - }; - WaitGroup.prototype.Done = function() { return this.$val.Done(); }; - WaitGroup.ptr.prototype.Wait = function() { - var wg; - wg = this; - if (!((wg.counter === 0))) { - $panic(new $String("sync: WaitGroup counter not zero")); - } - }; - WaitGroup.prototype.Wait = function() { return this.$val.Wait(); }; - Once.ptr.prototype.Do = function(f) { - var f, o, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; f = $f.f; o = $f.o; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - o = [o]; - o[0] = this; - if (o[0].done) { - $s = -1; return; - } - if (o[0].doing) { - $panic(new $String("nosync: Do called within f")); - } - o[0].doing = true; - $deferred.push([(function(o) { return function() { - o[0].doing = false; - o[0].done = true; - }; })(o), []]); - $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.f = f; $f.o = o; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - Once.prototype.Do = function(f) { return this.$val.Do(f); }; - Pool.ptr.prototype.Get = function() { - var _r, p, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - /* */ if (p.store.$length === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (p.store.$length === 0) { */ case 1: - /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!(p.New === $throwNilPointerError)) { */ case 3: - _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 4: - $s = -1; return $ifaceNil; - /* } */ case 2: - x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); - $s = -1; return x$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Pool.prototype.Get = function() { return this.$val.Get(); }; - Pool.ptr.prototype.Put = function(x) { - var p, x; - p = this; - if ($interfaceIsEqual(x, $ifaceNil)) { - return; - } - p.store = $append(p.store, x); - }; - Pool.prototype.Put = function(x) { return this.$val.Put(x); }; - ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [], false)}, {prop: "LoadOrStore", name: "LoadOrStore", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "Range", name: "Range", pkg: "", typ: $funcType([funcType], [], false)}]; - ptrType$1.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; - ptrType$3.methods = [{prop: "Add", name: "Add", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [], false)}, {prop: "Wait", name: "Wait", pkg: "", typ: $funcType([], [], false)}]; - ptrType$4.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType$1], [], false)}]; - ptrType$5.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}]; - Map.init("github.com/gopherjs/gopherjs/nosync", [{prop: "m", name: "m", embedded: false, exported: false, typ: mapType, tag: ""}]); - Mutex.init("github.com/gopherjs/gopherjs/nosync", [{prop: "locked", name: "locked", embedded: false, exported: false, typ: $Bool, tag: ""}]); - WaitGroup.init("github.com/gopherjs/gopherjs/nosync", [{prop: "counter", name: "counter", embedded: false, exported: false, typ: $Int, tag: ""}]); - Once.init("github.com/gopherjs/gopherjs/nosync", [{prop: "doing", name: "doing", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "done", name: "done", embedded: false, exported: false, typ: $Bool, tag: ""}]); - Pool.init("github.com/gopherjs/gopherjs/nosync", [{prop: "store", name: "store", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: funcType$2, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["time"] = (function() { - var $pkg = {}, $init, errors, js, nosync, runtime, syscall, ParseError, Time, Month, Weekday, Duration, Location, zone, zoneTrans, sliceType, sliceType$1, ptrType, sliceType$2, arrayType, sliceType$3, arrayType$1, arrayType$2, ptrType$2, arrayType$3, ptrType$4, ptrType$7, zoneSources, std0x, longDayNames, shortDayNames, shortMonthNames, longMonthNames, atoiError, errBad, errLeadingInt, months, days, daysBefore, startNano, utcLoc, utcLoc$24ptr, localLoc, localLoc$24ptr, localOnce, errLocation, badData, x, init, initLocal, runtimeNano, now, indexByte, startsWithLowerCase, nextStdChunk, match, lookup, appendInt, atoi, formatNano, quote, isDigit, getnum, cutspace, skip, Parse, parse, parseTimeZone, parseGMT, parseSignedOffset, parseNanoseconds, leadingInt, absWeekday, absClock, fmtFrac, fmtInt, lessThanHalf, Since, absDate, daysIn, Now, unixTime, Unix, isLeap, norm, Date, div, FixedZone; - errors = $packages["errors"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - runtime = $packages["runtime"]; - syscall = $packages["syscall"]; - ParseError = $pkg.ParseError = $newType(0, $kindStruct, "time.ParseError", true, "time", true, function(Layout_, Value_, LayoutElem_, ValueElem_, Message_) { - this.$val = this; - if (arguments.length === 0) { - this.Layout = ""; - this.Value = ""; - this.LayoutElem = ""; - this.ValueElem = ""; - this.Message = ""; - return; - } - this.Layout = Layout_; - this.Value = Value_; - this.LayoutElem = LayoutElem_; - this.ValueElem = ValueElem_; - this.Message = Message_; - }); - Time = $pkg.Time = $newType(0, $kindStruct, "time.Time", true, "time", true, function(wall_, ext_, loc_) { - this.$val = this; - if (arguments.length === 0) { - this.wall = new $Uint64(0, 0); - this.ext = new $Int64(0, 0); - this.loc = ptrType$2.nil; - return; - } - this.wall = wall_; - this.ext = ext_; - this.loc = loc_; - }); - Month = $pkg.Month = $newType(4, $kindInt, "time.Month", true, "time", true, null); - Weekday = $pkg.Weekday = $newType(4, $kindInt, "time.Weekday", true, "time", true, null); - Duration = $pkg.Duration = $newType(8, $kindInt64, "time.Duration", true, "time", true, null); - Location = $pkg.Location = $newType(0, $kindStruct, "time.Location", true, "time", true, function(name_, zone_, tx_, cacheStart_, cacheEnd_, cacheZone_) { - this.$val = this; - if (arguments.length === 0) { - this.name = ""; - this.zone = sliceType.nil; - this.tx = sliceType$1.nil; - this.cacheStart = new $Int64(0, 0); - this.cacheEnd = new $Int64(0, 0); - this.cacheZone = ptrType.nil; - return; - } - this.name = name_; - this.zone = zone_; - this.tx = tx_; - this.cacheStart = cacheStart_; - this.cacheEnd = cacheEnd_; - this.cacheZone = cacheZone_; - }); - zone = $pkg.zone = $newType(0, $kindStruct, "time.zone", true, "time", false, function(name_, offset_, isDST_) { - this.$val = this; - if (arguments.length === 0) { - this.name = ""; - this.offset = 0; - this.isDST = false; - return; - } - this.name = name_; - this.offset = offset_; - this.isDST = isDST_; - }); - zoneTrans = $pkg.zoneTrans = $newType(0, $kindStruct, "time.zoneTrans", true, "time", false, function(when_, index_, isstd_, isutc_) { - this.$val = this; - if (arguments.length === 0) { - this.when = new $Int64(0, 0); - this.index = 0; - this.isstd = false; - this.isutc = false; - return; - } - this.when = when_; - this.index = index_; - this.isstd = isstd_; - this.isutc = isutc_; - }); - sliceType = $sliceType(zone); - sliceType$1 = $sliceType(zoneTrans); - ptrType = $ptrType(zone); - sliceType$2 = $sliceType($String); - arrayType = $arrayType($Uint8, 20); - sliceType$3 = $sliceType($Uint8); - arrayType$1 = $arrayType($Uint8, 9); - arrayType$2 = $arrayType($Uint8, 64); - ptrType$2 = $ptrType(Location); - arrayType$3 = $arrayType($Uint8, 32); - ptrType$4 = $ptrType(ParseError); - ptrType$7 = $ptrType(Time); - init = function() { - $unused(Unix(new $Int64(0, 0), new $Int64(0, 0))); - }; - initLocal = function() { - var d, i, j, s; - d = new ($global.Date)(); - s = $internalize(d, $String); - i = indexByte(s, 40); - j = indexByte(s, 41); - if ((i === -1) || (j === -1)) { - localLoc.name = "UTC"; - return; - } - localLoc.name = $substring(s, (i + 1 >> 0), j); - localLoc.zone = new sliceType([new zone.ptr(localLoc.name, $imul(($parseInt(d.getTimezoneOffset()) >> 0), -60), false)]); - }; - runtimeNano = function() { - return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); - }; - now = function() { - var _tmp, _tmp$1, _tmp$2, mono, n, nsec, sec, x$1; - sec = new $Int64(0, 0); - nsec = 0; - mono = new $Int64(0, 0); - n = runtimeNano(); - _tmp = $div64(n, new $Int64(0, 1000000000), false); - _tmp$1 = (((x$1 = $div64(n, new $Int64(0, 1000000000), true), x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0)); - _tmp$2 = n; - sec = _tmp; - nsec = _tmp$1; - mono = _tmp$2; - return [sec, nsec, mono]; - }; - indexByte = function(s, c) { - var c, s; - return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; - }; - startsWithLowerCase = function(str) { - var c, str; - if (str.length === 0) { - return false; - } - c = str.charCodeAt(0); - return 97 <= c && c <= 122; - }; - nextStdChunk = function(layout) { - var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$51, _tmp$52, _tmp$53, _tmp$54, _tmp$55, _tmp$56, _tmp$57, _tmp$58, _tmp$59, _tmp$6, _tmp$60, _tmp$61, _tmp$62, _tmp$63, _tmp$64, _tmp$65, _tmp$66, _tmp$67, _tmp$68, _tmp$69, _tmp$7, _tmp$70, _tmp$71, _tmp$72, _tmp$73, _tmp$74, _tmp$75, _tmp$76, _tmp$77, _tmp$78, _tmp$79, _tmp$8, _tmp$80, _tmp$81, _tmp$82, _tmp$83, _tmp$84, _tmp$85, _tmp$86, _tmp$9, c, ch, i, j, layout, prefix, std, std$1, suffix, x$1; - prefix = ""; - std = 0; - suffix = ""; - i = 0; - while (true) { - if (!(i < layout.length)) { break; } - c = ((layout.charCodeAt(i) >> 0)); - _1 = c; - if (_1 === (74)) { - if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Jan") { - if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "January") { - _tmp = $substring(layout, 0, i); - _tmp$1 = 257; - _tmp$2 = $substring(layout, (i + 7 >> 0)); - prefix = _tmp; - std = _tmp$1; - suffix = _tmp$2; - return [prefix, std, suffix]; - } - if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { - _tmp$3 = $substring(layout, 0, i); - _tmp$4 = 258; - _tmp$5 = $substring(layout, (i + 3 >> 0)); - prefix = _tmp$3; - std = _tmp$4; - suffix = _tmp$5; - return [prefix, std, suffix]; - } - } - } else if (_1 === (77)) { - if (layout.length >= (i + 3 >> 0)) { - if ($substring(layout, i, (i + 3 >> 0)) === "Mon") { - if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Monday") { - _tmp$6 = $substring(layout, 0, i); - _tmp$7 = 261; - _tmp$8 = $substring(layout, (i + 6 >> 0)); - prefix = _tmp$6; - std = _tmp$7; - suffix = _tmp$8; - return [prefix, std, suffix]; - } - if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { - _tmp$9 = $substring(layout, 0, i); - _tmp$10 = 262; - _tmp$11 = $substring(layout, (i + 3 >> 0)); - prefix = _tmp$9; - std = _tmp$10; - suffix = _tmp$11; - return [prefix, std, suffix]; - } - } - if ($substring(layout, i, (i + 3 >> 0)) === "MST") { - _tmp$12 = $substring(layout, 0, i); - _tmp$13 = 21; - _tmp$14 = $substring(layout, (i + 3 >> 0)); - prefix = _tmp$12; - std = _tmp$13; - suffix = _tmp$14; - return [prefix, std, suffix]; - } - } - } else if (_1 === (48)) { - if (layout.length >= (i + 2 >> 0) && 49 <= layout.charCodeAt((i + 1 >> 0)) && layout.charCodeAt((i + 1 >> 0)) <= 54) { - _tmp$15 = $substring(layout, 0, i); - _tmp$16 = (x$1 = layout.charCodeAt((i + 1 >> 0)) - 49 << 24 >>> 24, ((x$1 < 0 || x$1 >= std0x.length) ? ($throwRuntimeError("index out of range"), undefined) : std0x[x$1])); - _tmp$17 = $substring(layout, (i + 2 >> 0)); - prefix = _tmp$15; - std = _tmp$16; - suffix = _tmp$17; - return [prefix, std, suffix]; - } - } else if (_1 === (49)) { - if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 53)) { - _tmp$18 = $substring(layout, 0, i); - _tmp$19 = 522; - _tmp$20 = $substring(layout, (i + 2 >> 0)); - prefix = _tmp$18; - std = _tmp$19; - suffix = _tmp$20; - return [prefix, std, suffix]; - } - _tmp$21 = $substring(layout, 0, i); - _tmp$22 = 259; - _tmp$23 = $substring(layout, (i + 1 >> 0)); - prefix = _tmp$21; - std = _tmp$22; - suffix = _tmp$23; - return [prefix, std, suffix]; - } else if (_1 === (50)) { - if (layout.length >= (i + 4 >> 0) && $substring(layout, i, (i + 4 >> 0)) === "2006") { - _tmp$24 = $substring(layout, 0, i); - _tmp$25 = 273; - _tmp$26 = $substring(layout, (i + 4 >> 0)); - prefix = _tmp$24; - std = _tmp$25; - suffix = _tmp$26; - return [prefix, std, suffix]; - } - _tmp$27 = $substring(layout, 0, i); - _tmp$28 = 263; - _tmp$29 = $substring(layout, (i + 1 >> 0)); - prefix = _tmp$27; - std = _tmp$28; - suffix = _tmp$29; - return [prefix, std, suffix]; - } else if (_1 === (95)) { - if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 50)) { - if (layout.length >= (i + 5 >> 0) && $substring(layout, (i + 1 >> 0), (i + 5 >> 0)) === "2006") { - _tmp$30 = $substring(layout, 0, (i + 1 >> 0)); - _tmp$31 = 273; - _tmp$32 = $substring(layout, (i + 5 >> 0)); - prefix = _tmp$30; - std = _tmp$31; - suffix = _tmp$32; - return [prefix, std, suffix]; - } - _tmp$33 = $substring(layout, 0, i); - _tmp$34 = 264; - _tmp$35 = $substring(layout, (i + 2 >> 0)); - prefix = _tmp$33; - std = _tmp$34; - suffix = _tmp$35; - return [prefix, std, suffix]; - } - } else if (_1 === (51)) { - _tmp$36 = $substring(layout, 0, i); - _tmp$37 = 523; - _tmp$38 = $substring(layout, (i + 1 >> 0)); - prefix = _tmp$36; - std = _tmp$37; - suffix = _tmp$38; - return [prefix, std, suffix]; - } else if (_1 === (52)) { - _tmp$39 = $substring(layout, 0, i); - _tmp$40 = 525; - _tmp$41 = $substring(layout, (i + 1 >> 0)); - prefix = _tmp$39; - std = _tmp$40; - suffix = _tmp$41; - return [prefix, std, suffix]; - } else if (_1 === (53)) { - _tmp$42 = $substring(layout, 0, i); - _tmp$43 = 527; - _tmp$44 = $substring(layout, (i + 1 >> 0)); - prefix = _tmp$42; - std = _tmp$43; - suffix = _tmp$44; - return [prefix, std, suffix]; - } else if (_1 === (80)) { - if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 77)) { - _tmp$45 = $substring(layout, 0, i); - _tmp$46 = 531; - _tmp$47 = $substring(layout, (i + 2 >> 0)); - prefix = _tmp$45; - std = _tmp$46; - suffix = _tmp$47; - return [prefix, std, suffix]; - } - } else if (_1 === (112)) { - if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 109)) { - _tmp$48 = $substring(layout, 0, i); - _tmp$49 = 532; - _tmp$50 = $substring(layout, (i + 2 >> 0)); - prefix = _tmp$48; - std = _tmp$49; - suffix = _tmp$50; - return [prefix, std, suffix]; - } - } else if (_1 === (45)) { - if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "-070000") { - _tmp$51 = $substring(layout, 0, i); - _tmp$52 = 28; - _tmp$53 = $substring(layout, (i + 7 >> 0)); - prefix = _tmp$51; - std = _tmp$52; - suffix = _tmp$53; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "-07:00:00") { - _tmp$54 = $substring(layout, 0, i); - _tmp$55 = 31; - _tmp$56 = $substring(layout, (i + 9 >> 0)); - prefix = _tmp$54; - std = _tmp$55; - suffix = _tmp$56; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "-0700") { - _tmp$57 = $substring(layout, 0, i); - _tmp$58 = 27; - _tmp$59 = $substring(layout, (i + 5 >> 0)); - prefix = _tmp$57; - std = _tmp$58; - suffix = _tmp$59; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "-07:00") { - _tmp$60 = $substring(layout, 0, i); - _tmp$61 = 30; - _tmp$62 = $substring(layout, (i + 6 >> 0)); - prefix = _tmp$60; - std = _tmp$61; - suffix = _tmp$62; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "-07") { - _tmp$63 = $substring(layout, 0, i); - _tmp$64 = 29; - _tmp$65 = $substring(layout, (i + 3 >> 0)); - prefix = _tmp$63; - std = _tmp$64; - suffix = _tmp$65; - return [prefix, std, suffix]; - } - } else if (_1 === (90)) { - if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "Z070000") { - _tmp$66 = $substring(layout, 0, i); - _tmp$67 = 23; - _tmp$68 = $substring(layout, (i + 7 >> 0)); - prefix = _tmp$66; - std = _tmp$67; - suffix = _tmp$68; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "Z07:00:00") { - _tmp$69 = $substring(layout, 0, i); - _tmp$70 = 26; - _tmp$71 = $substring(layout, (i + 9 >> 0)); - prefix = _tmp$69; - std = _tmp$70; - suffix = _tmp$71; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "Z0700") { - _tmp$72 = $substring(layout, 0, i); - _tmp$73 = 22; - _tmp$74 = $substring(layout, (i + 5 >> 0)); - prefix = _tmp$72; - std = _tmp$73; - suffix = _tmp$74; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Z07:00") { - _tmp$75 = $substring(layout, 0, i); - _tmp$76 = 25; - _tmp$77 = $substring(layout, (i + 6 >> 0)); - prefix = _tmp$75; - std = _tmp$76; - suffix = _tmp$77; - return [prefix, std, suffix]; - } - if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Z07") { - _tmp$78 = $substring(layout, 0, i); - _tmp$79 = 24; - _tmp$80 = $substring(layout, (i + 3 >> 0)); - prefix = _tmp$78; - std = _tmp$79; - suffix = _tmp$80; - return [prefix, std, suffix]; - } - } else if (_1 === (46)) { - if ((i + 1 >> 0) < layout.length && ((layout.charCodeAt((i + 1 >> 0)) === 48) || (layout.charCodeAt((i + 1 >> 0)) === 57))) { - ch = layout.charCodeAt((i + 1 >> 0)); - j = i + 1 >> 0; - while (true) { - if (!(j < layout.length && (layout.charCodeAt(j) === ch))) { break; } - j = j + (1) >> 0; - } - if (!isDigit(layout, j)) { - std$1 = 32; - if (layout.charCodeAt((i + 1 >> 0)) === 57) { - std$1 = 33; - } - std$1 = std$1 | ((((j - ((i + 1 >> 0)) >> 0)) << 16 >> 0)); - _tmp$81 = $substring(layout, 0, i); - _tmp$82 = std$1; - _tmp$83 = $substring(layout, j); - prefix = _tmp$81; - std = _tmp$82; - suffix = _tmp$83; - return [prefix, std, suffix]; - } - } - } - i = i + (1) >> 0; - } - _tmp$84 = layout; - _tmp$85 = 0; - _tmp$86 = ""; - prefix = _tmp$84; - std = _tmp$85; - suffix = _tmp$86; - return [prefix, std, suffix]; - }; - match = function(s1, s2) { - var c1, c2, i, s1, s2; - i = 0; - while (true) { - if (!(i < s1.length)) { break; } - c1 = s1.charCodeAt(i); - c2 = s2.charCodeAt(i); - if (!((c1 === c2))) { - c1 = (c1 | (32)) >>> 0; - c2 = (c2 | (32)) >>> 0; - if (!((c1 === c2)) || c1 < 97 || c1 > 122) { - return false; - } - } - i = i + (1) >> 0; - } - return true; - }; - lookup = function(tab, val) { - var _i, _ref, i, tab, v, val; - _ref = tab; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (val.length >= v.length && match($substring(val, 0, v.length), v)) { - return [i, $substring(val, v.length), $ifaceNil]; - } - _i++; - } - return [-1, val, errBad]; - }; - appendInt = function(b, x$1, width) { - var _q, b, buf, i, q, u, w, width, x$1; - u = ((x$1 >>> 0)); - if (x$1 < 0) { - b = $append(b, 45); - u = ((-x$1 >>> 0)); - } - buf = arrayType.zero(); - i = 20; - while (true) { - if (!(u >= 10)) { break; } - i = i - (1) >> 0; - q = (_q = u / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((48 + u >>> 0) - (q * 10 >>> 0) >>> 0) << 24 >>> 24))); - u = q; - } - i = i - (1) >> 0; - ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((48 + u >>> 0) << 24 >>> 24))); - w = 20 - i >> 0; - while (true) { - if (!(w < width)) { break; } - b = $append(b, 48); - w = w + (1) >> 0; - } - return $appendSlice(b, $subslice(new sliceType$3(buf), i)); - }; - atoi = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, neg, q, rem, s, x$1; - x$1 = 0; - err = $ifaceNil; - neg = false; - if (!(s === "") && ((s.charCodeAt(0) === 45) || (s.charCodeAt(0) === 43))) { - neg = s.charCodeAt(0) === 45; - s = $substring(s, 1); - } - _tuple = leadingInt(s); - q = _tuple[0]; - rem = _tuple[1]; - err = _tuple[2]; - x$1 = (((q.$low + ((q.$high >> 31) * 4294967296)) >> 0)); - if (!($interfaceIsEqual(err, $ifaceNil)) || !(rem === "")) { - _tmp = 0; - _tmp$1 = atoiError; - x$1 = _tmp; - err = _tmp$1; - return [x$1, err]; - } - if (neg) { - x$1 = -x$1; - } - _tmp$2 = x$1; - _tmp$3 = $ifaceNil; - x$1 = _tmp$2; - err = _tmp$3; - return [x$1, err]; - }; - formatNano = function(b, nanosec, n, trim) { - var _q, _r, b, buf, n, nanosec, start, trim, u, x$1; - u = nanosec; - buf = arrayType$1.zero(); - start = 9; - while (true) { - if (!(start > 0)) { break; } - start = start - (1) >> 0; - ((start < 0 || start >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[start] = ((((_r = u % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); - u = (_q = u / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - } - if (n > 9) { - n = 9; - } - if (trim) { - while (true) { - if (!(n > 0 && ((x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x$1])) === 48))) { break; } - n = n - (1) >> 0; - } - if (n === 0) { - return b; - } - } - b = $append(b, 46); - return $appendSlice(b, $subslice(new sliceType$3(buf), 0, n)); - }; - Time.ptr.prototype.String = function() { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, buf, m0, m1, m2, s, sign, t, wid, x$1, x$2, x$3, x$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; buf = $f.buf; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; s = $f.s; sign = $f.sign; t = $f.t; wid = $f.wid; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).Format("2006-01-02 15:04:05.999999999 -0700 MST"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - s = _r; - if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - m2 = ((x$3 = t.ext, new $Uint64(x$3.$high, x$3.$low))); - sign = 43; - if ((x$4 = t.ext, (x$4.$high < 0 || (x$4.$high === 0 && x$4.$low < 0)))) { - sign = 45; - m2 = new $Uint64(-m2.$high, -m2.$low); - } - _tmp = $div64(m2, new $Uint64(0, 1000000000), false); - _tmp$1 = $div64(m2, new $Uint64(0, 1000000000), true); - m1 = _tmp; - m2 = _tmp$1; - _tmp$2 = $div64(m1, new $Uint64(0, 1000000000), false); - _tmp$3 = $div64(m1, new $Uint64(0, 1000000000), true); - m0 = _tmp$2; - m1 = _tmp$3; - buf = sliceType$3.nil; - buf = $appendSlice(buf, " m="); - buf = $append(buf, sign); - wid = 0; - if (!((m0.$high === 0 && m0.$low === 0))) { - buf = appendInt(buf, ((m0.$low >> 0)), 0); - wid = 9; - } - buf = appendInt(buf, ((m1.$low >> 0)), wid); - buf = $append(buf, 46); - buf = appendInt(buf, ((m2.$low >> 0)), 9); - s = s + (($bytesToString(buf))); - } - $s = -1; return s; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.String }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.buf = buf; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.s = s; $f.sign = sign; $f.t = t; $f.wid = wid; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.String = function() { return this.$val.String(); }; - Time.ptr.prototype.Format = function(layout) { - var _r, b, buf, layout, max, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; buf = $f.buf; layout = $f.layout; max = $f.max; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - b = sliceType$3.nil; - max = layout.length + 10 >> 0; - if (max < 64) { - buf = arrayType$2.zero(); - b = $subslice(new sliceType$3(buf), 0, 0); - } else { - b = $makeSlice(sliceType$3, 0, max); - } - _r = $clone(t, Time).AppendFormat(b, layout); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - b = _r; - $s = -1; return ($bytesToString(b)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Format }; } $f._r = _r; $f.b = b; $f.buf = buf; $f.layout = layout; $f.max = max; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Format = function(layout) { return this.$val.Format(layout); }; - Time.ptr.prototype.AppendFormat = function(b, layout) { - var _1, _q, _q$1, _q$2, _q$3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, _tuple$2, _tuple$3, abs, absoffset, b, day, hour, hr, hr$1, layout, m, min, month, name, offset, prefix, s, sec, std, suffix, t, y, year, zone$1, zone$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; abs = $f.abs; absoffset = $f.absoffset; b = $f.b; day = $f.day; hour = $f.hour; hr = $f.hr; hr$1 = $f.hr$1; layout = $f.layout; m = $f.m; min = $f.min; month = $f.month; name = $f.name; offset = $f.offset; prefix = $f.prefix; s = $f.s; sec = $f.sec; std = $f.std; suffix = $f.suffix; t = $f.t; y = $f.y; year = $f.year; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).locabs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - name = _tuple[0]; - offset = _tuple[1]; - abs = _tuple[2]; - year = -1; - month = 0; - day = 0; - hour = -1; - min = 0; - sec = 0; - while (true) { - if (!(!(layout === ""))) { break; } - _tuple$1 = nextStdChunk(layout); - prefix = _tuple$1[0]; - std = _tuple$1[1]; - suffix = _tuple$1[2]; - if (!(prefix === "")) { - b = $appendSlice(b, prefix); - } - if (std === 0) { - break; - } - layout = suffix; - if (year < 0 && !(((std & 256) === 0))) { - _tuple$2 = absDate(abs, true); - year = _tuple$2[0]; - month = _tuple$2[1]; - day = _tuple$2[2]; - } - if (hour < 0 && !(((std & 512) === 0))) { - _tuple$3 = absClock(abs); - hour = _tuple$3[0]; - min = _tuple$3[1]; - sec = _tuple$3[2]; - } - switch (0) { default: - _1 = std & 65535; - if (_1 === (274)) { - y = year; - if (y < 0) { - y = -y; - } - b = appendInt(b, (_r$1 = y % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")), 2); - } else if (_1 === (273)) { - b = appendInt(b, year, 4); - } else if (_1 === (258)) { - b = $appendSlice(b, $substring(new Month(month).String(), 0, 3)); - } else if (_1 === (257)) { - m = new Month(month).String(); - b = $appendSlice(b, m); - } else if (_1 === (259)) { - b = appendInt(b, ((month >> 0)), 0); - } else if (_1 === (260)) { - b = appendInt(b, ((month >> 0)), 2); - } else if (_1 === (262)) { - b = $appendSlice(b, $substring(new Weekday(absWeekday(abs)).String(), 0, 3)); - } else if (_1 === (261)) { - s = new Weekday(absWeekday(abs)).String(); - b = $appendSlice(b, s); - } else if (_1 === (263)) { - b = appendInt(b, day, 0); - } else if (_1 === (264)) { - if (day < 10) { - b = $append(b, 32); - } - b = appendInt(b, day, 0); - } else if (_1 === (265)) { - b = appendInt(b, day, 2); - } else if (_1 === (522)) { - b = appendInt(b, hour, 2); - } else if (_1 === (523)) { - hr = (_r$2 = hour % 12, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")); - if (hr === 0) { - hr = 12; - } - b = appendInt(b, hr, 0); - } else if (_1 === (524)) { - hr$1 = (_r$3 = hour % 12, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); - if (hr$1 === 0) { - hr$1 = 12; - } - b = appendInt(b, hr$1, 2); - } else if (_1 === (525)) { - b = appendInt(b, min, 0); - } else if (_1 === (526)) { - b = appendInt(b, min, 2); - } else if (_1 === (527)) { - b = appendInt(b, sec, 0); - } else if (_1 === (528)) { - b = appendInt(b, sec, 2); - } else if (_1 === (531)) { - if (hour >= 12) { - b = $appendSlice(b, "PM"); - } else { - b = $appendSlice(b, "AM"); - } - } else if (_1 === (532)) { - if (hour >= 12) { - b = $appendSlice(b, "pm"); - } else { - b = $appendSlice(b, "am"); - } - } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (30)) || (_1 === (28)) || (_1 === (29)) || (_1 === (31))) { - if ((offset === 0) && ((std === 22) || (std === 25) || (std === 23) || (std === 24) || (std === 26))) { - b = $append(b, 90); - break; - } - zone$1 = (_q = offset / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - absoffset = offset; - if (zone$1 < 0) { - b = $append(b, 45); - zone$1 = -zone$1; - absoffset = -absoffset; - } else { - b = $append(b, 43); - } - b = appendInt(b, (_q$1 = zone$1 / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 2); - if ((std === 25) || (std === 30) || (std === 26) || (std === 31)) { - b = $append(b, 58); - } - if (!((std === 29)) && !((std === 24))) { - b = appendInt(b, (_r$4 = zone$1 % 60, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")), 2); - } - if ((std === 23) || (std === 28) || (std === 31) || (std === 26)) { - if ((std === 31) || (std === 26)) { - b = $append(b, 58); - } - b = appendInt(b, (_r$5 = absoffset % 60, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")), 2); - } - } else if (_1 === (21)) { - if (!(name === "")) { - b = $appendSlice(b, name); - break; - } - zone$2 = (_q$2 = offset / 60, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")); - if (zone$2 < 0) { - b = $append(b, 45); - zone$2 = -zone$2; - } else { - b = $append(b, 43); - } - b = appendInt(b, (_q$3 = zone$2 / 60, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")), 2); - b = appendInt(b, (_r$6 = zone$2 % 60, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")), 2); - } else if ((_1 === (32)) || (_1 === (33))) { - b = formatNano(b, (($clone(t, Time).Nanosecond() >>> 0)), std >> 16 >> 0, (std & 65535) === 33); - } - } - } - $s = -1; return b; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AppendFormat }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.abs = abs; $f.absoffset = absoffset; $f.b = b; $f.day = day; $f.hour = hour; $f.hr = hr; $f.hr$1 = hr$1; $f.layout = layout; $f.m = m; $f.min = min; $f.month = month; $f.name = name; $f.offset = offset; $f.prefix = prefix; $f.s = s; $f.sec = sec; $f.std = std; $f.suffix = suffix; $f.t = t; $f.y = y; $f.year = year; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.AppendFormat = function(b, layout) { return this.$val.AppendFormat(b, layout); }; - quote = function(s) { - var s; - return "\"" + s + "\""; - }; - ParseError.ptr.prototype.Error = function() { - var e; - e = this; - if (e.Message === "") { - return "parsing time " + quote(e.Value) + " as " + quote(e.Layout) + ": cannot parse " + quote(e.ValueElem) + " as " + quote(e.LayoutElem); - } - return "parsing time " + quote(e.Value) + e.Message; - }; - ParseError.prototype.Error = function() { return this.$val.Error(); }; - isDigit = function(s, i) { - var c, i, s; - if (s.length <= i) { - return false; - } - c = s.charCodeAt(i); - return 48 <= c && c <= 57; - }; - getnum = function(s, fixed) { - var fixed, s; - if (!isDigit(s, 0)) { - return [0, s, errBad]; - } - if (!isDigit(s, 1)) { - if (fixed) { - return [0, s, errBad]; - } - return [(((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), $substring(s, 1), $ifaceNil]; - } - return [($imul((((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), 10)) + (((s.charCodeAt(1) - 48 << 24 >>> 24) >> 0)) >> 0, $substring(s, 2), $ifaceNil]; - }; - cutspace = function(s) { - var s; - while (true) { - if (!(s.length > 0 && (s.charCodeAt(0) === 32))) { break; } - s = $substring(s, 1); - } - return s; - }; - skip = function(value, prefix) { - var prefix, value; - while (true) { - if (!(prefix.length > 0)) { break; } - if (prefix.charCodeAt(0) === 32) { - if (value.length > 0 && !((value.charCodeAt(0) === 32))) { - return [value, errBad]; - } - prefix = cutspace(prefix); - value = cutspace(value); - continue; - } - if ((value.length === 0) || !((value.charCodeAt(0) === prefix.charCodeAt(0)))) { - return [value, errBad]; - } - prefix = $substring(prefix, 1); - value = $substring(value, 1); - } - return [value, $ifaceNil]; - }; - Parse = function(layout, value) { - var _r, layout, value, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; layout = $f.layout; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = parse(layout, value, $pkg.UTC, $pkg.Local); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f._r = _r; $f.layout = layout; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Parse = Parse; - parse = function(layout, value, defaultLocation, local) { - var _1, _2, _3, _4, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$16, _tuple$17, _tuple$18, _tuple$19, _tuple$2, _tuple$20, _tuple$21, _tuple$22, _tuple$23, _tuple$24, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, alayout, amSet, avalue, day, defaultLocation, err, hour, hour$1, hr, i, layout, local, min, min$1, mm, month, n, n$1, name, ndigit, nsec, offset, offset$1, ok, ok$1, p, pmSet, prefix, rangeErrString, sec, seconds, sign, ss, std, stdstr, suffix, t, t$1, value, x$1, x$2, year, z, zoneName, zoneOffset, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$29 = $f._tmp$29; _tmp$3 = $f._tmp$3; _tmp$30 = $f._tmp$30; _tmp$31 = $f._tmp$31; _tmp$32 = $f._tmp$32; _tmp$33 = $f._tmp$33; _tmp$34 = $f._tmp$34; _tmp$35 = $f._tmp$35; _tmp$36 = $f._tmp$36; _tmp$37 = $f._tmp$37; _tmp$38 = $f._tmp$38; _tmp$39 = $f._tmp$39; _tmp$4 = $f._tmp$4; _tmp$40 = $f._tmp$40; _tmp$41 = $f._tmp$41; _tmp$42 = $f._tmp$42; _tmp$43 = $f._tmp$43; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$16 = $f._tuple$16; _tuple$17 = $f._tuple$17; _tuple$18 = $f._tuple$18; _tuple$19 = $f._tuple$19; _tuple$2 = $f._tuple$2; _tuple$20 = $f._tuple$20; _tuple$21 = $f._tuple$21; _tuple$22 = $f._tuple$22; _tuple$23 = $f._tuple$23; _tuple$24 = $f._tuple$24; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; alayout = $f.alayout; amSet = $f.amSet; avalue = $f.avalue; day = $f.day; defaultLocation = $f.defaultLocation; err = $f.err; hour = $f.hour; hour$1 = $f.hour$1; hr = $f.hr; i = $f.i; layout = $f.layout; local = $f.local; min = $f.min; min$1 = $f.min$1; mm = $f.mm; month = $f.month; n = $f.n; n$1 = $f.n$1; name = $f.name; ndigit = $f.ndigit; nsec = $f.nsec; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; pmSet = $f.pmSet; prefix = $f.prefix; rangeErrString = $f.rangeErrString; sec = $f.sec; seconds = $f.seconds; sign = $f.sign; ss = $f.ss; std = $f.std; stdstr = $f.stdstr; suffix = $f.suffix; t = $f.t; t$1 = $f.t$1; value = $f.value; x$1 = $f.x$1; x$2 = $f.x$2; year = $f.year; z = $f.z; zoneName = $f.zoneName; zoneOffset = $f.zoneOffset; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _tmp = layout; - _tmp$1 = value; - alayout = _tmp; - avalue = _tmp$1; - rangeErrString = ""; - amSet = false; - pmSet = false; - year = 0; - month = 1; - day = 1; - hour = 0; - min = 0; - sec = 0; - nsec = 0; - z = ptrType$2.nil; - zoneOffset = -1; - zoneName = ""; - while (true) { - err = $ifaceNil; - _tuple = nextStdChunk(layout); - prefix = _tuple[0]; - std = _tuple[1]; - suffix = _tuple[2]; - stdstr = $substring(layout, prefix.length, (layout.length - suffix.length >> 0)); - _tuple$1 = skip(value, prefix); - value = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, prefix, value, "")]; - } - if (std === 0) { - if (!((value.length === 0))) { - $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": extra text: " + value)]; - } - break; - } - layout = suffix; - p = ""; - switch (0) { default: - _1 = std & 65535; - if (_1 === (274)) { - if (value.length < 2) { - err = errBad; - break; - } - _tmp$2 = $substring(value, 0, 2); - _tmp$3 = $substring(value, 2); - p = _tmp$2; - value = _tmp$3; - _tuple$2 = atoi(p); - year = _tuple$2[0]; - err = _tuple$2[1]; - if (year >= 69) { - year = year + (1900) >> 0; - } else { - year = year + (2000) >> 0; - } - } else if (_1 === (273)) { - if (value.length < 4 || !isDigit(value, 0)) { - err = errBad; - break; - } - _tmp$4 = $substring(value, 0, 4); - _tmp$5 = $substring(value, 4); - p = _tmp$4; - value = _tmp$5; - _tuple$3 = atoi(p); - year = _tuple$3[0]; - err = _tuple$3[1]; - } else if (_1 === (258)) { - _tuple$4 = lookup(shortMonthNames, value); - month = _tuple$4[0]; - value = _tuple$4[1]; - err = _tuple$4[2]; - month = month + (1) >> 0; - } else if (_1 === (257)) { - _tuple$5 = lookup(longMonthNames, value); - month = _tuple$5[0]; - value = _tuple$5[1]; - err = _tuple$5[2]; - month = month + (1) >> 0; - } else if ((_1 === (259)) || (_1 === (260))) { - _tuple$6 = getnum(value, std === 260); - month = _tuple$6[0]; - value = _tuple$6[1]; - err = _tuple$6[2]; - if (month <= 0 || 12 < month) { - rangeErrString = "month"; - } - } else if (_1 === (262)) { - _tuple$7 = lookup(shortDayNames, value); - value = _tuple$7[1]; - err = _tuple$7[2]; - } else if (_1 === (261)) { - _tuple$8 = lookup(longDayNames, value); - value = _tuple$8[1]; - err = _tuple$8[2]; - } else if ((_1 === (263)) || (_1 === (264)) || (_1 === (265))) { - if ((std === 264) && value.length > 0 && (value.charCodeAt(0) === 32)) { - value = $substring(value, 1); - } - _tuple$9 = getnum(value, std === 265); - day = _tuple$9[0]; - value = _tuple$9[1]; - err = _tuple$9[2]; - if (day < 0) { - rangeErrString = "day"; - } - } else if (_1 === (522)) { - _tuple$10 = getnum(value, false); - hour = _tuple$10[0]; - value = _tuple$10[1]; - err = _tuple$10[2]; - if (hour < 0 || 24 <= hour) { - rangeErrString = "hour"; - } - } else if ((_1 === (523)) || (_1 === (524))) { - _tuple$11 = getnum(value, std === 524); - hour = _tuple$11[0]; - value = _tuple$11[1]; - err = _tuple$11[2]; - if (hour < 0 || 12 < hour) { - rangeErrString = "hour"; - } - } else if ((_1 === (525)) || (_1 === (526))) { - _tuple$12 = getnum(value, std === 526); - min = _tuple$12[0]; - value = _tuple$12[1]; - err = _tuple$12[2]; - if (min < 0 || 60 <= min) { - rangeErrString = "minute"; - } - } else if ((_1 === (527)) || (_1 === (528))) { - _tuple$13 = getnum(value, std === 528); - sec = _tuple$13[0]; - value = _tuple$13[1]; - err = _tuple$13[2]; - if (sec < 0 || 60 <= sec) { - rangeErrString = "second"; - break; - } - if (value.length >= 2 && (value.charCodeAt(0) === 46) && isDigit(value, 1)) { - _tuple$14 = nextStdChunk(layout); - std = _tuple$14[1]; - std = std & (65535); - if ((std === 32) || (std === 33)) { - break; - } - n = 2; - while (true) { - if (!(n < value.length && isDigit(value, n))) { break; } - n = n + (1) >> 0; - } - _tuple$15 = parseNanoseconds(value, n); - nsec = _tuple$15[0]; - rangeErrString = _tuple$15[1]; - err = _tuple$15[2]; - value = $substring(value, n); - } - } else if (_1 === (531)) { - if (value.length < 2) { - err = errBad; - break; - } - _tmp$6 = $substring(value, 0, 2); - _tmp$7 = $substring(value, 2); - p = _tmp$6; - value = _tmp$7; - _2 = p; - if (_2 === ("PM")) { - pmSet = true; - } else if (_2 === ("AM")) { - amSet = true; - } else { - err = errBad; - } - } else if (_1 === (532)) { - if (value.length < 2) { - err = errBad; - break; - } - _tmp$8 = $substring(value, 0, 2); - _tmp$9 = $substring(value, 2); - p = _tmp$8; - value = _tmp$9; - _3 = p; - if (_3 === ("pm")) { - pmSet = true; - } else if (_3 === ("am")) { - amSet = true; - } else { - err = errBad; - } - } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (29)) || (_1 === (30)) || (_1 === (28)) || (_1 === (31))) { - if (((std === 22) || (std === 24) || (std === 25)) && value.length >= 1 && (value.charCodeAt(0) === 90)) { - value = $substring(value, 1); - z = $pkg.UTC; - break; - } - _tmp$10 = ""; - _tmp$11 = ""; - _tmp$12 = ""; - _tmp$13 = ""; - sign = _tmp$10; - hour$1 = _tmp$11; - min$1 = _tmp$12; - seconds = _tmp$13; - if ((std === 25) || (std === 30)) { - if (value.length < 6) { - err = errBad; - break; - } - if (!((value.charCodeAt(3) === 58))) { - err = errBad; - break; - } - _tmp$14 = $substring(value, 0, 1); - _tmp$15 = $substring(value, 1, 3); - _tmp$16 = $substring(value, 4, 6); - _tmp$17 = "00"; - _tmp$18 = $substring(value, 6); - sign = _tmp$14; - hour$1 = _tmp$15; - min$1 = _tmp$16; - seconds = _tmp$17; - value = _tmp$18; - } else if ((std === 29) || (std === 24)) { - if (value.length < 3) { - err = errBad; - break; - } - _tmp$19 = $substring(value, 0, 1); - _tmp$20 = $substring(value, 1, 3); - _tmp$21 = "00"; - _tmp$22 = "00"; - _tmp$23 = $substring(value, 3); - sign = _tmp$19; - hour$1 = _tmp$20; - min$1 = _tmp$21; - seconds = _tmp$22; - value = _tmp$23; - } else if ((std === 26) || (std === 31)) { - if (value.length < 9) { - err = errBad; - break; - } - if (!((value.charCodeAt(3) === 58)) || !((value.charCodeAt(6) === 58))) { - err = errBad; - break; - } - _tmp$24 = $substring(value, 0, 1); - _tmp$25 = $substring(value, 1, 3); - _tmp$26 = $substring(value, 4, 6); - _tmp$27 = $substring(value, 7, 9); - _tmp$28 = $substring(value, 9); - sign = _tmp$24; - hour$1 = _tmp$25; - min$1 = _tmp$26; - seconds = _tmp$27; - value = _tmp$28; - } else if ((std === 23) || (std === 28)) { - if (value.length < 7) { - err = errBad; - break; - } - _tmp$29 = $substring(value, 0, 1); - _tmp$30 = $substring(value, 1, 3); - _tmp$31 = $substring(value, 3, 5); - _tmp$32 = $substring(value, 5, 7); - _tmp$33 = $substring(value, 7); - sign = _tmp$29; - hour$1 = _tmp$30; - min$1 = _tmp$31; - seconds = _tmp$32; - value = _tmp$33; - } else { - if (value.length < 5) { - err = errBad; - break; - } - _tmp$34 = $substring(value, 0, 1); - _tmp$35 = $substring(value, 1, 3); - _tmp$36 = $substring(value, 3, 5); - _tmp$37 = "00"; - _tmp$38 = $substring(value, 5); - sign = _tmp$34; - hour$1 = _tmp$35; - min$1 = _tmp$36; - seconds = _tmp$37; - value = _tmp$38; - } - _tmp$39 = 0; - _tmp$40 = 0; - _tmp$41 = 0; - hr = _tmp$39; - mm = _tmp$40; - ss = _tmp$41; - _tuple$16 = atoi(hour$1); - hr = _tuple$16[0]; - err = _tuple$16[1]; - if ($interfaceIsEqual(err, $ifaceNil)) { - _tuple$17 = atoi(min$1); - mm = _tuple$17[0]; - err = _tuple$17[1]; - } - if ($interfaceIsEqual(err, $ifaceNil)) { - _tuple$18 = atoi(seconds); - ss = _tuple$18[0]; - err = _tuple$18[1]; - } - zoneOffset = ($imul(((($imul(hr, 60)) + mm >> 0)), 60)) + ss >> 0; - _4 = sign.charCodeAt(0); - if (_4 === (43)) { - } else if (_4 === (45)) { - zoneOffset = -zoneOffset; - } else { - err = errBad; - } - } else if (_1 === (21)) { - if (value.length >= 3 && $substring(value, 0, 3) === "UTC") { - z = $pkg.UTC; - value = $substring(value, 3); - break; - } - _tuple$19 = parseTimeZone(value); - n$1 = _tuple$19[0]; - ok = _tuple$19[1]; - if (!ok) { - err = errBad; - break; - } - _tmp$42 = $substring(value, 0, n$1); - _tmp$43 = $substring(value, n$1); - zoneName = _tmp$42; - value = _tmp$43; - } else if (_1 === (32)) { - ndigit = 1 + ((std >> 16 >> 0)) >> 0; - if (value.length < ndigit) { - err = errBad; - break; - } - _tuple$20 = parseNanoseconds(value, ndigit); - nsec = _tuple$20[0]; - rangeErrString = _tuple$20[1]; - err = _tuple$20[2]; - value = $substring(value, ndigit); - } else if (_1 === (33)) { - if (value.length < 2 || !((value.charCodeAt(0) === 46)) || value.charCodeAt(1) < 48 || 57 < value.charCodeAt(1)) { - break; - } - i = 0; - while (true) { - if (!(i < 9 && (i + 1 >> 0) < value.length && 48 <= value.charCodeAt((i + 1 >> 0)) && value.charCodeAt((i + 1 >> 0)) <= 57)) { break; } - i = i + (1) >> 0; - } - _tuple$21 = parseNanoseconds(value, 1 + i >> 0); - nsec = _tuple$21[0]; - rangeErrString = _tuple$21[1]; - err = _tuple$21[2]; - value = $substring(value, (1 + i >> 0)); - } - } - if (!(rangeErrString === "")) { - $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range")]; - } - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, "")]; - } - } - if (pmSet && hour < 12) { - hour = hour + (12) >> 0; - } else if (amSet && (hour === 12)) { - hour = 0; - } - if (day < 1 || day > daysIn(((month >> 0)), year)) { - $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": day out of range")]; - } - /* */ if (!(z === ptrType$2.nil)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(z === ptrType$2.nil)) { */ case 1: - _r = Date(year, ((month >> 0)), day, hour, min, sec, nsec, z); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return [_r, $ifaceNil]; - /* } */ case 2: - /* */ if (!((zoneOffset === -1))) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!((zoneOffset === -1))) { */ case 4: - _r$1 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - t = $clone(_r$1, Time); - t.addSec((x$1 = (new $Int64(0, zoneOffset)), new $Int64(-x$1.$high, -x$1.$low))); - _r$2 = local.lookup(t.unixSec()); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$22 = _r$2; - name = _tuple$22[0]; - offset = _tuple$22[1]; - if ((offset === zoneOffset) && (zoneName === "" || name === zoneName)) { - t.setLoc(local); - $s = -1; return [t, $ifaceNil]; - } - t.setLoc(FixedZone(zoneName, zoneOffset)); - $s = -1; return [t, $ifaceNil]; - /* } */ case 5: - /* */ if (!(zoneName === "")) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (!(zoneName === "")) { */ case 8: - _r$3 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - t$1 = $clone(_r$3, Time); - _r$4 = local.lookupName(zoneName, t$1.unixSec()); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$23 = _r$4; - offset$1 = _tuple$23[0]; - ok$1 = _tuple$23[1]; - if (ok$1) { - t$1.addSec((x$2 = (new $Int64(0, offset$1)), new $Int64(-x$2.$high, -x$2.$low))); - t$1.setLoc(local); - $s = -1; return [t$1, $ifaceNil]; - } - if (zoneName.length > 3 && $substring(zoneName, 0, 3) === "GMT") { - _tuple$24 = atoi($substring(zoneName, 3)); - offset$1 = _tuple$24[0]; - offset$1 = $imul(offset$1, (3600)); - } - t$1.setLoc(FixedZone(zoneName, offset$1)); - $s = -1; return [t$1, $ifaceNil]; - /* } */ case 9: - _r$5 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, defaultLocation); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return [_r$5, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: parse }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$29 = _tmp$29; $f._tmp$3 = _tmp$3; $f._tmp$30 = _tmp$30; $f._tmp$31 = _tmp$31; $f._tmp$32 = _tmp$32; $f._tmp$33 = _tmp$33; $f._tmp$34 = _tmp$34; $f._tmp$35 = _tmp$35; $f._tmp$36 = _tmp$36; $f._tmp$37 = _tmp$37; $f._tmp$38 = _tmp$38; $f._tmp$39 = _tmp$39; $f._tmp$4 = _tmp$4; $f._tmp$40 = _tmp$40; $f._tmp$41 = _tmp$41; $f._tmp$42 = _tmp$42; $f._tmp$43 = _tmp$43; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$16 = _tuple$16; $f._tuple$17 = _tuple$17; $f._tuple$18 = _tuple$18; $f._tuple$19 = _tuple$19; $f._tuple$2 = _tuple$2; $f._tuple$20 = _tuple$20; $f._tuple$21 = _tuple$21; $f._tuple$22 = _tuple$22; $f._tuple$23 = _tuple$23; $f._tuple$24 = _tuple$24; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.alayout = alayout; $f.amSet = amSet; $f.avalue = avalue; $f.day = day; $f.defaultLocation = defaultLocation; $f.err = err; $f.hour = hour; $f.hour$1 = hour$1; $f.hr = hr; $f.i = i; $f.layout = layout; $f.local = local; $f.min = min; $f.min$1 = min$1; $f.mm = mm; $f.month = month; $f.n = n; $f.n$1 = n$1; $f.name = name; $f.ndigit = ndigit; $f.nsec = nsec; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.pmSet = pmSet; $f.prefix = prefix; $f.rangeErrString = rangeErrString; $f.sec = sec; $f.seconds = seconds; $f.sign = sign; $f.ss = ss; $f.std = std; $f.stdstr = stdstr; $f.suffix = suffix; $f.t = t; $f.t$1 = t$1; $f.value = value; $f.x$1 = x$1; $f.x$2 = x$2; $f.year = year; $f.z = z; $f.zoneName = zoneName; $f.zoneOffset = zoneOffset; $f.$s = $s; $f.$r = $r; return $f; - }; - parseTimeZone = function(value) { - var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c, length, nUpper, ok, ok$1, value; - length = 0; - ok = false; - if (value.length < 3) { - _tmp = 0; - _tmp$1 = false; - length = _tmp; - ok = _tmp$1; - return [length, ok]; - } - if (value.length >= 4 && ($substring(value, 0, 4) === "ChST" || $substring(value, 0, 4) === "MeST")) { - _tmp$2 = 4; - _tmp$3 = true; - length = _tmp$2; - ok = _tmp$3; - return [length, ok]; - } - if ($substring(value, 0, 3) === "GMT") { - length = parseGMT(value); - _tmp$4 = length; - _tmp$5 = true; - length = _tmp$4; - ok = _tmp$5; - return [length, ok]; - } - if ((value.charCodeAt(0) === 43) || (value.charCodeAt(0) === 45)) { - length = parseSignedOffset(value); - ok$1 = length > 0; - _tmp$6 = length; - _tmp$7 = ok$1; - length = _tmp$6; - ok = _tmp$7; - return [length, ok]; - } - nUpper = 0; - nUpper = 0; - while (true) { - if (!(nUpper < 6)) { break; } - if (nUpper >= value.length) { - break; - } - c = value.charCodeAt(nUpper); - if (c < 65 || 90 < c) { - break; - } - nUpper = nUpper + (1) >> 0; - } - _1 = nUpper; - if ((_1 === (0)) || (_1 === (1)) || (_1 === (2)) || (_1 === (6))) { - _tmp$8 = 0; - _tmp$9 = false; - length = _tmp$8; - ok = _tmp$9; - return [length, ok]; - } else if (_1 === (5)) { - if (value.charCodeAt(4) === 84) { - _tmp$10 = 5; - _tmp$11 = true; - length = _tmp$10; - ok = _tmp$11; - return [length, ok]; - } - } else if (_1 === (4)) { - if ((value.charCodeAt(3) === 84) || $substring(value, 0, 4) === "WITA") { - _tmp$12 = 4; - _tmp$13 = true; - length = _tmp$12; - ok = _tmp$13; - return [length, ok]; - } - } else if (_1 === (3)) { - _tmp$14 = 3; - _tmp$15 = true; - length = _tmp$14; - ok = _tmp$15; - return [length, ok]; - } - _tmp$16 = 0; - _tmp$17 = false; - length = _tmp$16; - ok = _tmp$17; - return [length, ok]; - }; - parseGMT = function(value) { - var value; - value = $substring(value, 3); - if (value.length === 0) { - return 3; - } - return 3 + parseSignedOffset(value) >> 0; - }; - parseSignedOffset = function(value) { - var _tuple, err, rem, sign, value, x$1; - sign = value.charCodeAt(0); - if (!((sign === 45)) && !((sign === 43))) { - return 0; - } - _tuple = leadingInt($substring(value, 1)); - x$1 = _tuple[0]; - rem = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil)) || $substring(value, 1) === rem) { - return 0; - } - if (sign === 45) { - x$1 = new $Int64(-x$1.$high, -x$1.$low); - } - if ((x$1.$high < -1 || (x$1.$high === -1 && x$1.$low < 4294967273)) || (0 < x$1.$high || (0 === x$1.$high && 23 < x$1.$low))) { - return 0; - } - return value.length - rem.length >> 0; - }; - parseNanoseconds = function(value, nbytes) { - var _tuple, err, i, nbytes, ns, rangeErrString, scaleDigits, value; - ns = 0; - rangeErrString = ""; - err = $ifaceNil; - if (!((value.charCodeAt(0) === 46))) { - err = errBad; - return [ns, rangeErrString, err]; - } - _tuple = atoi($substring(value, 1, nbytes)); - ns = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [ns, rangeErrString, err]; - } - if (ns < 0 || 1000000000 <= ns) { - rangeErrString = "fractional second"; - return [ns, rangeErrString, err]; - } - scaleDigits = 10 - nbytes >> 0; - i = 0; - while (true) { - if (!(i < scaleDigits)) { break; } - ns = $imul(ns, (10)); - i = i + (1) >> 0; - } - return [ns, rangeErrString, err]; - }; - leadingInt = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, c, err, i, rem, s, x$1, x$2, x$3, x$4; - x$1 = new $Int64(0, 0); - rem = ""; - err = $ifaceNil; - i = 0; - while (true) { - if (!(i < s.length)) { break; } - c = s.charCodeAt(i); - if (c < 48 || c > 57) { - break; - } - if ((x$1.$high > 214748364 || (x$1.$high === 214748364 && x$1.$low > 3435973836))) { - _tmp = new $Int64(0, 0); - _tmp$1 = ""; - _tmp$2 = errLeadingInt; - x$1 = _tmp; - rem = _tmp$1; - err = _tmp$2; - return [x$1, rem, err]; - } - x$1 = (x$2 = (x$3 = $mul64(x$1, new $Int64(0, 10)), x$4 = (new $Int64(0, c)), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), new $Int64(x$2.$high - 0, x$2.$low - 48)); - if ((x$1.$high < 0 || (x$1.$high === 0 && x$1.$low < 0))) { - _tmp$3 = new $Int64(0, 0); - _tmp$4 = ""; - _tmp$5 = errLeadingInt; - x$1 = _tmp$3; - rem = _tmp$4; - err = _tmp$5; - return [x$1, rem, err]; - } - i = i + (1) >> 0; - } - _tmp$6 = x$1; - _tmp$7 = $substring(s, i); - _tmp$8 = $ifaceNil; - x$1 = _tmp$6; - rem = _tmp$7; - err = _tmp$8; - return [x$1, rem, err]; - }; - Time.ptr.prototype.nsec = function() { - var t, x$1; - t = this; - return (((x$1 = t.wall, new $Uint64(x$1.$high & 0, (x$1.$low & 1073741823) >>> 0)).$low >> 0)); - }; - Time.prototype.nsec = function() { return this.$val.nsec(); }; - Time.ptr.prototype.sec = function() { - var t, x$1, x$2, x$3, x$4; - t = this; - if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - return (x$3 = ((x$4 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$4.$high, x$4.$low))), new $Int64(13 + x$3.$high, 3618733952 + x$3.$low)); - } - return t.ext; - }; - Time.prototype.sec = function() { return this.$val.sec(); }; - Time.ptr.prototype.unixSec = function() { - var t, x$1; - t = this; - return (x$1 = t.sec(), new $Int64(x$1.$high + -15, x$1.$low + 2288912640)); - }; - Time.prototype.unixSec = function() { return this.$val.unixSec(); }; - Time.ptr.prototype.addSec = function(d) { - var d, dsec, sec, t, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - t = this; - if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - sec = ((x$3 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$3.$high, x$3.$low))); - dsec = new $Int64(sec.$high + d.$high, sec.$low + d.$low); - if ((0 < dsec.$high || (0 === dsec.$high && 0 <= dsec.$low)) && (dsec.$high < 1 || (dsec.$high === 1 && dsec.$low <= 4294967295))) { - t.wall = (x$4 = (x$5 = (x$6 = t.wall, new $Uint64(x$6.$high & 0, (x$6.$low & 1073741823) >>> 0)), x$7 = $shiftLeft64((new $Uint64(dsec.$high, dsec.$low)), 30), new $Uint64(x$5.$high | x$7.$high, (x$5.$low | x$7.$low) >>> 0)), new $Uint64(x$4.$high | 2147483648, (x$4.$low | 0) >>> 0)); - return; - } - t.stripMono(); - } - t.ext = (x$8 = t.ext, x$9 = d, new $Int64(x$8.$high + x$9.$high, x$8.$low + x$9.$low)); - }; - Time.prototype.addSec = function(d) { return this.$val.addSec(d); }; - Time.ptr.prototype.setLoc = function(loc) { - var loc, t; - t = this; - if (loc === utcLoc) { - loc = ptrType$2.nil; - } - t.stripMono(); - t.loc = loc; - }; - Time.prototype.setLoc = function(loc) { return this.$val.setLoc(loc); }; - Time.ptr.prototype.stripMono = function() { - var t, x$1, x$2, x$3, x$4; - t = this; - if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - t.ext = t.sec(); - t.wall = (x$3 = t.wall, x$4 = new $Uint64(0, 1073741823), new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)); - } - }; - Time.prototype.stripMono = function() { return this.$val.stripMono(); }; - Time.ptr.prototype.After = function(u) { - var t, ts, u, us, x$1, x$2, x$3, x$4, x$5, x$6; - t = this; - if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - return (x$5 = t.ext, x$6 = u.ext, (x$5.$high > x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low))); - } - ts = t.sec(); - us = u.sec(); - return (ts.$high > us.$high || (ts.$high === us.$high && ts.$low > us.$low)) || (ts.$high === us.$high && ts.$low === us.$low) && t.nsec() > u.nsec(); - }; - Time.prototype.After = function(u) { return this.$val.After(u); }; - Time.ptr.prototype.Before = function(u) { - var t, u, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - t = this; - if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - return (x$5 = t.ext, x$6 = u.ext, (x$5.$high < x$6.$high || (x$5.$high === x$6.$high && x$5.$low < x$6.$low))); - } - return (x$7 = t.sec(), x$8 = u.sec(), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low < x$8.$low))) || (x$9 = t.sec(), x$10 = u.sec(), (x$9.$high === x$10.$high && x$9.$low === x$10.$low)) && t.nsec() < u.nsec(); - }; - Time.prototype.Before = function(u) { return this.$val.Before(u); }; - Time.ptr.prototype.Equal = function(u) { - var t, u, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; - t = this; - if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - return (x$5 = t.ext, x$6 = u.ext, (x$5.$high === x$6.$high && x$5.$low === x$6.$low)); - } - return (x$7 = t.sec(), x$8 = u.sec(), (x$7.$high === x$8.$high && x$7.$low === x$8.$low)) && (t.nsec() === u.nsec()); - }; - Time.prototype.Equal = function(u) { return this.$val.Equal(u); }; - Month.prototype.String = function() { - var buf, m, n, x$1; - m = this.$val; - if (1 <= m && m <= 12) { - return (x$1 = m - 1 >> 0, ((x$1 < 0 || x$1 >= months.length) ? ($throwRuntimeError("index out of range"), undefined) : months[x$1])); - } - buf = $makeSlice(sliceType$3, 20); - n = fmtInt(buf, (new $Uint64(0, m))); - return "%!Month(" + ($bytesToString($subslice(buf, n))) + ")"; - }; - $ptrType(Month).prototype.String = function() { return new Month(this.$get()).String(); }; - Weekday.prototype.String = function() { - var buf, d, n; - d = this.$val; - if (0 <= d && d <= 6) { - return ((d < 0 || d >= days.length) ? ($throwRuntimeError("index out of range"), undefined) : days[d]); - } - buf = $makeSlice(sliceType$3, 20); - n = fmtInt(buf, (new $Uint64(0, d))); - return "%!Weekday(" + ($bytesToString($subslice(buf, n))) + ")"; - }; - $ptrType(Weekday).prototype.String = function() { return new Weekday(this.$get()).String(); }; - Time.ptr.prototype.IsZero = function() { - var t, x$1; - t = this; - return (x$1 = t.sec(), (x$1.$high === 0 && x$1.$low === 0)) && (t.nsec() === 0); - }; - Time.prototype.IsZero = function() { return this.$val.IsZero(); }; - Time.ptr.prototype.abs = function() { - var _r, _r$1, _tuple, l, offset, sec, t, x$1, x$2, x$3, x$4, x$5, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; l = $f.l; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - l = t.loc; - /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: - _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - l = _r; - /* } */ case 2: - sec = t.unixSec(); - /* */ if (!(l === utcLoc)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!(l === utcLoc)) { */ case 4: - /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 6: - sec = (x$3 = (new $Int64(0, l.cacheZone.offset)), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low)); - $s = 8; continue; - /* } else { */ case 7: - _r$1 = l.lookup(sec); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - offset = _tuple[1]; - sec = (x$4 = (new $Int64(0, offset)), new $Int64(sec.$high + x$4.$high, sec.$low + x$4.$low)); - /* } */ case 8: - /* } */ case 5: - $s = -1; return ((x$5 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$5.$high, x$5.$low))); - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.abs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.l = l; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.abs = function() { return this.$val.abs(); }; - Time.ptr.prototype.locabs = function() { - var _r, _r$1, _tuple, abs, l, name, offset, sec, t, x$1, x$2, x$3, x$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; abs = $f.abs; l = $f.l; name = $f.name; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - name = ""; - offset = 0; - abs = new $Uint64(0, 0); - t = this; - l = t.loc; - /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: - _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - l = _r; - /* } */ case 2: - sec = t.unixSec(); - /* */ if (!(l === utcLoc)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!(l === utcLoc)) { */ case 4: - /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 7: - name = l.cacheZone.name; - offset = l.cacheZone.offset; - $s = 9; continue; - /* } else { */ case 8: - _r$1 = l.lookup(sec); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - name = _tuple[0]; - offset = _tuple[1]; - /* } */ case 9: - sec = (x$3 = (new $Int64(0, offset)), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low)); - $s = 6; continue; - /* } else { */ case 5: - name = "UTC"; - /* } */ case 6: - abs = ((x$4 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$4.$high, x$4.$low))); - $s = -1; return [name, offset, abs]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.locabs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.abs = abs; $f.l = l; $f.name = name; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.locabs = function() { return this.$val.locabs(); }; - Time.ptr.prototype.Date = function() { - var _r, _tuple, day, month, t, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; month = $f.month; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - year = 0; - month = 0; - day = 0; - t = this; - _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - year = _tuple[0]; - month = _tuple[1]; - day = _tuple[2]; - $s = -1; return [year, month, day]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Date }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.month = month; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Date = function() { return this.$val.Date(); }; - Time.ptr.prototype.Year = function() { - var _r, _tuple, t, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - year = _tuple[0]; - $s = -1; return year; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Year }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Year = function() { return this.$val.Year(); }; - Time.ptr.prototype.Month = function() { - var _r, _tuple, month, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; month = $f.month; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - month = _tuple[1]; - $s = -1; return month; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Month }; } $f._r = _r; $f._tuple = _tuple; $f.month = month; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Month = function() { return this.$val.Month(); }; - Time.ptr.prototype.Day = function() { - var _r, _tuple, day, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - day = _tuple[2]; - $s = -1; return day; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Day }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Day = function() { return this.$val.Day(); }; - Time.ptr.prototype.Weekday = function() { - var _r, _r$1, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = absWeekday(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Weekday }; } $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Weekday = function() { return this.$val.Weekday(); }; - absWeekday = function(abs) { - var _q, abs, sec; - sec = $div64((new $Uint64(abs.$high + 0, abs.$low + 86400)), new $Uint64(0, 604800), true); - return (((_q = ((sec.$low >> 0)) / 86400, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); - }; - Time.ptr.prototype.ISOWeek = function() { - var _q, _r, _r$1, _r$2, _r$3, _r$4, _tuple, day, dec31wday, jan1wday, month, t, wday, week, yday, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; day = $f.day; dec31wday = $f.dec31wday; jan1wday = $f.jan1wday; month = $f.month; t = $f.t; wday = $f.wday; week = $f.week; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - year = 0; - week = 0; - t = this; - _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - year = _tuple[0]; - month = _tuple[1]; - day = _tuple[2]; - yday = _tuple[3]; - _r$2 = $clone(t, Time).Weekday(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - wday = (_r$1 = (((_r$2 + 6 >> 0) >> 0)) % 7, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); - week = (_q = (((yday - wday >> 0) + 7 >> 0)) / 7, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - jan1wday = (_r$3 = (((wday - yday >> 0) + 371 >> 0)) % 7, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); - if (1 <= jan1wday && jan1wday <= 3) { - week = week + (1) >> 0; - } - if (week === 0) { - year = year - (1) >> 0; - week = 52; - if ((jan1wday === 4) || ((jan1wday === 5) && isLeap(year))) { - week = week + (1) >> 0; - } - } - if ((month === 12) && day >= 29 && wday < 3) { - dec31wday = (_r$4 = (((wday + 31 >> 0) - day >> 0)) % 7, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); - if (0 <= dec31wday && dec31wday <= 2) { - year = year + (1) >> 0; - week = 1; - } - } - $s = -1; return [year, week]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.ISOWeek }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.day = day; $f.dec31wday = dec31wday; $f.jan1wday = jan1wday; $f.month = month; $f.t = t; $f.wday = wday; $f.week = week; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.ISOWeek = function() { return this.$val.ISOWeek(); }; - Time.ptr.prototype.Clock = function() { - var _r, _r$1, _tuple, hour, min, sec, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; hour = $f.hour; min = $f.min; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - hour = 0; - min = 0; - sec = 0; - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = absClock(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - hour = _tuple[0]; - min = _tuple[1]; - sec = _tuple[2]; - $s = -1; return [hour, min, sec]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Clock }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.hour = hour; $f.min = min; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Clock = function() { return this.$val.Clock(); }; - absClock = function(abs) { - var _q, _q$1, abs, hour, min, sec; - hour = 0; - min = 0; - sec = 0; - sec = (($div64(abs, new $Uint64(0, 86400), true).$low >> 0)); - hour = (_q = sec / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - sec = sec - (($imul(hour, 3600))) >> 0; - min = (_q$1 = sec / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); - sec = sec - (($imul(min, 60))) >> 0; - return [hour, min, sec]; - }; - Time.ptr.prototype.Hour = function() { - var _q, _r, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (_q = (($div64(_r, new $Uint64(0, 86400), true).$low >> 0)) / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Hour }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Hour = function() { return this.$val.Hour(); }; - Time.ptr.prototype.Minute = function() { - var _q, _r, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (_q = (($div64(_r, new $Uint64(0, 3600), true).$low >> 0)) / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Minute }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Minute = function() { return this.$val.Minute(); }; - Time.ptr.prototype.Second = function() { - var _r, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (($div64(_r, new $Uint64(0, 60), true).$low >> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Second }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Second = function() { return this.$val.Second(); }; - Time.ptr.prototype.Nanosecond = function() { - var t; - t = this; - return ((t.nsec() >> 0)); - }; - Time.prototype.Nanosecond = function() { return this.$val.Nanosecond(); }; - Time.ptr.prototype.YearDay = function() { - var _r, _tuple, t, yday, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; yday = $f.yday; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - yday = _tuple[3]; - $s = -1; return yday + 1 >> 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.YearDay }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.yday = yday; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.YearDay = function() { return this.$val.YearDay(); }; - Duration.prototype.String = function() { - var _tuple, _tuple$1, buf, d, neg, prec, u, w; - d = this; - buf = arrayType$3.zero(); - w = 32; - u = (new $Uint64(d.$high, d.$low)); - neg = (d.$high < 0 || (d.$high === 0 && d.$low < 0)); - if (neg) { - u = new $Uint64(-u.$high, -u.$low); - } - if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000000))) { - prec = 0; - w = w - (1) >> 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); - w = w - (1) >> 0; - if ((u.$high === 0 && u.$low === 0)) { - return "0s"; - } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000))) { - prec = 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 110); - } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000))) { - prec = 3; - w = w - (1) >> 0; - $copyString($subslice(new sliceType$3(buf), w), "\xC2\xB5"); - } else { - prec = 6; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); - } - _tuple = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, prec); - w = _tuple[0]; - u = _tuple[1]; - w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); - } else { - w = w - (1) >> 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); - _tuple$1 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, 9); - w = _tuple$1[0]; - u = _tuple$1[1]; - w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); - u = $div64(u, (new $Uint64(0, 60)), false); - if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); - w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); - u = $div64(u, (new $Uint64(0, 60)), false); - if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 104); - w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); - } - } - } - if (neg) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); - } - return ($bytesToString($subslice(new sliceType$3(buf), w))); - }; - $ptrType(Duration).prototype.String = function() { return this.$get().String(); }; - fmtFrac = function(buf, v, prec) { - var _tmp, _tmp$1, buf, digit, i, nv, nw, prec, print, v, w; - nw = 0; - nv = new $Uint64(0, 0); - w = buf.$length; - print = false; - i = 0; - while (true) { - if (!(i < prec)) { break; } - digit = $div64(v, new $Uint64(0, 10), true); - print = print || !((digit.$high === 0 && digit.$low === 0)); - if (print) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = (((digit.$low << 24 >>> 24)) + 48 << 24 >>> 24)); - } - v = $div64(v, (new $Uint64(0, 10)), false); - i = i + (1) >> 0; - } - if (print) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); - } - _tmp = w; - _tmp$1 = v; - nw = _tmp; - nv = _tmp$1; - return [nw, nv]; - }; - fmtInt = function(buf, v) { - var buf, v, w; - w = buf.$length; - if ((v.$high === 0 && v.$low === 0)) { - w = w - (1) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); - } else { - while (true) { - if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } - w = w - (1) >> 0; - ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = ((($div64(v, new $Uint64(0, 10), true).$low << 24 >>> 24)) + 48 << 24 >>> 24)); - v = $div64(v, (new $Uint64(0, 10)), false); - } - } - return w; - }; - Duration.prototype.Nanoseconds = function() { - var d; - d = this; - return (new $Int64(d.$high, d.$low)); - }; - $ptrType(Duration).prototype.Nanoseconds = function() { return this.$get().Nanoseconds(); }; - Duration.prototype.Seconds = function() { - var d, nsec, sec; - d = this; - sec = $div64(d, new Duration(0, 1000000000), false); - nsec = $div64(d, new Duration(0, 1000000000), true); - return ($flatten64(sec)) + ($flatten64(nsec)) / 1e+09; - }; - $ptrType(Duration).prototype.Seconds = function() { return this.$get().Seconds(); }; - Duration.prototype.Minutes = function() { - var d, min, nsec; - d = this; - min = $div64(d, new Duration(13, 4165425152), false); - nsec = $div64(d, new Duration(13, 4165425152), true); - return ($flatten64(min)) + ($flatten64(nsec)) / 6e+10; - }; - $ptrType(Duration).prototype.Minutes = function() { return this.$get().Minutes(); }; - Duration.prototype.Hours = function() { - var d, hour, nsec; - d = this; - hour = $div64(d, new Duration(838, 817405952), false); - nsec = $div64(d, new Duration(838, 817405952), true); - return ($flatten64(hour)) + ($flatten64(nsec)) / 3.6e+12; - }; - $ptrType(Duration).prototype.Hours = function() { return this.$get().Hours(); }; - Duration.prototype.Truncate = function(m) { - var d, m, x$1; - d = this; - if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { - return d; - } - return (x$1 = $div64(d, m, true), new Duration(d.$high - x$1.$high, d.$low - x$1.$low)); - }; - $ptrType(Duration).prototype.Truncate = function(m) { return this.$get().Truncate(m); }; - lessThanHalf = function(x$1, y) { - var x$1, x$2, x$3, x$4, x$5, y; - return (x$2 = (x$3 = (new $Uint64(x$1.$high, x$1.$low)), x$4 = (new $Uint64(x$1.$high, x$1.$low)), new $Uint64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), x$5 = (new $Uint64(y.$high, y.$low)), (x$2.$high < x$5.$high || (x$2.$high === x$5.$high && x$2.$low < x$5.$low))); - }; - Duration.prototype.Round = function(m) { - var d, d1, d1$1, m, r, x$1, x$2; - d = this; - if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { - return d; - } - r = $div64(d, m, true); - if ((d.$high < 0 || (d.$high === 0 && d.$low < 0))) { - r = new Duration(-r.$high, -r.$low); - if (lessThanHalf(r, m)) { - return new Duration(d.$high + r.$high, d.$low + r.$low); - } - d1 = (x$1 = new Duration(d.$high - m.$high, d.$low - m.$low), new Duration(x$1.$high + r.$high, x$1.$low + r.$low)); - if ((d1.$high < d.$high || (d1.$high === d.$high && d1.$low < d.$low))) { - return d1; - } - return new Duration(-2147483648, 0); - } - if (lessThanHalf(r, m)) { - return new Duration(d.$high - r.$high, d.$low - r.$low); - } - d1$1 = (x$2 = new Duration(d.$high + m.$high, d.$low + m.$low), new Duration(x$2.$high - r.$high, x$2.$low - r.$low)); - if ((d1$1.$high > d.$high || (d1$1.$high === d.$high && d1$1.$low > d.$low))) { - return d1$1; - } - return new Duration(2147483647, 4294967295); - }; - $ptrType(Duration).prototype.Round = function(m) { return this.$get().Round(m); }; - Time.ptr.prototype.Add = function(d) { - var d, dsec, nsec, t, te, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - t = this; - dsec = ((x$1 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$1.$high, x$1.$low))); - nsec = t.nsec() + (((x$2 = $div64(d, new Duration(0, 1000000000), true), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)) >> 0; - if (nsec >= 1000000000) { - dsec = (x$3 = new $Int64(0, 1), new $Int64(dsec.$high + x$3.$high, dsec.$low + x$3.$low)); - nsec = nsec - (1000000000) >> 0; - } else if (nsec < 0) { - dsec = (x$4 = new $Int64(0, 1), new $Int64(dsec.$high - x$4.$high, dsec.$low - x$4.$low)); - nsec = nsec + (1000000000) >> 0; - } - t.wall = (x$5 = (x$6 = t.wall, new $Uint64(x$6.$high & ~0, (x$6.$low & ~1073741823) >>> 0)), x$7 = (new $Uint64(0, nsec)), new $Uint64(x$5.$high | x$7.$high, (x$5.$low | x$7.$low) >>> 0)); - t.addSec(dsec); - if (!((x$8 = (x$9 = t.wall, new $Uint64(x$9.$high & 2147483648, (x$9.$low & 0) >>> 0)), (x$8.$high === 0 && x$8.$low === 0)))) { - te = (x$10 = t.ext, x$11 = (new $Int64(d.$high, d.$low)), new $Int64(x$10.$high + x$11.$high, x$10.$low + x$11.$low)); - if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (x$12 = t.ext, (te.$high > x$12.$high || (te.$high === x$12.$high && te.$low > x$12.$low))) || (d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (x$13 = t.ext, (te.$high < x$13.$high || (te.$high === x$13.$high && te.$low < x$13.$low)))) { - t.stripMono(); - } else { - t.ext = te; - } - } - return t; - }; - Time.prototype.Add = function(d) { return this.$val.Add(d); }; - Time.ptr.prototype.Sub = function(u) { - var d, d$1, t, te, u, ue, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - t = this; - if (!((x$1 = (x$2 = (x$3 = t.wall, x$4 = u.wall, new $Uint64(x$3.$high & x$4.$high, (x$3.$low & x$4.$low) >>> 0)), new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - te = t.ext; - ue = u.ext; - d = ((x$5 = new $Int64(te.$high - ue.$high, te.$low - ue.$low), new Duration(x$5.$high, x$5.$low))); - if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (te.$high > ue.$high || (te.$high === ue.$high && te.$low > ue.$low))) { - return new Duration(2147483647, 4294967295); - } - if ((d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (te.$high < ue.$high || (te.$high === ue.$high && te.$low < ue.$low))) { - return new Duration(-2147483648, 0); - } - return d; - } - d$1 = (x$6 = $mul64(((x$7 = (x$8 = t.sec(), x$9 = u.sec(), new $Int64(x$8.$high - x$9.$high, x$8.$low - x$9.$low)), new Duration(x$7.$high, x$7.$low))), new Duration(0, 1000000000)), x$10 = (new Duration(0, (t.nsec() - u.nsec() >> 0))), new Duration(x$6.$high + x$10.$high, x$6.$low + x$10.$low)); - if ($clone($clone(u, Time).Add(d$1), Time).Equal($clone(t, Time))) { - return d$1; - } else if ($clone(t, Time).Before($clone(u, Time))) { - return new Duration(-2147483648, 0); - } else { - return new Duration(2147483647, 4294967295); - } - }; - Time.prototype.Sub = function(u) { return this.$val.Sub(u); }; - Since = function(t) { - var now$1, t, x$1, x$2, x$3; - now$1 = new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil); - if (!((x$1 = (x$2 = t.wall, new $Uint64(x$2.$high & 2147483648, (x$2.$low & 0) >>> 0)), (x$1.$high === 0 && x$1.$low === 0)))) { - Time.copy(now$1, new Time.ptr(new $Uint64(2147483648, 0), (x$3 = runtimeNano(), new $Int64(x$3.$high - startNano.$high, x$3.$low - startNano.$low)), ptrType$2.nil)); - } else { - Time.copy(now$1, Now()); - } - return $clone(now$1, Time).Sub($clone(t, Time)); - }; - $pkg.Since = Since; - Time.ptr.prototype.AddDate = function(years, months$1, days$1) { - var _r, _r$1, _r$2, _tuple, _tuple$1, day, days$1, hour, min, month, months$1, sec, t, year, years, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; day = $f.day; days$1 = $f.days$1; hour = $f.hour; min = $f.min; month = $f.month; months$1 = $f.months$1; sec = $f.sec; t = $f.t; year = $f.year; years = $f.years; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).Date(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - year = _tuple[0]; - month = _tuple[1]; - day = _tuple[2]; - _r$1 = $clone(t, Time).Clock(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - hour = _tuple$1[0]; - min = _tuple$1[1]; - sec = _tuple$1[2]; - _r$2 = Date(year + years >> 0, month + ((months$1 >> 0)) >> 0, day + days$1 >> 0, hour, min, sec, ((t.nsec() >> 0)), $clone(t, Time).Location()); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AddDate }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.day = day; $f.days$1 = days$1; $f.hour = hour; $f.min = min; $f.month = month; $f.months$1 = months$1; $f.sec = sec; $f.t = t; $f.year = year; $f.years = years; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.AddDate = function(years, months$1, days$1) { return this.$val.AddDate(years, months$1, days$1); }; - Time.ptr.prototype.date = function(full) { - var _r, _r$1, _tuple, day, full, month, t, yday, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; day = $f.day; full = $f.full; month = $f.month; t = $f.t; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - year = 0; - month = 0; - day = 0; - yday = 0; - t = this; - _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = absDate(_r, full); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - year = _tuple[0]; - month = _tuple[1]; - day = _tuple[2]; - yday = _tuple[3]; - $s = -1; return [year, month, day, yday]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.date }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.day = day; $f.full = full; $f.month = month; $f.t = t; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.date = function(full) { return this.$val.date(full); }; - absDate = function(abs, full) { - var _q, abs, begin, d, day, end, full, month, n, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, yday, year; - year = 0; - month = 0; - day = 0; - yday = 0; - d = $div64(abs, new $Uint64(0, 86400), false); - n = $div64(d, new $Uint64(0, 146097), false); - y = $mul64(new $Uint64(0, 400), n); - d = (x$1 = $mul64(new $Uint64(0, 146097), n), new $Uint64(d.$high - x$1.$high, d.$low - x$1.$low)); - n = $div64(d, new $Uint64(0, 36524), false); - n = (x$2 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$2.$high, n.$low - x$2.$low)); - y = (x$3 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high + x$3.$high, y.$low + x$3.$low)); - d = (x$4 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high - x$4.$high, d.$low - x$4.$low)); - n = $div64(d, new $Uint64(0, 1461), false); - y = (x$5 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high + x$5.$high, y.$low + x$5.$low)); - d = (x$6 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high - x$6.$high, d.$low - x$6.$low)); - n = $div64(d, new $Uint64(0, 365), false); - n = (x$7 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$7.$high, n.$low - x$7.$low)); - y = (x$8 = n, new $Uint64(y.$high + x$8.$high, y.$low + x$8.$low)); - d = (x$9 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high - x$9.$high, d.$low - x$9.$low)); - year = (((x$10 = (x$11 = (new $Int64(y.$high, y.$low)), new $Int64(x$11.$high + -69, x$11.$low + 4075721025)), x$10.$low + ((x$10.$high >> 31) * 4294967296)) >> 0)); - yday = ((d.$low >> 0)); - if (!full) { - return [year, month, day, yday]; - } - day = yday; - if (isLeap(year)) { - if (day > 59) { - day = day - (1) >> 0; - } else if ((day === 59)) { - month = 2; - day = 29; - return [year, month, day, yday]; - } - } - month = (((_q = day / 31, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); - end = (((x$12 = month + 1 >> 0, ((x$12 < 0 || x$12 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$12])) >> 0)); - begin = 0; - if (day >= end) { - month = month + (1) >> 0; - begin = end; - } else { - begin = ((((month < 0 || month >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[month]) >> 0)); - } - month = month + (1) >> 0; - day = (day - begin >> 0) + 1 >> 0; - return [year, month, day, yday]; - }; - daysIn = function(m, year) { - var m, x$1, year; - if ((m === 2) && isLeap(year)) { - return 29; - } - return (((((m < 0 || m >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[m]) - (x$1 = m - 1 >> 0, ((x$1 < 0 || x$1 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$1])) >> 0) >> 0)); - }; - Now = function() { - var _tuple, mono, nsec, sec, x$1, x$2, x$3, x$4, x$5, x$6; - _tuple = now(); - sec = _tuple[0]; - nsec = _tuple[1]; - mono = _tuple[2]; - mono = (x$1 = startNano, new $Int64(mono.$high - x$1.$high, mono.$low - x$1.$low)); - sec = (x$2 = new $Int64(0, 2682288000), new $Int64(sec.$high + x$2.$high, sec.$low + x$2.$low)); - if (!((x$3 = $shiftRightUint64((new $Uint64(sec.$high, sec.$low)), 33), (x$3.$high === 0 && x$3.$low === 0)))) { - return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 13, sec.$low + 3618733952), $pkg.Local); - } - return new Time.ptr((x$4 = (x$5 = $shiftLeft64((new $Uint64(sec.$high, sec.$low)), 30), new $Uint64(2147483648 | x$5.$high, (0 | x$5.$low) >>> 0)), x$6 = (new $Uint64(0, nsec)), new $Uint64(x$4.$high | x$6.$high, (x$4.$low | x$6.$low) >>> 0)), mono, $pkg.Local); - }; - $pkg.Now = Now; - unixTime = function(sec, nsec) { - var nsec, sec; - return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 14, sec.$low + 2006054656), $pkg.Local); - }; - Time.ptr.prototype.UTC = function() { - var t; - t = this; - t.setLoc(utcLoc); - return t; - }; - Time.prototype.UTC = function() { return this.$val.UTC(); }; - Time.ptr.prototype.Local = function() { - var t; - t = this; - t.setLoc($pkg.Local); - return t; - }; - Time.prototype.Local = function() { return this.$val.Local(); }; - Time.ptr.prototype.In = function(loc) { - var loc, t; - t = this; - if (loc === ptrType$2.nil) { - $panic(new $String("time: missing Location in call to Time.In")); - } - t.setLoc(loc); - return t; - }; - Time.prototype.In = function(loc) { return this.$val.In(loc); }; - Time.ptr.prototype.Location = function() { - var l, t; - t = this; - l = t.loc; - if (l === ptrType$2.nil) { - l = $pkg.UTC; - } - return l; - }; - Time.prototype.Location = function() { return this.$val.Location(); }; - Time.ptr.prototype.Zone = function() { - var _r, _tuple, name, offset, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; name = $f.name; offset = $f.offset; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - name = ""; - offset = 0; - t = this; - _r = t.loc.lookup(t.unixSec()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - name = _tuple[0]; - offset = _tuple[1]; - $s = -1; return [name, offset]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Zone }; } $f._r = _r; $f._tuple = _tuple; $f.name = name; $f.offset = offset; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.Zone = function() { return this.$val.Zone(); }; - Time.ptr.prototype.Unix = function() { - var t; - t = this; - return t.unixSec(); - }; - Time.prototype.Unix = function() { return this.$val.Unix(); }; - Time.ptr.prototype.UnixNano = function() { - var t, x$1, x$2; - t = this; - return (x$1 = $mul64((t.unixSec()), new $Int64(0, 1000000000)), x$2 = (new $Int64(0, t.nsec())), new $Int64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)); - }; - Time.prototype.UnixNano = function() { return this.$val.UnixNano(); }; - Time.ptr.prototype.MarshalBinary = function() { - var _q, _r, _r$1, _tuple, enc, nsec, offset, offsetMin, sec, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; enc = $f.enc; nsec = $f.nsec; offset = $f.offset; offsetMin = $f.offsetMin; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - offsetMin = 0; - /* */ if ($clone(t, Time).Location() === $pkg.UTC) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($clone(t, Time).Location() === $pkg.UTC) { */ case 1: - offsetMin = -1; - $s = 3; continue; - /* } else { */ case 2: - _r = $clone(t, Time).Zone(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - offset = _tuple[1]; - if (!(((_r$1 = offset % 60, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0))) { - $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: zone offset has fractional minute")]; - } - offset = (_q = offset / (60), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - if (offset < -32768 || (offset === -1) || offset > 32767) { - $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: unexpected zone offset")]; - } - offsetMin = ((offset << 16 >> 16)); - /* } */ case 3: - sec = t.sec(); - nsec = t.nsec(); - enc = new sliceType$3([1, (($shiftRightInt64(sec, 56).$low << 24 >>> 24)), (($shiftRightInt64(sec, 48).$low << 24 >>> 24)), (($shiftRightInt64(sec, 40).$low << 24 >>> 24)), (($shiftRightInt64(sec, 32).$low << 24 >>> 24)), (($shiftRightInt64(sec, 24).$low << 24 >>> 24)), (($shiftRightInt64(sec, 16).$low << 24 >>> 24)), (($shiftRightInt64(sec, 8).$low << 24 >>> 24)), ((sec.$low << 24 >>> 24)), (((nsec >> 24 >> 0) << 24 >>> 24)), (((nsec >> 16 >> 0) << 24 >>> 24)), (((nsec >> 8 >> 0) << 24 >>> 24)), ((nsec << 24 >>> 24)), (((offsetMin >> 8 << 16 >> 16) << 24 >>> 24)), ((offsetMin << 24 >>> 24))]); - $s = -1; return [enc, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalBinary }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.enc = enc; $f.nsec = nsec; $f.offset = offset; $f.offsetMin = offsetMin; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); }; - Time.ptr.prototype.UnmarshalBinary = function(data) { - var _r, _tuple, buf, data, localoff, nsec, offset, sec, t, x$1, x$10, x$11, x$12, x$13, x$14, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; data = $f.data; localoff = $f.localoff; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; t = $f.t; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - buf = data; - if (buf.$length === 0) { - $s = -1; return errors.New("Time.UnmarshalBinary: no data"); - } - if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { - $s = -1; return errors.New("Time.UnmarshalBinary: unsupported version"); - } - if (!((buf.$length === 15))) { - $s = -1; return errors.New("Time.UnmarshalBinary: invalid length"); - } - buf = $subslice(buf, 1); - sec = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (x$7 = (new $Int64(0, (7 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 7]))), x$8 = $shiftLeft64((new $Int64(0, (6 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 6]))), 8), new $Int64(x$7.$high | x$8.$high, (x$7.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Int64(0, (5 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 5]))), 16), new $Int64(x$6.$high | x$9.$high, (x$6.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Int64(0, (4 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 4]))), 24), new $Int64(x$5.$high | x$10.$high, (x$5.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Int64(0, (3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]))), 32), new $Int64(x$4.$high | x$11.$high, (x$4.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Int64(0, (2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]))), 40), new $Int64(x$3.$high | x$12.$high, (x$3.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Int64(0, (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]))), 48), new $Int64(x$2.$high | x$13.$high, (x$2.$low | x$13.$low) >>> 0)), x$14 = $shiftLeft64((new $Int64(0, (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]))), 56), new $Int64(x$1.$high | x$14.$high, (x$1.$low | x$14.$low) >>> 0)); - buf = $subslice(buf, 8); - nsec = (((((3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]) >> 0)) | ((((2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]) >> 0)) << 8 >> 0)) | ((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) >> 0)) << 16 >> 0)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) >> 0)) << 24 >> 0); - buf = $subslice(buf, 4); - offset = $imul(((((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) << 16 >> 16)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) << 16 >> 16)) << 8 << 16 >> 16)) >> 0)), 60); - Time.copy(t, new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil)); - t.wall = (new $Uint64(0, nsec)); - t.ext = sec; - /* */ if (offset === -60) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (offset === -60) { */ case 1: - t.setLoc(utcLoc); - $s = 3; continue; - /* } else { */ case 2: - _r = $pkg.Local.lookup(t.unixSec()); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - localoff = _tuple[1]; - if (offset === localoff) { - t.setLoc($pkg.Local); - } else { - t.setLoc(FixedZone("", offset)); - } - /* } */ case 3: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalBinary }; } $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.data = data; $f.localoff = localoff; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.UnmarshalBinary = function(data) { return this.$val.UnmarshalBinary(data); }; - Time.ptr.prototype.GobEncode = function() { - var _r, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).MarshalBinary(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobEncode }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.GobEncode = function() { return this.$val.GobEncode(); }; - Time.ptr.prototype.GobDecode = function(data) { - var _r, data, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; data = $f.data; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = t.UnmarshalBinary(data); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobDecode }; } $f._r = _r; $f.data = data; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.GobDecode = function(data) { return this.$val.GobDecode(data); }; - Time.ptr.prototype.MarshalJSON = function() { - var _r, _r$1, b, t, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - y = _r; - if (y < 0 || y >= 10000) { - $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")]; - } - b = $makeSlice(sliceType$3, 0, 37); - b = $append(b, 34); - _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - b = _r$1; - b = $append(b, 34); - $s = -1; return [b, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalJSON }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); }; - Time.ptr.prototype.UnmarshalJSON = function(data) { - var _r, _tuple, data, err, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - if (($bytesToString(data)) === "null") { - $s = -1; return $ifaceNil; - } - err = $ifaceNil; - _r = Parse("\"2006-01-02T15:04:05Z07:00\"", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - Time.copy(t, _tuple[0]); - err = _tuple[1]; - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalJSON }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.UnmarshalJSON = function(data) { return this.$val.UnmarshalJSON(data); }; - Time.ptr.prototype.MarshalText = function() { - var _r, _r$1, b, t, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - y = _r; - if (y < 0 || y >= 10000) { - $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalText: year outside of range [0,9999]")]; - } - b = $makeSlice(sliceType$3, 0, 35); - _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return [_r$1, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalText }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.MarshalText = function() { return this.$val.MarshalText(); }; - Time.ptr.prototype.UnmarshalText = function(data) { - var _r, _tuple, data, err, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - err = $ifaceNil; - _r = Parse("2006-01-02T15:04:05Z07:00", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - Time.copy(t, _tuple[0]); - err = _tuple[1]; - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalText }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Time.prototype.UnmarshalText = function(data) { return this.$val.UnmarshalText(data); }; - Unix = function(sec, nsec) { - var n, nsec, sec, x$1, x$2, x$3, x$4; - if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0)) || (nsec.$high > 0 || (nsec.$high === 0 && nsec.$low >= 1000000000))) { - n = $div64(nsec, new $Int64(0, 1000000000), false); - sec = (x$1 = n, new $Int64(sec.$high + x$1.$high, sec.$low + x$1.$low)); - nsec = (x$2 = $mul64(n, new $Int64(0, 1000000000)), new $Int64(nsec.$high - x$2.$high, nsec.$low - x$2.$low)); - if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0))) { - nsec = (x$3 = new $Int64(0, 1000000000), new $Int64(nsec.$high + x$3.$high, nsec.$low + x$3.$low)); - sec = (x$4 = new $Int64(0, 1), new $Int64(sec.$high - x$4.$high, sec.$low - x$4.$low)); - } - } - return unixTime(sec, (((nsec.$low + ((nsec.$high >> 31) * 4294967296)) >> 0))); - }; - $pkg.Unix = Unix; - isLeap = function(year) { - var _r, _r$1, _r$2, year; - return ((_r = year % 4, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0) && (!(((_r$1 = year % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0)) || ((_r$2 = year % 400, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0)); - }; - norm = function(hi, lo, base) { - var _q, _q$1, _tmp, _tmp$1, base, hi, lo, n, n$1, nhi, nlo; - nhi = 0; - nlo = 0; - if (lo < 0) { - n = (_q = ((-lo - 1 >> 0)) / base, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0; - hi = hi - (n) >> 0; - lo = lo + (($imul(n, base))) >> 0; - } - if (lo >= base) { - n$1 = (_q$1 = lo / base, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); - hi = hi + (n$1) >> 0; - lo = lo - (($imul(n$1, base))) >> 0; - } - _tmp = hi; - _tmp$1 = lo; - nhi = _tmp; - nlo = _tmp$1; - return [nhi, nlo]; - }; - Date = function(year, month, day, hour, min, sec, nsec, loc) { - var _r, _r$1, _r$2, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, abs, d, day, end, hour, loc, m, min, month, n, nsec, offset, sec, start, t, unix, utc, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; abs = $f.abs; d = $f.d; day = $f.day; end = $f.end; hour = $f.hour; loc = $f.loc; m = $f.m; min = $f.min; month = $f.month; n = $f.n; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; start = $f.start; t = $f.t; unix = $f.unix; utc = $f.utc; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (loc === ptrType$2.nil) { - $panic(new $String("time: missing Location in call to Date")); - } - m = ((month >> 0)) - 1 >> 0; - _tuple = norm(year, m, 12); - year = _tuple[0]; - m = _tuple[1]; - month = ((m >> 0)) + 1 >> 0; - _tuple$1 = norm(sec, nsec, 1000000000); - sec = _tuple$1[0]; - nsec = _tuple$1[1]; - _tuple$2 = norm(min, sec, 60); - min = _tuple$2[0]; - sec = _tuple$2[1]; - _tuple$3 = norm(hour, min, 60); - hour = _tuple$3[0]; - min = _tuple$3[1]; - _tuple$4 = norm(day, hour, 24); - day = _tuple$4[0]; - hour = _tuple$4[1]; - y = ((x$1 = (x$2 = (new $Int64(0, year)), new $Int64(x$2.$high - -69, x$2.$low - 4075721025)), new $Uint64(x$1.$high, x$1.$low))); - n = $div64(y, new $Uint64(0, 400), false); - y = (x$3 = $mul64(new $Uint64(0, 400), n), new $Uint64(y.$high - x$3.$high, y.$low - x$3.$low)); - d = $mul64(new $Uint64(0, 146097), n); - n = $div64(y, new $Uint64(0, 100), false); - y = (x$4 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high - x$4.$high, y.$low - x$4.$low)); - d = (x$5 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high + x$5.$high, d.$low + x$5.$low)); - n = $div64(y, new $Uint64(0, 4), false); - y = (x$6 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high - x$6.$high, y.$low - x$6.$low)); - d = (x$7 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high + x$7.$high, d.$low + x$7.$low)); - n = y; - d = (x$8 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high + x$8.$high, d.$low + x$8.$low)); - d = (x$9 = (new $Uint64(0, (x$10 = month - 1 >> 0, ((x$10 < 0 || x$10 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$10])))), new $Uint64(d.$high + x$9.$high, d.$low + x$9.$low)); - if (isLeap(year) && month >= 3) { - d = (x$11 = new $Uint64(0, 1), new $Uint64(d.$high + x$11.$high, d.$low + x$11.$low)); - } - d = (x$12 = (new $Uint64(0, (day - 1 >> 0))), new $Uint64(d.$high + x$12.$high, d.$low + x$12.$low)); - abs = $mul64(d, new $Uint64(0, 86400)); - abs = (x$13 = (new $Uint64(0, ((($imul(hour, 3600)) + ($imul(min, 60)) >> 0) + sec >> 0))), new $Uint64(abs.$high + x$13.$high, abs.$low + x$13.$low)); - unix = (x$14 = (new $Int64(abs.$high, abs.$low)), new $Int64(x$14.$high + -2147483647, x$14.$low + 3844486912)); - _r = loc.lookup(unix); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$5 = _r; - offset = _tuple$5[1]; - start = _tuple$5[2]; - end = _tuple$5[3]; - /* */ if (!((offset === 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((offset === 0))) { */ case 2: - utc = (x$15 = (new $Int64(0, offset)), new $Int64(unix.$high - x$15.$high, unix.$low - x$15.$low)); - /* */ if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { $s = 5; continue; } - /* */ if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { */ case 5: - _r$1 = loc.lookup(new $Int64(start.$high - 0, start.$low - 1)); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$6 = _r$1; - offset = _tuple$6[1]; - $s = 7; continue; - /* } else if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { */ case 6: - _r$2 = loc.lookup(end); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$7 = _r$2; - offset = _tuple$7[1]; - /* } */ case 7: - case 4: - unix = (x$16 = (new $Int64(0, offset)), new $Int64(unix.$high - x$16.$high, unix.$low - x$16.$low)); - /* } */ case 3: - t = $clone(unixTime(unix, ((nsec >> 0))), Time); - t.setLoc(loc); - $s = -1; return t; - /* */ } return; } if ($f === undefined) { $f = { $blk: Date }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.abs = abs; $f.d = d; $f.day = day; $f.end = end; $f.hour = hour; $f.loc = loc; $f.m = m; $f.min = min; $f.month = month; $f.n = n; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.start = start; $f.t = t; $f.unix = unix; $f.utc = utc; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Date = Date; - Time.ptr.prototype.Truncate = function(d) { - var _tuple, d, r, t; - t = this; - t.stripMono(); - if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { - return t; - } - _tuple = div($clone(t, Time), d); - r = _tuple[1]; - return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); - }; - Time.prototype.Truncate = function(d) { return this.$val.Truncate(d); }; - Time.ptr.prototype.Round = function(d) { - var _tuple, d, r, t; - t = this; - t.stripMono(); - if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { - return t; - } - _tuple = div($clone(t, Time), d); - r = _tuple[1]; - if (lessThanHalf(r, d)) { - return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); - } - return $clone(t, Time).Add(new Duration(d.$high - r.$high, d.$low - r.$low)); - }; - Time.prototype.Round = function(d) { return this.$val.Round(d); }; - div = function(t, d) { - var _q, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, d, d0, d1, d1$1, neg, nsec, qmod2, r, sec, sec$1, t, tmp, u0, u0x, u1, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - qmod2 = 0; - r = new Duration(0, 0); - neg = false; - nsec = t.nsec(); - sec = t.sec(); - if ((sec.$high < 0 || (sec.$high === 0 && sec.$low < 0))) { - neg = true; - sec = new $Int64(-sec.$high, -sec.$low); - nsec = -nsec; - if (nsec < 0) { - nsec = nsec + (1000000000) >> 0; - sec = (x$1 = new $Int64(0, 1), new $Int64(sec.$high - x$1.$high, sec.$low - x$1.$low)); - } - } - if ((d.$high < 0 || (d.$high === 0 && d.$low < 1000000000)) && (x$2 = $div64(new Duration(0, 1000000000), (new Duration(d.$high + d.$high, d.$low + d.$low)), true), (x$2.$high === 0 && x$2.$low === 0))) { - qmod2 = (((_q = nsec / (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) & 1; - r = (new Duration(0, (_r = nsec % (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), _r === _r ? _r : $throwRuntimeError("integer divide by zero")))); - } else if ((x$3 = $div64(d, new Duration(0, 1000000000), true), (x$3.$high === 0 && x$3.$low === 0))) { - d1 = ((x$4 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$4.$high, x$4.$low))); - qmod2 = (((x$5 = $div64(sec, d1, false), x$5.$low + ((x$5.$high >> 31) * 4294967296)) >> 0)) & 1; - r = (x$6 = $mul64(((x$7 = $div64(sec, d1, true), new Duration(x$7.$high, x$7.$low))), new Duration(0, 1000000000)), x$8 = (new Duration(0, nsec)), new Duration(x$6.$high + x$8.$high, x$6.$low + x$8.$low)); - } else { - sec$1 = (new $Uint64(sec.$high, sec.$low)); - tmp = $mul64(($shiftRightUint64(sec$1, 32)), new $Uint64(0, 1000000000)); - u1 = $shiftRightUint64(tmp, 32); - u0 = $shiftLeft64(tmp, 32); - tmp = $mul64((new $Uint64(sec$1.$high & 0, (sec$1.$low & 4294967295) >>> 0)), new $Uint64(0, 1000000000)); - _tmp = u0; - _tmp$1 = new $Uint64(u0.$high + tmp.$high, u0.$low + tmp.$low); - u0x = _tmp; - u0 = _tmp$1; - if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { - u1 = (x$9 = new $Uint64(0, 1), new $Uint64(u1.$high + x$9.$high, u1.$low + x$9.$low)); - } - _tmp$2 = u0; - _tmp$3 = (x$10 = (new $Uint64(0, nsec)), new $Uint64(u0.$high + x$10.$high, u0.$low + x$10.$low)); - u0x = _tmp$2; - u0 = _tmp$3; - if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { - u1 = (x$11 = new $Uint64(0, 1), new $Uint64(u1.$high + x$11.$high, u1.$low + x$11.$low)); - } - d1$1 = (new $Uint64(d.$high, d.$low)); - while (true) { - if (!(!((x$12 = $shiftRightUint64(d1$1, 63), (x$12.$high === 0 && x$12.$low === 1))))) { break; } - d1$1 = $shiftLeft64(d1$1, (1)); - } - d0 = new $Uint64(0, 0); - while (true) { - qmod2 = 0; - if ((u1.$high > d1$1.$high || (u1.$high === d1$1.$high && u1.$low > d1$1.$low)) || (u1.$high === d1$1.$high && u1.$low === d1$1.$low) && (u0.$high > d0.$high || (u0.$high === d0.$high && u0.$low >= d0.$low))) { - qmod2 = 1; - _tmp$4 = u0; - _tmp$5 = new $Uint64(u0.$high - d0.$high, u0.$low - d0.$low); - u0x = _tmp$4; - u0 = _tmp$5; - if ((u0.$high > u0x.$high || (u0.$high === u0x.$high && u0.$low > u0x.$low))) { - u1 = (x$13 = new $Uint64(0, 1), new $Uint64(u1.$high - x$13.$high, u1.$low - x$13.$low)); - } - u1 = (x$14 = d1$1, new $Uint64(u1.$high - x$14.$high, u1.$low - x$14.$low)); - } - if ((d1$1.$high === 0 && d1$1.$low === 0) && (x$15 = (new $Uint64(d.$high, d.$low)), (d0.$high === x$15.$high && d0.$low === x$15.$low))) { - break; - } - d0 = $shiftRightUint64(d0, (1)); - d0 = (x$16 = $shiftLeft64((new $Uint64(d1$1.$high & 0, (d1$1.$low & 1) >>> 0)), 63), new $Uint64(d0.$high | x$16.$high, (d0.$low | x$16.$low) >>> 0)); - d1$1 = $shiftRightUint64(d1$1, (1)); - } - r = (new Duration(u0.$high, u0.$low)); - } - if (neg && !((r.$high === 0 && r.$low === 0))) { - qmod2 = (qmod2 ^ (1)) >> 0; - r = new Duration(d.$high - r.$high, d.$low - r.$low); - } - return [qmod2, r]; - }; - Location.ptr.prototype.get = function() { - var l, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - if (l === ptrType$2.nil) { - $s = -1; return utcLoc; - } - /* */ if (l === localLoc) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (l === localLoc) { */ case 1: - $r = localOnce.Do(initLocal); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $s = -1; return l; - /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.get }; } $f.l = l; $f.$s = $s; $f.$r = $r; return $f; - }; - Location.prototype.get = function() { return this.$val.get(); }; - Location.ptr.prototype.String = function() { - var _r, l, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r.name; - /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.String }; } $f._r = _r; $f.l = l; $f.$s = $s; $f.$r = $r; return $f; - }; - Location.prototype.String = function() { return this.$val.String(); }; - FixedZone = function(name, offset) { - var l, name, offset, x$1; - l = new Location.ptr(name, new sliceType([new zone.ptr(name, offset, false)]), new sliceType$1([new zoneTrans.ptr(new $Int64(-2147483648, 0), 0, false, false)]), new $Int64(-2147483648, 0), new $Int64(2147483647, 4294967295), ptrType.nil); - l.cacheZone = (x$1 = l.zone, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); - return l; - }; - $pkg.FixedZone = FixedZone; - Location.ptr.prototype.lookup = function(sec) { - var _q, _r, end, hi, l, lim, lo, m, name, offset, sec, start, tx, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, zone$1, zone$2, zone$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; end = $f.end; hi = $f.hi; l = $f.l; lim = $f.lim; lo = $f.lo; m = $f.m; name = $f.name; offset = $f.offset; sec = $f.sec; start = $f.start; tx = $f.tx; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; zone$1 = $f.zone$1; zone$2 = $f.zone$2; zone$3 = $f.zone$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - name = ""; - offset = 0; - start = new $Int64(0, 0); - end = new $Int64(0, 0); - l = this; - _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - l = _r; - if (l.zone.$length === 0) { - name = "UTC"; - offset = 0; - start = new $Int64(-2147483648, 0); - end = new $Int64(2147483647, 4294967295); - $s = -1; return [name, offset, start, end]; - } - zone$1 = l.cacheZone; - if (!(zone$1 === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { - name = zone$1.name; - offset = zone$1.offset; - start = l.cacheStart; - end = l.cacheEnd; - $s = -1; return [name, offset, start, end]; - } - if ((l.tx.$length === 0) || (x$3 = (x$4 = l.tx, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])).when, (sec.$high < x$3.$high || (sec.$high === x$3.$high && sec.$low < x$3.$low)))) { - zone$2 = (x$5 = l.zone, x$6 = l.lookupFirstZone(), ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6])); - name = zone$2.name; - offset = zone$2.offset; - start = new $Int64(-2147483648, 0); - if (l.tx.$length > 0) { - end = (x$7 = l.tx, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])).when; - } else { - end = new $Int64(2147483647, 4294967295); - } - $s = -1; return [name, offset, start, end]; - } - tx = l.tx; - end = new $Int64(2147483647, 4294967295); - lo = 0; - hi = tx.$length; - while (true) { - if (!((hi - lo >> 0) > 1)) { break; } - m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - lim = ((m < 0 || m >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + m]).when; - if ((sec.$high < lim.$high || (sec.$high === lim.$high && sec.$low < lim.$low))) { - end = lim; - hi = m; - } else { - lo = m; - } - } - zone$3 = (x$8 = l.zone, x$9 = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).index, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])); - name = zone$3.name; - offset = zone$3.offset; - start = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).when; - $s = -1; return [name, offset, start, end]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookup }; } $f._q = _q; $f._r = _r; $f.end = end; $f.hi = hi; $f.l = l; $f.lim = lim; $f.lo = lo; $f.m = m; $f.name = name; $f.offset = offset; $f.sec = sec; $f.start = start; $f.tx = tx; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.zone$3 = zone$3; $f.$s = $s; $f.$r = $r; return $f; - }; - Location.prototype.lookup = function(sec) { return this.$val.lookup(sec); }; - Location.ptr.prototype.lookupFirstZone = function() { - var _i, _ref, l, x$1, x$2, x$3, x$4, x$5, x$6, zi, zi$1; - l = this; - if (!l.firstZoneUsed()) { - return 0; - } - if (l.tx.$length > 0 && (x$1 = l.zone, x$2 = (x$3 = l.tx, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).index, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])).isDST) { - zi = (((x$4 = l.tx, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])).index >> 0)) - 1 >> 0; - while (true) { - if (!(zi >= 0)) { break; } - if (!(x$5 = l.zone, ((zi < 0 || zi >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + zi])).isDST) { - return zi; - } - zi = zi - (1) >> 0; - } - } - _ref = l.zone; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - zi$1 = _i; - if (!(x$6 = l.zone, ((zi$1 < 0 || zi$1 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + zi$1])).isDST) { - return zi$1; - } - _i++; - } - return 0; - }; - Location.prototype.lookupFirstZone = function() { return this.$val.lookupFirstZone(); }; - Location.ptr.prototype.firstZoneUsed = function() { - var _i, _ref, l, tx; - l = this; - _ref = l.tx; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - tx = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), zoneTrans); - if (tx.index === 0) { - return true; - } - _i++; - } - return false; - }; - Location.prototype.firstZoneUsed = function() { return this.$val.firstZoneUsed(); }; - Location.ptr.prototype.lookupName = function(name, unix) { - var _i, _i$1, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, i, i$1, l, nam, name, offset, offset$1, ok, unix, x$1, x$2, x$3, zone$1, zone$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; i = $f.i; i$1 = $f.i$1; l = $f.l; nam = $f.nam; name = $f.name; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; unix = $f.unix; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - offset = 0; - ok = false; - l = this; - _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - l = _r; - _ref = l.zone; - _i = 0; - /* while (true) { */ case 2: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } - i = _i; - zone$1 = (x$1 = l.zone, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); - /* */ if (zone$1.name === name) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (zone$1.name === name) { */ case 4: - _r$1 = l.lookup((x$2 = (new $Int64(0, zone$1.offset)), new $Int64(unix.$high - x$2.$high, unix.$low - x$2.$low))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - nam = _tuple[0]; - offset$1 = _tuple[1]; - if (nam === zone$1.name) { - _tmp = offset$1; - _tmp$1 = true; - offset = _tmp; - ok = _tmp$1; - $s = -1; return [offset, ok]; - } - /* } */ case 5: - _i++; - /* } */ $s = 2; continue; case 3: - _ref$1 = l.zone; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - zone$2 = (x$3 = l.zone, ((i$1 < 0 || i$1 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i$1])); - if (zone$2.name === name) { - _tmp$2 = zone$2.offset; - _tmp$3 = true; - offset = _tmp$2; - ok = _tmp$3; - $s = -1; return [offset, ok]; - } - _i$1++; - } - $s = -1; return [offset, ok]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookupName }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.i = i; $f.i$1 = i$1; $f.l = l; $f.nam = nam; $f.name = name; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.unix = unix; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Location.prototype.lookupName = function(name, unix) { return this.$val.lookupName(name, unix); }; - ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - Time.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "AppendFormat", name: "AppendFormat", pkg: "", typ: $funcType([sliceType$3, $String], [sliceType$3], false)}, {prop: "After", name: "After", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Before", name: "Before", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "IsZero", name: "IsZero", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "abs", name: "abs", pkg: "time", typ: $funcType([], [$Uint64], false)}, {prop: "locabs", name: "locabs", pkg: "time", typ: $funcType([], [$String, $Int, $Uint64], false)}, {prop: "Date", name: "Date", pkg: "", typ: $funcType([], [$Int, Month, $Int], false)}, {prop: "Year", name: "Year", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Month", name: "Month", pkg: "", typ: $funcType([], [Month], false)}, {prop: "Day", name: "Day", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Weekday", name: "Weekday", pkg: "", typ: $funcType([], [Weekday], false)}, {prop: "ISOWeek", name: "ISOWeek", pkg: "", typ: $funcType([], [$Int, $Int], false)}, {prop: "Clock", name: "Clock", pkg: "", typ: $funcType([], [$Int, $Int, $Int], false)}, {prop: "Hour", name: "Hour", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Minute", name: "Minute", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Second", name: "Second", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Nanosecond", name: "Nanosecond", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "YearDay", name: "YearDay", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([Time], [Duration], false)}, {prop: "AddDate", name: "AddDate", pkg: "", typ: $funcType([$Int, $Int, $Int], [Time], false)}, {prop: "date", name: "date", pkg: "time", typ: $funcType([$Bool], [$Int, Month, $Int, $Int], false)}, {prop: "UTC", name: "UTC", pkg: "", typ: $funcType([], [Time], false)}, {prop: "Local", name: "Local", pkg: "", typ: $funcType([], [Time], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([ptrType$2], [Time], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$2], false)}, {prop: "Zone", name: "Zone", pkg: "", typ: $funcType([], [$String, $Int], false)}, {prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "UnixNano", name: "UnixNano", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Time], false)}]; - ptrType$7.methods = [{prop: "nsec", name: "nsec", pkg: "time", typ: $funcType([], [$Int32], false)}, {prop: "sec", name: "sec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "unixSec", name: "unixSec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "addSec", name: "addSec", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "setLoc", name: "setLoc", pkg: "time", typ: $funcType([ptrType$2], [], false)}, {prop: "stripMono", name: "stripMono", pkg: "time", typ: $funcType([], [], false)}, {prop: "setMono", name: "setMono", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "mono", name: "mono", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$3], [$error], false)}]; - Month.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - Weekday.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - Duration.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Nanoseconds", name: "Nanoseconds", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seconds", name: "Seconds", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Minutes", name: "Minutes", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Hours", name: "Hours", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Duration], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Duration], false)}]; - ptrType$2.methods = [{prop: "get", name: "get", pkg: "time", typ: $funcType([], [ptrType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "lookup", name: "lookup", pkg: "time", typ: $funcType([$Int64], [$String, $Int, $Int64, $Int64], false)}, {prop: "lookupFirstZone", name: "lookupFirstZone", pkg: "time", typ: $funcType([], [$Int], false)}, {prop: "firstZoneUsed", name: "firstZoneUsed", pkg: "time", typ: $funcType([], [$Bool], false)}, {prop: "lookupName", name: "lookupName", pkg: "time", typ: $funcType([$String, $Int64], [$Int, $Bool], false)}]; - ParseError.init("", [{prop: "Layout", name: "Layout", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Value", name: "Value", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "LayoutElem", name: "LayoutElem", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "ValueElem", name: "ValueElem", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Message", name: "Message", embedded: false, exported: true, typ: $String, tag: ""}]); - Time.init("time", [{prop: "wall", name: "wall", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "ext", name: "ext", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "loc", name: "loc", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); - Location.init("time", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "zone", name: "zone", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "tx", name: "tx", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "cacheStart", name: "cacheStart", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheEnd", name: "cacheEnd", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheZone", name: "cacheZone", embedded: false, exported: false, typ: ptrType, tag: ""}]); - zone.init("time", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "offset", name: "offset", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "isDST", name: "isDST", embedded: false, exported: false, typ: $Bool, tag: ""}]); - zoneTrans.init("time", [{prop: "when", name: "when", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: $Uint8, tag: ""}, {prop: "isstd", name: "isstd", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "isutc", name: "isutc", embedded: false, exported: false, typ: $Bool, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = nosync.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - localLoc = new Location.ptr("", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); - localOnce = new nosync.Once.ptr(false, false); - zoneSources = new sliceType$2([runtime.GOROOT() + "/lib/time/zoneinfo.zip"]); - std0x = $toNativeArray($kindInt, [260, 265, 524, 526, 528, 274]); - longDayNames = new sliceType$2(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); - shortDayNames = new sliceType$2(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]); - shortMonthNames = new sliceType$2(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]); - longMonthNames = new sliceType$2(["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); - atoiError = errors.New("time: invalid number"); - errBad = errors.New("bad value for field"); - errLeadingInt = errors.New("time: bad [0-9]*"); - months = $toNativeArray($kindString, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); - days = $toNativeArray($kindString, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); - daysBefore = $toNativeArray($kindInt32, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]); - startNano = (x = runtimeNano(), new $Int64(x.$high - 0, x.$low - 1)); - utcLoc = new Location.ptr("UTC", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); - $pkg.UTC = utcLoc; - $pkg.Local = localLoc; - errLocation = errors.New("time: invalid location name"); - badData = errors.New("malformed time zone information"); - $unused(new sliceType$2(["/usr/share/zoneinfo/", "/usr/share/lib/zoneinfo/", "/usr/lib/locale/TZ/", runtime.GOROOT() + "/lib/time/zoneinfo.zip"])); - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/poll"] = (function() { - var $pkg = {}, $init, errors, io, runtime, atomic, syscall, time, pollDesc, TimeoutError, fdMutex, FD, ptrType, chanType, sliceType, ptrType$1, ptrType$2, arrayType, sliceType$2, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, sliceType$3, ptrType$12, funcType, funcType$1, ptrType$13, ptrType$14, ptrType$15, ptrType$16, sliceType$4, ptrType$17, semWaiters, tryDupCloexec, tryDupCloexec$24ptr, runtime_Semacquire, runtime_Semrelease, errClosing, consume, fcntl, DupCloseOnExec, dupCloseOnExecOld, writev, accept; - errors = $packages["errors"]; - io = $packages["io"]; - runtime = $packages["runtime"]; - atomic = $packages["sync/atomic"]; - syscall = $packages["syscall"]; - time = $packages["time"]; - pollDesc = $pkg.pollDesc = $newType(0, $kindStruct, "poll.pollDesc", true, "internal/poll", false, function(closing_) { - this.$val = this; - if (arguments.length === 0) { - this.closing = false; - return; - } - this.closing = closing_; - }); - TimeoutError = $pkg.TimeoutError = $newType(0, $kindStruct, "poll.TimeoutError", true, "internal/poll", true, function() { - this.$val = this; - if (arguments.length === 0) { - return; - } - }); - fdMutex = $pkg.fdMutex = $newType(0, $kindStruct, "poll.fdMutex", true, "internal/poll", false, function(state_, rsema_, wsema_) { - this.$val = this; - if (arguments.length === 0) { - this.state = new $Uint64(0, 0); - this.rsema = 0; - this.wsema = 0; - return; - } - this.state = state_; - this.rsema = rsema_; - this.wsema = wsema_; - }); - FD = $pkg.FD = $newType(0, $kindStruct, "poll.FD", true, "internal/poll", true, function(fdmu_, Sysfd_, pd_, iovecs_, csema_, isBlocking_, IsStream_, ZeroReadIsEOF_, isFile_) { - this.$val = this; - if (arguments.length === 0) { - this.fdmu = new fdMutex.ptr(new $Uint64(0, 0), 0, 0); - this.Sysfd = 0; - this.pd = new pollDesc.ptr(false); - this.iovecs = ptrType$6.nil; - this.csema = 0; - this.isBlocking = 0; - this.IsStream = false; - this.ZeroReadIsEOF = false; - this.isFile = false; - return; - } - this.fdmu = fdmu_; - this.Sysfd = Sysfd_; - this.pd = pd_; - this.iovecs = iovecs_; - this.csema = csema_; - this.isBlocking = isBlocking_; - this.IsStream = IsStream_; - this.ZeroReadIsEOF = ZeroReadIsEOF_; - this.isFile = isFile_; - }); - ptrType = $ptrType($Uint32); - chanType = $chanType($Bool, false, false); - sliceType = $sliceType(chanType); - ptrType$1 = $ptrType($Uint64); - ptrType$2 = $ptrType($Int32); - arrayType = $arrayType($Uint8, 4); - sliceType$2 = $sliceType(syscall.Iovec); - ptrType$6 = $ptrType(sliceType$2); - ptrType$7 = $ptrType($Uint8); - ptrType$8 = $ptrType(FD); - ptrType$9 = $ptrType(pollDesc); - ptrType$10 = $ptrType(TimeoutError); - ptrType$11 = $ptrType(fdMutex); - sliceType$3 = $sliceType($Uint8); - ptrType$12 = $ptrType(syscall.Stat_t); - funcType = $funcType([$Uintptr], [], false); - funcType$1 = $funcType([$Uintptr], [$Bool], false); - ptrType$13 = $ptrType(syscall.Linger); - ptrType$14 = $ptrType(syscall.IPMreqn); - ptrType$15 = $ptrType(syscall.IPMreq); - ptrType$16 = $ptrType(syscall.IPv6Mreq); - sliceType$4 = $sliceType(sliceType$3); - ptrType$17 = $ptrType(sliceType$4); - pollDesc.ptr.prototype.init = function(fd) { - var fd, pd; - pd = this; - return $ifaceNil; - }; - pollDesc.prototype.init = function(fd) { return this.$val.init(fd); }; - pollDesc.ptr.prototype.close = function() { - var pd; - pd = this; - }; - pollDesc.prototype.close = function() { return this.$val.close(); }; - pollDesc.ptr.prototype.evict = function() { - var pd; - pd = this; - pd.closing = true; - }; - pollDesc.prototype.evict = function() { return this.$val.evict(); }; - pollDesc.ptr.prototype.prepare = function(mode, isFile) { - var isFile, mode, pd; - pd = this; - if (pd.closing) { - return errClosing(isFile); - } - return $ifaceNil; - }; - pollDesc.prototype.prepare = function(mode, isFile) { return this.$val.prepare(mode, isFile); }; - pollDesc.ptr.prototype.prepareRead = function(isFile) { - var isFile, pd; - pd = this; - return pd.prepare(114, isFile); - }; - pollDesc.prototype.prepareRead = function(isFile) { return this.$val.prepareRead(isFile); }; - pollDesc.ptr.prototype.prepareWrite = function(isFile) { - var isFile, pd; - pd = this; - return pd.prepare(119, isFile); - }; - pollDesc.prototype.prepareWrite = function(isFile) { return this.$val.prepareWrite(isFile); }; - pollDesc.ptr.prototype.wait = function(mode, isFile) { - var isFile, mode, pd; - pd = this; - if (pd.closing) { - return errClosing(isFile); - } - return $pkg.ErrTimeout; - }; - pollDesc.prototype.wait = function(mode, isFile) { return this.$val.wait(mode, isFile); }; - pollDesc.ptr.prototype.waitRead = function(isFile) { - var isFile, pd; - pd = this; - return pd.wait(114, isFile); - }; - pollDesc.prototype.waitRead = function(isFile) { return this.$val.waitRead(isFile); }; - pollDesc.ptr.prototype.waitWrite = function(isFile) { - var isFile, pd; - pd = this; - return pd.wait(119, isFile); - }; - pollDesc.prototype.waitWrite = function(isFile) { return this.$val.waitWrite(isFile); }; - pollDesc.ptr.prototype.pollable = function() { - return true; - }; - pollDesc.prototype.pollable = function() { return this.$val.pollable(); }; - FD.ptr.prototype.SetDeadline = function(t) { - var t; - return $ifaceNil; - }; - FD.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; - FD.ptr.prototype.SetReadDeadline = function(t) { - var t; - return $ifaceNil; - }; - FD.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; - FD.ptr.prototype.SetWriteDeadline = function(t) { - var t; - return $ifaceNil; - }; - FD.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; - runtime_Semacquire = function(s) { - var _entry, _key, _r, ch, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; _r = $f._r; ch = $f.ch; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if (s.$get() === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (s.$get() === 0) { */ case 1: - ch = new $Chan($Bool, 0); - _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: $append((_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil), ch) }; - _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r[0]; - /* } */ case 2: - s.$set(s.$get() - (1) >>> 0); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semacquire }; } $f._entry = _entry; $f._key = _key; $f._r = _r; $f.ch = ch; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - runtime_Semrelease = function(s) { - var _entry, _key, ch, s, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; ch = $f.ch; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s.$set(s.$get() + (1) >>> 0); - w = (_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil); - if (w.$length === 0) { - $s = -1; return; - } - ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); - w = $subslice(w, 1); - _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: w }; - if (w.$length === 0) { - delete semWaiters[ptrType.keyFor(s)]; - } - $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._key = _key; $f.ch = ch; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - errClosing = function(isFile) { - var isFile; - if (isFile) { - return $pkg.ErrFileClosing; - } - return $pkg.ErrNetClosing; - }; - TimeoutError.ptr.prototype.Error = function() { - var e; - e = this; - return "i/o timeout"; - }; - TimeoutError.prototype.Error = function() { return this.$val.Error(); }; - TimeoutError.ptr.prototype.Timeout = function() { - var e; - e = this; - return true; - }; - TimeoutError.prototype.Timeout = function() { return this.$val.Timeout(); }; - TimeoutError.ptr.prototype.Temporary = function() { - var e; - e = this; - return true; - }; - TimeoutError.prototype.Temporary = function() { return this.$val.Temporary(); }; - consume = function(v, n) { - var ln0, n, v, x, x$1, x$2, x$3; - while (true) { - if (!(v.$get().$length > 0)) { break; } - ln0 = (new $Int64(0, (x = v.$get(), (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])).$length)); - if ((ln0.$high > n.$high || (ln0.$high === n.$high && ln0.$low > n.$low))) { - (x$2 = v.$get(), (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0] = $subslice((x$1 = v.$get(), (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])), $flatten64(n)))); - return; - } - n = (x$3 = ln0, new $Int64(n.$high - x$3.$high, n.$low - x$3.$low)); - v.$set($subslice((v.$get()), 1)); - } - }; - FD.ptr.prototype.Fsync = function() { - var err, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Fsync(fd.Sysfd); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fsync }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Fsync = function() { return this.$val.Fsync(); }; - fcntl = function(fd, cmd, arg) { - var _tuple, arg, cmd, e, fd, r; - _tuple = syscall.Syscall(72, ((fd >>> 0)), ((cmd >>> 0)), ((arg >>> 0))); - r = _tuple[0]; - e = _tuple[2]; - if (!((e === 0))) { - return [((r >> 0)), new syscall.Errno((e))]; - } - return [((r >> 0)), $ifaceNil]; - }; - fdMutex.ptr.prototype.incref = function() { - var mu, new$1, old, x, x$1; - mu = this; - while (true) { - old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); - if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { - return false; - } - new$1 = new $Uint64(old.$high + 0, old.$low + 8); - if ((x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { - $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); - } - if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { - return true; - } - } - }; - fdMutex.prototype.incref = function() { return this.$val.incref(); }; - fdMutex.ptr.prototype.increfAndClose = function() { - var mu, new$1, old, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; mu = $f.mu; new$1 = $f.new$1; old = $f.old; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - mu = this; - /* while (true) { */ case 1: - old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); - if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { - $s = -1; return false; - } - new$1 = (x$1 = new $Uint64(old.$high | 0, (old.$low | 1) >>> 0), new $Uint64(x$1.$high + 0, x$1.$low + 8)); - if ((x$2 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$2.$high === 0 && x$2.$low === 0))) { - $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); - } - new$1 = (x$3 = new $Uint64(2147483647, 4286578688), new $Uint64(new$1.$high & ~x$3.$high, (new$1.$low & ~x$3.$low) >>> 0)); - /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: - /* while (true) { */ case 5: - /* if (!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { break; } */ if(!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { $s = 6; continue; } - old = (x$5 = new $Uint64(0, 8388608), new $Uint64(old.$high - x$5.$high, old.$low - x$5.$low)); - $r = runtime_Semrelease((mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ $s = 5; continue; case 6: - /* while (true) { */ case 8: - /* if (!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { break; } */ if(!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { $s = 9; continue; } - old = (x$7 = new $Uint64(2048, 0), new $Uint64(old.$high - x$7.$high, old.$low - x$7.$low)); - $r = runtime_Semrelease((mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu)))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ $s = 8; continue; case 9: - $s = -1; return true; - /* } */ case 4: - /* } */ $s = 1; continue; case 2: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.increfAndClose }; } $f.mu = mu; $f.new$1 = new$1; $f.old = old; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; - }; - fdMutex.prototype.increfAndClose = function() { return this.$val.increfAndClose(); }; - fdMutex.ptr.prototype.decref = function() { - var mu, new$1, old, x, x$1; - mu = this; - while (true) { - old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); - if ((x = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x.$high === 0 && x.$low === 0))) { - $panic(new $String("inconsistent poll.fdMutex")); - } - new$1 = new $Uint64(old.$high - 0, old.$low - 8); - if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { - return (x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$1.$high === 0 && x$1.$low === 1)); - } - } - }; - fdMutex.prototype.decref = function() { return this.$val.decref(); }; - fdMutex.ptr.prototype.rwlock = function(read) { - var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - mu = this; - _tmp = new $Uint64(0, 0); - _tmp$1 = new $Uint64(0, 0); - _tmp$2 = new $Uint64(0, 0); - mutexBit = _tmp; - mutexWait = _tmp$1; - mutexMask = _tmp$2; - mutexSema = ptrType.nil; - if (read) { - mutexBit = new $Uint64(0, 2); - mutexWait = new $Uint64(0, 8388608); - mutexMask = new $Uint64(2047, 4286578688); - mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); - } else { - mutexBit = new $Uint64(0, 4); - mutexWait = new $Uint64(2048, 0); - mutexMask = new $Uint64(2147481600, 0); - mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); - } - /* while (true) { */ case 1: - old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); - if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { - $s = -1; return false; - } - new$1 = new $Uint64(0, 0); - if ((x$1 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { - new$1 = (x$2 = new $Uint64(old.$high | mutexBit.$high, (old.$low | mutexBit.$low) >>> 0), new $Uint64(x$2.$high + 0, x$2.$low + 8)); - if ((x$3 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$3.$high === 0 && x$3.$low === 0))) { - $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); - } - } else { - new$1 = new $Uint64(old.$high + mutexWait.$high, old.$low + mutexWait.$low); - if ((x$4 = new $Uint64(new$1.$high & mutexMask.$high, (new$1.$low & mutexMask.$low) >>> 0), (x$4.$high === 0 && x$4.$low === 0))) { - $panic(new $String("too many concurrent operations on a single file or socket (max 1048575)")); - } - } - /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: - if ((x$5 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0))) { - $s = -1; return true; - } - $r = runtime_Semacquire(mutexSema); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 4: - /* } */ $s = 1; continue; case 2: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; - }; - fdMutex.prototype.rwlock = function(read) { return this.$val.rwlock(read); }; - fdMutex.ptr.prototype.rwunlock = function(read) { - var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, x$6, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - mu = this; - _tmp = new $Uint64(0, 0); - _tmp$1 = new $Uint64(0, 0); - _tmp$2 = new $Uint64(0, 0); - mutexBit = _tmp; - mutexWait = _tmp$1; - mutexMask = _tmp$2; - mutexSema = ptrType.nil; - if (read) { - mutexBit = new $Uint64(0, 2); - mutexWait = new $Uint64(0, 8388608); - mutexMask = new $Uint64(2047, 4286578688); - mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); - } else { - mutexBit = new $Uint64(0, 4); - mutexWait = new $Uint64(2048, 0); - mutexMask = new $Uint64(2147481600, 0); - mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); - } - /* while (true) { */ case 1: - old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); - if ((x = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x.$high === 0 && x.$low === 0)) || (x$1 = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { - $panic(new $String("inconsistent poll.fdMutex")); - } - new$1 = (x$2 = new $Uint64(old.$high & ~mutexBit.$high, (old.$low & ~mutexBit.$low) >>> 0), new $Uint64(x$2.$high - 0, x$2.$low - 8)); - if (!((x$3 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$3.$high === 0 && x$3.$low === 0)))) { - new$1 = (x$4 = mutexWait, new $Uint64(new$1.$high - x$4.$high, new$1.$low - x$4.$low)); - } - /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: - /* */ if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { */ case 5: - $r = runtime_Semrelease(mutexSema); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 6: - $s = -1; return (x$6 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$6.$high === 0 && x$6.$low === 1)); - /* } */ case 4: - /* } */ $s = 1; continue; case 2: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwunlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.$s = $s; $f.$r = $r; return $f; - }; - fdMutex.prototype.rwunlock = function(read) { return this.$val.rwunlock(read); }; - FD.ptr.prototype.incref = function() { - var fd; - fd = this; - if (!fd.fdmu.incref()) { - return errClosing(fd.isFile); - } - return $ifaceNil; - }; - FD.prototype.incref = function() { return this.$val.incref(); }; - FD.ptr.prototype.decref = function() { - var _r, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - /* */ if (fd.fdmu.decref()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (fd.fdmu.decref()) { */ case 1: - _r = fd.destroy(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 2: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.decref }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.decref = function() { return this.$val.decref(); }; - FD.ptr.prototype.readLock = function() { - var _r, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - _r = fd.fdmu.rwlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!_r) { */ case 1: - $s = -1; return errClosing(fd.isFile); - /* } */ case 2: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.readLock = function() { return this.$val.readLock(); }; - FD.ptr.prototype.readUnlock = function() { - var _r, _r$1, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - _r = fd.fdmu.rwunlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r) { */ case 1: - _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - /* } */ case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.readUnlock = function() { return this.$val.readUnlock(); }; - FD.ptr.prototype.writeLock = function() { - var _r, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - _r = fd.fdmu.rwlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!_r) { */ case 1: - $s = -1; return errClosing(fd.isFile); - /* } */ case 2: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.writeLock = function() { return this.$val.writeLock(); }; - FD.ptr.prototype.writeUnlock = function() { - var _r, _r$1, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - _r = fd.fdmu.rwunlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r) { */ case 1: - _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - /* } */ case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.writeUnlock = function() { return this.$val.writeUnlock(); }; - FD.ptr.prototype.eofError = function(n, err) { - var err, fd, n; - fd = this; - if ((n === 0) && $interfaceIsEqual(err, $ifaceNil) && fd.ZeroReadIsEOF) { - return io.EOF; - } - return err; - }; - FD.prototype.eofError = function(n, err) { return this.$val.eofError(n, err); }; - FD.ptr.prototype.Fchmod = function(mode) { - var err, fd, mode, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; mode = $f.mode; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Fchmod(fd.Sysfd, mode); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchmod }; } $f.err = err; $f.fd = fd; $f.mode = mode; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Fchmod = function(mode) { return this.$val.Fchmod(mode); }; - FD.ptr.prototype.Fchown = function(uid, gid) { - var err, fd, gid, uid, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; gid = $f.gid; uid = $f.uid; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Fchown(fd.Sysfd, uid, gid); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchown }; } $f.err = err; $f.fd = fd; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Fchown = function(uid, gid) { return this.$val.Fchown(uid, gid); }; - FD.ptr.prototype.Ftruncate = function(size) { - var err, fd, size, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; size = $f.size; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Ftruncate(fd.Sysfd, size); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Ftruncate }; } $f.err = err; $f.fd = fd; $f.size = size; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Ftruncate = function(size) { return this.$val.Ftruncate(size); }; - FD.ptr.prototype.Init = function(net, pollable) { - var err, fd, net, pollable; - fd = this; - if (net === "file") { - fd.isFile = true; - } - if (!pollable) { - fd.isBlocking = 1; - return $ifaceNil; - } - err = fd.pd.init(fd); - if (!($interfaceIsEqual(err, $ifaceNil))) { - fd.isBlocking = 1; - } - return err; - }; - FD.prototype.Init = function(net, pollable) { return this.$val.Init(net, pollable); }; - FD.ptr.prototype.destroy = function() { - var _r, err, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - fd.pd.close(); - _r = $pkg.CloseFunc(fd.Sysfd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - fd.Sysfd = -1; - $r = runtime_Semrelease((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.destroy }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.destroy = function() { return this.$val.destroy(); }; - FD.ptr.prototype.Close = function() { - var _r, _r$1, err, fd, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - _r = fd.fdmu.increfAndClose(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!_r) { */ case 1: - $s = -1; return errClosing(fd.isFile); - /* } */ case 2: - fd.pd.evict(); - _r$1 = fd.decref(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - err = _r$1; - /* */ if (fd.isBlocking === 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (fd.isBlocking === 0) { */ case 5: - $r = runtime_Semacquire((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 6: - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Close }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.Close = function() { return this.$val.Close(); }; - FD.ptr.prototype.Shutdown = function(how) { - var err, fd, how, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; how = $f.how; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Shutdown(fd.Sysfd, how); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Shutdown }; } $f.err = err; $f.fd = fd; $f.how = how; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Shutdown = function(how) { return this.$val.Shutdown(how); }; - FD.ptr.prototype.SetBlocking = function() { - var err, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - atomic.StoreUint32((fd.$ptr_isBlocking || (fd.$ptr_isBlocking = new ptrType(function() { return this.$target.isBlocking; }, function($v) { this.$target.isBlocking = $v; }, fd))), 1); - $s = -1; return syscall.SetNonblock(fd.Sysfd, false); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetBlocking }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetBlocking = function() { return this.$val.SetBlocking(); }; - FD.ptr.prototype.Read = function(p) { - var _r, _tuple, err, err$1, err$2, fd, n, p, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "readUnlock"), []]); - if (p.$length === 0) { - $s = -1; return [0, $ifaceNil]; - } - err$1 = fd.pd.prepareRead(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, err$1]; - } - if (fd.IsStream && p.$length > 1073741824) { - p = $subslice(p, 0, 1073741824); - } - while (true) { - _tuple = syscall.Read(fd.Sysfd, p); - n = _tuple[0]; - err$2 = _tuple[1]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - n = 0; - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitRead(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - continue; - } - } - if (false && $interfaceIsEqual(err$2, new syscall.Errno(4))) { - continue; - } - } - err$2 = fd.eofError(n, err$2); - $s = -1; return [n, err$2]; - } - $s = -1; return [0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Read }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Read = function(p) { return this.$val.Read(p); }; - FD.ptr.prototype.Pread = function(p, off) { - var _r, _tuple, err, err$1, fd, n, off, p, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; off = $f.off; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - if (fd.IsStream && p.$length > 1073741824) { - p = $subslice(p, 0, 1073741824); - } - _tuple = syscall.Pread(fd.Sysfd, p, off); - n = _tuple[0]; - err$1 = _tuple[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - n = 0; - } - _r = fd.decref(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - err$1 = fd.eofError(n, err$1); - $s = -1; return [n, err$1]; - /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pread }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.off = off; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.prototype.Pread = function(p, off) { return this.$val.Pread(p, off); }; - FD.ptr.prototype.ReadFrom = function(p) { - var _r, _tuple, err, err$1, err$2, fd, n, p, sa, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, $ifaceNil, err]; - } - $deferred.push([$methodVal(fd, "readUnlock"), []]); - err$1 = fd.pd.prepareRead(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, $ifaceNil, err$1]; - } - while (true) { - _tuple = syscall.Recvfrom(fd.Sysfd, p, 0); - n = _tuple[0]; - sa = _tuple[1]; - err$2 = _tuple[2]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - n = 0; - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitRead(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - continue; - } - } - } - err$2 = fd.eofError(n, err$2); - $s = -1; return [n, sa, err$2]; - } - $s = -1; return [0, $ifaceNil, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadFrom }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.ReadFrom = function(p) { return this.$val.ReadFrom(p); }; - FD.ptr.prototype.ReadMsg = function(p, oob) { - var _r, _tuple, err, err$1, err$2, fd, flags, n, oob, oobn, p, sa, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; flags = $f.flags; n = $f.n; oob = $f.oob; oobn = $f.oobn; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, 0, 0, $ifaceNil, err]; - } - $deferred.push([$methodVal(fd, "readUnlock"), []]); - err$1 = fd.pd.prepareRead(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, 0, 0, $ifaceNil, err$1]; - } - while (true) { - _tuple = syscall.Recvmsg(fd.Sysfd, p, oob, 0); - n = _tuple[0]; - oobn = _tuple[1]; - flags = _tuple[2]; - sa = _tuple[3]; - err$2 = _tuple[4]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitRead(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - continue; - } - } - } - err$2 = fd.eofError(n, err$2); - $s = -1; return [n, oobn, flags, sa, err$2]; - } - $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadMsg }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.flags = flags; $f.n = n; $f.oob = oob; $f.oobn = oobn; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.ReadMsg = function(p, oob) { return this.$val.ReadMsg(p, oob); }; - FD.ptr.prototype.Write = function(p) { - var _r, _tuple, err, err$1, err$2, fd, max, n, nn, p, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - err$1 = fd.pd.prepareWrite(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, err$1]; - } - nn = 0; - while (true) { - max = p.$length; - if (fd.IsStream && (max - nn >> 0) > 1073741824) { - max = nn + 1073741824 >> 0; - } - _tuple = syscall.Write(fd.Sysfd, $subslice(p, nn, max)); - n = _tuple[0]; - err$2 = _tuple[1]; - if (n > 0) { - nn = nn + (n) >> 0; - } - if (nn === p.$length) { - $s = -1; return [nn, err$2]; - } - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitWrite(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - continue; - } - } - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return [nn, err$2]; - } - if (n === 0) { - $s = -1; return [nn, io.ErrUnexpectedEOF]; - } - } - $s = -1; return [0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Write }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Write = function(p) { return this.$val.Write(p); }; - FD.ptr.prototype.Pwrite = function(p, off) { - var _tuple, err, err$1, fd, max, n, nn, off, p, x, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; off = $f.off; p = $f.p; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "decref"), []]); - nn = 0; - while (true) { - max = p.$length; - if (fd.IsStream && (max - nn >> 0) > 1073741824) { - max = nn + 1073741824 >> 0; - } - _tuple = syscall.Pwrite(fd.Sysfd, $subslice(p, nn, max), (x = (new $Int64(0, nn)), new $Int64(off.$high + x.$high, off.$low + x.$low))); - n = _tuple[0]; - err$1 = _tuple[1]; - if (n > 0) { - nn = nn + (n) >> 0; - } - if (nn === p.$length) { - $s = -1; return [nn, err$1]; - } - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [nn, err$1]; - } - if (n === 0) { - $s = -1; return [nn, io.ErrUnexpectedEOF]; - } - } - $s = -1; return [0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pwrite }; } $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.off = off; $f.p = p; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Pwrite = function(p, off) { return this.$val.Pwrite(p, off); }; - FD.ptr.prototype.WriteTo = function(p, sa) { - var _r, _r$1, err, err$1, err$2, fd, p, sa, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - err$1 = fd.pd.prepareWrite(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, err$1]; - } - /* while (true) { */ case 2: - _r$1 = syscall.Sendto(fd.Sysfd, p, 0, sa); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - err$2 = _r$1; - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitWrite(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - /* continue; */ $s = 2; continue; - } - } - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return [0, err$2]; - } - $s = -1; return [p.$length, $ifaceNil]; - /* } */ $s = 2; continue; case 3: - $s = -1; return [0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteTo }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.WriteTo = function(p, sa) { return this.$val.WriteTo(p, sa); }; - FD.ptr.prototype.WriteMsg = function(p, oob, sa) { - var _r, _r$1, _tuple, err, err$1, err$2, fd, n, oob, p, sa, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; oob = $f.oob; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, 0, err]; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - err$1 = fd.pd.prepareWrite(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [0, 0, err$1]; - } - /* while (true) { */ case 2: - _r$1 = syscall.SendmsgN(fd.Sysfd, p, oob, sa, 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - n = _tuple[0]; - err$2 = _tuple[1]; - if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { - err$2 = fd.pd.waitWrite(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - /* continue; */ $s = 2; continue; - } - } - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return [n, 0, err$2]; - } - $s = -1; return [n, oob.$length, err$2]; - /* } */ $s = 2; continue; case 3: - $s = -1; return [0, 0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteMsg }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.oob = oob; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.WriteMsg = function(p, oob, sa) { return this.$val.WriteMsg(p, oob, sa); }; - FD.ptr.prototype.Accept = function() { - var _1, _r, _r$1, _tuple, err, err$1, err$2, errcall, fd, rsa, s, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; errcall = $f.errcall; fd = $f.fd; rsa = $f.rsa; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [-1, $ifaceNil, "", err]; - } - $deferred.push([$methodVal(fd, "readUnlock"), []]); - err$1 = fd.pd.prepareRead(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [-1, $ifaceNil, "", err$1]; - } - /* while (true) { */ case 2: - _r$1 = accept(fd.Sysfd); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - s = _tuple[0]; - rsa = _tuple[1]; - errcall = _tuple[2]; - err$2 = _tuple[3]; - if ($interfaceIsEqual(err$2, $ifaceNil)) { - $s = -1; return [s, rsa, "", err$2]; - } - _1 = err$2; - if ($interfaceIsEqual(_1, new syscall.Errno((11)))) { - if (fd.pd.pollable()) { - err$2 = fd.pd.waitRead(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - /* continue; */ $s = 2; continue; - } - } - } else if ($interfaceIsEqual(_1, new syscall.Errno((103)))) { - /* continue; */ $s = 2; continue; - } - $s = -1; return [-1, $ifaceNil, errcall, err$2]; - /* } */ $s = 2; continue; case 3: - $s = -1; return [0, $ifaceNil, "", $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.errcall = errcall; $f.fd = fd; $f.rsa = rsa; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Accept = function() { return this.$val.Accept(); }; - FD.ptr.prototype.Seek = function(offset, whence) { - var err, fd, offset, whence, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; offset = $f.offset; whence = $f.whence; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [new $Int64(0, 0), err]; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Seek(fd.Sysfd, offset, whence); - /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Seek }; } $f.err = err; $f.fd = fd; $f.offset = offset; $f.whence = whence; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; - FD.ptr.prototype.ReadDirent = function(buf) { - var _tuple, buf, err, err$1, fd, n, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; buf = $f.buf; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "decref"), []]); - while (true) { - _tuple = syscall.ReadDirent(fd.Sysfd, buf); - n = _tuple[0]; - err$1 = _tuple[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - n = 0; - if ($interfaceIsEqual(err$1, new syscall.Errno(11)) && fd.pd.pollable()) { - err$1 = fd.pd.waitRead(fd.isFile); - if ($interfaceIsEqual(err$1, $ifaceNil)) { - continue; - } - } - } - $s = -1; return [n, err$1]; - } - $s = -1; return [0, $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadDirent }; } $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.ReadDirent = function(buf) { return this.$val.ReadDirent(buf); }; - FD.ptr.prototype.Fchdir = function() { - var err, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Fchdir(fd.Sysfd); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchdir }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Fchdir = function() { return this.$val.Fchdir(); }; - FD.ptr.prototype.Fstat = function(s) { - var err, fd, s, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.Fstat(fd.Sysfd, s); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fstat }; } $f.err = err; $f.fd = fd; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Fstat = function(s) { return this.$val.Fstat(s); }; - DupCloseOnExec = function(fd) { - var _1, _r, _tuple, e1, fd, r0, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _tuple = $f._tuple; e1 = $f.e1; fd = $f.fd; r0 = $f.r0; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (atomic.LoadInt32((tryDupCloexec$24ptr || (tryDupCloexec$24ptr = new ptrType$2(function() { return tryDupCloexec; }, function($v) { tryDupCloexec = $v; })))) === 1) { - _tuple = fcntl(fd, 1030, 0); - r0 = _tuple[0]; - e1 = _tuple[1]; - if ($interfaceIsEqual(e1, $ifaceNil)) { - $s = -1; return [r0, "", $ifaceNil]; - } - _1 = $assertType(e1, syscall.Errno); - if ((_1 === (22)) || (_1 === (38))) { - atomic.StoreInt32((tryDupCloexec$24ptr || (tryDupCloexec$24ptr = new ptrType$2(function() { return tryDupCloexec; }, function($v) { tryDupCloexec = $v; }))), 0); - } else { - $s = -1; return [-1, "fcntl", e1]; - } - } - _r = dupCloseOnExecOld(fd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: DupCloseOnExec }; } $f._1 = _1; $f._r = _r; $f._tuple = _tuple; $f.e1 = e1; $f.fd = fd; $f.r0 = r0; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.DupCloseOnExec = DupCloseOnExec; - dupCloseOnExecOld = function(fd) { - var _tuple, err, fd, newfd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; err = $f.err; fd = $f.fd; newfd = $f.newfd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - $r = syscall.ForkLock.RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $deferred.push([$methodVal(syscall.ForkLock, "RUnlock"), []]); - _tuple = syscall.Dup(fd); - newfd = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [-1, "dup", err]; - } - syscall.CloseOnExec(newfd); - $s = -1; return [newfd, "", $ifaceNil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: dupCloseOnExecOld }; } $f._tuple = _tuple; $f.err = err; $f.fd = fd; $f.newfd = newfd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.ptr.prototype.Dup = function() { - var _r, err, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [-1, "", err]; - } - $deferred.push([$methodVal(fd, "decref"), []]); - _r = DupCloseOnExec(fd.Sysfd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Dup }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Dup = function() { return this.$val.Dup(); }; - FD.ptr.prototype.WaitWrite = function() { - var fd; - fd = this; - return fd.pd.waitWrite(fd.isFile); - }; - FD.prototype.WaitWrite = function() { return this.$val.WaitWrite(); }; - FD.ptr.prototype.WriteOnce = function(p) { - var _r, err, fd, p, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [0, err]; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - $s = -1; return syscall.Write(fd.Sysfd, p); - /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteOnce }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.WriteOnce = function(p) { return this.$val.WriteOnce(p); }; - FD.ptr.prototype.RawControl = function(f) { - var err, f, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $r = f(((fd.Sysfd >>> 0))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return $ifaceNil; - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawControl }; } $f.err = err; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.RawControl = function(f) { return this.$val.RawControl(f); }; - FD.ptr.prototype.RawRead = function(f) { - var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "readUnlock"), []]); - err$1 = fd.pd.prepareRead(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return err$1; - } - /* while (true) { */ case 2: - _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$1) { */ case 4: - $s = -1; return $ifaceNil; - /* } */ case 5: - err$2 = fd.pd.waitRead(fd.isFile); - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return err$2; - } - /* } */ $s = 2; continue; case 3: - $s = -1; return $ifaceNil; - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawRead }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.RawRead = function(f) { return this.$val.RawRead(f); }; - FD.ptr.prototype.RawWrite = function(f) { - var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - err$1 = fd.pd.prepareWrite(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return err$1; - } - /* while (true) { */ case 2: - _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$1) { */ case 4: - $s = -1; return $ifaceNil; - /* } */ case 5: - err$2 = fd.pd.waitWrite(fd.isFile); - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return err$2; - } - /* } */ $s = 2; continue; case 3: - $s = -1; return $ifaceNil; - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawWrite }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.RawWrite = function(f) { return this.$val.RawWrite(f); }; - writev = function(fd, iovecs) { - var _tuple, e, fd, iovecs, r; - _tuple = syscall.Syscall(20, ((fd >>> 0)), (($sliceToArray(iovecs))), ((iovecs.$length >>> 0))); - r = _tuple[0]; - e = _tuple[2]; - if (!((e === 0))) { - return [r, new syscall.Errno((e))]; - } - return [r, $ifaceNil]; - }; - accept = function(s) { - var _1, _r, _r$1, _r$2, _tuple, _tuple$1, err, ns, s, sa, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; err = $f.err; ns = $f.ns; s = $f.s; sa = $f.sa; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $pkg.Accept4Func(s, 526336); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - ns = _tuple[0]; - sa = _tuple[1]; - err = _tuple[2]; - _1 = err; - if ($interfaceIsEqual(_1, $ifaceNil)) { - $s = -1; return [ns, sa, "", $ifaceNil]; - } else if ($interfaceIsEqual(_1, new syscall.Errno((38)))) { - } else if ($interfaceIsEqual(_1, new syscall.Errno((22)))) { - } else if ($interfaceIsEqual(_1, new syscall.Errno((13)))) { - } else if ($interfaceIsEqual(_1, new syscall.Errno((14)))) { - } else { - $s = -1; return [-1, sa, "accept4", err]; - } - _r$1 = $pkg.AcceptFunc(s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - ns = _tuple$1[0]; - sa = _tuple$1[1]; - err = _tuple$1[2]; - if ($interfaceIsEqual(err, $ifaceNil)) { - syscall.CloseOnExec(ns); - } - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [-1, $ifaceNil, "accept", err]; - } - err = syscall.SetNonblock(ns, true); - /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 3: - _r$2 = $pkg.CloseFunc(ns); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - $s = -1; return [-1, $ifaceNil, "setnonblock", err]; - /* } */ case 4: - $s = -1; return [ns, sa, "", $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.err = err; $f.ns = ns; $f.s = s; $f.sa = sa; $f.$s = $s; $f.$r = $r; return $f; - }; - FD.ptr.prototype.SetsockoptInt = function(level, name, arg) { - var arg, err, fd, level, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptInt(fd.Sysfd, level, name, arg); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInt }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptInt = function(level, name, arg) { return this.$val.SetsockoptInt(level, name, arg); }; - FD.ptr.prototype.SetsockoptInet4Addr = function(level, name, arg) { - var arg, err, fd, level, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptInet4Addr(fd.Sysfd, level, name, $clone(arg, arrayType)); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInet4Addr }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptInet4Addr = function(level, name, arg) { return this.$val.SetsockoptInet4Addr(level, name, arg); }; - FD.ptr.prototype.SetsockoptLinger = function(level, name, l) { - var err, fd, l, level, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; l = $f.l; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptLinger(fd.Sysfd, level, name, l); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptLinger }; } $f.err = err; $f.fd = fd; $f.l = l; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptLinger = function(level, name, l) { return this.$val.SetsockoptLinger(level, name, l); }; - FD.ptr.prototype.SetsockoptIPMreqn = function(level, name, mreq) { - var err, fd, level, mreq, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptIPMreqn(fd.Sysfd, level, name, mreq); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreqn }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptIPMreqn = function(level, name, mreq) { return this.$val.SetsockoptIPMreqn(level, name, mreq); }; - FD.ptr.prototype.SetsockoptByte = function(level, name, arg) { - var arg, err, fd, level, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptByte(fd.Sysfd, level, name, arg); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptByte }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptByte = function(level, name, arg) { return this.$val.SetsockoptByte(level, name, arg); }; - FD.ptr.prototype.SetsockoptIPMreq = function(level, name, mreq) { - var err, fd, level, mreq, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptIPMreq(fd.Sysfd, level, name, mreq); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptIPMreq = function(level, name, mreq) { return this.$val.SetsockoptIPMreq(level, name, mreq); }; - FD.ptr.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { - var err, fd, level, mreq, name, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - fd = this; - err = fd.incref(); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - $deferred.push([$methodVal(fd, "decref"), []]); - $s = -1; return syscall.SetsockoptIPv6Mreq(fd.Sysfd, level, name, mreq); - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPv6Mreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { return this.$val.SetsockoptIPv6Mreq(level, name, mreq); }; - FD.ptr.prototype.Writev = function(v) { - var _i, _r, _ref, _tuple, chunk, err, err$1, err$2, fd, iovecs, maxVec, n, v, wrote, x, x$1, x$2, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; chunk = $f.chunk; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; iovecs = $f.iovecs; maxVec = $f.maxVec; n = $f.n; v = $f.v; wrote = $f.wrote; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - iovecs = [iovecs]; - fd = this; - _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [new $Int64(0, 0), err]; - } - $deferred.push([$methodVal(fd, "writeUnlock"), []]); - err$1 = fd.pd.prepareWrite(fd.isFile); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [new $Int64(0, 0), err$1]; - } - iovecs[0] = sliceType$2.nil; - if (!(fd.iovecs === ptrType$6.nil)) { - iovecs[0] = fd.iovecs.$get(); - } - maxVec = 1024; - n = new $Int64(0, 0); - err$2 = $ifaceNil; - /* while (true) { */ case 2: - /* if (!(v.$get().$length > 0)) { break; } */ if(!(v.$get().$length > 0)) { $s = 3; continue; } - iovecs[0] = $subslice(iovecs[0], 0, 0); - _ref = v.$get(); - _i = 0; - /* while (true) { */ case 4: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } - chunk = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (chunk.$length === 0) { - _i++; - /* continue; */ $s = 4; continue; - } - iovecs[0] = $append(iovecs[0], new syscall.Iovec.ptr($indexPtr(chunk.$array, chunk.$offset + 0, ptrType$7), new $Uint64(0, 0))); - if (fd.IsStream && chunk.$length > 1073741824) { - (x = iovecs[0].$length - 1 >> 0, ((x < 0 || x >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x])).SetLen(1073741824); - /* break; */ $s = 5; continue; - } - (x$1 = iovecs[0].$length - 1 >> 0, ((x$1 < 0 || x$1 >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x$1])).SetLen(chunk.$length); - if (iovecs[0].$length === maxVec) { - /* break; */ $s = 5; continue; - } - _i++; - /* } */ $s = 4; continue; case 5: - if (iovecs[0].$length === 0) { - /* break; */ $s = 3; continue; - } - fd.iovecs = (iovecs.$ptr || (iovecs.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, iovecs))); - wrote = 0; - _tuple = writev(fd.Sysfd, iovecs[0]); - wrote = _tuple[0]; - err$2 = _tuple[1]; - if (wrote === 4294967295) { - wrote = 0; - } - $r = $pkg.TestHookDidWritev(((wrote >> 0))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - n = (x$2 = (new $Int64(0, wrote.constructor === Number ? wrote : 1)), new $Int64(n.$high + x$2.$high, n.$low + x$2.$low)); - consume(v, (new $Int64(0, wrote.constructor === Number ? wrote : 1))); - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - if ($assertType(err$2, syscall.Errno) === 11) { - err$2 = fd.pd.waitWrite(fd.isFile); - if ($interfaceIsEqual(err$2, $ifaceNil)) { - /* continue; */ $s = 2; continue; - } - } - /* break; */ $s = 3; continue; - } - if ((n.$high === 0 && n.$low === 0)) { - err$2 = io.ErrUnexpectedEOF; - /* break; */ $s = 3; continue; - } - /* } */ $s = 2; continue; case 3: - $s = -1; return [n, err$2]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Writev }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.chunk = chunk; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.iovecs = iovecs; $f.maxVec = maxVec; $f.n = n; $f.v = v; $f.wrote = wrote; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - FD.prototype.Writev = function(v) { return this.$val.Writev(v); }; - ptrType$9.methods = [{prop: "init", name: "init", pkg: "internal/poll", typ: $funcType([ptrType$8], [$error], false)}, {prop: "close", name: "close", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "evict", name: "evict", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "prepare", name: "prepare", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "prepareRead", name: "prepareRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "prepareWrite", name: "prepareWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "wait", name: "wait", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "waitRead", name: "waitRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitWrite", name: "waitWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitCanceled", name: "waitCanceled", pkg: "internal/poll", typ: $funcType([$Int], [], false)}, {prop: "pollable", name: "pollable", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}]; - ptrType$10.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}]; - ptrType$11.methods = [{prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "increfAndClose", name: "increfAndClose", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "rwlock", name: "rwlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}, {prop: "rwunlock", name: "rwunlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}]; - ptrType$8.methods = [{prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "Fsync", name: "Fsync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readLock", name: "readLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readUnlock", name: "readUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "writeLock", name: "writeLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "writeUnlock", name: "writeUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "eofError", name: "eofError", pkg: "internal/poll", typ: $funcType([$Int, $error], [$error], false)}, {prop: "Fchmod", name: "Fchmod", pkg: "", typ: $funcType([$Uint32], [$error], false)}, {prop: "Fchown", name: "Fchown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Ftruncate", name: "Ftruncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([$String, $Bool], [$error], false)}, {prop: "destroy", name: "destroy", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Shutdown", name: "Shutdown", pkg: "", typ: $funcType([$Int], [$error], false)}, {prop: "SetBlocking", name: "SetBlocking", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Pread", name: "Pread", pkg: "", typ: $funcType([sliceType$3, $Int64], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([sliceType$3], [$Int, syscall.Sockaddr, $error], false)}, {prop: "ReadMsg", name: "ReadMsg", pkg: "", typ: $funcType([sliceType$3, sliceType$3], [$Int, $Int, $Int, syscall.Sockaddr, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Pwrite", name: "Pwrite", pkg: "", typ: $funcType([sliceType$3, $Int64], [$Int, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([sliceType$3, syscall.Sockaddr], [$Int, $error], false)}, {prop: "WriteMsg", name: "WriteMsg", pkg: "", typ: $funcType([sliceType$3, sliceType$3, syscall.Sockaddr], [$Int, $Int, $error], false)}, {prop: "Accept", name: "Accept", pkg: "", typ: $funcType([], [$Int, syscall.Sockaddr, $String, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "ReadDirent", name: "ReadDirent", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "Fchdir", name: "Fchdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Fstat", name: "Fstat", pkg: "", typ: $funcType([ptrType$12], [$error], false)}, {prop: "Dup", name: "Dup", pkg: "", typ: $funcType([], [$Int, $String, $error], false)}, {prop: "WaitWrite", name: "WaitWrite", pkg: "", typ: $funcType([], [$error], false)}, {prop: "WriteOnce", name: "WriteOnce", pkg: "", typ: $funcType([sliceType$3], [$Int, $error], false)}, {prop: "RawControl", name: "RawControl", pkg: "", typ: $funcType([funcType], [$error], false)}, {prop: "RawRead", name: "RawRead", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "RawWrite", name: "RawWrite", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "SetsockoptInt", name: "SetsockoptInt", pkg: "", typ: $funcType([$Int, $Int, $Int], [$error], false)}, {prop: "SetsockoptInet4Addr", name: "SetsockoptInet4Addr", pkg: "", typ: $funcType([$Int, $Int, arrayType], [$error], false)}, {prop: "SetsockoptLinger", name: "SetsockoptLinger", pkg: "", typ: $funcType([$Int, $Int, ptrType$13], [$error], false)}, {prop: "SetsockoptIPMreqn", name: "SetsockoptIPMreqn", pkg: "", typ: $funcType([$Int, $Int, ptrType$14], [$error], false)}, {prop: "SetsockoptByte", name: "SetsockoptByte", pkg: "", typ: $funcType([$Int, $Int, $Uint8], [$error], false)}, {prop: "SetsockoptIPMreq", name: "SetsockoptIPMreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$15], [$error], false)}, {prop: "SetsockoptIPv6Mreq", name: "SetsockoptIPv6Mreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$16], [$error], false)}, {prop: "Writev", name: "Writev", pkg: "", typ: $funcType([ptrType$17], [$Int64, $error], false)}]; - pollDesc.init("internal/poll", [{prop: "closing", name: "closing", embedded: false, exported: false, typ: $Bool, tag: ""}]); - TimeoutError.init("", []); - fdMutex.init("internal/poll", [{prop: "state", name: "state", embedded: false, exported: false, typ: $Uint64, tag: ""}, {prop: "rsema", name: "rsema", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "wsema", name: "wsema", embedded: false, exported: false, typ: $Uint32, tag: ""}]); - FD.init("internal/poll", [{prop: "fdmu", name: "fdmu", embedded: false, exported: false, typ: fdMutex, tag: ""}, {prop: "Sysfd", name: "Sysfd", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "pd", name: "pd", embedded: false, exported: false, typ: pollDesc, tag: ""}, {prop: "iovecs", name: "iovecs", embedded: false, exported: false, typ: ptrType$6, tag: ""}, {prop: "csema", name: "csema", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "isBlocking", name: "isBlocking", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "IsStream", name: "IsStream", embedded: false, exported: true, typ: $Bool, tag: ""}, {prop: "ZeroReadIsEOF", name: "ZeroReadIsEOF", embedded: false, exported: true, typ: $Bool, tag: ""}, {prop: "isFile", name: "isFile", embedded: false, exported: false, typ: $Bool, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - semWaiters = {}; - $pkg.ErrNetClosing = errors.New("use of closed network connection"); - $pkg.ErrFileClosing = errors.New("use of closed file"); - $pkg.ErrNoDeadline = errors.New("file type does not support deadline"); - $pkg.ErrTimeout = new TimeoutError.ptr(); - $pkg.TestHookDidWritev = (function(wrote) { - var wrote; - }); - tryDupCloexec = 1; - $pkg.Accept4Func = syscall.Accept4; - $pkg.CloseFunc = syscall.Close; - $pkg.AcceptFunc = syscall.Accept; - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/syscall/unix"] = (function() { - var $pkg = {}, $init, atomic, syscall, IsNonblock; - atomic = $packages["sync/atomic"]; - syscall = $packages["syscall"]; - IsNonblock = function(fd) { - var _tmp, _tmp$1, err, fd, nonblocking; - nonblocking = false; - err = $ifaceNil; - _tmp = false; - _tmp$1 = $ifaceNil; - nonblocking = _tmp; - err = _tmp$1; - return [nonblocking, err]; - }; - $pkg.IsNonblock = IsNonblock; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = atomic.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = syscall.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["internal/testlog"] = (function() { - var $pkg = {}, $init, atomic, Interface, ptrType, logger, Logger, Stat; - atomic = $packages["sync/atomic"]; - Interface = $pkg.Interface = $newType(8, $kindInterface, "testlog.Interface", true, "internal/testlog", true, null); - ptrType = $ptrType(Interface); - Logger = function() { - var impl; - impl = logger.Load(); - if ($interfaceIsEqual(impl, $ifaceNil)) { - return $ifaceNil; - } - return $assertType(impl, ptrType).$get(); - }; - $pkg.Logger = Logger; - Stat = function(name) { - var log, name, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; log = $f.log; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - log = Logger(); - /* */ if (!($interfaceIsEqual(log, $ifaceNil))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!($interfaceIsEqual(log, $ifaceNil))) { */ case 1: - $r = log.Stat(name); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Stat }; } $f.log = log; $f.name = name; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Stat = Stat; - Interface.init([{prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Getenv", name: "Getenv", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Open", name: "Open", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([$String], [], false)}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = atomic.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - logger = new atomic.Value.ptr($ifaceNil); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["os"] = (function() { - var $pkg = {}, $init, errors, js, poll, unix, testlog, io, runtime, sync, atomic, syscall, time, dirInfo, timeout, PathError, SyscallError, LinkError, file, rawConn, File, FileInfo, FileMode, fileStat, sliceType, ptrType, sliceType$1, ptrType$1, sliceType$2, ptrType$2, ptrType$3, ptrType$4, sliceType$5, ptrType$12, arrayType$1, ptrType$13, funcType$1, ptrType$15, arrayType$6, ptrType$16, funcType$2, funcType$3, ptrType$18, errFinished, lstat, runtime_args, init, runtime_beforeExit, NewSyscallError, IsNotExist, underlyingError, wrapSyscallError, isNotExist, sigpipe, syscallMode, NewFile, newFile, epipecheck, basename, init$1, Exit, newRawConn, Lstat, fillFileStatFromSys, timespecToTime, lstatNolog; - errors = $packages["errors"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - poll = $packages["internal/poll"]; - unix = $packages["internal/syscall/unix"]; - testlog = $packages["internal/testlog"]; - io = $packages["io"]; - runtime = $packages["runtime"]; - sync = $packages["sync"]; - atomic = $packages["sync/atomic"]; - syscall = $packages["syscall"]; - time = $packages["time"]; - dirInfo = $pkg.dirInfo = $newType(0, $kindStruct, "os.dirInfo", true, "os", false, function(buf_, nbuf_, bufp_) { - this.$val = this; - if (arguments.length === 0) { - this.buf = sliceType$2.nil; - this.nbuf = 0; - this.bufp = 0; - return; - } - this.buf = buf_; - this.nbuf = nbuf_; - this.bufp = bufp_; - }); - timeout = $pkg.timeout = $newType(8, $kindInterface, "os.timeout", true, "os", false, null); - PathError = $pkg.PathError = $newType(0, $kindStruct, "os.PathError", true, "os", true, function(Op_, Path_, Err_) { - this.$val = this; - if (arguments.length === 0) { - this.Op = ""; - this.Path = ""; - this.Err = $ifaceNil; - return; - } - this.Op = Op_; - this.Path = Path_; - this.Err = Err_; - }); - SyscallError = $pkg.SyscallError = $newType(0, $kindStruct, "os.SyscallError", true, "os", true, function(Syscall_, Err_) { - this.$val = this; - if (arguments.length === 0) { - this.Syscall = ""; - this.Err = $ifaceNil; - return; - } - this.Syscall = Syscall_; - this.Err = Err_; - }); - LinkError = $pkg.LinkError = $newType(0, $kindStruct, "os.LinkError", true, "os", true, function(Op_, Old_, New_, Err_) { - this.$val = this; - if (arguments.length === 0) { - this.Op = ""; - this.Old = ""; - this.New = ""; - this.Err = $ifaceNil; - return; - } - this.Op = Op_; - this.Old = Old_; - this.New = New_; - this.Err = Err_; - }); - file = $pkg.file = $newType(0, $kindStruct, "os.file", true, "os", false, function(pfd_, name_, dirinfo_, nonblock_, stdoutOrErr_) { - this.$val = this; - if (arguments.length === 0) { - this.pfd = new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), 0, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, 0, false, false, false); - this.name = ""; - this.dirinfo = ptrType$1.nil; - this.nonblock = false; - this.stdoutOrErr = false; - return; - } - this.pfd = pfd_; - this.name = name_; - this.dirinfo = dirinfo_; - this.nonblock = nonblock_; - this.stdoutOrErr = stdoutOrErr_; - }); - rawConn = $pkg.rawConn = $newType(0, $kindStruct, "os.rawConn", true, "os", false, function(file_) { - this.$val = this; - if (arguments.length === 0) { - this.file = ptrType.nil; - return; - } - this.file = file_; - }); - File = $pkg.File = $newType(0, $kindStruct, "os.File", true, "os", true, function(file_) { - this.$val = this; - if (arguments.length === 0) { - this.file = ptrType$13.nil; - return; - } - this.file = file_; - }); - FileInfo = $pkg.FileInfo = $newType(8, $kindInterface, "os.FileInfo", true, "os", true, null); - FileMode = $pkg.FileMode = $newType(4, $kindUint32, "os.FileMode", true, "os", true, null); - fileStat = $pkg.fileStat = $newType(0, $kindStruct, "os.fileStat", true, "os", false, function(name_, size_, mode_, modTime_, sys_) { - this.$val = this; - if (arguments.length === 0) { - this.name = ""; - this.size = new $Int64(0, 0); - this.mode = 0; - this.modTime = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil); - this.sys = new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero()); - return; - } - this.name = name_; - this.size = size_; - this.mode = mode_; - this.modTime = modTime_; - this.sys = sys_; - }); - sliceType = $sliceType($String); - ptrType = $ptrType(File); - sliceType$1 = $sliceType(FileInfo); - ptrType$1 = $ptrType(dirInfo); - sliceType$2 = $sliceType($Uint8); - ptrType$2 = $ptrType(PathError); - ptrType$3 = $ptrType(LinkError); - ptrType$4 = $ptrType(SyscallError); - sliceType$5 = $sliceType(syscall.Iovec); - ptrType$12 = $ptrType(sliceType$5); - arrayType$1 = $arrayType($Int64, 3); - ptrType$13 = $ptrType(file); - funcType$1 = $funcType([ptrType$13], [$error], false); - ptrType$15 = $ptrType(time.Location); - arrayType$6 = $arrayType($Uint8, 32); - ptrType$16 = $ptrType(fileStat); - funcType$2 = $funcType([$Uintptr], [], false); - funcType$3 = $funcType([$Uintptr], [$Bool], false); - ptrType$18 = $ptrType(rawConn); - runtime_args = function() { - return $pkg.Args; - }; - init = function() { - var argv, i, process; - process = $global.process; - if (!(process === undefined)) { - argv = process.argv; - $pkg.Args = $makeSlice(sliceType, ($parseInt(argv.length) - 1 >> 0)); - i = 0; - while (true) { - if (!(i < ($parseInt(argv.length) - 1 >> 0))) { break; } - ((i < 0 || i >= $pkg.Args.$length) ? ($throwRuntimeError("index out of range"), undefined) : $pkg.Args.$array[$pkg.Args.$offset + i] = $internalize(argv[(i + 1 >> 0)], $String)); - i = i + (1) >> 0; - } - } - if ($pkg.Args.$length === 0) { - $pkg.Args = new sliceType(["?"]); - } - }; - runtime_beforeExit = function() { - }; - File.ptr.prototype.Readdir = function(n) { - var _r, f, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - if (f === ptrType.nil) { - $s = -1; return [sliceType$1.nil, $pkg.ErrInvalid]; - } - _r = f.readdir(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdir }; } $f._r = _r; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Readdir = function(n) { return this.$val.Readdir(n); }; - File.ptr.prototype.Readdirnames = function(n) { - var _r, _tmp, _tmp$1, _tuple, err, f, n, names, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - names = sliceType.nil; - err = $ifaceNil; - f = this; - if (f === ptrType.nil) { - _tmp = sliceType.nil; - _tmp$1 = $pkg.ErrInvalid; - names = _tmp; - err = _tmp$1; - $s = -1; return [names, err]; - } - _r = f.readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - names = _tuple[0]; - err = _tuple[1]; - $s = -1; return [names, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Readdirnames = function(n) { return this.$val.Readdirnames(n); }; - dirInfo.ptr.prototype.close = function() { - var d; - d = this; - }; - dirInfo.prototype.close = function() { return this.$val.close(); }; - File.ptr.prototype.readdirnames = function(n) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, d, err, errno, f, n, names, nb, nc, size, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; d = $f.d; err = $f.err; errno = $f.errno; f = $f.f; n = $f.n; names = $f.names; nb = $f.nb; nc = $f.nc; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - names = sliceType.nil; - err = $ifaceNil; - f = this; - if (f.file.dirinfo === ptrType$1.nil) { - f.file.dirinfo = new dirInfo.ptr(sliceType$2.nil, 0, 0); - f.file.dirinfo.buf = $makeSlice(sliceType$2, 8192); - } - d = f.file.dirinfo; - size = n; - if (size <= 0) { - size = 100; - n = -1; - } - names = $makeSlice(sliceType, 0, size); - /* while (true) { */ case 1: - /* if (!(!((n === 0)))) { break; } */ if(!(!((n === 0)))) { $s = 2; continue; } - /* */ if (d.bufp >= d.nbuf) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (d.bufp >= d.nbuf) { */ case 3: - d.bufp = 0; - errno = $ifaceNil; - _r = f.file.pfd.ReadDirent(d.buf); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - d.nbuf = _tuple[0]; - errno = _tuple[1]; - runtime.KeepAlive(f); - if (!($interfaceIsEqual(errno, $ifaceNil))) { - _tmp = names; - _tmp$1 = wrapSyscallError("readdirent", errno); - names = _tmp; - err = _tmp$1; - $s = -1; return [names, err]; - } - if (d.nbuf <= 0) { - /* break; */ $s = 2; continue; - } - /* } */ case 4: - _tmp$2 = 0; - _tmp$3 = 0; - nb = _tmp$2; - nc = _tmp$3; - _tuple$1 = syscall.ParseDirent($subslice(d.buf, d.bufp, d.nbuf), n, names); - nb = _tuple$1[0]; - nc = _tuple$1[1]; - names = _tuple$1[2]; - d.bufp = d.bufp + (nb) >> 0; - n = n - (nc) >> 0; - /* } */ $s = 1; continue; case 2: - if (n >= 0 && (names.$length === 0)) { - _tmp$4 = names; - _tmp$5 = io.EOF; - names = _tmp$4; - err = _tmp$5; - $s = -1; return [names, err]; - } - _tmp$6 = names; - _tmp$7 = $ifaceNil; - names = _tmp$6; - err = _tmp$7; - $s = -1; return [names, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.d = d; $f.err = err; $f.errno = errno; $f.f = f; $f.n = n; $f.names = names; $f.nb = nb; $f.nc = nc; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.readdirnames = function(n) { return this.$val.readdirnames(n); }; - PathError.ptr.prototype.Error = function() { - var _r, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return e.Op + " " + e.Path + ": " + _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - PathError.prototype.Error = function() { return this.$val.Error(); }; - PathError.ptr.prototype.Timeout = function() { - var _r, _tuple, _v, e, ok, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _tuple = $assertType(e.Err, timeout, true); - t = _tuple[0]; - ok = _tuple[1]; - if (!(ok)) { _v = false; $s = 1; continue s; } - _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 1: - $s = -1; return _v; - /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - PathError.prototype.Timeout = function() { return this.$val.Timeout(); }; - SyscallError.ptr.prototype.Error = function() { - var _r, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return e.Syscall + ": " + _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - SyscallError.prototype.Error = function() { return this.$val.Error(); }; - SyscallError.ptr.prototype.Timeout = function() { - var _r, _tuple, _v, e, ok, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _tuple = $assertType(e.Err, timeout, true); - t = _tuple[0]; - ok = _tuple[1]; - if (!(ok)) { _v = false; $s = 1; continue s; } - _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r; case 1: - $s = -1; return _v; - /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - SyscallError.prototype.Timeout = function() { return this.$val.Timeout(); }; - NewSyscallError = function(syscall$1, err) { - var err, syscall$1; - if ($interfaceIsEqual(err, $ifaceNil)) { - return $ifaceNil; - } - return new SyscallError.ptr(syscall$1, err); - }; - $pkg.NewSyscallError = NewSyscallError; - IsNotExist = function(err) { - var err; - return isNotExist(err); - }; - $pkg.IsNotExist = IsNotExist; - underlyingError = function(err) { - var _ref, err, err$1, err$2, err$3; - _ref = err; - if ($assertType(_ref, ptrType$2, true)[1]) { - err$1 = _ref.$val; - return err$1.Err; - } else if ($assertType(_ref, ptrType$3, true)[1]) { - err$2 = _ref.$val; - return err$2.Err; - } else if ($assertType(_ref, ptrType$4, true)[1]) { - err$3 = _ref.$val; - return err$3.Err; - } - return err; - }; - wrapSyscallError = function(name, err) { - var _tuple, err, name, ok; - _tuple = $assertType(err, syscall.Errno, true); - ok = _tuple[1]; - if (ok) { - err = NewSyscallError(name, err); - } - return err; - }; - isNotExist = function(err) { - var err; - err = underlyingError(err); - return $interfaceIsEqual(err, new syscall.Errno(2)) || $interfaceIsEqual(err, $pkg.ErrNotExist); - }; - File.ptr.prototype.Name = function() { - var f; - f = this; - return f.file.name; - }; - File.prototype.Name = function() { return this.$val.Name(); }; - LinkError.ptr.prototype.Error = function() { - var _r, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return e.Op + " " + e.Old + " " + e.New + ": " + _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: LinkError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - LinkError.prototype.Error = function() { return this.$val.Error(); }; - File.ptr.prototype.Read = function(b) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - err$1 = f.checkValid("read"); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = 0; - _tmp$1 = err$1; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - _r = f.read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - e = _tuple[1]; - _tmp$2 = n; - _tmp$3 = f.wrapErr("read", e); - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Read = function(b) { return this.$val.Read(b); }; - File.ptr.prototype.ReadAt = function(b, off) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - err$1 = f.checkValid("read"); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = 0; - _tmp$1 = err$1; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { - _tmp$2 = 0; - _tmp$3 = new PathError.ptr("readat", f.file.name, errors.New("negative offset")); - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - /* while (true) { */ case 1: - /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } - _r = f.pread(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - e = _tuple[1]; - if (!($interfaceIsEqual(e, $ifaceNil))) { - err = f.wrapErr("read", e); - /* break; */ $s = 2; continue; - } - n = n + (m) >> 0; - b = $subslice(b, m); - off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); - /* } */ $s = 1; continue; case 2: - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.ReadAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; - File.ptr.prototype.Write = function(b) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - err$1 = f.checkValid("write"); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = 0; - _tmp$1 = err$1; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - _r = f.write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - e = _tuple[1]; - if (n < 0) { - n = 0; - } - if (!((n === b.$length))) { - err = io.ErrShortWrite; - } - epipecheck(f, e); - if (!($interfaceIsEqual(e, $ifaceNil))) { - err = f.wrapErr("write", e); - } - _tmp$2 = n; - _tmp$3 = err; - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Write = function(b) { return this.$val.Write(b); }; - File.ptr.prototype.WriteAt = function(b, off) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - err$1 = f.checkValid("write"); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = 0; - _tmp$1 = err$1; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { - _tmp$2 = 0; - _tmp$3 = new PathError.ptr("writeat", f.file.name, errors.New("negative offset")); - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - /* while (true) { */ case 1: - /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } - _r = f.pwrite(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - e = _tuple[1]; - if (!($interfaceIsEqual(e, $ifaceNil))) { - err = f.wrapErr("write", e); - /* break; */ $s = 2; continue; - } - n = n + (m) >> 0; - b = $subslice(b, m); - off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); - /* } */ $s = 1; continue; case 2: - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.WriteAt = function(b, off) { return this.$val.WriteAt(b, off); }; - File.ptr.prototype.Seek = function(offset, whence) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, e, err, err$1, f, offset, r, ret, whence, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; offset = $f.offset; r = $f.r; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ret = new $Int64(0, 0); - err = $ifaceNil; - f = this; - err$1 = f.checkValid("seek"); - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp = new $Int64(0, 0); - _tmp$1 = err$1; - ret = _tmp; - err = _tmp$1; - $s = -1; return [ret, err]; - } - _r = f.seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - e = _tuple[1]; - if ($interfaceIsEqual(e, $ifaceNil) && !(f.file.dirinfo === ptrType$1.nil) && !((r.$high === 0 && r.$low === 0))) { - e = new syscall.Errno(21); - } - if (!($interfaceIsEqual(e, $ifaceNil))) { - _tmp$2 = new $Int64(0, 0); - _tmp$3 = f.wrapErr("seek", e); - ret = _tmp$2; - err = _tmp$3; - $s = -1; return [ret, err]; - } - _tmp$4 = r; - _tmp$5 = $ifaceNil; - ret = _tmp$4; - err = _tmp$5; - $s = -1; return [ret, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.offset = offset; $f.r = r; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; - File.ptr.prototype.WriteString = function(s) { - var _r, _tuple, err, f, n, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - _r = f.Write((new sliceType$2($stringToBytes(s)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteString }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; - File.ptr.prototype.wrapErr = function(op, err) { - var err, f, op; - f = this; - if ($interfaceIsEqual(err, $ifaceNil) || $interfaceIsEqual(err, io.EOF)) { - return err; - } - if ($interfaceIsEqual(err, poll.ErrFileClosing)) { - err = $pkg.ErrClosed; - } - return new PathError.ptr(op, f.file.name, err); - }; - File.prototype.wrapErr = function(op, err) { return this.$val.wrapErr(op, err); }; - File.ptr.prototype.Chmod = function(mode) { - var _r, f, mode, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - _r = f.chmod(mode); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chmod }; } $f._r = _r; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Chmod = function(mode) { return this.$val.Chmod(mode); }; - File.ptr.prototype.SetDeadline = function(t) { - var f, t; - f = this; - return f.setDeadline($clone(t, time.Time)); - }; - File.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; - File.ptr.prototype.SetReadDeadline = function(t) { - var f, t; - f = this; - return f.setReadDeadline($clone(t, time.Time)); - }; - File.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; - File.ptr.prototype.SetWriteDeadline = function(t) { - var f, t; - f = this; - return f.setWriteDeadline($clone(t, time.Time)); - }; - File.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; - File.ptr.prototype.SyscallConn = function() { - var _returncast, err, f; - f = this; - err = f.checkValid("SyscallConn"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [$ifaceNil, err]; - } - _returncast = newRawConn(f); - return [_returncast[0], _returncast[1]]; - }; - File.prototype.SyscallConn = function() { return this.$val.SyscallConn(); }; - sigpipe = function() { - $throwRuntimeError("native function not implemented: os.sigpipe"); - }; - syscallMode = function(i) { - var i, o; - o = 0; - o = (o | (((new FileMode(i).Perm() >>> 0)))) >>> 0; - if (!((((i & 8388608) >>> 0) === 0))) { - o = (o | (2048)) >>> 0; - } - if (!((((i & 4194304) >>> 0) === 0))) { - o = (o | (1024)) >>> 0; - } - if (!((((i & 1048576) >>> 0) === 0))) { - o = (o | (512)) >>> 0; - } - return o; - }; - File.ptr.prototype.chmod = function(mode) { - var _r, e, err, f, mode, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - err = f.checkValid("chmod"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = f.file.pfd.Fchmod(syscallMode(mode)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - $s = -1; return f.wrapErr("chmod", e); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.chmod }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.chmod = function(mode) { return this.$val.chmod(mode); }; - File.ptr.prototype.Chown = function(uid, gid) { - var _r, e, err, f, gid, uid, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; gid = $f.gid; uid = $f.uid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - err = f.checkValid("chown"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = f.file.pfd.Fchown(uid, gid); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - $s = -1; return f.wrapErr("chown", e); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chown }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Chown = function(uid, gid) { return this.$val.Chown(uid, gid); }; - File.ptr.prototype.Truncate = function(size) { - var _r, e, err, f, size, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - err = f.checkValid("truncate"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = f.file.pfd.Ftruncate(size); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - $s = -1; return f.wrapErr("truncate", e); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Truncate }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Truncate = function(size) { return this.$val.Truncate(size); }; - File.ptr.prototype.Sync = function() { - var _r, e, err, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - err = f.checkValid("sync"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = f.file.pfd.Fsync(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - $s = -1; return f.wrapErr("sync", e); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Sync }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Sync = function() { return this.$val.Sync(); }; - File.ptr.prototype.Chdir = function() { - var _r, e, err, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - err = f.checkValid("chdir"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = f.file.pfd.Fchdir(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - $s = -1; return f.wrapErr("chdir", e); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chdir }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Chdir = function() { return this.$val.Chdir(); }; - File.ptr.prototype.setDeadline = function(t) { - var err, f, t; - f = this; - err = f.checkValid("SetDeadline"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - return f.file.pfd.SetDeadline($clone(t, time.Time)); - }; - File.prototype.setDeadline = function(t) { return this.$val.setDeadline(t); }; - File.ptr.prototype.setReadDeadline = function(t) { - var err, f, t; - f = this; - err = f.checkValid("SetReadDeadline"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - return f.file.pfd.SetReadDeadline($clone(t, time.Time)); - }; - File.prototype.setReadDeadline = function(t) { return this.$val.setReadDeadline(t); }; - File.ptr.prototype.setWriteDeadline = function(t) { - var err, f, t; - f = this; - err = f.checkValid("SetWriteDeadline"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - return f.file.pfd.SetWriteDeadline($clone(t, time.Time)); - }; - File.prototype.setWriteDeadline = function(t) { return this.$val.setWriteDeadline(t); }; - File.ptr.prototype.checkValid = function(op) { - var f, op; - f = this; - if (f === ptrType.nil) { - return $pkg.ErrInvalid; - } - return $ifaceNil; - }; - File.prototype.checkValid = function(op) { return this.$val.checkValid(op); }; - File.ptr.prototype.Fd = function() { - var _r, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - if (f === ptrType.nil) { - $s = -1; return 4294967295; - } - /* */ if (f.file.nonblock) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (f.file.nonblock) { */ case 1: - _r = f.file.pfd.SetBlocking(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - /* } */ case 2: - $s = -1; return ((f.file.pfd.Sysfd >>> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Fd }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Fd = function() { return this.$val.Fd(); }; - NewFile = function(fd, name) { - var _tuple, err, fd, kind, name, nb; - kind = 0; - _tuple = unix.IsNonblock(((fd >> 0))); - nb = _tuple[0]; - err = _tuple[1]; - if ($interfaceIsEqual(err, $ifaceNil) && nb) { - kind = 3; - } - return newFile(fd, name, kind); - }; - $pkg.NewFile = NewFile; - newFile = function(fd, name, kind) { - var _1, err, err$1, err$2, err$3, f, fd, fdi, kind, name, pollable, st; - fdi = ((fd >> 0)); - if (fdi < 0) { - return ptrType.nil; - } - f = new File.ptr(new file.ptr(new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), fdi, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, 0, true, true, false), name, ptrType$1.nil, false, (fdi === 1) || (fdi === 2))); - pollable = (kind === 1) || (kind === 2) || (kind === 3); - if (kind === 1) { - st = new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero()); - _1 = "linux"; - if (_1 === ("freebsd")) { - pollable = false; - } else if (_1 === ("dragonfly") || _1 === ("netbsd") || _1 === ("openbsd")) { - err = syscall.Fstat(fdi, st); - if ($interfaceIsEqual(err, $ifaceNil) && (((st.Mode & 61440) >>> 0) === 32768)) { - pollable = false; - } - } else if (_1 === ("darwin")) { - err$1 = syscall.Fstat(fdi, st); - if ($interfaceIsEqual(err$1, $ifaceNil) && ((((st.Mode & 61440) >>> 0) === 4096) || (((st.Mode & 61440) >>> 0) === 32768))) { - pollable = false; - } - } - } - err$2 = f.file.pfd.Init("file", pollable); - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - } else if (pollable) { - err$3 = syscall.SetNonblock(fdi, true); - if ($interfaceIsEqual(err$3, $ifaceNil)) { - f.file.nonblock = true; - } - } - runtime.SetFinalizer(f.file, new funcType$1($methodExpr(ptrType$13, "close"))); - return f; - }; - epipecheck = function(file$1, e) { - var e, file$1; - if ($interfaceIsEqual(e, new syscall.Errno(32)) && file$1.file.stdoutOrErr) { - sigpipe(); - } - }; - File.ptr.prototype.Close = function() { - var _r, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = this; - if (f === ptrType.nil) { - $s = -1; return $pkg.ErrInvalid; - } - _r = f.file.close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Close }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Close = function() { return this.$val.Close(); }; - file.ptr.prototype.close = function() { - var _r, e, err, file$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; file$1 = $f.file$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - file$1 = this; - if (file$1 === ptrType$13.nil) { - $s = -1; return new syscall.Errno(22); - } - if (!(file$1.dirinfo === ptrType$1.nil)) { - file$1.dirinfo.close(); - } - err = $ifaceNil; - _r = file$1.pfd.Close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - e = _r; - if (!($interfaceIsEqual(e, $ifaceNil))) { - if ($interfaceIsEqual(e, poll.ErrFileClosing)) { - e = $pkg.ErrClosed; - } - err = new PathError.ptr("close", file$1.name, e); - } - runtime.SetFinalizer(file$1, $ifaceNil); - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: file.ptr.prototype.close }; } $f._r = _r; $f.e = e; $f.err = err; $f.file$1 = file$1; $f.$s = $s; $f.$r = $r; return $f; - }; - file.prototype.close = function() { return this.$val.close(); }; - File.ptr.prototype.read = function(b) { - var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - _r = f.file.pfd.Read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - runtime.KeepAlive(f); - _tmp = n; - _tmp$1 = err; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.read = function(b) { return this.$val.read(b); }; - File.ptr.prototype.pread = function(b, off) { - var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - _r = f.file.pfd.Pread(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - runtime.KeepAlive(f); - _tmp = n; - _tmp$1 = err; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pread }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.pread = function(b, off) { return this.$val.pread(b, off); }; - File.ptr.prototype.write = function(b) { - var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - _r = f.file.pfd.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - runtime.KeepAlive(f); - _tmp = n; - _tmp$1 = err; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.write = function(b) { return this.$val.write(b); }; - File.ptr.prototype.pwrite = function(b, off) { - var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - f = this; - _r = f.file.pfd.Pwrite(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - runtime.KeepAlive(f); - _tmp = n; - _tmp$1 = err; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pwrite }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.pwrite = function(b, off) { return this.$val.pwrite(b, off); }; - File.ptr.prototype.seek = function(offset, whence) { - var _r, _tmp, _tmp$1, _tuple, err, f, offset, ret, whence, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; offset = $f.offset; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ret = new $Int64(0, 0); - err = $ifaceNil; - f = this; - _r = f.file.pfd.Seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - ret = _tuple[0]; - err = _tuple[1]; - runtime.KeepAlive(f); - _tmp = ret; - _tmp$1 = err; - ret = _tmp; - err = _tmp$1; - $s = -1; return [ret, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.offset = offset; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.seek = function(offset, whence) { return this.$val.seek(offset, whence); }; - File.ptr.prototype.readdir = function(n) { - var _i, _r, _r$1, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, dirname, err, f, fi, filename, fip, lerr, n, names, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dirname = $f.dirname; err = $f.err; f = $f.f; fi = $f.fi; filename = $f.filename; fip = $f.fip; lerr = $f.lerr; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fi = sliceType$1.nil; - err = $ifaceNil; - f = this; - dirname = f.file.name; - if (dirname === "") { - dirname = "."; - } - _r = f.Readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - names = _tuple[0]; - err = _tuple[1]; - fi = $makeSlice(sliceType$1, 0, names.$length); - _ref = names; - _i = 0; - /* while (true) { */ case 2: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } - filename = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - _r$1 = lstat(dirname + "/" + filename); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - fip = _tuple$1[0]; - lerr = _tuple$1[1]; - if (IsNotExist(lerr)) { - _i++; - /* continue; */ $s = 2; continue; - } - if (!($interfaceIsEqual(lerr, $ifaceNil))) { - _tmp = fi; - _tmp$1 = lerr; - fi = _tmp; - err = _tmp$1; - $s = -1; return [fi, err]; - } - fi = $append(fi, fip); - _i++; - /* } */ $s = 2; continue; case 3: - if ((fi.$length === 0) && $interfaceIsEqual(err, $ifaceNil) && n > 0) { - err = io.EOF; - } - _tmp$2 = fi; - _tmp$3 = err; - fi = _tmp$2; - err = _tmp$3; - $s = -1; return [fi, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdir }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dirname = dirname; $f.err = err; $f.f = f; $f.fi = fi; $f.filename = filename; $f.fip = fip; $f.lerr = lerr; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.readdir = function(n) { return this.$val.readdir(n); }; - basename = function(name) { - var i, name; - i = name.length - 1 >> 0; - while (true) { - if (!(i > 0 && (name.charCodeAt(i) === 47))) { break; } - name = $substring(name, 0, i); - i = i - (1) >> 0; - } - i = i - (1) >> 0; - while (true) { - if (!(i >= 0)) { break; } - if (name.charCodeAt(i) === 47) { - name = $substring(name, (i + 1 >> 0)); - break; - } - i = i - (1) >> 0; - } - return name; - }; - init$1 = function() { - if (false) { - return; - } - $pkg.Args = runtime_args(); - }; - Exit = function(code) { - var code; - if (code === 0) { - runtime_beforeExit(); - } - syscall.Exit(code); - }; - $pkg.Exit = Exit; - rawConn.ptr.prototype.Control = function(f) { - var _r, c, err, err$1, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - c = this; - err = c.file.checkValid("SyscallConn.Control"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = c.file.file.pfd.RawControl(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err$1 = _r; - runtime.KeepAlive(c.file); - $s = -1; return err$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Control }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - rawConn.prototype.Control = function(f) { return this.$val.Control(f); }; - rawConn.ptr.prototype.Read = function(f) { - var _r, c, err, err$1, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - c = this; - err = c.file.checkValid("SyscallConn.Read"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = c.file.file.pfd.RawRead(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err$1 = _r; - runtime.KeepAlive(c.file); - $s = -1; return err$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Read }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - rawConn.prototype.Read = function(f) { return this.$val.Read(f); }; - rawConn.ptr.prototype.Write = function(f) { - var _r, c, err, err$1, f, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; err = $f.err; err$1 = $f.err$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - c = this; - err = c.file.checkValid("SyscallConn.Write"); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - _r = c.file.file.pfd.RawWrite(f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err$1 = _r; - runtime.KeepAlive(c.file); - $s = -1; return err$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: rawConn.ptr.prototype.Write }; } $f._r = _r; $f.c = c; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; - }; - rawConn.prototype.Write = function(f) { return this.$val.Write(f); }; - newRawConn = function(file$1) { - var file$1; - return [new rawConn.ptr(file$1), $ifaceNil]; - }; - Lstat = function(name) { - var name, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = testlog.Stat(name); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return lstatNolog(name); - /* */ } return; } if ($f === undefined) { $f = { $blk: Lstat }; } $f.name = name; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Lstat = Lstat; - fillFileStatFromSys = function(fs, name) { - var _1, fs, name; - fs.name = basename(name); - fs.size = fs.sys.Size; - time.Time.copy(fs.modTime, timespecToTime($clone(fs.sys.Mtim, syscall.Timespec))); - fs.mode = ((((fs.sys.Mode & 511) >>> 0) >>> 0)); - _1 = (fs.sys.Mode & 61440) >>> 0; - if (_1 === (24576)) { - fs.mode = (fs.mode | (67108864)) >>> 0; - } else if (_1 === (8192)) { - fs.mode = (fs.mode | (69206016)) >>> 0; - } else if (_1 === (16384)) { - fs.mode = (fs.mode | (2147483648)) >>> 0; - } else if (_1 === (4096)) { - fs.mode = (fs.mode | (33554432)) >>> 0; - } else if (_1 === (40960)) { - fs.mode = (fs.mode | (134217728)) >>> 0; - } else if (_1 === (32768)) { - } else if (_1 === (49152)) { - fs.mode = (fs.mode | (16777216)) >>> 0; - } - if (!((((fs.sys.Mode & 1024) >>> 0) === 0))) { - fs.mode = (fs.mode | (4194304)) >>> 0; - } - if (!((((fs.sys.Mode & 2048) >>> 0) === 0))) { - fs.mode = (fs.mode | (8388608)) >>> 0; - } - if (!((((fs.sys.Mode & 512) >>> 0) === 0))) { - fs.mode = (fs.mode | (1048576)) >>> 0; - } - }; - timespecToTime = function(ts) { - var ts; - return time.Unix((ts.Sec), (ts.Nsec)); - }; - File.ptr.prototype.Stat = function() { - var _r, err, f, fs, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; fs = $f.fs; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fs = [fs]; - f = this; - if (f === ptrType.nil) { - $s = -1; return [$ifaceNil, $pkg.ErrInvalid]; - } - fs[0] = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero())); - _r = f.file.pfd.Fstat(fs[0].sys); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err = _r; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [$ifaceNil, new PathError.ptr("stat", f.file.name, err)]; - } - fillFileStatFromSys(fs[0], f.file.name); - $s = -1; return [fs[0], $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Stat }; } $f._r = _r; $f.err = err; $f.f = f; $f.fs = fs; $f.$s = $s; $f.$r = $r; return $f; - }; - File.prototype.Stat = function() { return this.$val.Stat(); }; - lstatNolog = function(name) { - var err, fs, name; - fs = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$1.zero())); - err = syscall.Lstat(name, fs.sys); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [$ifaceNil, new PathError.ptr("lstat", name, err)]; - } - fillFileStatFromSys(fs, name); - return [fs, $ifaceNil]; - }; - FileMode.prototype.String = function() { - var _i, _i$1, _ref, _ref$1, _rune, _rune$1, buf, c, c$1, i, i$1, m, w, y, y$1; - m = this.$val; - buf = arrayType$6.zero(); - w = 0; - _ref = "dalTLDpSugct?"; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - i = _i; - c = _rune[0]; - if (!((((m & (((y = (((31 - i >> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) { - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c << 24 >>> 24))); - w = w + (1) >> 0; - } - _i += _rune[1]; - } - if (w === 0) { - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); - w = w + (1) >> 0; - } - _ref$1 = "rwxrwxrwx"; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.length)) { break; } - _rune$1 = $decodeRune(_ref$1, _i$1); - i$1 = _i$1; - c$1 = _rune$1[0]; - if (!((((m & (((y$1 = (((8 - i$1 >> 0) >>> 0)), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0) === 0))) { - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c$1 << 24 >>> 24))); - } else { - ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); - } - w = w + (1) >> 0; - _i$1 += _rune$1[1]; - } - return ($bytesToString($subslice(new sliceType$2(buf), 0, w))); - }; - $ptrType(FileMode).prototype.String = function() { return new FileMode(this.$get()).String(); }; - FileMode.prototype.IsDir = function() { - var m; - m = this.$val; - return !((((m & 2147483648) >>> 0) === 0)); - }; - $ptrType(FileMode).prototype.IsDir = function() { return new FileMode(this.$get()).IsDir(); }; - FileMode.prototype.IsRegular = function() { - var m; - m = this.$val; - return ((m & 2401763328) >>> 0) === 0; - }; - $ptrType(FileMode).prototype.IsRegular = function() { return new FileMode(this.$get()).IsRegular(); }; - FileMode.prototype.Perm = function() { - var m; - m = this.$val; - return (m & 511) >>> 0; - }; - $ptrType(FileMode).prototype.Perm = function() { return new FileMode(this.$get()).Perm(); }; - fileStat.ptr.prototype.Name = function() { - var fs; - fs = this; - return fs.name; - }; - fileStat.prototype.Name = function() { return this.$val.Name(); }; - fileStat.ptr.prototype.IsDir = function() { - var fs; - fs = this; - return new FileMode(fs.Mode()).IsDir(); - }; - fileStat.prototype.IsDir = function() { return this.$val.IsDir(); }; - fileStat.ptr.prototype.Size = function() { - var fs; - fs = this; - return fs.size; - }; - fileStat.prototype.Size = function() { return this.$val.Size(); }; - fileStat.ptr.prototype.Mode = function() { - var fs; - fs = this; - return fs.mode; - }; - fileStat.prototype.Mode = function() { return this.$val.Mode(); }; - fileStat.ptr.prototype.ModTime = function() { - var fs; - fs = this; - return fs.modTime; - }; - fileStat.prototype.ModTime = function() { return this.$val.ModTime(); }; - fileStat.ptr.prototype.Sys = function() { - var fs; - fs = this; - return fs.sys; - }; - fileStat.prototype.Sys = function() { return this.$val.Sys(); }; - ptrType$1.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [], false)}]; - ptrType$2.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; - ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; - ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$13.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [$error], false)}]; - ptrType$18.methods = [{prop: "Control", name: "Control", pkg: "", typ: $funcType([funcType$2], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([funcType$3], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([funcType$3], [$error], false)}]; - ptrType.methods = [{prop: "Readdir", name: "Readdir", pkg: "", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "Readdirnames", name: "Readdirnames", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "readdirnames", name: "readdirnames", pkg: "os", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteAt", name: "WriteAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "wrapErr", name: "wrapErr", pkg: "os", typ: $funcType([$String, $error], [$error], false)}, {prop: "Chmod", name: "Chmod", pkg: "", typ: $funcType([FileMode], [$error], false)}, {prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SyscallConn", name: "SyscallConn", pkg: "", typ: $funcType([], [syscall.RawConn, $error], false)}, {prop: "chmod", name: "chmod", pkg: "os", typ: $funcType([FileMode], [$error], false)}, {prop: "Chown", name: "Chown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Sync", name: "Sync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "setDeadline", name: "setDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setReadDeadline", name: "setReadDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setWriteDeadline", name: "setWriteDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "checkValid", name: "checkValid", pkg: "os", typ: $funcType([$String], [$error], false)}, {prop: "Fd", name: "Fd", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "read", name: "read", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pread", name: "pread", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "write", name: "write", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pwrite", name: "pwrite", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "seek", name: "seek", pkg: "os", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "readdir", name: "readdir", pkg: "os", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([], [FileInfo, $error], false)}]; - FileMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsRegular", name: "IsRegular", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([], [FileMode], false)}]; - ptrType$16.methods = [{prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]; - dirInfo.init("os", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "nbuf", name: "nbuf", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "bufp", name: "bufp", embedded: false, exported: false, typ: $Int, tag: ""}]); - timeout.init([{prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]); - PathError.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Path", name: "Path", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); - SyscallError.init("", [{prop: "Syscall", name: "Syscall", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); - LinkError.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Old", name: "Old", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "New", name: "New", embedded: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); - file.init("os", [{prop: "pfd", name: "pfd", embedded: false, exported: false, typ: poll.FD, tag: ""}, {prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "dirinfo", name: "dirinfo", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "nonblock", name: "nonblock", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "stdoutOrErr", name: "stdoutOrErr", embedded: false, exported: false, typ: $Bool, tag: ""}]); - rawConn.init("os", [{prop: "file", name: "file", embedded: false, exported: false, typ: ptrType, tag: ""}]); - File.init("os", [{prop: "file", name: "file", embedded: true, exported: false, typ: ptrType$13, tag: ""}]); - FileInfo.init([{prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]); - fileStat.init("os", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "size", name: "size", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "mode", name: "mode", embedded: false, exported: false, typ: FileMode, tag: ""}, {prop: "modTime", name: "modTime", embedded: false, exported: false, typ: time.Time, tag: ""}, {prop: "sys", name: "sys", embedded: false, exported: false, typ: syscall.Stat_t, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = poll.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unix.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = testlog.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = atomic.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = syscall.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.Args = sliceType.nil; - $pkg.ErrInvalid = errors.New("invalid argument"); - $pkg.ErrPermission = errors.New("permission denied"); - $pkg.ErrExist = errors.New("file already exists"); - $pkg.ErrNotExist = errors.New("file does not exist"); - $pkg.ErrClosed = errors.New("file already closed"); - errFinished = errors.New("os: process already finished"); - $pkg.Stdin = NewFile(((syscall.Stdin >>> 0)), "/dev/stdin"); - $pkg.Stdout = NewFile(((syscall.Stdout >>> 0)), "/dev/stdout"); - $pkg.Stderr = NewFile(((syscall.Stderr >>> 0)), "/dev/stderr"); - lstat = Lstat; - init(); - init$1(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["fmt"] = (function() { - var $pkg = {}, $init, errors, fmtsort, io, math, os, reflect, strconv, sync, utf8, fmtFlags, fmt, State, Formatter, Stringer, GoStringer, buffer, pp, ScanState, scanError, ss, ssave, sliceType, ptrType, ptrType$1, arrayType, arrayType$1, sliceType$1, sliceType$2, arrayType$2, ptrType$2, ptrType$5, ptrType$25, funcType, ppFree, space, ssFree, complexError, boolError, newPrinter, Fprintf, Sprintf, Errorf, Fprint, Sprint, Sprintln, getField, tooLarge, parsenum, intFromArg, parseArgNumber, isSpace, notSpace, indexRune; - errors = $packages["errors"]; - fmtsort = $packages["internal/fmtsort"]; - io = $packages["io"]; - math = $packages["math"]; - os = $packages["os"]; - reflect = $packages["reflect"]; - strconv = $packages["strconv"]; - sync = $packages["sync"]; - utf8 = $packages["unicode/utf8"]; - fmtFlags = $pkg.fmtFlags = $newType(0, $kindStruct, "fmt.fmtFlags", true, "fmt", false, function(widPresent_, precPresent_, minus_, plus_, sharp_, space_, zero_, plusV_, sharpV_) { - this.$val = this; - if (arguments.length === 0) { - this.widPresent = false; - this.precPresent = false; - this.minus = false; - this.plus = false; - this.sharp = false; - this.space = false; - this.zero = false; - this.plusV = false; - this.sharpV = false; - return; - } - this.widPresent = widPresent_; - this.precPresent = precPresent_; - this.minus = minus_; - this.plus = plus_; - this.sharp = sharp_; - this.space = space_; - this.zero = zero_; - this.plusV = plusV_; - this.sharpV = sharpV_; - }); - fmt = $pkg.fmt = $newType(0, $kindStruct, "fmt.fmt", true, "fmt", false, function(buf_, fmtFlags_, wid_, prec_, intbuf_) { - this.$val = this; - if (arguments.length === 0) { - this.buf = ptrType$1.nil; - this.fmtFlags = new fmtFlags.ptr(false, false, false, false, false, false, false, false, false); - this.wid = 0; - this.prec = 0; - this.intbuf = arrayType.zero(); - return; - } - this.buf = buf_; - this.fmtFlags = fmtFlags_; - this.wid = wid_; - this.prec = prec_; - this.intbuf = intbuf_; - }); - State = $pkg.State = $newType(8, $kindInterface, "fmt.State", true, "fmt", true, null); - Formatter = $pkg.Formatter = $newType(8, $kindInterface, "fmt.Formatter", true, "fmt", true, null); - Stringer = $pkg.Stringer = $newType(8, $kindInterface, "fmt.Stringer", true, "fmt", true, null); - GoStringer = $pkg.GoStringer = $newType(8, $kindInterface, "fmt.GoStringer", true, "fmt", true, null); - buffer = $pkg.buffer = $newType(12, $kindSlice, "fmt.buffer", true, "fmt", false, null); - pp = $pkg.pp = $newType(0, $kindStruct, "fmt.pp", true, "fmt", false, function(buf_, arg_, value_, fmt_, reordered_, goodArgNum_, panicking_, erroring_) { - this.$val = this; - if (arguments.length === 0) { - this.buf = buffer.nil; - this.arg = $ifaceNil; - this.value = new reflect.Value.ptr(ptrType.nil, 0, 0); - this.fmt = new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()); - this.reordered = false; - this.goodArgNum = false; - this.panicking = false; - this.erroring = false; - return; - } - this.buf = buf_; - this.arg = arg_; - this.value = value_; - this.fmt = fmt_; - this.reordered = reordered_; - this.goodArgNum = goodArgNum_; - this.panicking = panicking_; - this.erroring = erroring_; - }); - ScanState = $pkg.ScanState = $newType(8, $kindInterface, "fmt.ScanState", true, "fmt", true, null); - scanError = $pkg.scanError = $newType(0, $kindStruct, "fmt.scanError", true, "fmt", false, function(err_) { - this.$val = this; - if (arguments.length === 0) { - this.err = $ifaceNil; - return; - } - this.err = err_; - }); - ss = $pkg.ss = $newType(0, $kindStruct, "fmt.ss", true, "fmt", false, function(rs_, buf_, count_, atEOF_, ssave_) { - this.$val = this; - if (arguments.length === 0) { - this.rs = $ifaceNil; - this.buf = buffer.nil; - this.count = 0; - this.atEOF = false; - this.ssave = new ssave.ptr(false, false, false, 0, 0, 0); - return; - } - this.rs = rs_; - this.buf = buf_; - this.count = count_; - this.atEOF = atEOF_; - this.ssave = ssave_; - }); - ssave = $pkg.ssave = $newType(0, $kindStruct, "fmt.ssave", true, "fmt", false, function(validSave_, nlIsEnd_, nlIsSpace_, argLimit_, limit_, maxWid_) { - this.$val = this; - if (arguments.length === 0) { - this.validSave = false; - this.nlIsEnd = false; - this.nlIsSpace = false; - this.argLimit = 0; - this.limit = 0; - this.maxWid = 0; - return; - } - this.validSave = validSave_; - this.nlIsEnd = nlIsEnd_; - this.nlIsSpace = nlIsSpace_; - this.argLimit = argLimit_; - this.limit = limit_; - this.maxWid = maxWid_; - }); - sliceType = $sliceType($emptyInterface); - ptrType = $ptrType(reflect.rtype); - ptrType$1 = $ptrType(buffer); - arrayType = $arrayType($Uint8, 68); - arrayType$1 = $arrayType($Uint16, 2); - sliceType$1 = $sliceType(arrayType$1); - sliceType$2 = $sliceType($Uint8); - arrayType$2 = $arrayType($Uint8, 5); - ptrType$2 = $ptrType(pp); - ptrType$5 = $ptrType(ss); - ptrType$25 = $ptrType(fmt); - funcType = $funcType([$Int32], [$Bool], false); - fmt.ptr.prototype.clearflags = function() { - var f; - f = this; - fmtFlags.copy(f.fmtFlags, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false)); - }; - fmt.prototype.clearflags = function() { return this.$val.clearflags(); }; - fmt.ptr.prototype.init = function(buf) { - var buf, f; - f = this; - f.buf = buf; - f.clearflags(); - }; - fmt.prototype.init = function(buf) { return this.$val.init(buf); }; - fmt.ptr.prototype.writePadding = function(n) { - var _i, _ref, buf, f, i, n, newLen, oldLen, padByte, padding; - f = this; - if (n <= 0) { - return; - } - buf = f.buf.$get(); - oldLen = buf.$length; - newLen = oldLen + n >> 0; - if (newLen > buf.$capacity) { - buf = $makeSlice(buffer, (($imul(buf.$capacity, 2)) + n >> 0)); - $copySlice(buf, f.buf.$get()); - } - padByte = 32; - if (f.fmtFlags.zero) { - padByte = 48; - } - padding = $subslice(buf, oldLen, newLen); - _ref = padding; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - ((i < 0 || i >= padding.$length) ? ($throwRuntimeError("index out of range"), undefined) : padding.$array[padding.$offset + i] = padByte); - _i++; - } - f.buf.$set($subslice(buf, 0, newLen)); - }; - fmt.prototype.writePadding = function(n) { return this.$val.writePadding(n); }; - fmt.ptr.prototype.pad = function(b) { - var b, f, width; - f = this; - if (!f.fmtFlags.widPresent || (f.wid === 0)) { - f.buf.Write(b); - return; - } - width = f.wid - utf8.RuneCount(b) >> 0; - if (!f.fmtFlags.minus) { - f.writePadding(width); - f.buf.Write(b); - } else { - f.buf.Write(b); - f.writePadding(width); - } - }; - fmt.prototype.pad = function(b) { return this.$val.pad(b); }; - fmt.ptr.prototype.padString = function(s) { - var f, s, width; - f = this; - if (!f.fmtFlags.widPresent || (f.wid === 0)) { - f.buf.WriteString(s); - return; - } - width = f.wid - utf8.RuneCountInString(s) >> 0; - if (!f.fmtFlags.minus) { - f.writePadding(width); - f.buf.WriteString(s); - } else { - f.buf.WriteString(s); - f.writePadding(width); - } - }; - fmt.prototype.padString = function(s) { return this.$val.padString(s); }; - fmt.ptr.prototype.fmtBoolean = function(v) { - var f, v; - f = this; - if (v) { - f.padString("true"); - } else { - f.padString("false"); - } - }; - fmt.prototype.fmtBoolean = function(v) { return this.$val.fmtBoolean(v); }; - fmt.ptr.prototype.fmtUnicode = function(u) { - var buf, f, i, oldZero, prec, u, width; - f = this; - buf = $subslice(new sliceType$2(f.intbuf), 0); - prec = 4; - if (f.fmtFlags.precPresent && f.prec > 4) { - prec = f.prec; - width = (((2 + prec >> 0) + 2 >> 0) + 4 >> 0) + 1 >> 0; - if (width > buf.$length) { - buf = $makeSlice(sliceType$2, width); - } - } - i = buf.$length; - if (f.fmtFlags.sharp && (u.$high < 0 || (u.$high === 0 && u.$low <= 1114111)) && strconv.IsPrint(((u.$low >> 0)))) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); - i = i - (utf8.RuneLen(((u.$low >> 0)))) >> 0; - utf8.EncodeRune($subslice(buf, i), ((u.$low >> 0))); - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); - } - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); - prec = prec - (1) >> 0; - u = $shiftRightUint64(u, (4)); - } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(u))); - prec = prec - (1) >> 0; - while (true) { - if (!(prec > 0)) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); - prec = prec - (1) >> 0; - } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 85); - oldZero = f.fmtFlags.zero; - f.fmtFlags.zero = false; - f.pad($subslice(buf, i)); - f.fmtFlags.zero = oldZero; - }; - fmt.prototype.fmtUnicode = function(u) { return this.$val.fmtUnicode(u); }; - fmt.ptr.prototype.fmtInteger = function(u, base, isSigned, digits) { - var _1, _2, base, buf, digits, f, i, isSigned, negative, next, oldZero, oldZero$1, prec, u, width, x, x$1, x$2, x$3, x$4; - f = this; - negative = isSigned && (x = (new $Int64(u.$high, u.$low)), (x.$high < 0 || (x.$high === 0 && x.$low < 0))); - if (negative) { - u = new $Uint64(-u.$high, -u.$low); - } - buf = $subslice(new sliceType$2(f.intbuf), 0); - if (f.fmtFlags.widPresent || f.fmtFlags.precPresent) { - width = (3 + f.wid >> 0) + f.prec >> 0; - if (width > buf.$length) { - buf = $makeSlice(sliceType$2, width); - } - } - prec = 0; - if (f.fmtFlags.precPresent) { - prec = f.prec; - if ((prec === 0) && (u.$high === 0 && u.$low === 0)) { - oldZero = f.fmtFlags.zero; - f.fmtFlags.zero = false; - f.writePadding(f.wid); - f.fmtFlags.zero = oldZero; - return; - } - } else if (f.fmtFlags.zero && f.fmtFlags.widPresent) { - prec = f.wid; - if (negative || f.fmtFlags.plus || f.fmtFlags.space) { - prec = prec - (1) >> 0; - } - } - i = buf.$length; - _1 = base; - if (_1 === (10)) { - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 10)))) { break; } - i = i - (1) >> 0; - next = $div64(u, new $Uint64(0, 10), false); - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$1 = new $Uint64(0 + u.$high, 48 + u.$low), x$2 = $mul64(next, new $Uint64(0, 10)), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)).$low << 24 >>> 24))); - u = next; - } - } else if (_1 === (16)) { - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); - u = $shiftRightUint64(u, (4)); - } - } else if (_1 === (8)) { - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 8)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$3 = new $Uint64(u.$high & 0, (u.$low & 7) >>> 0), new $Uint64(0 + x$3.$high, 48 + x$3.$low)).$low << 24 >>> 24))); - u = $shiftRightUint64(u, (3)); - } - } else if (_1 === (2)) { - while (true) { - if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 2)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$4 = new $Uint64(u.$high & 0, (u.$low & 1) >>> 0), new $Uint64(0 + x$4.$high, 48 + x$4.$low)).$low << 24 >>> 24))); - u = $shiftRightUint64(u, (1)); - } - } else { - $panic(new $String("fmt: unknown base; can't happen")); - } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(u))); - while (true) { - if (!(i > 0 && prec > (buf.$length - i >> 0))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); - } - if (f.fmtFlags.sharp) { - _2 = base; - if (_2 === (8)) { - if (!((((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i]) === 48))) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); - } - } else if (_2 === (16)) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt(16)); - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); - } - } - if (negative) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 45); - } else if (f.fmtFlags.plus) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); - } else if (f.fmtFlags.space) { - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); - } - oldZero$1 = f.fmtFlags.zero; - f.fmtFlags.zero = false; - f.pad($subslice(buf, i)); - f.fmtFlags.zero = oldZero$1; - }; - fmt.prototype.fmtInteger = function(u, base, isSigned, digits) { return this.$val.fmtInteger(u, base, isSigned, digits); }; - fmt.ptr.prototype.truncateString = function(s) { - var _i, _ref, _rune, f, i, n, s; - f = this; - if (f.fmtFlags.precPresent) { - n = f.prec; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - i = _i; - n = n - (1) >> 0; - if (n < 0) { - return $substring(s, 0, i); - } - _i += _rune[1]; - } - } - return s; - }; - fmt.prototype.truncateString = function(s) { return this.$val.truncateString(s); }; - fmt.ptr.prototype.truncate = function(b) { - var _tuple, b, f, i, n, wid; - f = this; - if (f.fmtFlags.precPresent) { - n = f.prec; - i = 0; - while (true) { - if (!(i < b.$length)) { break; } - n = n - (1) >> 0; - if (n < 0) { - return $subslice(b, 0, i); - } - wid = 1; - if (((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) >= 128) { - _tuple = utf8.DecodeRune($subslice(b, i)); - wid = _tuple[1]; - } - i = i + (wid) >> 0; - } - } - return b; - }; - fmt.prototype.truncate = function(b) { return this.$val.truncate(b); }; - fmt.ptr.prototype.fmtS = function(s) { - var f, s; - f = this; - s = f.truncateString(s); - f.padString(s); - }; - fmt.prototype.fmtS = function(s) { return this.$val.fmtS(s); }; - fmt.ptr.prototype.fmtBs = function(b) { - var b, f; - f = this; - b = f.truncate(b); - f.pad(b); - }; - fmt.prototype.fmtBs = function(b) { return this.$val.fmtBs(b); }; - fmt.ptr.prototype.fmtSbx = function(s, b, digits) { - var b, buf, c, digits, f, i, length, s, width; - f = this; - length = b.$length; - if (b === sliceType$2.nil) { - length = s.length; - } - if (f.fmtFlags.precPresent && f.prec < length) { - length = f.prec; - } - width = $imul(2, length); - if (width > 0) { - if (f.fmtFlags.space) { - if (f.fmtFlags.sharp) { - width = $imul(width, (2)); - } - width = width + ((length - 1 >> 0)) >> 0; - } else if (f.fmtFlags.sharp) { - width = width + (2) >> 0; - } - } else { - if (f.fmtFlags.widPresent) { - f.writePadding(f.wid); - } - return; - } - if (f.fmtFlags.widPresent && f.wid > width && !f.fmtFlags.minus) { - f.writePadding(f.wid - width >> 0); - } - buf = f.buf.$get(); - if (f.fmtFlags.sharp) { - buf = $append(buf, 48, digits.charCodeAt(16)); - } - c = 0; - i = 0; - while (true) { - if (!(i < length)) { break; } - if (f.fmtFlags.space && i > 0) { - buf = $append(buf, 32); - if (f.fmtFlags.sharp) { - buf = $append(buf, 48, digits.charCodeAt(16)); - } - } - if (!(b === sliceType$2.nil)) { - c = ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]); - } else { - c = s.charCodeAt(i); - } - buf = $append(buf, digits.charCodeAt((c >>> 4 << 24 >>> 24)), digits.charCodeAt(((c & 15) >>> 0))); - i = i + (1) >> 0; - } - f.buf.$set(buf); - if (f.fmtFlags.widPresent && f.wid > width && f.fmtFlags.minus) { - f.writePadding(f.wid - width >> 0); - } - }; - fmt.prototype.fmtSbx = function(s, b, digits) { return this.$val.fmtSbx(s, b, digits); }; - fmt.ptr.prototype.fmtSx = function(s, digits) { - var digits, f, s; - f = this; - f.fmtSbx(s, sliceType$2.nil, digits); - }; - fmt.prototype.fmtSx = function(s, digits) { return this.$val.fmtSx(s, digits); }; - fmt.ptr.prototype.fmtBx = function(b, digits) { - var b, digits, f; - f = this; - f.fmtSbx("", b, digits); - }; - fmt.prototype.fmtBx = function(b, digits) { return this.$val.fmtBx(b, digits); }; - fmt.ptr.prototype.fmtQ = function(s) { - var buf, f, s; - f = this; - s = f.truncateString(s); - if (f.fmtFlags.sharp && strconv.CanBackquote(s)) { - f.padString("`" + s + "`"); - return; - } - buf = $subslice(new sliceType$2(f.intbuf), 0, 0); - if (f.fmtFlags.plus) { - f.pad(strconv.AppendQuoteToASCII(buf, s)); - } else { - f.pad(strconv.AppendQuote(buf, s)); - } - }; - fmt.prototype.fmtQ = function(s) { return this.$val.fmtQ(s); }; - fmt.ptr.prototype.fmtC = function(c) { - var buf, c, f, r, w; - f = this; - r = ((c.$low >> 0)); - if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { - r = 65533; - } - buf = $subslice(new sliceType$2(f.intbuf), 0, 0); - w = utf8.EncodeRune($subslice(buf, 0, 4), r); - f.pad($subslice(buf, 0, w)); - }; - fmt.prototype.fmtC = function(c) { return this.$val.fmtC(c); }; - fmt.ptr.prototype.fmtQc = function(c) { - var buf, c, f, r; - f = this; - r = ((c.$low >> 0)); - if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { - r = 65533; - } - buf = $subslice(new sliceType$2(f.intbuf), 0, 0); - if (f.fmtFlags.plus) { - f.pad(strconv.AppendQuoteRuneToASCII(buf, r)); - } else { - f.pad(strconv.AppendQuoteRune(buf, r)); - } - }; - fmt.prototype.fmtQc = function(c) { return this.$val.fmtQc(c); }; - fmt.ptr.prototype.fmtFloat = function(v, size, verb, prec) { - var _1, _2, digits, f, hasDecimalPoint, i, num, oldZero, prec, size, tail, tailBuf, v, verb; - f = this; - if (f.fmtFlags.precPresent) { - prec = f.prec; - } - num = strconv.AppendFloat($subslice(new sliceType$2(f.intbuf), 0, 1), v, ((verb << 24 >>> 24)), prec, size); - if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 45) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 43)) { - num = $subslice(num, 1); - } else { - (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 43); - } - if (f.fmtFlags.space && ((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43) && !f.fmtFlags.plus) { - (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 32); - } - if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 73) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78)) { - oldZero = f.fmtFlags.zero; - f.fmtFlags.zero = false; - if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78) && !f.fmtFlags.space && !f.fmtFlags.plus) { - num = $subslice(num, 1); - } - f.pad(num); - f.fmtFlags.zero = oldZero; - return; - } - if (f.fmtFlags.sharp && !((verb === 98))) { - digits = 0; - _1 = verb; - if ((_1 === (118)) || (_1 === (103)) || (_1 === (71))) { - digits = prec; - if (digits === -1) { - digits = 6; - } - } - tailBuf = arrayType$2.zero(); - tail = $subslice(new sliceType$2(tailBuf), 0, 0); - hasDecimalPoint = false; - i = 1; - while (true) { - if (!(i < num.$length)) { break; } - _2 = ((i < 0 || i >= num.$length) ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + i]); - if (_2 === (46)) { - hasDecimalPoint = true; - } else if ((_2 === (101)) || (_2 === (69))) { - tail = $appendSlice(tail, $subslice(num, i)); - num = $subslice(num, 0, i); - } else { - digits = digits - (1) >> 0; - } - i = i + (1) >> 0; - } - if (!hasDecimalPoint) { - num = $append(num, 46); - } - while (true) { - if (!(digits > 0)) { break; } - num = $append(num, 48); - digits = digits - (1) >> 0; - } - num = $appendSlice(num, tail); - } - if (f.fmtFlags.plus || !(((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43))) { - if (f.fmtFlags.zero && f.fmtFlags.widPresent && f.wid > num.$length) { - f.buf.WriteByte((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0])); - f.writePadding(f.wid - num.$length >> 0); - f.buf.Write($subslice(num, 1)); - return; - } - f.pad(num); - return; - } - f.pad($subslice(num, 1)); - }; - fmt.prototype.fmtFloat = function(v, size, verb, prec) { return this.$val.fmtFloat(v, size, verb, prec); }; - $ptrType(buffer).prototype.Write = function(p) { - var b, p; - b = this; - b.$set($appendSlice(b.$get(), p)); - }; - $ptrType(buffer).prototype.WriteString = function(s) { - var b, s; - b = this; - b.$set($appendSlice(b.$get(), s)); - }; - $ptrType(buffer).prototype.WriteByte = function(c) { - var b, c; - b = this; - b.$set($append(b.$get(), c)); - }; - $ptrType(buffer).prototype.WriteRune = function(r) { - var b, bp, n, r, w, x; - bp = this; - if (r < 128) { - bp.$set($append(bp.$get(), ((r << 24 >>> 24)))); - return; - } - b = bp.$get(); - n = b.$length; - while (true) { - if (!((n + 4 >> 0) > b.$capacity)) { break; } - b = $append(b, 0); - } - w = utf8.EncodeRune((x = $subslice(b, n, (n + 4 >> 0)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)), r); - bp.$set($subslice(b, 0, (n + w >> 0))); - }; - newPrinter = function() { - var _r, p, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = ppFree.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = $assertType(_r, ptrType$2); - p.panicking = false; - p.erroring = false; - p.fmt.init((p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p)))); - $s = -1; return p; - /* */ } return; } if ($f === undefined) { $f = { $blk: newPrinter }; } $f._r = _r; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.ptr.prototype.free = function() { - var p; - p = this; - if (p.buf.$capacity > 65536) { - return; - } - p.buf = $subslice(p.buf, 0, 0); - p.arg = $ifaceNil; - p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); - ppFree.Put(p); - }; - pp.prototype.free = function() { return this.$val.free(); }; - pp.ptr.prototype.Width = function() { - var _tmp, _tmp$1, ok, p, wid; - wid = 0; - ok = false; - p = this; - _tmp = p.fmt.wid; - _tmp$1 = p.fmt.fmtFlags.widPresent; - wid = _tmp; - ok = _tmp$1; - return [wid, ok]; - }; - pp.prototype.Width = function() { return this.$val.Width(); }; - pp.ptr.prototype.Precision = function() { - var _tmp, _tmp$1, ok, p, prec; - prec = 0; - ok = false; - p = this; - _tmp = p.fmt.prec; - _tmp$1 = p.fmt.fmtFlags.precPresent; - prec = _tmp; - ok = _tmp$1; - return [prec, ok]; - }; - pp.prototype.Precision = function() { return this.$val.Precision(); }; - pp.ptr.prototype.Flag = function(b) { - var _1, b, p; - p = this; - _1 = b; - if (_1 === (45)) { - return p.fmt.fmtFlags.minus; - } else if (_1 === (43)) { - return p.fmt.fmtFlags.plus || p.fmt.fmtFlags.plusV; - } else if (_1 === (35)) { - return p.fmt.fmtFlags.sharp || p.fmt.fmtFlags.sharpV; - } else if (_1 === (32)) { - return p.fmt.fmtFlags.space; - } else if (_1 === (48)) { - return p.fmt.fmtFlags.zero; - } - return false; - }; - pp.prototype.Flag = function(b) { return this.$val.Flag(b); }; - pp.ptr.prototype.Write = function(b) { - var _tmp, _tmp$1, b, err, p, ret; - ret = 0; - err = $ifaceNil; - p = this; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(b); - _tmp = b.$length; - _tmp$1 = $ifaceNil; - ret = _tmp; - err = _tmp$1; - return [ret, err]; - }; - pp.prototype.Write = function(b) { return this.$val.Write(b); }; - pp.ptr.prototype.WriteString = function(s) { - var _tmp, _tmp$1, err, p, ret, s; - ret = 0; - err = $ifaceNil; - p = this; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(s); - _tmp = s.length; - _tmp$1 = $ifaceNil; - ret = _tmp; - err = _tmp$1; - return [ret, err]; - }; - pp.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; - Fprintf = function(w, format, a) { - var _r, _r$1, _tuple, a, err, format, n, p, w, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - n = _tuple[0]; - err = _tuple[1]; - p.free(); - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintf }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Fprintf = Fprintf; - Sprintf = function(format, a) { - var _r, a, format, p, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; format = $f.format; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - s = ($bytesToString(p.buf)); - p.free(); - $s = -1; return s; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintf }; } $f._r = _r; $f.a = a; $f.format = format; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sprintf = Sprintf; - Errorf = function(format, a) { - var _r, _r$1, a, format, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; a = $f.a; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = Sprintf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = errors.New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Errorf }; } $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.format = format; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Errorf = Errorf; - Fprint = function(w, a) { - var _r, _r$1, _tuple, a, err, n, p, w, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - $r = p.doPrint(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - n = _tuple[0]; - err = _tuple[1]; - p.free(); - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Fprint }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Fprint = Fprint; - Sprint = function(a) { - var _r, a, p, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - $r = p.doPrint(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - s = ($bytesToString(p.buf)); - p.free(); - $s = -1; return s; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sprint }; } $f._r = _r; $f.a = a; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sprint = Sprint; - Sprintln = function(a) { - var _r, a, p, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - $r = p.doPrintln(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - s = ($bytesToString(p.buf)); - p.free(); - $s = -1; return s; - /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintln }; } $f._r = _r; $f.a = a; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Sprintln = Sprintln; - getField = function(v, i) { - var _r, _r$1, i, v, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = $clone(v, reflect.Value).Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - val = _r; - /* */ if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { */ case 2: - _r$1 = $clone(val, reflect.Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - val = _r$1; - /* } */ case 3: - $s = -1; return val; - /* */ } return; } if ($f === undefined) { $f = { $blk: getField }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - tooLarge = function(x) { - var x; - return x > 1000000 || x < -1000000; - }; - parsenum = function(s, start, end) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, end, isnum, newi, num, s, start; - num = 0; - isnum = false; - newi = 0; - if (start >= end) { - _tmp = 0; - _tmp$1 = false; - _tmp$2 = end; - num = _tmp; - isnum = _tmp$1; - newi = _tmp$2; - return [num, isnum, newi]; - } - newi = start; - while (true) { - if (!(newi < end && 48 <= s.charCodeAt(newi) && s.charCodeAt(newi) <= 57)) { break; } - if (tooLarge(num)) { - _tmp$3 = 0; - _tmp$4 = false; - _tmp$5 = end; - num = _tmp$3; - isnum = _tmp$4; - newi = _tmp$5; - return [num, isnum, newi]; - } - num = ($imul(num, 10)) + (((s.charCodeAt(newi) - 48 << 24 >>> 24) >> 0)) >> 0; - isnum = true; - newi = newi + (1) >> 0; - } - return [num, isnum, newi]; - }; - pp.ptr.prototype.unknownType = function(v) { - var _r, p, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - if (!$clone(v, reflect.Value).IsValid()) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - $s = -1; return; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); - _r = $clone(v, reflect.Value).Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.unknownType }; } $f._r = _r; $f.p = p; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.unknownType = function(v) { return this.$val.unknownType(v); }; - pp.ptr.prototype.badVerb = function(verb) { - var _r, _r$1, p, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - p.erroring = true; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); - /* */ if (!($interfaceIsEqual(p.arg, $ifaceNil))) { $s = 2; continue; } - /* */ if ($clone(p.value, reflect.Value).IsValid()) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!($interfaceIsEqual(p.arg, $ifaceNil))) { */ case 2: - _r = reflect.TypeOf(p.arg).String(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); - $r = p.printArg(p.arg, 118); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 5; continue; - /* } else if ($clone(p.value, reflect.Value).IsValid()) { */ case 3: - _r$1 = $clone(p.value, reflect.Value).Type().String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); - $r = p.printValue($clone(p.value, reflect.Value), 118, 0); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 5; continue; - /* } else { */ case 4: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - /* } */ case 5: - case 1: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); - p.erroring = false; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.badVerb }; } $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.badVerb = function(verb) { return this.$val.badVerb(verb); }; - pp.ptr.prototype.fmtBool = function(v, verb) { - var _1, p, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if ((_1 === (116)) || (_1 === (118))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if ((_1 === (116)) || (_1 === (118))) { */ case 2: - p.fmt.fmtBoolean(v); - $s = 4; continue; - /* } else { */ case 3: - $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 4: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBool }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtBool = function(v, verb) { return this.$val.fmtBool(v, verb); }; - pp.ptr.prototype.fmt0x64 = function(v, leading0x) { - var leading0x, p, sharp, v; - p = this; - sharp = p.fmt.fmtFlags.sharp; - p.fmt.fmtFlags.sharp = leading0x; - p.fmt.fmtInteger(v, 16, false, "0123456789abcdefx"); - p.fmt.fmtFlags.sharp = sharp; - }; - pp.prototype.fmt0x64 = function(v, leading0x) { return this.$val.fmt0x64(v, leading0x); }; - pp.ptr.prototype.fmtInteger = function(v, isSigned, verb) { - var _1, isSigned, p, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; isSigned = $f.isSigned; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if (_1 === (118)) { $s = 2; continue; } - /* */ if (_1 === (100)) { $s = 3; continue; } - /* */ if (_1 === (98)) { $s = 4; continue; } - /* */ if (_1 === (111)) { $s = 5; continue; } - /* */ if (_1 === (120)) { $s = 6; continue; } - /* */ if (_1 === (88)) { $s = 7; continue; } - /* */ if (_1 === (99)) { $s = 8; continue; } - /* */ if (_1 === (113)) { $s = 9; continue; } - /* */ if (_1 === (85)) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (_1 === (118)) { */ case 2: - if (p.fmt.fmtFlags.sharpV && !isSigned) { - p.fmt0x64(v, true); - } else { - p.fmt.fmtInteger(v, 10, isSigned, "0123456789abcdefx"); - } - $s = 12; continue; - /* } else if (_1 === (100)) { */ case 3: - p.fmt.fmtInteger(v, 10, isSigned, "0123456789abcdefx"); - $s = 12; continue; - /* } else if (_1 === (98)) { */ case 4: - p.fmt.fmtInteger(v, 2, isSigned, "0123456789abcdefx"); - $s = 12; continue; - /* } else if (_1 === (111)) { */ case 5: - p.fmt.fmtInteger(v, 8, isSigned, "0123456789abcdefx"); - $s = 12; continue; - /* } else if (_1 === (120)) { */ case 6: - p.fmt.fmtInteger(v, 16, isSigned, "0123456789abcdefx"); - $s = 12; continue; - /* } else if (_1 === (88)) { */ case 7: - p.fmt.fmtInteger(v, 16, isSigned, "0123456789ABCDEFX"); - $s = 12; continue; - /* } else if (_1 === (99)) { */ case 8: - p.fmt.fmtC(v); - $s = 12; continue; - /* } else if (_1 === (113)) { */ case 9: - /* */ if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 13: - p.fmt.fmtQc(v); - $s = 15; continue; - /* } else { */ case 14: - $r = p.badVerb(verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 15: - $s = 12; continue; - /* } else if (_1 === (85)) { */ case 10: - p.fmt.fmtUnicode(v); - $s = 12; continue; - /* } else { */ case 11: - $r = p.badVerb(verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 12: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtInteger }; } $f._1 = _1; $f.isSigned = isSigned; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtInteger = function(v, isSigned, verb) { return this.$val.fmtInteger(v, isSigned, verb); }; - pp.ptr.prototype.fmtFloat = function(v, size, verb) { - var _1, p, size, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if (_1 === (118)) { $s = 2; continue; } - /* */ if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { $s = 3; continue; } - /* */ if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { $s = 4; continue; } - /* */ if (_1 === (70)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_1 === (118)) { */ case 2: - p.fmt.fmtFloat(v, size, 103, -1); - $s = 7; continue; - /* } else if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { */ case 3: - p.fmt.fmtFloat(v, size, verb, -1); - $s = 7; continue; - /* } else if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { */ case 4: - p.fmt.fmtFloat(v, size, verb, 6); - $s = 7; continue; - /* } else if (_1 === (70)) { */ case 5: - p.fmt.fmtFloat(v, size, 102, 6); - $s = 7; continue; - /* } else { */ case 6: - $r = p.badVerb(verb); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 7: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat }; } $f._1 = _1; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtFloat = function(v, size, verb) { return this.$val.fmtFloat(v, size, verb); }; - pp.ptr.prototype.fmtComplex = function(v, size, verb) { - var _1, _q, _q$1, oldPlus, p, size, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; oldPlus = $f.oldPlus; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { */ case 2: - oldPlus = p.fmt.fmtFlags.plus; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); - $r = p.fmtFloat(v.$real, (_q = size / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - p.fmt.fmtFlags.plus = true; - $r = p.fmtFloat(v.$imag, (_q$1 = size / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("i)"); - p.fmt.fmtFlags.plus = oldPlus; - $s = 4; continue; - /* } else { */ case 3: - $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 4: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f.oldPlus = oldPlus; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtComplex = function(v, size, verb) { return this.$val.fmtComplex(v, size, verb); }; - pp.ptr.prototype.fmtString = function(v, verb) { - var _1, p, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if (_1 === (118)) { $s = 2; continue; } - /* */ if (_1 === (115)) { $s = 3; continue; } - /* */ if (_1 === (120)) { $s = 4; continue; } - /* */ if (_1 === (88)) { $s = 5; continue; } - /* */ if (_1 === (113)) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (_1 === (118)) { */ case 2: - if (p.fmt.fmtFlags.sharpV) { - p.fmt.fmtQ(v); - } else { - p.fmt.fmtS(v); - } - $s = 8; continue; - /* } else if (_1 === (115)) { */ case 3: - p.fmt.fmtS(v); - $s = 8; continue; - /* } else if (_1 === (120)) { */ case 4: - p.fmt.fmtSx(v, "0123456789abcdefx"); - $s = 8; continue; - /* } else if (_1 === (88)) { */ case 5: - p.fmt.fmtSx(v, "0123456789ABCDEFX"); - $s = 8; continue; - /* } else if (_1 === (113)) { */ case 6: - p.fmt.fmtQ(v); - $s = 8; continue; - /* } else { */ case 7: - $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 8: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtString }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtString = function(v, verb) { return this.$val.fmtString(v, verb); }; - pp.ptr.prototype.fmtBytes = function(v, verb, typeString) { - var _1, _i, _i$1, _r, _ref, _ref$1, c, c$1, i, i$1, p, typeString, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; c$1 = $f.c$1; i = $f.i; i$1 = $f.i$1; p = $f.p; typeString = $f.typeString; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _1 = verb; - /* */ if ((_1 === (118)) || (_1 === (100))) { $s = 2; continue; } - /* */ if (_1 === (115)) { $s = 3; continue; } - /* */ if (_1 === (120)) { $s = 4; continue; } - /* */ if (_1 === (88)) { $s = 5; continue; } - /* */ if (_1 === (113)) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if ((_1 === (118)) || (_1 === (100))) { */ case 2: - if (p.fmt.fmtFlags.sharpV) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(typeString); - if (v === sliceType$2.nil) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); - $s = -1; return; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); - _ref = v; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (i > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); - } - p.fmt0x64((new $Uint64(0, c)), true); - _i++; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); - } else { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); - _ref$1 = v; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - c$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - if (i$1 > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - p.fmt.fmtInteger((new $Uint64(0, c$1)), 10, false, "0123456789abcdefx"); - _i$1++; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); - } - $s = 8; continue; - /* } else if (_1 === (115)) { */ case 3: - p.fmt.fmtBs(v); - $s = 8; continue; - /* } else if (_1 === (120)) { */ case 4: - p.fmt.fmtBx(v, "0123456789abcdefx"); - $s = 8; continue; - /* } else if (_1 === (88)) { */ case 5: - p.fmt.fmtBx(v, "0123456789ABCDEFX"); - $s = 8; continue; - /* } else if (_1 === (113)) { */ case 6: - p.fmt.fmtQ(($bytesToString(v))); - $s = 8; continue; - /* } else { */ case 7: - _r = reflect.ValueOf(v); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = p.printValue($clone(_r, reflect.Value), verb, 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 8: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBytes }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.c$1 = c$1; $f.i = i; $f.i$1 = i$1; $f.p = p; $f.typeString = typeString; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtBytes = function(v, verb, typeString) { return this.$val.fmtBytes(v, verb, typeString); }; - pp.ptr.prototype.fmtPointer = function(value, verb) { - var _1, _2, _r, p, u, value, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; p = $f.p; u = $f.u; value = $f.value; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - u = 0; - _1 = $clone(value, reflect.Value).Kind(); - /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { */ case 2: - u = $clone(value, reflect.Value).Pointer(); - $s = 4; continue; - /* } else { */ case 3: - $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 4: - case 1: - _2 = verb; - /* */ if (_2 === (118)) { $s = 7; continue; } - /* */ if (_2 === (112)) { $s = 8; continue; } - /* */ if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (_2 === (118)) { */ case 7: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 12: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); - _r = $clone(value, reflect.Value).Type().String(); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(")("); - if (u === 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("nil"); - } else { - p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), true); - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); - $s = 14; continue; - /* } else { */ case 13: - if (u === 0) { - p.fmt.padString(""); - } else { - p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); - } - /* } */ case 14: - $s = 11; continue; - /* } else if (_2 === (112)) { */ case 8: - p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); - $s = 11; continue; - /* } else if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { */ case 9: - $r = p.fmtInteger((new $Uint64(0, u.constructor === Number ? u : 1)), false, verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 11; continue; - /* } else { */ case 10: - $r = p.badVerb(verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 11: - case 6: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtPointer }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f.p = p; $f.u = u; $f.value = value; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.fmtPointer = function(value, verb) { return this.$val.fmtPointer(value, verb); }; - pp.ptr.prototype.catchPanic = function(arg, verb, method) { - var _r, arg, err, method, oldFlags, p, v, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; arg = $f.arg; err = $f.err; method = $f.method; oldFlags = $f.oldFlags; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - err = $recover(); - /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 1: - _r = reflect.ValueOf(arg); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - $s = -1; return; - } - if (p.panicking) { - $panic(err); - } - oldFlags = $clone(p.fmt.fmtFlags, fmtFlags); - p.fmt.clearflags(); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(PANIC="); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(method); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(" method: "); - p.panicking = true; - $r = p.printArg(err, 118); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - p.panicking = false; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); - fmtFlags.copy(p.fmt.fmtFlags, oldFlags); - /* } */ case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.catchPanic }; } $f._r = _r; $f.arg = arg; $f.err = err; $f.method = method; $f.oldFlags = oldFlags; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.catchPanic = function(arg, verb, method) { return this.$val.catchPanic(arg, verb, method); }; - pp.ptr.prototype.handleMethods = function(verb) { - var _1, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, formatter, handled, ok, ok$1, p, stringer, v, v$1, verb, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; formatter = $f.formatter; handled = $f.handled; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; stringer = $f.stringer; v = $f.v; v$1 = $f.v$1; verb = $f.verb; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - handled = false; - p = this; - if (p.erroring) { - $s = -1; return handled; - } - _tuple = $assertType(p.arg, Formatter, true); - formatter = _tuple[0]; - ok = _tuple[1]; - /* */ if (ok) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (ok) { */ case 1: - handled = true; - $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "Format"]]); - $r = formatter.Format(p, verb); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return handled; - /* } */ case 2: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 4: - _tuple$1 = $assertType(p.arg, GoStringer, true); - stringer = _tuple$1[0]; - ok$1 = _tuple$1[1]; - /* */ if (ok$1) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (ok$1) { */ case 7: - handled = true; - $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "GoString"]]); - _r = stringer.GoString(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = p.fmt.fmtS(_r); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return handled; - /* } */ case 8: - $s = 6; continue; - /* } else { */ case 5: - _1 = verb; - /* */ if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { */ case 12: - _ref = p.arg; - /* */ if ($assertType(_ref, $error, true)[1]) { $s = 14; continue; } - /* */ if ($assertType(_ref, Stringer, true)[1]) { $s = 15; continue; } - /* */ $s = 16; continue; - /* if ($assertType(_ref, $error, true)[1]) { */ case 14: - v = _ref; - handled = true; - $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "Error"]]); - _r$1 = v.Error(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $r = p.fmtString(_r$1, verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return handled; - /* } else if ($assertType(_ref, Stringer, true)[1]) { */ case 15: - v$1 = _ref; - handled = true; - $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb, "String"]]); - _r$2 = v$1.String(); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $r = p.fmtString(_r$2, verb); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return handled; - /* } */ case 16: - /* } */ case 13: - case 11: - /* } */ case 6: - handled = false; - $s = -1; return handled; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return handled; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: pp.ptr.prototype.handleMethods }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.formatter = formatter; $f.handled = handled; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.stringer = stringer; $f.v = v; $f.v$1 = v$1; $f.verb = verb; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - pp.prototype.handleMethods = function(verb) { return this.$val.handleMethods(verb); }; - pp.ptr.prototype.printArg = function(arg, verb) { - var _1, _2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, arg, f, f$1, f$10, f$11, f$12, f$13, f$14, f$15, f$16, f$17, f$18, f$19, f$2, f$3, f$4, f$5, f$6, f$7, f$8, f$9, p, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; arg = $f.arg; f = $f.f; f$1 = $f.f$1; f$10 = $f.f$10; f$11 = $f.f$11; f$12 = $f.f$12; f$13 = $f.f$13; f$14 = $f.f$14; f$15 = $f.f$15; f$16 = $f.f$16; f$17 = $f.f$17; f$18 = $f.f$18; f$19 = $f.f$19; f$2 = $f.f$2; f$3 = $f.f$3; f$4 = $f.f$4; f$5 = $f.f$5; f$6 = $f.f$6; f$7 = $f.f$7; f$8 = $f.f$8; f$9 = $f.f$9; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - p.arg = arg; - p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); - /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 1: - _1 = verb; - /* */ if ((_1 === (84)) || (_1 === (118))) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((_1 === (84)) || (_1 === (118))) { */ case 4: - p.fmt.padString(""); - $s = 6; continue; - /* } else { */ case 5: - $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 6: - case 3: - $s = -1; return; - /* } */ case 2: - _2 = verb; - /* */ if (_2 === (84)) { $s = 9; continue; } - /* */ if (_2 === (112)) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (_2 === (84)) { */ case 9: - _r = reflect.TypeOf(arg).String(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $r = p.fmt.fmtS(_r); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } else if (_2 === (112)) { */ case 10: - _r$1 = reflect.ValueOf(arg); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $r = p.fmtPointer($clone(_r$1, reflect.Value), 112); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 11: - case 8: - _ref = arg; - /* */ if ($assertType(_ref, $Bool, true)[1]) { $s = 16; continue; } - /* */ if ($assertType(_ref, $Float32, true)[1]) { $s = 17; continue; } - /* */ if ($assertType(_ref, $Float64, true)[1]) { $s = 18; continue; } - /* */ if ($assertType(_ref, $Complex64, true)[1]) { $s = 19; continue; } - /* */ if ($assertType(_ref, $Complex128, true)[1]) { $s = 20; continue; } - /* */ if ($assertType(_ref, $Int, true)[1]) { $s = 21; continue; } - /* */ if ($assertType(_ref, $Int8, true)[1]) { $s = 22; continue; } - /* */ if ($assertType(_ref, $Int16, true)[1]) { $s = 23; continue; } - /* */ if ($assertType(_ref, $Int32, true)[1]) { $s = 24; continue; } - /* */ if ($assertType(_ref, $Int64, true)[1]) { $s = 25; continue; } - /* */ if ($assertType(_ref, $Uint, true)[1]) { $s = 26; continue; } - /* */ if ($assertType(_ref, $Uint8, true)[1]) { $s = 27; continue; } - /* */ if ($assertType(_ref, $Uint16, true)[1]) { $s = 28; continue; } - /* */ if ($assertType(_ref, $Uint32, true)[1]) { $s = 29; continue; } - /* */ if ($assertType(_ref, $Uint64, true)[1]) { $s = 30; continue; } - /* */ if ($assertType(_ref, $Uintptr, true)[1]) { $s = 31; continue; } - /* */ if ($assertType(_ref, $String, true)[1]) { $s = 32; continue; } - /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 33; continue; } - /* */ if ($assertType(_ref, reflect.Value, true)[1]) { $s = 34; continue; } - /* */ $s = 35; continue; - /* if ($assertType(_ref, $Bool, true)[1]) { */ case 16: - f = _ref.$val; - $r = p.fmtBool(f, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Float32, true)[1]) { */ case 17: - f$1 = _ref.$val; - $r = p.fmtFloat((f$1), 32, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Float64, true)[1]) { */ case 18: - f$2 = _ref.$val; - $r = p.fmtFloat(f$2, 64, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Complex64, true)[1]) { */ case 19: - f$3 = _ref.$val; - $r = p.fmtComplex((new $Complex128(f$3.$real, f$3.$imag)), 64, verb); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Complex128, true)[1]) { */ case 20: - f$4 = _ref.$val; - $r = p.fmtComplex(f$4, 128, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Int, true)[1]) { */ case 21: - f$5 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$5)), true, verb); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Int8, true)[1]) { */ case 22: - f$6 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$6)), true, verb); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Int16, true)[1]) { */ case 23: - f$7 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$7)), true, verb); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Int32, true)[1]) { */ case 24: - f$8 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$8)), true, verb); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Int64, true)[1]) { */ case 25: - f$9 = _ref.$val; - $r = p.fmtInteger((new $Uint64(f$9.$high, f$9.$low)), true, verb); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uint, true)[1]) { */ case 26: - f$10 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$10)), false, verb); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uint8, true)[1]) { */ case 27: - f$11 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$11)), false, verb); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uint16, true)[1]) { */ case 28: - f$12 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$12)), false, verb); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uint32, true)[1]) { */ case 29: - f$13 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$13)), false, verb); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uint64, true)[1]) { */ case 30: - f$14 = _ref.$val; - $r = p.fmtInteger(f$14, false, verb); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $Uintptr, true)[1]) { */ case 31: - f$15 = _ref.$val; - $r = p.fmtInteger((new $Uint64(0, f$15.constructor === Number ? f$15 : 1)), false, verb); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, $String, true)[1]) { */ case 32: - f$16 = _ref.$val; - $r = p.fmtString(f$16, verb); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 33: - f$17 = _ref.$val; - $r = p.fmtBytes(f$17, verb, "[]byte"); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else if ($assertType(_ref, reflect.Value, true)[1]) { */ case 34: - f$18 = _ref.$val; - /* */ if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { $s = 55; continue; } - /* */ $s = 56; continue; - /* if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { */ case 55: - _r$2 = $clone(f$18, reflect.Value).Interface(); /* */ $s = 57; case 57: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - p.arg = _r$2; - _r$3 = p.handleMethods(verb); /* */ $s = 60; case 60: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3) { $s = 58; continue; } - /* */ $s = 59; continue; - /* if (_r$3) { */ case 58: - $s = -1; return; - /* } */ case 59: - /* } */ case 56: - $r = p.printValue($clone(f$18, reflect.Value), verb, 0); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 36; continue; - /* } else { */ case 35: - f$19 = _ref; - _r$4 = p.handleMethods(verb); /* */ $s = 64; case 64: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (!_r$4) { $s = 62; continue; } - /* */ $s = 63; continue; - /* if (!_r$4) { */ case 62: - _r$5 = reflect.ValueOf(f$19); /* */ $s = 65; case 65: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $r = p.printValue($clone(_r$5, reflect.Value), verb, 0); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 63: - /* } */ case 36: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printArg }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.arg = arg; $f.f = f; $f.f$1 = f$1; $f.f$10 = f$10; $f.f$11 = f$11; $f.f$12 = f$12; $f.f$13 = f$13; $f.f$14 = f$14; $f.f$15 = f$15; $f.f$16 = f$16; $f.f$17 = f$17; $f.f$18 = f$18; $f.f$19 = f$19; $f.f$2 = f$2; $f.f$3 = f$3; $f.f$4 = f$4; $f.f$5 = f$5; $f.f$6 = f$6; $f.f$7 = f$7; $f.f$8 = f$8; $f.f$9 = f$9; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.printArg = function(arg, verb) { return this.$val.printArg(arg, verb); }; - pp.ptr.prototype.printValue = function(value, verb, depth) { - var _1, _2, _3, _4, _arg, _arg$1, _arg$2, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, a, bytes, depth, f, i, i$1, i$2, i$3, i$4, key, name, p, sorted, t, value, value$1, verb, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; a = $f.a; bytes = $f.bytes; depth = $f.depth; f = $f.f; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; key = $f.key; name = $f.name; p = $f.p; sorted = $f.sorted; t = $f.t; value = $f.value; value$1 = $f.value$1; verb = $f.verb; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - /* */ if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { */ case 1: - _r = $clone(value, reflect.Value).Interface(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p.arg = _r; - _r$1 = p.handleMethods(verb); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$1) { */ case 4: - $s = -1; return; - /* } */ case 5: - /* } */ case 2: - p.arg = $ifaceNil; - p.value = value; - f = value; - _1 = $clone(value, reflect.Value).Kind(); - /* */ if (_1 === (0)) { $s = 8; continue; } - /* */ if (_1 === (1)) { $s = 9; continue; } - /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 10; continue; } - /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 11; continue; } - /* */ if (_1 === (13)) { $s = 12; continue; } - /* */ if (_1 === (14)) { $s = 13; continue; } - /* */ if (_1 === (15)) { $s = 14; continue; } - /* */ if (_1 === (16)) { $s = 15; continue; } - /* */ if (_1 === (24)) { $s = 16; continue; } - /* */ if (_1 === (21)) { $s = 17; continue; } - /* */ if (_1 === (25)) { $s = 18; continue; } - /* */ if (_1 === (20)) { $s = 19; continue; } - /* */ if ((_1 === (17)) || (_1 === (23))) { $s = 20; continue; } - /* */ if (_1 === (22)) { $s = 21; continue; } - /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (_1 === (0)) { */ case 8: - /* */ if (depth === 0) { $s = 25; continue; } - /* */ $s = 26; continue; - /* if (depth === 0) { */ case 25: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - $s = 27; continue; - /* } else { */ case 26: - _2 = verb; - /* */ if (_2 === (118)) { $s = 29; continue; } - /* */ $s = 30; continue; - /* if (_2 === (118)) { */ case 29: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - $s = 31; continue; - /* } else { */ case 30: - $r = p.badVerb(verb); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 31: - case 28: - /* } */ case 27: - $s = 24; continue; - /* } else if (_1 === (1)) { */ case 9: - $r = p.fmtBool($clone(f, reflect.Value).Bool(), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 10: - $r = p.fmtInteger(((x = $clone(f, reflect.Value).Int(), new $Uint64(x.$high, x.$low))), true, verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 11: - $r = p.fmtInteger($clone(f, reflect.Value).Uint(), false, verb); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (13)) { */ case 12: - $r = p.fmtFloat($clone(f, reflect.Value).Float(), 32, verb); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (14)) { */ case 13: - $r = p.fmtFloat($clone(f, reflect.Value).Float(), 64, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (15)) { */ case 14: - $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 64, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (16)) { */ case 15: - $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 128, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (24)) { */ case 16: - _r$2 = $clone(f, reflect.Value).String(); /* */ $s = 40; case 40: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $r = p.fmtString(_r$2, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if (_1 === (21)) { */ case 17: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 42; continue; } - /* */ $s = 43; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 42: - _r$3 = $clone(f, reflect.Value).Type().String(); /* */ $s = 45; case 45: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$3); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - if ($clone(f, reflect.Value).IsNil()) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); - $s = -1; return; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); - $s = 44; continue; - /* } else { */ case 43: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("map["); - /* } */ case 44: - _r$4 = fmtsort.Sort($clone(f, reflect.Value)); /* */ $s = 47; case 47: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - sorted = _r$4; - _ref = sorted.Key; - _i = 0; - /* while (true) { */ case 48: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 49; continue; } - i = _i; - key = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (i > 0) { - if (p.fmt.fmtFlags.sharpV) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); - } else { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - } - $r = p.printValue($clone(key, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); - $r = p.printValue($clone((x$1 = sorted.Value, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])), reflect.Value), verb, depth + 1 >> 0); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _i++; - /* } */ $s = 48; continue; case 49: - if (p.fmt.fmtFlags.sharpV) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); - } else { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); - } - $s = 24; continue; - /* } else if (_1 === (25)) { */ case 18: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 52; continue; } - /* */ $s = 53; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 52: - _r$5 = $clone(f, reflect.Value).Type().String(); /* */ $s = 54; case 54: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$5); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 53: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); - i$1 = 0; - /* while (true) { */ case 56: - /* if (!(i$1 < $clone(f, reflect.Value).NumField())) { break; } */ if(!(i$1 < $clone(f, reflect.Value).NumField())) { $s = 57; continue; } - if (i$1 > 0) { - if (p.fmt.fmtFlags.sharpV) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); - } else { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - } - /* */ if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { $s = 58; continue; } - /* */ $s = 59; continue; - /* if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { */ case 58: - _r$6 = $clone(f, reflect.Value).Type().Field(i$1); /* */ $s = 60; case 60: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - name = _r$6.Name; - if (!(name === "")) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(name); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); - } - /* } */ case 59: - _r$7 = getField($clone(f, reflect.Value), i$1); /* */ $s = 61; case 61: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $r = p.printValue($clone(_r$7, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$1 = i$1 + (1) >> 0; - /* } */ $s = 56; continue; case 57: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); - $s = 24; continue; - /* } else if (_1 === (20)) { */ case 19: - _r$8 = $clone(f, reflect.Value).Elem(); /* */ $s = 63; case 63: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - value$1 = _r$8; - /* */ if (!$clone(value$1, reflect.Value).IsValid()) { $s = 64; continue; } - /* */ $s = 65; continue; - /* if (!$clone(value$1, reflect.Value).IsValid()) { */ case 64: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 67; continue; } - /* */ $s = 68; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 67: - _r$9 = $clone(f, reflect.Value).Type().String(); /* */ $s = 70; case 70: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$9); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); - $s = 69; continue; - /* } else { */ case 68: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - /* } */ case 69: - $s = 66; continue; - /* } else { */ case 65: - $r = p.printValue($clone(value$1, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 72; case 72: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 66: - $s = 24; continue; - /* } else if ((_1 === (17)) || (_1 === (23))) { */ case 20: - _3 = verb; - /* */ if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { $s = 74; continue; } - /* */ $s = 75; continue; - /* if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { */ case 74: - t = $clone(f, reflect.Value).Type(); - _r$10 = t.Elem(); /* */ $s = 78; case 78: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - _r$11 = _r$10.Kind(); /* */ $s = 79; case 79: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - /* */ if (_r$11 === 8) { $s = 76; continue; } - /* */ $s = 77; continue; - /* if (_r$11 === 8) { */ case 76: - bytes = sliceType$2.nil; - /* */ if ($clone(f, reflect.Value).Kind() === 23) { $s = 80; continue; } - /* */ if ($clone(f, reflect.Value).CanAddr()) { $s = 81; continue; } - /* */ $s = 82; continue; - /* if ($clone(f, reflect.Value).Kind() === 23) { */ case 80: - _r$12 = $clone(f, reflect.Value).Bytes(); /* */ $s = 84; case 84: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - bytes = _r$12; - $s = 83; continue; - /* } else if ($clone(f, reflect.Value).CanAddr()) { */ case 81: - _r$13 = $clone(f, reflect.Value).Slice(0, $clone(f, reflect.Value).Len()); /* */ $s = 85; case 85: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - _r$14 = $clone(_r$13, reflect.Value).Bytes(); /* */ $s = 86; case 86: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } - bytes = _r$14; - $s = 83; continue; - /* } else { */ case 82: - bytes = $makeSlice(sliceType$2, $clone(f, reflect.Value).Len()); - _ref$1 = bytes; - _i$1 = 0; - /* while (true) { */ case 87: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 88; continue; } - i$2 = _i$1; - _r$15 = $clone(f, reflect.Value).Index(i$2); /* */ $s = 89; case 89: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } - _r$16 = $clone(_r$15, reflect.Value).Uint(); /* */ $s = 90; case 90: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } - ((i$2 < 0 || i$2 >= bytes.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes.$array[bytes.$offset + i$2] = ((_r$16.$low << 24 >>> 24))); - _i$1++; - /* } */ $s = 87; continue; case 88: - /* } */ case 83: - _arg = bytes; - _arg$1 = verb; - _r$17 = t.String(); /* */ $s = 91; case 91: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } - _arg$2 = _r$17; - $r = p.fmtBytes(_arg, _arg$1, _arg$2); /* */ $s = 92; case 92: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 77: - /* } */ case 75: - case 73: - /* */ if (p.fmt.fmtFlags.sharpV) { $s = 93; continue; } - /* */ $s = 94; continue; - /* if (p.fmt.fmtFlags.sharpV) { */ case 93: - _r$18 = $clone(f, reflect.Value).Type().String(); /* */ $s = 96; case 96: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$18); /* */ $s = 97; case 97: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - if (($clone(f, reflect.Value).Kind() === 23) && $clone(f, reflect.Value).IsNil()) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); - $s = -1; return; - } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); - i$3 = 0; - /* while (true) { */ case 98: - /* if (!(i$3 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$3 < $clone(f, reflect.Value).Len())) { $s = 99; continue; } - if (i$3 > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); - } - _r$19 = $clone(f, reflect.Value).Index(i$3); /* */ $s = 100; case 100: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } - $r = p.printValue($clone(_r$19, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 101; case 101: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$3 = i$3 + (1) >> 0; - /* } */ $s = 98; continue; case 99: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); - $s = 95; continue; - /* } else { */ case 94: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); - i$4 = 0; - /* while (true) { */ case 102: - /* if (!(i$4 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$4 < $clone(f, reflect.Value).Len())) { $s = 103; continue; } - if (i$4 > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - _r$20 = $clone(f, reflect.Value).Index(i$4); /* */ $s = 104; case 104: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; } - $r = p.printValue($clone(_r$20, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i$4 = i$4 + (1) >> 0; - /* } */ $s = 102; continue; case 103: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); - /* } */ case 95: - $s = 24; continue; - /* } else if (_1 === (22)) { */ case 21: - /* */ if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { $s = 106; continue; } - /* */ $s = 107; continue; - /* if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { */ case 106: - _r$21 = $clone(f, reflect.Value).Elem(); /* */ $s = 109; case 109: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; } - a = _r$21; - _4 = $clone(a, reflect.Value).Kind(); - /* */ if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { $s = 110; continue; } - /* */ $s = 111; continue; - /* if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { */ case 110: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); - $r = p.printValue($clone(a, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 112; case 112: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 111: - case 108: - /* } */ case 107: - $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 113; case 113: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { */ case 22: - $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 24; continue; - /* } else { */ case 23: - $r = p.unknownType($clone(f, reflect.Value)); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 24: - case 7: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printValue }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f.a = a; $f.bytes = bytes; $f.depth = depth; $f.f = f; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.key = key; $f.name = name; $f.p = p; $f.sorted = sorted; $f.t = t; $f.value = value; $f.value$1 = value$1; $f.verb = verb; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.printValue = function(value, verb, depth) { return this.$val.printValue(value, verb, depth); }; - intFromArg = function(a, argNum) { - var _1, _r, _tuple, a, argNum, isInt, n, n$1, newArgNum, num, v, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _tuple = $f._tuple; a = $f.a; argNum = $f.argNum; isInt = $f.isInt; n = $f.n; n$1 = $f.n$1; newArgNum = $f.newArgNum; num = $f.num; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - num = 0; - isInt = false; - newArgNum = 0; - newArgNum = argNum; - /* */ if (argNum < a.$length) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (argNum < a.$length) { */ case 1: - _tuple = $assertType(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), $Int, true); - num = _tuple[0]; - isInt = _tuple[1]; - /* */ if (!isInt) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!isInt) { */ case 3: - _r = reflect.ValueOf(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum])); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - _1 = $clone(v, reflect.Value).Kind(); - if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { - n = $clone(v, reflect.Value).Int(); - if ((x = (new $Int64(0, (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)))), (x.$high === n.$high && x.$low === n.$low))) { - num = (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)); - isInt = true; - } - } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { - n$1 = $clone(v, reflect.Value).Uint(); - if ((x$1 = (new $Int64(n$1.$high, n$1.$low)), (x$1.$high > 0 || (x$1.$high === 0 && x$1.$low >= 0))) && (x$2 = (new $Uint64(0, ((n$1.$low >> 0)))), (x$2.$high === n$1.$high && x$2.$low === n$1.$low))) { - num = ((n$1.$low >> 0)); - isInt = true; - } - } - case 5: - /* } */ case 4: - newArgNum = argNum + 1 >> 0; - if (tooLarge(num)) { - num = 0; - isInt = false; - } - /* } */ case 2: - $s = -1; return [num, isInt, newArgNum]; - /* */ } return; } if ($f === undefined) { $f = { $blk: intFromArg }; } $f._1 = _1; $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.argNum = argNum; $f.isInt = isInt; $f.n = n; $f.n$1 = n$1; $f.newArgNum = newArgNum; $f.num = num; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - parseArgNumber = function(format) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, format, i, index, newi, ok, ok$1, wid, width; - index = 0; - wid = 0; - ok = false; - if (format.length < 3) { - _tmp = 0; - _tmp$1 = 1; - _tmp$2 = false; - index = _tmp; - wid = _tmp$1; - ok = _tmp$2; - return [index, wid, ok]; - } - i = 1; - while (true) { - if (!(i < format.length)) { break; } - if (format.charCodeAt(i) === 93) { - _tuple = parsenum(format, 1, i); - width = _tuple[0]; - ok$1 = _tuple[1]; - newi = _tuple[2]; - if (!ok$1 || !((newi === i))) { - _tmp$3 = 0; - _tmp$4 = i + 1 >> 0; - _tmp$5 = false; - index = _tmp$3; - wid = _tmp$4; - ok = _tmp$5; - return [index, wid, ok]; - } - _tmp$6 = width - 1 >> 0; - _tmp$7 = i + 1 >> 0; - _tmp$8 = true; - index = _tmp$6; - wid = _tmp$7; - ok = _tmp$8; - return [index, wid, ok]; - } - i = i + (1) >> 0; - } - _tmp$9 = 0; - _tmp$10 = 1; - _tmp$11 = false; - index = _tmp$9; - wid = _tmp$10; - ok = _tmp$11; - return [index, wid, ok]; - }; - pp.ptr.prototype.argNumber = function(argNum, format, i, numArgs) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, argNum, format, found, i, index, newArgNum, newi, numArgs, ok, p, wid; - newArgNum = 0; - newi = 0; - found = false; - p = this; - if (format.length <= i || !((format.charCodeAt(i) === 91))) { - _tmp = argNum; - _tmp$1 = i; - _tmp$2 = false; - newArgNum = _tmp; - newi = _tmp$1; - found = _tmp$2; - return [newArgNum, newi, found]; - } - p.reordered = true; - _tuple = parseArgNumber($substring(format, i)); - index = _tuple[0]; - wid = _tuple[1]; - ok = _tuple[2]; - if (ok && 0 <= index && index < numArgs) { - _tmp$3 = index; - _tmp$4 = i + wid >> 0; - _tmp$5 = true; - newArgNum = _tmp$3; - newi = _tmp$4; - found = _tmp$5; - return [newArgNum, newi, found]; - } - p.goodArgNum = false; - _tmp$6 = argNum; - _tmp$7 = i + wid >> 0; - _tmp$8 = ok; - newArgNum = _tmp$6; - newi = _tmp$7; - found = _tmp$8; - return [newArgNum, newi, found]; - }; - pp.prototype.argNumber = function(argNum, format, i, numArgs) { return this.$val.argNumber(argNum, format, i, numArgs); }; - pp.ptr.prototype.badArgNum = function(verb) { - var p, verb; - p = this; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(BADINDEX)"); - }; - pp.prototype.badArgNum = function(verb) { return this.$val.badArgNum(verb); }; - pp.ptr.prototype.missingArg = function(verb) { - var p, verb; - p = this; - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(MISSING)"); - }; - pp.prototype.missingArg = function(verb) { return this.$val.missingArg(verb); }; - pp.ptr.prototype.doPrintf = function(format, a) { - var _1, _i, _r, _r$1, _r$2, _ref, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, a, afterIndex, arg, argNum, c, end, format, i, i$1, lasti, p, size, verb, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; a = $f.a; afterIndex = $f.afterIndex; arg = $f.arg; argNum = $f.argNum; c = $f.c; end = $f.end; format = $f.format; i = $f.i; i$1 = $f.i$1; lasti = $f.lasti; p = $f.p; size = $f.size; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - end = format.length; - argNum = 0; - afterIndex = false; - p.reordered = false; - i = 0; - /* while (true) { */ case 1: - /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 2; continue; } - p.goodArgNum = true; - lasti = i; - while (true) { - if (!(i < end && !((format.charCodeAt(i) === 37)))) { break; } - i = i + (1) >> 0; - } - if (i > lasti) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString($substring(format, lasti, i)); - } - if (i >= end) { - /* break; */ $s = 2; continue; - } - i = i + (1) >> 0; - p.fmt.clearflags(); - /* while (true) { */ case 3: - /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 4; continue; } - c = format.charCodeAt(i); - _1 = c; - /* */ if (_1 === (35)) { $s = 6; continue; } - /* */ if (_1 === (48)) { $s = 7; continue; } - /* */ if (_1 === (43)) { $s = 8; continue; } - /* */ if (_1 === (45)) { $s = 9; continue; } - /* */ if (_1 === (32)) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (_1 === (35)) { */ case 6: - p.fmt.fmtFlags.sharp = true; - $s = 12; continue; - /* } else if (_1 === (48)) { */ case 7: - p.fmt.fmtFlags.zero = !p.fmt.fmtFlags.minus; - $s = 12; continue; - /* } else if (_1 === (43)) { */ case 8: - p.fmt.fmtFlags.plus = true; - $s = 12; continue; - /* } else if (_1 === (45)) { */ case 9: - p.fmt.fmtFlags.minus = true; - p.fmt.fmtFlags.zero = false; - $s = 12; continue; - /* } else if (_1 === (32)) { */ case 10: - p.fmt.fmtFlags.space = true; - $s = 12; continue; - /* } else { */ case 11: - /* */ if (97 <= c && c <= 122 && argNum < a.$length) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (97 <= c && c <= 122 && argNum < a.$length) { */ case 13: - if (c === 118) { - p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; - p.fmt.fmtFlags.sharp = false; - p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; - p.fmt.fmtFlags.plus = false; - } - $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), ((c >> 0))); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - argNum = argNum + (1) >> 0; - i = i + (1) >> 0; - /* continue formatLoop; */ $s = 1; continue s; - /* } */ case 14: - /* break simpleFormat; */ $s = 4; continue s; - /* } */ case 12: - case 5: - i = i + (1) >> 0; - /* } */ $s = 3; continue; case 4: - _tuple = p.argNumber(argNum, format, i, a.$length); - argNum = _tuple[0]; - i = _tuple[1]; - afterIndex = _tuple[2]; - /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 16: - i = i + (1) >> 0; - _r = intFromArg(a, argNum); /* */ $s = 19; case 19: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$1 = _r; - p.fmt.wid = _tuple$1[0]; - p.fmt.fmtFlags.widPresent = _tuple$1[1]; - argNum = _tuple$1[2]; - if (!p.fmt.fmtFlags.widPresent) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADWIDTH)"); - } - if (p.fmt.wid < 0) { - p.fmt.wid = -p.fmt.wid; - p.fmt.fmtFlags.minus = true; - p.fmt.fmtFlags.zero = false; - } - afterIndex = false; - $s = 18; continue; - /* } else { */ case 17: - _tuple$2 = parsenum(format, i, end); - p.fmt.wid = _tuple$2[0]; - p.fmt.fmtFlags.widPresent = _tuple$2[1]; - i = _tuple$2[2]; - if (afterIndex && p.fmt.fmtFlags.widPresent) { - p.goodArgNum = false; - } - /* } */ case 18: - /* */ if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { $s = 20; continue; } - /* */ $s = 21; continue; - /* if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { */ case 20: - i = i + (1) >> 0; - if (afterIndex) { - p.goodArgNum = false; - } - _tuple$3 = p.argNumber(argNum, format, i, a.$length); - argNum = _tuple$3[0]; - i = _tuple$3[1]; - afterIndex = _tuple$3[2]; - /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 22: - i = i + (1) >> 0; - _r$1 = intFromArg(a, argNum); /* */ $s = 25; case 25: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$4 = _r$1; - p.fmt.prec = _tuple$4[0]; - p.fmt.fmtFlags.precPresent = _tuple$4[1]; - argNum = _tuple$4[2]; - if (p.fmt.prec < 0) { - p.fmt.prec = 0; - p.fmt.fmtFlags.precPresent = false; - } - if (!p.fmt.fmtFlags.precPresent) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADPREC)"); - } - afterIndex = false; - $s = 24; continue; - /* } else { */ case 23: - _tuple$5 = parsenum(format, i, end); - p.fmt.prec = _tuple$5[0]; - p.fmt.fmtFlags.precPresent = _tuple$5[1]; - i = _tuple$5[2]; - if (!p.fmt.fmtFlags.precPresent) { - p.fmt.prec = 0; - p.fmt.fmtFlags.precPresent = true; - } - /* } */ case 24: - /* } */ case 21: - if (!afterIndex) { - _tuple$6 = p.argNumber(argNum, format, i, a.$length); - argNum = _tuple$6[0]; - i = _tuple$6[1]; - afterIndex = _tuple$6[2]; - } - if (i >= end) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(NOVERB)"); - /* break; */ $s = 2; continue; - } - _tmp = ((format.charCodeAt(i) >> 0)); - _tmp$1 = 1; - verb = _tmp; - size = _tmp$1; - if (verb >= 128) { - _tuple$7 = utf8.DecodeRuneInString($substring(format, i)); - verb = _tuple$7[0]; - size = _tuple$7[1]; - } - i = i + (size) >> 0; - /* */ if ((verb === 37)) { $s = 27; continue; } - /* */ if (!p.goodArgNum) { $s = 28; continue; } - /* */ if (argNum >= a.$length) { $s = 29; continue; } - /* */ if ((verb === 118)) { $s = 30; continue; } - /* */ $s = 31; continue; - /* if ((verb === 37)) { */ case 27: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(37); - $s = 32; continue; - /* } else if (!p.goodArgNum) { */ case 28: - p.badArgNum(verb); - $s = 32; continue; - /* } else if (argNum >= a.$length) { */ case 29: - p.missingArg(verb); - $s = 32; continue; - /* } else if ((verb === 118)) { */ case 30: - p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; - p.fmt.fmtFlags.sharp = false; - p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; - p.fmt.fmtFlags.plus = false; - $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - argNum = argNum + (1) >> 0; - $s = 32; continue; - /* } else { */ case 31: - $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - argNum = argNum + (1) >> 0; - /* } */ case 32: - case 26: - /* } */ $s = 1; continue; case 2: - /* */ if (!p.reordered && argNum < a.$length) { $s = 35; continue; } - /* */ $s = 36; continue; - /* if (!p.reordered && argNum < a.$length) { */ case 35: - p.fmt.clearflags(); - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(EXTRA "); - _ref = $subslice(a, argNum); - _i = 0; - /* while (true) { */ case 37: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 38; continue; } - i$1 = _i; - arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (i$1 > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); - } - /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 39; continue; } - /* */ $s = 40; continue; - /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 39: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); - $s = 41; continue; - /* } else { */ case 40: - _r$2 = reflect.TypeOf(arg).String(); /* */ $s = 42; case 42: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); - $r = p.printArg(arg, 118); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 41: - _i++; - /* } */ $s = 37; continue; case 38: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); - /* } */ case 36: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintf }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.a = a; $f.afterIndex = afterIndex; $f.arg = arg; $f.argNum = argNum; $f.c = c; $f.end = end; $f.format = format; $f.i = i; $f.i$1 = i$1; $f.lasti = lasti; $f.p = p; $f.size = size; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.doPrintf = function(format, a) { return this.$val.doPrintf(format, a); }; - pp.ptr.prototype.doPrint = function(a) { - var _i, _r, _ref, _v, a, arg, argNum, isString, p, prevString, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _v = $f._v; a = $f.a; arg = $f.arg; argNum = $f.argNum; isString = $f.isString; p = $f.p; prevString = $f.prevString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - prevString = false; - _ref = a; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - argNum = _i; - arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!(!($interfaceIsEqual(arg, $ifaceNil)))) { _v = false; $s = 3; continue s; } - _r = reflect.TypeOf(arg).Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _v = _r === 24; case 3: - isString = _v; - if (argNum > 0 && !isString && !prevString) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - $r = p.printArg(arg, 118); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - prevString = isString; - _i++; - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrint }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._v = _v; $f.a = a; $f.arg = arg; $f.argNum = argNum; $f.isString = isString; $f.p = p; $f.prevString = prevString; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.doPrint = function(a) { return this.$val.doPrint(a); }; - pp.ptr.prototype.doPrintln = function(a) { - var _i, _ref, a, arg, argNum, p, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _ref = $f._ref; a = $f.a; arg = $f.arg; argNum = $f.argNum; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _ref = a; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - argNum = _i; - arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (argNum > 0) { - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); - } - $r = p.printArg(arg, 118); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _i++; - /* } */ $s = 1; continue; case 2: - (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(10); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintln }; } $f._i = _i; $f._ref = _ref; $f.a = a; $f.arg = arg; $f.argNum = argNum; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; - }; - pp.prototype.doPrintln = function(a) { return this.$val.doPrintln(a); }; - ss.ptr.prototype.Read = function(buf) { - var _tmp, _tmp$1, buf, err, n, s; - n = 0; - err = $ifaceNil; - s = this; - _tmp = 0; - _tmp$1 = errors.New("ScanState's Read should not be called. Use ReadRune"); - n = _tmp; - err = _tmp$1; - return [n, err]; - }; - ss.prototype.Read = function(buf) { return this.$val.Read(buf); }; - ss.ptr.prototype.ReadRune = function() { - var _r, _tuple, err, r, s, size, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = 0; - size = 0; - err = $ifaceNil; - s = this; - if (s.atEOF || s.count >= s.ssave.argLimit) { - err = io.EOF; - $s = -1; return [r, size, err]; - } - _r = s.rs.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - size = _tuple[1]; - err = _tuple[2]; - if ($interfaceIsEqual(err, $ifaceNil)) { - s.count = s.count + (1) >> 0; - if (s.ssave.nlIsEnd && (r === 10)) { - s.atEOF = true; - } - } else if ($interfaceIsEqual(err, io.EOF)) { - s.atEOF = true; - } - $s = -1; return [r, size, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.ReadRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.ReadRune = function() { return this.$val.ReadRune(); }; - ss.ptr.prototype.Width = function() { - var _tmp, _tmp$1, _tmp$2, _tmp$3, ok, s, wid; - wid = 0; - ok = false; - s = this; - if (s.ssave.maxWid === 1073741824) { - _tmp = 0; - _tmp$1 = false; - wid = _tmp; - ok = _tmp$1; - return [wid, ok]; - } - _tmp$2 = s.ssave.maxWid; - _tmp$3 = true; - wid = _tmp$2; - ok = _tmp$3; - return [wid, ok]; - }; - ss.prototype.Width = function() { return this.$val.Width(); }; - ss.ptr.prototype.getRune = function() { - var _r, _tuple, err, r, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = 0; - s = this; - _r = s.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - if ($interfaceIsEqual(err, io.EOF)) { - r = -1; - $s = -1; return r; - } - s.error(err); - } - $s = -1; return r; - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.getRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.getRune = function() { return this.$val.getRune(); }; - ss.ptr.prototype.UnreadRune = function() { - var _r, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = this; - _r = s.rs.UnreadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - s.atEOF = false; - s.count = s.count - (1) >> 0; - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.UnreadRune }; } $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; - ss.ptr.prototype.error = function(err) { - var err, s, x; - s = this; - $panic((x = new scanError.ptr(err), new x.constructor.elem(x))); - }; - ss.prototype.error = function(err) { return this.$val.error(err); }; - ss.ptr.prototype.errorString = function(err) { - var err, s, x; - s = this; - $panic((x = new scanError.ptr(errors.New(err)), new x.constructor.elem(x))); - }; - ss.prototype.errorString = function(err) { return this.$val.errorString(err); }; - ss.ptr.prototype.Token = function(skipSpace, f) { - var _r, err, f, s, skipSpace, tok, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; s = $f.s; skipSpace = $f.skipSpace; tok = $f.tok; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - err = [err]; - tok = sliceType$2.nil; - err[0] = $ifaceNil; - s = this; - $deferred.push([(function(err) { return function() { - var _tuple, e, ok, se; - e = $recover(); - if (!($interfaceIsEqual(e, $ifaceNil))) { - _tuple = $assertType(e, scanError, true); - se = $clone(_tuple[0], scanError); - ok = _tuple[1]; - if (ok) { - err[0] = se.err; - } else { - $panic(e); - } - } - }; })(err), []]); - if (f === $throwNilPointerError) { - f = notSpace; - } - s.buf = $subslice(s.buf, 0, 0); - _r = s.token(skipSpace, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - tok = _r; - $s = -1; return [tok, err[0]]; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [tok, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ss.ptr.prototype.Token }; } $f._r = _r; $f.err = err; $f.f = f; $f.s = s; $f.skipSpace = skipSpace; $f.tok = tok; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - ss.prototype.Token = function(skipSpace, f) { return this.$val.Token(skipSpace, f); }; - isSpace = function(r) { - var _i, _ref, r, rng, rx; - if (r >= 65536) { - return false; - } - rx = ((r << 16 >>> 16)); - _ref = space; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - rng = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), arrayType$1); - if (rx < rng[0]) { - return false; - } - if (rx <= rng[1]) { - return true; - } - _i++; - } - return false; - }; - notSpace = function(r) { - var r; - return !isSpace(r); - }; - ss.ptr.prototype.free = function(old) { - var old, s; - s = this; - if (old.validSave) { - ssave.copy(s.ssave, old); - return; - } - if (s.buf.$capacity > 1024) { - return; - } - s.buf = $subslice(s.buf, 0, 0); - s.rs = $ifaceNil; - ssFree.Put(s); - }; - ss.prototype.free = function(old) { return this.$val.free(old); }; - ss.ptr.prototype.SkipSpace = function() { - var _r, _r$1, _r$2, _v, r, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _v = $f._v; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = this; - /* while (true) { */ case 1: - _r = s.getRune(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - if (r === -1) { - $s = -1; return; - } - if (!(r === 13)) { _v = false; $s = 6; continue s; } - _r$1 = s.peek("\n"); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v = _r$1; case 6: - /* */ if (_v) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_v) { */ case 4: - /* continue; */ $s = 1; continue; - /* } */ case 5: - /* */ if (r === 10) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (r === 10) { */ case 8: - if (s.ssave.nlIsSpace) { - /* continue; */ $s = 1; continue; - } - s.errorString("unexpected newline"); - $s = -1; return; - /* } */ case 9: - /* */ if (!isSpace(r)) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (!isSpace(r)) { */ case 10: - _r$2 = s.UnreadRune(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - /* break; */ $s = 2; continue; - /* } */ case 11: - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.SkipSpace }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._v = _v; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.SkipSpace = function() { return this.$val.SkipSpace(); }; - ss.ptr.prototype.token = function(skipSpace, f) { - var _r, _r$1, _r$2, f, r, s, skipSpace, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; f = $f.f; r = $f.r; s = $f.s; skipSpace = $f.skipSpace; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = this; - /* */ if (skipSpace) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (skipSpace) { */ case 1: - $r = s.SkipSpace(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - /* while (true) { */ case 4: - _r = s.getRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - if (r === -1) { - /* break; */ $s = 5; continue; - } - _r$1 = f(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!_r$1) { */ case 7: - _r$2 = s.UnreadRune(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - /* break; */ $s = 5; continue; - /* } */ case 8: - (s.$ptr_buf || (s.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, s))).WriteRune(r); - /* } */ $s = 4; continue; case 5: - $s = -1; return (x = s.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.token }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.f = f; $f.r = r; $f.s = s; $f.skipSpace = skipSpace; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.token = function(skipSpace, f) { return this.$val.token(skipSpace, f); }; - indexRune = function(s, r) { - var _i, _ref, _rune, c, i, r, s; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - i = _i; - c = _rune[0]; - if (c === r) { - return i; - } - _i += _rune[1]; - } - return -1; - }; - ss.ptr.prototype.peek = function(ok) { - var _r, _r$1, ok, r, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; ok = $f.ok; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = this; - _r = s.getRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - /* */ if (!((r === -1))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((r === -1))) { */ case 2: - _r$1 = s.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - /* } */ case 3: - $s = -1; return indexRune(ok, r) >= 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.peek }; } $f._r = _r; $f._r$1 = _r$1; $f.ok = ok; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - ss.prototype.peek = function(ok) { return this.$val.peek(ok); }; - ptrType$25.methods = [{prop: "clearflags", name: "clearflags", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "fmt", typ: $funcType([ptrType$1], [], false)}, {prop: "writePadding", name: "writePadding", pkg: "fmt", typ: $funcType([$Int], [], false)}, {prop: "pad", name: "pad", pkg: "fmt", typ: $funcType([sliceType$2], [], false)}, {prop: "padString", name: "padString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtBoolean", name: "fmtBoolean", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "fmtUnicode", name: "fmtUnicode", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtInteger", name: "fmtInteger", pkg: "fmt", typ: $funcType([$Uint64, $Int, $Bool, $String], [], false)}, {prop: "truncateString", name: "truncateString", pkg: "fmt", typ: $funcType([$String], [$String], false)}, {prop: "truncate", name: "truncate", pkg: "fmt", typ: $funcType([sliceType$2], [sliceType$2], false)}, {prop: "fmtS", name: "fmtS", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtBs", name: "fmtBs", pkg: "fmt", typ: $funcType([sliceType$2], [], false)}, {prop: "fmtSbx", name: "fmtSbx", pkg: "fmt", typ: $funcType([$String, sliceType$2, $String], [], false)}, {prop: "fmtSx", name: "fmtSx", pkg: "fmt", typ: $funcType([$String, $String], [], false)}, {prop: "fmtBx", name: "fmtBx", pkg: "fmt", typ: $funcType([sliceType$2, $String], [], false)}, {prop: "fmtQ", name: "fmtQ", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmtC", name: "fmtC", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtQc", name: "fmtQc", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmtFloat", name: "fmtFloat", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32, $Int], [], false)}]; - ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [], false)}]; - ptrType$2.methods = [{prop: "free", name: "free", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "unknownType", name: "unknownType", pkg: "fmt", typ: $funcType([reflect.Value], [], false)}, {prop: "badVerb", name: "badVerb", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "fmtBool", name: "fmtBool", pkg: "fmt", typ: $funcType([$Bool, $Int32], [], false)}, {prop: "fmt0x64", name: "fmt0x64", pkg: "fmt", typ: $funcType([$Uint64, $Bool], [], false)}, {prop: "fmtInteger", name: "fmtInteger", pkg: "fmt", typ: $funcType([$Uint64, $Bool, $Int32], [], false)}, {prop: "fmtFloat", name: "fmtFloat", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32], [], false)}, {prop: "fmtComplex", name: "fmtComplex", pkg: "fmt", typ: $funcType([$Complex128, $Int, $Int32], [], false)}, {prop: "fmtString", name: "fmtString", pkg: "fmt", typ: $funcType([$String, $Int32], [], false)}, {prop: "fmtBytes", name: "fmtBytes", pkg: "fmt", typ: $funcType([sliceType$2, $Int32, $String], [], false)}, {prop: "fmtPointer", name: "fmtPointer", pkg: "fmt", typ: $funcType([reflect.Value, $Int32], [], false)}, {prop: "catchPanic", name: "catchPanic", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32, $String], [], false)}, {prop: "handleMethods", name: "handleMethods", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "printArg", name: "printArg", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "printValue", name: "printValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [], false)}, {prop: "argNumber", name: "argNumber", pkg: "fmt", typ: $funcType([$Int, $String, $Int, $Int], [$Int, $Int, $Bool], false)}, {prop: "badArgNum", name: "badArgNum", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "missingArg", name: "missingArg", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "doPrintf", name: "doPrintf", pkg: "fmt", typ: $funcType([$String, sliceType], [], false)}, {prop: "doPrint", name: "doPrint", pkg: "fmt", typ: $funcType([sliceType], [], false)}, {prop: "doPrintln", name: "doPrintln", pkg: "fmt", typ: $funcType([sliceType], [], false)}]; - ptrType$5.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "getRune", name: "getRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "mustReadRune", name: "mustReadRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "error", name: "error", pkg: "fmt", typ: $funcType([$error], [], false)}, {prop: "errorString", name: "errorString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType$2, $error], false)}, {prop: "free", name: "free", pkg: "fmt", typ: $funcType([ssave], [], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "token", name: "token", pkg: "fmt", typ: $funcType([$Bool, funcType], [sliceType$2], false)}, {prop: "consume", name: "consume", pkg: "fmt", typ: $funcType([$String, $Bool], [$Bool], false)}, {prop: "peek", name: "peek", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "notEOF", name: "notEOF", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "accept", name: "accept", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "okVerb", name: "okVerb", pkg: "fmt", typ: $funcType([$Int32, $String, $String], [$Bool], false)}, {prop: "scanBool", name: "scanBool", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "getBase", name: "getBase", pkg: "fmt", typ: $funcType([$Int32], [$Int, $String], false)}, {prop: "scanNumber", name: "scanNumber", pkg: "fmt", typ: $funcType([$String, $Bool], [$String], false)}, {prop: "scanRune", name: "scanRune", pkg: "fmt", typ: $funcType([$Int], [$Int64], false)}, {prop: "scanBasePrefix", name: "scanBasePrefix", pkg: "fmt", typ: $funcType([], [$Int, $String, $Bool], false)}, {prop: "scanInt", name: "scanInt", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Int64], false)}, {prop: "scanUint", name: "scanUint", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Uint64], false)}, {prop: "floatToken", name: "floatToken", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "complexTokens", name: "complexTokens", pkg: "fmt", typ: $funcType([], [$String, $String], false)}, {prop: "convertFloat", name: "convertFloat", pkg: "fmt", typ: $funcType([$String, $Int], [$Float64], false)}, {prop: "scanComplex", name: "scanComplex", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Complex128], false)}, {prop: "convertString", name: "convertString", pkg: "fmt", typ: $funcType([$Int32], [$String], false)}, {prop: "quotedString", name: "quotedString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "hexByte", name: "hexByte", pkg: "fmt", typ: $funcType([], [$Uint8, $Bool], false)}, {prop: "hexString", name: "hexString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "scanOne", name: "scanOne", pkg: "fmt", typ: $funcType([$Int32, $emptyInterface], [], false)}, {prop: "doScan", name: "doScan", pkg: "fmt", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "advance", name: "advance", pkg: "fmt", typ: $funcType([$String], [$Int], false)}, {prop: "doScanf", name: "doScanf", pkg: "fmt", typ: $funcType([$String, sliceType], [$Int, $error], false)}]; - fmtFlags.init("fmt", [{prop: "widPresent", name: "widPresent", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "precPresent", name: "precPresent", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "minus", name: "minus", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "plus", name: "plus", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharp", name: "sharp", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "space", name: "space", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "zero", name: "zero", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "plusV", name: "plusV", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharpV", name: "sharpV", embedded: false, exported: false, typ: $Bool, tag: ""}]); - fmt.init("fmt", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "fmtFlags", name: "fmtFlags", embedded: true, exported: false, typ: fmtFlags, tag: ""}, {prop: "wid", name: "wid", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "prec", name: "prec", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "intbuf", name: "intbuf", embedded: false, exported: false, typ: arrayType, tag: ""}]); - State.init([{prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}]); - Formatter.init([{prop: "Format", name: "Format", pkg: "", typ: $funcType([State, $Int32], [], false)}]); - Stringer.init([{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]); - GoStringer.init([{prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]); - buffer.init($Uint8); - pp.init("fmt", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: buffer, tag: ""}, {prop: "arg", name: "arg", embedded: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "value", name: "value", embedded: false, exported: false, typ: reflect.Value, tag: ""}, {prop: "fmt", name: "fmt", embedded: false, exported: false, typ: fmt, tag: ""}, {prop: "reordered", name: "reordered", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "goodArgNum", name: "goodArgNum", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "panicking", name: "panicking", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "erroring", name: "erroring", embedded: false, exported: false, typ: $Bool, tag: ""}]); - ScanState.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType$2, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}]); - scanError.init("fmt", [{prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}]); - ss.init("fmt", [{prop: "rs", name: "rs", embedded: false, exported: false, typ: io.RuneScanner, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: buffer, tag: ""}, {prop: "count", name: "count", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "atEOF", name: "atEOF", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "ssave", name: "ssave", embedded: true, exported: false, typ: ssave, tag: ""}]); - ssave.init("fmt", [{prop: "validSave", name: "validSave", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsEnd", name: "nlIsEnd", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsSpace", name: "nlIsSpace", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "argLimit", name: "argLimit", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "limit", name: "limit", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "maxWid", name: "maxWid", embedded: false, exported: false, typ: $Int, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmtsort.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = os.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = reflect.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - ppFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { - return new pp.ptr(buffer.nil, $ifaceNil, new reflect.Value.ptr(ptrType.nil, 0, 0), new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()), false, false, false, false); - })); - space = new sliceType$1([$toNativeArray($kindUint16, [9, 13]), $toNativeArray($kindUint16, [32, 32]), $toNativeArray($kindUint16, [133, 133]), $toNativeArray($kindUint16, [160, 160]), $toNativeArray($kindUint16, [5760, 5760]), $toNativeArray($kindUint16, [8192, 8202]), $toNativeArray($kindUint16, [8232, 8233]), $toNativeArray($kindUint16, [8239, 8239]), $toNativeArray($kindUint16, [8287, 8287]), $toNativeArray($kindUint16, [12288, 12288])]); - ssFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { - return new ss.ptr($ifaceNil, buffer.nil, 0, false, new ssave.ptr(false, false, false, 0, 0, 0)); - })); - complexError = errors.New("syntax error scanning complex number"); - boolError = errors.New("syntax error scanning boolean"); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["strings"] = (function() { - var $pkg = {}, $init, errors, js, bytealg, io, sync, unicode, utf8, Builder, Reader, ptrType, sliceType, ptrType$6, IndexByte, Index, NewReader, Contains, ContainsRune, IndexRune, HasPrefix; - errors = $packages["errors"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - bytealg = $packages["internal/bytealg"]; - io = $packages["io"]; - sync = $packages["sync"]; - unicode = $packages["unicode"]; - utf8 = $packages["unicode/utf8"]; - Builder = $pkg.Builder = $newType(0, $kindStruct, "strings.Builder", true, "strings", true, function(addr_, buf_) { - this.$val = this; - if (arguments.length === 0) { - this.addr = ptrType.nil; - this.buf = sliceType.nil; - return; - } - this.addr = addr_; - this.buf = buf_; - }); - Reader = $pkg.Reader = $newType(0, $kindStruct, "strings.Reader", true, "strings", true, function(s_, i_, prevRune_) { - this.$val = this; - if (arguments.length === 0) { - this.s = ""; - this.i = new $Int64(0, 0); - this.prevRune = 0; - return; - } - this.s = s_; - this.i = i_; - this.prevRune = prevRune_; - }); - ptrType = $ptrType(Builder); - sliceType = $sliceType($Uint8); - ptrType$6 = $ptrType(Reader); - IndexByte = function(s, c) { - var c, s; - return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; - }; - $pkg.IndexByte = IndexByte; - Index = function(s, sep) { - var s, sep; - return $parseInt(s.indexOf(sep)) >> 0; - }; - $pkg.Index = Index; - Builder.ptr.prototype.String = function() { - var b; - b = this; - return ($bytesToString(b.buf)); - }; - Builder.prototype.String = function() { return this.$val.String(); }; - Builder.ptr.prototype.copyCheck = function() { - var b; - b = this; - if (b.addr === ptrType.nil) { - b.addr = b; - } else if (!(b.addr === b)) { - $panic(new $String("strings: illegal use of non-zero Builder copied by value")); - } - }; - Builder.prototype.copyCheck = function() { return this.$val.copyCheck(); }; - Builder.ptr.prototype.Len = function() { - var b; - b = this; - return b.buf.$length; - }; - Builder.prototype.Len = function() { return this.$val.Len(); }; - Builder.ptr.prototype.Cap = function() { - var b; - b = this; - return b.buf.$capacity; - }; - Builder.prototype.Cap = function() { return this.$val.Cap(); }; - Builder.ptr.prototype.Reset = function() { - var b; - b = this; - b.addr = ptrType.nil; - b.buf = sliceType.nil; - }; - Builder.prototype.Reset = function() { return this.$val.Reset(); }; - Builder.ptr.prototype.grow = function(n) { - var b, buf, n; - b = this; - buf = $makeSlice(sliceType, b.buf.$length, (($imul(2, b.buf.$capacity)) + n >> 0)); - $copySlice(buf, b.buf); - b.buf = buf; - }; - Builder.prototype.grow = function(n) { return this.$val.grow(n); }; - Builder.ptr.prototype.Grow = function(n) { - var b, n; - b = this; - b.copyCheck(); - if (n < 0) { - $panic(new $String("strings.Builder.Grow: negative count")); - } - if ((b.buf.$capacity - b.buf.$length >> 0) < n) { - b.grow(n); - } - }; - Builder.prototype.Grow = function(n) { return this.$val.Grow(n); }; - Builder.ptr.prototype.Write = function(p) { - var b, p; - b = this; - b.copyCheck(); - b.buf = $appendSlice(b.buf, p); - return [p.$length, $ifaceNil]; - }; - Builder.prototype.Write = function(p) { return this.$val.Write(p); }; - Builder.ptr.prototype.WriteByte = function(c) { - var b, c; - b = this; - b.copyCheck(); - b.buf = $append(b.buf, c); - return $ifaceNil; - }; - Builder.prototype.WriteByte = function(c) { return this.$val.WriteByte(c); }; - Builder.ptr.prototype.WriteRune = function(r) { - var b, l, n, r; - b = this; - b.copyCheck(); - if (r < 128) { - b.buf = $append(b.buf, ((r << 24 >>> 24))); - return [1, $ifaceNil]; - } - l = b.buf.$length; - if ((b.buf.$capacity - l >> 0) < 4) { - b.grow(4); - } - n = utf8.EncodeRune($subslice(b.buf, l, (l + 4 >> 0)), r); - b.buf = $subslice(b.buf, 0, (l + n >> 0)); - return [n, $ifaceNil]; - }; - Builder.prototype.WriteRune = function(r) { return this.$val.WriteRune(r); }; - Builder.ptr.prototype.WriteString = function(s) { - var b, s; - b = this; - b.copyCheck(); - b.buf = $appendSlice(b.buf, s); - return [s.length, $ifaceNil]; - }; - Builder.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; - Reader.ptr.prototype.Len = function() { - var r, x, x$1, x$2, x$3, x$4; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - return 0; - } - return (((x$2 = (x$3 = (new $Int64(0, r.s.length)), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); - }; - Reader.prototype.Len = function() { return this.$val.Len(); }; - Reader.ptr.prototype.Size = function() { - var r; - r = this; - return (new $Int64(0, r.s.length)); - }; - Reader.prototype.Size = function() { return this.$val.Size(); }; - Reader.ptr.prototype.Read = function(b) { - var _tmp, _tmp$1, b, err, n, r, x, x$1, x$2, x$3; - n = 0; - err = $ifaceNil; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - _tmp = 0; - _tmp$1 = io.EOF; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - r.prevRune = -1; - n = $copyString(b, $substring(r.s, $flatten64(r.i))); - r.i = (x$2 = r.i, x$3 = (new $Int64(0, n)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); - return [n, err]; - }; - Reader.prototype.Read = function(b) { return this.$val.Read(b); }; - Reader.ptr.prototype.ReadAt = function(b, off) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x; - n = 0; - err = $ifaceNil; - r = this; - if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { - _tmp = 0; - _tmp$1 = errors.New("strings.Reader.ReadAt: negative offset"); - n = _tmp; - err = _tmp$1; - return [n, err]; - } - if ((x = (new $Int64(0, r.s.length)), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) { - _tmp$2 = 0; - _tmp$3 = io.EOF; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - } - n = $copyString(b, $substring(r.s, $flatten64(off))); - if (n < b.$length) { - err = io.EOF; - } - return [n, err]; - }; - Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; - Reader.ptr.prototype.ReadByte = function() { - var b, r, x, x$1, x$2, x$3; - r = this; - r.prevRune = -1; - if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - return [0, io.EOF]; - } - b = r.s.charCodeAt($flatten64(r.i)); - r.i = (x$2 = r.i, x$3 = new $Int64(0, 1), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); - return [b, $ifaceNil]; - }; - Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; - Reader.ptr.prototype.UnreadByte = function() { - var r, x, x$1, x$2; - r = this; - if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { - return errors.New("strings.Reader.UnreadByte: at beginning of string"); - } - r.prevRune = -1; - r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - return $ifaceNil; - }; - Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; - Reader.ptr.prototype.ReadRune = function() { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6; - ch = 0; - size = 0; - err = $ifaceNil; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - r.prevRune = -1; - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = io.EOF; - ch = _tmp; - size = _tmp$1; - err = _tmp$2; - return [ch, size, err]; - } - r.prevRune = (((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); - c = r.s.charCodeAt($flatten64(r.i)); - if (c < 128) { - r.i = (x$3 = r.i, x$4 = new $Int64(0, 1), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)); - _tmp$3 = ((c >> 0)); - _tmp$4 = 1; - _tmp$5 = $ifaceNil; - ch = _tmp$3; - size = _tmp$4; - err = _tmp$5; - return [ch, size, err]; - } - _tuple = utf8.DecodeRuneInString($substring(r.s, $flatten64(r.i))); - ch = _tuple[0]; - size = _tuple[1]; - r.i = (x$5 = r.i, x$6 = (new $Int64(0, size)), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)); - return [ch, size, err]; - }; - Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); }; - Reader.ptr.prototype.UnreadRune = function() { - var r, x; - r = this; - if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { - return errors.New("strings.Reader.UnreadRune: at beginning of string"); - } - if (r.prevRune < 0) { - return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune"); - } - r.i = (new $Int64(0, r.prevRune)); - r.prevRune = -1; - return $ifaceNil; - }; - Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; - Reader.ptr.prototype.Seek = function(offset, whence) { - var _1, abs, offset, r, whence, x, x$1; - r = this; - r.prevRune = -1; - abs = new $Int64(0, 0); - _1 = whence; - if (_1 === (0)) { - abs = offset; - } else if (_1 === (1)) { - abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low)); - } else if (_1 === (2)) { - abs = (x$1 = (new $Int64(0, r.s.length)), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low)); - } else { - return [new $Int64(0, 0), errors.New("strings.Reader.Seek: invalid whence")]; - } - if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) { - return [new $Int64(0, 0), errors.New("strings.Reader.Seek: negative position")]; - } - r.i = abs; - return [abs, $ifaceNil]; - }; - Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; - Reader.ptr.prototype.WriteTo = function(w) { - var _r, _tmp, _tmp$1, _tuple, err, m, n, r, s, w, x, x$1, x$2, x$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; m = $f.m; n = $f.n; r = $f.r; s = $f.s; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Int64(0, 0); - err = $ifaceNil; - r = this; - r.prevRune = -1; - if ((x = r.i, x$1 = (new $Int64(0, r.s.length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - _tmp = new $Int64(0, 0); - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - s = $substring(r.s, $flatten64(r.i)); - _r = io.WriteString(w, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - err = _tuple[1]; - if (m > s.length) { - $panic(new $String("strings.Reader.WriteTo: invalid WriteString count")); - } - r.i = (x$2 = r.i, x$3 = (new $Int64(0, m)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); - n = (new $Int64(0, m)); - if (!((m === s.length)) && $interfaceIsEqual(err, $ifaceNil)) { - err = io.ErrShortWrite; - } - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.s = s; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; - }; - Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; - Reader.ptr.prototype.Reset = function(s) { - var r, s; - r = this; - Reader.copy(r, new Reader.ptr(s, new $Int64(0, 0), -1)); - }; - Reader.prototype.Reset = function(s) { return this.$val.Reset(s); }; - NewReader = function(s) { - var s; - return new Reader.ptr(s, new $Int64(0, 0), -1); - }; - $pkg.NewReader = NewReader; - Contains = function(s, substr) { - var s, substr; - return Index(s, substr) >= 0; - }; - $pkg.Contains = Contains; - ContainsRune = function(s, r) { - var r, s; - return IndexRune(s, r) >= 0; - }; - $pkg.ContainsRune = ContainsRune; - IndexRune = function(s, r) { - var _i, _ref, _rune, i, r, r$1, s; - if (0 <= r && r < 128) { - return IndexByte(s, ((r << 24 >>> 24))); - } else if ((r === 65533)) { - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - i = _i; - r$1 = _rune[0]; - if (r$1 === 65533) { - return i; - } - _i += _rune[1]; - } - return -1; - } else if (!utf8.ValidRune(r)) { - return -1; - } else { - return Index(s, ($encodeRune(r))); - } - }; - $pkg.IndexRune = IndexRune; - HasPrefix = function(s, prefix) { - var prefix, s; - return s.length >= prefix.length && $substring(s, 0, prefix.length) === prefix; - }; - $pkg.HasPrefix = HasPrefix; - ptrType.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "copyCheck", name: "copyCheck", pkg: "strings", typ: $funcType([], [], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "grow", name: "grow", pkg: "strings", typ: $funcType([$Int], [], false)}, {prop: "Grow", name: "Grow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}]; - ptrType$6.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([$String], [], false)}]; - Builder.init("strings", [{prop: "addr", name: "addr", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}]); - Reader.init("strings", [{prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", embedded: false, exported: false, typ: $Int, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bytealg.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["encoding/hex"] = (function() { - var $pkg = {}, $init, errors, fmt, io, strings, sliceType$1, EncodedLen, Encode, EncodeToString; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - io = $packages["io"]; - strings = $packages["strings"]; - sliceType$1 = $sliceType($Uint8); - EncodedLen = function(n) { - var n; - return $imul(n, 2); - }; - $pkg.EncodedLen = EncodedLen; - Encode = function(dst, src) { - var _i, _ref, dst, i, src, v, x, x$1; - _ref = src; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - (x = $imul(i, 2), ((x < 0 || x >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x] = "0123456789abcdef".charCodeAt((v >>> 4 << 24 >>> 24)))); - (x$1 = ($imul(i, 2)) + 1 >> 0, ((x$1 < 0 || x$1 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$1] = "0123456789abcdef".charCodeAt(((v & 15) >>> 0)))); - _i++; - } - return $imul(src.$length, 2); - }; - $pkg.Encode = Encode; - EncodeToString = function(src) { - var dst, src; - dst = $makeSlice(sliceType$1, EncodedLen(src.$length)); - Encode(dst, src); - return ($bytesToString(dst)); - }; - $pkg.EncodeToString = EncodeToString; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strings.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.ErrLength = errors.New("encoding/hex: odd length hex string"); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["bytes"] = (function() { - var $pkg = {}, $init, errors, bytealg, io, unicode, utf8, Buffer, readOp, asciiSet, Reader, ptrType, sliceType, ptrType$1, arrayType$1, ptrType$2, errNegativeRead, IndexByte, Equal, makeSlice, HasPrefix, TrimRightFunc, lastIndexFunc, makeASCIISet, makeCutsetFunc, TrimRight, EqualFold, Index, indexRabinKarp, hashStr, NewReader; - errors = $packages["errors"]; - bytealg = $packages["internal/bytealg"]; - io = $packages["io"]; - unicode = $packages["unicode"]; - utf8 = $packages["unicode/utf8"]; - Buffer = $pkg.Buffer = $newType(0, $kindStruct, "bytes.Buffer", true, "bytes", true, function(buf_, off_, lastRead_) { - this.$val = this; - if (arguments.length === 0) { - this.buf = sliceType.nil; - this.off = 0; - this.lastRead = 0; - return; - } - this.buf = buf_; - this.off = off_; - this.lastRead = lastRead_; - }); - readOp = $pkg.readOp = $newType(1, $kindInt8, "bytes.readOp", true, "bytes", false, null); - asciiSet = $pkg.asciiSet = $newType(32, $kindArray, "bytes.asciiSet", true, "bytes", false, null); - Reader = $pkg.Reader = $newType(0, $kindStruct, "bytes.Reader", true, "bytes", true, function(s_, i_, prevRune_) { - this.$val = this; - if (arguments.length === 0) { - this.s = sliceType.nil; - this.i = new $Int64(0, 0); - this.prevRune = 0; - return; - } - this.s = s_; - this.i = i_; - this.prevRune = prevRune_; - }); - ptrType = $ptrType(Buffer); - sliceType = $sliceType($Uint8); - ptrType$1 = $ptrType(asciiSet); - arrayType$1 = $arrayType($Uint32, 8); - ptrType$2 = $ptrType(Reader); - IndexByte = function(s, c) { - var _i, _ref, b, c, i, s; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (b === c) { - return i; - } - _i++; - } - return -1; - }; - $pkg.IndexByte = IndexByte; - Equal = function(a, b) { - var _i, _ref, a, b, c, i; - if (!((a.$length === b.$length))) { - return false; - } - _ref = a; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((c === ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i])))) { - return false; - } - _i++; - } - return true; - }; - $pkg.Equal = Equal; - Buffer.ptr.prototype.Bytes = function() { - var b; - b = this; - return $subslice(b.buf, b.off); - }; - Buffer.prototype.Bytes = function() { return this.$val.Bytes(); }; - Buffer.ptr.prototype.String = function() { - var b; - b = this; - if (b === ptrType.nil) { - return ""; - } - return ($bytesToString($subslice(b.buf, b.off))); - }; - Buffer.prototype.String = function() { return this.$val.String(); }; - Buffer.ptr.prototype.empty = function() { - var b; - b = this; - return b.buf.$length <= b.off; - }; - Buffer.prototype.empty = function() { return this.$val.empty(); }; - Buffer.ptr.prototype.Len = function() { - var b; - b = this; - return b.buf.$length - b.off >> 0; - }; - Buffer.prototype.Len = function() { return this.$val.Len(); }; - Buffer.ptr.prototype.Cap = function() { - var b; - b = this; - return b.buf.$capacity; - }; - Buffer.prototype.Cap = function() { return this.$val.Cap(); }; - Buffer.ptr.prototype.Truncate = function(n) { - var b, n; - b = this; - if (n === 0) { - b.Reset(); - return; - } - b.lastRead = 0; - if (n < 0 || n > b.Len()) { - $panic(new $String("bytes.Buffer: truncation out of range")); - } - b.buf = $subslice(b.buf, 0, (b.off + n >> 0)); - }; - Buffer.prototype.Truncate = function(n) { return this.$val.Truncate(n); }; - Buffer.ptr.prototype.Reset = function() { - var b; - b = this; - b.buf = $subslice(b.buf, 0, 0); - b.off = 0; - b.lastRead = 0; - }; - Buffer.prototype.Reset = function() { return this.$val.Reset(); }; - Buffer.ptr.prototype.tryGrowByReslice = function(n) { - var b, l, n; - b = this; - l = b.buf.$length; - if (n <= (b.buf.$capacity - l >> 0)) { - b.buf = $subslice(b.buf, 0, (l + n >> 0)); - return [l, true]; - } - return [0, false]; - }; - Buffer.prototype.tryGrowByReslice = function(n) { return this.$val.tryGrowByReslice(n); }; - Buffer.ptr.prototype.grow = function(n) { - var _q, _tuple, b, buf, c, i, m, n, ok; - b = this; - m = b.Len(); - if ((m === 0) && !((b.off === 0))) { - b.Reset(); - } - _tuple = b.tryGrowByReslice(n); - i = _tuple[0]; - ok = _tuple[1]; - if (ok) { - return i; - } - if (b.buf === sliceType.nil && n <= 64) { - b.buf = $makeSlice(sliceType, n, 64); - return 0; - } - c = b.buf.$capacity; - if (n <= ((_q = c / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) - m >> 0)) { - $copySlice(b.buf, $subslice(b.buf, b.off)); - } else if (c > ((2147483647 - c >> 0) - n >> 0)) { - $panic($pkg.ErrTooLarge); - } else { - buf = makeSlice(($imul(2, c)) + n >> 0); - $copySlice(buf, $subslice(b.buf, b.off)); - b.buf = buf; - } - b.off = 0; - b.buf = $subslice(b.buf, 0, (m + n >> 0)); - return m; - }; - Buffer.prototype.grow = function(n) { return this.$val.grow(n); }; - Buffer.ptr.prototype.Grow = function(n) { - var b, m, n; - b = this; - if (n < 0) { - $panic(new $String("bytes.Buffer.Grow: negative count")); - } - m = b.grow(n); - b.buf = $subslice(b.buf, 0, m); - }; - Buffer.prototype.Grow = function(n) { return this.$val.Grow(n); }; - Buffer.ptr.prototype.Write = function(p) { - var _tmp, _tmp$1, _tuple, b, err, m, n, ok, p; - n = 0; - err = $ifaceNil; - b = this; - b.lastRead = 0; - _tuple = b.tryGrowByReslice(p.$length); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = b.grow(p.$length); - } - _tmp = $copySlice($subslice(b.buf, m), p); - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - }; - Buffer.prototype.Write = function(p) { return this.$val.Write(p); }; - Buffer.ptr.prototype.WriteString = function(s) { - var _tmp, _tmp$1, _tuple, b, err, m, n, ok, s; - n = 0; - err = $ifaceNil; - b = this; - b.lastRead = 0; - _tuple = b.tryGrowByReslice(s.length); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = b.grow(s.length); - } - _tmp = $copyString($subslice(b.buf, m), s); - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - }; - Buffer.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; - Buffer.ptr.prototype.ReadFrom = function(r) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, i, m, n, r, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; i = $f.i; m = $f.m; n = $f.n; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Int64(0, 0); - err = $ifaceNil; - b = this; - b.lastRead = 0; - /* while (true) { */ case 1: - i = b.grow(512); - b.buf = $subslice(b.buf, 0, i); - _r = r.Read($subslice(b.buf, i, b.buf.$capacity)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - e = _tuple[1]; - if (m < 0) { - $panic(errNegativeRead); - } - b.buf = $subslice(b.buf, 0, (i + m >> 0)); - n = (x = (new $Int64(0, m)), new $Int64(n.$high + x.$high, n.$low + x.$low)); - if ($interfaceIsEqual(e, io.EOF)) { - _tmp = n; - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - if (!($interfaceIsEqual(e, $ifaceNil))) { - _tmp$2 = n; - _tmp$3 = e; - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - /* } */ $s = 1; continue; case 2: - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.ReadFrom }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.i = i; $f.m = m; $f.n = n; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Buffer.prototype.ReadFrom = function(r) { return this.$val.ReadFrom(r); }; - makeSlice = function(n) { - var n, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - $deferred.push([(function() { - if (!($interfaceIsEqual($recover(), $ifaceNil))) { - $panic($pkg.ErrTooLarge); - } - }), []]); - return $makeSlice(sliceType, n); - /* */ } catch(err) { $err = err; return sliceType.nil; } finally { $callDeferred($deferred, $err); } - }; - Buffer.ptr.prototype.WriteTo = function(w) { - var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, b, e, err, m, n, nBytes, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; n = $f.n; nBytes = $f.nBytes; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Int64(0, 0); - err = $ifaceNil; - b = this; - b.lastRead = 0; - nBytes = b.Len(); - /* */ if (nBytes > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (nBytes > 0) { */ case 1: - _r = w.Write($subslice(b.buf, b.off)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - e = _tuple[1]; - if (m > nBytes) { - $panic(new $String("bytes.Buffer.WriteTo: invalid Write count")); - } - b.off = b.off + (m) >> 0; - n = (new $Int64(0, m)); - if (!($interfaceIsEqual(e, $ifaceNil))) { - _tmp = n; - _tmp$1 = e; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - if (!((m === nBytes))) { - _tmp$2 = n; - _tmp$3 = io.ErrShortWrite; - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - /* } */ case 2: - b.Reset(); - _tmp$4 = n; - _tmp$5 = $ifaceNil; - n = _tmp$4; - err = _tmp$5; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.n = n; $f.nBytes = nBytes; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - Buffer.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; - Buffer.ptr.prototype.WriteByte = function(c) { - var _tuple, b, c, m, ok, x; - b = this; - b.lastRead = 0; - _tuple = b.tryGrowByReslice(1); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = b.grow(1); - } - (x = b.buf, ((m < 0 || m >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + m] = c)); - return $ifaceNil; - }; - Buffer.prototype.WriteByte = function(c) { return this.$val.WriteByte(c); }; - Buffer.ptr.prototype.WriteRune = function(r) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, err, m, n, ok, r; - n = 0; - err = $ifaceNil; - b = this; - if (r < 128) { - b.WriteByte(((r << 24 >>> 24))); - _tmp = 1; - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - b.lastRead = 0; - _tuple = b.tryGrowByReslice(4); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = b.grow(4); - } - n = utf8.EncodeRune($subslice(b.buf, m, (m + 4 >> 0)), r); - b.buf = $subslice(b.buf, 0, (m + n >> 0)); - _tmp$2 = n; - _tmp$3 = $ifaceNil; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - }; - Buffer.prototype.WriteRune = function(r) { return this.$val.WriteRune(r); }; - Buffer.ptr.prototype.Read = function(p) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, err, n, p; - n = 0; - err = $ifaceNil; - b = this; - b.lastRead = 0; - if (b.empty()) { - b.Reset(); - if (p.$length === 0) { - _tmp = 0; - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - _tmp$2 = 0; - _tmp$3 = io.EOF; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - } - n = $copySlice(p, $subslice(b.buf, b.off)); - b.off = b.off + (n) >> 0; - if (n > 0) { - b.lastRead = -1; - } - _tmp$4 = n; - _tmp$5 = $ifaceNil; - n = _tmp$4; - err = _tmp$5; - return [n, err]; - }; - Buffer.prototype.Read = function(p) { return this.$val.Read(p); }; - Buffer.ptr.prototype.Next = function(n) { - var b, data, m, n; - b = this; - b.lastRead = 0; - m = b.Len(); - if (n > m) { - n = m; - } - data = $subslice(b.buf, b.off, (b.off + n >> 0)); - b.off = b.off + (n) >> 0; - if (n > 0) { - b.lastRead = -1; - } - return data; - }; - Buffer.prototype.Next = function(n) { return this.$val.Next(n); }; - Buffer.ptr.prototype.ReadByte = function() { - var b, c, x, x$1; - b = this; - if (b.empty()) { - b.Reset(); - return [0, io.EOF]; - } - c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - b.off = b.off + (1) >> 0; - b.lastRead = -1; - return [c, $ifaceNil]; - }; - Buffer.prototype.ReadByte = function() { return this.$val.ReadByte(); }; - Buffer.ptr.prototype.ReadRune = function() { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, b, c, err, n, r, size, x, x$1; - r = 0; - size = 0; - err = $ifaceNil; - b = this; - if (b.empty()) { - b.Reset(); - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = io.EOF; - r = _tmp; - size = _tmp$1; - err = _tmp$2; - return [r, size, err]; - } - c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (c < 128) { - b.off = b.off + (1) >> 0; - b.lastRead = 1; - _tmp$3 = ((c >> 0)); - _tmp$4 = 1; - _tmp$5 = $ifaceNil; - r = _tmp$3; - size = _tmp$4; - err = _tmp$5; - return [r, size, err]; - } - _tuple = utf8.DecodeRune($subslice(b.buf, b.off)); - r = _tuple[0]; - n = _tuple[1]; - b.off = b.off + (n) >> 0; - b.lastRead = ((n << 24 >> 24)); - _tmp$6 = r; - _tmp$7 = n; - _tmp$8 = $ifaceNil; - r = _tmp$6; - size = _tmp$7; - err = _tmp$8; - return [r, size, err]; - }; - Buffer.prototype.ReadRune = function() { return this.$val.ReadRune(); }; - Buffer.ptr.prototype.UnreadRune = function() { - var b; - b = this; - if (b.lastRead <= 0) { - return errors.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune"); - } - if (b.off >= ((b.lastRead >> 0))) { - b.off = b.off - (((b.lastRead >> 0))) >> 0; - } - b.lastRead = 0; - return $ifaceNil; - }; - Buffer.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; - Buffer.ptr.prototype.UnreadByte = function() { - var b; - b = this; - if (b.lastRead === 0) { - return errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read"); - } - b.lastRead = 0; - if (b.off > 0) { - b.off = b.off - (1) >> 0; - } - return $ifaceNil; - }; - Buffer.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; - Buffer.ptr.prototype.ReadBytes = function(delim) { - var _tmp, _tmp$1, _tuple, b, delim, err, line, slice; - line = sliceType.nil; - err = $ifaceNil; - b = this; - _tuple = b.readSlice(delim); - slice = _tuple[0]; - err = _tuple[1]; - line = $appendSlice(line, slice); - _tmp = line; - _tmp$1 = err; - line = _tmp; - err = _tmp$1; - return [line, err]; - }; - Buffer.prototype.ReadBytes = function(delim) { return this.$val.ReadBytes(delim); }; - Buffer.ptr.prototype.readSlice = function(delim) { - var _tmp, _tmp$1, b, delim, end, err, i, line; - line = sliceType.nil; - err = $ifaceNil; - b = this; - i = IndexByte($subslice(b.buf, b.off), delim); - end = (b.off + i >> 0) + 1 >> 0; - if (i < 0) { - end = b.buf.$length; - err = io.EOF; - } - line = $subslice(b.buf, b.off, end); - b.off = end; - b.lastRead = -1; - _tmp = line; - _tmp$1 = err; - line = _tmp; - err = _tmp$1; - return [line, err]; - }; - Buffer.prototype.readSlice = function(delim) { return this.$val.readSlice(delim); }; - Buffer.ptr.prototype.ReadString = function(delim) { - var _tmp, _tmp$1, _tuple, b, delim, err, line, slice; - line = ""; - err = $ifaceNil; - b = this; - _tuple = b.readSlice(delim); - slice = _tuple[0]; - err = _tuple[1]; - _tmp = ($bytesToString(slice)); - _tmp$1 = err; - line = _tmp; - err = _tmp$1; - return [line, err]; - }; - Buffer.prototype.ReadString = function(delim) { return this.$val.ReadString(delim); }; - HasPrefix = function(s, prefix) { - var prefix, s; - return s.$length >= prefix.$length && Equal($subslice(s, 0, prefix.$length), prefix); - }; - $pkg.HasPrefix = HasPrefix; - TrimRightFunc = function(s, f) { - var _r, _tuple, f, i, s, wid, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; f = $f.f; i = $f.i; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = lastIndexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - i = _r; - if (i >= 0 && ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) >= 128) { - _tuple = utf8.DecodeRune($subslice(s, i)); - wid = _tuple[1]; - i = i + (wid) >> 0; - } else { - i = i + (1) >> 0; - } - $s = -1; return $subslice(s, 0, i); - /* */ } return; } if ($f === undefined) { $f = { $blk: TrimRightFunc }; } $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.TrimRightFunc = TrimRightFunc; - lastIndexFunc = function(s, f, truth) { - var _r, _tmp, _tmp$1, _tuple, f, i, r, s, size, truth, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; i = $f.i; r = $f.r; s = $f.s; size = $f.size; truth = $f.truth; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = s.$length; - /* while (true) { */ case 1: - /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 2; continue; } - _tmp = (((x = i - 1 >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) >> 0)); - _tmp$1 = 1; - r = _tmp; - size = _tmp$1; - if (r >= 128) { - _tuple = utf8.DecodeLastRune($subslice(s, 0, i)); - r = _tuple[0]; - size = _tuple[1]; - } - i = i - (size) >> 0; - _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r === truth) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_r === truth) { */ case 3: - $s = -1; return i; - /* } */ case 4: - /* } */ $s = 1; continue; case 2: - $s = -1; return -1; - /* */ } return; } if ($f === undefined) { $f = { $blk: lastIndexFunc }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.r = r; $f.s = s; $f.size = size; $f.truth = truth; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - makeASCIISet = function(chars) { - var _index, _tmp, _tmp$1, _tmp$2, _tmp$3, as, c, chars, i, ok, y; - as = arrayType$1.zero(); - ok = false; - i = 0; - while (true) { - if (!(i < chars.length)) { break; } - c = chars.charCodeAt(i); - if (c >= 128) { - _tmp = $clone(as, asciiSet); - _tmp$1 = false; - asciiSet.copy(as, _tmp); - ok = _tmp$1; - return [as, ok]; - } - _index = c >>> 5 << 24 >>> 24; - ((_index < 0 || _index >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[_index] = ((((_index < 0 || _index >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[_index]) | (((y = ((((c & 31) >>> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0)); - i = i + (1) >> 0; - } - _tmp$2 = $clone(as, asciiSet); - _tmp$3 = true; - asciiSet.copy(as, _tmp$2); - ok = _tmp$3; - return [as, ok]; - }; - asciiSet.prototype.contains = function(c) { - var as, c, x, y; - as = this.$val; - return !((((((x = c >>> 5 << 24 >>> 24, (as.nilCheck, ((x < 0 || x >= as.length) ? ($throwRuntimeError("index out of range"), undefined) : as[x]))) & (((y = ((((c & 31) >>> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0)) === 0)); - }; - $ptrType(asciiSet).prototype.contains = function(c) { return (new asciiSet(this.$get())).contains(c); }; - makeCutsetFunc = function(cutset) { - var _tuple, as, cutset, isASCII; - if ((cutset.length === 1) && cutset.charCodeAt(0) < 128) { - return (function(r) { - var r; - return r === ((cutset.charCodeAt(0) >> 0)); - }); - } - _tuple = makeASCIISet(cutset); - as = $clone(_tuple[0], asciiSet); - isASCII = _tuple[1]; - if (isASCII) { - return (function(r) { - var r; - return r < 128 && new ptrType$1(as).contains(((r << 24 >>> 24))); - }); - } - return (function(r) { - var _i, _ref, _rune, c, r; - _ref = cutset; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - c = _rune[0]; - if (c === r) { - return true; - } - _i += _rune[1]; - } - return false; - }); - }; - TrimRight = function(s, cutset) { - var _r, cutset, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; cutset = $f.cutset; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = TrimRightFunc(s, makeCutsetFunc(cutset)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: TrimRight }; } $f._r = _r; $f.cutset = cutset; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.TrimRight = TrimRight; - EqualFold = function(s, t) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, r, r$1, r$2, s, size, size$1, sr, t, tr; - while (true) { - if (!(!((s.$length === 0)) && !((t.$length === 0)))) { break; } - _tmp = 0; - _tmp$1 = 0; - sr = _tmp; - tr = _tmp$1; - if ((0 >= s.$length ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + 0]) < 128) { - _tmp$2 = (((0 >= s.$length ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + 0]) >> 0)); - _tmp$3 = $subslice(s, 1); - sr = _tmp$2; - s = _tmp$3; - } else { - _tuple = utf8.DecodeRune(s); - r = _tuple[0]; - size = _tuple[1]; - _tmp$4 = r; - _tmp$5 = $subslice(s, size); - sr = _tmp$4; - s = _tmp$5; - } - if ((0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]) < 128) { - _tmp$6 = (((0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]) >> 0)); - _tmp$7 = $subslice(t, 1); - tr = _tmp$6; - t = _tmp$7; - } else { - _tuple$1 = utf8.DecodeRune(t); - r$1 = _tuple$1[0]; - size$1 = _tuple$1[1]; - _tmp$8 = r$1; - _tmp$9 = $subslice(t, size$1); - tr = _tmp$8; - t = _tmp$9; - } - if (tr === sr) { - continue; - } - if (tr < sr) { - _tmp$10 = sr; - _tmp$11 = tr; - tr = _tmp$10; - sr = _tmp$11; - } - if (tr < 128) { - if (65 <= sr && sr <= 90 && (tr === ((sr + 97 >> 0) - 65 >> 0))) { - continue; - } - return false; - } - r$2 = unicode.SimpleFold(sr); - while (true) { - if (!(!((r$2 === sr)) && r$2 < tr)) { break; } - r$2 = unicode.SimpleFold(r$2); - } - if (r$2 === tr) { - continue; - } - return false; - } - return s.$length === t.$length; - }; - $pkg.EqualFold = EqualFold; - Index = function(s, sep) { - var c0, c0$1, c1, c1$1, fails, fails$1, i, i$1, j, n, o, o$1, r, s, sep, t, t$1, x, x$1; - n = sep.$length; - if ((n === 0)) { - return 0; - } else if ((n === 1)) { - return IndexByte(s, (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0])); - } else if ((n === s.$length)) { - if (Equal(sep, s)) { - return 0; - } - return -1; - } else if (n > s.$length) { - return -1; - } else if (n <= bytealg.MaxLen) { - if (s.$length <= 0) { - return bytealg.Index(s, sep); - } - c0 = (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0]); - c1 = (1 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 1]); - i = 0; - t = (s.$length - n >> 0) + 1 >> 0; - fails = 0; - while (true) { - if (!(i < t)) { break; } - if (!((((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) === c0))) { - o = IndexByte($subslice(s, i, t), c0); - if (o < 0) { - return -1; - } - i = i + (o) >> 0; - } - if (((x = i + 1 >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) === c1) && Equal($subslice(s, i, (i + n >> 0)), sep)) { - return i; - } - fails = fails + (1) >> 0; - i = i + (1) >> 0; - if (fails > bytealg.Cutover(i)) { - r = bytealg.Index($subslice(s, i), sep); - if (r >= 0) { - return r + i >> 0; - } - return -1; - } - } - return -1; - } - c0$1 = (0 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 0]); - c1$1 = (1 >= sep.$length ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + 1]); - i$1 = 0; - fails$1 = 0; - t$1 = (s.$length - n >> 0) + 1 >> 0; - while (true) { - if (!(i$1 < t$1)) { break; } - if (!((((i$1 < 0 || i$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i$1]) === c0$1))) { - o$1 = IndexByte($subslice(s, i$1, t$1), c0$1); - if (o$1 < 0) { - break; - } - i$1 = i$1 + (o$1) >> 0; - } - if (((x$1 = i$1 + 1 >> 0, ((x$1 < 0 || x$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x$1])) === c1$1) && Equal($subslice(s, i$1, (i$1 + n >> 0)), sep)) { - return i$1; - } - i$1 = i$1 + (1) >> 0; - fails$1 = fails$1 + (1) >> 0; - if (fails$1 >= (4 + (i$1 >> 4 >> 0) >> 0) && i$1 < t$1) { - j = indexRabinKarp($subslice(s, i$1), sep); - if (j < 0) { - return -1; - } - return i$1 + j >> 0; - } - } - return -1; - }; - $pkg.Index = Index; - indexRabinKarp = function(s, sep) { - var _tuple, h, hashsep, i, i$1, n, pow, s, sep, x; - _tuple = hashStr(sep); - hashsep = _tuple[0]; - pow = _tuple[1]; - n = sep.$length; - h = 0; - i = 0; - while (true) { - if (!(i < n)) { break; } - h = ($imul(h, 16777619) >>> 0) + ((((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) >>> 0)) >>> 0; - i = i + (1) >> 0; - } - if ((h === hashsep) && Equal($subslice(s, 0, n), sep)) { - return 0; - } - i$1 = n; - while (true) { - if (!(i$1 < s.$length)) { break; } - h = $imul(h, (16777619)) >>> 0; - h = h + (((((i$1 < 0 || i$1 >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i$1]) >>> 0))) >>> 0; - h = h - (($imul(pow, (((x = i$1 - n >> 0, ((x < 0 || x >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + x])) >>> 0))) >>> 0)) >>> 0; - i$1 = i$1 + (1) >> 0; - if ((h === hashsep) && Equal($subslice(s, (i$1 - n >> 0), i$1), sep)) { - return i$1 - n >> 0; - } - } - return -1; - }; - hashStr = function(sep) { - var _tmp, _tmp$1, hash, i, i$1, pow, sep, sq; - hash = 0; - i = 0; - while (true) { - if (!(i < sep.$length)) { break; } - hash = ($imul(hash, 16777619) >>> 0) + ((((i < 0 || i >= sep.$length) ? ($throwRuntimeError("index out of range"), undefined) : sep.$array[sep.$offset + i]) >>> 0)) >>> 0; - i = i + (1) >> 0; - } - _tmp = 1; - _tmp$1 = 16777619; - pow = _tmp; - sq = _tmp$1; - i$1 = sep.$length; - while (true) { - if (!(i$1 > 0)) { break; } - if (!(((i$1 & 1) === 0))) { - pow = $imul(pow, (sq)) >>> 0; - } - sq = $imul(sq, (sq)) >>> 0; - i$1 = (i$1 >> $min((1), 31)) >> 0; - } - return [hash, pow]; - }; - Reader.ptr.prototype.Len = function() { - var r, x, x$1, x$2, x$3, x$4; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - return 0; - } - return (((x$2 = (x$3 = (new $Int64(0, r.s.$length)), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); - }; - Reader.prototype.Len = function() { return this.$val.Len(); }; - Reader.ptr.prototype.Size = function() { - var r; - r = this; - return (new $Int64(0, r.s.$length)); - }; - Reader.prototype.Size = function() { return this.$val.Size(); }; - Reader.ptr.prototype.Read = function(b) { - var _tmp, _tmp$1, b, err, n, r, x, x$1, x$2, x$3; - n = 0; - err = $ifaceNil; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - _tmp = 0; - _tmp$1 = io.EOF; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - r.prevRune = -1; - n = $copySlice(b, $subslice(r.s, $flatten64(r.i))); - r.i = (x$2 = r.i, x$3 = (new $Int64(0, n)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); - return [n, err]; - }; - Reader.prototype.Read = function(b) { return this.$val.Read(b); }; - Reader.ptr.prototype.ReadAt = function(b, off) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x; - n = 0; - err = $ifaceNil; - r = this; - if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { - _tmp = 0; - _tmp$1 = errors.New("bytes.Reader.ReadAt: negative offset"); - n = _tmp; - err = _tmp$1; - return [n, err]; - } - if ((x = (new $Int64(0, r.s.$length)), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) { - _tmp$2 = 0; - _tmp$3 = io.EOF; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - } - n = $copySlice(b, $subslice(r.s, $flatten64(off))); - if (n < b.$length) { - err = io.EOF; - } - return [n, err]; - }; - Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; - Reader.ptr.prototype.ReadByte = function() { - var b, r, x, x$1, x$2, x$3, x$4, x$5; - r = this; - r.prevRune = -1; - if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - return [0, io.EOF]; - } - b = (x$2 = r.s, x$3 = r.i, (($flatten64(x$3) < 0 || $flatten64(x$3) >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + $flatten64(x$3)])); - r.i = (x$4 = r.i, x$5 = new $Int64(0, 1), new $Int64(x$4.$high + x$5.$high, x$4.$low + x$5.$low)); - return [b, $ifaceNil]; - }; - Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; - Reader.ptr.prototype.UnreadByte = function() { - var r, x, x$1, x$2; - r = this; - if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { - return errors.New("bytes.Reader.UnreadByte: at beginning of slice"); - } - r.prevRune = -1; - r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - return $ifaceNil; - }; - Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; - Reader.ptr.prototype.ReadRune = function() { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; - ch = 0; - size = 0; - err = $ifaceNil; - r = this; - if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - r.prevRune = -1; - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = io.EOF; - ch = _tmp; - size = _tmp$1; - err = _tmp$2; - return [ch, size, err]; - } - r.prevRune = (((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); - c = (x$3 = r.s, x$4 = r.i, (($flatten64(x$4) < 0 || $flatten64(x$4) >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + $flatten64(x$4)])); - if (c < 128) { - r.i = (x$5 = r.i, x$6 = new $Int64(0, 1), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)); - _tmp$3 = ((c >> 0)); - _tmp$4 = 1; - _tmp$5 = $ifaceNil; - ch = _tmp$3; - size = _tmp$4; - err = _tmp$5; - return [ch, size, err]; - } - _tuple = utf8.DecodeRune($subslice(r.s, $flatten64(r.i))); - ch = _tuple[0]; - size = _tuple[1]; - r.i = (x$7 = r.i, x$8 = (new $Int64(0, size)), new $Int64(x$7.$high + x$8.$high, x$7.$low + x$8.$low)); - return [ch, size, err]; - }; - Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); }; - Reader.ptr.prototype.UnreadRune = function() { - var r, x; - r = this; - if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) { - return errors.New("bytes.Reader.UnreadRune: at beginning of slice"); - } - if (r.prevRune < 0) { - return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune"); - } - r.i = (new $Int64(0, r.prevRune)); - r.prevRune = -1; - return $ifaceNil; - }; - Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; - Reader.ptr.prototype.Seek = function(offset, whence) { - var _1, abs, offset, r, whence, x, x$1; - r = this; - r.prevRune = -1; - abs = new $Int64(0, 0); - _1 = whence; - if (_1 === (0)) { - abs = offset; - } else if (_1 === (1)) { - abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low)); - } else if (_1 === (2)) { - abs = (x$1 = (new $Int64(0, r.s.$length)), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low)); - } else { - return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: invalid whence")]; - } - if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) { - return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: negative position")]; - } - r.i = abs; - return [abs, $ifaceNil]; - }; - Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; - Reader.ptr.prototype.WriteTo = function(w) { - var _r, _tmp, _tmp$1, _tuple, b, err, m, n, r, w, x, x$1, x$2, x$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; m = $f.m; n = $f.n; r = $f.r; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Int64(0, 0); - err = $ifaceNil; - r = this; - r.prevRune = -1; - if ((x = r.i, x$1 = (new $Int64(0, r.s.$length)), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) { - _tmp = new $Int64(0, 0); - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - b = $subslice(r.s, $flatten64(r.i)); - _r = w.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - m = _tuple[0]; - err = _tuple[1]; - if (m > b.$length) { - $panic(new $String("bytes.Reader.WriteTo: invalid Write count")); - } - r.i = (x$2 = r.i, x$3 = (new $Int64(0, m)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)); - n = (new $Int64(0, m)); - if (!((m === b.$length)) && $interfaceIsEqual(err, $ifaceNil)) { - err = io.ErrShortWrite; - } - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; - }; - Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); }; - Reader.ptr.prototype.Reset = function(b) { - var b, r; - r = this; - Reader.copy(r, new Reader.ptr(b, new $Int64(0, 0), -1)); - }; - Reader.prototype.Reset = function(b) { return this.$val.Reset(b); }; - NewReader = function(b) { - var b; - return new Reader.ptr(b, new $Int64(0, 0), -1); - }; - $pkg.NewReader = NewReader; - ptrType.methods = [{prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "empty", name: "empty", pkg: "bytes", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "tryGrowByReslice", name: "tryGrowByReslice", pkg: "bytes", typ: $funcType([$Int], [$Int, $Bool], false)}, {prop: "grow", name: "grow", pkg: "bytes", typ: $funcType([$Int], [$Int], false)}, {prop: "Grow", name: "Grow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([io.Reader], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$Int, $error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([$Int], [sliceType], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadBytes", name: "ReadBytes", pkg: "", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "readSlice", name: "readSlice", pkg: "bytes", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "ReadString", name: "ReadString", pkg: "", typ: $funcType([$Uint8], [$String, $error], false)}]; - ptrType$1.methods = [{prop: "contains", name: "contains", pkg: "bytes", typ: $funcType([$Uint8], [$Bool], false)}]; - ptrType$2.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([sliceType], [], false)}]; - Buffer.init("bytes", [{prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "off", name: "off", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "lastRead", name: "lastRead", embedded: false, exported: false, typ: readOp, tag: ""}]); - asciiSet.init($Uint32, 8); - Reader.init("bytes", [{prop: "s", name: "s", embedded: false, exported: false, typ: sliceType, tag: ""}, {prop: "i", name: "i", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", embedded: false, exported: false, typ: $Int, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bytealg.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.ErrTooLarge = errors.New("bytes.Buffer: too large"); - errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read"); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["encoding"] = (function() { - var $pkg = {}, $init, TextMarshaler, TextUnmarshaler, sliceType; - TextMarshaler = $pkg.TextMarshaler = $newType(8, $kindInterface, "encoding.TextMarshaler", true, "encoding", true, null); - TextUnmarshaler = $pkg.TextUnmarshaler = $newType(8, $kindInterface, "encoding.TextUnmarshaler", true, "encoding", true, null); - sliceType = $sliceType($Uint8); - TextMarshaler.init([{prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType, $error], false)}]); - TextUnmarshaler.init([{prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType], [$error], false)}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["encoding/binary"] = (function() { - var $pkg = {}, $init, errors, io, math, reflect, littleEndian, bigEndian, sliceType, overflow; - errors = $packages["errors"]; - io = $packages["io"]; - math = $packages["math"]; - reflect = $packages["reflect"]; - littleEndian = $pkg.littleEndian = $newType(0, $kindStruct, "binary.littleEndian", true, "encoding/binary", false, function() { - this.$val = this; - if (arguments.length === 0) { - return; - } - }); - bigEndian = $pkg.bigEndian = $newType(0, $kindStruct, "binary.bigEndian", true, "encoding/binary", false, function() { - this.$val = this; - if (arguments.length === 0) { - return; - } - }); - sliceType = $sliceType($Uint8); - littleEndian.ptr.prototype.Uint16 = function(b) { - var b; - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - return ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) << 16 >>> 16)) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) << 16 >>> 16)) << 8 << 16 >>> 16)) >>> 0; - }; - littleEndian.prototype.Uint16 = function(b) { return this.$val.Uint16(b); }; - littleEndian.ptr.prototype.PutUint16 = function(b, v) { - var b, v; - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 8 << 16 >>> 16) << 24 >>> 24))); - }; - littleEndian.prototype.PutUint16 = function(b, v) { return this.$val.PutUint16(b, v); }; - littleEndian.ptr.prototype.Uint32 = function(b) { - var b; - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - return ((((((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) << 24 >>> 0)) >>> 0; - }; - littleEndian.prototype.Uint32 = function(b) { return this.$val.Uint32(b); }; - littleEndian.ptr.prototype.PutUint32 = function(b, v) { - var b, v; - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 8 >>> 0) << 24 >>> 24))); - (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (((v >>> 16 >>> 0) << 24 >>> 24))); - (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (((v >>> 24 >>> 0) << 24 >>> 24))); - }; - littleEndian.prototype.PutUint32 = function(b, v) { return this.$val.PutUint32(b, v); }; - littleEndian.ptr.prototype.Uint64 = function(b) { - var b, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$7 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); - }; - littleEndian.prototype.Uint64 = function(b) { return this.$val.Uint64(b); }; - littleEndian.ptr.prototype.PutUint64 = function(b, v) { - var b, v; - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = ((v.$low << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (($shiftRightUint64(v, 8).$low << 24 >>> 24))); - (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (($shiftRightUint64(v, 16).$low << 24 >>> 24))); - (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (($shiftRightUint64(v, 24).$low << 24 >>> 24))); - (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4] = (($shiftRightUint64(v, 32).$low << 24 >>> 24))); - (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5] = (($shiftRightUint64(v, 40).$low << 24 >>> 24))); - (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6] = (($shiftRightUint64(v, 48).$low << 24 >>> 24))); - (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7] = (($shiftRightUint64(v, 56).$low << 24 >>> 24))); - }; - littleEndian.prototype.PutUint64 = function(b, v) { return this.$val.PutUint64(b, v); }; - littleEndian.ptr.prototype.String = function() { - return "LittleEndian"; - }; - littleEndian.prototype.String = function() { return this.$val.String(); }; - littleEndian.ptr.prototype.GoString = function() { - return "binary.LittleEndian"; - }; - littleEndian.prototype.GoString = function() { return this.$val.GoString(); }; - bigEndian.ptr.prototype.Uint16 = function(b) { - var b; - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - return ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) << 16 >>> 16)) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) << 16 >>> 16)) << 8 << 16 >>> 16)) >>> 0; - }; - bigEndian.prototype.Uint16 = function(b) { return this.$val.Uint16(b); }; - bigEndian.ptr.prototype.PutUint16 = function(b, v) { - var b, v; - $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (((v >>> 8 << 16 >>> 16) << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = ((v << 24 >>> 24))); - }; - bigEndian.prototype.PutUint16 = function(b, v) { return this.$val.PutUint16(b, v); }; - bigEndian.ptr.prototype.Uint32 = function(b) { - var b; - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - return ((((((((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]) >>> 0)) | ((((2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | ((((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]) >>> 0)) << 24 >>> 0)) >>> 0; - }; - bigEndian.prototype.Uint32 = function(b) { return this.$val.Uint32(b); }; - bigEndian.ptr.prototype.PutUint32 = function(b, v) { - var b, v; - $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (((v >>> 24 >>> 0) << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (((v >>> 16 >>> 0) << 24 >>> 24))); - (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (((v >>> 8 >>> 0) << 24 >>> 24))); - (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = ((v << 24 >>> 24))); - }; - bigEndian.prototype.PutUint32 = function(b, v) { return this.$val.PutUint32(b, v); }; - bigEndian.ptr.prototype.Uint64 = function(b) { - var b, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$7 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); - }; - bigEndian.prototype.Uint64 = function(b) { return this.$val.Uint64(b); }; - bigEndian.ptr.prototype.PutUint64 = function(b, v) { - var b, v; - $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); - (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0] = (($shiftRightUint64(v, 56).$low << 24 >>> 24))); - (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1] = (($shiftRightUint64(v, 48).$low << 24 >>> 24))); - (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2] = (($shiftRightUint64(v, 40).$low << 24 >>> 24))); - (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3] = (($shiftRightUint64(v, 32).$low << 24 >>> 24))); - (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4] = (($shiftRightUint64(v, 24).$low << 24 >>> 24))); - (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5] = (($shiftRightUint64(v, 16).$low << 24 >>> 24))); - (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6] = (($shiftRightUint64(v, 8).$low << 24 >>> 24))); - (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7] = ((v.$low << 24 >>> 24))); - }; - bigEndian.prototype.PutUint64 = function(b, v) { return this.$val.PutUint64(b, v); }; - bigEndian.ptr.prototype.String = function() { - return "BigEndian"; - }; - bigEndian.prototype.String = function() { return this.$val.String(); }; - bigEndian.ptr.prototype.GoString = function() { - return "binary.BigEndian"; - }; - bigEndian.prototype.GoString = function() { return this.$val.GoString(); }; - littleEndian.methods = [{prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]; - bigEndian.methods = [{prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]; - littleEndian.init("", []); - bigEndian.init("", []); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.LittleEndian = new littleEndian.ptr(); - $pkg.BigEndian = new bigEndian.ptr(); - overflow = errors.New("binary: varint overflows a 64-bit integer"); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["encoding/base64"] = (function() { - var $pkg = {}, $init, binary, io, strconv, Encoding, encoder, CorruptInputError, arrayType, arrayType$1, sliceType, ptrType, arrayType$2, arrayType$3, arrayType$4, ptrType$1, NewEncoding, NewEncoder; - binary = $packages["encoding/binary"]; - io = $packages["io"]; - strconv = $packages["strconv"]; - Encoding = $pkg.Encoding = $newType(0, $kindStruct, "base64.Encoding", true, "encoding/base64", true, function(encode_, decodeMap_, padChar_, strict_) { - this.$val = this; - if (arguments.length === 0) { - this.encode = arrayType.zero(); - this.decodeMap = arrayType$1.zero(); - this.padChar = 0; - this.strict = false; - return; - } - this.encode = encode_; - this.decodeMap = decodeMap_; - this.padChar = padChar_; - this.strict = strict_; - }); - encoder = $pkg.encoder = $newType(0, $kindStruct, "base64.encoder", true, "encoding/base64", false, function(err_, enc_, w_, buf_, nbuf_, out_) { - this.$val = this; - if (arguments.length === 0) { - this.err = $ifaceNil; - this.enc = ptrType.nil; - this.w = $ifaceNil; - this.buf = arrayType$2.zero(); - this.nbuf = 0; - this.out = arrayType$3.zero(); - return; - } - this.err = err_; - this.enc = enc_; - this.w = w_; - this.buf = buf_; - this.nbuf = nbuf_; - this.out = out_; - }); - CorruptInputError = $pkg.CorruptInputError = $newType(8, $kindInt64, "base64.CorruptInputError", true, "encoding/base64", true, null); - arrayType = $arrayType($Uint8, 64); - arrayType$1 = $arrayType($Uint8, 256); - sliceType = $sliceType($Uint8); - ptrType = $ptrType(Encoding); - arrayType$2 = $arrayType($Uint8, 3); - arrayType$3 = $arrayType($Uint8, 1024); - arrayType$4 = $arrayType($Uint8, 4); - ptrType$1 = $ptrType(encoder); - NewEncoding = function(encoder$1) { - var e, encoder$1, i, i$1, i$2, x, x$1, x$2; - if (!((encoder$1.length === 64))) { - $panic(new $String("encoding alphabet is not 64-bytes long")); - } - i = 0; - while (true) { - if (!(i < encoder$1.length)) { break; } - if ((encoder$1.charCodeAt(i) === 10) || (encoder$1.charCodeAt(i) === 13)) { - $panic(new $String("encoding alphabet contains newline character")); - } - i = i + (1) >> 0; - } - e = new Encoding.ptr(arrayType.zero(), arrayType$1.zero(), 0, false); - e.padChar = 61; - $copyString(new sliceType(e.encode), encoder$1); - i$1 = 0; - while (true) { - if (!(i$1 < 256)) { break; } - (x = e.decodeMap, ((i$1 < 0 || i$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i$1] = 255)); - i$1 = i$1 + (1) >> 0; - } - i$2 = 0; - while (true) { - if (!(i$2 < encoder$1.length)) { break; } - (x$1 = e.decodeMap, x$2 = encoder$1.charCodeAt(i$2), ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2] = ((i$2 << 24 >>> 24)))); - i$2 = i$2 + (1) >> 0; - } - return e; - }; - $pkg.NewEncoding = NewEncoding; - Encoding.ptr.prototype.WithPadding = function(padding) { - var enc, i, padding, x; - enc = this; - if ((padding === 13) || (padding === 10) || padding > 255) { - $panic(new $String("invalid padding")); - } - i = 0; - while (true) { - if (!(i < 64)) { break; } - if ((((x = enc.encode, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])) >> 0)) === padding) { - $panic(new $String("padding contained in alphabet")); - } - i = i + (1) >> 0; - } - enc.padChar = padding; - return enc; - }; - Encoding.prototype.WithPadding = function(padding) { return this.$val.WithPadding(padding); }; - Encoding.ptr.prototype.Strict = function() { - var enc; - enc = this; - enc.strict = true; - return enc; - }; - Encoding.prototype.Strict = function() { return this.$val.Strict(); }; - Encoding.ptr.prototype.Encode = function(dst, src) { - var _1, _q, _tmp, _tmp$1, di, dst, enc, n, remain, si, src, val, val$1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$25, x$26, x$27, x$28, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - enc = this; - if (src.$length === 0) { - return; - } - _tmp = 0; - _tmp$1 = 0; - di = _tmp; - si = _tmp$1; - n = $imul(((_q = src.$length / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))), 3); - while (true) { - if (!(si < n)) { break; } - val = (((((((x = si + 0 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) >>> 0)) << 16 >>> 0) | ((((x$1 = si + 1 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) >>> 0)) << 8 >>> 0)) >>> 0) | (((x$2 = si + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) >>> 0))) >>> 0; - (x$5 = di + 0 >> 0, ((x$5 < 0 || x$5 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$5] = (x$3 = enc.encode, x$4 = ((val >>> 18 >>> 0) & 63) >>> 0, ((x$4 < 0 || x$4 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[x$4])))); - (x$8 = di + 1 >> 0, ((x$8 < 0 || x$8 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$8] = (x$6 = enc.encode, x$7 = ((val >>> 12 >>> 0) & 63) >>> 0, ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])))); - (x$11 = di + 2 >> 0, ((x$11 < 0 || x$11 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$11] = (x$9 = enc.encode, x$10 = ((val >>> 6 >>> 0) & 63) >>> 0, ((x$10 < 0 || x$10 >= x$9.length) ? ($throwRuntimeError("index out of range"), undefined) : x$9[x$10])))); - (x$14 = di + 3 >> 0, ((x$14 < 0 || x$14 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$14] = (x$12 = enc.encode, x$13 = (val & 63) >>> 0, ((x$13 < 0 || x$13 >= x$12.length) ? ($throwRuntimeError("index out of range"), undefined) : x$12[x$13])))); - si = si + (3) >> 0; - di = di + (4) >> 0; - } - remain = src.$length - si >> 0; - if (remain === 0) { - return; - } - val$1 = (((x$15 = si + 0 >> 0, ((x$15 < 0 || x$15 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$15])) >>> 0)) << 16 >>> 0; - if (remain === 2) { - val$1 = (val$1 | (((((x$16 = si + 1 >> 0, ((x$16 < 0 || x$16 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$16])) >>> 0)) << 8 >>> 0))) >>> 0; - } - (x$19 = di + 0 >> 0, ((x$19 < 0 || x$19 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$19] = (x$17 = enc.encode, x$18 = ((val$1 >>> 18 >>> 0) & 63) >>> 0, ((x$18 < 0 || x$18 >= x$17.length) ? ($throwRuntimeError("index out of range"), undefined) : x$17[x$18])))); - (x$22 = di + 1 >> 0, ((x$22 < 0 || x$22 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$22] = (x$20 = enc.encode, x$21 = ((val$1 >>> 12 >>> 0) & 63) >>> 0, ((x$21 < 0 || x$21 >= x$20.length) ? ($throwRuntimeError("index out of range"), undefined) : x$20[x$21])))); - _1 = remain; - if (_1 === (2)) { - (x$25 = di + 2 >> 0, ((x$25 < 0 || x$25 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$25] = (x$23 = enc.encode, x$24 = ((val$1 >>> 6 >>> 0) & 63) >>> 0, ((x$24 < 0 || x$24 >= x$23.length) ? ($throwRuntimeError("index out of range"), undefined) : x$23[x$24])))); - if (!((enc.padChar === -1))) { - (x$26 = di + 3 >> 0, ((x$26 < 0 || x$26 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$26] = ((enc.padChar << 24 >>> 24)))); - } - } else if (_1 === (1)) { - if (!((enc.padChar === -1))) { - (x$27 = di + 2 >> 0, ((x$27 < 0 || x$27 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$27] = ((enc.padChar << 24 >>> 24)))); - (x$28 = di + 3 >> 0, ((x$28 < 0 || x$28 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$28] = ((enc.padChar << 24 >>> 24)))); - } - } - }; - Encoding.prototype.Encode = function(dst, src) { return this.$val.Encode(dst, src); }; - Encoding.ptr.prototype.EncodeToString = function(src) { - var buf, enc, src; - enc = this; - buf = $makeSlice(sliceType, enc.EncodedLen(src.$length)); - enc.Encode(buf, src); - return ($bytesToString(buf)); - }; - Encoding.prototype.EncodeToString = function(src) { return this.$val.EncodeToString(src); }; - encoder.ptr.prototype.Write = function(p) { - var _q, _r, _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, e, err, i, i$1, n, nn, p, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; e = $f.e; err = $f.err; i = $f.i; i$1 = $f.i$1; n = $f.n; nn = $f.nn; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - e = this; - if (!($interfaceIsEqual(e.err, $ifaceNil))) { - _tmp = 0; - _tmp$1 = e.err; - n = _tmp; - err = _tmp$1; - $s = -1; return [n, err]; - } - /* */ if (e.nbuf > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (e.nbuf > 0) { */ case 1: - i = 0; - i = 0; - while (true) { - if (!(i < p.$length && e.nbuf < 3)) { break; } - (x = e.buf, x$1 = e.nbuf, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1] = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]))); - e.nbuf = e.nbuf + (1) >> 0; - i = i + (1) >> 0; - } - n = n + (i) >> 0; - p = $subslice(p, i); - if (e.nbuf < 3) { - $s = -1; return [n, err]; - } - e.enc.Encode(new sliceType(e.out), new sliceType(e.buf)); - _r = e.w.Write($subslice(new sliceType(e.out), 0, 4)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - e.err = _tuple[1]; - if (!($interfaceIsEqual(e.err, $ifaceNil))) { - _tmp$2 = n; - _tmp$3 = e.err; - n = _tmp$2; - err = _tmp$3; - $s = -1; return [n, err]; - } - e.nbuf = 0; - /* } */ case 2: - /* while (true) { */ case 4: - /* if (!(p.$length >= 3)) { break; } */ if(!(p.$length >= 3)) { $s = 5; continue; } - nn = 768; - if (nn > p.$length) { - nn = p.$length; - nn = nn - ((_r$1 = nn % 3, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))) >> 0; - } - e.enc.Encode(new sliceType(e.out), $subslice(p, 0, nn)); - _r$2 = e.w.Write($subslice(new sliceType(e.out), 0, ($imul((_q = nn / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), 4)))); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - e.err = _tuple$1[1]; - if (!($interfaceIsEqual(e.err, $ifaceNil))) { - _tmp$4 = n; - _tmp$5 = e.err; - n = _tmp$4; - err = _tmp$5; - $s = -1; return [n, err]; - } - n = n + (nn) >> 0; - p = $subslice(p, nn); - /* } */ $s = 4; continue; case 5: - i$1 = 0; - while (true) { - if (!(i$1 < p.$length)) { break; } - (x$2 = e.buf, ((i$1 < 0 || i$1 >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i$1] = ((i$1 < 0 || i$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i$1]))); - i$1 = i$1 + (1) >> 0; - } - e.nbuf = p.$length; - n = n + (p.$length) >> 0; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Write }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.e = e; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.n = n; $f.nn = nn; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - encoder.prototype.Write = function(p) { return this.$val.Write(p); }; - encoder.ptr.prototype.Close = function() { - var _r, _tuple, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - /* */ if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { */ case 1: - e.enc.Encode(new sliceType(e.out), $subslice(new sliceType(e.buf), 0, e.nbuf)); - _r = e.w.Write($subslice(new sliceType(e.out), 0, e.enc.EncodedLen(e.nbuf))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - e.err = _tuple[1]; - e.nbuf = 0; - /* } */ case 2: - $s = -1; return e.err; - /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Close }; } $f._r = _r; $f._tuple = _tuple; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - encoder.prototype.Close = function() { return this.$val.Close(); }; - NewEncoder = function(enc, w) { - var enc, w; - return new encoder.ptr($ifaceNil, enc, w, arrayType$2.zero(), 0, arrayType$3.zero()); - }; - $pkg.NewEncoder = NewEncoder; - Encoding.ptr.prototype.EncodedLen = function(n) { - var _q, _q$1, enc, n; - enc = this; - if (enc.padChar === -1) { - return (_q = ((($imul(n, 8)) + 5 >> 0)) / 6, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - } - return $imul((_q$1 = ((n + 2 >> 0)) / 3, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 4); - }; - Encoding.prototype.EncodedLen = function(n) { return this.$val.EncodedLen(n); }; - CorruptInputError.prototype.Error = function() { - var e; - e = this; - return "illegal base64 data at input byte " + strconv.FormatInt((new $Int64(e.$high, e.$low)), 10); - }; - $ptrType(CorruptInputError).prototype.Error = function() { return this.$get().Error(); }; - Encoding.ptr.prototype.decodeQuantum = function(dst, src, si) { - var _1, _2, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dbuf, dinc, dlen, dst, enc, err, in$1, j, n, nsi, out, si, src, val, x; - nsi = 0; - n = 0; - err = $ifaceNil; - enc = this; - dbuf = arrayType$4.zero(); - _tmp = 3; - _tmp$1 = 4; - dinc = _tmp; - dlen = _tmp$1; - j = 0; - while (true) { - if (!(j < 4)) { break; } - if (src.$length === si) { - if ((j === 0)) { - _tmp$2 = si; - _tmp$3 = 0; - _tmp$4 = $ifaceNil; - nsi = _tmp$2; - n = _tmp$3; - err = _tmp$4; - return [nsi, n, err]; - } else if (((j === 1)) || (!((enc.padChar === -1)))) { - _tmp$5 = si; - _tmp$6 = 0; - _tmp$7 = (new CorruptInputError(0, (si - j >> 0))); - nsi = _tmp$5; - n = _tmp$6; - err = _tmp$7; - return [nsi, n, err]; - } - _tmp$8 = j - 1 >> 0; - _tmp$9 = j; - dinc = _tmp$8; - dlen = _tmp$9; - break; - } - in$1 = ((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]); - si = si + (1) >> 0; - out = (x = enc.decodeMap, ((in$1 < 0 || in$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[in$1])); - if (!((out === 255))) { - ((j < 0 || j >= dbuf.length) ? ($throwRuntimeError("index out of range"), undefined) : dbuf[j] = out); - j = j + (1) >> 0; - continue; - } - if ((in$1 === 10) || (in$1 === 13)) { - j = j - (1) >> 0; - j = j + (1) >> 0; - continue; - } - if (!((((in$1 >> 0)) === enc.padChar))) { - _tmp$10 = si; - _tmp$11 = 0; - _tmp$12 = (new CorruptInputError(0, (si - 1 >> 0))); - nsi = _tmp$10; - n = _tmp$11; - err = _tmp$12; - return [nsi, n, err]; - } - _1 = j; - if ((_1 === (0)) || (_1 === (1))) { - _tmp$13 = si; - _tmp$14 = 0; - _tmp$15 = (new CorruptInputError(0, (si - 1 >> 0))); - nsi = _tmp$13; - n = _tmp$14; - err = _tmp$15; - return [nsi, n, err]; - } else if (_1 === (2)) { - while (true) { - if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 13)))) { break; } - si = si + (1) >> 0; - } - if (si === src.$length) { - _tmp$16 = si; - _tmp$17 = 0; - _tmp$18 = (new CorruptInputError(0, src.$length)); - nsi = _tmp$16; - n = _tmp$17; - err = _tmp$18; - return [nsi, n, err]; - } - if (!((((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) >> 0)) === enc.padChar))) { - _tmp$19 = si; - _tmp$20 = 0; - _tmp$21 = (new CorruptInputError(0, (si - 1 >> 0))); - nsi = _tmp$19; - n = _tmp$20; - err = _tmp$21; - return [nsi, n, err]; - } - si = si + (1) >> 0; - } - while (true) { - if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + si]) === 13)))) { break; } - si = si + (1) >> 0; - } - if (si < src.$length) { - err = (new CorruptInputError(0, si)); - } - _tmp$22 = 3; - _tmp$23 = j; - dinc = _tmp$22; - dlen = _tmp$23; - break; - } - val = ((((((((dbuf[0] >>> 0)) << 18 >>> 0) | (((dbuf[1] >>> 0)) << 12 >>> 0)) >>> 0) | (((dbuf[2] >>> 0)) << 6 >>> 0)) >>> 0) | ((dbuf[3] >>> 0))) >>> 0; - _tmp$24 = (((val >>> 0 >>> 0) << 24 >>> 24)); - _tmp$25 = (((val >>> 8 >>> 0) << 24 >>> 24)); - _tmp$26 = (((val >>> 16 >>> 0) << 24 >>> 24)); - dbuf[2] = _tmp$24; - dbuf[1] = _tmp$25; - dbuf[0] = _tmp$26; - _2 = dlen; - if (_2 === (4)) { - (2 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 2] = dbuf[2]); - dbuf[2] = 0; - (1 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 1] = dbuf[1]); - if (enc.strict && !((dbuf[2] === 0))) { - _tmp$27 = si; - _tmp$28 = 0; - _tmp$29 = (new CorruptInputError(0, (si - 1 >> 0))); - nsi = _tmp$27; - n = _tmp$28; - err = _tmp$29; - return [nsi, n, err]; - } - dbuf[1] = 0; - (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); - if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { - _tmp$30 = si; - _tmp$31 = 0; - _tmp$32 = (new CorruptInputError(0, (si - 2 >> 0))); - nsi = _tmp$30; - n = _tmp$31; - err = _tmp$32; - return [nsi, n, err]; - } - } else if (_2 === (3)) { - (1 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 1] = dbuf[1]); - if (enc.strict && !((dbuf[2] === 0))) { - _tmp$33 = si; - _tmp$34 = 0; - _tmp$35 = (new CorruptInputError(0, (si - 1 >> 0))); - nsi = _tmp$33; - n = _tmp$34; - err = _tmp$35; - return [nsi, n, err]; - } - dbuf[1] = 0; - (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); - if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { - _tmp$36 = si; - _tmp$37 = 0; - _tmp$38 = (new CorruptInputError(0, (si - 2 >> 0))); - nsi = _tmp$36; - n = _tmp$37; - err = _tmp$38; - return [nsi, n, err]; - } - } else if (_2 === (2)) { - (0 >= dst.$length ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + 0] = dbuf[0]); - if (enc.strict && (!((dbuf[1] === 0)) || !((dbuf[2] === 0)))) { - _tmp$39 = si; - _tmp$40 = 0; - _tmp$41 = (new CorruptInputError(0, (si - 2 >> 0))); - nsi = _tmp$39; - n = _tmp$40; - err = _tmp$41; - return [nsi, n, err]; - } - } - dst = $subslice(dst, dinc); - _tmp$42 = si; - _tmp$43 = dlen - 1 >> 0; - _tmp$44 = err; - nsi = _tmp$42; - n = _tmp$43; - err = _tmp$44; - return [nsi, n, err]; - }; - Encoding.prototype.decodeQuantum = function(dst, src, si) { return this.$val.decodeQuantum(dst, src, si); }; - Encoding.ptr.prototype.DecodeString = function(s) { - var _tuple, dbuf, enc, err, n, s; - enc = this; - dbuf = $makeSlice(sliceType, enc.DecodedLen(s.length)); - _tuple = enc.Decode(dbuf, (new sliceType($stringToBytes(s)))); - n = _tuple[0]; - err = _tuple[1]; - return [$subslice(dbuf, 0, n), err]; - }; - Encoding.prototype.DecodeString = function(s) { return this.$val.DecodeString(s); }; - Encoding.ptr.prototype.Decode = function(dst, src) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, dn, dn$1, dst, enc, err, n, ninc, ninc$1, ninc$2, ok, ok$1, si, src; - n = 0; - err = $ifaceNil; - enc = this; - if (src.$length === 0) { - _tmp = 0; - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - si = 0; - while (true) { - if (!(false && (src.$length - si >> 0) >= 8 && (dst.$length - n >> 0) >= 8)) { break; } - _tuple = enc.decode64($subslice(src, si)); - dn = _tuple[0]; - ok = _tuple[1]; - if (ok) { - $clone(binary.BigEndian, binary.bigEndian).PutUint64($subslice(dst, n), dn); - n = n + (6) >> 0; - si = si + (8) >> 0; - } else { - ninc = 0; - _tuple$1 = enc.decodeQuantum($subslice(dst, n), src, si); - si = _tuple$1[0]; - ninc = _tuple$1[1]; - err = _tuple$1[2]; - n = n + (ninc) >> 0; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$2 = n; - _tmp$3 = err; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - } - } - } - while (true) { - if (!((src.$length - si >> 0) >= 4 && (dst.$length - n >> 0) >= 4)) { break; } - _tuple$2 = enc.decode32($subslice(src, si)); - dn$1 = _tuple$2[0]; - ok$1 = _tuple$2[1]; - if (ok$1) { - $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(dst, n), dn$1); - n = n + (3) >> 0; - si = si + (4) >> 0; - } else { - ninc$1 = 0; - _tuple$3 = enc.decodeQuantum($subslice(dst, n), src, si); - si = _tuple$3[0]; - ninc$1 = _tuple$3[1]; - err = _tuple$3[2]; - n = n + (ninc$1) >> 0; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$4 = n; - _tmp$5 = err; - n = _tmp$4; - err = _tmp$5; - return [n, err]; - } - } - } - while (true) { - if (!(si < src.$length)) { break; } - ninc$2 = 0; - _tuple$4 = enc.decodeQuantum($subslice(dst, n), src, si); - si = _tuple$4[0]; - ninc$2 = _tuple$4[1]; - err = _tuple$4[2]; - n = n + (ninc$2) >> 0; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$6 = n; - _tmp$7 = err; - n = _tmp$6; - err = _tmp$7; - return [n, err]; - } - } - _tmp$8 = n; - _tmp$9 = err; - n = _tmp$8; - err = _tmp$9; - return [n, err]; - }; - Encoding.prototype.Decode = function(dst, src) { return this.$val.Decode(dst, src); }; - Encoding.ptr.prototype.decode32 = function(src) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dn, enc, n, ok, src, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; - dn = 0; - ok = false; - enc = this; - n = 0; - $unused((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3])); - n = (((x = enc.decodeMap, x$1 = (0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]), ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])) >>> 0)); - if (n === 255) { - _tmp = 0; - _tmp$1 = false; - dn = _tmp; - ok = _tmp$1; - return [dn, ok]; - } - dn = (dn | ((n << 26 >>> 0))) >>> 0; - n = (((x$2 = enc.decodeMap, x$3 = (1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]), ((x$3 < 0 || x$3 >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[x$3])) >>> 0)); - if (n === 255) { - _tmp$2 = 0; - _tmp$3 = false; - dn = _tmp$2; - ok = _tmp$3; - return [dn, ok]; - } - dn = (dn | ((n << 20 >>> 0))) >>> 0; - n = (((x$4 = enc.decodeMap, x$5 = (2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]), ((x$5 < 0 || x$5 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[x$5])) >>> 0)); - if (n === 255) { - _tmp$4 = 0; - _tmp$5 = false; - dn = _tmp$4; - ok = _tmp$5; - return [dn, ok]; - } - dn = (dn | ((n << 14 >>> 0))) >>> 0; - n = (((x$6 = enc.decodeMap, x$7 = (3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]), ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])) >>> 0)); - if (n === 255) { - _tmp$6 = 0; - _tmp$7 = false; - dn = _tmp$6; - ok = _tmp$7; - return [dn, ok]; - } - dn = (dn | ((n << 8 >>> 0))) >>> 0; - _tmp$8 = dn; - _tmp$9 = true; - dn = _tmp$8; - ok = _tmp$9; - return [dn, ok]; - }; - Encoding.prototype.decode32 = function(src) { return this.$val.decode32(src); }; - Encoding.ptr.prototype.decode64 = function(src) { - var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dn, enc, n, ok, src, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - dn = new $Uint64(0, 0); - ok = false; - enc = this; - n = new $Uint64(0, 0); - $unused((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7])); - n = (new $Uint64(0, (x = enc.decodeMap, x$1 = (0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]), ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp = new $Uint64(0, 0); - _tmp$1 = false; - dn = _tmp; - ok = _tmp$1; - return [dn, ok]; - } - dn = (x$2 = $shiftLeft64(n, 58), new $Uint64(dn.$high | x$2.$high, (dn.$low | x$2.$low) >>> 0)); - n = (new $Uint64(0, (x$3 = enc.decodeMap, x$4 = (1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]), ((x$4 < 0 || x$4 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[x$4])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$2 = new $Uint64(0, 0); - _tmp$3 = false; - dn = _tmp$2; - ok = _tmp$3; - return [dn, ok]; - } - dn = (x$5 = $shiftLeft64(n, 52), new $Uint64(dn.$high | x$5.$high, (dn.$low | x$5.$low) >>> 0)); - n = (new $Uint64(0, (x$6 = enc.decodeMap, x$7 = (2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]), ((x$7 < 0 || x$7 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[x$7])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$4 = new $Uint64(0, 0); - _tmp$5 = false; - dn = _tmp$4; - ok = _tmp$5; - return [dn, ok]; - } - dn = (x$8 = $shiftLeft64(n, 46), new $Uint64(dn.$high | x$8.$high, (dn.$low | x$8.$low) >>> 0)); - n = (new $Uint64(0, (x$9 = enc.decodeMap, x$10 = (3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]), ((x$10 < 0 || x$10 >= x$9.length) ? ($throwRuntimeError("index out of range"), undefined) : x$9[x$10])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$6 = new $Uint64(0, 0); - _tmp$7 = false; - dn = _tmp$6; - ok = _tmp$7; - return [dn, ok]; - } - dn = (x$11 = $shiftLeft64(n, 40), new $Uint64(dn.$high | x$11.$high, (dn.$low | x$11.$low) >>> 0)); - n = (new $Uint64(0, (x$12 = enc.decodeMap, x$13 = (4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4]), ((x$13 < 0 || x$13 >= x$12.length) ? ($throwRuntimeError("index out of range"), undefined) : x$12[x$13])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$8 = new $Uint64(0, 0); - _tmp$9 = false; - dn = _tmp$8; - ok = _tmp$9; - return [dn, ok]; - } - dn = (x$14 = $shiftLeft64(n, 34), new $Uint64(dn.$high | x$14.$high, (dn.$low | x$14.$low) >>> 0)); - n = (new $Uint64(0, (x$15 = enc.decodeMap, x$16 = (5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5]), ((x$16 < 0 || x$16 >= x$15.length) ? ($throwRuntimeError("index out of range"), undefined) : x$15[x$16])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$10 = new $Uint64(0, 0); - _tmp$11 = false; - dn = _tmp$10; - ok = _tmp$11; - return [dn, ok]; - } - dn = (x$17 = $shiftLeft64(n, 28), new $Uint64(dn.$high | x$17.$high, (dn.$low | x$17.$low) >>> 0)); - n = (new $Uint64(0, (x$18 = enc.decodeMap, x$19 = (6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6]), ((x$19 < 0 || x$19 >= x$18.length) ? ($throwRuntimeError("index out of range"), undefined) : x$18[x$19])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$12 = new $Uint64(0, 0); - _tmp$13 = false; - dn = _tmp$12; - ok = _tmp$13; - return [dn, ok]; - } - dn = (x$20 = $shiftLeft64(n, 22), new $Uint64(dn.$high | x$20.$high, (dn.$low | x$20.$low) >>> 0)); - n = (new $Uint64(0, (x$21 = enc.decodeMap, x$22 = (7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7]), ((x$22 < 0 || x$22 >= x$21.length) ? ($throwRuntimeError("index out of range"), undefined) : x$21[x$22])))); - if ((n.$high === 0 && n.$low === 255)) { - _tmp$14 = new $Uint64(0, 0); - _tmp$15 = false; - dn = _tmp$14; - ok = _tmp$15; - return [dn, ok]; - } - dn = (x$23 = $shiftLeft64(n, 16), new $Uint64(dn.$high | x$23.$high, (dn.$low | x$23.$low) >>> 0)); - _tmp$16 = dn; - _tmp$17 = true; - dn = _tmp$16; - ok = _tmp$17; - return [dn, ok]; - }; - Encoding.prototype.decode64 = function(src) { return this.$val.decode64(src); }; - Encoding.ptr.prototype.DecodedLen = function(n) { - var _q, _q$1, enc, n; - enc = this; - if (enc.padChar === -1) { - return (_q = ($imul(n, 6)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - } - return $imul((_q$1 = n / 4, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 3); - }; - Encoding.prototype.DecodedLen = function(n) { return this.$val.DecodedLen(n); }; - Encoding.methods = [{prop: "WithPadding", name: "WithPadding", pkg: "", typ: $funcType([$Int32], [ptrType], false)}, {prop: "Strict", name: "Strict", pkg: "", typ: $funcType([], [ptrType], false)}]; - ptrType.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([sliceType, sliceType], [], false)}, {prop: "EncodeToString", name: "EncodeToString", pkg: "", typ: $funcType([sliceType], [$String], false)}, {prop: "EncodedLen", name: "EncodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "decodeQuantum", name: "decodeQuantum", pkg: "encoding/base64", typ: $funcType([sliceType, sliceType, $Int], [$Int, $Int, $error], false)}, {prop: "DecodeString", name: "DecodeString", pkg: "", typ: $funcType([$String], [sliceType, $error], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([sliceType, sliceType], [$Int, $error], false)}, {prop: "decode32", name: "decode32", pkg: "encoding/base64", typ: $funcType([sliceType], [$Uint32, $Bool], false)}, {prop: "decode64", name: "decode64", pkg: "encoding/base64", typ: $funcType([sliceType], [$Uint64, $Bool], false)}, {prop: "DecodedLen", name: "DecodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}]; - ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}]; - CorruptInputError.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - Encoding.init("encoding/base64", [{prop: "encode", name: "encode", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "decodeMap", name: "decodeMap", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "padChar", name: "padChar", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "strict", name: "strict", embedded: false, exported: false, typ: $Bool, tag: ""}]); - encoder.init("encoding/base64", [{prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}, {prop: "enc", name: "enc", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "w", name: "w", embedded: false, exported: false, typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: arrayType$2, tag: ""}, {prop: "nbuf", name: "nbuf", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: arrayType$3, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = binary.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.StdEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"); - $pkg.URLEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"); - $pkg.RawStdEncoding = $clone($pkg.StdEncoding, Encoding).WithPadding(-1); - $pkg.RawURLEncoding = $clone($pkg.URLEncoding, Encoding).WithPadding(-1); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["unicode/utf16"] = (function() { - var $pkg = {}, $init; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["encoding/json"] = (function() { - var $pkg = {}, $init, bytes, encoding, base64, errors, fmt, nosync, io, math, reflect, sort, strconv, strings, unicode, utf16, utf8, Number, Marshaler, UnsupportedTypeError, UnsupportedValueError, MarshalerError, encodeState, jsonError, encOpts, encoderFunc, floatEncoder, structEncoder, mapEncoder, sliceEncoder, arrayEncoder, ptrEncoder, condAddrEncoder, reflectWithString, field, byIndex, SyntaxError, scanner, tagOptions, sliceType, sliceType$1, ptrType, ptrType$1, ptrType$2, sliceType$2, ptrType$5, sliceType$3, ptrType$7, arrayType, sliceType$4, ptrType$14, ptrType$15, ptrType$17, ptrType$18, funcType, ptrType$19, ptrType$20, funcType$1, textUnmarshalerType, numberType, hex, encodeStatePool, encoderCache, marshalerType, textMarshalerType, float32Encoder, float64Encoder, fieldCache, safeSet, htmlSafeSet, _r, _r$1, _r$2, isValidNumber, Marshal, HTMLEscape, newEncodeState, isEmptyValue, valueEncoder, typeEncoder, newTypeEncoder, invalidValueEncoder, marshalerEncoder, addrMarshalerEncoder, textMarshalerEncoder, addrTextMarshalerEncoder, boolEncoder, intEncoder, uintEncoder, stringEncoder, interfaceEncoder, unsupportedTypeEncoder, newStructEncoder, newMapEncoder, encodeByteSlice, newSliceEncoder, newArrayEncoder, newPtrEncoder, newCondAddrEncoder, isValidTag, typeByIndex, typeFields, dominantField, cachedTypeFields, foldFunc, equalFoldRight, asciiEqualFold, simpleLetterEqualFold, compact, isSpace, stateBeginValueOrEmpty, stateBeginValue, stateBeginStringOrEmpty, stateBeginString, stateEndValue, stateEndTop, stateInString, stateInStringEsc, stateInStringEscU, stateInStringEscU1, stateInStringEscU12, stateInStringEscU123, stateNeg, state1, state0, stateDot, stateDot0, stateE, stateESign, stateE0, stateT, stateTr, stateTru, stateF, stateFa, stateFal, stateFals, stateN, stateNu, stateNul, stateError, quoteChar, parseTag; - bytes = $packages["bytes"]; - encoding = $packages["encoding"]; - base64 = $packages["encoding/base64"]; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - io = $packages["io"]; - math = $packages["math"]; - reflect = $packages["reflect"]; - sort = $packages["sort"]; - strconv = $packages["strconv"]; - strings = $packages["strings"]; - unicode = $packages["unicode"]; - utf16 = $packages["unicode/utf16"]; - utf8 = $packages["unicode/utf8"]; - Number = $pkg.Number = $newType(8, $kindString, "json.Number", true, "encoding/json", true, null); - Marshaler = $pkg.Marshaler = $newType(8, $kindInterface, "json.Marshaler", true, "encoding/json", true, null); - UnsupportedTypeError = $pkg.UnsupportedTypeError = $newType(0, $kindStruct, "json.UnsupportedTypeError", true, "encoding/json", true, function(Type_) { - this.$val = this; - if (arguments.length === 0) { - this.Type = $ifaceNil; - return; - } - this.Type = Type_; - }); - UnsupportedValueError = $pkg.UnsupportedValueError = $newType(0, $kindStruct, "json.UnsupportedValueError", true, "encoding/json", true, function(Value_, Str_) { - this.$val = this; - if (arguments.length === 0) { - this.Value = new reflect.Value.ptr(ptrType$5.nil, 0, 0); - this.Str = ""; - return; - } - this.Value = Value_; - this.Str = Str_; - }); - MarshalerError = $pkg.MarshalerError = $newType(0, $kindStruct, "json.MarshalerError", true, "encoding/json", true, function(Type_, Err_) { - this.$val = this; - if (arguments.length === 0) { - this.Type = $ifaceNil; - this.Err = $ifaceNil; - return; - } - this.Type = Type_; - this.Err = Err_; - }); - encodeState = $pkg.encodeState = $newType(0, $kindStruct, "json.encodeState", true, "encoding/json", false, function(Buffer_, scratch_) { - this.$val = this; - if (arguments.length === 0) { - this.Buffer = new bytes.Buffer.ptr(sliceType$1.nil, 0, 0); - this.scratch = arrayType.zero(); - return; - } - this.Buffer = Buffer_; - this.scratch = scratch_; - }); - jsonError = $pkg.jsonError = $newType(0, $kindStruct, "json.jsonError", true, "encoding/json", false, function(error_) { - this.$val = this; - if (arguments.length === 0) { - this.error = $ifaceNil; - return; - } - this.error = error_; - }); - encOpts = $pkg.encOpts = $newType(0, $kindStruct, "json.encOpts", true, "encoding/json", false, function(quoted_, escapeHTML_) { - this.$val = this; - if (arguments.length === 0) { - this.quoted = false; - this.escapeHTML = false; - return; - } - this.quoted = quoted_; - this.escapeHTML = escapeHTML_; - }); - encoderFunc = $pkg.encoderFunc = $newType(4, $kindFunc, "json.encoderFunc", true, "encoding/json", false, null); - floatEncoder = $pkg.floatEncoder = $newType(4, $kindInt, "json.floatEncoder", true, "encoding/json", false, null); - structEncoder = $pkg.structEncoder = $newType(0, $kindStruct, "json.structEncoder", true, "encoding/json", false, function(fields_) { - this.$val = this; - if (arguments.length === 0) { - this.fields = sliceType$3.nil; - return; - } - this.fields = fields_; - }); - mapEncoder = $pkg.mapEncoder = $newType(0, $kindStruct, "json.mapEncoder", true, "encoding/json", false, function(elemEnc_) { - this.$val = this; - if (arguments.length === 0) { - this.elemEnc = $throwNilPointerError; - return; - } - this.elemEnc = elemEnc_; - }); - sliceEncoder = $pkg.sliceEncoder = $newType(0, $kindStruct, "json.sliceEncoder", true, "encoding/json", false, function(arrayEnc_) { - this.$val = this; - if (arguments.length === 0) { - this.arrayEnc = $throwNilPointerError; - return; - } - this.arrayEnc = arrayEnc_; - }); - arrayEncoder = $pkg.arrayEncoder = $newType(0, $kindStruct, "json.arrayEncoder", true, "encoding/json", false, function(elemEnc_) { - this.$val = this; - if (arguments.length === 0) { - this.elemEnc = $throwNilPointerError; - return; - } - this.elemEnc = elemEnc_; - }); - ptrEncoder = $pkg.ptrEncoder = $newType(0, $kindStruct, "json.ptrEncoder", true, "encoding/json", false, function(elemEnc_) { - this.$val = this; - if (arguments.length === 0) { - this.elemEnc = $throwNilPointerError; - return; - } - this.elemEnc = elemEnc_; - }); - condAddrEncoder = $pkg.condAddrEncoder = $newType(0, $kindStruct, "json.condAddrEncoder", true, "encoding/json", false, function(canAddrEnc_, elseEnc_) { - this.$val = this; - if (arguments.length === 0) { - this.canAddrEnc = $throwNilPointerError; - this.elseEnc = $throwNilPointerError; - return; - } - this.canAddrEnc = canAddrEnc_; - this.elseEnc = elseEnc_; - }); - reflectWithString = $pkg.reflectWithString = $newType(0, $kindStruct, "json.reflectWithString", true, "encoding/json", false, function(v_, s_) { - this.$val = this; - if (arguments.length === 0) { - this.v = new reflect.Value.ptr(ptrType$5.nil, 0, 0); - this.s = ""; - return; - } - this.v = v_; - this.s = s_; - }); - field = $pkg.field = $newType(0, $kindStruct, "json.field", true, "encoding/json", false, function(name_, nameBytes_, equalFold_, nameNonEsc_, nameEscHTML_, tag_, index_, typ_, omitEmpty_, quoted_, encoder_) { - this.$val = this; - if (arguments.length === 0) { - this.name = ""; - this.nameBytes = sliceType$1.nil; - this.equalFold = $throwNilPointerError; - this.nameNonEsc = ""; - this.nameEscHTML = ""; - this.tag = false; - this.index = sliceType$2.nil; - this.typ = $ifaceNil; - this.omitEmpty = false; - this.quoted = false; - this.encoder = $throwNilPointerError; - return; - } - this.name = name_; - this.nameBytes = nameBytes_; - this.equalFold = equalFold_; - this.nameNonEsc = nameNonEsc_; - this.nameEscHTML = nameEscHTML_; - this.tag = tag_; - this.index = index_; - this.typ = typ_; - this.omitEmpty = omitEmpty_; - this.quoted = quoted_; - this.encoder = encoder_; - }); - byIndex = $pkg.byIndex = $newType(12, $kindSlice, "json.byIndex", true, "encoding/json", false, null); - SyntaxError = $pkg.SyntaxError = $newType(0, $kindStruct, "json.SyntaxError", true, "encoding/json", true, function(msg_, Offset_) { - this.$val = this; - if (arguments.length === 0) { - this.msg = ""; - this.Offset = new $Int64(0, 0); - return; - } - this.msg = msg_; - this.Offset = Offset_; - }); - scanner = $pkg.scanner = $newType(0, $kindStruct, "json.scanner", true, "encoding/json", false, function(step_, endTop_, parseState_, err_, bytes_) { - this.$val = this; - if (arguments.length === 0) { - this.step = $throwNilPointerError; - this.endTop = false; - this.parseState = sliceType$2.nil; - this.err = $ifaceNil; - this.bytes = new $Int64(0, 0); - return; - } - this.step = step_; - this.endTop = endTop_; - this.parseState = parseState_; - this.err = err_; - this.bytes = bytes_; - }); - tagOptions = $pkg.tagOptions = $newType(8, $kindString, "json.tagOptions", true, "encoding/json", false, null); - sliceType = $sliceType($emptyInterface); - sliceType$1 = $sliceType($Uint8); - ptrType = $ptrType(encoding.TextUnmarshaler); - ptrType$1 = $ptrType(Marshaler); - ptrType$2 = $ptrType(encoding.TextMarshaler); - sliceType$2 = $sliceType($Int); - ptrType$5 = $ptrType(reflect.rtype); - sliceType$3 = $sliceType(field); - ptrType$7 = $ptrType(encodeState); - arrayType = $arrayType($Uint8, 64); - sliceType$4 = $sliceType(reflectWithString); - ptrType$14 = $ptrType(UnsupportedTypeError); - ptrType$15 = $ptrType(UnsupportedValueError); - ptrType$17 = $ptrType(MarshalerError); - ptrType$18 = $ptrType(reflectWithString); - funcType = $funcType([sliceType$1, sliceType$1], [$Bool], false); - ptrType$19 = $ptrType(SyntaxError); - ptrType$20 = $ptrType(scanner); - funcType$1 = $funcType([ptrType$20, $Uint8], [$Int], false); - Number.prototype.String = function() { - var n; - n = this.$val; - return (n); - }; - $ptrType(Number).prototype.String = function() { return new Number(this.$get()).String(); }; - Number.prototype.Float64 = function() { - var n; - n = this.$val; - return strconv.ParseFloat((n), 64); - }; - $ptrType(Number).prototype.Float64 = function() { return new Number(this.$get()).Float64(); }; - Number.prototype.Int64 = function() { - var n; - n = this.$val; - return strconv.ParseInt((n), 10, 64); - }; - $ptrType(Number).prototype.Int64 = function() { return new Number(this.$get()).Int64(); }; - isValidNumber = function(s) { - var s; - if (s === "") { - return false; - } - if (s.charCodeAt(0) === 45) { - s = $substring(s, 1); - if (s === "") { - return false; - } - } - if ((s.charCodeAt(0) === 48)) { - s = $substring(s, 1); - } else if (49 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57) { - s = $substring(s, 1); - while (true) { - if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } - s = $substring(s, 1); - } - } else { - return false; - } - if (s.length >= 2 && (s.charCodeAt(0) === 46) && 48 <= s.charCodeAt(1) && s.charCodeAt(1) <= 57) { - s = $substring(s, 2); - while (true) { - if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } - s = $substring(s, 1); - } - } - if (s.length >= 2 && ((s.charCodeAt(0) === 101) || (s.charCodeAt(0) === 69))) { - s = $substring(s, 1); - if ((s.charCodeAt(0) === 43) || (s.charCodeAt(0) === 45)) { - s = $substring(s, 1); - if (s === "") { - return false; - } - } - while (true) { - if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } - s = $substring(s, 1); - } - } - return s === ""; - }; - Marshal = function(v) { - var _r$3, _r$4, buf, e, err, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; buf = $f.buf; e = $f.e; err = $f.err; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = newEncodeState(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - e = _r$3; - _r$4 = e.marshal(v, new encOpts.ptr(false, true)); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - err = _r$4; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [sliceType$1.nil, err]; - } - buf = $appendSlice((sliceType$1.nil), e.Buffer.Bytes()); - e.Buffer.Reset(); - encodeStatePool.Put(e); - $s = -1; return [buf, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Marshal }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.buf = buf; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Marshal = Marshal; - HTMLEscape = function(dst, src) { - var _i, _ref, c, dst, i, src, start, x, x$1, x$2; - start = 0; - _ref = src; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if ((c === 60) || (c === 62) || (c === 38)) { - if (start < i) { - dst.Write($subslice(src, start, i)); - } - dst.WriteString("\\u00"); - dst.WriteByte(hex.charCodeAt((c >>> 4 << 24 >>> 24))); - dst.WriteByte(hex.charCodeAt(((c & 15) >>> 0))); - start = i + 1 >> 0; - } - if ((c === 226) && (i + 2 >> 0) < src.$length && ((x = i + 1 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) & ~1) << 24 >>> 24) === 168)) { - if (start < i) { - dst.Write($subslice(src, start, i)); - } - dst.WriteString("\\u202"); - dst.WriteByte(hex.charCodeAt((((x$2 = i + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) & 15) >>> 0))); - start = i + 3 >> 0; - } - _i++; - } - if (start < src.$length) { - dst.Write($subslice(src, start)); - } - }; - $pkg.HTMLEscape = HTMLEscape; - UnsupportedTypeError.ptr.prototype.Error = function() { - var _r$3, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r$3 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $s = -1; return "json: unsupported type: " + _r$3; - /* */ } return; } if ($f === undefined) { $f = { $blk: UnsupportedTypeError.ptr.prototype.Error }; } $f._r$3 = _r$3; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - UnsupportedTypeError.prototype.Error = function() { return this.$val.Error(); }; - UnsupportedValueError.ptr.prototype.Error = function() { - var e; - e = this; - return "json: unsupported value: " + e.Str; - }; - UnsupportedValueError.prototype.Error = function() { return this.$val.Error(); }; - MarshalerError.ptr.prototype.Error = function() { - var _r$3, _r$4, e, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r$3 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = e.Err.Error(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return "json: error calling MarshalJSON for type " + _r$3 + ": " + _r$4; - /* */ } return; } if ($f === undefined) { $f = { $blk: MarshalerError.ptr.prototype.Error }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; - }; - MarshalerError.prototype.Error = function() { return this.$val.Error(); }; - newEncodeState = function() { - var _r$3, e, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = encodeStatePool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - v = _r$3; - if (!($interfaceIsEqual(v, $ifaceNil))) { - e = $assertType(v, ptrType$7); - e.Buffer.Reset(); - $s = -1; return e; - } - $s = -1; return new encodeState.ptr(new bytes.Buffer.ptr(sliceType$1.nil, 0, 0), arrayType.zero()); - /* */ } return; } if ($f === undefined) { $f = { $blk: newEncodeState }; } $f._r$3 = _r$3; $f.e = e; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - encodeState.ptr.prototype.marshal = function(v, opts) { - var _r$3, e, err, opts, v, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; err = $f.err; opts = $f.opts; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - err = [err]; - err[0] = $ifaceNil; - e = this; - $deferred.push([(function(err) { return function() { - var _tuple, je, ok, r; - r = $recover(); - if (!($interfaceIsEqual(r, $ifaceNil))) { - _tuple = $assertType(r, jsonError, true); - je = $clone(_tuple[0], jsonError); - ok = _tuple[1]; - if (ok) { - err[0] = je.error; - } else { - $panic(r); - } - } - }; })(err), []]); - _r$3 = reflect.ValueOf(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $r = e.reflectValue($clone(_r$3, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - err[0] = $ifaceNil; - $s = -1; return err[0]; - /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.marshal }; } $f._r$3 = _r$3; $f.e = e; $f.err = err; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - encodeState.prototype.marshal = function(v, opts) { return this.$val.marshal(v, opts); }; - encodeState.ptr.prototype.error = function(err) { - var e, err, x; - e = this; - $panic((x = new jsonError.ptr(err), new x.constructor.elem(x))); - }; - encodeState.prototype.error = function(err) { return this.$val.error(err); }; - isEmptyValue = function(v) { - var _1, v, x, x$1; - _1 = $clone(v, reflect.Value).Kind(); - if ((_1 === (17)) || (_1 === (21)) || (_1 === (23)) || (_1 === (24))) { - return $clone(v, reflect.Value).Len() === 0; - } else if (_1 === (1)) { - return !$clone(v, reflect.Value).Bool(); - } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { - return (x = $clone(v, reflect.Value).Int(), (x.$high === 0 && x.$low === 0)); - } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { - return (x$1 = $clone(v, reflect.Value).Uint(), (x$1.$high === 0 && x$1.$low === 0)); - } else if ((_1 === (13)) || (_1 === (14))) { - return $clone(v, reflect.Value).Float() === 0; - } else if ((_1 === (20)) || (_1 === (22))) { - return $clone(v, reflect.Value).IsNil(); - } - return false; - }; - encodeState.ptr.prototype.reflectValue = function(v, opts) { - var _r$3, e, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - e = this; - _r$3 = valueEncoder($clone(v, reflect.Value)); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $r = _r$3(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.reflectValue }; } $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - encodeState.prototype.reflectValue = function(v, opts) { return this.$val.reflectValue(v, opts); }; - valueEncoder = function(v) { - var _r$3, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (!$clone(v, reflect.Value).IsValid()) { - $s = -1; return invalidValueEncoder; - } - _r$3 = typeEncoder($clone(v, reflect.Value).Type()); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $s = -1; return _r$3; - /* */ } return; } if ($f === undefined) { $f = { $blk: valueEncoder }; } $f._r$3 = _r$3; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - typeEncoder = function(t) { - var _r$3, _tuple, _tuple$1, f, fi, fi$1, loaded, ok, t, wg, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; fi = $f.fi; fi$1 = $f.fi$1; loaded = $f.loaded; ok = $f.ok; t = $f.t; wg = $f.wg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = [f]; - wg = [wg]; - _tuple = encoderCache.Load(t); - fi = _tuple[0]; - ok = _tuple[1]; - if (ok) { - $s = -1; return $assertType(fi, encoderFunc); - } - wg[0] = new nosync.WaitGroup.ptr(0); - f[0] = $throwNilPointerError; - wg[0].Add(1); - _tuple$1 = encoderCache.LoadOrStore(t, new encoderFunc(((function(f, wg) { return function $b(e, v, opts) { - var e, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - wg[0].Wait(); - $r = f[0](e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; })(f, wg)))); - fi$1 = _tuple$1[0]; - loaded = _tuple$1[1]; - if (loaded) { - $s = -1; return $assertType(fi$1, encoderFunc); - } - _r$3 = newTypeEncoder(t, true); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - f[0] = _r$3; - wg[0].Done(); - encoderCache.Store(t, new encoderFunc(f[0])); - $s = -1; return f[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: typeEncoder }; } $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.fi = fi; $f.fi$1 = fi$1; $f.loaded = loaded; $f.ok = ok; $f.t = t; $f.wg = wg; $f.$s = $s; $f.$r = $r; return $f; - }; - newTypeEncoder = function(t, allowAddr) { - var _1, _arg, _arg$1, _arg$2, _arg$3, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, allowAddr, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; allowAddr = $f.allowAddr; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = t.Implements(marshalerType); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r$3) { */ case 1: - $s = -1; return marshalerEncoder; - /* } */ case 2: - _r$4 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (!((_r$4 === 22)) && allowAddr) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!((_r$4 === 22)) && allowAddr) { */ case 4: - _r$5 = reflect.PtrTo(t).Implements(marshalerType); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (_r$5) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_r$5) { */ case 7: - _arg = addrMarshalerEncoder; - _r$6 = newTypeEncoder(t, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _arg$1 = _r$6; - _r$7 = newCondAddrEncoder(_arg, _arg$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $s = -1; return _r$7; - /* } */ case 8: - /* } */ case 5: - _r$8 = t.Implements(textMarshalerType); /* */ $s = 14; case 14: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - /* */ if (_r$8) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (_r$8) { */ case 12: - $s = -1; return textMarshalerEncoder; - /* } */ case 13: - _r$9 = t.Kind(); /* */ $s = 17; case 17: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - /* */ if (!((_r$9 === 22)) && allowAddr) { $s = 15; continue; } - /* */ $s = 16; continue; - /* if (!((_r$9 === 22)) && allowAddr) { */ case 15: - _r$10 = reflect.PtrTo(t).Implements(textMarshalerType); /* */ $s = 20; case 20: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - /* */ if (_r$10) { $s = 18; continue; } - /* */ $s = 19; continue; - /* if (_r$10) { */ case 18: - _arg$2 = addrTextMarshalerEncoder; - _r$11 = newTypeEncoder(t, false); /* */ $s = 21; case 21: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - _arg$3 = _r$11; - _r$12 = newCondAddrEncoder(_arg$2, _arg$3); /* */ $s = 22; case 22: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - $s = -1; return _r$12; - /* } */ case 19: - /* } */ case 16: - _r$13 = t.Kind(); /* */ $s = 24; case 24: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - _1 = _r$13; - /* */ if (_1 === (1)) { $s = 25; continue; } - /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 26; continue; } - /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 27; continue; } - /* */ if (_1 === (13)) { $s = 28; continue; } - /* */ if (_1 === (14)) { $s = 29; continue; } - /* */ if (_1 === (24)) { $s = 30; continue; } - /* */ if (_1 === (20)) { $s = 31; continue; } - /* */ if (_1 === (25)) { $s = 32; continue; } - /* */ if (_1 === (21)) { $s = 33; continue; } - /* */ if (_1 === (23)) { $s = 34; continue; } - /* */ if (_1 === (17)) { $s = 35; continue; } - /* */ if (_1 === (22)) { $s = 36; continue; } - /* */ $s = 37; continue; - /* if (_1 === (1)) { */ case 25: - $s = -1; return boolEncoder; - /* } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 26: - $s = -1; return intEncoder; - /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 27: - $s = -1; return uintEncoder; - /* } else if (_1 === (13)) { */ case 28: - $s = -1; return float32Encoder; - /* } else if (_1 === (14)) { */ case 29: - $s = -1; return float64Encoder; - /* } else if (_1 === (24)) { */ case 30: - $s = -1; return stringEncoder; - /* } else if (_1 === (20)) { */ case 31: - $s = -1; return interfaceEncoder; - /* } else if (_1 === (25)) { */ case 32: - _r$14 = newStructEncoder(t); /* */ $s = 39; case 39: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } - $s = -1; return _r$14; - /* } else if (_1 === (21)) { */ case 33: - _r$15 = newMapEncoder(t); /* */ $s = 40; case 40: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } - $s = -1; return _r$15; - /* } else if (_1 === (23)) { */ case 34: - _r$16 = newSliceEncoder(t); /* */ $s = 41; case 41: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } - $s = -1; return _r$16; - /* } else if (_1 === (17)) { */ case 35: - _r$17 = newArrayEncoder(t); /* */ $s = 42; case 42: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } - $s = -1; return _r$17; - /* } else if (_1 === (22)) { */ case 36: - _r$18 = newPtrEncoder(t); /* */ $s = 43; case 43: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } - $s = -1; return _r$18; - /* } else { */ case 37: - $s = -1; return unsupportedTypeEncoder; - /* } */ case 38: - case 23: - $s = -1; return $throwNilPointerError; - /* */ } return; } if ($f === undefined) { $f = { $blk: newTypeEncoder }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.allowAddr = allowAddr; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - invalidValueEncoder = function(e, v, param) { - var e, param, v; - e.Buffer.WriteString("null"); - }; - marshalerEncoder = function(e, v, opts) { - var _r$3, _r$4, _r$5, _tuple, _tuple$1, b, e, err, m, ok, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; e = $f.e; err = $f.err; m = $f.m; ok = $f.ok; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(v, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple = $assertType(_r$3, Marshaler, true); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$4 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - b = _tuple$1[0]; - err = _tuple$1[1]; - /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: - _r$5 = compact(e.Buffer, b, opts.escapeHTML); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - err = _r$5; - /* } */ case 4: - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: marshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.ok = ok; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - addrMarshalerEncoder = function(e, v, param) { - var _r$3, _r$4, _r$5, _tuple, b, e, err, m, param, v, va, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; param = $f.param; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - va = $clone(v, reflect.Value).Addr(); - if ($clone(va, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(va, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - m = $assertType(_r$3, Marshaler); - _r$4 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = _r$4; - b = _tuple[0]; - err = _tuple[1]; - /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: - _r$5 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - err = _r$5; - /* } */ case 4: - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: addrMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.param = param; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; - }; - textMarshalerEncoder = function(e, v, opts) { - var _r$3, _r$4, _tuple, b, e, err, m, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(v, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - m = $assertType(_r$3, encoding.TextMarshaler); - _r$4 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = _r$4; - b = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); - } - e.stringBytes(b, opts.escapeHTML); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: textMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - addrTextMarshalerEncoder = function(e, v, opts) { - var _r$3, _r$4, _tuple, b, e, err, m, opts, v, va, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; opts = $f.opts; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - va = $clone(v, reflect.Value).Addr(); - if ($clone(va, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(va, reflect.Value).Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - m = $assertType(_r$3, encoding.TextMarshaler); - _r$4 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = _r$4; - b = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(new MarshalerError.ptr($clone(v, reflect.Value).Type(), err)); - } - e.stringBytes(b, opts.escapeHTML); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: addrTextMarshalerEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.opts = opts; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; - }; - boolEncoder = function(e, v, opts) { - var e, opts, v; - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - if ($clone(v, reflect.Value).Bool()) { - e.Buffer.WriteString("true"); - } else { - e.Buffer.WriteString("false"); - } - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - }; - intEncoder = function(e, v, opts) { - var b, e, opts, v; - b = strconv.AppendInt($subslice(new sliceType$1(e.scratch), 0, 0), $clone(v, reflect.Value).Int(), 10); - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - e.Buffer.Write(b); - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - }; - uintEncoder = function(e, v, opts) { - var b, e, opts, v; - b = strconv.AppendUint($subslice(new sliceType$1(e.scratch), 0, 0), $clone(v, reflect.Value).Uint(), 10); - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - e.Buffer.Write(b); - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - }; - floatEncoder.prototype.encode = function(e, v, opts) { - var abs, b, bits, e, f, fmt$1, n, opts, v, x, x$1, x$2, x$3, x$4; - bits = this.$val; - f = $clone(v, reflect.Value).Float(); - if (math.IsInf(f, 0) || math.IsNaN(f)) { - e.error(new UnsupportedValueError.ptr($clone(v, reflect.Value), strconv.FormatFloat(f, 103, -1, ((bits >> 0))))); - } - b = $subslice(new sliceType$1(e.scratch), 0, 0); - abs = math.Abs(f); - fmt$1 = 102; - if (!((abs === 0))) { - if ((bits === 64) && (abs < 1e-06 || abs >= 1e+21) || (bits === 32) && (($fround(abs)) < 9.999999974752427e-07 || ($fround(abs)) >= 1.0000000200408773e+21)) { - fmt$1 = 101; - } - } - b = strconv.AppendFloat(b, f, fmt$1, -1, ((bits >> 0))); - if (fmt$1 === 101) { - n = b.$length; - if (n >= 4 && ((x = n - 4 >> 0, ((x < 0 || x >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x])) === 101) && ((x$1 = n - 3 >> 0, ((x$1 < 0 || x$1 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$1])) === 45) && ((x$2 = n - 2 >> 0, ((x$2 < 0 || x$2 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$2])) === 48)) { - (x$4 = n - 2 >> 0, ((x$4 < 0 || x$4 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$4] = (x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + x$3])))); - b = $subslice(b, 0, (n - 1 >> 0)); - } - } - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - e.Buffer.Write(b); - if (opts.quoted) { - e.Buffer.WriteByte(34); - } - }; - $ptrType(floatEncoder).prototype.encode = function(e, v, opts) { return new floatEncoder(this.$get()).encode(e, v, opts); }; - stringEncoder = function(e, v, opts) { - var _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, e, err, numStr, opts, sb, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; e = $f.e; err = $f.err; numStr = $f.numStr; opts = $f.opts; sb = $f.sb; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if ($interfaceIsEqual($clone(v, reflect.Value).Type(), numberType)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($interfaceIsEqual($clone(v, reflect.Value).Type(), numberType)) { */ case 1: - _r$3 = $clone(v, reflect.Value).String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - numStr = _r$3; - if (numStr === "") { - numStr = "0"; - } - /* */ if (!isValidNumber(numStr)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!isValidNumber(numStr)) { */ case 4: - _r$4 = fmt.Errorf("json: invalid number literal %q", new sliceType([new $String(numStr)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $r = e.error(_r$4); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 5: - e.Buffer.WriteString(numStr); - $s = -1; return; - /* } */ case 2: - /* */ if (opts.quoted) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (opts.quoted) { */ case 8: - _r$5 = $clone(v, reflect.Value).String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$6 = Marshal(new $String(_r$5)); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple = _r$6; - sb = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(err); - } - e.string(($bytesToString(sb)), opts.escapeHTML); - $s = 10; continue; - /* } else { */ case 9: - _r$7 = $clone(v, reflect.Value).String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $r = e.string(_r$7, opts.escapeHTML); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 10: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: stringEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.numStr = numStr; $f.opts = opts; $f.sb = sb; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - interfaceEncoder = function(e, v, opts) { - var _r$3, e, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if ($clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(v, reflect.Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $r = e.reflectValue($clone(_r$3, reflect.Value), $clone(opts, encOpts)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: interfaceEncoder }; } $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - unsupportedTypeEncoder = function(e, v, param) { - var e, param, v; - e.error(new UnsupportedTypeError.ptr($clone(v, reflect.Value).Type())); - }; - structEncoder.ptr.prototype.encode = function(e, v, opts) { - var _i, _i$1, _r$3, _r$4, _ref, _ref$1, e, f, fv, i, i$1, next, opts, se, v, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; e = $f.e; f = $f.f; fv = $f.fv; i = $f.i; i$1 = $f.i$1; next = $f.next; opts = $f.opts; se = $f.se; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - se = this; - next = 123; - _ref = se.fields; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - i = _i; - f = (x = se.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - fv = v; - _ref$1 = f.index; - _i$1 = 0; - /* while (true) { */ case 3: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 4; continue; } - i$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - /* */ if ($clone(fv, reflect.Value).Kind() === 22) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ($clone(fv, reflect.Value).Kind() === 22) { */ case 5: - /* */ if ($clone(fv, reflect.Value).IsNil()) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if ($clone(fv, reflect.Value).IsNil()) { */ case 7: - _i++; - /* continue FieldLoop; */ $s = 1; continue s; - /* } */ case 8: - _r$3 = $clone(fv, reflect.Value).Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - fv = _r$3; - /* } */ case 6: - _r$4 = $clone(fv, reflect.Value).Field(i$1); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - fv = _r$4; - _i$1++; - /* } */ $s = 3; continue; case 4: - /* */ if (f.omitEmpty && isEmptyValue($clone(fv, reflect.Value))) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (f.omitEmpty && isEmptyValue($clone(fv, reflect.Value))) { */ case 11: - _i++; - /* continue; */ $s = 1; continue; - /* } */ case 12: - e.Buffer.WriteByte(next); - next = 44; - if (opts.escapeHTML) { - e.Buffer.WriteString(f.nameEscHTML); - } else { - e.Buffer.WriteString(f.nameNonEsc); - } - opts.quoted = f.quoted; - $r = f.encoder(e, $clone(fv, reflect.Value), $clone(opts, encOpts)); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _i++; - /* } */ $s = 1; continue; case 2: - if (next === 123) { - e.Buffer.WriteString("{}"); - } else { - e.Buffer.WriteByte(125); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: structEncoder.ptr.prototype.encode }; } $f._i = _i; $f._i$1 = _i$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f.e = e; $f.f = f; $f.fv = fv; $f.i = i; $f.i$1 = i$1; $f.next = next; $f.opts = opts; $f.se = se; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - structEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newStructEncoder = function(t) { - var _r$3, se, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; se = $f.se; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = cachedTypeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - se = new structEncoder.ptr(_r$3); - $s = -1; return $methodVal($clone(se, structEncoder), "encode"); - /* */ } return; } if ($f === undefined) { $f = { $blk: newStructEncoder }; } $f._r$3 = _r$3; $f.se = se; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - mapEncoder.ptr.prototype.encode = function(e, v, opts) { - var _arg, _arg$1, _arg$2, _i, _i$1, _r$3, _r$4, _r$5, _ref, _ref$1, e, err, i, i$1, keys, kv, me, opts, sv, v, v$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _i$1 = $f._i$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; e = $f.e; err = $f.err; i = $f.i; i$1 = $f.i$1; keys = $f.keys; kv = $f.kv; me = $f.me; opts = $f.opts; sv = $f.sv; v = $f.v; v$1 = $f.v$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - sv = [sv]; - me = this; - if ($clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - e.Buffer.WriteByte(123); - _r$3 = $clone(v, reflect.Value).MapKeys(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - keys = _r$3; - sv[0] = $makeSlice(sliceType$4, keys.$length); - _ref = keys; - _i = 0; - /* while (true) { */ case 2: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } - i = _i; - v$1 = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - ((i < 0 || i >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i]).v = v$1; - _r$4 = ((i < 0 || i >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i]).resolve(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - err = _r$4; - if (!($interfaceIsEqual(err, $ifaceNil))) { - e.error(new MarshalerError.ptr($clone(v$1, reflect.Value).Type(), err)); - } - _i++; - /* } */ $s = 2; continue; case 3: - $r = sort.Slice(sv[0], (function(sv) { return function(i$1, j) { - var i$1, j; - return ((i$1 < 0 || i$1 >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + i$1]).s < ((j < 0 || j >= sv[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : sv[0].$array[sv[0].$offset + j]).s; - }; })(sv)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _ref$1 = sv[0]; - _i$1 = 0; - /* while (true) { */ case 6: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 7; continue; } - i$1 = _i$1; - kv = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), reflectWithString); - if (i$1 > 0) { - e.Buffer.WriteByte(44); - } - e.string(kv.s, opts.escapeHTML); - e.Buffer.WriteByte(58); - _arg = e; - _r$5 = $clone(v, reflect.Value).MapIndex($clone(kv.v, reflect.Value)); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$1 = $clone(_r$5, reflect.Value); - _arg$2 = $clone(opts, encOpts); - $r = me.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _i$1++; - /* } */ $s = 6; continue; case 7: - e.Buffer.WriteByte(125); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: mapEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._i$1 = _i$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f.e = e; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.keys = keys; $f.kv = kv; $f.me = me; $f.opts = opts; $f.sv = sv; $f.v = v; $f.v$1 = v$1; $f.$s = $s; $f.$r = $r; return $f; - }; - mapEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newMapEncoder = function(t) { - var _1, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, me, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; me = $f.me; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = t.Key(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = _r$3.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _1 = _r$4; - /* */ if ((_1 === (24)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 4; continue; } - _r$5 = t.Key(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$6 = _r$5.Implements(textMarshalerType); /* */ $s = 8; case 8: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - /* */ if (!_r$6) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((_1 === (24)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 4: - $s = 6; continue; - /* } else if (!_r$6) { */ case 5: - $s = -1; return unsupportedTypeEncoder; - /* } */ case 6: - case 1: - _r$7 = t.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _r$8 = typeEncoder(_r$7); /* */ $s = 10; case 10: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - me = new mapEncoder.ptr(_r$8); - $s = -1; return $methodVal($clone(me, mapEncoder), "encode"); - /* */ } return; } if ($f === undefined) { $f = { $blk: newMapEncoder }; } $f._1 = _1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f.me = me; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - encodeByteSlice = function(e, v, param) { - var _r$3, _r$4, _r$5, dst, dst$1, e, enc, encodedLen, param, s, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; dst = $f.dst; dst$1 = $f.dst$1; e = $f.e; enc = $f.enc; encodedLen = $f.encodedLen; param = $f.param; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if ($clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _r$3 = $clone(v, reflect.Value).Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - s = _r$3; - e.Buffer.WriteByte(34); - encodedLen = base64.StdEncoding.EncodedLen(s.$length); - /* */ if (encodedLen <= 64) { $s = 2; continue; } - /* */ if (encodedLen <= 1024) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (encodedLen <= 64) { */ case 2: - dst = $subslice(new sliceType$1(e.scratch), 0, encodedLen); - base64.StdEncoding.Encode(dst, s); - e.Buffer.Write(dst); - $s = 5; continue; - /* } else if (encodedLen <= 1024) { */ case 3: - dst$1 = $makeSlice(sliceType$1, encodedLen); - base64.StdEncoding.Encode(dst$1, s); - e.Buffer.Write(dst$1); - $s = 5; continue; - /* } else { */ case 4: - enc = base64.NewEncoder(base64.StdEncoding, e); - _r$4 = enc.Write(s); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$4; - _r$5 = enc.Close(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$5; - /* } */ case 5: - e.Buffer.WriteByte(34); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: encodeByteSlice }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.dst = dst; $f.dst$1 = dst$1; $f.e = e; $f.enc = enc; $f.encodedLen = encodedLen; $f.param = param; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - sliceEncoder.ptr.prototype.encode = function(e, v, opts) { - var e, opts, se, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; opts = $f.opts; se = $f.se; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - se = this; - if ($clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - $r = se.arrayEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: sliceEncoder.ptr.prototype.encode }; } $f.e = e; $f.opts = opts; $f.se = se; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - sliceEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newSliceEncoder = function(t) { - var _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _v, enc, p, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _v = $f._v; enc = $f.enc; p = $f.p; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = t.Elem(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = _r$3.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (_r$4 === 8) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (_r$4 === 8) { */ case 1: - _r$5 = t.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$6 = reflect.PtrTo(_r$5); /* */ $s = 6; case 6: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - p = _r$6; - _r$7 = p.Implements(marshalerType); /* */ $s = 10; case 10: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - if (!(!_r$7)) { _v = false; $s = 9; continue s; } - _r$8 = p.Implements(textMarshalerType); /* */ $s = 11; case 11: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _v = !_r$8; case 9: - /* */ if (_v) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_v) { */ case 7: - $s = -1; return encodeByteSlice; - /* } */ case 8: - /* } */ case 2: - _r$9 = newArrayEncoder(t); /* */ $s = 12; case 12: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - enc = new sliceEncoder.ptr(_r$9); - $s = -1; return $methodVal($clone(enc, sliceEncoder), "encode"); - /* */ } return; } if ($f === undefined) { $f = { $blk: newSliceEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._v = _v; $f.enc = enc; $f.p = p; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - arrayEncoder.ptr.prototype.encode = function(e, v, opts) { - var _arg, _arg$1, _arg$2, _r$3, ae, e, i, n, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$3 = $f._r$3; ae = $f.ae; e = $f.e; i = $f.i; n = $f.n; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ae = this; - e.Buffer.WriteByte(91); - n = $clone(v, reflect.Value).Len(); - i = 0; - /* while (true) { */ case 1: - /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } - if (i > 0) { - e.Buffer.WriteByte(44); - } - _arg = e; - _r$3 = $clone(v, reflect.Value).Index(i); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _arg$1 = $clone(_r$3, reflect.Value); - _arg$2 = $clone(opts, encOpts); - $r = ae.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - e.Buffer.WriteByte(93); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: arrayEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$3 = _r$3; $f.ae = ae; $f.e = e; $f.i = i; $f.n = n; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - arrayEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newArrayEncoder = function(t) { - var _r$3, _r$4, enc, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = typeEncoder(_r$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - enc = new arrayEncoder.ptr(_r$4); - $s = -1; return $methodVal($clone(enc, arrayEncoder), "encode"); - /* */ } return; } if ($f === undefined) { $f = { $blk: newArrayEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - ptrEncoder.ptr.prototype.encode = function(e, v, opts) { - var _arg, _arg$1, _arg$2, _r$3, e, opts, pe, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$3 = $f._r$3; e = $f.e; opts = $f.opts; pe = $f.pe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - pe = this; - if ($clone(v, reflect.Value).IsNil()) { - e.Buffer.WriteString("null"); - $s = -1; return; - } - _arg = e; - _r$3 = $clone(v, reflect.Value).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _arg$1 = $clone(_r$3, reflect.Value); - _arg$2 = $clone(opts, encOpts); - $r = pe.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: ptrEncoder.ptr.prototype.encode }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$3 = _r$3; $f.e = e; $f.opts = opts; $f.pe = pe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - ptrEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newPtrEncoder = function(t) { - var _r$3, _r$4, enc, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; _r$4 = $f._r$4; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$3 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = typeEncoder(_r$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - enc = new ptrEncoder.ptr(_r$4); - $s = -1; return $methodVal($clone(enc, ptrEncoder), "encode"); - /* */ } return; } if ($f === undefined) { $f = { $blk: newPtrEncoder }; } $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - condAddrEncoder.ptr.prototype.encode = function(e, v, opts) { - var ce, e, opts, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; ce = $f.ce; e = $f.e; opts = $f.opts; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ce = this; - /* */ if ($clone(v, reflect.Value).CanAddr()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($clone(v, reflect.Value).CanAddr()) { */ case 1: - $r = ce.canAddrEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 3; continue; - /* } else { */ case 2: - $r = ce.elseEnc(e, $clone(v, reflect.Value), $clone(opts, encOpts)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 3: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: condAddrEncoder.ptr.prototype.encode }; } $f.ce = ce; $f.e = e; $f.opts = opts; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - condAddrEncoder.prototype.encode = function(e, v, opts) { return this.$val.encode(e, v, opts); }; - newCondAddrEncoder = function(canAddrEnc, elseEnc) { - var canAddrEnc, elseEnc, enc; - enc = new condAddrEncoder.ptr(canAddrEnc, elseEnc); - return $methodVal($clone(enc, condAddrEncoder), "encode"); - }; - isValidTag = function(s) { - var _i, _ref, _rune, c, s; - if (s === "") { - return false; - } - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - c = _rune[0]; - if (strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c)) { - } else if (!unicode.IsLetter(c) && !unicode.IsDigit(c)) { - return false; - } - _i += _rune[1]; - } - return true; - }; - typeByIndex = function(t, index) { - var _i, _r$3, _r$4, _r$5, _ref, i, index, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; i = $f.i; index = $f.index; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _ref = index; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - i = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - _r$3 = t.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3 === 22) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_r$3 === 22) { */ case 3: - _r$4 = t.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - t = _r$4; - /* } */ case 4: - _r$5 = t.Field(i); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - t = _r$5.Type; - _i++; - /* } */ $s = 1; continue; case 2: - $s = -1; return t; - /* */ } return; } if ($f === undefined) { $f = { $blk: typeByIndex }; } $f._i = _i; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.i = i; $f.index = index; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - reflectWithString.ptr.prototype.resolve = function() { - var _1, _r$3, _r$4, _r$5, _tuple, _tuple$1, buf, err, ok, tm, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; err = $f.err; ok = $f.ok; tm = $f.tm; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - w = this; - /* */ if ($clone(w.v, reflect.Value).Kind() === 24) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ($clone(w.v, reflect.Value).Kind() === 24) { */ case 1: - _r$3 = $clone(w.v, reflect.Value).String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - w.s = _r$3; - $s = -1; return $ifaceNil; - /* } */ case 2: - _r$4 = $clone(w.v, reflect.Value).Interface(); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = $assertType(_r$4, encoding.TextMarshaler, true); - tm = _tuple[0]; - ok = _tuple[1]; - /* */ if (ok) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (ok) { */ case 5: - _r$5 = tm.MarshalText(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$1 = _r$5; - buf = _tuple$1[0]; - err = _tuple$1[1]; - w.s = ($bytesToString(buf)); - $s = -1; return err; - /* } */ case 6: - _1 = $clone(w.v, reflect.Value).Kind(); - if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { - w.s = strconv.FormatInt($clone(w.v, reflect.Value).Int(), 10); - $s = -1; return $ifaceNil; - } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { - w.s = strconv.FormatUint($clone(w.v, reflect.Value).Uint(), 10); - $s = -1; return $ifaceNil; - } - $panic(new $String("unexpected map key type")); - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: reflectWithString.ptr.prototype.resolve }; } $f._1 = _1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.err = err; $f.ok = ok; $f.tm = tm; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - reflectWithString.prototype.resolve = function() { return this.$val.resolve(); }; - encodeState.ptr.prototype.string = function(s, escapeHTML) { - var _1, _tuple, b, c, e, escapeHTML, i, s, size, start; - e = this; - e.Buffer.WriteByte(34); - start = 0; - i = 0; - while (true) { - if (!(i < s.length)) { break; } - b = s.charCodeAt(i); - if (b < 128) { - if (((b < 0 || b >= htmlSafeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : htmlSafeSet[b]) || (!escapeHTML && ((b < 0 || b >= safeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : safeSet[b]))) { - i = i + (1) >> 0; - continue; - } - if (start < i) { - e.Buffer.WriteString($substring(s, start, i)); - } - e.Buffer.WriteByte(92); - _1 = b; - if ((_1 === (92)) || (_1 === (34))) { - e.Buffer.WriteByte(b); - } else if (_1 === (10)) { - e.Buffer.WriteByte(110); - } else if (_1 === (13)) { - e.Buffer.WriteByte(114); - } else if (_1 === (9)) { - e.Buffer.WriteByte(116); - } else { - e.Buffer.WriteString("u00"); - e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24))); - e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0))); - } - i = i + (1) >> 0; - start = i; - continue; - } - _tuple = utf8.DecodeRuneInString($substring(s, i)); - c = _tuple[0]; - size = _tuple[1]; - if ((c === 65533) && (size === 1)) { - if (start < i) { - e.Buffer.WriteString($substring(s, start, i)); - } - e.Buffer.WriteString("\\ufffd"); - i = i + (size) >> 0; - start = i; - continue; - } - if ((c === 8232) || (c === 8233)) { - if (start < i) { - e.Buffer.WriteString($substring(s, start, i)); - } - e.Buffer.WriteString("\\u202"); - e.Buffer.WriteByte(hex.charCodeAt((c & 15))); - i = i + (size) >> 0; - start = i; - continue; - } - i = i + (size) >> 0; - } - if (start < s.length) { - e.Buffer.WriteString($substring(s, start)); - } - e.Buffer.WriteByte(34); - }; - encodeState.prototype.string = function(s, escapeHTML) { return this.$val.string(s, escapeHTML); }; - encodeState.ptr.prototype.stringBytes = function(s, escapeHTML) { - var _1, _tuple, b, c, e, escapeHTML, i, s, size, start; - e = this; - e.Buffer.WriteByte(34); - start = 0; - i = 0; - while (true) { - if (!(i < s.$length)) { break; } - b = ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]); - if (b < 128) { - if (((b < 0 || b >= htmlSafeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : htmlSafeSet[b]) || (!escapeHTML && ((b < 0 || b >= safeSet.length) ? ($throwRuntimeError("index out of range"), undefined) : safeSet[b]))) { - i = i + (1) >> 0; - continue; - } - if (start < i) { - e.Buffer.Write($subslice(s, start, i)); - } - e.Buffer.WriteByte(92); - _1 = b; - if ((_1 === (92)) || (_1 === (34))) { - e.Buffer.WriteByte(b); - } else if (_1 === (10)) { - e.Buffer.WriteByte(110); - } else if (_1 === (13)) { - e.Buffer.WriteByte(114); - } else if (_1 === (9)) { - e.Buffer.WriteByte(116); - } else { - e.Buffer.WriteString("u00"); - e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24))); - e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0))); - } - i = i + (1) >> 0; - start = i; - continue; - } - _tuple = utf8.DecodeRune($subslice(s, i)); - c = _tuple[0]; - size = _tuple[1]; - if ((c === 65533) && (size === 1)) { - if (start < i) { - e.Buffer.Write($subslice(s, start, i)); - } - e.Buffer.WriteString("\\ufffd"); - i = i + (size) >> 0; - start = i; - continue; - } - if ((c === 8232) || (c === 8233)) { - if (start < i) { - e.Buffer.Write($subslice(s, start, i)); - } - e.Buffer.WriteString("\\u202"); - e.Buffer.WriteByte(hex.charCodeAt((c & 15))); - i = i + (size) >> 0; - start = i; - continue; - } - i = i + (size) >> 0; - } - if (start < s.$length) { - e.Buffer.Write($subslice(s, start)); - } - e.Buffer.WriteByte(34); - }; - encodeState.prototype.stringBytes = function(s, escapeHTML) { return this.$val.stringBytes(s, escapeHTML); }; - byIndex.prototype.Len = function() { - var x; - x = this; - return x.$length; - }; - $ptrType(byIndex).prototype.Len = function() { return this.$get().Len(); }; - byIndex.prototype.Swap = function(i, j) { - var _tmp, _tmp$1, i, j, x; - x = this; - _tmp = $clone(((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]), field); - _tmp$1 = $clone(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), field); - field.copy(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), _tmp); - field.copy(((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]), _tmp$1); - }; - $ptrType(byIndex).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; - byIndex.prototype.Less = function(i, j) { - var _i, _ref, i, j, k, x, x$1, x$2, xik; - x = this; - _ref = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]).index; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - k = _i; - xik = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (k >= ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index.$length) { - return false; - } - if (!((xik === (x$1 = ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + k]))))) { - return xik < (x$2 = ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + k])); - } - _i++; - } - return ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]).index.$length; - }; - $ptrType(byIndex).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; - typeFields = function(t) { - var _1, _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _v, _v$1, _v$2, advance, count, current, dominant, f, f$1, fi, field$1, fields, fj, ft, i, i$1, i$2, index, isUnexported, name, name$1, nameEscBuf, next, nextCount, ok, opts, out, quoted, sf, t, t$1, tag, tagged, visited, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; advance = $f.advance; count = $f.count; current = $f.current; dominant = $f.dominant; f = $f.f; f$1 = $f.f$1; fi = $f.fi; field$1 = $f.field$1; fields = $f.fields; fj = $f.fj; ft = $f.ft; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; index = $f.index; isUnexported = $f.isUnexported; name = $f.name; name$1 = $f.name$1; nameEscBuf = $f.nameEscBuf; next = $f.next; nextCount = $f.nextCount; ok = $f.ok; opts = $f.opts; out = $f.out; quoted = $f.quoted; sf = $f.sf; t = $f.t; t$1 = $f.t$1; tag = $f.tag; tagged = $f.tagged; visited = $f.visited; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - fields = [fields]; - nameEscBuf = [nameEscBuf]; - current = new sliceType$3([]); - next = new sliceType$3([new field.ptr("", sliceType$1.nil, $throwNilPointerError, "", "", false, sliceType$2.nil, t, false, false, $throwNilPointerError)]); - count = $makeMap(reflect.Type.keyFor, []); - nextCount = $makeMap(reflect.Type.keyFor, []); - visited = $makeMap(reflect.Type.keyFor, []); - fields[0] = sliceType$3.nil; - nameEscBuf[0] = new bytes.Buffer.ptr(sliceType$1.nil, 0, 0); - /* while (true) { */ case 1: - /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; } - _tmp = next; - _tmp$1 = $subslice(current, 0, 0); - current = _tmp; - next = _tmp$1; - _tmp$2 = nextCount; - _tmp$3 = $makeMap(reflect.Type.keyFor, []); - count = _tmp$2; - nextCount = _tmp$3; - _ref = current; - _i = 0; - /* while (true) { */ case 3: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } - f = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), field); - /* */ if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { */ case 5: - _i++; - /* continue; */ $s = 3; continue; - /* } */ case 6: - _key = f.typ; (visited || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key)] = { k: _key, v: true }; - i = 0; - /* while (true) { */ case 7: - _r$3 = f.typ.NumField(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* if (!(i < _r$3)) { break; } */ if(!(i < _r$3)) { $s = 8; continue; } - _r$4 = f.typ.Field(i); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - sf = $clone(_r$4, reflect.StructField); - isUnexported = !(sf.PkgPath === ""); - /* */ if (sf.Anonymous) { $s = 11; continue; } - /* */ if (isUnexported) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (sf.Anonymous) { */ case 11: - t$1 = sf.Type; - _r$5 = t$1.Kind(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (_r$5 === 22) { $s = 14; continue; } - /* */ $s = 15; continue; - /* if (_r$5 === 22) { */ case 14: - _r$6 = t$1.Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - t$1 = _r$6; - /* } */ case 15: - if (!(isUnexported)) { _v = false; $s = 20; continue s; } - _r$7 = t$1.Kind(); /* */ $s = 21; case 21: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _v = !((_r$7 === 25)); case 20: - /* */ if (_v) { $s = 18; continue; } - /* */ $s = 19; continue; - /* if (_v) { */ case 18: - i = i + (1) >> 0; - /* continue; */ $s = 7; continue; - /* } */ case 19: - $s = 13; continue; - /* } else if (isUnexported) { */ case 12: - i = i + (1) >> 0; - /* continue; */ $s = 7; continue; - /* } */ case 13: - tag = new reflect.StructTag(sf.Tag).Get("json"); - /* */ if (tag === "-") { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (tag === "-") { */ case 22: - i = i + (1) >> 0; - /* continue; */ $s = 7; continue; - /* } */ case 23: - _tuple = parseTag(tag); - name = _tuple[0]; - opts = _tuple[1]; - if (!isValidTag(name)) { - name = ""; - } - index = $makeSlice(sliceType$2, (f.index.$length + 1 >> 0)); - $copySlice(index, f.index); - (x = f.index.$length, ((x < 0 || x >= index.$length) ? ($throwRuntimeError("index out of range"), undefined) : index.$array[index.$offset + x] = i)); - ft = sf.Type; - _r$8 = ft.Name(); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - if (!(_r$8 === "")) { _v$1 = false; $s = 26; continue s; } - _r$9 = ft.Kind(); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _v$1 = _r$9 === 22; case 26: - /* */ if (_v$1) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (_v$1) { */ case 24: - _r$10 = ft.Elem(); /* */ $s = 29; case 29: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - ft = _r$10; - /* } */ case 25: - quoted = false; - /* */ if (new tagOptions(opts).Contains("string")) { $s = 30; continue; } - /* */ $s = 31; continue; - /* if (new tagOptions(opts).Contains("string")) { */ case 30: - _r$11 = ft.Kind(); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - _1 = _r$11; - if ((_1 === (1)) || (_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12)) || (_1 === (13)) || (_1 === (14)) || (_1 === (24))) { - quoted = true; - } - case 32: - /* } */ case 31: - if (!(name === "") || !sf.Anonymous) { _v$2 = true; $s = 36; continue s; } - _r$12 = ft.Kind(); /* */ $s = 37; case 37: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - _v$2 = !((_r$12 === 25)); case 36: - /* */ if (_v$2) { $s = 34; continue; } - /* */ $s = 35; continue; - /* if (_v$2) { */ case 34: - tagged = !(name === ""); - if (name === "") { - name = sf.Name; - } - field$1 = new field.ptr(name, sliceType$1.nil, $throwNilPointerError, "", "", tagged, index, ft, new tagOptions(opts).Contains("omitempty"), quoted, $throwNilPointerError); - field$1.nameBytes = (new sliceType$1($stringToBytes(field$1.name))); - field$1.equalFold = foldFunc(field$1.nameBytes); - nameEscBuf[0].Reset(); - nameEscBuf[0].WriteString("\""); - HTMLEscape(nameEscBuf[0], field$1.nameBytes); - nameEscBuf[0].WriteString("\":"); - field$1.nameEscHTML = nameEscBuf[0].String(); - field$1.nameNonEsc = "\"" + field$1.name + "\":"; - fields[0] = $append(fields[0], field$1); - if ((_entry$1 = count[reflect.Type.keyFor(f.typ)], _entry$1 !== undefined ? _entry$1.v : 0) > 1) { - fields[0] = $append(fields[0], (x$1 = fields[0].$length - 1 >> 0, ((x$1 < 0 || x$1 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + x$1]))); - } - i = i + (1) >> 0; - /* continue; */ $s = 7; continue; - /* } */ case 35: - _key$1 = ft; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$1)] = { k: _key$1, v: (_entry$2 = nextCount[reflect.Type.keyFor(ft)], _entry$2 !== undefined ? _entry$2.v : 0) + (1) >> 0 }; - /* */ if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { $s = 38; continue; } - /* */ $s = 39; continue; - /* if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { */ case 38: - _r$13 = ft.Name(); /* */ $s = 40; case 40: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - next = $append(next, new field.ptr(_r$13, sliceType$1.nil, $throwNilPointerError, "", "", false, index, ft, false, false, $throwNilPointerError)); - /* } */ case 39: - i = i + (1) >> 0; - /* } */ $s = 7; continue; case 8: - _i++; - /* } */ $s = 3; continue; case 4: - /* } */ $s = 1; continue; case 2: - $r = sort.Slice(fields[0], (function(fields, nameEscBuf) { return function(i$1, j) { - var i$1, j, x$2; - x$2 = fields[0]; - if (!(((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).name === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).name)) { - return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).name < ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).name; - } - if (!((((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).index.$length === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).index.$length))) { - return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).index.$length < ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).index.$length; - } - if (!(((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).tag === ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j]).tag)) { - return ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1]).tag; - } - return ($subslice(new byIndex(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)).Less(i$1, j); - }; })(fields, nameEscBuf)); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - out = $subslice(fields[0], 0, 0); - _tmp$4 = 0; - _tmp$5 = 0; - advance = _tmp$4; - i$1 = _tmp$5; - /* while (true) { */ case 42: - /* if (!(i$1 < fields[0].$length)) { break; } */ if(!(i$1 < fields[0].$length)) { $s = 43; continue; } - fi = $clone(((i$1 < 0 || i$1 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + i$1]), field); - name$1 = fi.name; - advance = 1; - while (true) { - if (!((i$1 + advance >> 0) < fields[0].$length)) { break; } - fj = $clone((x$2 = i$1 + advance >> 0, ((x$2 < 0 || x$2 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + x$2])), field); - if (!(fj.name === name$1)) { - break; - } - advance = advance + (1) >> 0; - } - if (advance === 1) { - out = $append(out, fi); - i$1 = i$1 + (advance) >> 0; - /* continue; */ $s = 42; continue; - } - _tuple$1 = dominantField($subslice(fields[0], i$1, (i$1 + advance >> 0))); - dominant = $clone(_tuple$1[0], field); - ok = _tuple$1[1]; - if (ok) { - out = $append(out, dominant); - } - i$1 = i$1 + (advance) >> 0; - /* } */ $s = 42; continue; case 43: - fields[0] = out; - $r = sort.Sort(($subslice(new byIndex(fields[0].$array), fields[0].$offset, fields[0].$offset + fields[0].$length))); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _ref$1 = fields[0]; - _i$1 = 0; - /* while (true) { */ case 45: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 46; continue; } - i$2 = _i$1; - f$1 = ((i$2 < 0 || i$2 >= fields[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : fields[0].$array[fields[0].$offset + i$2]); - _r$14 = typeByIndex(t, f$1.index); /* */ $s = 47; case 47: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } - _r$15 = typeEncoder(_r$14); /* */ $s = 48; case 48: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } - f$1.encoder = _r$15; - _i$1++; - /* } */ $s = 45; continue; case 46: - $s = -1; return fields[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: typeFields }; } $f._1 = _1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.advance = advance; $f.count = count; $f.current = current; $f.dominant = dominant; $f.f = f; $f.f$1 = f$1; $f.fi = fi; $f.field$1 = field$1; $f.fields = fields; $f.fj = fj; $f.ft = ft; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.index = index; $f.isUnexported = isUnexported; $f.name = name; $f.name$1 = name$1; $f.nameEscBuf = nameEscBuf; $f.next = next; $f.nextCount = nextCount; $f.ok = ok; $f.opts = opts; $f.out = out; $f.quoted = quoted; $f.sf = sf; $f.t = t; $f.t$1 = t$1; $f.tag = tag; $f.tagged = tagged; $f.visited = visited; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - dominantField = function(fields) { - var fields; - if (fields.$length > 1 && ((0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]).index.$length === (1 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 1]).index.$length) && (0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]).tag === (1 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 1]).tag) { - return [new field.ptr("", sliceType$1.nil, $throwNilPointerError, "", "", false, sliceType$2.nil, $ifaceNil, false, false, $throwNilPointerError), false]; - } - return [(0 >= fields.$length ? ($throwRuntimeError("index out of range"), undefined) : fields.$array[fields.$offset + 0]), true]; - }; - cachedTypeFields = function(t) { - var _arg, _arg$1, _r$3, _r$4, _tuple, _tuple$1, f, f$1, ok, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; f$1 = $f.f$1; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _tuple = fieldCache.Load(t); - f = _tuple[0]; - ok = _tuple[1]; - if (ok) { - $s = -1; return $assertType(f, sliceType$3); - } - _arg = t; - _r$3 = typeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _arg$1 = _r$3; - _r$4 = fieldCache.LoadOrStore(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - f$1 = _tuple$1[0]; - $s = -1; return $assertType(f$1, sliceType$3); - /* */ } return; } if ($f === undefined) { $f = { $blk: cachedTypeFields }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.f$1 = f$1; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - foldFunc = function(s) { - var _i, _ref, b, nonLetter, s, special, upper; - nonLetter = false; - special = false; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (b >= 128) { - return bytes.EqualFold; - } - upper = (b & 223) >>> 0; - if (upper < 65 || upper > 90) { - nonLetter = true; - } else if ((upper === 75) || (upper === 83)) { - special = true; - } - _i++; - } - if (special) { - return equalFoldRight; - } - if (nonLetter) { - return asciiEqualFold; - } - return simpleLetterEqualFold; - }; - equalFoldRight = function(s, t) { - var _1, _i, _ref, _tuple, s, sb, sbUpper, size, t, tb, tr; - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - sb = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (t.$length === 0) { - return false; - } - tb = (0 >= t.$length ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + 0]); - if (tb < 128) { - if (!((sb === tb))) { - sbUpper = (sb & 223) >>> 0; - if (65 <= sbUpper && sbUpper <= 90) { - if (!((sbUpper === ((tb & 223) >>> 0)))) { - return false; - } - } else { - return false; - } - } - t = $subslice(t, 1); - _i++; - continue; - } - _tuple = utf8.DecodeRune(t); - tr = _tuple[0]; - size = _tuple[1]; - _1 = sb; - if ((_1 === (115)) || (_1 === (83))) { - if (!((tr === 383))) { - return false; - } - } else if ((_1 === (107)) || (_1 === (75))) { - if (!((tr === 8490))) { - return false; - } - } else { - return false; - } - t = $subslice(t, size); - _i++; - } - if (t.$length > 0) { - return false; - } - return true; - }; - asciiEqualFold = function(s, t) { - var _i, _ref, i, s, sb, t, tb; - if (!((s.$length === t.$length))) { - return false; - } - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - sb = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - tb = ((i < 0 || i >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + i]); - if (sb === tb) { - _i++; - continue; - } - if ((97 <= sb && sb <= 122) || (65 <= sb && sb <= 90)) { - if (!((((sb & 223) >>> 0) === ((tb & 223) >>> 0)))) { - return false; - } - } else { - return false; - } - _i++; - } - return true; - }; - simpleLetterEqualFold = function(s, t) { - var _i, _ref, b, i, s, t; - if (!((s.$length === t.$length))) { - return false; - } - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((((b & 223) >>> 0) === ((((i < 0 || i >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + i]) & 223) >>> 0)))) { - return false; - } - _i++; - } - return true; - }; - compact = function(dst, src, escape) { - var _i, _r$3, _r$4, _ref, c, dst, escape, i, origLen, scan, src, start, v, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; c = $f.c; dst = $f.dst; escape = $f.escape; i = $f.i; origLen = $f.origLen; scan = $f.scan; src = $f.src; start = $f.start; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - scan = [scan]; - origLen = dst.Len(); - scan[0] = new scanner.ptr($throwNilPointerError, false, sliceType$2.nil, $ifaceNil, new $Int64(0, 0)); - scan[0].reset(); - start = 0; - _ref = src; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - i = _i; - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (escape && ((c === 60) || (c === 62) || (c === 38))) { - if (start < i) { - dst.Write($subslice(src, start, i)); - } - dst.WriteString("\\u00"); - dst.WriteByte(hex.charCodeAt((c >>> 4 << 24 >>> 24))); - dst.WriteByte(hex.charCodeAt(((c & 15) >>> 0))); - start = i + 1 >> 0; - } - if ((c === 226) && (i + 2 >> 0) < src.$length && ((x = i + 1 >> 0, ((x < 0 || x >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$1])) & ~1) << 24 >>> 24) === 168)) { - if (start < i) { - dst.Write($subslice(src, start, i)); - } - dst.WriteString("\\u202"); - dst.WriteByte(hex.charCodeAt((((x$2 = i + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + x$2])) & 15) >>> 0))); - start = i + 3 >> 0; - } - _r$3 = scan[0].step(scan[0], c); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - v = _r$3; - if (v >= 9) { - if (v === 11) { - /* break; */ $s = 2; continue; - } - if (start < i) { - dst.Write($subslice(src, start, i)); - } - start = i + 1 >> 0; - } - _i++; - /* } */ $s = 1; continue; case 2: - _r$4 = scan[0].eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (_r$4 === 11) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$4 === 11) { */ case 4: - dst.Truncate(origLen); - $s = -1; return scan[0].err; - /* } */ case 5: - if (start < src.$length) { - dst.Write($subslice(src, start)); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: compact }; } $f._i = _i; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.c = c; $f.dst = dst; $f.escape = escape; $f.i = i; $f.origLen = origLen; $f.scan = scan; $f.src = src; $f.start = start; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - SyntaxError.ptr.prototype.Error = function() { - var e; - e = this; - return e.msg; - }; - SyntaxError.prototype.Error = function() { return this.$val.Error(); }; - scanner.ptr.prototype.reset = function() { - var s; - s = this; - s.step = stateBeginValue; - s.parseState = $subslice(s.parseState, 0, 0); - s.err = $ifaceNil; - s.endTop = false; - }; - scanner.prototype.reset = function() { return this.$val.reset(); }; - scanner.ptr.prototype.eof = function() { - var _r$3, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$3 = $f._r$3; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = this; - if (!($interfaceIsEqual(s.err, $ifaceNil))) { - $s = -1; return 11; - } - if (s.endTop) { - $s = -1; return 10; - } - _r$3 = s.step(s, 32); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - if (s.endTop) { - $s = -1; return 10; - } - if ($interfaceIsEqual(s.err, $ifaceNil)) { - s.err = new SyntaxError.ptr("unexpected end of JSON input", s.bytes); - } - $s = -1; return 11; - /* */ } return; } if ($f === undefined) { $f = { $blk: scanner.ptr.prototype.eof }; } $f._r$3 = _r$3; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - scanner.prototype.eof = function() { return this.$val.eof(); }; - scanner.ptr.prototype.pushParseState = function(p) { - var p, s; - s = this; - s.parseState = $append(s.parseState, p); - }; - scanner.prototype.pushParseState = function(p) { return this.$val.pushParseState(p); }; - scanner.ptr.prototype.popParseState = function() { - var n, s; - s = this; - n = s.parseState.$length - 1 >> 0; - s.parseState = $subslice(s.parseState, 0, n); - if (n === 0) { - s.step = stateEndTop; - s.endTop = true; - } else { - s.step = stateEndValue; - } - }; - scanner.prototype.popParseState = function() { return this.$val.popParseState(); }; - isSpace = function(c) { - var c; - return (c === 32) || (c === 9) || (c === 13) || (c === 10); - }; - stateBeginValueOrEmpty = function(s, c) { - var c, s; - if (c <= 32 && isSpace(c)) { - return 9; - } - if (c === 93) { - return stateEndValue(s, c); - } - return stateBeginValue(s, c); - }; - stateBeginValue = function(s, c) { - var _1, c, s; - if (c <= 32 && isSpace(c)) { - return 9; - } - _1 = c; - if (_1 === (123)) { - s.step = stateBeginStringOrEmpty; - s.pushParseState(0); - return 2; - } else if (_1 === (91)) { - s.step = stateBeginValueOrEmpty; - s.pushParseState(2); - return 6; - } else if (_1 === (34)) { - s.step = stateInString; - return 1; - } else if (_1 === (45)) { - s.step = stateNeg; - return 1; - } else if (_1 === (48)) { - s.step = state0; - return 1; - } else if (_1 === (116)) { - s.step = stateT; - return 1; - } else if (_1 === (102)) { - s.step = stateF; - return 1; - } else if (_1 === (110)) { - s.step = stateN; - return 1; - } - if (49 <= c && c <= 57) { - s.step = state1; - return 1; - } - return s.error(c, "looking for beginning of value"); - }; - stateBeginStringOrEmpty = function(s, c) { - var c, n, s, x, x$1; - if (c <= 32 && isSpace(c)) { - return 9; - } - if (c === 125) { - n = s.parseState.$length; - (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1] = 1)); - return stateEndValue(s, c); - } - return stateBeginString(s, c); - }; - stateBeginString = function(s, c) { - var c, s; - if (c <= 32 && isSpace(c)) { - return 9; - } - if (c === 34) { - s.step = stateInString; - return 1; - } - return s.error(c, "looking for beginning of object key string"); - }; - stateEndValue = function(s, c) { - var _1, c, n, ps, s, x, x$1, x$2, x$3, x$4, x$5; - n = s.parseState.$length; - if (n === 0) { - s.step = stateEndTop; - s.endTop = true; - return stateEndTop(s, c); - } - if (c <= 32 && isSpace(c)) { - s.step = stateEndValue; - return 9; - } - ps = (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - _1 = ps; - if (_1 === (0)) { - if (c === 58) { - (x$2 = s.parseState, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3] = 1)); - s.step = stateBeginValue; - return 3; - } - return s.error(c, "after object key"); - } else if (_1 === (1)) { - if (c === 44) { - (x$4 = s.parseState, x$5 = n - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5] = 0)); - s.step = stateBeginString; - return 4; - } - if (c === 125) { - s.popParseState(); - return 5; - } - return s.error(c, "after object key:value pair"); - } else if (_1 === (2)) { - if (c === 44) { - s.step = stateBeginValue; - return 7; - } - if (c === 93) { - s.popParseState(); - return 8; - } - return s.error(c, "after array element"); - } - return s.error(c, ""); - }; - stateEndTop = function(s, c) { - var c, s; - if (!isSpace(c)) { - s.error(c, "after top-level value"); - } - return 10; - }; - stateInString = function(s, c) { - var c, s; - if (c === 34) { - s.step = stateEndValue; - return 0; - } - if (c === 92) { - s.step = stateInStringEsc; - return 0; - } - if (c < 32) { - return s.error(c, "in string literal"); - } - return 0; - }; - stateInStringEsc = function(s, c) { - var _1, c, s; - _1 = c; - if ((_1 === (98)) || (_1 === (102)) || (_1 === (110)) || (_1 === (114)) || (_1 === (116)) || (_1 === (92)) || (_1 === (47)) || (_1 === (34))) { - s.step = stateInString; - return 0; - } else if (_1 === (117)) { - s.step = stateInStringEscU; - return 0; - } - return s.error(c, "in string escape code"); - }; - stateInStringEscU = function(s, c) { - var c, s; - if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { - s.step = stateInStringEscU1; - return 0; - } - return s.error(c, "in \\u hexadecimal character escape"); - }; - stateInStringEscU1 = function(s, c) { - var c, s; - if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { - s.step = stateInStringEscU12; - return 0; - } - return s.error(c, "in \\u hexadecimal character escape"); - }; - stateInStringEscU12 = function(s, c) { - var c, s; - if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { - s.step = stateInStringEscU123; - return 0; - } - return s.error(c, "in \\u hexadecimal character escape"); - }; - stateInStringEscU123 = function(s, c) { - var c, s; - if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) { - s.step = stateInString; - return 0; - } - return s.error(c, "in \\u hexadecimal character escape"); - }; - stateNeg = function(s, c) { - var c, s; - if (c === 48) { - s.step = state0; - return 0; - } - if (49 <= c && c <= 57) { - s.step = state1; - return 0; - } - return s.error(c, "in numeric literal"); - }; - state1 = function(s, c) { - var c, s; - if (48 <= c && c <= 57) { - s.step = state1; - return 0; - } - return state0(s, c); - }; - state0 = function(s, c) { - var c, s; - if (c === 46) { - s.step = stateDot; - return 0; - } - if ((c === 101) || (c === 69)) { - s.step = stateE; - return 0; - } - return stateEndValue(s, c); - }; - stateDot = function(s, c) { - var c, s; - if (48 <= c && c <= 57) { - s.step = stateDot0; - return 0; - } - return s.error(c, "after decimal point in numeric literal"); - }; - stateDot0 = function(s, c) { - var c, s; - if (48 <= c && c <= 57) { - return 0; - } - if ((c === 101) || (c === 69)) { - s.step = stateE; - return 0; - } - return stateEndValue(s, c); - }; - stateE = function(s, c) { - var c, s; - if ((c === 43) || (c === 45)) { - s.step = stateESign; - return 0; - } - return stateESign(s, c); - }; - stateESign = function(s, c) { - var c, s; - if (48 <= c && c <= 57) { - s.step = stateE0; - return 0; - } - return s.error(c, "in exponent of numeric literal"); - }; - stateE0 = function(s, c) { - var c, s; - if (48 <= c && c <= 57) { - return 0; - } - return stateEndValue(s, c); - }; - stateT = function(s, c) { - var c, s; - if (c === 114) { - s.step = stateTr; - return 0; - } - return s.error(c, "in literal true (expecting 'r')"); - }; - stateTr = function(s, c) { - var c, s; - if (c === 117) { - s.step = stateTru; - return 0; - } - return s.error(c, "in literal true (expecting 'u')"); - }; - stateTru = function(s, c) { - var c, s; - if (c === 101) { - s.step = stateEndValue; - return 0; - } - return s.error(c, "in literal true (expecting 'e')"); - }; - stateF = function(s, c) { - var c, s; - if (c === 97) { - s.step = stateFa; - return 0; - } - return s.error(c, "in literal false (expecting 'a')"); - }; - stateFa = function(s, c) { - var c, s; - if (c === 108) { - s.step = stateFal; - return 0; - } - return s.error(c, "in literal false (expecting 'l')"); - }; - stateFal = function(s, c) { - var c, s; - if (c === 115) { - s.step = stateFals; - return 0; - } - return s.error(c, "in literal false (expecting 's')"); - }; - stateFals = function(s, c) { - var c, s; - if (c === 101) { - s.step = stateEndValue; - return 0; - } - return s.error(c, "in literal false (expecting 'e')"); - }; - stateN = function(s, c) { - var c, s; - if (c === 117) { - s.step = stateNu; - return 0; - } - return s.error(c, "in literal null (expecting 'u')"); - }; - stateNu = function(s, c) { - var c, s; - if (c === 108) { - s.step = stateNul; - return 0; - } - return s.error(c, "in literal null (expecting 'l')"); - }; - stateNul = function(s, c) { - var c, s; - if (c === 108) { - s.step = stateEndValue; - return 0; - } - return s.error(c, "in literal null (expecting 'l')"); - }; - stateError = function(s, c) { - var c, s; - return 11; - }; - scanner.ptr.prototype.error = function(c, context) { - var c, context, s; - s = this; - s.step = stateError; - s.err = new SyntaxError.ptr("invalid character " + quoteChar(c) + " " + context, s.bytes); - return 11; - }; - scanner.prototype.error = function(c, context) { return this.$val.error(c, context); }; - quoteChar = function(c) { - var c, s; - if (c === 39) { - return "'\\''"; - } - if (c === 34) { - return "'\"'"; - } - s = strconv.Quote(($encodeRune(c))); - return "'" + $substring(s, 1, (s.length - 1 >> 0)) + "'"; - }; - parseTag = function(tag) { - var idx, tag; - idx = strings.Index(tag, ","); - if (!((idx === -1))) { - return [$substring(tag, 0, idx), ($substring(tag, (idx + 1 >> 0)))]; - } - return [tag, ""]; - }; - tagOptions.prototype.Contains = function(optionName) { - var _tmp, _tmp$1, i, next, o, optionName, s; - o = this.$val; - if (o.length === 0) { - return false; - } - s = (o); - while (true) { - if (!(!(s === ""))) { break; } - next = ""; - i = strings.Index(s, ","); - if (i >= 0) { - _tmp = $substring(s, 0, i); - _tmp$1 = $substring(s, (i + 1 >> 0)); - s = _tmp; - next = _tmp$1; - } - if (s === optionName) { - return true; - } - s = next; - } - return false; - }; - $ptrType(tagOptions).prototype.Contains = function(optionName) { return new tagOptions(this.$get()).Contains(optionName); }; - Number.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $error], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64, $error], false)}]; - ptrType$14.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$15.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$17.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$7.methods = [{prop: "marshal", name: "marshal", pkg: "encoding/json", typ: $funcType([$emptyInterface, encOpts], [$error], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "reflectValue", name: "reflectValue", pkg: "encoding/json", typ: $funcType([reflect.Value, encOpts], [], false)}, {prop: "string", name: "string", pkg: "encoding/json", typ: $funcType([$String, $Bool], [], false)}, {prop: "stringBytes", name: "stringBytes", pkg: "encoding/json", typ: $funcType([sliceType$1, $Bool], [], false)}]; - floatEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - structEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - mapEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - sliceEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - arrayEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - ptrEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - condAddrEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$7, reflect.Value, encOpts], [], false)}]; - ptrType$18.methods = [{prop: "resolve", name: "resolve", pkg: "encoding/json", typ: $funcType([], [$error], false)}]; - byIndex.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}]; - ptrType$19.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$20.methods = [{prop: "reset", name: "reset", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "eof", name: "eof", pkg: "encoding/json", typ: $funcType([], [$Int], false)}, {prop: "pushParseState", name: "pushParseState", pkg: "encoding/json", typ: $funcType([$Int], [], false)}, {prop: "popParseState", name: "popParseState", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$Uint8, $String], [$Int], false)}]; - tagOptions.methods = [{prop: "Contains", name: "Contains", pkg: "", typ: $funcType([$String], [$Bool], false)}]; - Marshaler.init([{prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}]); - UnsupportedTypeError.init("", [{prop: "Type", name: "Type", embedded: false, exported: true, typ: reflect.Type, tag: ""}]); - UnsupportedValueError.init("", [{prop: "Value", name: "Value", embedded: false, exported: true, typ: reflect.Value, tag: ""}, {prop: "Str", name: "Str", embedded: false, exported: true, typ: $String, tag: ""}]); - MarshalerError.init("", [{prop: "Type", name: "Type", embedded: false, exported: true, typ: reflect.Type, tag: ""}, {prop: "Err", name: "Err", embedded: false, exported: true, typ: $error, tag: ""}]); - encodeState.init("encoding/json", [{prop: "Buffer", name: "Buffer", embedded: true, exported: true, typ: bytes.Buffer, tag: ""}, {prop: "scratch", name: "scratch", embedded: false, exported: false, typ: arrayType, tag: ""}]); - jsonError.init("encoding/json", [{prop: "error", name: "error", embedded: true, exported: false, typ: $error, tag: ""}]); - encOpts.init("encoding/json", [{prop: "quoted", name: "quoted", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "escapeHTML", name: "escapeHTML", embedded: false, exported: false, typ: $Bool, tag: ""}]); - encoderFunc.init([ptrType$7, reflect.Value, encOpts], [], false); - structEncoder.init("encoding/json", [{prop: "fields", name: "fields", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); - mapEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - sliceEncoder.init("encoding/json", [{prop: "arrayEnc", name: "arrayEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - arrayEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - ptrEncoder.init("encoding/json", [{prop: "elemEnc", name: "elemEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - condAddrEncoder.init("encoding/json", [{prop: "canAddrEnc", name: "canAddrEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}, {prop: "elseEnc", name: "elseEnc", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - reflectWithString.init("encoding/json", [{prop: "v", name: "v", embedded: false, exported: false, typ: reflect.Value, tag: ""}, {prop: "s", name: "s", embedded: false, exported: false, typ: $String, tag: ""}]); - field.init("encoding/json", [{prop: "name", name: "name", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "nameBytes", name: "nameBytes", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "equalFold", name: "equalFold", embedded: false, exported: false, typ: funcType, tag: ""}, {prop: "nameNonEsc", name: "nameNonEsc", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "nameEscHTML", name: "nameEscHTML", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tag", name: "tag", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "index", name: "index", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "typ", name: "typ", embedded: false, exported: false, typ: reflect.Type, tag: ""}, {prop: "omitEmpty", name: "omitEmpty", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "quoted", name: "quoted", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "encoder", name: "encoder", embedded: false, exported: false, typ: encoderFunc, tag: ""}]); - byIndex.init(field); - SyntaxError.init("encoding/json", [{prop: "msg", name: "msg", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "Offset", name: "Offset", embedded: false, exported: true, typ: $Int64, tag: ""}]); - scanner.init("encoding/json", [{prop: "step", name: "step", embedded: false, exported: false, typ: funcType$1, tag: ""}, {prop: "endTop", name: "endTop", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "parseState", name: "parseState", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "err", name: "err", embedded: false, exported: false, typ: $error, tag: ""}, {prop: "bytes", name: "bytes", embedded: false, exported: false, typ: $Int64, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = encoding.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = base64.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = errors.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = nosync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = reflect.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sort.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strings.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf16.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - encodeStatePool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); - encoderCache = new nosync.Map.ptr(false); - fieldCache = new nosync.Map.ptr(false); - _r = reflect.TypeOf((ptrType.nil)).Elem(); /* */ $s = 16; case 16: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - textUnmarshalerType = _r; - numberType = reflect.TypeOf(new Number("")); - hex = "0123456789abcdef"; - _r$1 = reflect.TypeOf((ptrType$1.nil)).Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - marshalerType = _r$1; - _r$2 = reflect.TypeOf((ptrType$2.nil)).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - textMarshalerType = _r$2; - float32Encoder = $methodVal(new floatEncoder(32), "encode"); - float64Encoder = $methodVal(new floatEncoder(64), "encode"); - safeSet = $toNativeArray($kindBool, [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]); - htmlSafeSet = $toNativeArray($kindBool, [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["log"] = (function() { - var $pkg = {}, $init, fmt, nosync, io, os, runtime, time, Logger, sliceType, arrayType, ptrType, sliceType$1, ptrType$1, std, New, itoa, Printf, Println; - fmt = $packages["fmt"]; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - io = $packages["io"]; - os = $packages["os"]; - runtime = $packages["runtime"]; - time = $packages["time"]; - Logger = $pkg.Logger = $newType(0, $kindStruct, "log.Logger", true, "log", true, function(mu_, prefix_, flag_, out_, buf_) { - this.$val = this; - if (arguments.length === 0) { - this.mu = new nosync.Mutex.ptr(false); - this.prefix = ""; - this.flag = 0; - this.out = $ifaceNil; - this.buf = sliceType.nil; - return; - } - this.mu = mu_; - this.prefix = prefix_; - this.flag = flag_; - this.out = out_; - this.buf = buf_; - }); - sliceType = $sliceType($Uint8); - arrayType = $arrayType($Uint8, 20); - ptrType = $ptrType(sliceType); - sliceType$1 = $sliceType($emptyInterface); - ptrType$1 = $ptrType(Logger); - New = function(out, prefix, flag) { - var flag, out, prefix; - return new Logger.ptr(new nosync.Mutex.ptr(false), prefix, flag, out, sliceType.nil); - }; - $pkg.New = New; - Logger.ptr.prototype.SetOutput = function(w) { - var l, w, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - l.out = w; - /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.SetOutput = function(w) { return this.$val.SetOutput(w); }; - itoa = function(buf, i, wid) { - var _q, b, bp, buf, i, q, wid; - b = arrayType.zero(); - bp = 19; - while (true) { - if (!(i >= 10 || wid > 1)) { break; } - wid = wid - (1) >> 0; - q = (_q = i / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - ((bp < 0 || bp >= b.length) ? ($throwRuntimeError("index out of range"), undefined) : b[bp] = ((((48 + i >> 0) - ($imul(q, 10)) >> 0) << 24 >>> 24))); - bp = bp - (1) >> 0; - i = q; - } - ((bp < 0 || bp >= b.length) ? ($throwRuntimeError("index out of range"), undefined) : b[bp] = (((48 + i >> 0) << 24 >>> 24))); - buf.$set($appendSlice(buf.$get(), $subslice(new sliceType(b), bp))); - }; - Logger.ptr.prototype.formatHeader = function(buf, t, file, line) { - var _q, _r, _r$1, _tuple, _tuple$1, buf, day, file, hour, i, l, line, min, month, sec, short$1, t, year, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; day = $f.day; file = $f.file; hour = $f.hour; i = $f.i; l = $f.l; line = $f.line; min = $f.min; month = $f.month; sec = $f.sec; short$1 = $f.short$1; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - buf.$set($appendSlice(buf.$get(), l.prefix)); - /* */ if (!(((l.flag & 7) === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(((l.flag & 7) === 0))) { */ case 1: - if (!(((l.flag & 32) === 0))) { - time.Time.copy(t, $clone(t, time.Time).UTC()); - } - /* */ if (!(((l.flag & 1) === 0))) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!(((l.flag & 1) === 0))) { */ case 3: - _r = $clone(t, time.Time).Date(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - year = _tuple[0]; - month = _tuple[1]; - day = _tuple[2]; - itoa(buf, year, 4); - buf.$set($append(buf.$get(), 47)); - itoa(buf, ((month >> 0)), 2); - buf.$set($append(buf.$get(), 47)); - itoa(buf, day, 2); - buf.$set($append(buf.$get(), 32)); - /* } */ case 4: - /* */ if (!(((l.flag & 6) === 0))) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (!(((l.flag & 6) === 0))) { */ case 6: - _r$1 = $clone(t, time.Time).Clock(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - hour = _tuple$1[0]; - min = _tuple$1[1]; - sec = _tuple$1[2]; - itoa(buf, hour, 2); - buf.$set($append(buf.$get(), 58)); - itoa(buf, min, 2); - buf.$set($append(buf.$get(), 58)); - itoa(buf, sec, 2); - if (!(((l.flag & 4) === 0))) { - buf.$set($append(buf.$get(), 46)); - itoa(buf, (_q = $clone(t, time.Time).Nanosecond() / 1000, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), 6); - } - buf.$set($append(buf.$get(), 32)); - /* } */ case 7: - /* } */ case 2: - if (!(((l.flag & 24) === 0))) { - if (!(((l.flag & 16) === 0))) { - short$1 = file; - i = file.length - 1 >> 0; - while (true) { - if (!(i > 0)) { break; } - if (file.charCodeAt(i) === 47) { - short$1 = $substring(file, (i + 1 >> 0)); - break; - } - i = i - (1) >> 0; - } - file = short$1; - } - buf.$set($appendSlice(buf.$get(), file)); - buf.$set($append(buf.$get(), 58)); - itoa(buf, line, -1); - buf.$set($appendSlice(buf.$get(), ": ")); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.formatHeader }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.day = day; $f.file = file; $f.hour = hour; $f.i = i; $f.l = l; $f.line = line; $f.min = min; $f.month = month; $f.sec = sec; $f.short$1 = short$1; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.formatHeader = function(buf, t, file, line) { return this.$val.formatHeader(buf, t, file, line); }; - Logger.ptr.prototype.Output = function(calldepth, s) { - var _r, _tuple, _tuple$1, calldepth, err, file, l, line, now, ok, s, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; calldepth = $f.calldepth; err = $f.err; file = $f.file; l = $f.l; line = $f.line; now = $f.now; ok = $f.ok; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - now = $clone(time.Now(), time.Time); - file = ""; - line = 0; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - if (!(((l.flag & 24) === 0))) { - l.mu.Unlock(); - ok = false; - _tuple = runtime.Caller(calldepth); - file = _tuple[1]; - line = _tuple[2]; - ok = _tuple[3]; - if (!ok) { - file = "???"; - line = 0; - } - l.mu.Lock(); - } - l.buf = $subslice(l.buf, 0, 0); - $r = l.formatHeader((l.$ptr_buf || (l.$ptr_buf = new ptrType(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, l))), $clone(now, time.Time), file, line); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - l.buf = $appendSlice(l.buf, s); - if ((s.length === 0) || !((s.charCodeAt((s.length - 1 >> 0)) === 10))) { - l.buf = $append(l.buf, 10); - } - _r = l.out.Write(l.buf); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$1 = _r; - err = _tuple$1[1]; - $s = -1; return err; - /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Output }; } $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.calldepth = calldepth; $f.err = err; $f.file = file; $f.l = l; $f.line = line; $f.now = now; $f.ok = ok; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - Logger.prototype.Output = function(calldepth, s) { return this.$val.Output(calldepth, s); }; - Logger.ptr.prototype.Printf = function(format, v) { - var _arg, _r, _r$1, format, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Printf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Printf = function(format, v) { return this.$val.Printf(format, v); }; - Logger.ptr.prototype.Print = function(v) { - var _arg, _r, _r$1, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Print }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Print = function(v) { return this.$val.Print(v); }; - Logger.ptr.prototype.Println = function(v) { - var _arg, _r, _r$1, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Println }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Println = function(v) { return this.$val.Println(v); }; - Logger.ptr.prototype.Fatal = function(v) { - var _arg, _r, _r$1, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - os.Exit(1); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatal }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Fatal = function(v) { return this.$val.Fatal(v); }; - Logger.ptr.prototype.Fatalf = function(format, v) { - var _arg, _r, _r$1, format, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - os.Exit(1); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatalf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Fatalf = function(format, v) { return this.$val.Fatalf(format, v); }; - Logger.ptr.prototype.Fatalln = function(v) { - var _arg, _r, _r$1, l, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; l = $f.l; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = l.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - os.Exit(1); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Fatalln }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Fatalln = function(v) { return this.$val.Fatalln(v); }; - Logger.ptr.prototype.Panic = function(v) { - var _r, _r$1, l, s, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprint(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - s = _r; - _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $panic(new $String(s)); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panic }; } $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Panic = function(v) { return this.$val.Panic(v); }; - Logger.ptr.prototype.Panicf = function(format, v) { - var _r, _r$1, format, l, s, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; format = $f.format; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - s = _r; - _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $panic(new $String(s)); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panicf }; } $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Panicf = function(format, v) { return this.$val.Panicf(format, v); }; - Logger.ptr.prototype.Panicln = function(v) { - var _r, _r$1, l, s, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; l = $f.l; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - l = this; - _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - s = _r; - _r$1 = l.Output(2, s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $panic(new $String(s)); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Logger.ptr.prototype.Panicln }; } $f._r = _r; $f._r$1 = _r$1; $f.l = l; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Logger.prototype.Panicln = function(v) { return this.$val.Panicln(v); }; - Logger.ptr.prototype.Flags = function() { - var l, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - return l.flag; - /* */ } catch(err) { $err = err; return 0; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.Flags = function() { return this.$val.Flags(); }; - Logger.ptr.prototype.SetFlags = function(flag) { - var flag, l, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - l.flag = flag; - /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.SetFlags = function(flag) { return this.$val.SetFlags(flag); }; - Logger.ptr.prototype.Prefix = function() { - var l, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - return l.prefix; - /* */ } catch(err) { $err = err; return ""; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.Prefix = function() { return this.$val.Prefix(); }; - Logger.ptr.prototype.SetPrefix = function(prefix) { - var l, prefix, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - l.prefix = prefix; - /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.SetPrefix = function(prefix) { return this.$val.SetPrefix(prefix); }; - Logger.ptr.prototype.Writer = function() { - var l, $deferred; - /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - l = this; - l.mu.Lock(); - $deferred.push([$methodVal(l.mu, "Unlock"), []]); - return l.out; - /* */ } catch(err) { $err = err; return $ifaceNil; } finally { $callDeferred($deferred, $err); } - }; - Logger.prototype.Writer = function() { return this.$val.Writer(); }; - Printf = function(format, v) { - var _arg, _r, _r$1, format, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; format = $f.format; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = fmt.Sprintf(format, v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = std.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Printf }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.format = format; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Printf = Printf; - Println = function(v) { - var _arg, _r, _r$1, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r = $f._r; _r$1 = $f._r$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = fmt.Sprintln(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg = _r; - _r$1 = std.Output(2, _arg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Println }; } $f._arg = _arg; $f._r = _r; $f._r$1 = _r$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Println = Println; - ptrType$1.methods = [{prop: "SetOutput", name: "SetOutput", pkg: "", typ: $funcType([io.Writer], [], false)}, {prop: "formatHeader", name: "formatHeader", pkg: "log", typ: $funcType([ptrType, time.Time, $String, $Int], [], false)}, {prop: "Output", name: "Output", pkg: "", typ: $funcType([$Int, $String], [$error], false)}, {prop: "Printf", name: "Printf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Print", name: "Print", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Println", name: "Println", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Fatal", name: "Fatal", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Fatalf", name: "Fatalf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Fatalln", name: "Fatalln", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Panic", name: "Panic", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Panicf", name: "Panicf", pkg: "", typ: $funcType([$String, sliceType$1], [], true)}, {prop: "Panicln", name: "Panicln", pkg: "", typ: $funcType([sliceType$1], [], true)}, {prop: "Flags", name: "Flags", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetFlags", name: "SetFlags", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Prefix", name: "Prefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetPrefix", name: "SetPrefix", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Writer", name: "Writer", pkg: "", typ: $funcType([], [io.Writer], false)}]; - Logger.init("log", [{prop: "mu", name: "mu", embedded: false, exported: false, typ: nosync.Mutex, tag: ""}, {prop: "prefix", name: "prefix", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "flag", name: "flag", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", embedded: false, exported: false, typ: sliceType, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = fmt.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = nosync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - std = New(os.Stderr, "", 3); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["math/rand"] = (function() { - var $pkg = {}, $init, nosync, math, Source, Source64, Rand, lockedSource, rngSource, arrayType, ptrType, ptrType$1, sliceType, ptrType$2, ptrType$3, funcType, sliceType$1, ptrType$5, ke, we, fe, kn, wn, fn, globalRand, rngCooked, absInt32, NewSource, New, read, seedrand; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - math = $packages["math"]; - Source = $pkg.Source = $newType(8, $kindInterface, "rand.Source", true, "math/rand", true, null); - Source64 = $pkg.Source64 = $newType(8, $kindInterface, "rand.Source64", true, "math/rand", true, null); - Rand = $pkg.Rand = $newType(0, $kindStruct, "rand.Rand", true, "math/rand", true, function(src_, s64_, readVal_, readPos_) { - this.$val = this; - if (arguments.length === 0) { - this.src = $ifaceNil; - this.s64 = $ifaceNil; - this.readVal = new $Int64(0, 0); - this.readPos = 0; - return; - } - this.src = src_; - this.s64 = s64_; - this.readVal = readVal_; - this.readPos = readPos_; - }); - lockedSource = $pkg.lockedSource = $newType(0, $kindStruct, "rand.lockedSource", true, "math/rand", false, function(lk_, src_) { - this.$val = this; - if (arguments.length === 0) { - this.lk = new nosync.Mutex.ptr(false); - this.src = $ifaceNil; - return; - } - this.lk = lk_; - this.src = src_; - }); - rngSource = $pkg.rngSource = $newType(0, $kindStruct, "rand.rngSource", true, "math/rand", false, function(tap_, feed_, vec_) { - this.$val = this; - if (arguments.length === 0) { - this.tap = 0; - this.feed = 0; - this.vec = arrayType.zero(); - return; - } - this.tap = tap_; - this.feed = feed_; - this.vec = vec_; - }); - arrayType = $arrayType($Int64, 607); - ptrType = $ptrType(lockedSource); - ptrType$1 = $ptrType($Int8); - sliceType = $sliceType($Int); - ptrType$2 = $ptrType($Int64); - ptrType$3 = $ptrType(Rand); - funcType = $funcType([$Int, $Int], [], false); - sliceType$1 = $sliceType($Uint8); - ptrType$5 = $ptrType(rngSource); - Rand.ptr.prototype.ExpFloat64 = function() { - var _r, _r$1, _r$2, _r$3, i, j, r, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - /* while (true) { */ case 1: - _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - j = _r; - i = (j & 255) >>> 0; - x = (j) * (((i < 0 || i >= we.length) ? ($throwRuntimeError("index out of range"), undefined) : we[i])); - if (j < ((i < 0 || i >= ke.length) ? ($throwRuntimeError("index out of range"), undefined) : ke[i])) { - $s = -1; return x; - } - /* */ if (i === 0) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (i === 0) { */ case 4: - _r$1 = r.Float64(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = math.Log(_r$1); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return 7.69711747013105 - _r$2; - /* } */ case 5: - _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if ($fround(((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]) + $fround(($fround(_r$3)) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[x$1])) - ((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]))))) < ($fround(math.Exp(-x)))) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if ($fround(((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]) + $fround(($fround(_r$3)) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[x$1])) - ((i < 0 || i >= fe.length) ? ($throwRuntimeError("index out of range"), undefined) : fe[i]))))) < ($fround(math.Exp(-x)))) { */ case 8: - $s = -1; return x; - /* } */ case 9: - /* } */ $s = 1; continue; case 2: - $s = -1; return 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.ExpFloat64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.ExpFloat64 = function() { return this.$val.ExpFloat64(); }; - absInt32 = function(i) { - var i; - if (i < 0) { - return ((-i >>> 0)); - } - return ((i >>> 0)); - }; - Rand.ptr.prototype.NormFloat64 = function() { - var _r, _r$1, _r$2, _r$3, _r$4, _r$5, i, j, r, x, x$1, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - /* while (true) { */ case 1: - _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - j = ((_r >> 0)); - i = j & 127; - x = (j) * (((i < 0 || i >= wn.length) ? ($throwRuntimeError("index out of range"), undefined) : wn[i])); - if (absInt32(j) < ((i < 0 || i >= kn.length) ? ($throwRuntimeError("index out of range"), undefined) : kn[i])) { - $s = -1; return x; - } - /* */ if (i === 0) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (i === 0) { */ case 4: - /* while (true) { */ case 6: - _r$1 = r.Float64(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = math.Log(_r$1); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = -_r$2 * 0.29047645161474317; - _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = math.Log(_r$3); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - y = -_r$4; - if (y + y >= x * x) { - /* break; */ $s = 7; continue; - } - /* } */ $s = 6; continue; case 7: - if (j > 0) { - $s = -1; return 3.442619855899 + x; - } - $s = -1; return -3.442619855899 - x; - /* } */ case 5: - _r$5 = r.Float64(); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if ($fround(((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]) + $fround(($fround(_r$5)) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[x$1])) - ((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]))))) < ($fround(math.Exp(-0.5 * x * x)))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ($fround(((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]) + $fround(($fround(_r$5)) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[x$1])) - ((i < 0 || i >= fn.length) ? ($throwRuntimeError("index out of range"), undefined) : fn[i]))))) < ($fround(math.Exp(-0.5 * x * x)))) { */ case 12: - $s = -1; return x; - /* } */ case 13: - /* } */ $s = 1; continue; case 2: - $s = -1; return 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.NormFloat64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.NormFloat64 = function() { return this.$val.NormFloat64(); }; - NewSource = function(seed) { - var rng, seed; - rng = new rngSource.ptr(0, 0, arrayType.zero()); - rng.Seed(seed); - return rng; - }; - $pkg.NewSource = NewSource; - New = function(src) { - var _tuple, s64, src; - _tuple = $assertType(src, Source64, true); - s64 = _tuple[0]; - return new Rand.ptr(src, s64, new $Int64(0, 0), 0); - }; - $pkg.New = New; - Rand.ptr.prototype.Seed = function(seed) { - var _tuple, lk, ok, r, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; lk = $f.lk; ok = $f.ok; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _tuple = $assertType(r.src, ptrType, true); - lk = _tuple[0]; - ok = _tuple[1]; - /* */ if (ok) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (ok) { */ case 1: - $r = lk.seedPos(seed, (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* } */ case 2: - $r = r.src.Seed(seed); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - r.readPos = 0; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Seed }; } $f._tuple = _tuple; $f.lk = lk; $f.ok = ok; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; - Rand.ptr.prototype.Int63 = function() { - var _r, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63 }; } $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Int63 = function() { return this.$val.Int63(); }; - Rand.ptr.prototype.Uint32 = function() { - var _r, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (($shiftRightInt64(_r, 31).$low >>> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Uint32 }; } $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Uint32 = function() { return this.$val.Uint32(); }; - Rand.ptr.prototype.Uint64 = function() { - var _r, _r$1, _r$2, r, x, x$1, x$2, x$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; r = $f.r; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - /* */ if (!($interfaceIsEqual(r.s64, $ifaceNil))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!($interfaceIsEqual(r.s64, $ifaceNil))) { */ case 1: - _r = r.s64.Uint64(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 2: - _r$1 = r.Int63(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = r.Int63(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return (x = $shiftRightUint64(((x$1 = _r$1, new $Uint64(x$1.$high, x$1.$low))), 31), x$2 = $shiftLeft64(((x$3 = _r$2, new $Uint64(x$3.$high, x$3.$low))), 32), new $Uint64(x.$high | x$2.$high, (x.$low | x$2.$low) >>> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Uint64 }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Uint64 = function() { return this.$val.Uint64(); }; - Rand.ptr.prototype.Int31 = function() { - var _r, r, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (((x = $shiftRightInt64(_r, 32), x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31 }; } $f._r = _r; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Int31 = function() { return this.$val.Int31(); }; - Rand.ptr.prototype.Int = function() { - var _r, r, u, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - u = ((_r.$low >>> 0)); - $s = -1; return ((((u << 1 >>> 0) >>> 1 >>> 0) >> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int }; } $f._r = _r; $f.r = r; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Int = function() { return this.$val.Int(); }; - Rand.ptr.prototype.Int63n = function(n) { - var _r, _r$1, _r$2, max, n, r, v, x, x$1, x$2, x$3, x$4, x$5, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; max = $f.max; n = $f.n; r = $f.r; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - if ((n.$high < 0 || (n.$high === 0 && n.$low <= 0))) { - $panic(new $String("invalid argument to Int63n")); - } - /* */ if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { */ case 1: - _r = r.Int63(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return (x$2 = _r, x$3 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); - /* } */ case 2: - max = ((x$4 = (x$5 = $div64(new $Uint64(2147483648, 0), (new $Uint64(n.$high, n.$low)), true), new $Uint64(2147483647 - x$5.$high, 4294967295 - x$5.$low)), new $Int64(x$4.$high, x$4.$low))); - _r$1 = r.Int63(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - v = _r$1; - /* while (true) { */ case 5: - /* if (!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { break; } */ if(!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { $s = 6; continue; } - _r$2 = r.Int63(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - v = _r$2; - /* } */ $s = 5; continue; case 6: - $s = -1; return $div64(v, n, true); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Int63n = function(n) { return this.$val.Int63n(n); }; - Rand.ptr.prototype.Int31n = function(n) { - var _r, _r$1, _r$2, _r$3, _r$4, max, n, r, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; max = $f.max; n = $f.n; r = $f.r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - if (n <= 0) { - $panic(new $String("invalid argument to Int31n")); - } - /* */ if ((n & ((n - 1 >> 0))) === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((n & ((n - 1 >> 0))) === 0) { */ case 1: - _r = r.Int31(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r & ((n - 1 >> 0)); - /* } */ case 2: - max = (((2147483647 - (_r$1 = 2147483648 % ((n >>> 0)), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0) >> 0)); - _r$2 = r.Int31(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - v = _r$2; - /* while (true) { */ case 5: - /* if (!(v > max)) { break; } */ if(!(v > max)) { $s = 6; continue; } - _r$3 = r.Int31(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - v = _r$3; - /* } */ $s = 5; continue; case 6: - $s = -1; return (_r$4 = v % n, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Int31n = function(n) { return this.$val.Int31n(n); }; - Rand.ptr.prototype.int31n = function(n) { - var _r, _r$1, _r$2, low, n, prod, r, thresh, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; low = $f.low; n = $f.n; prod = $f.prod; r = $f.r; thresh = $f.thresh; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r = r.Uint32(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - v = _r; - prod = $mul64((new $Uint64(0, v)), (new $Uint64(0, n))); - low = ((prod.$low >>> 0)); - /* */ if (low < ((n >>> 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (low < ((n >>> 0))) { */ case 2: - thresh = (_r$1 = ((-n >>> 0)) % ((n >>> 0)), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); - /* while (true) { */ case 4: - /* if (!(low < thresh)) { break; } */ if(!(low < thresh)) { $s = 5; continue; } - _r$2 = r.Uint32(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - v = _r$2; - prod = $mul64((new $Uint64(0, v)), (new $Uint64(0, n))); - low = ((prod.$low >>> 0)); - /* } */ $s = 4; continue; case 5: - /* } */ case 3: - $s = -1; return (($shiftRightUint64(prod, 32).$low >> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.int31n }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.low = low; $f.n = n; $f.prod = prod; $f.r = r; $f.thresh = thresh; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.int31n = function(n) { return this.$val.int31n(n); }; - Rand.ptr.prototype.Intn = function(n) { - var _r, _r$1, n, r, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; n = $f.n; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - if (n <= 0) { - $panic(new $String("invalid argument to Intn")); - } - /* */ if (n <= 2147483647) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (n <= 2147483647) { */ case 1: - _r = r.Int31n(((n >> 0))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return ((_r >> 0)); - /* } */ case 2: - _r$1 = r.Int63n((new $Int64(0, n))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return (((x = _r$1, x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Intn }; } $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Intn = function(n) { return this.$val.Intn(n); }; - Rand.ptr.prototype.Float64 = function() { - var _r, f, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - /* again: */ case 1: - _r = r.Int63(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - f = ($flatten64(_r)) / 9.223372036854776e+18; - /* */ if (f === 1) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (f === 1) { */ case 3: - /* goto again */ $s = 1; continue; - /* } */ case 4: - $s = -1; return f; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float64 }; } $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Float64 = function() { return this.$val.Float64(); }; - Rand.ptr.prototype.Float32 = function() { - var _r, f, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - /* again: */ case 1: - _r = r.Float64(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - f = ($fround(_r)); - /* */ if (f === 1) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (f === 1) { */ case 3: - /* goto again */ $s = 1; continue; - /* } */ case 4: - $s = -1; return f; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float32 }; } $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Float32 = function() { return this.$val.Float32(); }; - Rand.ptr.prototype.Perm = function(n) { - var _r, i, j, m, n, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; j = $f.j; m = $f.m; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - m = $makeSlice(sliceType, n); - i = 0; - /* while (true) { */ case 1: - /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; } - _r = r.Intn(i + 1 >> 0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - j = _r; - ((i < 0 || i >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + i] = ((j < 0 || j >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + j])); - ((j < 0 || j >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + j] = i); - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return m; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Perm }; } $f._r = _r; $f.i = i; $f.j = j; $f.m = m; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Perm = function(n) { return this.$val.Perm(n); }; - Rand.ptr.prototype.Shuffle = function(n, swap) { - var _r, _r$1, i, j, j$1, n, r, swap, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; j = $f.j; j$1 = $f.j$1; n = $f.n; r = $f.r; swap = $f.swap; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - if (n < 0) { - $panic(new $String("invalid argument to Shuffle")); - } - i = n - 1 >> 0; - /* while (true) { */ case 1: - /* if (!(i > 2147483646)) { break; } */ if(!(i > 2147483646)) { $s = 2; continue; } - _r = r.Int63n((new $Int64(0, (i + 1 >> 0)))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - j = (((x = _r, x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); - $r = swap(i, j); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i - (1) >> 0; - /* } */ $s = 1; continue; case 2: - /* while (true) { */ case 5: - /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 6; continue; } - _r$1 = r.int31n((((i + 1 >> 0) >> 0))); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - j$1 = ((_r$1 >> 0)); - $r = swap(i, j$1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i - (1) >> 0; - /* } */ $s = 5; continue; case 6: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Shuffle }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.j = j; $f.j$1 = j$1; $f.n = n; $f.r = r; $f.swap = swap; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Shuffle = function(n, swap) { return this.$val.Shuffle(n, swap); }; - Rand.ptr.prototype.Read = function(p) { - var _r, _r$1, _tuple, _tuple$1, _tuple$2, err, lk, n, ok, p, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; lk = $f.lk; n = $f.n; ok = $f.ok; p = $f.p; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - r = this; - _tuple = $assertType(r.src, ptrType, true); - lk = _tuple[0]; - ok = _tuple[1]; - /* */ if (ok) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (ok) { */ case 1: - _r = lk.read(p, (r.$ptr_readVal || (r.$ptr_readVal = new ptrType$2(function() { return this.$target.readVal; }, function($v) { this.$target.readVal = $v; }, r))), (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$1 = _r; - n = _tuple$1[0]; - err = _tuple$1[1]; - $s = -1; return [n, err]; - /* } */ case 2: - _r$1 = read(p, $methodVal(r, "Int63"), (r.$ptr_readVal || (r.$ptr_readVal = new ptrType$2(function() { return this.$target.readVal; }, function($v) { this.$target.readVal = $v; }, r))), (r.$ptr_readPos || (r.$ptr_readPos = new ptrType$1(function() { return this.$target.readPos; }, function($v) { this.$target.readPos = $v; }, r)))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$2 = _r$1; - n = _tuple$2[0]; - err = _tuple$2[1]; - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Read }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.lk = lk; $f.n = n; $f.ok = ok; $f.p = p; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rand.prototype.Read = function(p) { return this.$val.Read(p); }; - read = function(p, int63, readVal, readPos) { - var _r, err, int63, n, p, pos, readPos, readVal, val, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; int63 = $f.int63; n = $f.n; p = $f.p; pos = $f.pos; readPos = $f.readPos; readVal = $f.readVal; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - pos = readPos.$get(); - val = readVal.$get(); - n = 0; - /* while (true) { */ case 1: - /* if (!(n < p.$length)) { break; } */ if(!(n < p.$length)) { $s = 2; continue; } - /* */ if (pos === 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (pos === 0) { */ case 3: - _r = int63(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - val = _r; - pos = 7; - /* } */ case 4: - ((n < 0 || n >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + n] = ((val.$low << 24 >>> 24))); - val = $shiftRightInt64(val, (8)); - pos = pos - (1) << 24 >> 24; - n = n + (1) >> 0; - /* } */ $s = 1; continue; case 2: - readPos.$set(pos); - readVal.$set(val); - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: read }; } $f._r = _r; $f.err = err; $f.int63 = int63; $f.n = n; $f.p = p; $f.pos = pos; $f.readPos = readPos; $f.readVal = readVal; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.ptr.prototype.Int63 = function() { - var _r, n, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Int64(0, 0); - r = this; - r.lk.Lock(); - _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - n = _r; - r.lk.Unlock(); - $s = -1; return n; - /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Int63 }; } $f._r = _r; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.prototype.Int63 = function() { return this.$val.Int63(); }; - lockedSource.ptr.prototype.Uint64 = function() { - var _r, n, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = new $Uint64(0, 0); - r = this; - r.lk.Lock(); - _r = r.src.Uint64(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - n = _r; - r.lk.Unlock(); - $s = -1; return n; - /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Uint64 }; } $f._r = _r; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.prototype.Uint64 = function() { return this.$val.Uint64(); }; - lockedSource.ptr.prototype.Seed = function(seed) { - var r, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - r.lk.Lock(); - $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - r.lk.Unlock(); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Seed }; } $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; - lockedSource.ptr.prototype.seedPos = function(seed, readPos) { - var r, readPos, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; r = $f.r; readPos = $f.readPos; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - r.lk.Lock(); - $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - readPos.$set(0); - r.lk.Unlock(); - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.seedPos }; } $f.r = r; $f.readPos = readPos; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.prototype.seedPos = function(seed, readPos) { return this.$val.seedPos(seed, readPos); }; - lockedSource.ptr.prototype.read = function(p, readVal, readPos) { - var _r, _tuple, err, n, p, r, readPos, readVal, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; n = $f.n; p = $f.p; r = $f.r; readPos = $f.readPos; readVal = $f.readVal; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = 0; - err = $ifaceNil; - r = this; - r.lk.Lock(); - _r = read(p, $methodVal(r.src, "Int63"), readVal, readPos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - n = _tuple[0]; - err = _tuple[1]; - r.lk.Unlock(); - $s = -1; return [n, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.read }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.n = n; $f.p = p; $f.r = r; $f.readPos = readPos; $f.readVal = readVal; $f.$s = $s; $f.$r = $r; return $f; - }; - lockedSource.prototype.read = function(p, readVal, readPos) { return this.$val.read(p, readVal, readPos); }; - seedrand = function(x) { - var _q, _r, hi, lo, x; - hi = (_q = x / 44488, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - lo = (_r = x % 44488, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); - x = ($imul(48271, lo)) - ($imul(3399, hi)) >> 0; - if (x < 0) { - x = x + (2147483647) >> 0; - } - return x; - }; - rngSource.ptr.prototype.Seed = function(seed) { - var i, rng, seed, u, x, x$1, x$2, x$3, x$4, x$5; - rng = this; - rng.tap = 0; - rng.feed = 334; - seed = $div64(seed, new $Int64(0, 2147483647), true); - if ((seed.$high < 0 || (seed.$high === 0 && seed.$low < 0))) { - seed = (x = new $Int64(0, 2147483647), new $Int64(seed.$high + x.$high, seed.$low + x.$low)); - } - if ((seed.$high === 0 && seed.$low === 0)) { - seed = new $Int64(0, 89482311); - } - x$1 = (((seed.$low + ((seed.$high >> 31) * 4294967296)) >> 0)); - i = -20; - while (true) { - if (!(i < 607)) { break; } - x$1 = seedrand(x$1); - if (i >= 0) { - u = new $Int64(0, 0); - u = $shiftLeft64((new $Int64(0, x$1)), 40); - x$1 = seedrand(x$1); - u = (x$2 = $shiftLeft64((new $Int64(0, x$1)), 20), new $Int64(u.$high ^ x$2.$high, (u.$low ^ x$2.$low) >>> 0)); - x$1 = seedrand(x$1); - u = (x$3 = (new $Int64(0, x$1)), new $Int64(u.$high ^ x$3.$high, (u.$low ^ x$3.$low) >>> 0)); - u = (x$4 = ((i < 0 || i >= rngCooked.length) ? ($throwRuntimeError("index out of range"), undefined) : rngCooked[i]), new $Int64(u.$high ^ x$4.$high, (u.$low ^ x$4.$low) >>> 0)); - (x$5 = rng.vec, ((i < 0 || i >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i] = u)); - } - i = i + (1) >> 0; - } - }; - rngSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); }; - rngSource.ptr.prototype.Int63 = function() { - var rng, x, x$1; - rng = this; - return ((x = (x$1 = rng.Uint64(), new $Uint64(x$1.$high & 2147483647, (x$1.$low & 4294967295) >>> 0)), new $Int64(x.$high, x.$low))); - }; - rngSource.prototype.Int63 = function() { return this.$val.Int63(); }; - rngSource.ptr.prototype.Uint64 = function() { - var rng, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; - rng = this; - rng.tap = rng.tap - (1) >> 0; - if (rng.tap < 0) { - rng.tap = rng.tap + (607) >> 0; - } - rng.feed = rng.feed - (1) >> 0; - if (rng.feed < 0) { - rng.feed = rng.feed + (607) >> 0; - } - x$6 = (x = (x$1 = rng.vec, x$2 = rng.feed, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2])), x$3 = (x$4 = rng.vec, x$5 = rng.tap, ((x$5 < 0 || x$5 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[x$5])), new $Int64(x.$high + x$3.$high, x.$low + x$3.$low)); - (x$7 = rng.vec, x$8 = rng.feed, ((x$8 < 0 || x$8 >= x$7.length) ? ($throwRuntimeError("index out of range"), undefined) : x$7[x$8] = x$6)); - return (new $Uint64(x$6.$high, x$6.$low)); - }; - rngSource.prototype.Uint64 = function() { return this.$val.Uint64(); }; - ptrType$3.methods = [{prop: "ExpFloat64", name: "ExpFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "NormFloat64", name: "NormFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([], [$Uint32], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Int31", name: "Int31", pkg: "", typ: $funcType([], [$Int32], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int63n", name: "Int63n", pkg: "", typ: $funcType([$Int64], [$Int64], false)}, {prop: "Int31n", name: "Int31n", pkg: "", typ: $funcType([$Int32], [$Int32], false)}, {prop: "int31n", name: "int31n", pkg: "math/rand", typ: $funcType([$Int32], [$Int32], false)}, {prop: "Intn", name: "Intn", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([$Int], [sliceType], false)}, {prop: "Shuffle", name: "Shuffle", pkg: "", typ: $funcType([$Int, funcType], [], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}]; - ptrType.methods = [{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "seedPos", name: "seedPos", pkg: "math/rand", typ: $funcType([$Int64, ptrType$1], [], false)}, {prop: "read", name: "read", pkg: "math/rand", typ: $funcType([sliceType$1, ptrType$2, ptrType$1], [$Int, $error], false)}]; - ptrType$5.methods = [{prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}]; - Source.init([{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}]); - Source64.init([{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}]); - Rand.init("math/rand", [{prop: "src", name: "src", embedded: false, exported: false, typ: Source, tag: ""}, {prop: "s64", name: "s64", embedded: false, exported: false, typ: Source64, tag: ""}, {prop: "readVal", name: "readVal", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "readPos", name: "readPos", embedded: false, exported: false, typ: $Int8, tag: ""}]); - lockedSource.init("math/rand", [{prop: "lk", name: "lk", embedded: false, exported: false, typ: nosync.Mutex, tag: ""}, {prop: "src", name: "src", embedded: false, exported: false, typ: Source64, tag: ""}]); - rngSource.init("math/rand", [{prop: "tap", name: "tap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "feed", name: "feed", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "vec", name: "vec", embedded: false, exported: false, typ: arrayType, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = nosync.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - ke = $toNativeArray($kindUint32, [3801129273, 0, 2615860924, 3279400049, 3571300752, 3733536696, 3836274812, 3906990442, 3958562475, 3997804264, 4028649213, 4053523342, 4074002619, 4091154507, 4105727352, 4118261130, 4129155133, 4138710916, 4147160435, 4154685009, 4161428406, 4167506077, 4173011791, 4178022498, 4182601930, 4186803325, 4190671498, 4194244443, 4197554582, 4200629752, 4203493986, 4206168142, 4208670408, 4211016720, 4213221098, 4215295924, 4217252177, 4219099625, 4220846988, 4222502074, 4224071896, 4225562770, 4226980400, 4228329951, 4229616109, 4230843138, 4232014925, 4233135020, 4234206673, 4235232866, 4236216336, 4237159604, 4238064994, 4238934652, 4239770563, 4240574564, 4241348362, 4242093539, 4242811568, 4243503822, 4244171579, 4244816032, 4245438297, 4246039419, 4246620374, 4247182079, 4247725394, 4248251127, 4248760037, 4249252839, 4249730206, 4250192773, 4250641138, 4251075867, 4251497493, 4251906522, 4252303431, 4252688672, 4253062674, 4253425844, 4253778565, 4254121205, 4254454110, 4254777611, 4255092022, 4255397640, 4255694750, 4255983622, 4256264513, 4256537670, 4256803325, 4257061702, 4257313014, 4257557464, 4257795244, 4258026541, 4258251531, 4258470383, 4258683258, 4258890309, 4259091685, 4259287526, 4259477966, 4259663135, 4259843154, 4260018142, 4260188212, 4260353470, 4260514019, 4260669958, 4260821380, 4260968374, 4261111028, 4261249421, 4261383632, 4261513736, 4261639802, 4261761900, 4261880092, 4261994441, 4262105003, 4262211835, 4262314988, 4262414513, 4262510454, 4262602857, 4262691764, 4262777212, 4262859239, 4262937878, 4263013162, 4263085118, 4263153776, 4263219158, 4263281289, 4263340187, 4263395872, 4263448358, 4263497660, 4263543789, 4263586755, 4263626565, 4263663224, 4263696735, 4263727099, 4263754314, 4263778377, 4263799282, 4263817020, 4263831582, 4263842955, 4263851124, 4263856071, 4263857776, 4263856218, 4263851370, 4263843206, 4263831695, 4263816804, 4263798497, 4263776735, 4263751476, 4263722676, 4263690284, 4263654251, 4263614520, 4263571032, 4263523724, 4263472530, 4263417377, 4263358192, 4263294892, 4263227394, 4263155608, 4263079437, 4262998781, 4262913534, 4262823581, 4262728804, 4262629075, 4262524261, 4262414220, 4262298801, 4262177846, 4262051187, 4261918645, 4261780032, 4261635148, 4261483780, 4261325704, 4261160681, 4260988457, 4260808763, 4260621313, 4260425802, 4260221905, 4260009277, 4259787550, 4259556329, 4259315195, 4259063697, 4258801357, 4258527656, 4258242044, 4257943926, 4257632664, 4257307571, 4256967906, 4256612870, 4256241598, 4255853155, 4255446525, 4255020608, 4254574202, 4254106002, 4253614578, 4253098370, 4252555662, 4251984571, 4251383021, 4250748722, 4250079132, 4249371435, 4248622490, 4247828790, 4246986404, 4246090910, 4245137315, 4244119963, 4243032411, 4241867296, 4240616155, 4239269214, 4237815118, 4236240596, 4234530035, 4232664930, 4230623176, 4228378137, 4225897409, 4223141146, 4220059768, 4216590757, 4212654085, 4208145538, 4202926710, 4196809522, 4189531420, 4180713890, 4169789475, 4155865042, 4137444620, 4111806704, 4073393724, 4008685917, 3873074895]); - we = $toNativeArray($kindFloat32, [2.0249555365836613e-09, 1.4866739783681027e-11, 2.4409616689036184e-11, 3.1968806074589295e-11, 3.844677007314168e-11, 4.42282044321729e-11, 4.951644302919611e-11, 5.443358958023836e-11, 5.905943789574764e-11, 6.34494193296753e-11, 6.764381416113352e-11, 7.167294535648239e-11, 7.556032188826833e-11, 7.932458162551725e-11, 8.298078890689453e-11, 8.654132271912474e-11, 9.001651507523079e-11, 9.341507428706208e-11, 9.674443190998971e-11, 1.0001099254308699e-10, 1.0322031424037093e-10, 1.0637725422757427e-10, 1.0948611461891744e-10, 1.1255067711157807e-10, 1.1557434870246297e-10, 1.1856014781042035e-10, 1.2151082917633005e-10, 1.2442885610752796e-10, 1.2731647680563896e-10, 1.3017574518325858e-10, 1.330085347417409e-10, 1.3581656632677408e-10, 1.386014220061682e-10, 1.413645728254309e-10, 1.4410737880776736e-10, 1.4683107507629245e-10, 1.4953686899854546e-10, 1.522258291641876e-10, 1.5489899640730442e-10, 1.575573282952547e-10, 1.6020171300645814e-10, 1.628330109637588e-10, 1.6545202707884954e-10, 1.68059510752272e-10, 1.7065616975120435e-10, 1.73242697965037e-10, 1.758197337720091e-10, 1.783878739169964e-10, 1.8094774290045024e-10, 1.834998542005195e-10, 1.8604476292871652e-10, 1.8858298256319017e-10, 1.9111498494872592e-10, 1.9364125580789704e-10, 1.9616222535212557e-10, 1.9867835154840918e-10, 2.011900368525943e-10, 2.0369768372052732e-10, 2.062016807302669e-10, 2.0870240258208383e-10, 2.1120022397624894e-10, 2.136955057352452e-10, 2.1618855317040442e-10, 2.1867974098199738e-10, 2.2116936060356807e-10, 2.2365774510202385e-10, 2.2614519978869652e-10, 2.2863201609713002e-10, 2.3111849933865614e-10, 2.3360494094681883e-10, 2.3609159072179864e-10, 2.3857874009713953e-10, 2.4106666662859766e-10, 2.4355562011635357e-10, 2.460458781161634e-10, 2.485376904282077e-10, 2.5103127909709144e-10, 2.5352694943414633e-10, 2.560248957284017e-10, 2.585253955356137e-10, 2.610286709003873e-10, 2.6353494386732734e-10, 2.6604446423661443e-10, 2.6855745405285347e-10, 2.71074163116225e-10, 2.7359478571575835e-10, 2.7611959940720965e-10, 2.786487707240326e-10, 2.8118254946640775e-10, 2.8372118543451563e-10, 2.8626484516180994e-10, 2.8881380620404684e-10, 2.9136826285025563e-10, 2.9392840938946563e-10, 2.96494523377433e-10, 2.990667713476114e-10, 3.016454031001814e-10, 3.042306406797479e-10, 3.068226783753403e-10, 3.09421765987139e-10, 3.12028125559749e-10, 3.1464195138219964e-10, 3.17263521010247e-10, 3.1989300097734485e-10, 3.225306410836737e-10, 3.2517669112941405e-10, 3.2783134540359526e-10, 3.3049485370639786e-10, 3.3316743808242677e-10, 3.3584937608743815e-10, 3.385408342548857e-10, 3.4124211789610115e-10, 3.4395342130011386e-10, 3.4667499426710435e-10, 3.494071143528288e-10, 3.521500313574677e-10, 3.54903967325626e-10, 3.576691720574843e-10, 3.6044595086437425e-10, 3.632345535464765e-10, 3.660352021483959e-10, 3.688482297370399e-10, 3.716738583570134e-10, 3.7451239331964814e-10, 3.773641121807003e-10, 3.802292924959261e-10, 3.831082673322328e-10, 3.8600128648980103e-10, 3.8890865527996255e-10, 3.9183070676962473e-10, 3.9476774627011935e-10, 3.977200790927782e-10, 4.006880383045086e-10, 4.0367195697221803e-10, 4.066721681628138e-10, 4.0968900494320337e-10, 4.127228558914453e-10, 4.15774054074447e-10, 4.188429603146915e-10, 4.2192993543466173e-10, 4.25035395767992e-10, 4.2815970213716525e-10, 4.313032986313914e-10, 4.3446651831757777e-10, 4.376498607960855e-10, 4.408536868893975e-10, 4.4407846844229937e-10, 4.4732464954400086e-10, 4.5059267428371186e-10, 4.538830145062178e-10, 4.5719619756745544e-10, 4.605326675566346e-10, 4.638929240741163e-10, 4.672775499869886e-10, 4.706869893844612e-10, 4.74121908400349e-10, 4.775827511238617e-10, 4.810701836888143e-10, 4.845848167178701e-10, 4.881271498113904e-10, 4.916979601254923e-10, 4.952977472605369e-10, 4.989272883726414e-10, 5.025872495956207e-10, 5.062783525744408e-10, 5.100013189540675e-10, 5.13756870379467e-10, 5.175458395179078e-10, 5.21369003525507e-10, 5.252272505806843e-10, 5.29121357839557e-10, 5.330522134805449e-10, 5.3702081670437e-10, 5.41028055689452e-10, 5.450749851476644e-10, 5.491624932574268e-10, 5.532918012640664e-10, 5.574638528571541e-10, 5.616799247931681e-10, 5.659410717839819e-10, 5.702485705860738e-10, 5.746036979559221e-10, 5.790077306500052e-10, 5.83462111958255e-10, 5.879682296594524e-10, 5.925275825546805e-10, 5.971417249561739e-10, 6.01812211176167e-10, 6.065408175714992e-10, 6.113292094767075e-10, 6.16179329782085e-10, 6.21092954844471e-10, 6.260721940876124e-10, 6.311191569352559e-10, 6.362359528111483e-10, 6.414249686947926e-10, 6.466885360545405e-10, 6.520292639144998e-10, 6.574497612987784e-10, 6.629528592760892e-10, 6.685415554485985e-10, 6.742187919073217e-10, 6.799880103436351e-10, 6.858525969377638e-10, 6.918161599145378e-10, 6.978825850545434e-10, 7.040559801829716e-10, 7.103406751696184e-10, 7.167412219288849e-10, 7.232625609532306e-10, 7.2990985477972e-10, 7.366885990123251e-10, 7.436047333442275e-10, 7.506645305355164e-10, 7.57874762946642e-10, 7.652426470272644e-10, 7.727759543385559e-10, 7.804830115532013e-10, 7.883728114777e-10, 7.964550685635174e-10, 8.047402189070851e-10, 8.132396422944055e-10, 8.219657177122031e-10, 8.309318788590758e-10, 8.401527806789488e-10, 8.496445214056791e-10, 8.594246980742071e-10, 8.695127395874636e-10, 8.799300732498239e-10, 8.90700457834015e-10, 9.01850316648023e-10, 9.134091816243028e-10, 9.254100818978372e-10, 9.37890431984556e-10, 9.508922538259412e-10, 9.64463842123564e-10, 9.78660263939446e-10, 9.935448019859905e-10, 1.0091912860943353e-09, 1.0256859805934937e-09, 1.0431305819125214e-09, 1.0616465484503124e-09, 1.0813799855569073e-09, 1.1025096391392708e-09, 1.1252564435793033e-09, 1.149898620766976e-09, 1.176793218427008e-09, 1.2064089727203964e-09, 1.2393785997488749e-09, 1.2765849488616254e-09, 1.319313880365769e-09, 1.36954347862428e-09, 1.4305497897382224e-09, 1.5083649884672923e-09, 1.6160853766322703e-09, 1.7921247819074893e-09]); - fe = $toNativeArray($kindFloat32, [1, 0.9381436705589294, 0.900469958782196, 0.8717043399810791, 0.847785472869873, 0.8269932866096497, 0.8084216713905334, 0.7915276288986206, 0.7759568691253662, 0.7614634037017822, 0.7478685975074768, 0.7350381016731262, 0.7228676676750183, 0.7112747430801392, 0.7001926302909851, 0.6895664930343628, 0.6793505549430847, 0.669506311416626, 0.6600008606910706, 0.6508058309555054, 0.6418967247009277, 0.633251965045929, 0.62485271692276, 0.6166821718215942, 0.608725368976593, 0.6009689569473267, 0.5934008955955505, 0.5860103368759155, 0.5787873864173889, 0.5717230439186096, 0.5648092031478882, 0.5580382943153381, 0.5514034032821655, 0.5448982119560242, 0.5385168790817261, 0.5322538614273071, 0.526104211807251, 0.5200631618499756, 0.5141264200210571, 0.5082897543907166, 0.5025495290756226, 0.4969019889831543, 0.4913438558578491, 0.4858720004558563, 0.48048335313796997, 0.4751752018928528, 0.4699448347091675, 0.4647897481918335, 0.4597076177597046, 0.4546961486339569, 0.4497532546520233, 0.44487687945365906, 0.4400651156902313, 0.4353161156177521, 0.4306281507015228, 0.42599955201148987, 0.42142874002456665, 0.4169141948223114, 0.4124544560909271, 0.40804818272590637, 0.4036940038204193, 0.39939069747924805, 0.3951369822025299, 0.39093172550201416, 0.38677382469177246, 0.38266217708587646, 0.378595769405365, 0.37457355856895447, 0.37059465050697327, 0.366658091545105, 0.362762987613678, 0.358908474445343, 0.35509374737739563, 0.35131800174713135, 0.3475804924964905, 0.34388044476509094, 0.34021714329719543, 0.33658990263938904, 0.3329980671405792, 0.3294409513473511, 0.32591795921325684, 0.32242849469184875, 0.3189719021320343, 0.3155476748943329, 0.31215524673461914, 0.3087940812110901, 0.30546361207962036, 0.30216339230537415, 0.29889291524887085, 0.29565170407295227, 0.2924392819404602, 0.2892552316188812, 0.28609907627105713, 0.2829704284667969, 0.27986884117126465, 0.2767939269542694, 0.2737452983856201, 0.2707225978374481, 0.26772540807724, 0.26475343108177185, 0.2618062496185303, 0.258883535861969, 0.2559850215911865, 0.25311028957366943, 0.25025907158851624, 0.24743106961250305, 0.2446259707212448, 0.24184346199035645, 0.23908329010009766, 0.23634515702724457, 0.2336287796497345, 0.23093391954898834, 0.22826029360294342, 0.22560766339302063, 0.22297576069831848, 0.22036437690258026, 0.21777324378490448, 0.21520215272903442, 0.212650865316391, 0.21011915802955627, 0.20760682225227356, 0.20511364936828613, 0.20263944566249847, 0.20018397271633148, 0.19774706661701202, 0.1953285187482834, 0.19292815029621124, 0.19054576754570007, 0.18818120658397675, 0.18583425879478455, 0.18350479006767273, 0.18119260668754578, 0.17889754474163055, 0.17661945521831512, 0.17435817420482635, 0.1721135377883911, 0.16988539695739746, 0.16767361760139465, 0.16547803580760956, 0.16329853236675262, 0.16113494336605072, 0.1589871346950531, 0.15685498714447021, 0.15473836660385132, 0.15263713896274567, 0.1505511850118637, 0.1484803706407547, 0.14642459154129028, 0.1443837285041809, 0.14235764741897583, 0.1403462439775467, 0.13834942877292633, 0.136367067694664, 0.13439907133579254, 0.1324453204870224, 0.1305057406425476, 0.12858019769191742, 0.12666863203048706, 0.12477091699838638, 0.12288697808980942, 0.1210167184472084, 0.11916005611419678, 0.11731690168380737, 0.11548716574907303, 0.11367076635360718, 0.11186762899160385, 0.11007767915725708, 0.1083008274435997, 0.10653700679540634, 0.10478614270687103, 0.1030481606721878, 0.10132300108671188, 0.0996105819940567, 0.09791085124015808, 0.09622374176979065, 0.09454918652772903, 0.09288713335990906, 0.09123751521110535, 0.08960027992725372, 0.08797537535429001, 0.08636274188756943, 0.0847623273730278, 0.08317409455776215, 0.08159798383712769, 0.08003395050764084, 0.07848194986581802, 0.07694194465875626, 0.07541389018297195, 0.07389774918556213, 0.07239348441362381, 0.070901058614254, 0.06942043453454971, 0.06795158982276917, 0.06649449467658997, 0.06504911929368973, 0.06361543387174606, 0.06219341605901718, 0.06078304722905159, 0.0593843050301075, 0.05799717456102371, 0.05662164092063904, 0.05525768920779228, 0.05390531197190285, 0.05256449431180954, 0.05123523622751236, 0.04991753399372101, 0.04861138388514519, 0.047316793352365494, 0.04603376239538193, 0.044762298464775085, 0.04350241273641586, 0.04225412383675575, 0.04101744294166565, 0.039792392402887344, 0.03857899457216263, 0.03737728297710419, 0.03618728369474411, 0.03500903770327568, 0.03384258225560188, 0.0326879620552063, 0.031545232981443405, 0.030414443463087082, 0.0292956605553627, 0.028188949450850487, 0.027094384655356407, 0.02601204626262188, 0.024942025542259216, 0.023884421214461327, 0.022839335724711418, 0.021806888282299042, 0.020787203684449196, 0.019780423492193222, 0.018786700442433357, 0.017806200310587883, 0.016839107498526573, 0.015885621309280396, 0.014945968054234982, 0.01402039173990488, 0.013109165243804455, 0.012212592177093029, 0.011331013403832912, 0.010464809834957123, 0.009614413604140282, 0.008780314587056637, 0.007963077165186405, 0.007163353264331818, 0.0063819061033427715, 0.005619642324745655, 0.004877655766904354, 0.004157294984906912, 0.003460264764726162, 0.0027887988835573196, 0.0021459676790982485, 0.001536299823783338, 0.0009672692976891994, 0.0004541343660093844]); - kn = $toNativeArray($kindUint32, [1991057938, 0, 1611602771, 1826899878, 1918584482, 1969227037, 2001281515, 2023368125, 2039498179, 2051788381, 2061460127, 2069267110, 2075699398, 2081089314, 2085670119, 2089610331, 2093034710, 2096037586, 2098691595, 2101053571, 2103168620, 2105072996, 2106796166, 2108362327, 2109791536, 2111100552, 2112303493, 2113412330, 2114437283, 2115387130, 2116269447, 2117090813, 2117856962, 2118572919, 2119243101, 2119871411, 2120461303, 2121015852, 2121537798, 2122029592, 2122493434, 2122931299, 2123344971, 2123736059, 2124106020, 2124456175, 2124787725, 2125101763, 2125399283, 2125681194, 2125948325, 2126201433, 2126441213, 2126668298, 2126883268, 2127086657, 2127278949, 2127460589, 2127631985, 2127793506, 2127945490, 2128088244, 2128222044, 2128347141, 2128463758, 2128572095, 2128672327, 2128764606, 2128849065, 2128925811, 2128994934, 2129056501, 2129110560, 2129157136, 2129196237, 2129227847, 2129251929, 2129268426, 2129277255, 2129278312, 2129271467, 2129256561, 2129233410, 2129201800, 2129161480, 2129112170, 2129053545, 2128985244, 2128906855, 2128817916, 2128717911, 2128606255, 2128482298, 2128345305, 2128194452, 2128028813, 2127847342, 2127648860, 2127432031, 2127195339, 2126937058, 2126655214, 2126347546, 2126011445, 2125643893, 2125241376, 2124799783, 2124314271, 2123779094, 2123187386, 2122530867, 2121799464, 2120980787, 2120059418, 2119015917, 2117825402, 2116455471, 2114863093, 2112989789, 2110753906, 2108037662, 2104664315, 2100355223, 2094642347, 2086670106, 2074676188, 2054300022, 2010539237]); - wn = $toNativeArray($kindFloat32, [1.7290404663583558e-09, 1.2680928529462676e-10, 1.689751810696194e-10, 1.9862687883343e-10, 2.223243117382978e-10, 2.4244936613904144e-10, 2.601613091623989e-10, 2.761198769629658e-10, 2.9073962681813725e-10, 3.042996965518796e-10, 3.169979556627567e-10, 3.289802041894774e-10, 3.4035738116777736e-10, 3.5121602848242617e-10, 3.61625090983253e-10, 3.7164057942185025e-10, 3.813085680537398e-10, 3.906675816178762e-10, 3.997501218933053e-10, 4.0858399996679395e-10, 4.1719308563337165e-10, 4.255982233303257e-10, 4.3381759295968436e-10, 4.4186720948857783e-10, 4.497613115272969e-10, 4.57512583373898e-10, 4.6513240481438345e-10, 4.726310454117311e-10, 4.800177477726209e-10, 4.873009773476156e-10, 4.944885056978876e-10, 5.015873272284921e-10, 5.086040477664255e-10, 5.155446070048697e-10, 5.224146670812502e-10, 5.292193350214802e-10, 5.359634958068682e-10, 5.426517013518151e-10, 5.492881705038144e-10, 5.558769555769061e-10, 5.624218868405251e-10, 5.689264614971989e-10, 5.75394121238304e-10, 5.818281967329142e-10, 5.882316855831959e-10, 5.946076964136182e-10, 6.009590047817426e-10, 6.072883862451306e-10, 6.135985053390414e-10, 6.19892026598734e-10, 6.261713370037114e-10, 6.324390455780815e-10, 6.386973727678935e-10, 6.449488165749528e-10, 6.511955974453087e-10, 6.574400468473129e-10, 6.636843297158634e-10, 6.699307220081607e-10, 6.761814441702541e-10, 6.824387166481927e-10, 6.887046488657234e-10, 6.949815167800466e-10, 7.012714853260604e-10, 7.075767749498141e-10, 7.13899661608508e-10, 7.202424212593428e-10, 7.266072743483676e-10, 7.329966078550854e-10, 7.394128087589991e-10, 7.458582640396116e-10, 7.523354716987285e-10, 7.588469852493063e-10, 7.653954137154528e-10, 7.719834771435785e-10, 7.786139510912449e-10, 7.852897221383159e-10, 7.920137878869582e-10, 7.987892014504894e-10, 8.056192379868321e-10, 8.125072836762115e-10, 8.194568912323064e-10, 8.264716688799467e-10, 8.3355555791087e-10, 8.407127216614185e-10, 8.479473234679347e-10, 8.552640262671218e-10, 8.626675485068347e-10, 8.701631637464402e-10, 8.777562010564566e-10, 8.854524335966119e-10, 8.932581896381464e-10, 9.011799639857543e-10, 9.092249730890956e-10, 9.174008219758889e-10, 9.25715837318819e-10, 9.341788453909317e-10, 9.42799727177146e-10, 9.515889187738935e-10, 9.605578554783278e-10, 9.697193048552322e-10, 9.790869226478094e-10, 9.886760299337993e-10, 9.985036131254788e-10, 1.008588212947359e-09, 1.0189509236369076e-09, 1.0296150598776421e-09, 1.040606933955246e-09, 1.0519566329136865e-09, 1.0636980185552147e-09, 1.0758701707302976e-09, 1.0885182755160372e-09, 1.101694735439196e-09, 1.115461056855338e-09, 1.1298901814171813e-09, 1.1450695946990663e-09, 1.1611052119775422e-09, 1.178127595480305e-09, 1.1962995039027646e-09, 1.2158286599728285e-09, 1.2369856250415978e-09, 1.2601323318151003e-09, 1.2857697129220469e-09, 1.3146201904845611e-09, 1.3477839955200466e-09, 1.3870635751089821e-09, 1.43574030442295e-09, 1.5008658760251592e-09, 1.6030947680434338e-09]); - fn = $toNativeArray($kindFloat32, [1, 0.963599681854248, 0.9362826943397522, 0.9130436182022095, 0.8922816514968872, 0.8732430338859558, 0.8555005788803101, 0.8387836217880249, 0.8229072093963623, 0.8077383041381836, 0.7931770086288452, 0.7791460752487183, 0.7655841708183289, 0.7524415850639343, 0.7396772503852844, 0.7272568941116333, 0.7151514887809753, 0.7033361196517944, 0.6917891502380371, 0.6804918646812439, 0.6694276928901672, 0.6585819721221924, 0.6479418277740479, 0.6374954581260681, 0.6272324919700623, 0.6171433925628662, 0.6072195172309875, 0.5974531769752502, 0.5878370404243469, 0.5783646702766418, 0.5690299868583679, 0.5598273873329163, 0.550751805305481, 0.5417983531951904, 0.5329626798629761, 0.5242405533790588, 0.5156282186508179, 0.5071220397949219, 0.49871864914894104, 0.4904148280620575, 0.48220765590667725, 0.47409430146217346, 0.466072142124176, 0.45813870429992676, 0.45029163360595703, 0.44252872467041016, 0.4348478317260742, 0.42724698781967163, 0.41972434520721436, 0.41227802634239197, 0.40490642189979553, 0.39760786294937134, 0.3903807997703552, 0.3832238018512726, 0.3761354684829712, 0.3691144585609436, 0.36215949058532715, 0.3552693724632263, 0.3484429717063904, 0.3416791558265686, 0.33497685194015503, 0.32833510637283325, 0.3217529058456421, 0.3152293860912323, 0.30876362323760986, 0.3023548424243927, 0.2960021495819092, 0.2897048592567444, 0.28346219658851624, 0.2772735059261322, 0.271138072013855, 0.2650552988052368, 0.25902456045150757, 0.25304529070854187, 0.24711695313453674, 0.24123899638652802, 0.23541094362735748, 0.22963231801986694, 0.22390270233154297, 0.21822164952754974, 0.21258877217769623, 0.20700371265411377, 0.20146611332893372, 0.1959756463766098, 0.19053204357624054, 0.18513499200344086, 0.17978426814079285, 0.1744796335697174, 0.16922089457511902, 0.16400785744190216, 0.1588403731584549, 0.15371830761432648, 0.14864157140254974, 0.14361007511615753, 0.13862377405166626, 0.13368265330791473, 0.12878671288490295, 0.12393598258495331, 0.11913054436445236, 0.11437050998210907, 0.10965602099895477, 0.1049872562289238, 0.10036443918943405, 0.09578784555196762, 0.09125780314207077, 0.08677466958761215, 0.08233889937400818, 0.07795098423957825, 0.07361150532960892, 0.06932111829519272, 0.06508058309555054, 0.06089077144861221, 0.05675266310572624, 0.05266740173101425, 0.048636294901371, 0.044660862535238266, 0.040742866694927216, 0.03688438981771469, 0.03308788686990738, 0.029356317594647408, 0.025693291798233986, 0.02210330404341221, 0.018592102453112602, 0.015167297795414925, 0.011839478276669979, 0.0086244847625494, 0.005548994988203049, 0.0026696291752159595]); - rngCooked = $toNativeArray($kindInt64, [new $Int64(-973649357, 3952672746), new $Int64(-1065661887, 3130416987), new $Int64(324977939, 3414273807), new $Int64(1241840476, 2806224363), new $Int64(-1477934308, 1997590414), new $Int64(2103305448, 2402795971), new $Int64(1663160183, 1140819369), new $Int64(1120601685, 1788868961), new $Int64(1848035537, 1089001426), new $Int64(1235702047, 873593504), new $Int64(1911387977, 581324885), new $Int64(-1654874170, 1609182556), new $Int64(1069394745, 1241596776), new $Int64(1895445337, 1771189259), new $Int64(-1374618802, 3467012610), new $Int64(-140526423, 2344407434), new $Int64(-1745367887, 782467244), new $Int64(26335124, 3404933915), new $Int64(1063924276, 618867887), new $Int64(-968700782, 520164395), new $Int64(-1591572833, 1341358184), new $Int64(-1515085039, 665794848), new $Int64(1527227641, 3183648150), new $Int64(1781176124, 696329606), new $Int64(1789146075, 4151988961), new $Int64(-2087444114, 998951326), new $Int64(-612324923, 1364957564), new $Int64(63173359, 4090230633), new $Int64(-1498029007, 4009697548), new $Int64(248009524, 2569622517), new $Int64(778703922, 3742421481), new $Int64(-1109106023, 1506914633), new $Int64(1738099768, 1983412561), new $Int64(236311649, 1436266083), new $Int64(-1111517500, 3922894967), new $Int64(-1336974714, 1792680179), new $Int64(563141142, 1188796351), new $Int64(1349617468, 405968250), new $Int64(1044074554, 433754187), new $Int64(870549669, 4073162024), new $Int64(-1094251604, 433121399), new $Int64(2451824, 4162580594), new $Int64(-137262572, 4132415622), new $Int64(-1536231048, 3033822028), new $Int64(2016407895, 824682382), new $Int64(2366218, 3583765414), new $Int64(-624604839, 535386927), new $Int64(1637219058, 2286693689), new $Int64(1453075389, 2968466525), new $Int64(193683513, 1351410206), new $Int64(-283806096, 1412813499), new $Int64(492736522, 4126267639), new $Int64(512765208, 2105529399), new $Int64(2132966268, 2413882233), new $Int64(947457634, 32226200), new $Int64(1149341356, 2032329073), new $Int64(106485445, 1356518208), new $Int64(-2067810156, 3430061722), new $Int64(-1484435135, 3820169661), new $Int64(-1665985194, 2981816134), new $Int64(1017155588, 4184371017), new $Int64(206574701, 2119206761), new $Int64(-852109057, 2472200560), new $Int64(-560457548, 2853524696), new $Int64(1307803389, 1681119904), new $Int64(-174986835, 95608918), new $Int64(392686347, 3690479145), new $Int64(-1205570926, 1397922290), new $Int64(-1159314025, 1516129515), new $Int64(-320178155, 1547420459), new $Int64(1311333971, 1470949486), new $Int64(-1953469798, 1336785672), new $Int64(-45086614, 4131677129), new $Int64(-1392278100, 4246329084), new $Int64(-1142500187, 3788585631), new $Int64(-66478285, 3080389532), new $Int64(-646438364, 2215402037), new $Int64(391002300, 1171593935), new $Int64(1408774047, 1423855166), new $Int64(-519177718, 2276716302), new $Int64(-368453140, 2068027241), new $Int64(1369359303, 3427553297), new $Int64(189241615, 3289637845), new $Int64(1057480830, 3486407650), new $Int64(-1512910664, 3071877822), new $Int64(1159653919, 3363620705), new $Int64(-934256930, 4159821533), new $Int64(-76621938, 1894661), new $Int64(-674493898, 1156868282), new $Int64(348271067, 776219088), new $Int64(-501428838, 2425634259), new $Int64(1716021749, 680510161), new $Int64(-574263456, 1310101429), new $Int64(1095885995, 2964454134), new $Int64(-325695512, 3467098407), new $Int64(1990672920, 2109628894), new $Int64(-2139648704, 1232604732), new $Int64(-1838070714, 3261916179), new $Int64(1699175360, 434597899), new $Int64(235436061, 1624796439), new $Int64(-1626402839, 3589632480), new $Int64(1198416575, 864579159), new $Int64(-1938748161, 1380889830), new $Int64(619206309, 2654509477), new $Int64(1419738251, 1468209306), new $Int64(-1744284772, 100794388), new $Int64(-1191421458, 2991674471), new $Int64(-208666741, 2224662036), new $Int64(-173659161, 977097250), new $Int64(1351320195, 726419512), new $Int64(-183459897, 1747974366), new $Int64(-753095183, 1556430604), new $Int64(-1049492215, 1080776742), new $Int64(-385846958, 280794874), new $Int64(117767733, 919835643), new $Int64(-967009426, 3434019658), new $Int64(-1951414480, 2461941785), new $Int64(133215641, 3615001066), new $Int64(417204809, 3103414427), new $Int64(790056561, 3380809712), new $Int64(-1267681408, 2724693469), new $Int64(547796833, 598827710), new $Int64(-1846559452, 3452273442), new $Int64(-75778224, 649274915), new $Int64(-801301329, 2585724112), new $Int64(-1510934263, 3165579553), new $Int64(1185578221, 2635894283), new $Int64(-52910178, 2053289721), new $Int64(985976581, 3169337108), new $Int64(1170569632, 144717764), new $Int64(1079216270, 1383666384), new $Int64(-124804942, 681540375), new $Int64(1375448925, 537050586), new $Int64(-1964768344, 315246468), new $Int64(226402871, 849323088), new $Int64(-885062465, 45543944), new $Int64(-946445250, 2319052083), new $Int64(-40708194, 3613090841), new $Int64(560472520, 2992171180), new $Int64(-381863169, 2068244785), new $Int64(917538188, 4239862634), new $Int64(-1369555809, 3892253031), new $Int64(720683925, 958186149), new $Int64(-423297785, 1877702262), new $Int64(1357886971, 837674867), new $Int64(1837048883, 1507589294), new $Int64(1905518400, 873336795), new $Int64(-1879761037, 2764496274), new $Int64(-1806480530, 4196182374), new $Int64(-1066765755, 550964545), new $Int64(818747069, 420611474), new $Int64(-1924830376, 204265180), new $Int64(1549974541, 1787046383), new $Int64(1215581865, 3102292318), new $Int64(418321538, 1552199393), new $Int64(1243493047, 980542004), new $Int64(267284263, 3293718720), new $Int64(1179528763, 3771917473), new $Int64(599484404, 2195808264), new $Int64(252818753, 3894702887), new $Int64(-1367475956, 2099949527), new $Int64(1424094358, 338442522), new $Int64(490737398, 637158004), new $Int64(-1727621530, 281976339), new $Int64(574970164, 3619802330), new $Int64(-431930823, 3084554784), new $Int64(-1264611183, 4129772886), new $Int64(-2104399043, 1680378557), new $Int64(-1621962591, 3339087776), new $Int64(1680500332, 4220317857), new $Int64(-1935828963, 2959322499), new $Int64(1675600481, 1488354890), new $Int64(-834863562, 3958162143), new $Int64(-1226511573, 2773705983), new $Int64(1876039582, 225908689), new $Int64(-1183735113, 908216283), new $Int64(-605696219, 3574646075), new $Int64(-1827723091, 1936937569), new $Int64(1519770881, 75492235), new $Int64(816689472, 1935193178), new $Int64(2142521206, 2018250883), new $Int64(455141620, 3943126022), new $Int64(-601399488, 3066544345), new $Int64(1932392669, 2793082663), new $Int64(-1239009361, 3297036421), new $Int64(1640597065, 2206987825), new $Int64(-553246738, 807894872), new $Int64(-1781325307, 766252117), new $Int64(2060649606, 3833114345), new $Int64(845619743, 1255067973), new $Int64(1201145605, 741697208), new $Int64(-1476242608, 2810093753), new $Int64(1109032642, 4229340371), new $Int64(1462188720, 1361684224), new $Int64(-1159399429, 1906263026), new $Int64(475781207, 3904421704), new $Int64(-623537128, 1769075545), new $Int64(1062308525, 2621599764), new $Int64(1279509432, 3431891480), new $Int64(-1742751146, 1871896503), new $Int64(128756421, 1412808876), new $Int64(1605404688, 952876175), new $Int64(-230443691, 1824438899), new $Int64(1662295856, 1005035476), new $Int64(-156574141, 527508597), new $Int64(1288873303, 3066806859), new $Int64(565995893, 3244940914), new $Int64(-889746188, 209092916), new $Int64(-247669406, 1242699167), new $Int64(-713830396, 456723774), new $Int64(1776978905, 1001252870), new $Int64(1468772157, 2026725874), new $Int64(857254202, 2137562569), new $Int64(765939740, 3183366709), new $Int64(1533887628, 2612072960), new $Int64(56977098, 1727148468), new $Int64(-1197583895, 3803658212), new $Int64(1883670356, 479946959), new $Int64(685713571, 1562982345), new $Int64(-1946242443, 1766109365), new $Int64(700596547, 3257093788), new $Int64(-184714929, 2365720207), new $Int64(93384808, 3742754173), new $Int64(-458385235, 2878193673), new $Int64(1096135042, 2174002182), new $Int64(-834260953, 3573511231), new $Int64(-754572527, 1760299077), new $Int64(-1375627191, 2260779833), new $Int64(-866019274, 1452805722), new $Int64(-1229671918, 2940011802), new $Int64(1890251082, 1886183802), new $Int64(893897673, 2514369088), new $Int64(1644345561, 3924317791), new $Int64(-1974867432, 500935732), new $Int64(1403501753, 676580929), new $Int64(-1565912283, 1184984890), new $Int64(-691968413, 1271474274), new $Int64(-1828754738, 3163791473), new $Int64(2051027584, 2842487377), new $Int64(1511537551, 2170968612), new $Int64(573262976, 3535856740), new $Int64(-2053227187, 1488599718), new $Int64(-1180531831, 3408913763), new $Int64(-2086531912, 2501050084), new $Int64(-875130448, 1639124157), new $Int64(-2009482504, 4088176393), new $Int64(1574896563, 3989947576), new $Int64(-165243708, 3414355209), new $Int64(-792329287, 2275136352), new $Int64(-2057774345, 2151835223), new $Int64(-931144933, 1654534827), new $Int64(-679921451, 377892833), new $Int64(-482716010, 660204544), new $Int64(85706799, 390828249), new $Int64(-1422172693, 3402783878), new $Int64(-1468634160, 3717936603), new $Int64(1113532086, 2211058823), new $Int64(1564224320, 2692150867), new $Int64(1952770442, 1928910388), new $Int64(788716862, 3931011137), new $Int64(1083670504, 1112701047), new $Int64(-68150572, 2452299106), new $Int64(-896164822, 2337204777), new $Int64(1774877857, 273889282), new $Int64(1798719843, 1462008793), new $Int64(2138834788, 1554494002), new $Int64(-1194967131, 182675323), new $Int64(-1598554764, 1882802136), new $Int64(589279648, 3700220025), new $Int64(381039426, 3083431543), new $Int64(-851859191, 3622207527), new $Int64(338126939, 432729309), new $Int64(-1667470126, 2391914317), new $Int64(-1849558151, 235747924), new $Int64(2120733629, 3088823825), new $Int64(-745079795, 2314658321), new $Int64(1165929723, 2957634338), new $Int64(501323675, 4117056981), new $Int64(1564699815, 1482500298), new $Int64(-740826490, 840489337), new $Int64(799522364, 3483178565), new $Int64(532129761, 2074004656), new $Int64(724246478, 3643392642), new $Int64(-665153481, 1583624461), new $Int64(-885822954, 287473085), new $Int64(1667835381, 3136843981), new $Int64(1138806821, 1266970974), new $Int64(135185781, 1998688839), new $Int64(392094735, 1492900209), new $Int64(1031326774, 1538112737), new $Int64(-2070568842, 2207265429), new $Int64(-1886797613, 963263315), new $Int64(1671145500, 2295892134), new $Int64(1068469660, 2002560897), new $Int64(-356250305, 1369254035), new $Int64(33436120, 3353312708), new $Int64(57507843, 947771099), new $Int64(-1945755145, 1747061399), new $Int64(1507240140, 2047354631), new $Int64(720000810, 4165367136), new $Int64(479265078, 3388864963), new $Int64(-952181250, 286492130), new $Int64(2045622690, 2795735007), new $Int64(-715730566, 3703961339), new $Int64(-148436487, 1797825479), new $Int64(1429039600, 1116589674), new $Int64(-1665420098, 2593309206), new $Int64(1329049334, 3404995677), new $Int64(-750579440, 3453462936), new $Int64(1014767077, 3016498634), new $Int64(75698599, 1650371545), new $Int64(1592007860, 212344364), new $Int64(1127766888, 3843932156), new $Int64(-748019856, 3573129983), new $Int64(-890581831, 665897820), new $Int64(1071492673, 1675628772), new $Int64(243225682, 2831752928), new $Int64(2120298836, 1486294219), new $Int64(-1954407413, 268782709), new $Int64(-1002123503, 4186179080), new $Int64(624342951, 1613720397), new $Int64(857179861, 2703686015), new $Int64(-911618704, 2205342611), new $Int64(-672703993, 1411666394), new $Int64(-1528454899, 677744900), new $Int64(-1876628533, 4172867247), new $Int64(135494707, 2163418403), new $Int64(849547544, 2841526879), new $Int64(-1117516959, 1082141470), new $Int64(-1770111792, 4046134367), new $Int64(51415528, 2142943655), new $Int64(-249824333, 3124627521), new $Int64(998228909, 219992939), new $Int64(-1078790951, 1756846531), new $Int64(1283749206, 1225118210), new $Int64(-525858006, 1647770243), new $Int64(-2035959705, 444807907), new $Int64(2036369448, 3952076173), new $Int64(53201823, 1461839639), new $Int64(315761893, 3699250910), new $Int64(702974850, 1373688981), new $Int64(734022261, 147523747), new $Int64(-2047330906, 1211276581), new $Int64(1294440951, 2548832680), new $Int64(1144696256, 1995631888), new $Int64(-1992983070, 2011457303), new $Int64(-1351022674, 3057425772), new $Int64(667839456, 81484597), new $Int64(-1681980888, 3646681560), new $Int64(-1372462725, 635548515), new $Int64(602489502, 2508044581), new $Int64(-1794220117, 1014917157), new $Int64(719992433, 3214891315), new $Int64(-1294799037, 959582252), new $Int64(226415134, 3347040449), new $Int64(-362868096, 4102971975), new $Int64(397887437, 4078022210), new $Int64(-536803826, 2851767182), new $Int64(-1398321012, 1540160644), new $Int64(-1549098876, 1057290595), new $Int64(-112592988, 3907769253), new $Int64(579300318, 4248952684), new $Int64(-1054576049, 132554364), new $Int64(-1085862414, 1029351092), new $Int64(697840928, 2583007416), new $Int64(298619124, 1486185789), new $Int64(55905697, 2871589073), new $Int64(2017643612, 723203291), new $Int64(146250550, 2494333952), new $Int64(-1082993397, 2230939180), new $Int64(-1804568072, 3943232912), new $Int64(1768732449, 2181367922), new $Int64(-729261111, 2889274791), new $Int64(1824032949, 2046728161), new $Int64(1653899792, 1376052477), new $Int64(1022327048, 381236993), new $Int64(-1113097690, 3188942166), new $Int64(-74480109, 350070824), new $Int64(144881592, 61758415), new $Int64(-741824226, 3492950336), new $Int64(-2030042720, 3093818430), new $Int64(-453590535, 2962480613), new $Int64(-1912050708, 3154871160), new $Int64(-1636478569, 3228564679), new $Int64(610731502, 888276216), new $Int64(-946702974, 3574998604), new $Int64(-1277068380, 1967526716), new $Int64(-1556147941, 1554691298), new $Int64(-1573024234, 339944798), new $Int64(1223764147, 1154515356), new $Int64(1825645307, 967516237), new $Int64(1546195135, 596588202), new $Int64(-1867600880, 3764362170), new $Int64(-1655392592, 266611402), new $Int64(-393255880, 2047856075), new $Int64(-1000726433, 21444105), new $Int64(-949424754, 3065563181), new $Int64(-232418803, 1140663212), new $Int64(633187674, 2323741028), new $Int64(2126290159, 3103873707), new $Int64(1008658319, 2766828349), new $Int64(-485587503, 1970872996), new $Int64(1628585413, 3766615585), new $Int64(-595148528, 2036813414), new $Int64(-1994877121, 3105536507), new $Int64(13954645, 3396176938), new $Int64(-721402003, 1377154485), new $Int64(-61839181, 3807014186), new $Int64(543009040, 3710110597), new $Int64(-1751425519, 916420443), new $Int64(734556788, 2103831255), new $Int64(-1766161494, 717331943), new $Int64(-1574598896, 3550505941), new $Int64(45939673, 378749927), new $Int64(-1997615719, 611017331), new $Int64(592130075, 758907650), new $Int64(1012992349, 154266815), new $Int64(-1040454942, 1407468696), new $Int64(-1678191250, 970098704), new $Int64(-285057486, 1971660656), new $Int64(998365243, 3332747885), new $Int64(1947089649, 1935189867), new $Int64(1510248801, 203520055), new $Int64(-1305165746, 3916463034), new $Int64(-388598655, 3474113316), new $Int64(1036101639, 316544223), new $Int64(-1773744891, 1650844677), new $Int64(-907191419, 4267565603), new $Int64(-1070275024, 2501167616), new $Int64(-1520651863, 3929401789), new $Int64(-2091360852, 337170252), new $Int64(-960502090, 2061966842), new $Int64(-304190848, 2508461464), new $Int64(-1941471116, 2791377107), new $Int64(1240791848, 1227227588), new $Int64(1813978778, 1709681848), new $Int64(1153692192, 3768820575), new $Int64(-1002297449, 2887126398), new $Int64(-1447111334, 296561685), new $Int64(700300844, 3729960077), new $Int64(-1572311344, 372833036), new $Int64(2078875613, 2409779288), new $Int64(1829161290, 555274064), new $Int64(-1105595719, 4239804901), new $Int64(1839403216, 3723486978), new $Int64(-1649093095, 2145871984), new $Int64(-1582765715, 3565480803), new $Int64(-1568653827, 2197313814), new $Int64(974785092, 3613674566), new $Int64(438638731, 3042093666), new $Int64(-96556264, 3324034321), new $Int64(869420878, 3708873369), new $Int64(946682149, 1698090092), new $Int64(1618900382, 4213940712), new $Int64(-1843479747, 2087477361), new $Int64(-1766167800, 2407950639), new $Int64(-1296225558, 3942568569), new $Int64(-1223900450, 4088074412), new $Int64(723260036, 2964773675), new $Int64(-673921829, 1539178386), new $Int64(1062961552, 2694849566), new $Int64(460977733, 2120273838), new $Int64(-1604570740, 2484608657), new $Int64(880846449, 2956190677), new $Int64(1970902366, 4223313749), new $Int64(662161910, 3502682327), new $Int64(705634754, 4133891139), new $Int64(-1031359300, 1166449596), new $Int64(1038247601, 3362705993), new $Int64(93734798, 3892921029), new $Int64(1876124043, 786869787), new $Int64(1057490746, 1046342263), new $Int64(242763728, 493777327), new $Int64(-853573201, 3304827646), new $Int64(616460742, 125356352), new $Int64(499300063, 74094113), new $Int64(-795586925, 2500816079), new $Int64(-490248444, 514015239), new $Int64(1377565129, 543520454), new $Int64(-2039776725, 3614531153), new $Int64(2056746300, 2356753985), new $Int64(1390062617, 2018141668), new $Int64(131272971, 2087974891), new $Int64(-1502927041, 3166972343), new $Int64(372256200, 1517638666), new $Int64(-935275664, 173466846), new $Int64(-695774461, 4241513471), new $Int64(-1413550842, 2783126920), new $Int64(1972004134, 4167264826), new $Int64(29260506, 3907395640), new $Int64(-910901561, 1539634186), new $Int64(-595957298, 178241987), new $Int64(-113277636, 182168164), new $Int64(-1102530459, 2386154934), new $Int64(1379126408, 4077374341), new $Int64(-2114679722, 1732699140), new $Int64(-421057745, 1041306002), new $Int64(1860414813, 2068001749), new $Int64(1005320202, 3208962910), new $Int64(844054010, 697710380), new $Int64(-1509359403, 2228431183), new $Int64(-810313977, 3554678728), new $Int64(-750989047, 173470263), new $Int64(-85886265, 3848297795), new $Int64(-926936977, 246236185), new $Int64(-1984190461, 2066374846), new $Int64(1771673660, 312890749), new $Int64(703378057, 3573310289), new $Int64(-598851901, 143166754), new $Int64(613554316, 2081511079), new $Int64(1197802104, 486038032), new $Int64(-1906483789, 2982218564), new $Int64(364901986, 1000939191), new $Int64(1902782651, 2750454885), new $Int64(-671844857, 3375313137), new $Int64(-1643868040, 881302957), new $Int64(-1508784745, 2514186393), new $Int64(-1703622845, 360024739), new $Int64(1399671872, 292500025), new $Int64(1381210821, 2276300752), new $Int64(521803381, 4069087683), new $Int64(-1938982667, 1637778212), new $Int64(720490469, 1676670893), new $Int64(1067262482, 3855174429), new $Int64(2114075974, 2067248671), new $Int64(-89426259, 2884561259), new $Int64(-805741095, 2456511185), new $Int64(983726246, 561175414), new $Int64(-1719489563, 432588903), new $Int64(885133709, 4059399550), new $Int64(-93096266, 1075014784), new $Int64(-1733832628, 2728058415), new $Int64(1839142064, 1299703678), new $Int64(1262333188, 2347583393), new $Int64(1285481956, 2468164145), new $Int64(-1158354011, 1140014346), new $Int64(2033889184, 1936972070), new $Int64(-1737578993, 3870530098), new $Int64(-484494257, 1717789158), new $Int64(-232997156, 1153452491), new $Int64(-990424416, 3948827651), new $Int64(-1357145630, 2101413152), new $Int64(1495744672, 3854091229), new $Int64(83644069, 4215565463), new $Int64(-1385277313, 1202710438), new $Int64(-564909037, 2072216740), new $Int64(705690639, 2066751068), new $Int64(-2113583312, 173902580), new $Int64(-741983806, 142459001), new $Int64(172391592, 1889151926), new $Int64(-498943125, 3034199774), new $Int64(1618587731, 516490102), new $Int64(93114264, 3692577783), new $Int64(-2078821353, 2953948865), new $Int64(-320938673, 4041040923), new $Int64(-1942517976, 592046130), new $Int64(-705643640, 384297211), new $Int64(-2051649464, 265863924), new $Int64(2101717619, 1333136237), new $Int64(1499611781, 1406273556), new $Int64(1074670496, 426305476), new $Int64(125704633, 2750898176), new $Int64(488068495, 1633944332), new $Int64(2037723464, 3236349343), new $Int64(-1703423246, 4013676611), new $Int64(1718532237, 2265047407), new $Int64(1433593806, 875071080), new $Int64(-343047503, 1418843655), new $Int64(2009228711, 451657300), new $Int64(1229446621, 1866374663), new $Int64(1653472867, 1551455622), new $Int64(577191481, 3560962459), new $Int64(1669204077, 3347903778), new $Int64(-298327194, 2675874918), new $Int64(-1831355577, 2762991672), new $Int64(530492383, 3689068477), new $Int64(844089962, 4071997905), new $Int64(1508155730, 1381702441), new $Int64(2089931018, 2373284878), new $Int64(-864267462, 2143983064), new $Int64(308739063, 1938207195), new $Int64(1754949306, 1188152253), new $Int64(1272345009, 615870490), new $Int64(742653194, 2662252621), new $Int64(1477718295, 3839976789), new $Int64(-2091334213, 306752547), new $Int64(-1426688067, 2162363077), new $Int64(-57052633, 2767224719), new $Int64(-1471624099, 2628837712), new $Int64(1678405918, 2967771969), new $Int64(1694285728, 499792248), new $Int64(-1744131281, 4285253508), new $Int64(962357072, 2856511070), new $Int64(679471692, 2526409716), new $Int64(-1793706473, 1240875658), new $Int64(-914893422, 2577342868), new $Int64(-1001298215, 4136853496), new $Int64(-1477114974, 2403540137), new $Int64(1372824515, 1371410668), new $Int64(-176562048, 371758825), new $Int64(-441063112, 1528834084), new $Int64(-71688630, 1504757260), new $Int64(-1461820072, 699052551), new $Int64(-505543539, 3347789870), new $Int64(1951619734, 3430604759), new $Int64(2119672219, 1935601723), new $Int64(966789690, 834676166)]); - globalRand = New(new lockedSource.ptr(new nosync.Mutex.ptr(false), $assertType(NewSource(new $Int64(0, 1)), Source64))); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["math/big"] = (function() { - var $pkg = {}, $init, bytes, binary, errors, fmt, nosync, io, math, bits, rand, strconv, strings, Word, decimal, Float, ErrNaN, form, RoundingMode, Accuracy, Int, byteReader, nat, divisor, Rat, sliceType, arrayType, structType, sliceType$1, ptrType, sliceType$2, ptrType$1, ptrType$2, ptrType$3, ptrType$4, arrayType$1, sliceType$3, ptrType$5, ptrType$6, _Accuracy_index, pow5tab, intOne, natOne, natTwo, natTen, karatsubaThreshold, basicSqrThreshold, karatsubaSqrThreshold, natPool, leafSize, cacheBase10, _RoundingMode_index, three, _r, addWW_g, subWW_g, mulWW_g, mulAddWWW_g, nlz, divWW_g, addVV_g, subVV_g, addVW_g, subVW_g, shlVU_g, shrVU_g, mulAddVWW_g, addMulVVW_g, divWVW_g, mulWW, divWW, addVV, subVV, addVW, subVW, shlVU, shrVU, mulAddVWW, addMulVVW, divWVW, shr, appendZeros, shouldRoundUp, trim, NewFloat, makeAcc, fnorm, msb32, msb64, validateBinaryOperands, umax32, roundShortest, fmtE, fmtF, min, NewInt, low32, low64, lehmerSimulate, lehmerUpdate, euclidUpdate, Jacobi, writeMultiple, scanSign, basicMul, karatsubaAdd, karatsubaSub, karatsuba, alias, addAt, max, karatsubaLen, basicSqr, karatsubaSqr, getNat, putNat, same, greaterThan, bigEndianWord, maxPow, pow, divisors, quotToFloat32, quotToFloat64, mulDenom, scaleDenom, ratTok, scanExponent, newFloat; - bytes = $packages["bytes"]; - binary = $packages["encoding/binary"]; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - io = $packages["io"]; - math = $packages["math"]; - bits = $packages["math/bits"]; - rand = $packages["math/rand"]; - strconv = $packages["strconv"]; - strings = $packages["strings"]; - Word = $pkg.Word = $newType(4, $kindUintptr, "big.Word", true, "math/big", true, null); - decimal = $pkg.decimal = $newType(0, $kindStruct, "big.decimal", true, "math/big", false, function(mant_, exp_) { - this.$val = this; - if (arguments.length === 0) { - this.mant = sliceType$1.nil; - this.exp = 0; - return; - } - this.mant = mant_; - this.exp = exp_; - }); - Float = $pkg.Float = $newType(0, $kindStruct, "big.Float", true, "math/big", true, function(prec_, mode_, acc_, form_, neg_, mant_, exp_) { - this.$val = this; - if (arguments.length === 0) { - this.prec = 0; - this.mode = 0; - this.acc = 0; - this.form = 0; - this.neg = false; - this.mant = nat.nil; - this.exp = 0; - return; - } - this.prec = prec_; - this.mode = mode_; - this.acc = acc_; - this.form = form_; - this.neg = neg_; - this.mant = mant_; - this.exp = exp_; - }); - ErrNaN = $pkg.ErrNaN = $newType(0, $kindStruct, "big.ErrNaN", true, "math/big", true, function(msg_) { - this.$val = this; - if (arguments.length === 0) { - this.msg = ""; - return; - } - this.msg = msg_; - }); - form = $pkg.form = $newType(1, $kindUint8, "big.form", true, "math/big", false, null); - RoundingMode = $pkg.RoundingMode = $newType(1, $kindUint8, "big.RoundingMode", true, "math/big", true, null); - Accuracy = $pkg.Accuracy = $newType(1, $kindInt8, "big.Accuracy", true, "math/big", true, null); - Int = $pkg.Int = $newType(0, $kindStruct, "big.Int", true, "math/big", true, function(neg_, abs_) { - this.$val = this; - if (arguments.length === 0) { - this.neg = false; - this.abs = nat.nil; - return; - } - this.neg = neg_; - this.abs = abs_; - }); - byteReader = $pkg.byteReader = $newType(0, $kindStruct, "big.byteReader", true, "math/big", false, function(ScanState_) { - this.$val = this; - if (arguments.length === 0) { - this.ScanState = $ifaceNil; - return; - } - this.ScanState = ScanState_; - }); - nat = $pkg.nat = $newType(12, $kindSlice, "big.nat", true, "math/big", false, null); - divisor = $pkg.divisor = $newType(0, $kindStruct, "big.divisor", true, "math/big", false, function(bbb_, nbits_, ndigits_) { - this.$val = this; - if (arguments.length === 0) { - this.bbb = nat.nil; - this.nbits = 0; - this.ndigits = 0; - return; - } - this.bbb = bbb_; - this.nbits = nbits_; - this.ndigits = ndigits_; - }); - Rat = $pkg.Rat = $newType(0, $kindStruct, "big.Rat", true, "math/big", true, function(a_, b_) { - this.$val = this; - if (arguments.length === 0) { - this.a = new Int.ptr(false, nat.nil); - this.b = new Int.ptr(false, nat.nil); - return; - } - this.a = a_; - this.b = b_; - }); - sliceType = $sliceType($emptyInterface); - arrayType = $arrayType(divisor, 64); - structType = $structType("math/big", [{prop: "Mutex", name: "Mutex", embedded: true, exported: true, typ: nosync.Mutex, tag: ""}, {prop: "table", name: "table", embedded: false, exported: false, typ: arrayType, tag: ""}]); - sliceType$1 = $sliceType($Uint8); - ptrType = $ptrType(Float); - sliceType$2 = $sliceType(Word); - ptrType$1 = $ptrType(Int); - ptrType$2 = $ptrType(Rat); - ptrType$3 = $ptrType(Word); - ptrType$4 = $ptrType(nat); - arrayType$1 = $arrayType(nat, 16); - sliceType$3 = $sliceType(divisor); - ptrType$5 = $ptrType(decimal); - ptrType$6 = $ptrType(rand.Rand); - Accuracy.prototype.String = function() { - var i, x; - i = this.$val; - i = i - (-1) << 24 >> 24; - if (i < 0 || i >= 3) { - return "Accuracy(" + strconv.FormatInt((new $Int64(0, (i + -1 << 24 >> 24))), 10) + ")"; - } - return $substring("BelowExactAbove", ((i < 0 || i >= _Accuracy_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _Accuracy_index[i]), (x = i + 1 << 24 >> 24, ((x < 0 || x >= _Accuracy_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _Accuracy_index[x]))); - }; - $ptrType(Accuracy).prototype.String = function() { return new Accuracy(this.$get()).String(); }; - addWW_g = function(x, y, c) { - var c, x, y, yc, z0, z1; - z1 = 0; - z0 = 0; - yc = y + c >>> 0; - z0 = x + yc >>> 0; - if (z0 < x || yc < y) { - z1 = 1; - } - return [z1, z0]; - }; - subWW_g = function(x, y, c) { - var c, x, y, yc, z0, z1; - z1 = 0; - z0 = 0; - yc = y + c >>> 0; - z0 = x - yc >>> 0; - if (z0 > x || yc < y) { - z1 = 1; - } - return [z1, z0]; - }; - mulWW_g = function(x, y) { - var t, w0, w1, w2, x, x0, x1, y, y0, y1, z0, z1; - z1 = 0; - z0 = 0; - x0 = (x & 65535) >>> 0; - x1 = x >>> 16 >>> 0; - y0 = (y & 65535) >>> 0; - y1 = y >>> 16 >>> 0; - w0 = $imul(x0, y0) >>> 0; - t = ($imul(x1, y0) >>> 0) + (w0 >>> 16 >>> 0) >>> 0; - w1 = (t & 65535) >>> 0; - w2 = t >>> 16 >>> 0; - w1 = w1 + (($imul(x0, y1) >>> 0)) >>> 0; - z1 = (($imul(x1, y1) >>> 0) + w2 >>> 0) + (w1 >>> 16 >>> 0) >>> 0; - z0 = $imul(x, y) >>> 0; - return [z1, z0]; - }; - mulAddWWW_g = function(x, y, c) { - var _tuple, c, x, y, z0, z1, zz0; - z1 = 0; - z0 = 0; - _tuple = mulWW_g(x, y); - z1 = _tuple[0]; - zz0 = _tuple[1]; - z0 = zz0 + c >>> 0; - if (z0 < zz0) { - z1 = z1 + (1) >>> 0; - } - return [z1, z0]; - }; - nlz = function(x) { - var x; - return ((bits.LeadingZeros(((x >>> 0))) >>> 0)); - }; - divWW_g = function(u1, u0, v) { - var _q, _q$1, _tmp, _tmp$1, _tmp$2, _tmp$3, q, q0, q1, r, rhat, s, u0, u1, un0, un1, un10, un21, un32, v, vn0, vn1, y, y$1, y$2, y$3, y$4; - q = 0; - r = 0; - if (u1 >= v) { - _tmp = 4294967295; - _tmp$1 = 4294967295; - q = _tmp; - r = _tmp$1; - return [q, r]; - } - s = nlz(v); - v = (y = (s), y < 32 ? (v << y) : 0) >>> 0; - vn1 = v >>> 16 >>> 0; - vn0 = (v & 65535) >>> 0; - un32 = (((y$1 = s, y$1 < 32 ? (u1 << y$1) : 0) >>> 0) | ((y$2 = ((32 - s >>> 0)), y$2 < 32 ? (u0 >>> y$2) : 0) >>> 0)) >>> 0; - un10 = (y$3 = s, y$3 < 32 ? (u0 << y$3) : 0) >>> 0; - un1 = un10 >>> 16 >>> 0; - un0 = (un10 & 65535) >>> 0; - q1 = (_q = un32 / vn1, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - rhat = un32 - ($imul(q1, vn1) >>> 0) >>> 0; - while (true) { - if (!(q1 >= 65536 || ($imul(q1, vn0) >>> 0) > (($imul(65536, rhat) >>> 0) + un1 >>> 0))) { break; } - q1 = q1 - (1) >>> 0; - rhat = rhat + (vn1) >>> 0; - if (rhat >= 65536) { - break; - } - } - un21 = (($imul(un32, 65536) >>> 0) + un1 >>> 0) - ($imul(q1, v) >>> 0) >>> 0; - q0 = (_q$1 = un21 / vn1, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - rhat = un21 - ($imul(q0, vn1) >>> 0) >>> 0; - while (true) { - if (!(q0 >= 65536 || ($imul(q0, vn0) >>> 0) > (($imul(65536, rhat) >>> 0) + un0 >>> 0))) { break; } - q0 = q0 - (1) >>> 0; - rhat = rhat + (vn1) >>> 0; - if (rhat >= 65536) { - break; - } - } - _tmp$2 = ($imul(q1, 65536) >>> 0) + q0 >>> 0; - _tmp$3 = (y$4 = s, y$4 < 32 ? ((((($imul(un21, 65536) >>> 0) + un0 >>> 0) - ($imul(q0, v) >>> 0) >>> 0)) >>> y$4) : 0) >>> 0; - q = _tmp$2; - r = _tmp$3; - return [q, r]; - }; - addVV_g = function(z, x, y) { - var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, yi, z, zi; - c = 0; - if (false) { - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = addWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]), c); - c = _tuple[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); - _i++; - } - return c; - } - _ref$1 = $subslice(x, 0, z.$length); - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); - zi = (xi + yi >>> 0) + c >>> 0; - ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); - c = (((((xi & yi) >>> 0) | (((((xi | yi) >>> 0)) & ~zi) >>> 0)) >>> 0)) >>> 31 >>> 0; - _i$1++; - } - return c; - }; - subVV_g = function(z, x, y) { - var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, yi, z, zi; - c = 0; - if (false) { - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = subWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]), c); - c = _tuple[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); - _i++; - } - return c; - } - _ref$1 = $subslice(x, 0, z.$length); - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); - zi = (xi - yi >>> 0) - c >>> 0; - ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); - c = (((((yi & ~xi) >>> 0) | (((((yi | (~xi >>> 0)) >>> 0)) & zi) >>> 0)) >>> 0)) >>> 31 >>> 0; - _i$1++; - } - return c; - }; - addVW_g = function(z, x, y) { - var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, z, zi; - c = 0; - if (false) { - c = y; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = addWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), c, 0); - c = _tuple[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); - _i++; - } - return c; - } - c = y; - _ref$1 = $subslice(x, 0, z.$length); - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - zi = xi + c >>> 0; - ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); - c = ((xi & ~zi) >>> 0) >>> 31 >>> 0; - _i$1++; - } - return c; - }; - subVW_g = function(z, x, y) { - var _i, _i$1, _ref, _ref$1, _tuple, c, i, i$1, x, xi, y, z, zi; - c = 0; - if (false) { - c = y; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = subWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), c, 0); - c = _tuple[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); - _i++; - } - return c; - } - c = y; - _ref$1 = $subslice(x, 0, z.$length); - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - xi = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - zi = xi - c >>> 0; - ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = zi); - c = (((zi & ~xi) >>> 0)) >>> 31 >>> 0; - _i$1++; - } - return c; - }; - shlVU_g = function(z, x, s) { - var $C5$9D, c, i, n, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z; - c = 0; - n = z.$length; - if (n > 0) { - $C5$9D = 32 - s >>> 0; - w1 = (x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - c = (y = $C5$9D, y < 32 ? (w1 >>> y) : 0) >>> 0; - i = n - 1 >> 0; - while (true) { - if (!(i > 0)) { break; } - w = w1; - w1 = (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$2])); - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((y$1 = s, y$1 < 32 ? (w << y$1) : 0) >>> 0) | ((y$2 = $C5$9D, y$2 < 32 ? (w1 >>> y$2) : 0) >>> 0)) >>> 0)); - i = i - (1) >> 0; - } - (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = ((y$3 = s, y$3 < 32 ? (w1 << y$3) : 0) >>> 0)); - } - return c; - }; - shrVU_g = function(z, x, s) { - var $C5$9D, c, i, n, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z; - c = 0; - n = z.$length; - if (n > 0) { - $C5$9D = 32 - s >>> 0; - w1 = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); - c = (y = $C5$9D, y < 32 ? (w1 << y) : 0) >>> 0; - i = 0; - while (true) { - if (!(i < (n - 1 >> 0))) { break; } - w = w1; - w1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((y$1 = s, y$1 < 32 ? (w >>> y$1) : 0) >>> 0) | ((y$2 = $C5$9D, y$2 < 32 ? (w1 << y$2) : 0) >>> 0)) >>> 0)); - i = i + (1) >> 0; - } - (x$2 = n - 1 >> 0, ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = ((y$3 = s, y$3 < 32 ? (w1 >>> y$3) : 0) >>> 0))); - } - return c; - }; - mulAddVWW_g = function(z, x, y, r) { - var _i, _ref, _tuple, c, i, r, x, y, z; - c = 0; - c = r; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y, c); - c = _tuple[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[1]); - _i++; - } - return c; - }; - addMulVVW_g = function(z, x, y) { - var _i, _ref, _tuple, _tuple$1, c, i, x, y, z, z0, z1; - c = 0; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y, ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i])); - z1 = _tuple[0]; - z0 = _tuple[1]; - _tuple$1 = addWW_g(z0, c, 0); - c = _tuple$1[0]; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple$1[1]); - c = c + (z1) >>> 0; - _i++; - } - return c; - }; - divWVW_g = function(z, xn, x, y) { - var _tuple, i, r, x, xn, y, z; - r = 0; - r = xn; - i = z.$length - 1 >> 0; - while (true) { - if (!(i >= 0)) { break; } - _tuple = divWW_g(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), y); - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = _tuple[0]); - r = _tuple[1]; - i = i - (1) >> 0; - } - return r; - }; - mulWW = function(x, y) { - var _tuple, x, y, z0, z1; - z1 = 0; - z0 = 0; - _tuple = mulWW_g(x, y); - z1 = _tuple[0]; - z0 = _tuple[1]; - return [z1, z0]; - }; - divWW = function(x1, x0, y) { - var _tuple, q, r, x0, x1, y; - q = 0; - r = 0; - _tuple = divWW_g(x1, x0, y); - q = _tuple[0]; - r = _tuple[1]; - return [q, r]; - }; - addVV = function(z, x, y) { - var c, x, y, z; - c = 0; - c = addVV_g(z, x, y); - return c; - }; - subVV = function(z, x, y) { - var c, x, y, z; - c = 0; - c = subVV_g(z, x, y); - return c; - }; - addVW = function(z, x, y) { - var c, x, y, z; - c = 0; - c = addVW_g(z, x, y); - return c; - }; - subVW = function(z, x, y) { - var c, x, y, z; - c = 0; - c = subVW_g(z, x, y); - return c; - }; - shlVU = function(z, x, s) { - var c, s, x, z; - c = 0; - c = shlVU_g(z, x, s); - return c; - }; - shrVU = function(z, x, s) { - var c, s, x, z; - c = 0; - c = shrVU_g(z, x, s); - return c; - }; - mulAddVWW = function(z, x, y, r) { - var c, r, x, y, z; - c = 0; - c = mulAddVWW_g(z, x, y, r); - return c; - }; - addMulVVW = function(z, x, y) { - var c, x, y, z; - c = 0; - c = addMulVVW_g(z, x, y); - return c; - }; - divWVW = function(z, xn, x, y) { - var r, x, xn, y, z; - r = 0; - r = divWVW_g(z, xn, x, y); - return r; - }; - decimal.ptr.prototype.at = function(i) { - var d, i, x; - d = this; - if (0 <= i && i < d.mant.$length) { - return (x = d.mant, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); - } - return 48; - }; - decimal.prototype.at = function(i) { return this.$val.at(i); }; - decimal.ptr.prototype.init = function(m, shift) { - var _r$1, m, n, ntz, s, s$1, shift, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; m = $f.m; n = $f.n; ntz = $f.ntz; s = $f.s; s$1 = $f.s$1; shift = $f.shift; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (m.$length === 0) { - x.mant = $subslice(x.mant, 0, 0); - x.exp = 0; - $s = -1; return; - } - if (shift < 0) { - ntz = m.trailingZeroBits(); - s = ((-shift >>> 0)); - if (s >= ntz) { - s = ntz; - } - m = (nat.nil).shr(m, s); - shift = shift + (((s >> 0))) >> 0; - } - if (shift > 0) { - m = (nat.nil).shl(m, ((shift >>> 0))); - shift = 0; - } - _r$1 = m.utoa(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - s$1 = _r$1; - n = s$1.$length; - x.exp = n; - while (true) { - if (!(n > 0 && ((x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= s$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : s$1.$array[s$1.$offset + x$1])) === 48))) { break; } - n = n - (1) >> 0; - } - x.mant = $appendSlice($subslice(x.mant, 0, 0), $subslice(s$1, 0, n)); - if (shift < 0) { - while (true) { - if (!(shift < -28)) { break; } - shr(x, 28); - shift = shift + (28) >> 0; - } - shr(x, ((-shift >>> 0))); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: decimal.ptr.prototype.init }; } $f._r$1 = _r$1; $f.m = m; $f.n = n; $f.ntz = ntz; $f.s = s; $f.s$1 = s$1; $f.shift = shift; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - decimal.prototype.init = function(m, shift) { return this.$val.init(m, shift); }; - shr = function(x, s) { - var ch, ch$1, d, d$1, d$2, mask, n, r, s, w, x, x$1, x$2, x$3, x$4, y, y$1, y$2, y$3, y$4, y$5; - r = 0; - n = 0; - while (true) { - if (!((((y = s, y < 32 ? (n >>> y) : 0) >>> 0) === 0) && r < x.mant.$length)) { break; } - ch = (((x$1 = x.mant, ((r < 0 || r >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + r])) >>> 0)); - r = r + (1) >> 0; - n = (($imul(n, 10) >>> 0) + ch >>> 0) - 48 >>> 0; - } - if (n === 0) { - x.mant = $subslice(x.mant, 0, 0); - return; - } - while (true) { - if (!(((y$1 = s, y$1 < 32 ? (n >>> y$1) : 0) >>> 0) === 0)) { break; } - r = r + (1) >> 0; - n = $imul(n, (10)) >>> 0; - } - x.exp = x.exp + ((1 - r >> 0)) >> 0; - w = 0; - mask = ((y$2 = s, y$2 < 32 ? (1 << y$2) : 0) >>> 0) - 1 >>> 0; - while (true) { - if (!(r < x.mant.$length)) { break; } - ch$1 = (((x$2 = x.mant, ((r < 0 || r >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + r])) >>> 0)); - r = r + (1) >> 0; - d = (y$3 = s, y$3 < 32 ? (n >>> y$3) : 0) >>> 0; - n = (n & (mask)) >>> 0; - (x$3 = x.mant, ((w < 0 || w >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + w] = (((d + 48 >>> 0) << 24 >>> 24)))); - w = w + (1) >> 0; - n = (($imul(n, 10) >>> 0) + ch$1 >>> 0) - 48 >>> 0; - } - while (true) { - if (!(n > 0 && w < x.mant.$length)) { break; } - d$1 = (y$4 = s, y$4 < 32 ? (n >>> y$4) : 0) >>> 0; - n = (n & (mask)) >>> 0; - (x$4 = x.mant, ((w < 0 || w >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + w] = (((d$1 + 48 >>> 0) << 24 >>> 24)))); - w = w + (1) >> 0; - n = $imul(n, 10) >>> 0; - } - x.mant = $subslice(x.mant, 0, w); - while (true) { - if (!(n > 0)) { break; } - d$2 = (y$5 = s, y$5 < 32 ? (n >>> y$5) : 0) >>> 0; - n = (n & (mask)) >>> 0; - x.mant = $append(x.mant, (((d$2 + 48 >>> 0) << 24 >>> 24))); - n = $imul(n, 10) >>> 0; - } - trim(x); - }; - decimal.ptr.prototype.String = function() { - var buf, x; - x = this; - if (x.mant.$length === 0) { - return "0"; - } - buf = sliceType$1.nil; - if (x.exp <= 0) { - buf = $appendSlice(buf, "0."); - buf = appendZeros(buf, -x.exp); - buf = $appendSlice(buf, x.mant); - } else if (x.exp < x.mant.$length) { - buf = $appendSlice(buf, $subslice(x.mant, 0, x.exp)); - buf = $append(buf, 46); - buf = $appendSlice(buf, $subslice(x.mant, x.exp)); - } else { - buf = $appendSlice(buf, x.mant); - buf = appendZeros(buf, x.exp - x.mant.$length >> 0); - } - return ($bytesToString(buf)); - }; - decimal.prototype.String = function() { return this.$val.String(); }; - appendZeros = function(buf, n) { - var buf, n; - while (true) { - if (!(n > 0)) { break; } - buf = $append(buf, 48); - n = n - (1) >> 0; - } - return buf; - }; - shouldRoundUp = function(x, n) { - var n, x, x$1, x$2, x$3, x$4; - if (((x$1 = x.mant, ((n < 0 || n >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + n])) === 53) && ((n + 1 >> 0) === x.mant.$length)) { - return n > 0 && !(((((((x$2 = x.mant, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])) - 48 << 24 >>> 24)) & 1) >>> 0) === 0)); - } - return (x$4 = x.mant, ((n < 0 || n >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + n])) >= 53; - }; - decimal.ptr.prototype.round = function(n) { - var n, x; - x = this; - if (n < 0 || n >= x.mant.$length) { - return; - } - if (shouldRoundUp(x, n)) { - x.roundUp(n); - } else { - x.roundDown(n); - } - }; - decimal.prototype.round = function(n) { return this.$val.round(n); }; - decimal.ptr.prototype.roundUp = function(n) { - var _index, n, x, x$1, x$2, x$3, x$4, x$5; - x = this; - if (n < 0 || n >= x.mant.$length) { - return; - } - while (true) { - if (!(n > 0 && (x$1 = x.mant, x$2 = n - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) >= 57)) { break; } - n = n - (1) >> 0; - } - if (n === 0) { - (x$3 = x.mant, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = 49)); - x.mant = $subslice(x.mant, 0, 1); - x.exp = x.exp + (1) >> 0; - return; - } - _index = n - 1 >> 0; - (x$5 = x.mant, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index] = ((x$4 = x.mant, ((_index < 0 || _index >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + _index])) + (1) << 24 >>> 24))); - x.mant = $subslice(x.mant, 0, n); - }; - decimal.prototype.roundUp = function(n) { return this.$val.roundUp(n); }; - decimal.ptr.prototype.roundDown = function(n) { - var n, x; - x = this; - if (n < 0 || n >= x.mant.$length) { - return; - } - x.mant = $subslice(x.mant, 0, n); - trim(x); - }; - decimal.prototype.roundDown = function(n) { return this.$val.roundDown(n); }; - trim = function(x) { - var i, x, x$1, x$2; - i = x.mant.$length; - while (true) { - if (!(i > 0 && ((x$1 = x.mant, x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === 48))) { break; } - i = i - (1) >> 0; - } - x.mant = $subslice(x.mant, 0, i); - if (i === 0) { - x.exp = 0; - } - }; - ErrNaN.ptr.prototype.Error = function() { - var err; - err = this; - return err.msg; - }; - ErrNaN.prototype.Error = function() { return this.$val.Error(); }; - NewFloat = function(x) { - var _r$1, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (math.IsNaN(x)) { - $panic((x$1 = new ErrNaN.ptr("NewFloat(NaN)"), new x$1.constructor.elem(x$1))); - } - _r$1 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetFloat64(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewFloat }; } $f._r$1 = _r$1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewFloat = NewFloat; - Float.ptr.prototype.SetPrec = function(prec) { - var old, prec, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; old = $f.old; prec = $f.prec; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - z.acc = 0; - if (prec === 0) { - z.prec = 0; - if (z.form === 1) { - z.acc = makeAcc(z.neg); - z.form = 0; - } - $s = -1; return z; - } - if (prec > 4294967295) { - prec = 4294967295; - } - old = z.prec; - z.prec = ((prec >>> 0)); - /* */ if (z.prec < old) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (z.prec < old) { */ case 1: - $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetPrec }; } $f.old = old; $f.prec = prec; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetPrec = function(prec) { return this.$val.SetPrec(prec); }; - makeAcc = function(above) { - var above; - if (above) { - return 1; - } - return -1; - }; - Float.ptr.prototype.SetMode = function(mode) { - var mode, z; - z = this; - z.mode = mode; - z.acc = 0; - return z; - }; - Float.prototype.SetMode = function(mode) { return this.$val.SetMode(mode); }; - Float.ptr.prototype.Prec = function() { - var x; - x = this; - return ((x.prec >>> 0)); - }; - Float.prototype.Prec = function() { return this.$val.Prec(); }; - Float.ptr.prototype.MinPrec = function() { - var x; - x = this; - if (!((x.form === 1))) { - return 0; - } - return (((x.mant.$length >>> 0)) * 32 >>> 0) - x.mant.trailingZeroBits() >>> 0; - }; - Float.prototype.MinPrec = function() { return this.$val.MinPrec(); }; - Float.ptr.prototype.Mode = function() { - var x; - x = this; - return x.mode; - }; - Float.prototype.Mode = function() { return this.$val.Mode(); }; - Float.ptr.prototype.Acc = function() { - var x; - x = this; - return x.acc; - }; - Float.prototype.Acc = function() { return this.$val.Acc(); }; - Float.ptr.prototype.Sign = function() { - var x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (x.form === 0) { - $s = -1; return 0; - } - if (x.neg) { - $s = -1; return -1; - } - $s = -1; return 1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sign }; } $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Sign = function() { return this.$val.Sign(); }; - Float.ptr.prototype.MantExp = function(mant) { - var _r$1, exp, mant, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; exp = $f.exp; mant = $f.mant; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - exp = 0; - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (x.form === 1) { - exp = ((x.exp >> 0)); - } - /* */ if (!(mant === ptrType.nil)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!(mant === ptrType.nil)) { */ case 4: - _r$1 = mant.Copy(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - if (mant.form === 1) { - mant.exp = 0; - } - /* } */ case 5: - $s = -1; return exp; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.MantExp }; } $f._r$1 = _r$1; $f.exp = exp; $f.mant = mant; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.MantExp = function(mant) { return this.$val.MantExp(mant); }; - Float.ptr.prototype.setExpAndRound = function(exp, sbit) { - var exp, sbit, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; exp = $f.exp; sbit = $f.sbit; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if ((exp.$high < -1 || (exp.$high === -1 && exp.$low < 2147483648))) { - z.acc = makeAcc(z.neg); - z.form = 0; - $s = -1; return; - } - if ((exp.$high > 0 || (exp.$high === 0 && exp.$low > 2147483647))) { - z.acc = makeAcc(!z.neg); - z.form = 2; - $s = -1; return; - } - z.form = 1; - z.exp = (((exp.$low + ((exp.$high >> 31) * 4294967296)) >> 0)); - $r = z.round(sbit); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.setExpAndRound }; } $f.exp = exp; $f.sbit = sbit; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.setExpAndRound = function(exp, sbit) { return this.$val.setExpAndRound(exp, sbit); }; - Float.ptr.prototype.SetMantExp = function(mant, exp) { - var _r$1, exp, mant, x, x$1, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; exp = $f.exp; mant = $f.mant; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = z.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = mant.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _r$1 = z.Copy(mant); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - if (!((z.form === 1))) { - $s = -1; return z; - } - $r = z.setExpAndRound((x = (new $Int64(0, z.exp)), x$1 = (new $Int64(0, exp)), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)), 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetMantExp }; } $f._r$1 = _r$1; $f.exp = exp; $f.mant = mant; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetMantExp = function(mant, exp) { return this.$val.SetMantExp(mant, exp); }; - Float.ptr.prototype.Signbit = function() { - var x; - x = this; - return x.neg; - }; - Float.prototype.Signbit = function() { return this.$val.Signbit(); }; - Float.ptr.prototype.IsInf = function() { - var x; - x = this; - return x.form === 2; - }; - Float.prototype.IsInf = function() { return this.$val.IsInf(); }; - Float.ptr.prototype.IsInt = function() { - var x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (!((x.form === 1))) { - $s = -1; return x.form === 0; - } - if (x.exp <= 0) { - $s = -1; return false; - } - $s = -1; return x.prec <= ((x.exp >>> 0)) || x.MinPrec() <= ((x.exp >>> 0)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.IsInt }; } $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.IsInt = function() { return this.$val.IsInt(); }; - Float.ptr.prototype.validate = function() { - var _arg, _arg$1, _r$1, _r$2, m, x, x$1, x$2, x$3, x$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; m = $f.m; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (true) { - $panic(new $String("validate called but debugFloat is not set")); - } - if (!((x.form === 1))) { - $s = -1; return; - } - m = x.mant.$length; - if (m === 0) { - $panic(new $String("nonzero finite number with empty mantissa")); - } - /* */ if ((((x$1 = x.mant, x$2 = m - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) & 2147483648) >>> 0) === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((((x$1 = x.mant, x$2 = m - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) & 2147483648) >>> 0) === 0) { */ case 1: - _arg = new Word((x$3 = x.mant, x$4 = m - 1 >> 0, ((x$4 < 0 || x$4 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + x$4]))); - _r$1 = x.Text(112, 0); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$1 = new $String(_r$1); - _r$2 = fmt.Sprintf("msb not set in last word %#x of %s", new sliceType([_arg, _arg$1])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $panic(new $String(_r$2)); - /* } */ case 2: - if (x.prec === 0) { - $panic(new $String("zero precision finite number")); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.validate }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.m = m; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.validate = function() { return this.$val.validate(); }; - Float.ptr.prototype.round = function(sbit) { - var _1, _index, _q, bits$1, inc, lsb, m, n, ntz, r, rbit, sbit, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _index = $f._index; _q = $f._q; bits$1 = $f.bits$1; inc = $f.inc; lsb = $f.lsb; m = $f.m; n = $f.n; ntz = $f.ntz; r = $f.r; rbit = $f.rbit; sbit = $f.sbit; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = z.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - z.acc = 0; - if (!((z.form === 1))) { - $s = -1; return; - } - m = ((z.mant.$length >>> 0)); - bits$1 = $imul(m, 32) >>> 0; - if (bits$1 <= z.prec) { - $s = -1; return; - } - r = ((((bits$1 - z.prec >>> 0) - 1 >>> 0) >>> 0)); - rbit = (z.mant.bit(r) & 1) >>> 0; - if ((sbit === 0) && ((rbit === 0) || (z.mode === 0))) { - sbit = z.mant.sticky(r); - } - sbit = (sbit & (1)) >>> 0; - n = (_q = ((z.prec + 31 >>> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - if (m > n) { - $copySlice(z.mant, $subslice(z.mant, (m - n >>> 0))); - z.mant = $subslice(z.mant, 0, n); - } - ntz = ($imul(n, 32) >>> 0) - z.prec >>> 0; - lsb = (y = ntz, y < 32 ? (1 << y) : 0) >>> 0; - if (!((((rbit | sbit) >>> 0) === 0))) { - inc = false; - _1 = z.mode; - if (_1 === (4)) { - inc = z.neg; - } else if (_1 === (2)) { - } else if (_1 === (0)) { - inc = !((rbit === 0)) && (!((sbit === 0)) || !(((((x = z.mant, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) & lsb) >>> 0) === 0))); - } else if (_1 === (1)) { - inc = !((rbit === 0)); - } else if (_1 === (3)) { - inc = true; - } else if (_1 === (5)) { - inc = !z.neg; - } else { - $panic(new $String("unreachable")); - } - z.acc = makeAcc(!(inc === z.neg)); - if (inc) { - if (!((addVW((x$1 = z.mant, $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (x$2 = z.mant, $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), lsb) === 0))) { - if (z.exp >= 2147483647) { - z.form = 2; - $s = -1; return; - } - z.exp = z.exp + (1) >> 0; - shrVU((x$3 = z.mant, $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = z.mant, $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), 1); - _index = n - 1 >>> 0; - (x$6 = z.mant, ((_index < 0 || _index >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + _index] = (((x$5 = z.mant, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index])) | (2147483648)) >>> 0))); - } - } - } - (x$8 = z.mant, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0] = (((x$7 = z.mant, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])) & ~((lsb - 1 >>> 0))) >>> 0))); - /* */ if (false) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (false) { */ case 4: - $r = z.validate(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 5: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.round }; } $f._1 = _1; $f._index = _index; $f._q = _q; $f.bits$1 = bits$1; $f.inc = inc; $f.lsb = lsb; $f.m = m; $f.n = n; $f.ntz = ntz; $f.r = r; $f.rbit = rbit; $f.sbit = sbit; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.round = function(sbit) { return this.$val.round(sbit); }; - Float.ptr.prototype.setBits64 = function(neg, x) { - var neg, s, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; neg = $f.neg; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (z.prec === 0) { - z.prec = 64; - } - z.acc = 0; - z.neg = neg; - if ((x.$high === 0 && x.$low === 0)) { - z.form = 0; - $s = -1; return z; - } - z.form = 1; - s = bits.LeadingZeros64(x); - z.mant = z.mant.setUint64($shiftLeft64(x, ((s >>> 0)))); - z.exp = (((64 - s >> 0) >> 0)); - /* */ if (z.prec < 64) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (z.prec < 64) { */ case 1: - $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.setBits64 }; } $f.neg = neg; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.setBits64 = function(neg, x) { return this.$val.setBits64(neg, x); }; - Float.ptr.prototype.SetUint64 = function(x) { - var _r$1, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.setBits64(false, x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetUint64 }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetUint64 = function(x) { return this.$val.SetUint64(x); }; - Float.ptr.prototype.SetInt64 = function(x) { - var _r$1, u, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; u = $f.u; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - u = x; - if ((u.$high < 0 || (u.$high === 0 && u.$low < 0))) { - u = new $Int64(-u.$high, -u.$low); - } - _r$1 = z.setBits64((x.$high < 0 || (x.$high === 0 && x.$low < 0)), (new $Uint64(u.$high, u.$low))); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetInt64 }; } $f._r$1 = _r$1; $f.u = u; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; - Float.ptr.prototype.SetFloat64 = function(x) { - var _tuple, exp, fmant, x, x$1, x$2, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; exp = $f.exp; fmant = $f.fmant; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (z.prec === 0) { - z.prec = 53; - } - if (math.IsNaN(x)) { - $panic((x$1 = new ErrNaN.ptr("Float.SetFloat64(NaN)"), new x$1.constructor.elem(x$1))); - } - z.acc = 0; - z.neg = math.Signbit(x); - if (x === 0) { - z.form = 0; - $s = -1; return z; - } - if (math.IsInf(x, 0)) { - z.form = 2; - $s = -1; return z; - } - z.form = 1; - _tuple = math.Frexp(x); - fmant = _tuple[0]; - exp = _tuple[1]; - z.mant = z.mant.setUint64((x$2 = $shiftLeft64(math.Float64bits(fmant), 11), new $Uint64(2147483648 | x$2.$high, (0 | x$2.$low) >>> 0))); - z.exp = ((exp >> 0)); - /* */ if (z.prec < 53) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (z.prec < 53) { */ case 1: - $r = z.round(0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetFloat64 }; } $f._tuple = _tuple; $f.exp = exp; $f.fmant = fmant; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetFloat64 = function(x) { return this.$val.SetFloat64(x); }; - fnorm = function(m) { - var c, m, s, x, x$1; - if (false && ((m.$length === 0) || ((x = m.$length - 1 >> 0, ((x < 0 || x >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x])) === 0))) { - $panic(new $String("msw of mantissa is 0")); - } - s = nlz((x$1 = m.$length - 1 >> 0, ((x$1 < 0 || x$1 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$1]))); - if (s > 0) { - c = shlVU($subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), s); - if (false && !((c === 0))) { - $panic(new $String("nlz or shlVU incorrect")); - } - } - return (new $Int64(0, s)); - }; - Float.ptr.prototype.SetInt = function(x) { - var bits$1, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; bits$1 = $f.bits$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - bits$1 = ((x.BitLen() >>> 0)); - if (z.prec === 0) { - z.prec = umax32(bits$1, 64); - } - z.acc = 0; - z.neg = x.neg; - if (x.abs.$length === 0) { - z.form = 0; - $s = -1; return z; - } - z.mant = z.mant.set(x.abs); - fnorm(z.mant); - $r = z.setExpAndRound((new $Int64(0, bits$1)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetInt }; } $f.bits$1 = bits$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; - Float.ptr.prototype.SetRat = function(x) { - var _r$1, _r$2, _r$3, _r$4, _tmp, _tmp$1, a, b, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - b = [b]; - z = this; - /* */ if (x.IsInt()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (x.IsInt()) { */ case 1: - _r$1 = z.SetInt(x.Num()); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - _tmp = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - _tmp$1 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - a[0] = $clone(_tmp, Float); - b[0] = $clone(_tmp$1, Float); - _r$2 = a[0].SetInt(x.Num()); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - _r$3 = b[0].SetInt(x.Denom()); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - if (z.prec === 0) { - z.prec = umax32(a[0].prec, b[0].prec); - } - _r$4 = z.Quo(a[0], b[0]); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return _r$4; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetRat }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetRat = function(x) { return this.$val.SetRat(x); }; - Float.ptr.prototype.SetInf = function(signbit) { - var signbit, z; - z = this; - z.acc = 0; - z.form = 2; - z.neg = signbit; - return z; - }; - Float.prototype.SetInf = function(signbit) { return this.$val.SetInf(signbit); }; - Float.ptr.prototype.Set = function(x) { - var x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - z.acc = 0; - /* */ if (!(z === x)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!(z === x)) { */ case 4: - z.form = x.form; - z.neg = x.neg; - if (x.form === 1) { - z.exp = x.exp; - z.mant = z.mant.set(x.mant); - } - /* */ if (z.prec === 0) { $s = 6; continue; } - /* */ if (z.prec < x.prec) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (z.prec === 0) { */ case 6: - z.prec = x.prec; - $s = 8; continue; - /* } else if (z.prec < x.prec) { */ case 7: - $r = z.round(0); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 8: - /* } */ case 5: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Set }; } $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Set = function(x) { return this.$val.Set(x); }; - Float.ptr.prototype.Copy = function(x) { - var x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (!(z === x)) { - z.prec = x.prec; - z.mode = x.mode; - z.acc = x.acc; - z.form = x.form; - z.neg = x.neg; - if (z.form === 1) { - z.mant = z.mant.set(x.mant); - z.exp = x.exp; - } - } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Copy }; } $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Copy = function(x) { return this.$val.Copy(x); }; - msb32 = function(x) { - var _1, i, x; - i = x.$length - 1 >> 0; - if (i < 0) { - return 0; - } - if (false && (((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & 2147483648) >>> 0) === 0)) { - $panic(new $String("x not normalized")); - } - _1 = 32; - if (_1 === (32)) { - return ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0)); - } else if (_1 === (64)) { - return ((0 >>> 0)); - } - $panic(new $String("unreachable")); - }; - msb64 = function(x) { - var _1, i, v, x, x$1, x$2, x$3, x$4, x$5; - i = x.$length - 1 >> 0; - if (i < 0) { - return new $Uint64(0, 0); - } - if (false && (((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & 2147483648) >>> 0) === 0)) { - $panic(new $String("x not normalized")); - } - _1 = 32; - if (_1 === (32)) { - v = $shiftLeft64(((x$1 = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), new $Uint64(0, x$1.constructor === Number ? x$1 : 1))), 32); - if (i > 0) { - v = (x$2 = ((x$3 = (x$4 = i - 1 >> 0, ((x$4 < 0 || x$4 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$4])), new $Uint64(0, x$3.constructor === Number ? x$3 : 1))), new $Uint64(v.$high | x$2.$high, (v.$low | x$2.$low) >>> 0)); - } - return v; - } else if (_1 === (64)) { - return ((x$5 = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), new $Uint64(0, x$5.constructor === Number ? x$5 : 1))); - } - $panic(new $String("unreachable")); - }; - Float.ptr.prototype.Uint64 = function() { - var _1, u, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; u = $f.u; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _1 = x.form; - if (_1 === (1)) { - if (x.neg) { - $s = -1; return [new $Uint64(0, 0), 1]; - } - if (x.exp <= 0) { - $s = -1; return [new $Uint64(0, 0), -1]; - } - if (x.exp <= 64) { - u = $shiftRightUint64(msb64(x.mant), ((64 - ((x.exp >>> 0)) >>> 0))); - if (x.MinPrec() <= 64) { - $s = -1; return [u, 0]; - } - $s = -1; return [u, -1]; - } - $s = -1; return [new $Uint64(4294967295, 4294967295), -1]; - } else if (_1 === (0)) { - $s = -1; return [new $Uint64(0, 0), 0]; - } else if (_1 === (2)) { - if (x.neg) { - $s = -1; return [new $Uint64(0, 0), 1]; - } - $s = -1; return [new $Uint64(4294967295, 4294967295), -1]; - } - $panic(new $String("unreachable")); - $s = -1; return [new $Uint64(0, 0), 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Uint64 }; } $f._1 = _1; $f.u = u; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Uint64 = function() { return this.$val.Uint64(); }; - Float.ptr.prototype.Int64 = function() { - var _1, acc, i, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; acc = $f.acc; i = $f.i; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _1 = x.form; - if (_1 === (1)) { - acc = makeAcc(x.neg); - if (x.exp <= 0) { - $s = -1; return [new $Int64(0, 0), acc]; - } - if (x.exp <= 63) { - i = ((x$1 = $shiftRightUint64(msb64(x.mant), ((64 - ((x.exp >>> 0)) >>> 0))), new $Int64(x$1.$high, x$1.$low))); - if (x.neg) { - i = new $Int64(-i.$high, -i.$low); - } - if (x.MinPrec() <= ((x.exp >>> 0))) { - $s = -1; return [i, 0]; - } - $s = -1; return [i, acc]; - } - if (x.neg) { - if ((x.exp === 64) && (x.MinPrec() === 1)) { - acc = 0; - } - $s = -1; return [new $Int64(-2147483648, 0), acc]; - } - $s = -1; return [new $Int64(2147483647, 4294967295), -1]; - } else if (_1 === (0)) { - $s = -1; return [new $Int64(0, 0), 0]; - } else if (_1 === (2)) { - if (x.neg) { - $s = -1; return [new $Int64(-2147483648, 0), 1]; - } - $s = -1; return [new $Int64(2147483647, 4294967295), -1]; - } - $panic(new $String("unreachable")); - $s = -1; return [new $Int64(0, 0), 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Int64 }; } $f._1 = _1; $f.acc = acc; $f.i = i; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Int64 = function() { return this.$val.Int64(); }; - Float.ptr.prototype.Float32 = function() { - var _1, _r$1, _tmp, _tmp$1, _tmp$2, bexp, e, mant, p, r, sign, x, y, z, z$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; bexp = $f.bexp; e = $f.e; mant = $f.mant; p = $f.p; r = $f.r; sign = $f.sign; x = $f.x; y = $f.y; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _1 = x.form; - /* */ if (_1 === (1)) { $s = 5; continue; } - /* */ if (_1 === (0)) { $s = 6; continue; } - /* */ if (_1 === (2)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_1 === (1)) { */ case 5: - e = x.exp - 1 >> 0; - p = 24; - if (e < -126) { - p = 150 + ((e >> 0)) >> 0; - if (p < 0 || (p === 0) && (x.mant.sticky((((x.mant.$length >>> 0)) * 32 >>> 0) - 1 >>> 0) === 0)) { - if (x.neg) { - z = 0; - $s = -1; return [-z, 1]; - } - $s = -1; return [0, -1]; - } - if (p === 0) { - if (x.neg) { - $s = -1; return [-1.401298464324817e-45, -1]; - } - $s = -1; return [1.401298464324817e-45, 1]; - } - } - r = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - r.prec = ((p >>> 0)); - _r$1 = r.Set(x); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - e = r.exp - 1 >> 0; - if ((r.form === 2) || e > 127) { - if (x.neg) { - $s = -1; return [($fround(math.Inf(-1))), -1]; - } - $s = -1; return [($fround(math.Inf(1))), 1]; - } - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = 0; - sign = _tmp; - bexp = _tmp$1; - mant = _tmp$2; - if (x.neg) { - sign = 2147483648; - } - if (e < -126) { - p = 150 + ((e >> 0)) >> 0; - mant = (y = (((32 - p >> 0) >>> 0)), y < 32 ? (msb32(r.mant) >>> y) : 0) >>> 0; - } else { - bexp = (((e + 127 >> 0) >>> 0)) << 23 >>> 0; - mant = ((msb32(r.mant) >>> 8 >>> 0) & 8388607) >>> 0; - } - $s = -1; return [math.Float32frombits((((sign | bexp) >>> 0) | mant) >>> 0), r.acc]; - /* } else if (_1 === (0)) { */ case 6: - if (x.neg) { - z$1 = 0; - $s = -1; return [-z$1, 0]; - } - $s = -1; return [0, 0]; - /* } else if (_1 === (2)) { */ case 7: - if (x.neg) { - $s = -1; return [($fround(math.Inf(-1))), 0]; - } - $s = -1; return [($fround(math.Inf(1))), 0]; - /* } */ case 8: - case 4: - $panic(new $String("unreachable")); - $s = -1; return [0, 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Float32 }; } $f._1 = _1; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.bexp = bexp; $f.e = e; $f.mant = mant; $f.p = p; $f.r = r; $f.sign = sign; $f.x = x; $f.y = y; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Float32 = function() { return this.$val.Float32(); }; - Float.ptr.prototype.Float64 = function() { - var _1, _r$1, _tmp, _tmp$1, _tmp$2, bexp, e, mant, p, r, sign, x, x$1, x$2, z, z$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; bexp = $f.bexp; e = $f.e; mant = $f.mant; p = $f.p; r = $f.r; sign = $f.sign; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - _1 = x.form; - /* */ if (_1 === (1)) { $s = 5; continue; } - /* */ if (_1 === (0)) { $s = 6; continue; } - /* */ if (_1 === (2)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_1 === (1)) { */ case 5: - e = x.exp - 1 >> 0; - p = 53; - if (e < -1022) { - p = 1075 + ((e >> 0)) >> 0; - if (p < 0 || (p === 0) && (x.mant.sticky((((x.mant.$length >>> 0)) * 32 >>> 0) - 1 >>> 0) === 0)) { - if (x.neg) { - z = 0; - $s = -1; return [-z, 1]; - } - $s = -1; return [0, -1]; - } - if (p === 0) { - if (x.neg) { - $s = -1; return [-5e-324, -1]; - } - $s = -1; return [5e-324, 1]; - } - } - r = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - r.prec = ((p >>> 0)); - _r$1 = r.Set(x); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - e = r.exp - 1 >> 0; - if ((r.form === 2) || e > 1023) { - if (x.neg) { - $s = -1; return [math.Inf(-1), -1]; - } - $s = -1; return [math.Inf(1), 1]; - } - _tmp = new $Uint64(0, 0); - _tmp$1 = new $Uint64(0, 0); - _tmp$2 = new $Uint64(0, 0); - sign = _tmp; - bexp = _tmp$1; - mant = _tmp$2; - if (x.neg) { - sign = new $Uint64(2147483648, 0); - } - if (e < -1022) { - p = 1075 + ((e >> 0)) >> 0; - mant = $shiftRightUint64(msb64(r.mant), (((64 - p >> 0) >>> 0))); - } else { - bexp = $shiftLeft64((new $Uint64(0, (e + 1023 >> 0))), 52); - mant = (x$1 = $shiftRightUint64(msb64(r.mant), 11), new $Uint64(x$1.$high & 1048575, (x$1.$low & 4294967295) >>> 0)); - } - $s = -1; return [math.Float64frombits((x$2 = new $Uint64(sign.$high | bexp.$high, (sign.$low | bexp.$low) >>> 0), new $Uint64(x$2.$high | mant.$high, (x$2.$low | mant.$low) >>> 0))), r.acc]; - /* } else if (_1 === (0)) { */ case 6: - if (x.neg) { - z$1 = 0; - $s = -1; return [-z$1, 0]; - } - $s = -1; return [0, 0]; - /* } else if (_1 === (2)) { */ case 7: - if (x.neg) { - $s = -1; return [math.Inf(-1), 0]; - } - $s = -1; return [math.Inf(1), 0]; - /* } */ case 8: - case 4: - $panic(new $String("unreachable")); - $s = -1; return [0, 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Float64 }; } $f._1 = _1; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.bexp = bexp; $f.e = e; $f.mant = mant; $f.p = p; $f.r = r; $f.sign = sign; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Float64 = function() { return this.$val.Float64(); }; - Float.ptr.prototype.Int = function(z) { - var _1, acc, allBits, exp, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; acc = $f.acc; allBits = $f.allBits; exp = $f.exp; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z === ptrType$1.nil && x.form <= 1) { - z = new Int.ptr(false, nat.nil); - } - _1 = x.form; - if (_1 === (1)) { - acc = makeAcc(x.neg); - if (x.exp <= 0) { - $s = -1; return [z.SetInt64(new $Int64(0, 0)), acc]; - } - allBits = ((x.mant.$length >>> 0)) * 32 >>> 0; - exp = ((x.exp >>> 0)); - if (x.MinPrec() <= exp) { - acc = 0; - } - if (z === ptrType$1.nil) { - z = new Int.ptr(false, nat.nil); - } - z.neg = x.neg; - if (exp > allBits) { - z.abs = z.abs.shl(x.mant, exp - allBits >>> 0); - } else if (exp < allBits) { - z.abs = z.abs.shr(x.mant, allBits - exp >>> 0); - } else { - z.abs = z.abs.set(x.mant); - } - $s = -1; return [z, acc]; - } else if (_1 === (0)) { - $s = -1; return [z.SetInt64(new $Int64(0, 0)), 0]; - } else if (_1 === (2)) { - $s = -1; return [ptrType$1.nil, makeAcc(x.neg)]; - } - $panic(new $String("unreachable")); - $s = -1; return [ptrType$1.nil, 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Int }; } $f._1 = _1; $f.acc = acc; $f.allBits = allBits; $f.exp = exp; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Int = function(z) { return this.$val.Int(z); }; - Float.ptr.prototype.Rat = function(z) { - var _1, _r$1, allBits, t, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; allBits = $f.allBits; t = $f.t; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z === ptrType$2.nil && x.form <= 1) { - z = new Rat.ptr(new Int.ptr(false, nat.nil), new Int.ptr(false, nat.nil)); - } - _1 = x.form; - /* */ if (_1 === (1)) { $s = 5; continue; } - /* */ if (_1 === (0)) { $s = 6; continue; } - /* */ if (_1 === (2)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (_1 === (1)) { */ case 5: - allBits = $imul(((x.mant.$length >> 0)), 32); - z.a.neg = x.neg; - /* */ if (x.exp > allBits) { $s = 10; continue; } - /* */ if (x.exp < allBits) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (x.exp > allBits) { */ case 10: - z.a.abs = z.a.abs.shl(x.mant, (((x.exp - allBits >> 0) >>> 0))); - z.b.abs = $subslice(z.b.abs, 0, 0); - $s = 13; continue; - /* } else if (x.exp < allBits) { */ case 11: - z.a.abs = z.a.abs.set(x.mant); - t = z.b.abs.setUint64(new $Uint64(0, 1)); - z.b.abs = t.shl(t, (((allBits - x.exp >> 0) >>> 0))); - _r$1 = z.norm(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = 13; continue; - /* } else { */ case 12: - z.a.abs = z.a.abs.set(x.mant); - z.b.abs = $subslice(z.b.abs, 0, 0); - /* } */ case 13: - case 9: - $s = -1; return [z, 0]; - /* } else if (_1 === (0)) { */ case 6: - $s = -1; return [z.SetInt64(new $Int64(0, 0)), 0]; - /* } else if (_1 === (2)) { */ case 7: - $s = -1; return [ptrType$2.nil, makeAcc(x.neg)]; - /* } */ case 8: - case 4: - $panic(new $String("unreachable")); - $s = -1; return [ptrType$2.nil, 0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Rat }; } $f._1 = _1; $f._r$1 = _r$1; $f.allBits = allBits; $f.t = t; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Rat = function(z) { return this.$val.Rat(z); }; - Float.ptr.prototype.Abs = function(x) { - var _r$1, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.Set(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - z.neg = false; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Abs }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Abs = function(x) { return this.$val.Abs(x); }; - Float.ptr.prototype.Neg = function(x) { - var _r$1, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.Set(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - z.neg = !z.neg; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Neg }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Neg = function(x) { return this.$val.Neg(x); }; - validateBinaryOperands = function(x, y) { - var x, y; - if (true) { - $panic(new $String("validateBinaryOperands called but debugFloat is not set")); - } - if (x.mant.$length === 0) { - $panic(new $String("empty mantissa for x")); - } - if (y.mant.$length === 0) { - $panic(new $String("empty mantissa for y")); - } - }; - Float.ptr.prototype.uadd = function(x, y) { - var al, ex, ey, t, t$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; al = $f.al; ex = $f.ex; ey = $f.ey; t = $f.t; t$1 = $f.t$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (false) { - validateBinaryOperands(x, y); - } - ex = (x$1 = (new $Int64(0, x.exp)), x$2 = $mul64((new $Int64(0, x.mant.$length)), new $Int64(0, 32)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - ey = (x$3 = (new $Int64(0, y.exp)), x$4 = $mul64((new $Int64(0, y.mant.$length)), new $Int64(0, 32)), new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)); - al = alias(z.mant, x.mant) || alias(z.mant, y.mant); - if ((ex.$high < ey.$high || (ex.$high === ey.$high && ex.$low < ey.$low))) { - if (al) { - t = (nat.nil).shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); - z.mant = z.mant.add(x.mant, t); - } else { - z.mant = z.mant.shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); - z.mant = z.mant.add(x.mant, z.mant); - } - } else if ((ex.$high > ey.$high || (ex.$high === ey.$high && ex.$low > ey.$low))) { - if (al) { - t$1 = (nat.nil).shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); - z.mant = z.mant.add(t$1, y.mant); - } else { - z.mant = z.mant.shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); - z.mant = z.mant.add(z.mant, y.mant); - } - ex = ey; - } else { - z.mant = z.mant.add(x.mant, y.mant); - } - $r = z.setExpAndRound((x$5 = (x$6 = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), new $Int64(ex.$high + x$6.$high, ex.$low + x$6.$low)), x$7 = fnorm(z.mant), new $Int64(x$5.$high - x$7.$high, x$5.$low - x$7.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.uadd }; } $f.al = al; $f.ex = ex; $f.ey = ey; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.uadd = function(x, y) { return this.$val.uadd(x, y); }; - Float.ptr.prototype.usub = function(x, y) { - var al, ex, ey, t, t$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; al = $f.al; ex = $f.ex; ey = $f.ey; t = $f.t; t$1 = $f.t$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (false) { - validateBinaryOperands(x, y); - } - ex = (x$1 = (new $Int64(0, x.exp)), x$2 = $mul64((new $Int64(0, x.mant.$length)), new $Int64(0, 32)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - ey = (x$3 = (new $Int64(0, y.exp)), x$4 = $mul64((new $Int64(0, y.mant.$length)), new $Int64(0, 32)), new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)); - al = alias(z.mant, x.mant) || alias(z.mant, y.mant); - if ((ex.$high < ey.$high || (ex.$high === ey.$high && ex.$low < ey.$low))) { - if (al) { - t = (nat.nil).shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); - z.mant = t.sub(x.mant, t); - } else { - z.mant = z.mant.shl(y.mant, ((new $Int64(ey.$high - ex.$high, ey.$low - ex.$low).$low >>> 0))); - z.mant = z.mant.sub(x.mant, z.mant); - } - } else if ((ex.$high > ey.$high || (ex.$high === ey.$high && ex.$low > ey.$low))) { - if (al) { - t$1 = (nat.nil).shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); - z.mant = t$1.sub(t$1, y.mant); - } else { - z.mant = z.mant.shl(x.mant, ((new $Int64(ex.$high - ey.$high, ex.$low - ey.$low).$low >>> 0))); - z.mant = z.mant.sub(z.mant, y.mant); - } - ex = ey; - } else { - z.mant = z.mant.sub(x.mant, y.mant); - } - if (z.mant.$length === 0) { - z.acc = 0; - z.form = 0; - z.neg = false; - $s = -1; return; - } - $r = z.setExpAndRound((x$5 = (x$6 = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), new $Int64(ex.$high + x$6.$high, ex.$low + x$6.$low)), x$7 = fnorm(z.mant), new $Int64(x$5.$high - x$7.$high, x$5.$low - x$7.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.usub }; } $f.al = al; $f.ex = ex; $f.ey = ey; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.usub = function(x, y) { return this.$val.usub(x, y); }; - Float.ptr.prototype.umul = function(x, y) { - var e, x, x$1, x$2, x$3, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; e = $f.e; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (false) { - validateBinaryOperands(x, y); - } - e = (x$1 = (new $Int64(0, x.exp)), x$2 = (new $Int64(0, y.exp)), new $Int64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)); - if (x === y) { - z.mant = z.mant.sqr(x.mant); - } else { - z.mant = z.mant.mul(x.mant, y.mant); - } - $r = z.setExpAndRound((x$3 = fnorm(z.mant), new $Int64(e.$high - x$3.$high, e.$low - x$3.$low)), 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.umul }; } $f.e = e; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.umul = function(x, y) { return this.$val.umul(x, y); }; - Float.ptr.prototype.uquo = function(x, y) { - var _q, _r$1, _tuple, d, d$1, e, n, r, sbit, x, x$1, x$2, x$3, x$4, x$5, xadj, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _tuple = $f._tuple; d = $f.d; d$1 = $f.d$1; e = $f.e; n = $f.n; r = $f.r; sbit = $f.sbit; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; xadj = $f.xadj; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (false) { - validateBinaryOperands(x, y); - } - n = (((_q = z.prec / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) + 1 >> 0; - xadj = x.mant; - d = (n - x.mant.$length >> 0) + y.mant.$length >> 0; - if (d > 0) { - xadj = $makeSlice(nat, (x.mant.$length + d >> 0)); - $copySlice($subslice(xadj, d), x.mant); - } - d$1 = xadj.$length - y.mant.$length >> 0; - r = nat.nil; - _r$1 = z.mant.div(nat.nil, xadj, y.mant); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z.mant = _tuple[0]; - r = _tuple[1]; - e = (x$1 = (x$2 = (new $Int64(0, x.exp)), x$3 = (new $Int64(0, y.exp)), new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low)), x$4 = $mul64((new $Int64(0, (d$1 - z.mant.$length >> 0))), new $Int64(0, 32)), new $Int64(x$1.$high - x$4.$high, x$1.$low - x$4.$low)); - sbit = 0; - if (r.$length > 0) { - sbit = 1; - } - $r = z.setExpAndRound((x$5 = fnorm(z.mant), new $Int64(e.$high - x$5.$high, e.$low - x$5.$low)), sbit); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.uquo }; } $f._q = _q; $f._r$1 = _r$1; $f._tuple = _tuple; $f.d = d; $f.d$1 = d$1; $f.e = e; $f.n = n; $f.r = r; $f.sbit = sbit; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.xadj = xadj; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.uquo = function(x, y) { return this.$val.uquo(x, y); }; - Float.ptr.prototype.ucmp = function(y) { - var _tmp, _tmp$1, i, j, x, x$1, x$2, xm, y, ym; - x = this; - if (false) { - validateBinaryOperands(x, y); - } - if (x.exp < y.exp) { - return -1; - } else if (x.exp > y.exp) { - return 1; - } - i = x.mant.$length; - j = y.mant.$length; - while (true) { - if (!(i > 0 || j > 0)) { break; } - _tmp = 0; - _tmp$1 = 0; - xm = _tmp; - ym = _tmp$1; - if (i > 0) { - i = i - (1) >> 0; - xm = (x$1 = x.mant, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])); - } - if (j > 0) { - j = j - (1) >> 0; - ym = (x$2 = y.mant, ((j < 0 || j >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j])); - } - if (xm < ym) { - return -1; - } else if (xm > ym) { - return 1; - } - } - return 0; - }; - Float.prototype.ucmp = function(y) { return this.$val.ucmp(y); }; - Float.ptr.prototype.Add = function(x, y) { - var _r$1, _r$2, x, x$1, y, yneg, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; x$1 = $f.x$1; y = $f.y; yneg = $f.yneg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z.prec === 0) { - z.prec = umax32(x.prec, y.prec); - } - /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((x.form === 1) && (y.form === 1)) { */ case 5: - yneg = y.neg; - z.neg = x.neg; - /* */ if (x.neg === yneg) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (x.neg === yneg) { */ case 7: - $r = z.uadd(x, y); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 9; continue; - /* } else { */ case 8: - /* */ if (x.ucmp(y) > 0) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (x.ucmp(y) > 0) { */ case 11: - $r = z.usub(x, y); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 13; continue; - /* } else { */ case 12: - z.neg = !z.neg; - $r = z.usub(y, x); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 13: - /* } */ case 9: - if ((z.form === 0) && (z.mode === 4) && (z.acc === 0)) { - z.neg = true; - } - $s = -1; return z; - /* } */ case 6: - if ((x.form === 2) && (y.form === 2) && !(x.neg === y.neg)) { - z.acc = 0; - z.form = 0; - z.neg = false; - $panic((x$1 = new ErrNaN.ptr("addition of infinities with opposite signs"), new x$1.constructor.elem(x$1))); - } - if ((x.form === 0) && (y.form === 0)) { - z.acc = 0; - z.form = 0; - z.neg = x.neg && y.neg; - $s = -1; return z; - } - /* */ if ((x.form === 2) || (y.form === 0)) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if ((x.form === 2) || (y.form === 0)) { */ case 16: - _r$1 = z.Set(x); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 17: - _r$2 = z.Set(y); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Add }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.yneg = yneg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; - Float.ptr.prototype.Sub = function(x, y) { - var _r$1, _r$2, x, x$1, y, yneg, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; x$1 = $f.x$1; y = $f.y; yneg = $f.yneg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z.prec === 0) { - z.prec = umax32(x.prec, y.prec); - } - /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((x.form === 1) && (y.form === 1)) { */ case 5: - yneg = y.neg; - z.neg = x.neg; - /* */ if (!(x.neg === yneg)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!(x.neg === yneg)) { */ case 7: - $r = z.uadd(x, y); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 9; continue; - /* } else { */ case 8: - /* */ if (x.ucmp(y) > 0) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (x.ucmp(y) > 0) { */ case 11: - $r = z.usub(x, y); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 13; continue; - /* } else { */ case 12: - z.neg = !z.neg; - $r = z.usub(y, x); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 13: - /* } */ case 9: - if ((z.form === 0) && (z.mode === 4) && (z.acc === 0)) { - z.neg = true; - } - $s = -1; return z; - /* } */ case 6: - if ((x.form === 2) && (y.form === 2) && x.neg === y.neg) { - z.acc = 0; - z.form = 0; - z.neg = false; - $panic((x$1 = new ErrNaN.ptr("subtraction of infinities with equal signs"), new x$1.constructor.elem(x$1))); - } - if ((x.form === 0) && (y.form === 0)) { - z.acc = 0; - z.form = 0; - z.neg = x.neg && !y.neg; - $s = -1; return z; - } - /* */ if ((x.form === 2) || (y.form === 0)) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if ((x.form === 2) || (y.form === 0)) { */ case 16: - _r$1 = z.Set(x); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 17: - _r$2 = z.Neg(y); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sub }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.yneg = yneg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; - Float.ptr.prototype.Mul = function(x, y) { - var x, x$1, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z.prec === 0) { - z.prec = umax32(x.prec, y.prec); - } - z.neg = !(x.neg === y.neg); - /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((x.form === 1) && (y.form === 1)) { */ case 5: - $r = z.umul(x, y); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return z; - /* } */ case 6: - z.acc = 0; - if ((x.form === 0) && (y.form === 2) || (x.form === 2) && (y.form === 0)) { - z.form = 0; - z.neg = false; - $panic((x$1 = new ErrNaN.ptr("multiplication of zero with infinity"), new x$1.constructor.elem(x$1))); - } - if ((x.form === 2) || (y.form === 2)) { - z.form = 2; - $s = -1; return z; - } - z.form = 0; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Mul }; } $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; - Float.ptr.prototype.Quo = function(x, y) { - var x, x$1, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z.prec === 0) { - z.prec = umax32(x.prec, y.prec); - } - z.neg = !(x.neg === y.neg); - /* */ if ((x.form === 1) && (y.form === 1)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if ((x.form === 1) && (y.form === 1)) { */ case 5: - $r = z.uquo(x, y); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return z; - /* } */ case 6: - z.acc = 0; - if ((x.form === 0) && (y.form === 0) || (x.form === 2) && (y.form === 2)) { - z.form = 0; - z.neg = false; - $panic((x$1 = new ErrNaN.ptr("division of zero by zero or infinity by infinity"), new x$1.constructor.elem(x$1))); - } - if ((x.form === 0) || (y.form === 2)) { - z.form = 0; - $s = -1; return z; - } - z.form = 2; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Quo }; } $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; - Float.ptr.prototype.Cmp = function(y) { - var _1, mx, my, x, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; mx = $f.mx; my = $f.my; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = y.validate(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - mx = x.ord(); - my = y.ord(); - if (mx < my) { - $s = -1; return -1; - } else if (mx > my) { - $s = -1; return 1; - } - _1 = mx; - if (_1 === (-1)) { - $s = -1; return y.ucmp(x); - } else if (_1 === (1)) { - $s = -1; return x.ucmp(y); - } - $s = -1; return 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Cmp }; } $f._1 = _1; $f.mx = mx; $f.my = my; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; - Float.ptr.prototype.ord = function() { - var _1, m, x; - x = this; - m = 0; - _1 = x.form; - if (_1 === (1)) { - m = 1; - } else if (_1 === (0)) { - return 0; - } else if (_1 === (2)) { - m = 2; - } - if (x.neg) { - m = -m; - } - return m; - }; - Float.prototype.ord = function() { return this.$val.ord(); }; - umax32 = function(x, y) { - var x, y; - if (x > y) { - return x; - } - return y; - }; - Float.ptr.prototype.SetString = function(s) { - var _r$1, _tuple, err, f, s, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; f = $f.f; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.Parse(s, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - f = _tuple[0]; - err = _tuple[2]; - if ($interfaceIsEqual(err, $ifaceNil)) { - $s = -1; return [f, true]; - } - $s = -1; return [ptrType.nil, false]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.SetString = function(s) { return this.$val.SetString(s); }; - Float.ptr.prototype.scan = function(r, base) { - var _1, _2, _arg, _arg$1, _arg$2, _arg$3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _tuple$2, b, base, d, ebase, err, exp, exp2, exp5, f, fcount, p, prec, r, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; b = $f.b; base = $f.base; d = $f.d; ebase = $f.ebase; err = $f.err; exp = $f.exp; exp2 = $f.exp2; exp5 = $f.exp5; f = $f.f; fcount = $f.fcount; p = $f.p; prec = $f.prec; r = $f.r; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = ptrType.nil; - b = 0; - err = $ifaceNil; - z = this; - prec = z.prec; - if (prec === 0) { - prec = 64; - } - z.form = 0; - _r$1 = scanSign(r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z.neg = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [f, b, err]; - } - fcount = 0; - _r$2 = z.mant.scan(r, base, true); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - z.mant = _tuple$1[0]; - b = _tuple$1[1]; - fcount = _tuple$1[2]; - err = _tuple$1[3]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [f, b, err]; - } - exp = new $Int64(0, 0); - ebase = 0; - _r$3 = scanExponent(r, true); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$2 = _r$3; - exp = _tuple$2[0]; - ebase = _tuple$2[1]; - err = _tuple$2[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [f, b, err]; - } - if (z.mant.$length === 0) { - z.prec = prec; - z.acc = 0; - z.form = 0; - f = z; - $s = -1; return [f, b, err]; - } - exp2 = (x = $mul64((new $Int64(0, z.mant.$length)), new $Int64(0, 32)), x$1 = fnorm(z.mant), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low)); - exp5 = new $Int64(0, 0); - if (fcount < 0) { - d = (new $Int64(0, fcount)); - _1 = b; - if (_1 === (10)) { - exp5 = d; - exp2 = (x$2 = d, new $Int64(exp2.$high + x$2.$high, exp2.$low + x$2.$low)); - } else if (_1 === (2)) { - exp2 = (x$3 = d, new $Int64(exp2.$high + x$3.$high, exp2.$low + x$3.$low)); - } else if (_1 === (16)) { - exp2 = (x$4 = $mul64(d, new $Int64(0, 4)), new $Int64(exp2.$high + x$4.$high, exp2.$low + x$4.$low)); - } else { - $panic(new $String("unexpected mantissa base")); - } - } - _2 = ebase; - if (_2 === (10)) { - exp5 = (x$5 = exp, new $Int64(exp5.$high + x$5.$high, exp5.$low + x$5.$low)); - exp2 = (x$6 = exp, new $Int64(exp2.$high + x$6.$high, exp2.$low + x$6.$low)); - } else if (_2 === (2)) { - exp2 = (x$7 = exp, new $Int64(exp2.$high + x$7.$high, exp2.$low + x$7.$low)); - } else { - $panic(new $String("unexpected exponent base")); - } - /* */ if ((-1 < exp2.$high || (-1 === exp2.$high && 2147483648 <= exp2.$low)) && (exp2.$high < 0 || (exp2.$high === 0 && exp2.$low <= 2147483647))) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((-1 < exp2.$high || (-1 === exp2.$high && 2147483648 <= exp2.$low)) && (exp2.$high < 0 || (exp2.$high === 0 && exp2.$low <= 2147483647))) { */ case 4: - z.prec = prec; - z.form = 1; - z.exp = (((exp2.$low + ((exp2.$high >> 31) * 4294967296)) >> 0)); - f = z; - $s = 6; continue; - /* } else { */ case 5: - _r$4 = fmt.Errorf("exponent overflow", new sliceType([])); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - err = _r$4; - $s = -1; return [f, b, err]; - /* } */ case 6: - /* */ if ((exp5.$high === 0 && exp5.$low === 0)) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if ((exp5.$high === 0 && exp5.$low === 0)) { */ case 8: - $r = z.round(0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return [f, b, err]; - /* } */ case 9: - _r$5 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetPrec(z.Prec() + 64 >>> 0); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - p = _r$5; - /* */ if ((exp5.$high < 0 || (exp5.$high === 0 && exp5.$low < 0))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ((exp5.$high < 0 || (exp5.$high === 0 && exp5.$low < 0))) { */ case 12: - _arg = z; - _r$6 = p.pow5(((x$8 = new $Int64(-exp5.$high, -exp5.$low), new $Uint64(x$8.$high, x$8.$low)))); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _arg$1 = _r$6; - _r$7 = z.Quo(_arg, _arg$1); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _r$7; - $s = 14; continue; - /* } else { */ case 13: - _arg$2 = z; - _r$8 = p.pow5((new $Uint64(exp5.$high, exp5.$low))); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _arg$3 = _r$8; - _r$9 = z.Mul(_arg$2, _arg$3); /* */ $s = 18; case 18: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _r$9; - /* } */ case 14: - $s = -1; return [f, b, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.scan }; } $f._1 = _1; $f._2 = _2; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.b = b; $f.base = base; $f.d = d; $f.ebase = ebase; $f.err = err; $f.exp = exp; $f.exp2 = exp2; $f.exp5 = exp5; $f.f = f; $f.fcount = fcount; $f.p = p; $f.prec = prec; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.scan = function(r, base) { return this.$val.scan(r, base); }; - Float.ptr.prototype.pow5 = function(n) { - var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, f, n, x, x$1, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; f = $f.f; n = $f.n; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if ((n.$high < 0 || (n.$high === 0 && n.$low <= 27))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((n.$high < 0 || (n.$high === 0 && n.$low <= 27))) { */ case 1: - _r$1 = z.SetUint64((($flatten64(n) < 0 || $flatten64(n) >= pow5tab.length) ? ($throwRuntimeError("index out of range"), undefined) : pow5tab[$flatten64(n)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - _r$2 = z.SetUint64(pow5tab[27]); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - n = (x = new $Uint64(0, 27), new $Uint64(n.$high - x.$high, n.$low - x.$low)); - _r$3 = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0).SetPrec(z.Prec() + 64 >>> 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = _r$3.SetUint64(new $Uint64(0, 5)); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - f = _r$4; - /* while (true) { */ case 7: - /* if (!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { break; } */ if(!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { $s = 8; continue; } - /* */ if (!((x$1 = new $Uint64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 0)))) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (!((x$1 = new $Uint64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 0)))) { */ case 9: - _r$5 = z.Mul(z, f); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$5; - /* } */ case 10: - _r$6 = f.Mul(f, f); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$6; - n = $shiftRightUint64(n, (1)); - /* } */ $s = 7; continue; case 8: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.pow5 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.f = f; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.pow5 = function(n) { return this.$val.pow5(n); }; - Float.ptr.prototype.Parse = function(s, base) { - var _r$1, _r$2, _tuple, _tuple$1, b, base, ch, err, err2, f, r, s, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; base = $f.base; ch = $f.ch; err = $f.err; err2 = $f.err2; f = $f.f; r = $f.r; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = ptrType.nil; - b = 0; - err = $ifaceNil; - z = this; - if ((s.length === 3) && (s === "Inf" || s === "inf")) { - f = z.SetInf(false); - $s = -1; return [f, b, err]; - } - if ((s.length === 4) && ((s.charCodeAt(0) === 43) || (s.charCodeAt(0) === 45)) && ($substring(s, 1) === "Inf" || $substring(s, 1) === "inf")) { - f = z.SetInf(s.charCodeAt(0) === 45); - $s = -1; return [f, b, err]; - } - r = strings.NewReader(s); - _r$1 = z.scan(r, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - f = _tuple[0]; - b = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [f, b, err]; - } - _tuple$1 = r.ReadByte(); - ch = _tuple$1[0]; - err2 = _tuple$1[1]; - /* */ if ($interfaceIsEqual(err2, $ifaceNil)) { $s = 2; continue; } - /* */ if (!($interfaceIsEqual(err2, io.EOF))) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if ($interfaceIsEqual(err2, $ifaceNil)) { */ case 2: - _r$2 = fmt.Errorf("expected end of string, found %q", new sliceType([new $Uint8(ch)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - err = _r$2; - $s = 4; continue; - /* } else if (!($interfaceIsEqual(err2, io.EOF))) { */ case 3: - err = err2; - /* } */ case 4: - $s = -1; return [f, b, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Parse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.base = base; $f.ch = ch; $f.err = err; $f.err2 = err2; $f.f = f; $f.r = r; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Parse = function(s, base) { return this.$val.Parse(s, base); }; - Float.ptr.prototype.Scan = function(s, ch) { - var _r$1, _tuple, ch, err, s, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; ch = $f.ch; err = $f.err; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - $r = s.SkipSpace(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$1 = z.scan((x = new byteReader.ptr(s), new x.constructor.elem(x)), 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - err = _tuple[2]; - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Scan }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; - Float.ptr.prototype.GobEncode = function() { - var _q, b, buf, n, sz, x; - x = this; - if (x === ptrType.nil) { - return [sliceType$1.nil, $ifaceNil]; - } - sz = 6; - n = 0; - if (x.form === 1) { - n = (((_q = ((x.prec + 31 >>> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); - if (x.mant.$length < n) { - n = x.mant.$length; - } - sz = sz + ((4 + ($imul(n, 4)) >> 0)) >> 0; - } - buf = $makeSlice(sliceType$1, sz); - (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0] = 1); - b = ((((((((x.mode & 7) >>> 0) << 24 >>> 24)) << 5 << 24 >>> 24) | ((((((x.acc + 1 << 24 >> 24)) & 3) << 24 >>> 24)) << 3 << 24 >>> 24)) >>> 0) | (((((x.form & 3) >>> 0) << 24 >>> 24)) << 1 << 24 >>> 24)) >>> 0; - if (x.neg) { - b = (b | (1)) >>> 0; - } - (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1] = b); - $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, 2), x.prec); - if (x.form === 1) { - $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, 6), ((x.exp >>> 0))); - $subslice(x.mant, (x.mant.$length - n >> 0)).bytes($subslice(buf, 10)); - } - return [buf, $ifaceNil]; - }; - Float.prototype.GobEncode = function() { return this.$val.GobEncode(); }; - Float.ptr.prototype.GobDecode = function(buf) { - var _r$1, _r$2, b, buf, oldMode, oldPrec, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; b = $f.b; buf = $f.buf; oldMode = $f.oldMode; oldPrec = $f.oldPrec; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (buf.$length === 0) { - Float.copy(z, new Float.ptr(0, 0, 0, 0, false, nat.nil, 0)); - $s = -1; return $ifaceNil; - } - /* */ if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { */ case 1: - _r$1 = fmt.Errorf("Float.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - oldPrec = z.prec; - oldMode = z.mode; - b = (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]); - z.mode = ((((((b >>> 5 << 24 >>> 24)) & 7) >>> 0) << 24 >>> 24)); - z.acc = ((((((b >>> 3 << 24 >>> 24)) & 3) >>> 0) << 24 >> 24)) - 1 << 24 >> 24; - z.form = ((((((b >>> 1 << 24 >>> 24)) & 3) >>> 0) << 24 >>> 24)); - z.neg = !((((b & 1) >>> 0) === 0)); - z.prec = $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 2)); - if (z.form === 1) { - z.exp = (($clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 6)) >> 0)); - z.mant = z.mant.setBytes($subslice(buf, 10)); - } - /* */ if (!((oldPrec === 0))) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (!((oldPrec === 0))) { */ case 4: - z.mode = oldMode; - _r$2 = z.SetPrec(((oldPrec >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - /* } */ case 5: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.b = b; $f.buf = buf; $f.oldMode = oldMode; $f.oldPrec = oldPrec; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; - Float.ptr.prototype.MarshalText = function() { - var _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, buf, err, text, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; buf = $f.buf; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - text = sliceType$1.nil; - err = $ifaceNil; - x = this; - if (x === ptrType.nil) { - _tmp = (new sliceType$1($stringToBytes(""))); - _tmp$1 = $ifaceNil; - text = _tmp; - err = _tmp$1; - $s = -1; return [text, err]; - } - buf = sliceType$1.nil; - _r$1 = x.Append(buf, 103, -1); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tmp$2 = _r$1; - _tmp$3 = $ifaceNil; - text = _tmp$2; - err = _tmp$3; - $s = -1; return [text, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.buf = buf; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.MarshalText = function() { return this.$val.MarshalText(); }; - Float.ptr.prototype.UnmarshalText = function(text) { - var _r$1, _r$2, _tuple, err, text, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; err = $f.err; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.Parse(($bytesToString(text)), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - err = _tuple[2]; - /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2: - _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", new sliceType([text, err])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - err = _r$2; - /* } */ case 3: - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.err = err; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; - Float.ptr.prototype.Text = function(format, prec) { - var _r$1, cap, format, prec, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; cap = $f.cap; format = $f.format; prec = $f.prec; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - cap = 10; - if (prec > 0) { - cap = cap + (prec) >> 0; - } - _r$1 = x.Append($makeSlice(sliceType$1, 0, cap), format, prec); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return ($bytesToString(_r$1)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Text }; } $f._r$1 = _r$1; $f.cap = cap; $f.format = format; $f.prec = prec; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Text = function(format, prec) { return this.$val.Text(format, prec); }; - Float.ptr.prototype.String = function() { - var _r$1, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = x.Text(103, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.String = function() { return this.$val.String(); }; - Float.ptr.prototype.Append = function(buf, fmt$1, prec) { - var _1, _2, _3, _4, _r$1, _r$2, buf, d, eprec, exp, fmt$1, prec, shortest, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; d = $f.d; eprec = $f.eprec; exp = $f.exp; fmt$1 = $f.fmt$1; prec = $f.prec; shortest = $f.shortest; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - d = [d]; - x = this; - if (x.neg) { - buf = $append(buf, 45); - } - if (x.form === 2) { - if (!x.neg) { - buf = $append(buf, 43); - } - $s = -1; return $appendSlice(buf, "Inf"); - } - _1 = fmt$1; - /* */ if (_1 === (98)) { $s = 2; continue; } - /* */ if (_1 === (112)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_1 === (98)) { */ case 2: - _r$1 = x.fmtB(buf); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } else if (_1 === (112)) { */ case 3: - _r$2 = x.fmtP(buf); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* } */ case 4: - case 1: - d[0] = new decimal.ptr(sliceType$1.nil, 0); - /* */ if (x.form === 1) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (x.form === 1) { */ case 7: - $r = d[0].init(x.mant, ((x.exp >> 0)) - x.mant.bitLen() >> 0); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 8: - shortest = false; - /* */ if (prec < 0) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (prec < 0) { */ case 10: - shortest = true; - $r = roundShortest(d[0], x); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _2 = fmt$1; - if ((_2 === (101)) || (_2 === (69))) { - prec = d[0].mant.$length - 1 >> 0; - } else if (_2 === (102)) { - prec = max(d[0].mant.$length - d[0].exp >> 0, 0); - } else if ((_2 === (103)) || (_2 === (71))) { - prec = d[0].mant.$length; - } - $s = 12; continue; - /* } else { */ case 11: - _3 = fmt$1; - if ((_3 === (101)) || (_3 === (69))) { - d[0].round(1 + prec >> 0); - } else if (_3 === (102)) { - d[0].round(d[0].exp + prec >> 0); - } else if ((_3 === (103)) || (_3 === (71))) { - if (prec === 0) { - prec = 1; - } - d[0].round(prec); - } - /* } */ case 12: - _4 = fmt$1; - if ((_4 === (101)) || (_4 === (69))) { - $s = -1; return fmtE(buf, fmt$1, prec, $clone(d[0], decimal)); - } else if (_4 === (102)) { - $s = -1; return fmtF(buf, prec, $clone(d[0], decimal)); - } else if ((_4 === (103)) || (_4 === (71))) { - eprec = prec; - if (eprec > d[0].mant.$length && d[0].mant.$length >= d[0].exp) { - eprec = d[0].mant.$length; - } - if (shortest) { - eprec = 6; - } - exp = d[0].exp - 1 >> 0; - if (exp < -4 || exp >= eprec) { - if (prec > d[0].mant.$length) { - prec = d[0].mant.$length; - } - $s = -1; return fmtE(buf, (fmt$1 + 101 << 24 >>> 24) - 103 << 24 >>> 24, prec - 1 >> 0, $clone(d[0], decimal)); - } - if (prec > d[0].exp) { - prec = d[0].mant.$length; - } - $s = -1; return fmtF(buf, max(prec - d[0].exp >> 0, 0), $clone(d[0], decimal)); - } - if (x.neg) { - buf = $subslice(buf, 0, (buf.$length - 1 >> 0)); - } - $s = -1; return $append(buf, 37, fmt$1); - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Append }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.d = d; $f.eprec = eprec; $f.exp = exp; $f.fmt$1 = fmt$1; $f.prec = prec; $f.shortest = shortest; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Append = function(buf, fmt$1, prec) { return this.$val.Append(buf, fmt$1, prec); }; - roundShortest = function(d, x) { - var _i, _ref, d, exp, i, inclusive, l, lower, m, mant, okdown, okup, s, tmp, u, upper, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _ref = $f._ref; d = $f.d; exp = $f.exp; i = $f.i; inclusive = $f.inclusive; l = $f.l; lower = $f.lower; m = $f.m; mant = $f.mant; okdown = $f.okdown; okup = $f.okup; s = $f.s; tmp = $f.tmp; u = $f.u; upper = $f.upper; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (d.mant.$length === 0) { - $s = -1; return; - } - mant = (nat.nil).set(x.mant); - exp = ((x.exp >> 0)) - mant.bitLen() >> 0; - s = mant.bitLen() - (((x.prec + 1 >>> 0) >> 0)) >> 0; - if (s < 0) { - mant = mant.shl(mant, ((-s >>> 0))); - } else if (s > 0) { - mant = mant.shr(mant, ((s >>> 0))); - } - exp = exp + (s) >> 0; - lower = new decimal.ptr(sliceType$1.nil, 0); - tmp = nat.nil; - $r = lower.init(tmp.sub(mant, natOne), exp); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - upper = new decimal.ptr(sliceType$1.nil, 0); - $r = upper.init(tmp.add(mant, natOne), exp); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - inclusive = (((0 >= mant.$length ? ($throwRuntimeError("index out of range"), undefined) : mant.$array[mant.$offset + 0]) & 2) >>> 0) === 0; - _ref = d.mant; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - m = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - l = lower.at(i); - u = upper.at(i); - okdown = !((l === m)) || inclusive && ((i + 1 >> 0) === lower.mant.$length); - okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.mant.$length); - if (okdown && okup) { - d.round(i + 1 >> 0); - $s = -1; return; - } else if (okdown) { - d.roundDown(i + 1 >> 0); - $s = -1; return; - } else if (okup) { - d.roundUp(i + 1 >> 0); - $s = -1; return; - } - _i++; - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: roundShortest }; } $f._i = _i; $f._ref = _ref; $f.d = d; $f.exp = exp; $f.i = i; $f.inclusive = inclusive; $f.l = l; $f.lower = lower; $f.m = m; $f.mant = mant; $f.okdown = okdown; $f.okup = okup; $f.s = s; $f.tmp = tmp; $f.u = u; $f.upper = upper; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - fmtE = function(buf, fmt$1, prec, d) { - var buf, ch, d, exp, fmt$1, i, m, prec, x, x$1; - ch = 48; - if (d.mant.$length > 0) { - ch = (x = d.mant, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - } - buf = $append(buf, ch); - if (prec > 0) { - buf = $append(buf, 46); - i = 1; - m = min(d.mant.$length, prec + 1 >> 0); - if (i < m) { - buf = $appendSlice(buf, $subslice(d.mant, i, m)); - i = m; - } - while (true) { - if (!(i <= prec)) { break; } - buf = $append(buf, 48); - i = i + (1) >> 0; - } - } - buf = $append(buf, fmt$1); - exp = new $Int64(0, 0); - if (d.mant.$length > 0) { - exp = (x$1 = (new $Int64(0, d.exp)), new $Int64(x$1.$high - 0, x$1.$low - 1)); - } - if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { - ch = 45; - exp = new $Int64(-exp.$high, -exp.$low); - } else { - ch = 43; - } - buf = $append(buf, ch); - if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 10))) { - buf = $append(buf, 48); - } - return strconv.AppendInt(buf, exp, 10); - }; - fmtF = function(buf, prec, d) { - var buf, d, i, m, prec; - if (d.exp > 0) { - m = min(d.mant.$length, d.exp); - buf = $appendSlice(buf, $subslice(d.mant, 0, m)); - while (true) { - if (!(m < d.exp)) { break; } - buf = $append(buf, 48); - m = m + (1) >> 0; - } - } else { - buf = $append(buf, 48); - } - if (prec > 0) { - buf = $append(buf, 46); - i = 0; - while (true) { - if (!(i < prec)) { break; } - buf = $append(buf, d.at(d.exp + i >> 0)); - i = i + (1) >> 0; - } - } - return buf; - }; - Float.ptr.prototype.fmtB = function(buf) { - var _arg, _arg$1, _r$1, buf, e, m, w, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; buf = $f.buf; e = $f.e; m = $f.m; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (x.form === 0) { - $s = -1; return $append(buf, 48); - } - if (false && !((x.form === 1))) { - $panic(new $String("non-finite float")); - } - m = x.mant; - w = $imul(((x.mant.$length >>> 0)), 32) >>> 0; - if (w < x.prec) { - m = (nat.nil).shl(m, (((x.prec - w >>> 0) >>> 0))); - } else if (w > x.prec) { - m = (nat.nil).shr(m, (((w - x.prec >>> 0) >>> 0))); - } - _arg = buf; - _r$1 = m.utoa(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$1 = _r$1; - buf = $appendSlice(_arg, _arg$1); - buf = $append(buf, 112); - e = (x$1 = (new $Int64(0, x.exp)), x$2 = (new $Int64(0, x.prec)), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); - if ((e.$high > 0 || (e.$high === 0 && e.$low >= 0))) { - buf = $append(buf, 43); - } - $s = -1; return strconv.AppendInt(buf, e, 10); - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.fmtB }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f.buf = buf; $f.e = e; $f.m = m; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.fmtB = function(buf) { return this.$val.fmtB(buf); }; - Float.ptr.prototype.fmtP = function(buf) { - var _arg, _arg$1, _r$1, _r$2, buf, i, m, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; i = $f.i; m = $f.m; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (x.form === 0) { - $s = -1; return $append(buf, 48); - } - if (false && !((x.form === 1))) { - $panic(new $String("non-finite float")); - } - m = x.mant; - i = 0; - while (true) { - if (!(i < m.$length && (((i < 0 || i >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + i]) === 0))) { break; } - i = i + (1) >> 0; - } - m = $subslice(m, i); - buf = $appendSlice(buf, "0x."); - _arg = buf; - _r$1 = m.utoa(16); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = bytes.TrimRight(_r$1, "0"); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _arg$1 = _r$2; - buf = $appendSlice(_arg, _arg$1); - buf = $append(buf, 112); - if (x.exp >= 0) { - buf = $append(buf, 43); - } - $s = -1; return strconv.AppendInt(buf, (new $Int64(0, x.exp)), 10); - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.fmtP }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.i = i; $f.m = m; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.fmtP = function(buf) { return this.$val.fmtP(buf); }; - min = function(x, y) { - var x, y; - if (x < y) { - return x; - } - return y; - }; - Float.ptr.prototype.Format = function(s, format) { - var _1, _arg, _arg$1, _arg$2, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, buf, format, hasPrec, hasWidth, padding, prec, s, sign, width, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; format = $f.format; hasPrec = $f.hasPrec; hasWidth = $f.hasWidth; padding = $f.padding; prec = $f.prec; s = $f.s; sign = $f.sign; width = $f.width; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = s.Precision(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - prec = _tuple[0]; - hasPrec = _tuple[1]; - if (!hasPrec) { - prec = 6; - } - _1 = format; - /* */ if ((_1 === (101)) || (_1 === (69)) || (_1 === (102)) || (_1 === (98)) || (_1 === (112))) { $s = 3; continue; } - /* */ if (_1 === (70)) { $s = 4; continue; } - /* */ if (_1 === (118)) { $s = 5; continue; } - /* */ if ((_1 === (103)) || (_1 === (71))) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if ((_1 === (101)) || (_1 === (69)) || (_1 === (102)) || (_1 === (98)) || (_1 === (112))) { */ case 3: - $s = 8; continue; - /* } else if (_1 === (70)) { */ case 4: - format = 102; - $s = 8; continue; - /* } else if (_1 === (118)) { */ case 5: - format = 103; - if (!hasPrec) { - prec = -1; - } - $s = 8; continue; - /* } else if ((_1 === (103)) || (_1 === (71))) { */ case 6: - if (!hasPrec) { - prec = -1; - } - $s = 8; continue; - /* } else { */ case 7: - _arg = s; - _arg$1 = new $Int32(format); - _r$2 = x.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _arg$2 = new $String(_r$2); - _r$3 = fmt.Fprintf(_arg, "%%!%c(*big.Float=%s)", new sliceType([_arg$1, _arg$2])); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - $s = -1; return; - /* } */ case 8: - case 2: - buf = sliceType$1.nil; - _r$4 = x.Append(buf, ((format << 24 >>> 24)), prec); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - buf = _r$4; - if (buf.$length === 0) { - buf = (new sliceType$1($stringToBytes("?"))); - } - sign = ""; - /* */ if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 45)) { $s = 13; continue; } - /* */ if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 43)) { $s = 14; continue; } - _r$5 = s.Flag(43); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (_r$5) { $s = 15; continue; } - _r$6 = s.Flag(32); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - /* */ if (_r$6) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 45)) { */ case 13: - sign = "-"; - buf = $subslice(buf, 1); - $s = 17; continue; - /* } else if (((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 43)) { */ case 14: - sign = "+"; - _r$7 = s.Flag(32); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - /* */ if (_r$7) { $s = 20; continue; } - /* */ $s = 21; continue; - /* if (_r$7) { */ case 20: - sign = " "; - /* } */ case 21: - buf = $subslice(buf, 1); - $s = 17; continue; - /* } else if (_r$5) { */ case 15: - sign = "+"; - $s = 17; continue; - /* } else if (_r$6) { */ case 16: - sign = " "; - /* } */ case 17: - case 12: - padding = 0; - _r$8 = s.Width(); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _tuple$1 = _r$8; - width = _tuple$1[0]; - hasWidth = _tuple$1[1]; - if (hasWidth && width > (sign.length + buf.$length >> 0)) { - padding = (width - sign.length >> 0) - buf.$length >> 0; - } - _r$9 = s.Flag(48); /* */ $s = 29; case 29: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - /* */ if (_r$9 && !x.IsInf()) { $s = 25; continue; } - _r$10 = s.Flag(45); /* */ $s = 30; case 30: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - /* */ if (_r$10) { $s = 26; continue; } - /* */ $s = 27; continue; - /* if (_r$9 && !x.IsInf()) { */ case 25: - $r = writeMultiple(s, sign, 1); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = writeMultiple(s, "0", padding); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$11 = s.Write(buf); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - _r$11; - $s = 28; continue; - /* } else if (_r$10) { */ case 26: - $r = writeMultiple(s, sign, 1); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$12 = s.Write(buf); /* */ $s = 35; case 35: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - _r$12; - $r = writeMultiple(s, " ", padding); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 28; continue; - /* } else { */ case 27: - $r = writeMultiple(s, " ", padding); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = writeMultiple(s, sign, 1); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$13 = s.Write(buf); /* */ $s = 39; case 39: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - _r$13; - /* } */ case 28: - case 24: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Format }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.format = format; $f.hasPrec = hasPrec; $f.hasWidth = hasWidth; $f.padding = padding; $f.prec = prec; $f.s = s; $f.sign = sign; $f.width = width; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Format = function(s, format) { return this.$val.Format(s, format); }; - Int.ptr.prototype.Sign = function() { - var x; - x = this; - if (x.abs.$length === 0) { - return 0; - } - if (x.neg) { - return -1; - } - return 1; - }; - Int.prototype.Sign = function() { return this.$val.Sign(); }; - Int.ptr.prototype.SetInt64 = function(x) { - var neg, x, z; - z = this; - neg = false; - if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) { - neg = true; - x = new $Int64(-x.$high, -x.$low); - } - z.abs = z.abs.setUint64((new $Uint64(x.$high, x.$low))); - z.neg = neg; - return z; - }; - Int.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; - Int.ptr.prototype.SetUint64 = function(x) { - var x, z; - z = this; - z.abs = z.abs.setUint64(x); - z.neg = false; - return z; - }; - Int.prototype.SetUint64 = function(x) { return this.$val.SetUint64(x); }; - NewInt = function(x) { - var x; - return new Int.ptr(false, nat.nil).SetInt64(x); - }; - $pkg.NewInt = NewInt; - Int.ptr.prototype.Set = function(x) { - var x, z; - z = this; - if (!(z === x)) { - z.abs = z.abs.set(x.abs); - z.neg = x.neg; - } - return z; - }; - Int.prototype.Set = function(x) { return this.$val.Set(x); }; - Int.ptr.prototype.Bits = function() { - var x, x$1; - x = this; - return (x$1 = x.abs, $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)); - }; - Int.prototype.Bits = function() { return this.$val.Bits(); }; - Int.ptr.prototype.SetBits = function(abs) { - var abs, z; - z = this; - z.abs = ($subslice(new nat(abs.$array), abs.$offset, abs.$offset + abs.$length)).norm(); - z.neg = false; - return z; - }; - Int.prototype.SetBits = function(abs) { return this.$val.SetBits(abs); }; - Int.ptr.prototype.Abs = function(x) { - var x, z; - z = this; - z.Set(x); - z.neg = false; - return z; - }; - Int.prototype.Abs = function(x) { return this.$val.Abs(x); }; - Int.ptr.prototype.Neg = function(x) { - var x, z; - z = this; - z.Set(x); - z.neg = z.abs.$length > 0 && !z.neg; - return z; - }; - Int.prototype.Neg = function(x) { return this.$val.Neg(x); }; - Int.ptr.prototype.Add = function(x, y) { - var neg, x, y, z; - z = this; - neg = x.neg; - if (x.neg === y.neg) { - z.abs = z.abs.add(x.abs, y.abs); - } else { - if (x.abs.cmp(y.abs) >= 0) { - z.abs = z.abs.sub(x.abs, y.abs); - } else { - neg = !neg; - z.abs = z.abs.sub(y.abs, x.abs); - } - } - z.neg = z.abs.$length > 0 && neg; - return z; - }; - Int.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; - Int.ptr.prototype.Sub = function(x, y) { - var neg, x, y, z; - z = this; - neg = x.neg; - if (!(x.neg === y.neg)) { - z.abs = z.abs.add(x.abs, y.abs); - } else { - if (x.abs.cmp(y.abs) >= 0) { - z.abs = z.abs.sub(x.abs, y.abs); - } else { - neg = !neg; - z.abs = z.abs.sub(y.abs, x.abs); - } - } - z.neg = z.abs.$length > 0 && neg; - return z; - }; - Int.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; - Int.ptr.prototype.Mul = function(x, y) { - var x, y, z; - z = this; - if (x === y) { - z.abs = z.abs.sqr(x.abs); - z.neg = false; - return z; - } - z.abs = z.abs.mul(x.abs, y.abs); - z.neg = z.abs.$length > 0 && !(x.neg === y.neg); - return z; - }; - Int.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; - Int.ptr.prototype.MulRange = function(a, b) { - var _tmp, _tmp$1, a, b, neg, x, x$1, z; - z = this; - if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { - return z.SetInt64(new $Int64(0, 1)); - } else if ((a.$high < 0 || (a.$high === 0 && a.$low <= 0)) && (b.$high > 0 || (b.$high === 0 && b.$low >= 0))) { - return z.SetInt64(new $Int64(0, 0)); - } - neg = false; - if ((a.$high < 0 || (a.$high === 0 && a.$low < 0))) { - neg = (x = (x$1 = new $Int64(b.$high - a.$high, b.$low - a.$low), new $Int64(x$1.$high & 0, (x$1.$low & 1) >>> 0)), (x.$high === 0 && x.$low === 0)); - _tmp = new $Int64(-b.$high, -b.$low); - _tmp$1 = new $Int64(-a.$high, -a.$low); - a = _tmp; - b = _tmp$1; - } - z.abs = z.abs.mulRange((new $Uint64(a.$high, a.$low)), (new $Uint64(b.$high, b.$low))); - z.neg = neg; - return z; - }; - Int.prototype.MulRange = function(a, b) { return this.$val.MulRange(a, b); }; - Int.ptr.prototype.Binomial = function(n, k) { - var _r$1, _tmp, _tmp$1, a, b, k, n, x, x$1, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; a = $f.a; b = $f.b; k = $f.k; n = $f.n; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - b = [b]; - z = this; - if ((x = $div64(n, new $Int64(0, 2), false), (x.$high < k.$high || (x.$high === k.$high && x.$low < k.$low))) && (k.$high < n.$high || (k.$high === n.$high && k.$low <= n.$low))) { - k = new $Int64(n.$high - k.$high, n.$low - k.$low); - } - _tmp = new Int.ptr(false, nat.nil); - _tmp$1 = new Int.ptr(false, nat.nil); - a[0] = $clone(_tmp, Int); - b[0] = $clone(_tmp$1, Int); - a[0].MulRange((x$1 = new $Int64(n.$high - k.$high, n.$low - k.$low), new $Int64(x$1.$high + 0, x$1.$low + 1)), n); - b[0].MulRange(new $Int64(0, 1), k); - _r$1 = z.Quo(a[0], b[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Binomial }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.a = a; $f.b = b; $f.k = k; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Binomial = function(n, k) { return this.$val.Binomial(n, k); }; - Int.ptr.prototype.Quo = function(x, y) { - var _r$1, _tuple, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.abs.div(nat.nil, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z.abs = _tuple[0]; - z.neg = z.abs.$length > 0 && !(x.neg === y.neg); - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Quo }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; - Int.ptr.prototype.Rem = function(x, y) { - var _r$1, _tuple, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = (nat.nil).div(z.abs, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z.abs = _tuple[1]; - z.neg = z.abs.$length > 0 && x.neg; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Rem }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Rem = function(x, y) { return this.$val.Rem(x, y); }; - Int.ptr.prototype.QuoRem = function(x, y, r) { - var _r$1, _tmp, _tmp$1, _tuple, r, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; r = $f.r; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.abs.div(r.abs, x.abs, y.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z.abs = _tuple[0]; - r.abs = _tuple[1]; - _tmp = z.abs.$length > 0 && !(x.neg === y.neg); - _tmp$1 = r.abs.$length > 0 && x.neg; - z.neg = _tmp; - r.neg = _tmp$1; - $s = -1; return [z, r]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.QuoRem }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.r = r; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.QuoRem = function(x, y, r) { return this.$val.QuoRem(x, y, r); }; - Int.ptr.prototype.Div = function(x, y) { - var _r$1, r, x, y, y_neg, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; r = $f.r; x = $f.x; y = $f.y; y_neg = $f.y_neg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = [r]; - z = this; - y_neg = y.neg; - r[0] = new Int.ptr(false, nat.nil); - _r$1 = z.QuoRem(x, y, r[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - if (r[0].neg) { - if (y_neg) { - z.Add(z, intOne); - } else { - z.Sub(z, intOne); - } - } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Div }; } $f._r$1 = _r$1; $f.r = r; $f.x = x; $f.y = y; $f.y_neg = y_neg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Div = function(x, y) { return this.$val.Div(x, y); }; - Int.ptr.prototype.Mod = function(x, y) { - var _r$1, q, x, y, y0, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; q = $f.q; x = $f.x; y = $f.y; y0 = $f.y0; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - y0 = y; - if (z === y || alias(z.abs, y.abs)) { - y0 = new Int.ptr(false, nat.nil).Set(y); - } - q = new Int.ptr(false, nat.nil); - _r$1 = q.QuoRem(x, y, z); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - if (z.neg) { - if (y0.neg) { - z.Sub(z, y0); - } else { - z.Add(z, y0); - } - } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Mod }; } $f._r$1 = _r$1; $f.q = q; $f.x = x; $f.y = y; $f.y0 = y0; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Mod = function(x, y) { return this.$val.Mod(x, y); }; - Int.ptr.prototype.DivMod = function(x, y, m) { - var _r$1, m, x, y, y0, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; m = $f.m; x = $f.x; y = $f.y; y0 = $f.y0; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - y0 = y; - if (z === y || alias(z.abs, y.abs)) { - y0 = new Int.ptr(false, nat.nil).Set(y); - } - _r$1 = z.QuoRem(x, y, m); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - if (m.neg) { - if (y0.neg) { - z.Add(z, intOne); - m.Sub(m, y0); - } else { - z.Sub(z, intOne); - m.Add(m, y0); - } - } - $s = -1; return [z, m]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.DivMod }; } $f._r$1 = _r$1; $f.m = m; $f.x = x; $f.y = y; $f.y0 = y0; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.DivMod = function(x, y, m) { return this.$val.DivMod(x, y, m); }; - Int.ptr.prototype.Cmp = function(y) { - var r, x, y; - r = 0; - x = this; - if (x.neg === y.neg) { - r = x.abs.cmp(y.abs); - if (x.neg) { - r = -r; - } - } else if (x.neg) { - r = -1; - } else { - r = 1; - } - return r; - }; - Int.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; - Int.ptr.prototype.CmpAbs = function(y) { - var x, y; - x = this; - return x.abs.cmp(y.abs); - }; - Int.prototype.CmpAbs = function(y) { return this.$val.CmpAbs(y); }; - low32 = function(x) { - var x; - if (x.$length === 0) { - return 0; - } - return (((0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]) >>> 0)); - }; - low64 = function(x) { - var v, x, x$1, x$2, x$3; - if (x.$length === 0) { - return new $Uint64(0, 0); - } - v = ((x$1 = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]), new $Uint64(0, x$1.constructor === Number ? x$1 : 1))); - if (true && x.$length > 1) { - return (x$2 = $shiftLeft64(((x$3 = (1 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 1]), new $Uint64(0, x$3.constructor === Number ? x$3 : 1))), 32), new $Uint64(x$2.$high | v.$high, (x$2.$low | v.$low) >>> 0)); - } - return v; - }; - Int.ptr.prototype.Int64 = function() { - var v, x, x$1; - x = this; - v = ((x$1 = low64(x.abs), new $Int64(x$1.$high, x$1.$low))); - if (x.neg) { - v = new $Int64(-v.$high, -v.$low); - } - return v; - }; - Int.prototype.Int64 = function() { return this.$val.Int64(); }; - Int.ptr.prototype.Uint64 = function() { - var x; - x = this; - return low64(x.abs); - }; - Int.prototype.Uint64 = function() { return this.$val.Uint64(); }; - Int.ptr.prototype.IsInt64 = function() { - var w, x, x$1, x$2; - x = this; - if (x.abs.$length <= 2) { - w = ((x$1 = low64(x.abs), new $Int64(x$1.$high, x$1.$low))); - return (w.$high > 0 || (w.$high === 0 && w.$low >= 0)) || x.neg && (x$2 = new $Int64(-w.$high, -w.$low), (w.$high === x$2.$high && w.$low === x$2.$low)); - } - return false; - }; - Int.prototype.IsInt64 = function() { return this.$val.IsInt64(); }; - Int.ptr.prototype.IsUint64 = function() { - var x; - x = this; - return !x.neg && x.abs.$length <= 2; - }; - Int.prototype.IsUint64 = function() { return this.$val.IsUint64(); }; - Int.ptr.prototype.SetString = function(s, base) { - var _r$1, base, s, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.setFromScanner(strings.NewReader(s), base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f.base = base; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.SetString = function(s, base) { return this.$val.SetString(s, base); }; - Int.ptr.prototype.setFromScanner = function(r, base) { - var _r$1, _r$2, _tuple, _tuple$1, base, err, err$1, r, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; err = $f.err; err$1 = $f.err$1; r = $f.r; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.scan(r, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, false]; - } - _r$2 = r.ReadByte(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - err$1 = _tuple$1[1]; - if (!($interfaceIsEqual(err$1, io.EOF))) { - $s = -1; return [ptrType$1.nil, false]; - } - $s = -1; return [z, true]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.setFromScanner }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.err = err; $f.err$1 = err$1; $f.r = r; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.setFromScanner = function(r, base) { return this.$val.setFromScanner(r, base); }; - Int.ptr.prototype.SetBytes = function(buf) { - var buf, z; - z = this; - z.abs = z.abs.setBytes(buf); - z.neg = false; - return z; - }; - Int.prototype.SetBytes = function(buf) { return this.$val.SetBytes(buf); }; - Int.ptr.prototype.Bytes = function() { - var buf, x; - x = this; - buf = $makeSlice(sliceType$1, ($imul(x.abs.$length, 4))); - return $subslice(buf, x.abs.bytes(buf)); - }; - Int.prototype.Bytes = function() { return this.$val.Bytes(); }; - Int.ptr.prototype.BitLen = function() { - var x; - x = this; - return x.abs.bitLen(); - }; - Int.prototype.BitLen = function() { return this.$val.BitLen(); }; - Int.ptr.prototype.Exp = function(x, y, m) { - var _r$1, _r$2, m, mWords, x, xWords, y, yWords, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; m = $f.m; mWords = $f.mWords; x = $f.x; xWords = $f.xWords; y = $f.y; yWords = $f.yWords; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - xWords = x.abs; - /* */ if (y.neg) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (y.neg) { */ case 1: - if (m === ptrType$1.nil || (m.abs.$length === 0)) { - $s = -1; return z.SetInt64(new $Int64(0, 1)); - } - _r$1 = new Int.ptr(false, nat.nil).ModInverse(x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - xWords = _r$1.abs; - /* } */ case 2: - yWords = y.abs; - mWords = nat.nil; - if (!(m === ptrType$1.nil)) { - mWords = m.abs; - } - _r$2 = z.abs.expNN(xWords, yWords, mWords); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - z.abs = _r$2; - z.neg = z.abs.$length > 0 && x.neg && yWords.$length > 0 && ((((0 >= yWords.$length ? ($throwRuntimeError("index out of range"), undefined) : yWords.$array[yWords.$offset + 0]) & 1) >>> 0) === 1); - if (z.neg && mWords.$length > 0) { - z.abs = z.abs.sub(mWords, z.abs); - z.neg = false; - } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Exp }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.m = m; $f.mWords = mWords; $f.x = x; $f.xWords = xWords; $f.y = y; $f.yWords = yWords; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Exp = function(x, y, m) { return this.$val.Exp(x, y, m); }; - Int.ptr.prototype.GCD = function(x, y, a, b) { - var _r$1, a, b, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (a.Sign() <= 0 || b.Sign() <= 0) { - z.SetInt64(new $Int64(0, 0)); - if (!(x === ptrType$1.nil)) { - x.SetInt64(new $Int64(0, 0)); - } - if (!(y === ptrType$1.nil)) { - y.SetInt64(new $Int64(0, 0)); - } - $s = -1; return z; - } - _r$1 = z.lehmerGCD(x, y, a, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.GCD }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.GCD = function(x, y, a, b) { return this.$val.GCD(x, y, a, b); }; - lehmerSimulate = function(A, B) { - var A, B, _q, _r$1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, a1, a2, even, h, m, n, q, r, u0, u1, u2, v0, v1, v2, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2, y$3, y$4; - u0 = 0; - u1 = 0; - v0 = 0; - v1 = 0; - even = false; - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = 0; - _tmp$3 = 0; - a1 = _tmp; - a2 = _tmp$1; - u2 = _tmp$2; - v2 = _tmp$3; - m = B.abs.$length; - n = A.abs.$length; - h = nlz((x = A.abs, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); - a1 = (((y = h, y < 32 ? ((x$2 = A.abs, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])) << y) : 0) >>> 0) | ((y$1 = ((32 - h >>> 0)), y$1 < 32 ? ((x$4 = A.abs, x$5 = n - 2 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) >>> y$1) : 0) >>> 0)) >>> 0; - if ((n === m)) { - a2 = (((y$2 = h, y$2 < 32 ? ((x$6 = B.abs, x$7 = n - 1 >> 0, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])) << y$2) : 0) >>> 0) | ((y$3 = ((32 - h >>> 0)), y$3 < 32 ? ((x$8 = B.abs, x$9 = n - 2 >> 0, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])) >>> y$3) : 0) >>> 0)) >>> 0; - } else if ((n === (m + 1 >> 0))) { - a2 = (y$4 = ((32 - h >>> 0)), y$4 < 32 ? ((x$10 = B.abs, x$11 = n - 2 >> 0, ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11])) >>> y$4) : 0) >>> 0; - } else { - a2 = 0; - } - even = false; - _tmp$4 = 0; - _tmp$5 = 1; - _tmp$6 = 0; - u0 = _tmp$4; - u1 = _tmp$5; - u2 = _tmp$6; - _tmp$7 = 0; - _tmp$8 = 0; - _tmp$9 = 1; - v0 = _tmp$7; - v1 = _tmp$8; - v2 = _tmp$9; - while (true) { - if (!(a2 >= v2 && (a1 - a2 >>> 0) >= (v1 + v2 >>> 0))) { break; } - _tmp$10 = (_q = a1 / a2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - _tmp$11 = (_r$1 = a1 % a2, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); - q = _tmp$10; - r = _tmp$11; - _tmp$12 = a2; - _tmp$13 = r; - a1 = _tmp$12; - a2 = _tmp$13; - _tmp$14 = u1; - _tmp$15 = u2; - _tmp$16 = u1 + ($imul(q, u2) >>> 0) >>> 0; - u0 = _tmp$14; - u1 = _tmp$15; - u2 = _tmp$16; - _tmp$17 = v1; - _tmp$18 = v2; - _tmp$19 = v1 + ($imul(q, v2) >>> 0) >>> 0; - v0 = _tmp$17; - v1 = _tmp$18; - v2 = _tmp$19; - even = !even; - } - return [u0, u1, v0, v1, even]; - }; - lehmerUpdate = function(A, B, q, r, s, t, u0, u1, v0, v1, even) { - var A, B, even, q, r, s, t, u0, u1, v0, v1; - t.abs = t.abs.setWord(u0); - s.abs = s.abs.setWord(v0); - t.neg = !even; - s.neg = even; - t.Mul(A, t); - s.Mul(B, s); - r.abs = r.abs.setWord(u1); - q.abs = q.abs.setWord(v1); - r.neg = even; - q.neg = !even; - r.Mul(A, r); - q.Mul(B, q); - A.Add(t, s); - B.Add(r, q); - }; - euclidUpdate = function(A, B, Ua, Ub, q, r, s, t, extended) { - var A, B, Ua, Ub, _r$1, _tmp, _tmp$1, _tmp$2, _tuple, extended, q, r, s, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; Ua = $f.Ua; Ub = $f.Ub; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; extended = $f.extended; q = $f.q; r = $f.r; s = $f.s; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$1 = q.QuoRem(A, B, r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - q = _tuple[0]; - r = _tuple[1]; - _tmp = $clone(B, Int); - _tmp$1 = $clone(r, Int); - _tmp$2 = $clone(A, Int); - Int.copy(A, _tmp); - Int.copy(B, _tmp$1); - Int.copy(r, _tmp$2); - if (extended) { - t.Set(Ub); - s.Mul(Ub, q); - Ub.Sub(Ua, s); - Ua.Set(t); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: euclidUpdate }; } $f.A = A; $f.B = B; $f.Ua = Ua; $f.Ub = Ub; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.extended = extended; $f.q = q; $f.r = r; $f.s = s; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.ptr.prototype.lehmerGCD = function(x, y, a, b) { - var A, B, Ua, Ub, _q, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, a, aWord, b, bWord, even, even$1, extended, q, q$1, r, r$1, s, t, u0, u1, ua, ub, v0, v1, va, vb, x, x$1, x$2, x$3, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; Ua = $f.Ua; Ub = $f.Ub; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; a = $f.a; aWord = $f.aWord; b = $f.b; bWord = $f.bWord; even = $f.even; even$1 = $f.even$1; extended = $f.extended; q = $f.q; q$1 = $f.q$1; r = $f.r; r$1 = $f.r$1; s = $f.s; t = $f.t; u0 = $f.u0; u1 = $f.u1; ua = $f.ua; ub = $f.ub; v0 = $f.v0; v1 = $f.v1; va = $f.va; vb = $f.vb; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _tmp = ptrType$1.nil; - _tmp$1 = ptrType$1.nil; - _tmp$2 = ptrType$1.nil; - _tmp$3 = ptrType$1.nil; - A = _tmp; - B = _tmp$1; - Ua = _tmp$2; - Ub = _tmp$3; - A = new Int.ptr(false, nat.nil).Set(a); - B = new Int.ptr(false, nat.nil).Set(b); - extended = !(x === ptrType$1.nil) || !(y === ptrType$1.nil); - if (extended) { - Ua = new Int.ptr(false, nat.nil).SetInt64(new $Int64(0, 1)); - Ub = new Int.ptr(false, nat.nil); - } - q = new Int.ptr(false, nat.nil); - r = new Int.ptr(false, nat.nil); - s = new Int.ptr(false, nat.nil); - t = new Int.ptr(false, nat.nil); - if (A.abs.cmp(B.abs) < 0) { - _tmp$4 = B; - _tmp$5 = A; - A = _tmp$4; - B = _tmp$5; - _tmp$6 = Ua; - _tmp$7 = Ub; - Ub = _tmp$6; - Ua = _tmp$7; - } - /* while (true) { */ case 1: - /* if (!(B.abs.$length > 1)) { break; } */ if(!(B.abs.$length > 1)) { $s = 2; continue; } - _tuple = lehmerSimulate(A, B); - u0 = _tuple[0]; - u1 = _tuple[1]; - v0 = _tuple[2]; - v1 = _tuple[3]; - even = _tuple[4]; - /* */ if (!((v0 === 0))) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!((v0 === 0))) { */ case 3: - lehmerUpdate(A, B, q, r, s, t, u0, u1, v0, v1, even); - if (extended) { - lehmerUpdate(Ua, Ub, q, r, s, t, u0, u1, v0, v1, even); - } - $s = 5; continue; - /* } else { */ case 4: - $r = euclidUpdate(A, B, Ua, Ub, q, r, s, t, extended); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 5: - /* } */ $s = 1; continue; case 2: - /* */ if (B.abs.$length > 0) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (B.abs.$length > 0) { */ case 7: - /* */ if (A.abs.$length > 1) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (A.abs.$length > 1) { */ case 9: - $r = euclidUpdate(A, B, Ua, Ub, q, r, s, t, extended); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 10: - if (B.abs.$length > 0) { - _tmp$8 = (x$1 = A.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); - _tmp$9 = (x$2 = B.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])); - aWord = _tmp$8; - bWord = _tmp$9; - if (extended) { - _tmp$10 = 0; - _tmp$11 = 0; - _tmp$12 = 0; - _tmp$13 = 0; - ua = _tmp$10; - ub = _tmp$11; - va = _tmp$12; - vb = _tmp$13; - _tmp$14 = 1; - _tmp$15 = 0; - ua = _tmp$14; - ub = _tmp$15; - _tmp$16 = 0; - _tmp$17 = 1; - va = _tmp$16; - vb = _tmp$17; - even$1 = true; - while (true) { - if (!(!((bWord === 0)))) { break; } - _tmp$18 = (_q = aWord / bWord, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - _tmp$19 = (_r$1 = aWord % bWord, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); - q$1 = _tmp$18; - r$1 = _tmp$19; - _tmp$20 = bWord; - _tmp$21 = r$1; - aWord = _tmp$20; - bWord = _tmp$21; - _tmp$22 = ub; - _tmp$23 = ua + ($imul(q$1, ub) >>> 0) >>> 0; - ua = _tmp$22; - ub = _tmp$23; - _tmp$24 = vb; - _tmp$25 = va + ($imul(q$1, vb) >>> 0) >>> 0; - va = _tmp$24; - vb = _tmp$25; - even$1 = !even$1; - } - t.abs = t.abs.setWord(ua); - s.abs = s.abs.setWord(va); - t.neg = !even$1; - s.neg = even$1; - t.Mul(Ua, t); - s.Mul(Ub, s); - Ua.Add(t, s); - } else { - while (true) { - if (!(!((bWord === 0)))) { break; } - _tmp$26 = bWord; - _tmp$27 = (_r$2 = aWord % bWord, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")); - aWord = _tmp$26; - bWord = _tmp$27; - } - } - (x$3 = A.abs, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = aWord)); - } - /* } */ case 8: - if (!(x === ptrType$1.nil)) { - Int.copy(x, Ua); - } - /* */ if (!(y === ptrType$1.nil)) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (!(y === ptrType$1.nil)) { */ case 12: - y.Mul(a, Ua); - y.Sub(A, y); - _r$3 = y.Div(y, b); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - /* } */ case 13: - Int.copy(z, A); - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.lehmerGCD }; } $f.A = A; $f.B = B; $f.Ua = Ua; $f.Ub = Ub; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f.a = a; $f.aWord = aWord; $f.b = b; $f.bWord = bWord; $f.even = even; $f.even$1 = even$1; $f.extended = extended; $f.q = q; $f.q$1 = q$1; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.t = t; $f.u0 = u0; $f.u1 = u1; $f.ua = ua; $f.ub = ub; $f.v0 = v0; $f.v1 = v1; $f.va = va; $f.vb = vb; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.lehmerGCD = function(x, y, a, b) { return this.$val.lehmerGCD(x, y, a, b); }; - Int.ptr.prototype.Rand = function(rnd, n) { - var _r$1, n, rnd, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; n = $f.n; rnd = $f.rnd; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - z.neg = false; - if (n.neg || (n.abs.$length === 0)) { - z.abs = nat.nil; - $s = -1; return z; - } - _r$1 = z.abs.random(rnd, n.abs, n.abs.bitLen()); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - z.abs = _r$1; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Rand }; } $f._r$1 = _r$1; $f.n = n; $f.rnd = rnd; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Rand = function(rnd, n) { return this.$val.Rand(rnd, n); }; - Int.ptr.prototype.ModInverse = function(g, n) { - var _r$1, _r$2, _tmp, _tmp$1, d, g, g2, n, n2, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; d = $f.d; g = $f.g; g2 = $f.g2; n = $f.n; n2 = $f.n2; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = [x]; - z = this; - if (n.neg) { - n2 = new Int.ptr(false, nat.nil); - n = n2.Neg(n); - } - /* */ if (g.neg) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (g.neg) { */ case 1: - g2 = new Int.ptr(false, nat.nil); - _r$1 = g2.Mod(g, n); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - g = _r$1; - /* } */ case 2: - _tmp = new Int.ptr(false, nat.nil); - _tmp$1 = new Int.ptr(false, nat.nil); - d = $clone(_tmp, Int); - x[0] = $clone(_tmp$1, Int); - _r$2 = d.GCD(x[0], ptrType$1.nil, g, n); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - if (!((d.Cmp(intOne) === 0))) { - $s = -1; return ptrType$1.nil; - } - if (x[0].neg) { - z.Add(x[0], n); - } else { - z.Set(x[0]); - } - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ModInverse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.d = d; $f.g = g; $f.g2 = g2; $f.n = n; $f.n2 = n2; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.ModInverse = function(g, n) { return this.$val.ModInverse(g, n); }; - Jacobi = function(x, y) { - var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, a, b, bmod8, c, j, s, x, x$1, x$2, x$3, x$4, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; a = $f.a; b = $f.b; bmod8 = $f.bmod8; c = $f.c; j = $f.j; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - a = [a]; - b = [b]; - c = [c]; - /* */ if ((y.abs.$length === 0) || ((((x$1 = y.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) === 0)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((y.abs.$length === 0) || ((((x$1 = y.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) === 0)) { */ case 1: - _r$1 = fmt.Sprintf("big: invalid 2nd argument to Int.Jacobi: need odd integer but got %s", new sliceType([y])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $panic(new $String(_r$1)); - /* } */ case 2: - _tmp = new Int.ptr(false, nat.nil); - _tmp$1 = new Int.ptr(false, nat.nil); - _tmp$2 = new Int.ptr(false, nat.nil); - a[0] = $clone(_tmp, Int); - b[0] = $clone(_tmp$1, Int); - c[0] = $clone(_tmp$2, Int); - a[0].Set(x); - b[0].Set(y); - j = 1; - if (b[0].neg) { - if (a[0].neg) { - j = -1; - } - b[0].neg = false; - } - /* while (true) { */ case 4: - if (b[0].Cmp(intOne) === 0) { - $s = -1; return j; - } - if (a[0].abs.$length === 0) { - $s = -1; return 0; - } - _r$2 = a[0].Mod(a[0], b[0]); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - if (a[0].abs.$length === 0) { - $s = -1; return 0; - } - s = a[0].abs.trailingZeroBits(); - if (!((((s & 1) >>> 0) === 0))) { - bmod8 = ((x$2 = b[0].abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) & 7) >>> 0; - if ((bmod8 === 3) || (bmod8 === 5)) { - j = -j; - } - } - c[0].Rsh(a[0], s); - if (((((x$3 = b[0].abs, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])) & 3) >>> 0) === 3) && ((((x$4 = c[0].abs, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])) & 3) >>> 0) === 3)) { - j = -j; - } - a[0].Set(b[0]); - b[0].Set(c[0]); - /* } */ $s = 4; continue; case 5: - $s = -1; return 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Jacobi }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.a = a; $f.b = b; $f.bmod8 = bmod8; $f.c = c; $f.j = j; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Jacobi = Jacobi; - Int.ptr.prototype.modSqrt3Mod4Prime = function(x, p) { - var _r$1, e, p, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; e = $f.e; p = $f.p; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - e = new Int.ptr(false, nat.nil).Add(p, intOne); - e.Rsh(e, 2); - _r$1 = z.Exp(x, e, p); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrt3Mod4Prime }; } $f._r$1 = _r$1; $f.e = e; $f.p = p; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.modSqrt3Mod4Prime = function(x, p) { return this.$val.modSqrt3Mod4Prime(x, p); }; - Int.ptr.prototype.modSqrt5Mod8Prime = function(x, p) { - var _r$1, _r$2, _r$3, _r$4, _r$5, alpha, beta, e, p, tx, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; alpha = $f.alpha; beta = $f.beta; e = $f.e; p = $f.p; tx = $f.tx; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - e = new Int.ptr(false, nat.nil).Rsh(p, 3); - tx = new Int.ptr(false, nat.nil).Lsh(x, 1); - _r$1 = new Int.ptr(false, nat.nil).Exp(tx, e, p); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - alpha = _r$1; - beta = new Int.ptr(false, nat.nil).Mul(alpha, alpha); - _r$2 = beta.Mod(beta, p); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - beta.Mul(beta, tx); - _r$3 = beta.Mod(beta, p); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - beta.Sub(beta, intOne); - beta.Mul(beta, x); - _r$4 = beta.Mod(beta, p); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$4; - beta.Mul(beta, alpha); - _r$5 = z.Mod(beta, p); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$5; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrt5Mod8Prime }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.alpha = alpha; $f.beta = beta; $f.e = e; $f.p = p; $f.tx = tx; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.modSqrt5Mod8Prime = function(x, p) { return this.$val.modSqrt5Mod8Prime(x, p); }; - Int.ptr.prototype.modSqrtTonelliShanks = function(x, p) { - var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tmp$2, _tmp$3, b, e, g, m, n, p, r, s, t, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; b = $f.b; e = $f.e; g = $f.g; m = $f.m; n = $f.n; p = $f.p; r = $f.r; s = $f.s; t = $f.t; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - b = [b]; - g = [g]; - n = [n]; - s = [s]; - t = [t]; - y = [y]; - z = this; - s[0] = new Int.ptr(false, nat.nil); - s[0].Sub(p, intOne); - e = s[0].abs.trailingZeroBits(); - s[0].Rsh(s[0], e); - n[0] = new Int.ptr(false, nat.nil); - n[0].SetInt64(new $Int64(0, 2)); - /* while (true) { */ case 1: - _r$1 = Jacobi(n[0], p); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* if (!(!((_r$1 === -1)))) { break; } */ if(!(!((_r$1 === -1)))) { $s = 2; continue; } - n[0].Add(n[0], intOne); - /* } */ $s = 1; continue; case 2: - _tmp = new Int.ptr(false, nat.nil); - _tmp$1 = new Int.ptr(false, nat.nil); - _tmp$2 = new Int.ptr(false, nat.nil); - _tmp$3 = new Int.ptr(false, nat.nil); - y[0] = $clone(_tmp, Int); - b[0] = $clone(_tmp$1, Int); - g[0] = $clone(_tmp$2, Int); - t[0] = $clone(_tmp$3, Int); - y[0].Add(s[0], intOne); - y[0].Rsh(y[0], 1); - _r$2 = y[0].Exp(x, y[0], p); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - _r$3 = b[0].Exp(x, s[0], p); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - _r$4 = g[0].Exp(n[0], s[0], p); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$4; - r = e; - /* while (true) { */ case 7: - m = 0; - t[0].Set(b[0]); - /* while (true) { */ case 9: - /* if (!(!((t[0].Cmp(intOne) === 0)))) { break; } */ if(!(!((t[0].Cmp(intOne) === 0)))) { $s = 10; continue; } - _r$5 = t[0].Mul(t[0], t[0]).Mod(t[0], p); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$5; - m = m + (1) >>> 0; - /* } */ $s = 9; continue; case 10: - if (m === 0) { - $s = -1; return z.Set(y[0]); - } - _r$6 = t[0].SetInt64(new $Int64(0, 0)).SetBit(t[0], ((((r - m >>> 0) - 1 >>> 0) >> 0)), 1).Exp(g[0], t[0], p); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$6; - _r$7 = g[0].Mul(t[0], t[0]).Mod(g[0], p); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _r$7; - _r$8 = y[0].Mul(y[0], t[0]).Mod(y[0], p); /* */ $s = 14; case 14: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _r$8; - _r$9 = b[0].Mul(b[0], g[0]).Mod(b[0], p); /* */ $s = 15; case 15: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _r$9; - r = m; - /* } */ $s = 7; continue; case 8: - $s = -1; return ptrType$1.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.modSqrtTonelliShanks }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.b = b; $f.e = e; $f.g = g; $f.m = m; $f.n = n; $f.p = p; $f.r = r; $f.s = s; $f.t = t; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.modSqrtTonelliShanks = function(x, p) { return this.$val.modSqrtTonelliShanks(x, p); }; - Int.ptr.prototype.ModSqrt = function(x, p) { - var _1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, p, x, x$1, x$2, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = Jacobi(x, p); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _1 = _r$1; - if (_1 === (-1)) { - $s = -1; return ptrType$1.nil; - } else if (_1 === (0)) { - $s = -1; return z.SetInt64(new $Int64(0, 0)); - } else if (_1 === (1)) { - /* break; */ $s = 1; continue; - } - case 1: - /* */ if (x.neg || x.Cmp(p) >= 0) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (x.neg || x.Cmp(p) >= 0) { */ case 3: - _r$2 = new Int.ptr(false, nat.nil).Mod(x, p); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = _r$2; - /* } */ case 4: - /* */ if (((_r$3 = (x$1 = p.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) % 4, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 3)) { $s = 7; continue; } - /* */ if (((_r$4 = (x$2 = p.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) % 8, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 5)) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (((_r$3 = (x$1 = p.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) % 4, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 3)) { */ case 7: - _r$5 = z.modSqrt3Mod4Prime(x, p); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return _r$5; - /* } else if (((_r$4 = (x$2 = p.abs, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) % 8, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 5)) { */ case 8: - _r$6 = z.modSqrt5Mod8Prime(x, p); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - $s = -1; return _r$6; - /* } else { */ case 9: - _r$7 = z.modSqrtTonelliShanks(x, p); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - $s = -1; return _r$7; - /* } */ case 10: - case 6: - $s = -1; return ptrType$1.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ModSqrt }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.ModSqrt = function(x, p) { return this.$val.ModSqrt(x, p); }; - Int.ptr.prototype.Lsh = function(x, n) { - var n, x, z; - z = this; - z.abs = z.abs.shl(x.abs, n); - z.neg = x.neg; - return z; - }; - Int.prototype.Lsh = function(x, n) { return this.$val.Lsh(x, n); }; - Int.ptr.prototype.Rsh = function(x, n) { - var n, t, x, z; - z = this; - if (x.neg) { - t = z.abs.sub(x.abs, natOne); - t = t.shr(t, n); - z.abs = t.add(t, natOne); - z.neg = true; - return z; - } - z.abs = z.abs.shr(x.abs, n); - z.neg = false; - return z; - }; - Int.prototype.Rsh = function(x, n) { return this.$val.Rsh(x, n); }; - Int.ptr.prototype.Bit = function(i) { - var i, t, x, x$1; - x = this; - if (i === 0) { - if (x.abs.$length > 0) { - return (((((x$1 = x.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) >>> 0)); - } - return 0; - } - if (i < 0) { - $panic(new $String("negative bit index")); - } - if (x.neg) { - t = (nat.nil).sub(x.abs, natOne); - return (t.bit(((i >>> 0))) ^ 1) >>> 0; - } - return x.abs.bit(((i >>> 0))); - }; - Int.prototype.Bit = function(i) { return this.$val.Bit(i); }; - Int.ptr.prototype.SetBit = function(x, i, b) { - var b, i, t, x, z; - z = this; - if (i < 0) { - $panic(new $String("negative bit index")); - } - if (x.neg) { - t = z.abs.sub(x.abs, natOne); - t = t.setBit(t, ((i >>> 0)), (b ^ 1) >>> 0); - z.abs = t.add(t, natOne); - z.neg = z.abs.$length > 0; - return z; - } - z.abs = z.abs.setBit(x.abs, ((i >>> 0)), b); - z.neg = false; - return z; - }; - Int.prototype.SetBit = function(x, i, b) { return this.$val.SetBit(x, i, b); }; - Int.ptr.prototype.And = function(x, y) { - var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; - z = this; - if (x.neg === y.neg) { - if (x.neg) { - x1 = (nat.nil).sub(x.abs, natOne); - y1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.add(z.abs.or(x1, y1), natOne); - z.neg = true; - return z; - } - z.abs = z.abs.and(x.abs, y.abs); - z.neg = false; - return z; - } - if (x.neg) { - _tmp = y; - _tmp$1 = x; - x = _tmp; - y = _tmp$1; - } - y1$1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.andNot(x.abs, y1$1); - z.neg = false; - return z; - }; - Int.prototype.And = function(x, y) { return this.$val.And(x, y); }; - Int.ptr.prototype.AndNot = function(x, y) { - var x, x1, x1$1, y, y1, y1$1, z; - z = this; - if (x.neg === y.neg) { - if (x.neg) { - x1 = (nat.nil).sub(x.abs, natOne); - y1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.andNot(y1, x1); - z.neg = false; - return z; - } - z.abs = z.abs.andNot(x.abs, y.abs); - z.neg = false; - return z; - } - if (x.neg) { - x1$1 = (nat.nil).sub(x.abs, natOne); - z.abs = z.abs.add(z.abs.or(x1$1, y.abs), natOne); - z.neg = true; - return z; - } - y1$1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.and(x.abs, y1$1); - z.neg = false; - return z; - }; - Int.prototype.AndNot = function(x, y) { return this.$val.AndNot(x, y); }; - Int.ptr.prototype.Or = function(x, y) { - var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; - z = this; - if (x.neg === y.neg) { - if (x.neg) { - x1 = (nat.nil).sub(x.abs, natOne); - y1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.add(z.abs.and(x1, y1), natOne); - z.neg = true; - return z; - } - z.abs = z.abs.or(x.abs, y.abs); - z.neg = false; - return z; - } - if (x.neg) { - _tmp = y; - _tmp$1 = x; - x = _tmp; - y = _tmp$1; - } - y1$1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.add(z.abs.andNot(y1$1, x.abs), natOne); - z.neg = true; - return z; - }; - Int.prototype.Or = function(x, y) { return this.$val.Or(x, y); }; - Int.ptr.prototype.Xor = function(x, y) { - var _tmp, _tmp$1, x, x1, y, y1, y1$1, z; - z = this; - if (x.neg === y.neg) { - if (x.neg) { - x1 = (nat.nil).sub(x.abs, natOne); - y1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.xor(x1, y1); - z.neg = false; - return z; - } - z.abs = z.abs.xor(x.abs, y.abs); - z.neg = false; - return z; - } - if (x.neg) { - _tmp = y; - _tmp$1 = x; - x = _tmp; - y = _tmp$1; - } - y1$1 = (nat.nil).sub(y.abs, natOne); - z.abs = z.abs.add(z.abs.xor(x.abs, y1$1), natOne); - z.neg = true; - return z; - }; - Int.prototype.Xor = function(x, y) { return this.$val.Xor(x, y); }; - Int.ptr.prototype.Not = function(x) { - var x, z; - z = this; - if (x.neg) { - z.abs = z.abs.sub(x.abs, natOne); - z.neg = false; - return z; - } - z.abs = z.abs.add(x.abs, natOne); - z.neg = true; - return z; - }; - Int.prototype.Not = function(x) { return this.$val.Not(x); }; - Int.ptr.prototype.Sqrt = function(x) { - var _r$1, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (x.neg) { - $panic(new $String("square root of negative number")); - } - z.neg = false; - _r$1 = z.abs.sqrt(x.abs); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - z.abs = _r$1; - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Sqrt }; } $f._r$1 = _r$1; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Sqrt = function(x) { return this.$val.Sqrt(x); }; - Int.ptr.prototype.Text = function(base) { - var _r$1, base, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (x === ptrType$1.nil) { - $s = -1; return ""; - } - _r$1 = x.abs.itoa(x.neg, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return ($bytesToString(_r$1)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Text }; } $f._r$1 = _r$1; $f.base = base; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Text = function(base) { return this.$val.Text(base); }; - Int.ptr.prototype.Append = function(buf, base) { - var _arg, _arg$1, _r$1, base, buf, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; base = $f.base; buf = $f.buf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (x === ptrType$1.nil) { - $s = -1; return $appendSlice(buf, ""); - } - _arg = buf; - _r$1 = x.abs.itoa(x.neg, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$1 = _r$1; - $s = -1; return $appendSlice(_arg, _arg$1); - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Append }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f.base = base; $f.buf = buf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Append = function(buf, base) { return this.$val.Append(buf, base); }; - Int.ptr.prototype.String = function() { - var _r$1, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = x.Text(10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.String = function() { return this.$val.String(); }; - writeMultiple = function(s, text, count) { - var _r$1, b, count, s, text, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; count = $f.count; s = $f.s; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - /* */ if (text.length > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (text.length > 0) { */ case 1: - b = (new sliceType$1($stringToBytes(text))); - /* while (true) { */ case 3: - /* if (!(count > 0)) { break; } */ if(!(count > 0)) { $s = 4; continue; } - _r$1 = s.Write(b); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - count = count - (1) >> 0; - /* } */ $s = 3; continue; case 4: - /* } */ case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: writeMultiple }; } $f._r$1 = _r$1; $f.b = b; $f.count = count; $f.s = s; $f.text = text; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.ptr.prototype.Format = function(s, ch) { - var _1, _2, _arg, _arg$1, _arg$2, _i, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, base, ch, d, d$1, digits, i, left, length, precision, precisionSet, prefix, right, s, sign, width, widthSet, x, zeros, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; ch = $f.ch; d = $f.d; d$1 = $f.d$1; digits = $f.digits; i = $f.i; left = $f.left; length = $f.length; precision = $f.precision; precisionSet = $f.precisionSet; prefix = $f.prefix; right = $f.right; s = $f.s; sign = $f.sign; width = $f.width; widthSet = $f.widthSet; x = $f.x; zeros = $f.zeros; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - base = 0; - _1 = ch; - /* */ if (_1 === (98)) { $s = 2; continue; } - /* */ if (_1 === (111)) { $s = 3; continue; } - /* */ if ((_1 === (100)) || (_1 === (115)) || (_1 === (118))) { $s = 4; continue; } - /* */ if ((_1 === (120)) || (_1 === (88))) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_1 === (98)) { */ case 2: - base = 2; - $s = 7; continue; - /* } else if (_1 === (111)) { */ case 3: - base = 8; - $s = 7; continue; - /* } else if ((_1 === (100)) || (_1 === (115)) || (_1 === (118))) { */ case 4: - base = 10; - $s = 7; continue; - /* } else if ((_1 === (120)) || (_1 === (88))) { */ case 5: - base = 16; - $s = 7; continue; - /* } else { */ case 6: - _arg = s; - _arg$1 = new $Int32(ch); - _r$1 = x.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$2 = new $String(_r$1); - _r$2 = fmt.Fprintf(_arg, "%%!%c(big.Int=%s)", new sliceType([_arg$1, _arg$2])); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - $s = -1; return; - /* } */ case 7: - case 1: - /* */ if (x === ptrType$1.nil) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (x === ptrType$1.nil) { */ case 10: - _r$3 = fmt.Fprint(s, new sliceType([new $String("")])); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - $s = -1; return; - /* } */ case 11: - sign = ""; - /* */ if (x.neg) { $s = 14; continue; } - _r$4 = s.Flag(43); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - /* */ if (_r$4) { $s = 15; continue; } - _r$5 = s.Flag(32); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (_r$5) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (x.neg) { */ case 14: - sign = "-"; - $s = 17; continue; - /* } else if (_r$4) { */ case 15: - sign = "+"; - $s = 17; continue; - /* } else if (_r$5) { */ case 16: - sign = " "; - /* } */ case 17: - case 13: - prefix = ""; - _r$6 = s.Flag(35); /* */ $s = 22; case 22: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - /* */ if (_r$6) { $s = 20; continue; } - /* */ $s = 21; continue; - /* if (_r$6) { */ case 20: - _2 = ch; - if (_2 === (111)) { - prefix = "0"; - } else if (_2 === (120)) { - prefix = "0x"; - } else if (_2 === (88)) { - prefix = "0X"; - } - /* } */ case 21: - _r$7 = x.abs.utoa(base); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - digits = _r$7; - if (ch === 88) { - _ref = digits; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (97 <= d && d <= 122) { - ((i < 0 || i >= digits.$length) ? ($throwRuntimeError("index out of range"), undefined) : digits.$array[digits.$offset + i] = (65 + ((d - 97 << 24 >>> 24)) << 24 >>> 24)); - } - _i++; - } - } - left = 0; - zeros = 0; - right = 0; - _r$8 = s.Precision(); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _tuple = _r$8; - precision = _tuple[0]; - precisionSet = _tuple[1]; - if (precisionSet) { - if (digits.$length < precision) { - zeros = precision - digits.$length >> 0; - } else if ((digits.$length === 1) && ((0 >= digits.$length ? ($throwRuntimeError("index out of range"), undefined) : digits.$array[digits.$offset + 0]) === 48) && (precision === 0)) { - $s = -1; return; - } - } - length = ((sign.length + prefix.length >> 0) + zeros >> 0) + digits.$length >> 0; - _r$9 = s.Width(); /* */ $s = 25; case 25: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _tuple$1 = _r$9; - width = _tuple$1[0]; - widthSet = _tuple$1[1]; - /* */ if (widthSet && length < width) { $s = 26; continue; } - /* */ $s = 27; continue; - /* if (widthSet && length < width) { */ case 26: - d$1 = width - length >> 0; - _r$10 = s.Flag(45); /* */ $s = 33; case 33: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - /* */ if (_r$10) { $s = 29; continue; } - _r$11 = s.Flag(48); /* */ $s = 34; case 34: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - /* */ if (_r$11 && !precisionSet) { $s = 30; continue; } - /* */ $s = 31; continue; - /* if (_r$10) { */ case 29: - right = d$1; - $s = 32; continue; - /* } else if (_r$11 && !precisionSet) { */ case 30: - zeros = d$1; - $s = 32; continue; - /* } else { */ case 31: - left = d$1; - /* } */ case 32: - case 28: - /* } */ case 27: - $r = writeMultiple(s, " ", left); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = writeMultiple(s, sign, 1); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = writeMultiple(s, prefix, 1); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = writeMultiple(s, "0", zeros); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$12 = s.Write(digits); /* */ $s = 39; case 39: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - _r$12; - $r = writeMultiple(s, " ", right); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Format }; } $f._1 = _1; $f._2 = _2; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.ch = ch; $f.d = d; $f.d$1 = d$1; $f.digits = digits; $f.i = i; $f.left = left; $f.length = length; $f.precision = precision; $f.precisionSet = precisionSet; $f.prefix = prefix; $f.right = right; $f.s = s; $f.sign = sign; $f.width = width; $f.widthSet = widthSet; $f.x = x; $f.zeros = zeros; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Format = function(s, ch) { return this.$val.Format(s, ch); }; - Int.ptr.prototype.scan = function(r, base) { - var _r$1, _r$2, _tuple, _tuple$1, base, err, neg, r, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; err = $f.err; neg = $f.neg; r = $f.r; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = scanSign(r); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - neg = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, 0, err]; - } - _r$2 = z.abs.scan(r, base, false); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - z.abs = _tuple$1[0]; - base = _tuple$1[1]; - err = _tuple$1[3]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, base, err]; - } - z.neg = z.abs.$length > 0 && neg; - $s = -1; return [z, base, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.scan }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.err = err; $f.neg = neg; $f.r = r; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.scan = function(r, base) { return this.$val.scan(r, base); }; - scanSign = function(r) { - var _1, _r$1, _r$2, _tmp, _tmp$1, _tuple, ch, err, neg, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; ch = $f.ch; err = $f.err; neg = $f.neg; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - neg = false; - err = $ifaceNil; - ch = 0; - _r$1 = r.ReadByte(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ch = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp = false; - _tmp$1 = err; - neg = _tmp; - err = _tmp$1; - $s = -1; return [neg, err]; - } - _1 = ch; - /* */ if (_1 === (45)) { $s = 3; continue; } - /* */ if (_1 === (43)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_1 === (45)) { */ case 3: - neg = true; - $s = 6; continue; - /* } else if (_1 === (43)) { */ case 4: - $s = 6; continue; - /* } else { */ case 5: - _r$2 = r.UnreadByte(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - /* } */ case 6: - case 2: - $s = -1; return [neg, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: scanSign }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.neg = neg; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - byteReader.ptr.prototype.ReadByte = function() { - var _r$1, _r$2, _tuple, ch, err, r, size, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ch = $f.ch; err = $f.err; r = $f.r; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r$1 = r.ScanState.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ch = _tuple[0]; - size = _tuple[1]; - err = _tuple[2]; - /* */ if (!((size === 1)) && $interfaceIsEqual(err, $ifaceNil)) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((size === 1)) && $interfaceIsEqual(err, $ifaceNil)) { */ case 2: - _r$2 = fmt.Errorf("invalid rune %#U", new sliceType([new $Int32(ch)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - err = _r$2; - /* } */ case 3: - $s = -1; return [((ch << 24 >>> 24)), err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: byteReader.ptr.prototype.ReadByte }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ch = ch; $f.err = err; $f.r = r; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; - }; - byteReader.prototype.ReadByte = function() { return this.$val.ReadByte(); }; - byteReader.ptr.prototype.UnreadByte = function() { - var _r$1, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _r$1 = r.ScanState.UnreadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: byteReader.ptr.prototype.UnreadByte }; } $f._r$1 = _r$1; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - byteReader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); }; - Int.ptr.prototype.Scan = function(s, ch) { - var _1, _r$1, _tuple, base, ch, err, s, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _tuple = $f._tuple; base = $f.base; ch = $f.ch; err = $f.err; s = $f.s; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - $r = s.SkipSpace(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - base = 0; - _1 = ch; - if (_1 === (98)) { - base = 2; - } else if (_1 === (111)) { - base = 8; - } else if (_1 === (100)) { - base = 10; - } else if ((_1 === (120)) || (_1 === (88))) { - base = 16; - } else if ((_1 === (115)) || (_1 === (118))) { - } else { - $s = -1; return errors.New("Int.Scan: invalid verb"); - } - _r$1 = z.scan((x = new byteReader.ptr(s), new x.constructor.elem(x)), base); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - err = _tuple[2]; - $s = -1; return err; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Scan }; } $f._1 = _1; $f._r$1 = _r$1; $f._tuple = _tuple; $f.base = base; $f.ch = ch; $f.err = err; $f.s = s; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; - Int.ptr.prototype.GobEncode = function() { - var b, buf, i, x; - x = this; - if (x === ptrType$1.nil) { - return [sliceType$1.nil, $ifaceNil]; - } - buf = $makeSlice(sliceType$1, (1 + ($imul(x.abs.$length, 4)) >> 0)); - i = x.abs.bytes(buf) - 1 >> 0; - b = 2; - if (x.neg) { - b = (b | (1)) >>> 0; - } - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = b); - return [$subslice(buf, i), $ifaceNil]; - }; - Int.prototype.GobEncode = function() { return this.$val.GobEncode(); }; - Int.ptr.prototype.GobDecode = function(buf) { - var _r$1, b, buf, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (buf.$length === 0) { - Int.copy(z, new Int.ptr(false, nat.nil)); - $s = -1; return $ifaceNil; - } - b = (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]); - /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1: - _r$1 = fmt.Errorf("Int.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - z.neg = !((((b & 1) >>> 0) === 0)); - z.abs = z.abs.setBytes($subslice(buf, 1)); - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; - Int.ptr.prototype.MarshalText = function() { - var _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, err, text, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - text = sliceType$1.nil; - err = $ifaceNil; - x = this; - if (x === ptrType$1.nil) { - _tmp = (new sliceType$1($stringToBytes(""))); - _tmp$1 = $ifaceNil; - text = _tmp; - err = _tmp$1; - $s = -1; return [text, err]; - } - _r$1 = x.abs.itoa(x.neg, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tmp$2 = _r$1; - _tmp$3 = $ifaceNil; - text = _tmp$2; - err = _tmp$3; - $s = -1; return [text, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.MarshalText = function() { return this.$val.MarshalText(); }; - Int.ptr.prototype.UnmarshalText = function(text) { - var _r$1, _r$2, _tuple, ok, text, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.setFromScanner(bytes.NewReader(text), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ok = _tuple[1]; - /* */ if (!ok) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!ok) { */ case 2: - _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", new sliceType([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* } */ case 3: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; - Int.ptr.prototype.MarshalJSON = function() { - var _r$1, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = x.MarshalText(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.MarshalJSON }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); }; - Int.ptr.prototype.UnmarshalJSON = function(text) { - var _r$1, text, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (($bytesToString(text)) === "null") { - $s = -1; return $ifaceNil; - } - _r$1 = z.UnmarshalText(text); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalJSON }; } $f._r$1 = _r$1; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.UnmarshalJSON = function(text) { return this.$val.UnmarshalJSON(text); }; - nat.prototype.clear = function() { - var _i, _ref, i, z; - z = this; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = 0); - _i++; - } - }; - $ptrType(nat).prototype.clear = function() { return this.$get().clear(); }; - nat.prototype.norm = function() { - var i, x, z; - z = this; - i = z.$length; - while (true) { - if (!(i > 0 && ((x = i - 1 >> 0, ((x < 0 || x >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x])) === 0))) { break; } - i = i - (1) >> 0; - } - return $subslice(z, 0, i); - }; - $ptrType(nat).prototype.norm = function() { return this.$get().norm(); }; - nat.prototype.make = function(n) { - var n, z; - z = this; - if (n <= z.$capacity) { - return $subslice(z, 0, n); - } - if (n === 1) { - return $makeSlice(nat, 1); - } - return $makeSlice(nat, n, (n + 4 >> 0)); - }; - $ptrType(nat).prototype.make = function(n) { return this.$get().make(n); }; - nat.prototype.setWord = function(x) { - var x, z; - z = this; - if (x === 0) { - return $subslice(z, 0, 0); - } - z = z.make(1); - (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = x); - return z; - }; - $ptrType(nat).prototype.setWord = function(x) { return this.$get().setWord(x); }; - nat.prototype.setUint64 = function(x) { - var w, x, x$1, z; - z = this; - w = ((x.$low >>> 0)); - if ((x$1 = (new $Uint64(0, w.constructor === Number ? w : 1)), (x$1.$high === x.$high && x$1.$low === x.$low))) { - return z.setWord(w); - } - z = z.make(2); - (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = (($shiftRightUint64(x, 32).$low >>> 0))); - (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = ((x.$low >>> 0))); - return z; - }; - $ptrType(nat).prototype.setUint64 = function(x) { return this.$get().setUint64(x); }; - nat.prototype.set = function(x) { - var x, z; - z = this; - z = z.make(x.$length); - $copySlice(z, x); - return z; - }; - $ptrType(nat).prototype.set = function(x) { return this.$get().set(x); }; - nat.prototype.add = function(x, y) { - var c, m, n, x, x$1, x$2, x$3, y, z; - z = this; - m = x.$length; - n = y.$length; - if (m < n) { - return z.add(y, x); - } else if ((m === 0)) { - return $subslice(z, 0, 0); - } else if ((n === 0)) { - return z.set(x); - } - z = z.make(m + 1 >> 0); - c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$2(y.$array), y.$offset, y.$offset + y.$length)); - if (m > n) { - c = addVW((x$2 = $subslice(z, n, m), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); - } - ((m < 0 || m >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + m] = c); - return z.norm(); - }; - $ptrType(nat).prototype.add = function(x, y) { return this.$get().add(x, y); }; - nat.prototype.sub = function(x, y) { - var c, m, n, x, x$1, x$2, x$3, y, z; - z = this; - m = x.$length; - n = y.$length; - if (m < n) { - $panic(new $String("underflow")); - } else if ((m === 0)) { - return $subslice(z, 0, 0); - } else if ((n === 0)) { - return z.set(x); - } - z = z.make(m); - c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$2(y.$array), y.$offset, y.$offset + y.$length)); - if (m > n) { - c = subVW((x$2 = $subslice(z, n), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); - } - if (!((c === 0))) { - $panic(new $String("underflow")); - } - return z.norm(); - }; - $ptrType(nat).prototype.sub = function(x, y) { return this.$get().sub(x, y); }; - nat.prototype.cmp = function(y) { - var i, m, n, r, x, y; - r = 0; - x = this; - m = x.$length; - n = y.$length; - if (!((m === n)) || (m === 0)) { - if (m < n) { - r = -1; - } else if (m > n) { - r = 1; - } - return r; - } - i = m - 1 >> 0; - while (true) { - if (!(i > 0 && (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) === ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])))) { break; } - i = i - (1) >> 0; - } - if (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) < ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) { - r = -1; - } else if (((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) > ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) { - r = 1; - } - return r; - }; - $ptrType(nat).prototype.cmp = function(y) { return this.$get().cmp(y); }; - nat.prototype.mulAddWW = function(x, y, r) { - var m, r, x, x$1, y, z; - z = this; - m = x.$length; - if ((m === 0) || (y === 0)) { - return z.setWord(r); - } - z = z.make(m + 1 >> 0); - ((m < 0 || m >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + m] = mulAddVWW((x$1 = $subslice(z, 0, m), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), y, r)); - return z.norm(); - }; - $ptrType(nat).prototype.mulAddWW = function(x, y, r) { return this.$get().mulAddWW(x, y, r); }; - basicMul = function(z, x, y) { - var _i, _ref, d, i, x, x$1, x$2, y, z; - $subslice(z, 0, (x.$length + y.$length >> 0)).clear(); - _ref = y; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((d === 0))) { - (x$2 = x.$length + i >> 0, ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = addMulVVW((x$1 = $subslice(z, i, (i + x.$length >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d))); - } - _i++; - } - }; - nat.prototype.montgomery = function(x, y, m, k, n) { - var c, c2, c3, cx, cy, d, i, k, m, n, t, x, x$1, x$2, x$3, x$4, x$5, y, z; - z = this; - if (!((x.$length === n)) || !((y.$length === n)) || !((m.$length === n))) { - $panic(new $String("math/big: mismatched montgomery number lengths")); - } - z = z.make($imul(n, 2)); - z.clear(); - c = 0; - i = 0; - while (true) { - if (!(i < n)) { break; } - d = ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]); - c2 = addMulVVW((x$1 = $subslice(z, i, (n + i >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d); - t = $imul(((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i]), k) >>> 0; - c3 = addMulVVW((x$2 = $subslice(z, i, (n + i >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length), t); - cx = c + c2 >>> 0; - cy = cx + c3 >>> 0; - (x$3 = n + i >> 0, ((x$3 < 0 || x$3 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$3] = cy)); - if (cx < c2 || cy < c3) { - c = 1; - } else { - c = 0; - } - i = i + (1) >> 0; - } - if (!((c === 0))) { - subVV((x$4 = $subslice(z, 0, n), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), (x$5 = $subslice(z, n), $subslice(new sliceType$2(x$5.$array), x$5.$offset, x$5.$offset + x$5.$length)), $subslice(new sliceType$2(m.$array), m.$offset, m.$offset + m.$length)); - } else { - $copySlice($subslice(z, 0, n), $subslice(z, n)); - } - return $subslice(z, 0, n); - }; - $ptrType(nat).prototype.montgomery = function(x, y, m, k, n) { return this.$get().montgomery(x, y, m, k, n); }; - karatsubaAdd = function(z, x, n) { - var c, n, x, x$1, x$2, x$3, z; - c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); - if (!((c === 0))) { - addVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); - } - }; - karatsubaSub = function(z, x, n) { - var c, n, x, x$1, x$2, x$3, z; - c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); - if (!((c === 0))) { - subVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c); - } - }; - karatsuba = function(z, x, y) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, n, n2, p, r, s, x, x0, x1, xd, y, y0, y1, yd, z; - n = y.$length; - if (!(((n & 1) === 0)) || n < karatsubaThreshold || n < 2) { - basicMul(z, x, y); - return; - } - n2 = n >> 1 >> 0; - _tmp = $subslice(x, n2); - _tmp$1 = $subslice(x, 0, n2); - x1 = _tmp; - x0 = _tmp$1; - _tmp$2 = $subslice(y, n2); - _tmp$3 = $subslice(y, 0, n2); - y1 = _tmp$2; - y0 = _tmp$3; - karatsuba(z, x0, y0); - karatsuba($subslice(z, n), x1, y1); - s = 1; - xd = $subslice(z, ($imul(2, n)), (($imul(2, n)) + n2 >> 0)); - if (!((subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length)) === 0))) { - s = -s; - subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length)); - } - yd = $subslice(z, (($imul(2, n)) + n2 >> 0), ($imul(3, n))); - if (!((subVV($subslice(new sliceType$2(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$2(y0.$array), y0.$offset, y0.$offset + y0.$length), $subslice(new sliceType$2(y1.$array), y1.$offset, y1.$offset + y1.$length)) === 0))) { - s = -s; - subVV($subslice(new sliceType$2(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$2(y1.$array), y1.$offset, y1.$offset + y1.$length), $subslice(new sliceType$2(y0.$array), y0.$offset, y0.$offset + y0.$length)); - } - p = $subslice(z, ($imul(n, 3))); - karatsuba(p, xd, yd); - r = $subslice(z, ($imul(n, 4))); - $copySlice(r, $subslice(z, 0, ($imul(n, 2)))); - karatsubaAdd($subslice(z, n2), r, n); - karatsubaAdd($subslice(z, n2), $subslice(r, n), n); - if (s > 0) { - karatsubaAdd($subslice(z, n2), p, n); - } else { - karatsubaSub($subslice(z, n2), p, n); - } - }; - alias = function(x, y) { - var x, x$1, x$2, y; - return x.$capacity > 0 && y.$capacity > 0 && (x$1 = $subslice(x, 0, x.$capacity), $indexPtr(x$1.$array, x$1.$offset + (x.$capacity - 1 >> 0), ptrType$3)) === (x$2 = $subslice(y, 0, y.$capacity), $indexPtr(x$2.$array, x$2.$offset + (y.$capacity - 1 >> 0), ptrType$3)); - }; - addAt = function(z, x, i) { - var c, i, j, n, x, x$1, x$2, x$3, x$4, z; - n = x.$length; - if (n > 0) { - c = addVV((x$1 = $subslice(z, i, (i + n >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (x$2 = $subslice(z, i), $subslice(new sliceType$2(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); - if (!((c === 0))) { - j = i + n >> 0; - if (j < z.$length) { - addVW((x$3 = $subslice(z, j), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = $subslice(z, j), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), c); - } - } - } - }; - max = function(x, y) { - var x, y; - if (x > y) { - return x; - } - return y; - }; - karatsubaLen = function(n, threshold) { - var i, n, threshold, y; - i = 0; - while (true) { - if (!(n > threshold)) { break; } - n = (n >> $min((1), 31)) >> 0; - i = i + (1) >>> 0; - } - return (y = i, y < 32 ? (n << y) : 0) >> 0; - }; - nat.prototype.mul = function(x, y) { - var i, k, m, n, t, x, x0, x0$1, xi, y, y0, y0$1, y1, z; - z = this; - m = x.$length; - n = y.$length; - if (m < n) { - return z.mul(y, x); - } else if ((m === 0) || (n === 0)) { - return $subslice(z, 0, 0); - } else if ((n === 1)) { - return z.mulAddWW(x, (0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]), 0); - } - if (alias(z, x) || alias(z, y)) { - z = nat.nil; - } - if (n < karatsubaThreshold) { - z = z.make(m + n >> 0); - basicMul(z, x, y); - return z.norm(); - } - k = karatsubaLen(n, karatsubaThreshold); - x0 = $subslice(x, 0, k); - y0 = $subslice(y, 0, k); - z = z.make(max($imul(6, k), m + n >> 0)); - karatsuba(z, x0, y0); - z = $subslice(z, 0, (m + n >> 0)); - $subslice(z, ($imul(2, k))).clear(); - if (k < n || !((m === n))) { - t = nat.nil; - x0$1 = x0.norm(); - y1 = $subslice(y, k); - t = t.mul(x0$1, y1); - addAt(z, t, k); - y0$1 = y0.norm(); - i = k; - while (true) { - if (!(i < x.$length)) { break; } - xi = $subslice(x, i); - if (xi.$length > k) { - xi = $subslice(xi, 0, k); - } - xi = xi.norm(); - t = t.mul(xi, y0$1); - addAt(z, t, i); - t = t.mul(xi, y1); - addAt(z, t, i + k >> 0); - i = i + (k) >> 0; - } - } - return z.norm(); - }; - $ptrType(nat).prototype.mul = function(x, y) { return this.$get().mul(x, y); }; - basicSqr = function(z, x) { - var _tuple, _tuple$1, d, i, n, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, z; - n = x.$length; - t = $makeSlice(nat, ($imul(2, n))); - _tuple = mulWW((0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]), (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = _tuple[0]); - (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = _tuple[1]); - i = 1; - while (true) { - if (!(i < n)) { break; } - d = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]); - _tuple$1 = mulWW(d, d); - (x$1 = ($imul(2, i)) + 1 >> 0, ((x$1 < 0 || x$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$1] = _tuple$1[0])); - (x$2 = $imul(2, i), ((x$2 < 0 || x$2 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$2] = _tuple$1[1])); - (x$5 = $imul(2, i), ((x$5 < 0 || x$5 >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + x$5] = addMulVVW((x$3 = $subslice(t, i, ($imul(2, i))), $subslice(new sliceType$2(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = $subslice(x, 0, i), $subslice(new sliceType$2(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), d))); - i = i + (1) >> 0; - } - (x$8 = ($imul(2, n)) - 1 >> 0, ((x$8 < 0 || x$8 >= t.$length) ? ($throwRuntimeError("index out of range"), undefined) : t.$array[t.$offset + x$8] = shlVU((x$6 = $subslice(t, 1, (($imul(2, n)) - 1 >> 0)), $subslice(new sliceType$2(x$6.$array), x$6.$offset, x$6.$offset + x$6.$length)), (x$7 = $subslice(t, 1, (($imul(2, n)) - 1 >> 0)), $subslice(new sliceType$2(x$7.$array), x$7.$offset, x$7.$offset + x$7.$length)), 1))); - addVV($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$2(t.$array), t.$offset, t.$offset + t.$length)); - }; - karatsubaSqr = function(z, x) { - var _tmp, _tmp$1, n, n2, p, r, x, x0, x1, xd, z; - n = x.$length; - if (!(((n & 1) === 0)) || n < karatsubaSqrThreshold || n < 2) { - basicSqr($subslice(z, 0, ($imul(2, n))), x); - return; - } - n2 = n >> 1 >> 0; - _tmp = $subslice(x, n2); - _tmp$1 = $subslice(x, 0, n2); - x1 = _tmp; - x0 = _tmp$1; - karatsubaSqr(z, x0); - karatsubaSqr($subslice(z, n), x1); - xd = $subslice(z, ($imul(2, n)), (($imul(2, n)) + n2 >> 0)); - if (!((subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length)) === 0))) { - subVV($subslice(new sliceType$2(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$2(x0.$array), x0.$offset, x0.$offset + x0.$length), $subslice(new sliceType$2(x1.$array), x1.$offset, x1.$offset + x1.$length)); - } - p = $subslice(z, ($imul(n, 3))); - karatsubaSqr(p, xd); - r = $subslice(z, ($imul(n, 4))); - $copySlice(r, $subslice(z, 0, ($imul(n, 2)))); - karatsubaAdd($subslice(z, n2), r, n); - karatsubaAdd($subslice(z, n2), $subslice(r, n), n); - karatsubaSub($subslice(z, n2), p, n); - }; - nat.prototype.sqr = function(x) { - var _tuple, d, k, n, t, x, x0, x0$1, x1, z; - z = this; - n = x.$length; - if ((n === 0)) { - return $subslice(z, 0, 0); - } else if ((n === 1)) { - d = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); - z = z.make(2); - _tuple = mulWW(d, d); - (1 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 1] = _tuple[0]); - (0 >= z.$length ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + 0] = _tuple[1]); - return z.norm(); - } - if (alias(z, x)) { - z = nat.nil; - } - if (n < basicSqrThreshold) { - z = z.make($imul(2, n)); - basicMul(z, x, x); - return z.norm(); - } - if (n < karatsubaSqrThreshold) { - z = z.make($imul(2, n)); - basicSqr(z, x); - return z.norm(); - } - k = karatsubaLen(n, karatsubaSqrThreshold); - x0 = $subslice(x, 0, k); - z = z.make(max($imul(6, k), $imul(2, n))); - karatsubaSqr(z, x0); - z = $subslice(z, 0, ($imul(2, n))); - $subslice(z, ($imul(2, k))).clear(); - if (k < n) { - t = nat.nil; - x0$1 = x0.norm(); - x1 = $subslice(x, k); - t = t.mul(x0$1, x1); - addAt(z, t, k); - addAt(z, t, k); - t = t.sqr(x1); - addAt(z, t, $imul(2, k)); - } - return z.norm(); - }; - $ptrType(nat).prototype.sqr = function(x) { return this.$get().sqr(x); }; - nat.prototype.mulRange = function(a, b) { - var a, b, m, x, z; - z = this; - if ((a.$high === 0 && a.$low === 0)) { - return z.setUint64(new $Uint64(0, 0)); - } else if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) { - return z.setUint64(new $Uint64(0, 1)); - } else if ((a.$high === b.$high && a.$low === b.$low)) { - return z.setUint64(a); - } else if ((x = new $Uint64(a.$high + 0, a.$low + 1), (x.$high === b.$high && x.$low === b.$low))) { - return z.mul((nat.nil).setUint64(a), (nat.nil).setUint64(b)); - } - m = $div64((new $Uint64(a.$high + b.$high, a.$low + b.$low)), new $Uint64(0, 2), false); - return z.mul((nat.nil).mulRange(a, m), (nat.nil).mulRange(new $Uint64(m.$high + 0, m.$low + 1), b)); - }; - $ptrType(nat).prototype.mulRange = function(a, b) { return this.$get().mulRange(a, b); }; - nat.prototype.divW = function(x, y) { - var m, q, r, x, y, z; - q = nat.nil; - r = 0; - z = this; - m = x.$length; - if ((y === 0)) { - $panic(new $String("division by zero")); - } else if ((y === 1)) { - q = z.set(x); - return [q, r]; - } else if ((m === 0)) { - q = $subslice(z, 0, 0); - return [q, r]; - } - z = z.make(m); - r = divWVW($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), 0, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), y); - q = z.norm(); - return [q, r]; - }; - $ptrType(nat).prototype.divW = function(x, y) { return this.$get().divW(x, y); }; - nat.prototype.div = function(z2, u, v) { - var _r$1, _tuple, _tuple$1, q, r, r2, u, v, z, z2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; q = $f.q; r = $f.r; r2 = $f.r2; u = $f.u; v = $f.v; z = $f.z; z2 = $f.z2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - q = nat.nil; - r = nat.nil; - z = this; - if (v.$length === 0) { - $panic(new $String("division by zero")); - } - if (u.cmp(v) < 0) { - q = $subslice(z, 0, 0); - r = z2.set(u); - $s = -1; return [q, r]; - } - if (v.$length === 1) { - r2 = 0; - _tuple = z.divW(u, (0 >= v.$length ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + 0])); - q = _tuple[0]; - r2 = _tuple[1]; - r = z2.setWord(r2); - $s = -1; return [q, r]; - } - _r$1 = z.divLarge(z2, u, v); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - q = _tuple$1[0]; - r = _tuple$1[1]; - $s = -1; return [q, r]; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.div }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.q = q; $f.r = r; $f.r2 = r2; $f.u = u; $f.v = v; $f.z = z; $f.z2 = z2; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.div = function(z2, u, v) { return this.$get().div(z2, u, v); }; - getNat = function(n) { - var _r$1, n, v, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; n = $f.n; v = $f.v; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = ptrType$4.nil; - _r$1 = natPool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - v = _r$1; - if (!($interfaceIsEqual(v, $ifaceNil))) { - z = $assertType(v, ptrType$4); - } - if (z === ptrType$4.nil) { - z = $newDataPointer(nat.nil, ptrType$4); - } - z.$set(z.make(n)); - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: getNat }; } $f._r$1 = _r$1; $f.n = n; $f.v = v; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - putNat = function(x) { - var x; - natPool.Put(x); - }; - nat.prototype.divLarge = function(u, uIn, vIn) { - var _index, _r$1, _r$2, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, c, c$1, j, m, n, prevRhat, q, qhat, qhatv, qhatvp, r, rhat, shift, u, uIn, ujn, ujn2, v, vIn, vn1, vn2, vp, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, x1, x2, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _index = $f._index; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; c = $f.c; c$1 = $f.c$1; j = $f.j; m = $f.m; n = $f.n; prevRhat = $f.prevRhat; q = $f.q; qhat = $f.qhat; qhatv = $f.qhatv; qhatvp = $f.qhatvp; r = $f.r; rhat = $f.rhat; shift = $f.shift; u = $f.u; uIn = $f.uIn; ujn = $f.ujn; ujn2 = $f.ujn2; v = $f.v; vIn = $f.vIn; vn1 = $f.vn1; vn2 = $f.vn2; vp = $f.vp; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; x1 = $f.x1; x2 = $f.x2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - q = nat.nil; - r = nat.nil; - z = this; - n = vIn.$length; - m = uIn.$length - n >> 0; - shift = nlz((x = n - 1 >> 0, ((x < 0 || x >= vIn.$length) ? ($throwRuntimeError("index out of range"), undefined) : vIn.$array[vIn.$offset + x]))); - _r$1 = getNat(n); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - vp = _r$1; - v = vp.$get(); - shlVU($subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length), $subslice(new sliceType$2(vIn.$array), vIn.$offset, vIn.$offset + vIn.$length), shift); - u = u.make(uIn.$length + 1 >> 0); - (x$2 = uIn.$length, ((x$2 < 0 || x$2 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$2] = shlVU((x$1 = $subslice(u, 0, uIn.$length), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(uIn.$array), uIn.$offset, uIn.$offset + uIn.$length), shift))); - if (alias(z, u)) { - z = nat.nil; - } - q = z.make(m + 1 >> 0); - _r$2 = getNat(n + 1 >> 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - qhatvp = _r$2; - qhatv = qhatvp.$get(); - vn1 = (x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= v.$length) ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + x$3])); - j = m; - while (true) { - if (!(j >= 0)) { break; } - qhat = 4294967295; - ujn = (x$4 = j + n >> 0, ((x$4 < 0 || x$4 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$4])); - if (!((ujn === vn1))) { - rhat = 0; - _tuple = divWW(ujn, (x$5 = (j + n >> 0) - 1 >> 0, ((x$5 < 0 || x$5 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$5])), vn1); - qhat = _tuple[0]; - rhat = _tuple[1]; - vn2 = (x$6 = n - 2 >> 0, ((x$6 < 0 || x$6 >= v.$length) ? ($throwRuntimeError("index out of range"), undefined) : v.$array[v.$offset + x$6])); - _tuple$1 = mulWW(qhat, vn2); - x1 = _tuple$1[0]; - x2 = _tuple$1[1]; - ujn2 = (x$7 = (j + n >> 0) - 2 >> 0, ((x$7 < 0 || x$7 >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + x$7])); - while (true) { - if (!(greaterThan(x1, x2, rhat, ujn2))) { break; } - qhat = qhat - (1) >>> 0; - prevRhat = rhat; - rhat = rhat + (vn1) >>> 0; - if (rhat < prevRhat) { - break; - } - _tuple$2 = mulWW(qhat, vn2); - x1 = _tuple$2[0]; - x2 = _tuple$2[1]; - } - } - ((n < 0 || n >= qhatv.$length) ? ($throwRuntimeError("index out of range"), undefined) : qhatv.$array[qhatv.$offset + n] = mulAddVWW((x$8 = $subslice(qhatv, 0, n), $subslice(new sliceType$2(x$8.$array), x$8.$offset, x$8.$offset + x$8.$length)), $subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length), qhat, 0)); - c = subVV((x$9 = $subslice(u, j, (j + qhatv.$length >> 0)), $subslice(new sliceType$2(x$9.$array), x$9.$offset, x$9.$offset + x$9.$length)), (x$10 = $subslice(u, j), $subslice(new sliceType$2(x$10.$array), x$10.$offset, x$10.$offset + x$10.$length)), $subslice(new sliceType$2(qhatv.$array), qhatv.$offset, qhatv.$offset + qhatv.$length)); - if (!((c === 0))) { - c$1 = addVV((x$11 = $subslice(u, j, (j + n >> 0)), $subslice(new sliceType$2(x$11.$array), x$11.$offset, x$11.$offset + x$11.$length)), (x$12 = $subslice(u, j), $subslice(new sliceType$2(x$12.$array), x$12.$offset, x$12.$offset + x$12.$length)), $subslice(new sliceType$2(v.$array), v.$offset, v.$offset + v.$length)); - _index = j + n >> 0; - ((_index < 0 || _index >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + _index] = (((_index < 0 || _index >= u.$length) ? ($throwRuntimeError("index out of range"), undefined) : u.$array[u.$offset + _index]) + (c$1) >>> 0)); - qhat = qhat - (1) >>> 0; - } - ((j < 0 || j >= q.$length) ? ($throwRuntimeError("index out of range"), undefined) : q.$array[q.$offset + j] = qhat); - j = j - (1) >> 0; - } - putNat(vp); - putNat(qhatvp); - q = q.norm(); - shrVU($subslice(new sliceType$2(u.$array), u.$offset, u.$offset + u.$length), $subslice(new sliceType$2(u.$array), u.$offset, u.$offset + u.$length), shift); - r = u.norm(); - _tmp = q; - _tmp$1 = r; - q = _tmp; - r = _tmp$1; - $s = -1; return [q, r]; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.divLarge }; } $f._index = _index; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.c = c; $f.c$1 = c$1; $f.j = j; $f.m = m; $f.n = n; $f.prevRhat = prevRhat; $f.q = q; $f.qhat = qhat; $f.qhatv = qhatv; $f.qhatvp = qhatvp; $f.r = r; $f.rhat = rhat; $f.shift = shift; $f.u = u; $f.uIn = uIn; $f.ujn = ujn; $f.ujn2 = ujn2; $f.v = v; $f.vIn = vIn; $f.vn1 = vn1; $f.vn2 = vn2; $f.vp = vp; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.x1 = x1; $f.x2 = x2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.divLarge = function(u, uIn, vIn) { return this.$get().divLarge(u, uIn, vIn); }; - nat.prototype.bitLen = function() { - var i, x; - x = this; - i = x.$length - 1 >> 0; - if (i >= 0) { - return ($imul(i, 32)) + bits.Len(((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0))) >> 0; - } - return 0; - }; - $ptrType(nat).prototype.bitLen = function() { return this.$get().bitLen(); }; - nat.prototype.trailingZeroBits = function() { - var i, x; - x = this; - if (x.$length === 0) { - return 0; - } - i = 0; - while (true) { - if (!(((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) === 0)) { break; } - i = i + (1) >>> 0; - } - return (i * 32 >>> 0) + ((bits.TrailingZeros(((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) >>> 0))) >>> 0)) >>> 0; - }; - $ptrType(nat).prototype.trailingZeroBits = function() { return this.$get().trailingZeroBits(); }; - same = function(x, y) { - var x, y; - return (x.$length === y.$length) && x.$length > 0 && $indexPtr(x.$array, x.$offset + 0, ptrType$3) === $indexPtr(y.$array, y.$offset + 0, ptrType$3); - }; - nat.prototype.shl = function(x, s) { - var _q, _r$1, m, n, s, x, x$1, z; - z = this; - if (s === 0) { - if (same(z, x)) { - return z; - } - if (!alias(z, x)) { - return z.set(x); - } - } - m = x.$length; - if (m === 0) { - return $subslice(z, 0, 0); - } - n = m + (((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) >> 0; - z = z.make(n + 1 >> 0); - ((n < 0 || n >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + n] = shlVU((x$1 = $subslice(z, (n - m >> 0), n), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), (_r$1 = s % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")))); - $subslice(z, 0, (n - m >> 0)).clear(); - return z.norm(); - }; - $ptrType(nat).prototype.shl = function(x, s) { return this.$get().shl(x, s); }; - nat.prototype.shr = function(x, s) { - var _q, _r$1, m, n, s, x, x$1, z; - z = this; - if (s === 0) { - if (same(z, x)) { - return z; - } - if (!alias(z, x)) { - return z.set(x); - } - } - m = x.$length; - n = m - (((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) >> 0; - if (n <= 0) { - return $subslice(z, 0, 0); - } - z = z.make(n); - shrVU($subslice(new sliceType$2(z.$array), z.$offset, z.$offset + z.$length), (x$1 = $subslice(x, (m - n >> 0)), $subslice(new sliceType$2(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (_r$1 = s % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))); - return z.norm(); - }; - $ptrType(nat).prototype.shr = function(x, s) { return this.$get().shr(x, s); }; - nat.prototype.setBit = function(x, i, b) { - var _1, _q, _r$1, b, i, j, m, n, x, y, z; - z = this; - j = (((_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); - m = (y = ((_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (1 << y) : 0) >>> 0; - n = x.$length; - _1 = b; - if (_1 === (0)) { - z = z.make(n); - $copySlice(z, x); - if (j >= n) { - return z; - } - ((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j] = ((((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j]) & ~(m)) >>> 0)); - return z.norm(); - } else if (_1 === (1)) { - if (j >= n) { - z = z.make(j + 1 >> 0); - $subslice(z, n).clear(); - } else { - z = z.make(n); - } - $copySlice(z, x); - ((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j] = ((((j < 0 || j >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + j]) | (m)) >>> 0)); - return z; - } - $panic(new $String("set bit is not 0 or 1")); - }; - $ptrType(nat).prototype.setBit = function(x, i, b) { return this.$get().setBit(x, i, b); }; - nat.prototype.bit = function(i) { - var _q, _r$1, i, j, x, y; - x = this; - j = (_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - if (j >= ((x.$length >>> 0))) { - return 0; - } - return ((((((y = ((_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]) >>> y) : 0) >>> 0) & 1) >>> 0) >>> 0)); - }; - $ptrType(nat).prototype.bit = function(i) { return this.$get().bit(i); }; - nat.prototype.sticky = function(i) { - var _i, _q, _r$1, _ref, i, j, x, x$1, y; - x = this; - j = (_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - if (j >= ((x.$length >>> 0))) { - if (x.$length === 0) { - return 0; - } - return 1; - } - _ref = $subslice(x, 0, j); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - x$1 = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((x$1 === 0))) { - return 1; - } - _i++; - } - if (!((((y = ((32 - (_r$1 = i % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)), y < 32 ? (((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j]) << y) : 0) >>> 0) === 0))) { - return 1; - } - return 0; - }; - $ptrType(nat).prototype.sticky = function(i) { return this.$get().sticky(i); }; - nat.prototype.and = function(x, y) { - var i, m, n, x, y, z; - z = this; - m = x.$length; - n = y.$length; - if (m > n) { - m = n; - } - z = z.make(m); - i = 0; - while (true) { - if (!(i < m)) { break; } - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); - i = i + (1) >> 0; - } - return z.norm(); - }; - $ptrType(nat).prototype.and = function(x, y) { return this.$get().and(x, y); }; - nat.prototype.andNot = function(x, y) { - var i, m, n, x, y, z; - z = this; - m = x.$length; - n = y.$length; - if (n > m) { - n = m; - } - z = z.make(m); - i = 0; - while (true) { - if (!(i < n)) { break; } - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) & ~((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); - i = i + (1) >> 0; - } - $copySlice($subslice(z, n, m), $subslice(x, n, m)); - return z.norm(); - }; - $ptrType(nat).prototype.andNot = function(x, y) { return this.$get().andNot(x, y); }; - nat.prototype.or = function(x, y) { - var _tmp, _tmp$1, i, m, n, s, x, y, z; - z = this; - m = x.$length; - n = y.$length; - s = x; - if (m < n) { - _tmp = m; - _tmp$1 = n; - n = _tmp; - m = _tmp$1; - s = y; - } - z = z.make(m); - i = 0; - while (true) { - if (!(i < n)) { break; } - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) | ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); - i = i + (1) >> 0; - } - $copySlice($subslice(z, n, m), $subslice(s, n, m)); - return z.norm(); - }; - $ptrType(nat).prototype.or = function(x, y) { return this.$get().or(x, y); }; - nat.prototype.xor = function(x, y) { - var _tmp, _tmp$1, i, m, n, s, x, y, z; - z = this; - m = x.$length; - n = y.$length; - s = x; - if (m < n) { - _tmp = m; - _tmp$1 = n; - n = _tmp; - m = _tmp$1; - s = y; - } - z = z.make(m); - i = 0; - while (true) { - if (!(i < n)) { break; } - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]) ^ ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i])) >>> 0)); - i = i + (1) >> 0; - } - $copySlice($subslice(z, n, m), $subslice(s, n, m)); - return z.norm(); - }; - $ptrType(nat).prototype.xor = function(x, y) { return this.$get().xor(x, y); }; - greaterThan = function(x1, x2, y1, y2) { - var x1, x2, y1, y2; - return x1 > y1 || (x1 === y1) && x2 > y2; - }; - nat.prototype.modW = function(d) { - var d, q, r, x; - r = 0; - x = this; - q = nat.nil; - q = q.make(x.$length); - r = divWVW($subslice(new sliceType$2(q.$array), q.$offset, q.$offset + q.$length), 0, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length), d); - return r; - }; - $ptrType(nat).prototype.modW = function(d) { return this.$get().modW(d); }; - nat.prototype.random = function(rand$1, limit, n) { - var _1, _i, _i$1, _index, _r$1, _r$2, _r$3, _ref, _ref$1, bitLengthOfMSW, i, i$1, limit, mask, n, rand$1, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _index = $f._index; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; bitLengthOfMSW = $f.bitLengthOfMSW; i = $f.i; i$1 = $f.i$1; limit = $f.limit; mask = $f.mask; n = $f.n; rand$1 = $f.rand$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (alias(z, limit)) { - z = nat.nil; - } - z = z.make(limit.$length); - bitLengthOfMSW = (((_r$1 = n % 32, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)); - if (bitLengthOfMSW === 0) { - bitLengthOfMSW = 32; - } - mask = (((((y = bitLengthOfMSW, y < 32 ? (1 << y) : 0) >>> 0)) - 1 >>> 0)); - /* while (true) { */ case 1: - _1 = 32; - /* */ if (_1 === (32)) { $s = 4; continue; } - /* */ if (_1 === (64)) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (_1 === (32)) { */ case 4: - _ref = z; - _i = 0; - /* while (true) { */ case 8: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 9; continue; } - i = _i; - _r$2 = rand$1.Uint32(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - ((i < 0 || i >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i] = ((_r$2 >>> 0))); - _i++; - /* } */ $s = 8; continue; case 9: - $s = 7; continue; - /* } else if (_1 === (64)) { */ case 5: - _ref$1 = z; - _i$1 = 0; - /* while (true) { */ case 11: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 12; continue; } - i$1 = _i$1; - _r$3 = rand$1.Uint32(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - ((i$1 < 0 || i$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + i$1] = ((((_r$3 >>> 0)) | 0) >>> 0)); - _i$1++; - /* } */ $s = 11; continue; case 12: - $s = 7; continue; - /* } else { */ case 6: - $panic(new $String("unknown word size")); - /* } */ case 7: - case 3: - _index = limit.$length - 1 >> 0; - ((_index < 0 || _index >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + _index] = ((((_index < 0 || _index >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + _index]) & (mask)) >>> 0)); - if (z.cmp(limit) < 0) { - /* break; */ $s = 2; continue; - } - /* } */ $s = 1; continue; case 2: - $s = -1; return z.norm(); - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.random }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._index = _index; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.bitLengthOfMSW = bitLengthOfMSW; $f.i = i; $f.i$1 = i$1; $f.limit = limit; $f.mask = mask; $f.n = n; $f.rand$1 = rand$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.random = function(rand$1, limit, n) { return this.$get().random(rand$1, limit, n); }; - nat.prototype.expNN = function(x, y, m) { - var _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, i, j, j$1, m, q, r, shift, v, w, x, x$1, y, y$1, y$2, y$3, z, zz, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; i = $f.i; j = $f.j; j$1 = $f.j$1; m = $f.m; q = $f.q; r = $f.r; shift = $f.shift; v = $f.v; w = $f.w; x = $f.x; x$1 = $f.x$1; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (alias(z, x) || alias(z, y)) { - z = nat.nil; - } - if ((m.$length === 1) && ((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) === 1)) { - $s = -1; return z.setWord(0); - } - if (y.$length === 0) { - $s = -1; return z.setWord(1); - } - /* */ if ((y.$length === 1) && ((0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]) === 1) && !((m.$length === 0))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((y.$length === 1) && ((0 >= y.$length ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + 0]) === 1) && !((m.$length === 0))) { */ case 1: - _r$1 = (nat.nil).div(z, x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z = _tuple[1]; - $s = -1; return z; - /* } */ case 2: - if (!((m.$length === 0))) { - z = z.make(m.$length); - } - z = z.set(x); - /* */ if (x.cmp(natOne) > 0 && y.$length > 1 && m.$length > 0) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (x.cmp(natOne) > 0 && y.$length > 1 && m.$length > 0) { */ case 4: - /* */ if ((((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) & 1) >>> 0) === 1) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if ((((0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) & 1) >>> 0) === 1) { */ case 6: - _r$2 = z.expNNMontgomery(x, y, m); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* } */ case 7: - _r$3 = z.expNNWindowed(x, y, m); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $s = -1; return _r$3; - /* } */ case 5: - v = (x$1 = y.$length - 1 >> 0, ((x$1 < 0 || x$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + x$1])); - shift = nlz(v) + 1 >>> 0; - v = (y$1 = (shift), y$1 < 32 ? (v << y$1) : 0) >>> 0; - q = nat.nil; - w = 32 - ((shift >> 0)) >> 0; - _tmp = nat.nil; - _tmp$1 = nat.nil; - zz = _tmp; - r = _tmp$1; - j = 0; - /* while (true) { */ case 10: - /* if (!(j < w)) { break; } */ if(!(j < w)) { $s = 11; continue; } - zz = zz.sqr(z); - _tmp$2 = z; - _tmp$3 = zz; - zz = _tmp$2; - z = _tmp$3; - if (!((((v & 2147483648) >>> 0) === 0))) { - zz = zz.mul(z, x); - _tmp$4 = z; - _tmp$5 = zz; - zz = _tmp$4; - z = _tmp$5; - } - /* */ if (!((m.$length === 0))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (!((m.$length === 0))) { */ case 12: - _r$4 = zz.div(r, z, m); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - zz = _tuple$1[0]; - r = _tuple$1[1]; - _tmp$6 = q; - _tmp$7 = z; - _tmp$8 = zz; - _tmp$9 = r; - zz = _tmp$6; - r = _tmp$7; - q = _tmp$8; - z = _tmp$9; - /* } */ case 13: - v = (y$2 = (1), y$2 < 32 ? (v << y$2) : 0) >>> 0; - j = j + (1) >> 0; - /* } */ $s = 10; continue; case 11: - i = y.$length - 2 >> 0; - /* while (true) { */ case 15: - /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 16; continue; } - v = ((i < 0 || i >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i]); - j$1 = 0; - /* while (true) { */ case 17: - /* if (!(j$1 < 32)) { break; } */ if(!(j$1 < 32)) { $s = 18; continue; } - zz = zz.sqr(z); - _tmp$10 = z; - _tmp$11 = zz; - zz = _tmp$10; - z = _tmp$11; - if (!((((v & 2147483648) >>> 0) === 0))) { - zz = zz.mul(z, x); - _tmp$12 = z; - _tmp$13 = zz; - zz = _tmp$12; - z = _tmp$13; - } - /* */ if (!((m.$length === 0))) { $s = 19; continue; } - /* */ $s = 20; continue; - /* if (!((m.$length === 0))) { */ case 19: - _r$5 = zz.div(r, z, m); /* */ $s = 21; case 21: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$2 = _r$5; - zz = _tuple$2[0]; - r = _tuple$2[1]; - _tmp$14 = q; - _tmp$15 = z; - _tmp$16 = zz; - _tmp$17 = r; - zz = _tmp$14; - r = _tmp$15; - q = _tmp$16; - z = _tmp$17; - /* } */ case 20: - v = (y$3 = (1), y$3 < 32 ? (v << y$3) : 0) >>> 0; - j$1 = j$1 + (1) >> 0; - /* } */ $s = 17; continue; case 18: - i = i - (1) >> 0; - /* } */ $s = 15; continue; case 16: - $s = -1; return z.norm(); - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNN }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.i = i; $f.j = j; $f.j$1 = j$1; $f.m = m; $f.q = q; $f.r = r; $f.shift = shift; $f.v = v; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.expNN = function(x, y, m) { return this.$get().expNN(x, y, m); }; - nat.prototype.expNNWindowed = function(x, y, m) { - var _q, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, i, i$1, j, m, p, p1, p2, powers, r, x, x$1, y, y$1, yi, z, zz, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; i = $f.i; i$1 = $f.i$1; j = $f.j; m = $f.m; p = $f.p; p1 = $f.p1; p2 = $f.p2; powers = $f.powers; r = $f.r; x = $f.x; x$1 = $f.x$1; y = $f.y; y$1 = $f.y$1; yi = $f.yi; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _tmp = nat.nil; - _tmp$1 = nat.nil; - zz = _tmp; - r = _tmp$1; - powers = arrayType$1.zero(); - powers[0] = natOne; - powers[1] = x; - i = 2; - /* while (true) { */ case 1: - /* if (!(i < 16)) { break; } */ if(!(i < 16)) { $s = 2; continue; } - _tmp$2 = $indexPtr(powers, (_q = i / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), ptrType$4); - _tmp$3 = $indexPtr(powers, i, ptrType$4); - _tmp$4 = $indexPtr(powers, (i + 1 >> 0), ptrType$4); - p2 = _tmp$2; - p = _tmp$3; - p1 = _tmp$4; - p.$set(p.sqr(p2.$get())); - _r$1 = zz.div(r, p.$get(), m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - zz = _tuple[0]; - r = _tuple[1]; - _tmp$5 = r; - _tmp$6 = p.$get(); - p.$set(_tmp$5); - r = _tmp$6; - p1.$set(p1.mul(p.$get(), x)); - _r$2 = zz.div(r, p1.$get(), m); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - zz = _tuple$1[0]; - r = _tuple$1[1]; - _tmp$7 = r; - _tmp$8 = p1.$get(); - p1.$set(_tmp$7); - r = _tmp$8; - i = i + (2) >> 0; - /* } */ $s = 1; continue; case 2: - z = z.setWord(1); - i$1 = y.$length - 1 >> 0; - /* while (true) { */ case 5: - /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 6; continue; } - yi = ((i$1 < 0 || i$1 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$1]); - j = 0; - /* while (true) { */ case 7: - /* if (!(j < 32)) { break; } */ if(!(j < 32)) { $s = 8; continue; } - /* */ if (!((i$1 === (y.$length - 1 >> 0))) || !((j === 0))) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if (!((i$1 === (y.$length - 1 >> 0))) || !((j === 0))) { */ case 9: - zz = zz.sqr(z); - _tmp$9 = z; - _tmp$10 = zz; - zz = _tmp$9; - z = _tmp$10; - _r$3 = zz.div(r, z, m); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$2 = _r$3; - zz = _tuple$2[0]; - r = _tuple$2[1]; - _tmp$11 = r; - _tmp$12 = z; - z = _tmp$11; - r = _tmp$12; - zz = zz.sqr(z); - _tmp$13 = z; - _tmp$14 = zz; - zz = _tmp$13; - z = _tmp$14; - _r$4 = zz.div(r, z, m); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$3 = _r$4; - zz = _tuple$3[0]; - r = _tuple$3[1]; - _tmp$15 = r; - _tmp$16 = z; - z = _tmp$15; - r = _tmp$16; - zz = zz.sqr(z); - _tmp$17 = z; - _tmp$18 = zz; - zz = _tmp$17; - z = _tmp$18; - _r$5 = zz.div(r, z, m); /* */ $s = 13; case 13: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$4 = _r$5; - zz = _tuple$4[0]; - r = _tuple$4[1]; - _tmp$19 = r; - _tmp$20 = z; - z = _tmp$19; - r = _tmp$20; - zz = zz.sqr(z); - _tmp$21 = z; - _tmp$22 = zz; - zz = _tmp$21; - z = _tmp$22; - _r$6 = zz.div(r, z, m); /* */ $s = 14; case 14: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple$5 = _r$6; - zz = _tuple$5[0]; - r = _tuple$5[1]; - _tmp$23 = r; - _tmp$24 = z; - z = _tmp$23; - r = _tmp$24; - /* } */ case 10: - zz = zz.mul(z, (x$1 = yi >>> 28 >>> 0, ((x$1 < 0 || x$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$1]))); - _tmp$25 = z; - _tmp$26 = zz; - zz = _tmp$25; - z = _tmp$26; - _r$7 = zz.div(r, z, m); /* */ $s = 15; case 15: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _tuple$6 = _r$7; - zz = _tuple$6[0]; - r = _tuple$6[1]; - _tmp$27 = r; - _tmp$28 = z; - z = _tmp$27; - r = _tmp$28; - yi = (y$1 = (4), y$1 < 32 ? (yi << y$1) : 0) >>> 0; - j = j + (4) >> 0; - /* } */ $s = 7; continue; case 8: - i$1 = i$1 - (1) >> 0; - /* } */ $s = 5; continue; case 6: - $s = -1; return z.norm(); - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNNWindowed }; } $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.i = i; $f.i$1 = i$1; $f.j = j; $f.m = m; $f.p = p; $f.p1 = p1; $f.p2 = p2; $f.powers = powers; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.y$1 = y$1; $f.yi = yi; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.expNNWindowed = function(x, y, m) { return this.$get().expNNWindowed(x, y, m); }; - nat.prototype.expNNMontgomery = function(x, y, m) { - var RR, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, i, i$1, i$2, j, k0, m, numWords, one, powers, rr, t, x, x$1, x$2, y, y$1, y$2, yi, z, zz, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; RR = $f.RR; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; j = $f.j; k0 = $f.k0; m = $f.m; numWords = $f.numWords; one = $f.one; powers = $f.powers; rr = $f.rr; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; yi = $f.yi; z = $f.z; zz = $f.zz; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - numWords = m.$length; - /* */ if (x.$length > numWords) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (x.$length > numWords) { */ case 1: - _r$1 = (nat.nil).div(nat.nil, x, m); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - x = _tuple[1]; - /* } */ case 2: - if (x.$length < numWords) { - rr = $makeSlice(nat, numWords); - $copySlice(rr, x); - x = rr; - } - k0 = 2 - (0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) >>> 0; - t = (0 >= m.$length ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + 0]) - 1 >>> 0; - i = 1; - while (true) { - if (!(i < 32)) { break; } - t = $imul(t, (t)) >>> 0; - k0 = $imul(k0, (((t + 1 >>> 0)))) >>> 0; - i = (y$1 = (1), y$1 < 32 ? (i << y$1) : 0) >> 0; - } - k0 = -k0 >>> 0; - RR = (nat.nil).setWord(1); - zz = (nat.nil).shl(RR, ((($imul(($imul(2, numWords)), 32)) >>> 0))); - _r$2 = (nat.nil).div(RR, zz, m); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - RR = _tuple$1[1]; - if (RR.$length < numWords) { - zz = zz.make(numWords); - $copySlice(zz, RR); - RR = zz; - } - one = $makeSlice(nat, numWords); - (0 >= one.$length ? ($throwRuntimeError("index out of range"), undefined) : one.$array[one.$offset + 0] = 1); - powers = arrayType$1.zero(); - powers[0] = powers[0].montgomery(one, RR, m, k0, numWords); - powers[1] = powers[1].montgomery(x, RR, m, k0, numWords); - i$1 = 2; - while (true) { - if (!(i$1 < 16)) { break; } - ((i$1 < 0 || i$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[i$1] = ((i$1 < 0 || i$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[i$1]).montgomery((x$1 = i$1 - 1 >> 0, ((x$1 < 0 || x$1 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$1])), powers[1], m, k0, numWords)); - i$1 = i$1 + (1) >> 0; - } - z = z.make(numWords); - $copySlice(z, powers[0]); - zz = zz.make(numWords); - i$2 = y.$length - 1 >> 0; - while (true) { - if (!(i$2 >= 0)) { break; } - yi = ((i$2 < 0 || i$2 >= y.$length) ? ($throwRuntimeError("index out of range"), undefined) : y.$array[y.$offset + i$2]); - j = 0; - while (true) { - if (!(j < 32)) { break; } - if (!((i$2 === (y.$length - 1 >> 0))) || !((j === 0))) { - zz = zz.montgomery(z, z, m, k0, numWords); - z = z.montgomery(zz, zz, m, k0, numWords); - zz = zz.montgomery(z, z, m, k0, numWords); - z = z.montgomery(zz, zz, m, k0, numWords); - } - zz = zz.montgomery(z, (x$2 = yi >>> 28 >>> 0, ((x$2 < 0 || x$2 >= powers.length) ? ($throwRuntimeError("index out of range"), undefined) : powers[x$2])), m, k0, numWords); - _tmp = zz; - _tmp$1 = z; - z = _tmp; - zz = _tmp$1; - yi = (y$2 = (4), y$2 < 32 ? (yi << y$2) : 0) >>> 0; - j = j + (4) >> 0; - } - i$2 = i$2 - (1) >> 0; - } - zz = zz.montgomery(z, one, m, k0, numWords); - /* */ if (zz.cmp(m) >= 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (zz.cmp(m) >= 0) { */ case 5: - zz = zz.sub(zz, m); - /* */ if (zz.cmp(m) >= 0) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (zz.cmp(m) >= 0) { */ case 7: - _r$3 = (nat.nil).div(nat.nil, zz, m); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$2 = _r$3; - zz = _tuple$2[1]; - /* } */ case 8: - /* } */ case 6: - $s = -1; return zz.norm(); - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expNNMontgomery }; } $f.RR = RR; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.j = j; $f.k0 = k0; $f.m = m; $f.numWords = numWords; $f.one = one; $f.powers = powers; $f.rr = rr; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.yi = yi; $f.z = z; $f.zz = zz; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.expNNMontgomery = function(x, y, m) { return this.$get().expNNMontgomery(x, y, m); }; - nat.prototype.bytes = function(buf) { - var _i, _ref, buf, d, i, j, y, z; - i = 0; - z = this; - i = buf.$length; - _ref = z; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - d = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - j = 0; - while (true) { - if (!(j < 4)) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = ((d << 24 >>> 24))); - d = (y = (8), y < 32 ? (d >>> y) : 0) >>> 0; - j = j + (1) >> 0; - } - _i++; - } - while (true) { - if (!(i < buf.$length && (((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i]) === 0))) { break; } - i = i + (1) >> 0; - } - return i; - }; - $ptrType(nat).prototype.bytes = function(buf) { return this.$get().bytes(buf); }; - bigEndianWord = function(buf) { - var buf; - if (false) { - return (($clone(binary.BigEndian, binary.bigEndian).Uint64(buf).$low >>> 0)); - } - return (($clone(binary.BigEndian, binary.bigEndian).Uint32(buf) >>> 0)); - }; - nat.prototype.setBytes = function(buf) { - var _q, buf, d, i, k, s, x, x$1, y, z; - z = this; - z = z.make((_q = (((buf.$length + 4 >> 0) - 1 >> 0)) / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); - i = buf.$length; - k = 0; - while (true) { - if (!(i >= 4)) { break; } - ((k < 0 || k >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + k] = bigEndianWord($subslice(buf, (i - 4 >> 0), i))); - i = i - (4) >> 0; - k = k + (1) >> 0; - } - if (i > 0) { - d = 0; - s = 0; - while (true) { - if (!(i > 0)) { break; } - d = (d | (((y = s, y < 32 ? ((((x = i - 1 >> 0, ((x < 0 || x >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + x])) >>> 0)) << y) : 0) >>> 0))) >>> 0; - i = i - (1) >> 0; - s = s + (8) >>> 0; - } - (x$1 = z.$length - 1 >> 0, ((x$1 < 0 || x$1 >= z.$length) ? ($throwRuntimeError("index out of range"), undefined) : z.$array[z.$offset + x$1] = d)); - } - return z.norm(); - }; - $ptrType(nat).prototype.setBytes = function(buf) { return this.$get().setBytes(buf); }; - nat.prototype.sqrt = function(x) { - var _q, _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, n, x, z, z1, z2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; n = $f.n; x = $f.x; z = $f.z; z1 = $f.z1; z2 = $f.z2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (x.cmp(natOne) <= 0) { - $s = -1; return z.set(x); - } - if (alias(z, x)) { - z = nat.nil; - } - _tmp = nat.nil; - _tmp$1 = nat.nil; - z1 = _tmp; - z2 = _tmp$1; - z1 = z; - z1 = z1.setUint64(new $Uint64(0, 1)); - z1 = z1.shl(z1, ((((_q = x.bitLen() / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0) >>> 0))); - n = 0; - /* while (true) { */ case 1: - _r$1 = z2.div(nat.nil, x, z1); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - z2 = _tuple[0]; - z2 = z2.add(z2, z1); - z2 = z2.shr(z2, 1); - if (z2.cmp(z1) >= 0) { - if ((n & 1) === 0) { - $s = -1; return z1; - } - $s = -1; return z.set(z1); - } - _tmp$2 = z2; - _tmp$3 = z1; - z1 = _tmp$2; - z2 = _tmp$3; - n = n + (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return nat.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.sqrt }; } $f._q = _q; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.n = n; $f.x = x; $f.z = z; $f.z1 = z1; $f.z2 = z2; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.sqrt = function(x) { return this.$get().sqrt(x); }; - maxPow = function(b) { - var _q, _tmp, _tmp$1, b, max$1, n, p; - p = 0; - n = 0; - _tmp = b; - _tmp$1 = 1; - p = _tmp; - n = _tmp$1; - max$1 = (_q = 4294967295 / b, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - while (true) { - if (!(p <= max$1)) { break; } - p = $imul(p, (b)) >>> 0; - n = n + (1) >> 0; - } - return [p, n]; - }; - pow = function(x, n) { - var n, p, x; - p = 0; - p = 1; - while (true) { - if (!(n > 0)) { break; } - if (!(((n & 1) === 0))) { - p = $imul(p, (x)) >>> 0; - } - x = $imul(x, (x)) >>> 0; - n = (n >> $min((1), 31)) >> 0; - } - return p; - }; - nat.prototype.scan = function(r, base, fracOk) { - var _1, _2, _3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, b, b1, base, baseOk, bn, ch, count, d1, di, dp, err, fracOk, i, n, r, res, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; b = $f.b; b1 = $f.b1; base = $f.base; baseOk = $f.baseOk; bn = $f.bn; ch = $f.ch; count = $f.count; d1 = $f.d1; di = $f.di; dp = $f.dp; err = $f.err; fracOk = $f.fracOk; i = $f.i; n = $f.n; r = $f.r; res = $f.res; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - res = nat.nil; - b = 0; - count = 0; - err = $ifaceNil; - z = this; - baseOk = (base === 0) || !fracOk && 2 <= base && base <= 62 || fracOk && ((base === 2) || (base === 10) || (base === 16)); - /* */ if (!baseOk) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!baseOk) { */ case 1: - _r$1 = fmt.Sprintf("illegal number base %d", new sliceType([new $Int(base)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $panic(new $String(_r$1)); - /* } */ case 2: - _r$2 = r.ReadByte(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - ch = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [res, b, count, err]; - } - b = base; - /* */ if (base === 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (base === 0) { */ case 5: - b = 10; - /* */ if (ch === 48) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (ch === 48) { */ case 7: - count = 1; - _r$3 = r.ReadByte(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$1 = _r$3; - ch = _tuple$1[0]; - err = _tuple$1[1]; - _1 = err; - /* */ if ($interfaceIsEqual(_1, $ifaceNil)) { $s = 11; continue; } - /* */ if ($interfaceIsEqual(_1, (io.EOF))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if ($interfaceIsEqual(_1, $ifaceNil)) { */ case 11: - if (!fracOk) { - b = 8; - } - _2 = ch; - if ((_2 === (120)) || (_2 === (88))) { - b = 16; - } else if ((_2 === (98)) || (_2 === (66))) { - b = 2; - } - _3 = b; - /* */ if ((_3 === (16)) || (_3 === (2))) { $s = 16; continue; } - /* */ if (_3 === (8)) { $s = 17; continue; } - /* */ $s = 18; continue; - /* if ((_3 === (16)) || (_3 === (2))) { */ case 16: - count = 0; - _r$4 = r.ReadByte(); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$2 = _r$4; - ch = _tuple$2[0]; - err = _tuple$2[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [res, b, count, err]; - } - $s = 18; continue; - /* } else if (_3 === (8)) { */ case 17: - count = 0; - /* } */ case 18: - case 15: - $s = 14; continue; - /* } else if ($interfaceIsEqual(_1, (io.EOF))) { */ case 12: - res = $subslice(z, 0, 0); - err = $ifaceNil; - $s = -1; return [res, b, count, err]; - /* } else { */ case 13: - $s = -1; return [res, b, count, err]; - /* } */ case 14: - case 9: - /* } */ case 8: - /* } */ case 6: - z = $subslice(z, 0, 0); - b1 = ((b >>> 0)); - _tuple$3 = maxPow(b1); - bn = _tuple$3[0]; - n = _tuple$3[1]; - di = 0; - i = 0; - dp = -1; - /* while (true) { */ case 20: - /* */ if (fracOk && (ch === 46)) { $s = 22; continue; } - /* */ $s = 23; continue; - /* if (fracOk && (ch === 46)) { */ case 22: - fracOk = false; - dp = count; - _r$5 = r.ReadByte(); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$4 = _r$5; - ch = _tuple$4[0]; - err = _tuple$4[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - if ($interfaceIsEqual(err, io.EOF)) { - err = $ifaceNil; - /* break; */ $s = 21; continue; - } - $s = -1; return [res, b, count, err]; - } - /* } */ case 23: - d1 = 0; - if (48 <= ch && ch <= 57) { - d1 = (((ch - 48 << 24 >>> 24) >>> 0)); - } else if (97 <= ch && ch <= 122) { - d1 = ((((ch - 97 << 24 >>> 24) + 10 << 24 >>> 24) >>> 0)); - } else if (65 <= ch && ch <= 90) { - if (b <= 36) { - d1 = ((((ch - 65 << 24 >>> 24) + 10 << 24 >>> 24) >>> 0)); - } else { - d1 = ((((ch - 65 << 24 >>> 24) + 36 << 24 >>> 24) >>> 0)); - } - } else { - d1 = 63; - } - /* */ if (d1 >= b1) { $s = 25; continue; } - /* */ $s = 26; continue; - /* if (d1 >= b1) { */ case 25: - _r$6 = r.UnreadByte(); /* */ $s = 27; case 27: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$6; - /* break; */ $s = 21; continue; - /* } */ case 26: - count = count + (1) >> 0; - di = ($imul(di, b1) >>> 0) + d1 >>> 0; - i = i + (1) >> 0; - if (i === n) { - z = z.mulAddWW(z, bn, di); - di = 0; - i = 0; - } - _r$7 = r.ReadByte(); /* */ $s = 28; case 28: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _tuple$5 = _r$7; - ch = _tuple$5[0]; - err = _tuple$5[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - if ($interfaceIsEqual(err, io.EOF)) { - err = $ifaceNil; - /* break; */ $s = 21; continue; - } - $s = -1; return [res, b, count, err]; - } - /* } */ $s = 20; continue; case 21: - if (count === 0) { - if ((base === 0) && (b === 8)) { - count = 1; - b = 10; - } else if (!((base === 0)) || !((b === 8))) { - err = errors.New("syntax error scanning number"); - } - $s = -1; return [res, b, count, err]; - } - if (i > 0) { - z = z.mulAddWW(z, pow(b1, i), di); - } - res = z.norm(); - if (dp >= 0) { - count = dp - count >> 0; - } - $s = -1; return [res, b, count, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.scan }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.b = b; $f.b1 = b1; $f.base = base; $f.baseOk = baseOk; $f.bn = bn; $f.ch = ch; $f.count = count; $f.d1 = d1; $f.di = di; $f.dp = dp; $f.err = err; $f.fracOk = fracOk; $f.i = i; $f.n = n; $f.r = r; $f.res = res; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.scan = function(r, base, fracOk) { return this.$get().scan(r, base, fracOk); }; - nat.prototype.utoa = function(base) { - var _r$1, base, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; base = $f.base; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = x.itoa(false, base); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.utoa }; } $f._r$1 = _r$1; $f.base = base; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.utoa = function(base) { return this.$get().utoa(base); }; - nat.prototype.itoa = function(neg, base) { - var _r$1, _tuple, b, base, bb, i, k, mask, nbits, ndigits, neg, q, s, shift, table, w, x, y, y$1, y$2, y$3, y$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; base = $f.base; bb = $f.bb; i = $f.i; k = $f.k; mask = $f.mask; nbits = $f.nbits; ndigits = $f.ndigits; neg = $f.neg; q = $f.q; s = $f.s; shift = $f.shift; table = $f.table; w = $f.w; x = $f.x; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (base < 2 || base > 62) { - $panic(new $String("invalid base")); - } - if (x.$length === 0) { - $s = -1; return (new sliceType$1($stringToBytes("0"))); - } - i = (((x.bitLen()) / math.Log2((base)) >> 0)) + 1 >> 0; - if (neg) { - i = i + (1) >> 0; - } - s = $makeSlice(sliceType$1, i); - b = ((base >>> 0)); - /* */ if (b === ((b & (-b >>> 0)) >>> 0)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (b === ((b & (-b >>> 0)) >>> 0)) { */ case 1: - shift = ((bits.TrailingZeros(((b >>> 0))) >>> 0)); - mask = ((((y = shift, y < 32 ? (1 << y) : 0) >>> 0) - 1 >>> 0)); - w = (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]); - nbits = 32; - k = 1; - while (true) { - if (!(k < x.$length)) { break; } - while (true) { - if (!(nbits >= shift)) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); - w = (y$1 = (shift), y$1 < 32 ? (w >>> y$1) : 0) >>> 0; - nbits = nbits - (shift) >>> 0; - } - if (nbits === 0) { - w = ((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]); - nbits = 32; - } else { - w = (w | (((y$2 = nbits, y$2 < 32 ? (((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]) << y$2) : 0) >>> 0))) >>> 0; - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); - w = (y$3 = ((shift - nbits >>> 0)), y$3 < 32 ? (((k < 0 || k >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + k]) >>> y$3) : 0) >>> 0; - nbits = 32 - ((shift - nbits >>> 0)) >>> 0; - } - k = k + (1) >> 0; - } - while (true) { - if (!(!((w === 0)))) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((w & mask) >>> 0))); - w = (y$4 = (shift), y$4 < 32 ? (w >>> y$4) : 0) >>> 0; - } - $s = 3; continue; - /* } else { */ case 2: - _tuple = maxPow(b); - bb = _tuple[0]; - ndigits = _tuple[1]; - _r$1 = divisors(x.$length, b, ndigits, bb); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - table = _r$1; - q = (nat.nil).set(x); - $r = q.convertWords(s, b, ndigits, bb, table); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = 0; - while (true) { - if (!(((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i]) === 48)) { break; } - i = i + (1) >> 0; - } - /* } */ case 3: - if (neg) { - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = 45); - } - $s = -1; return $subslice(s, i); - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.itoa }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.base = base; $f.bb = bb; $f.i = i; $f.k = k; $f.mask = mask; $f.nbits = nbits; $f.ndigits = ndigits; $f.neg = neg; $f.q = q; $f.s = s; $f.shift = shift; $f.table = table; $f.w = w; $f.x = x; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.itoa = function(neg, base) { return this.$get().itoa(neg, base); }; - nat.prototype.convertWords = function(s, b, ndigits, bb, table) { - var _q, _q$1, _r$1, _r$2, _tuple, _tuple$1, _tuple$2, b, bb, h, i, index, j, j$1, maxLength, minLength, ndigits, q, r, r$1, s, t, table, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _q$1 = $f._q$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; b = $f.b; bb = $f.bb; h = $f.h; i = $f.i; index = $f.index; j = $f.j; j$1 = $f.j$1; maxLength = $f.maxLength; minLength = $f.minLength; ndigits = $f.ndigits; q = $f.q; r = $f.r; r$1 = $f.r$1; s = $f.s; t = $f.t; table = $f.table; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - q = this; - /* */ if (!(table === sliceType$3.nil)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(table === sliceType$3.nil)) { */ case 1: - r = nat.nil; - index = table.$length - 1 >> 0; - /* while (true) { */ case 3: - /* if (!(q.$length > leafSize)) { break; } */ if(!(q.$length > leafSize)) { $s = 4; continue; } - maxLength = q.bitLen(); - minLength = maxLength >> 1 >> 0; - while (true) { - if (!(index > 0 && (x = index - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).nbits > minLength)) { break; } - index = index - (1) >> 0; - } - if (((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).nbits >= maxLength && ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).bbb.cmp(q) >= 0) { - index = index - (1) >> 0; - if (index < 0) { - $panic(new $String("internal inconsistency")); - } - } - _r$1 = q.div(r, q, ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).bbb); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - q = _tuple[0]; - r = _tuple[1]; - h = s.$length - ((index < 0 || index >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + index]).ndigits >> 0; - $r = r.convertWords($subslice(s, h), b, ndigits, bb, $subslice(table, 0, index)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - s = $subslice(s, 0, h); - /* } */ $s = 3; continue; case 4: - /* } */ case 2: - i = s.$length; - r$1 = 0; - if (b === 10) { - while (true) { - if (!(q.$length > 0)) { break; } - _tuple$1 = q.divW(q, bb); - q = _tuple$1[0]; - r$1 = _tuple$1[1]; - j = 0; - while (true) { - if (!(j < ndigits && i > 0)) { break; } - i = i - (1) >> 0; - t = (_q = r$1 / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = (48 + (((r$1 - ($imul(t, 10) >>> 0) >>> 0) << 24 >>> 24)) << 24 >>> 24)); - r$1 = t; - j = j + (1) >> 0; - } - } - } else { - while (true) { - if (!(q.$length > 0)) { break; } - _tuple$2 = q.divW(q, bb); - q = _tuple$2[0]; - r$1 = _tuple$2[1]; - j$1 = 0; - while (true) { - if (!(j$1 < ndigits && i > 0)) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt((_r$2 = r$1 % b, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")))); - r$1 = (_q$1 = r$1 / (b), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - j$1 = j$1 + (1) >> 0; - } - } - } - while (true) { - if (!(i > 0)) { break; } - i = i - (1) >> 0; - ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = 48); - } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.convertWords }; } $f._q = _q; $f._q$1 = _q$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.b = b; $f.bb = bb; $f.h = h; $f.i = i; $f.index = index; $f.j = j; $f.j$1 = j$1; $f.maxLength = maxLength; $f.minLength = minLength; $f.ndigits = ndigits; $f.q = q; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.t = t; $f.table = table; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.convertWords = function(s, b, ndigits, bb, table) { return this.$get().convertWords(s, b, ndigits, bb, table); }; - nat.prototype.expWW = function(x, y) { - var _r$1, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.expNN((nat.nil).setWord(x), (nat.nil).setWord(y), nat.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.expWW }; } $f._r$1 = _r$1; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.expWW = function(x, y) { return this.$get().expWW(x, y); }; - divisors = function(m, b, ndigits, bb) { - var _r$1, b, bb, i, k, larger, m, ndigits, table, words, x, x$1, x$2, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; bb = $f.bb; i = $f.i; k = $f.k; larger = $f.larger; m = $f.m; ndigits = $f.ndigits; table = $f.table; words = $f.words; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if ((leafSize === 0) || m <= leafSize) { - $s = -1; return sliceType$3.nil; - } - k = 1; - words = leafSize; - while (true) { - if (!(words < (m >> 1 >> 0) && k < 64)) { break; } - k = k + (1) >> 0; - words = (y = (1), y < 32 ? (words << y) : 0) >> 0; - } - table = sliceType$3.nil; - if (b === 10) { - cacheBase10.Mutex.Lock(); - table = $subslice(new sliceType$3(cacheBase10.table), 0, k); - } else { - table = $makeSlice(sliceType$3, k); - } - /* */ if ((x = k - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).ndigits === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((x = k - 1 >> 0, ((x < 0 || x >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x])).ndigits === 0) { */ case 1: - larger = nat.nil; - i = 0; - /* while (true) { */ case 3: - /* if (!(i < k)) { break; } */ if(!(i < k)) { $s = 4; continue; } - /* */ if (((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits === 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits === 0) { */ case 5: - /* */ if (i === 0) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (i === 0) { */ case 7: - _r$1 = (nat.nil).expWW(bb, ((leafSize >>> 0))); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - (0 >= table.$length ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + 0]).bbb = _r$1; - (0 >= table.$length ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + 0]).ndigits = $imul(ndigits, leafSize); - $s = 9; continue; - /* } else { */ case 8: - ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb = (nat.nil).sqr((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x$1])).bbb); - ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits = $imul(2, (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + x$2])).ndigits); - /* } */ case 9: - larger = (nat.nil).set(((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb); - while (true) { - if (!(mulAddVWW($subslice(new sliceType$2(larger.$array), larger.$offset, larger.$offset + larger.$length), $subslice(new sliceType$2(larger.$array), larger.$offset, larger.$offset + larger.$length), b, 0) === 0)) { break; } - ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb.set(larger); - ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).ndigits + (1) >> 0; - } - ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).nbits = ((i < 0 || i >= table.$length) ? ($throwRuntimeError("index out of range"), undefined) : table.$array[table.$offset + i]).bbb.bitLen(); - /* } */ case 6: - i = i + (1) >> 0; - /* } */ $s = 3; continue; case 4: - /* } */ case 2: - if (b === 10) { - cacheBase10.Mutex.Unlock(); - } - $s = -1; return table; - /* */ } return; } if ($f === undefined) { $f = { $blk: divisors }; } $f._r$1 = _r$1; $f.b = b; $f.bb = bb; $f.i = i; $f.k = k; $f.larger = larger; $f.m = m; $f.ndigits = ndigits; $f.table = table; $f.words = words; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.ptr.prototype.ProbablyPrime = function(n) { - var _1, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _v, n, r, rA, rB, w, x, x$1, x$2, x$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _v = $f._v; n = $f.n; r = $f.r; rA = $f.rA; rB = $f.rB; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - if (n < 0) { - $panic(new $String("negative n for ProbablyPrime")); - } - if (x.neg || (x.abs.$length === 0)) { - $s = -1; return false; - } - w = (x$1 = x.abs, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); - if ((x.abs.$length === 1) && w < 64) { - $s = -1; return !((x$2 = (x$3 = $shiftLeft64(new $Uint64(0, 1), w), new $Uint64(673221152 & x$3.$high, (2693408940 & x$3.$low) >>> 0)), (x$2.$high === 0 && x$2.$low === 0))); - } - if (((w & 1) >>> 0) === 0) { - $s = -1; return false; - } - _tmp = 0; - _tmp$1 = 0; - rA = _tmp; - rB = _tmp$1; - _1 = 32; - if (_1 === (32)) { - rA = ((x.abs.modW(4127218095) >>> 0)); - rB = ((x.abs.modW(3948078067) >>> 0)); - } else if (_1 === (64)) { - r = x.abs.modW(820596253); - rA = (((_r$1 = r % 4127218095, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0)); - rB = (((_r$2 = r % 3948078067, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) >>> 0)); - } else { - $panic(new $String("math/big: invalid word size")); - } - if (((_r$3 = rA % 3, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$4 = rA % 5, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$5 = rA % 7, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$6 = rA % 11, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$7 = rA % 13, _r$7 === _r$7 ? _r$7 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$8 = rA % 17, _r$8 === _r$8 ? _r$8 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$9 = rA % 19, _r$9 === _r$9 ? _r$9 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$10 = rA % 23, _r$10 === _r$10 ? _r$10 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$11 = rA % 37, _r$11 === _r$11 ? _r$11 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$12 = rB % 29, _r$12 === _r$12 ? _r$12 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$13 = rB % 31, _r$13 === _r$13 ? _r$13 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$14 = rB % 41, _r$14 === _r$14 ? _r$14 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$15 = rB % 43, _r$15 === _r$15 ? _r$15 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$16 = rB % 47, _r$16 === _r$16 ? _r$16 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$17 = rB % 53, _r$17 === _r$17 ? _r$17 : $throwRuntimeError("integer divide by zero")) === 0)) { - $s = -1; return false; - } - _r$18 = x.abs.probablyPrimeMillerRabin(n + 1 >> 0, true); /* */ $s = 2; case 2: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } - if (!(_r$18)) { _v = false; $s = 1; continue s; } - _r$19 = x.abs.probablyPrimeLucas(); /* */ $s = 3; case 3: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } - _v = _r$19; case 1: - $s = -1; return _v; - /* */ } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ProbablyPrime }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._v = _v; $f.n = n; $f.r = r; $f.rA = rA; $f.rB = rB; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; - }; - Int.prototype.ProbablyPrime = function(n) { return this.$val.ProbablyPrime(n); }; - nat.prototype.probablyPrimeMillerRabin = function(reps, force2) { - var _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tuple, force2, i, j, k, n, nm1, nm3, nm3Len, q, quotient, rand$1, reps, x, x$1, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; force2 = $f.force2; i = $f.i; j = $f.j; k = $f.k; n = $f.n; nm1 = $f.nm1; nm3 = $f.nm3; nm3Len = $f.nm3Len; q = $f.q; quotient = $f.quotient; rand$1 = $f.rand$1; reps = $f.reps; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = this; - nm1 = (nat.nil).sub(n, natOne); - k = nm1.trailingZeroBits(); - q = (nat.nil).shr(nm1, k); - nm3 = (nat.nil).sub(nm1, natTwo); - rand$1 = rand.New(rand.NewSource(((x = (0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]), new $Int64(0, x.constructor === Number ? x : 1))))); - _tmp = nat.nil; - _tmp$1 = nat.nil; - _tmp$2 = nat.nil; - x$1 = _tmp; - y = _tmp$1; - quotient = _tmp$2; - nm3Len = nm3.bitLen(); - i = 0; - /* while (true) { */ case 1: - /* if (!(i < reps)) { break; } */ if(!(i < reps)) { $s = 2; continue; } - /* */ if ((i === (reps - 1 >> 0)) && force2) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if ((i === (reps - 1 >> 0)) && force2) { */ case 3: - x$1 = x$1.set(natTwo); - $s = 5; continue; - /* } else { */ case 4: - _r$1 = x$1.random(rand$1, nm3, nm3Len); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - x$1 = _r$1; - x$1 = x$1.add(x$1, natTwo); - /* } */ case 5: - _r$2 = y.expNN(x$1, q, n); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - y = _r$2; - /* */ if ((y.cmp(natOne) === 0) || (y.cmp(nm1) === 0)) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if ((y.cmp(natOne) === 0) || (y.cmp(nm1) === 0)) { */ case 8: - i = i + (1) >> 0; - /* continue; */ $s = 1; continue; - /* } */ case 9: - j = 1; - /* while (true) { */ case 10: - /* if (!(j < k)) { break; } */ if(!(j < k)) { $s = 11; continue; } - y = y.sqr(y); - _r$3 = quotient.div(y, y, n); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple = _r$3; - quotient = _tuple[0]; - y = _tuple[1]; - if (y.cmp(nm1) === 0) { - i = i + (1) >> 0; - /* continue NextRandom; */ $s = 1; continue s; - } - if (y.cmp(natOne) === 0) { - $s = -1; return false; - } - j = j + (1) >>> 0; - /* } */ $s = 10; continue; case 11: - $s = -1; return false; - /* } */ $s = 1; continue; case 2: - $s = -1; return true; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.probablyPrimeMillerRabin }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.force2 = force2; $f.i = i; $f.j = j; $f.k = k; $f.n = n; $f.nm1 = nm1; $f.nm3 = nm3; $f.nm3Len = nm3Len; $f.q = q; $f.quotient = quotient; $f.rand$1 = rand$1; $f.reps = reps; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.probablyPrimeMillerRabin = function(reps, force2) { return this.$get().probablyPrimeMillerRabin(reps, force2); }; - nat.prototype.probablyPrimeLucas = function() { - var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, d, i, intD, intN, j, n, natP, nm2, p, r, s, t, t1, t1$1, t2, t2$1, t3, vk, vk1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; d = $f.d; i = $f.i; intD = $f.intD; intN = $f.intN; j = $f.j; n = $f.n; natP = $f.natP; nm2 = $f.nm2; p = $f.p; r = $f.r; s = $f.s; t = $f.t; t1 = $f.t1; t1$1 = $f.t1$1; t2 = $f.t2; t2$1 = $f.t2$1; t3 = $f.t3; vk = $f.vk; vk1 = $f.vk1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - n = this; - if ((n.$length === 0) || (n.cmp(natOne) === 0)) { - $s = -1; return false; - } - if ((((0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]) & 1) >>> 0) === 0) { - $s = -1; return n.cmp(natTwo) === 0; - } - p = 3; - d = new nat([1]); - t1 = (nat.nil); - intD = new Int.ptr(false, d); - intN = new Int.ptr(false, n); - /* while (true) { */ case 1: - /* */ if (p > 10000) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (p > 10000) { */ case 3: - _r$1 = intN.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $panic(new $String("math/big: internal error: cannot find (D/n) = -1 for " + _r$1)); - /* } */ case 4: - (0 >= d.$length ? ($throwRuntimeError("index out of range"), undefined) : d.$array[d.$offset + 0] = (($imul(p, p) >>> 0) - 4 >>> 0)); - _r$2 = Jacobi(intD, intN); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - j = _r$2; - if (j === -1) { - /* break; */ $s = 2; continue; - } - if (j === 0) { - $s = -1; return (n.$length === 1) && ((0 >= n.$length ? ($throwRuntimeError("index out of range"), undefined) : n.$array[n.$offset + 0]) === (p + 2 >>> 0)); - } - /* */ if (p === 40) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (p === 40) { */ case 7: - _r$3 = t1.sqrt(n); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - t1 = _r$3; - t1 = t1.sqr(t1); - if (t1.cmp(n) === 0) { - $s = -1; return false; - } - /* } */ case 8: - p = p + (1) >>> 0; - /* } */ $s = 1; continue; case 2: - s = (nat.nil).add(n, natOne); - r = ((s.trailingZeroBits() >> 0)); - s = s.shr(s, ((r >>> 0))); - nm2 = (nat.nil).sub(n, natTwo); - natP = (nat.nil).setWord(p); - vk = (nat.nil).setWord(2); - vk1 = (nat.nil).setWord(p); - t2 = (nat.nil); - i = (s.bitLen()); - /* while (true) { */ case 10: - /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 11; continue; } - /* */ if (!((s.bit(((i >>> 0))) === 0))) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (!((s.bit(((i >>> 0))) === 0))) { */ case 12: - t1 = t1.mul(vk, vk1); - t1 = t1.add(t1, n); - t1 = t1.sub(t1, natP); - _r$4 = t2.div(vk, t1, n); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = _r$4; - t2 = _tuple[0]; - vk = _tuple[1]; - t1 = t1.sqr(vk1); - t1 = t1.add(t1, nm2); - _r$5 = t2.div(vk1, t1, n); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$1 = _r$5; - t2 = _tuple$1[0]; - vk1 = _tuple$1[1]; - $s = 14; continue; - /* } else { */ case 13: - t1 = t1.mul(vk, vk1); - t1 = t1.add(t1, n); - t1 = t1.sub(t1, natP); - _r$6 = t2.div(vk1, t1, n); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple$2 = _r$6; - t2 = _tuple$2[0]; - vk1 = _tuple$2[1]; - t1 = t1.sqr(vk); - t1 = t1.add(t1, nm2); - _r$7 = t2.div(vk, t1, n); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _tuple$3 = _r$7; - t2 = _tuple$3[0]; - vk = _tuple$3[1]; - /* } */ case 14: - i = i - (1) >> 0; - /* } */ $s = 10; continue; case 11: - /* */ if ((vk.cmp(natTwo) === 0) || (vk.cmp(nm2) === 0)) { $s = 19; continue; } - /* */ $s = 20; continue; - /* if ((vk.cmp(natTwo) === 0) || (vk.cmp(nm2) === 0)) { */ case 19: - t1$1 = t1.mul(vk, natP); - t2$1 = t2.shl(vk1, 1); - if (t1$1.cmp(t2$1) < 0) { - _tmp = t2$1; - _tmp$1 = t1$1; - t1$1 = _tmp; - t2$1 = _tmp$1; - } - t1$1 = t1$1.sub(t1$1, t2$1); - t3 = vk1; - vk1 = nat.nil; - $unused(vk1); - _r$8 = t2$1.div(t3, t1$1, n); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _tuple$4 = _r$8; - t2$1 = _tuple$4[0]; - t3 = _tuple$4[1]; - if (t3.$length === 0) { - $s = -1; return true; - } - /* } */ case 20: - t = 0; - /* while (true) { */ case 22: - /* if (!(t < (r - 1 >> 0))) { break; } */ if(!(t < (r - 1 >> 0))) { $s = 23; continue; } - if (vk.$length === 0) { - $s = -1; return true; - } - if ((vk.$length === 1) && ((0 >= vk.$length ? ($throwRuntimeError("index out of range"), undefined) : vk.$array[vk.$offset + 0]) === 2)) { - $s = -1; return false; - } - t1 = t1.sqr(vk); - t1 = t1.sub(t1, natTwo); - _r$9 = t2.div(vk, t1, n); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _tuple$5 = _r$9; - t2 = _tuple$5[0]; - vk = _tuple$5[1]; - t = t + (1) >> 0; - /* } */ $s = 22; continue; case 23: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: nat.prototype.probablyPrimeLucas }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.d = d; $f.i = i; $f.intD = intD; $f.intN = intN; $f.j = j; $f.n = n; $f.natP = natP; $f.nm2 = nm2; $f.p = p; $f.r = r; $f.s = s; $f.t = t; $f.t1 = t1; $f.t1$1 = t1$1; $f.t2 = t2; $f.t2$1 = t2$1; $f.t3 = t3; $f.vk = vk; $f.vk1 = vk1; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(nat).prototype.probablyPrimeLucas = function() { return this.$get().probablyPrimeLucas(); }; - Rat.ptr.prototype.SetFloat64 = function(f) { - var _1, _r$1, bits$1, exp, f, mantissa, shift, x, x$1, x$2, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; bits$1 = $f.bits$1; exp = $f.exp; f = $f.f; mantissa = $f.mantissa; shift = $f.shift; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - bits$1 = math.Float64bits(f); - mantissa = new $Uint64(bits$1.$high & 1048575, (bits$1.$low & 4294967295) >>> 0); - exp = (((x = $shiftRightUint64(bits$1, 52), new $Uint64(x.$high & 0, (x.$low & 2047) >>> 0)).$low >> 0)); - _1 = exp; - if (_1 === (2047)) { - $s = -1; return ptrType$2.nil; - } else if (_1 === (0)) { - exp = exp - (1022) >> 0; - } else { - mantissa = (x$1 = new $Uint64(1048576, 0), new $Uint64(mantissa.$high | x$1.$high, (mantissa.$low | x$1.$low) >>> 0)); - exp = exp - (1023) >> 0; - } - shift = 52 - exp >> 0; - while (true) { - if (!((x$2 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$2.$high === 0 && x$2.$low === 0)) && shift > 0)) { break; } - mantissa = $shiftRightUint64(mantissa, (1)); - shift = shift - (1) >> 0; - } - z.a.SetUint64(mantissa); - z.a.neg = f < 0; - z.b.Set(intOne); - if (shift > 0) { - z.b.Lsh(z.b, ((shift >>> 0))); - } else { - z.a.Lsh(z.a, ((-shift >>> 0))); - } - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFloat64 }; } $f._1 = _1; $f._r$1 = _r$1; $f.bits$1 = bits$1; $f.exp = exp; $f.f = f; $f.mantissa = mantissa; $f.shift = shift; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.SetFloat64 = function(f) { return this.$val.SetFloat64(f); }; - quotToFloat32 = function(a, b) { - var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, y, y$1, y$2, y$3, y$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = 0; - exact = false; - alen = a.bitLen(); - if (alen === 0) { - _tmp = 0; - _tmp$1 = true; - f = _tmp; - exact = _tmp$1; - $s = -1; return [f, exact]; - } - blen = b.bitLen(); - if (blen === 0) { - $panic(new $String("division by zero")); - } - exp = alen - blen >> 0; - _tmp$2 = nat.nil; - _tmp$3 = nat.nil; - a2 = _tmp$2; - b2 = _tmp$3; - a2 = a2.set(a); - b2 = b2.set(b); - shift = 25 - exp >> 0; - if (shift > 0) { - a2 = a2.shl(a2, ((shift >>> 0))); - } else if (shift < 0) { - b2 = b2.shl(b2, ((-shift >>> 0))); - } - q = nat.nil; - _r$1 = q.div(a2, a2, b2); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - q = _tuple[0]; - r = _tuple[1]; - mantissa = low32(q); - haveRem = r.$length > 0; - if ((mantissa >>> 25 >>> 0) === 1) { - if (((mantissa & 1) >>> 0) === 1) { - haveRem = true; - } - mantissa = (y = (1), y < 32 ? (mantissa >>> y) : 0) >>> 0; - exp = exp + (1) >> 0; - } - /* */ if (!(((mantissa >>> 24 >>> 0) === 1))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!(((mantissa >>> 24 >>> 0) === 1))) { */ case 2: - _r$2 = fmt.Sprintf("expected exactly %d bits of result", new sliceType([new $Int(25)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $panic(new $String(_r$2)); - /* } */ case 3: - if (-149 <= exp && exp <= -126) { - shift$1 = (((-126 - ((exp - 1 >> 0)) >> 0) >>> 0)); - lostbits = (mantissa & ((((y$1 = shift$1, y$1 < 32 ? (1 << y$1) : 0) >>> 0) - 1 >>> 0))) >>> 0; - haveRem = haveRem || !((lostbits === 0)); - mantissa = (y$2 = (shift$1), y$2 < 32 ? (mantissa >>> y$2) : 0) >>> 0; - exp = -125; - } - exact = !haveRem; - if (!((((mantissa & 1) >>> 0) === 0))) { - exact = false; - if (haveRem || !((((mantissa & 2) >>> 0) === 0))) { - mantissa = mantissa + (1) >>> 0; - if (mantissa >= 33554432) { - mantissa = (y$3 = (1), y$3 < 32 ? (mantissa >>> y$3) : 0) >>> 0; - exp = exp + (1) >> 0; - } - } - } - mantissa = (y$4 = (1), y$4 < 32 ? (mantissa >>> y$4) : 0) >>> 0; - f = ($fround(math.Ldexp((mantissa), exp - 24 >> 0))); - if (math.IsInf((f), 0)) { - exact = false; - } - $s = -1; return [f, exact]; - /* */ } return; } if ($f === undefined) { $f = { $blk: quotToFloat32 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f; - }; - quotToFloat64 = function(a, b) { - var _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = 0; - exact = false; - alen = a.bitLen(); - if (alen === 0) { - _tmp = 0; - _tmp$1 = true; - f = _tmp; - exact = _tmp$1; - $s = -1; return [f, exact]; - } - blen = b.bitLen(); - if (blen === 0) { - $panic(new $String("division by zero")); - } - exp = alen - blen >> 0; - _tmp$2 = nat.nil; - _tmp$3 = nat.nil; - a2 = _tmp$2; - b2 = _tmp$3; - a2 = a2.set(a); - b2 = b2.set(b); - shift = 54 - exp >> 0; - if (shift > 0) { - a2 = a2.shl(a2, ((shift >>> 0))); - } else if (shift < 0) { - b2 = b2.shl(b2, ((-shift >>> 0))); - } - q = nat.nil; - _r$1 = q.div(a2, a2, b2); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - q = _tuple[0]; - r = _tuple[1]; - mantissa = low64(q); - haveRem = r.$length > 0; - if ((x = $shiftRightUint64(mantissa, 54), (x.$high === 0 && x.$low === 1))) { - if ((x$1 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { - haveRem = true; - } - mantissa = $shiftRightUint64(mantissa, (1)); - exp = exp + (1) >> 0; - } - /* */ if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { */ case 2: - _r$2 = fmt.Sprintf("expected exactly %d bits of result", new sliceType([new $Int(54)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $panic(new $String(_r$2)); - /* } */ case 3: - if (-1074 <= exp && exp <= -1022) { - shift$1 = (((-1022 - ((exp - 1 >> 0)) >> 0) >>> 0)); - lostbits = (x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), shift$1), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(mantissa.$high & x$3.$high, (mantissa.$low & x$3.$low) >>> 0)); - haveRem = haveRem || !((lostbits.$high === 0 && lostbits.$low === 0)); - mantissa = $shiftRightUint64(mantissa, (shift$1)); - exp = -1021; - } - exact = !haveRem; - if (!((x$5 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { - exact = false; - if (haveRem || !((x$6 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 2) >>> 0), (x$6.$high === 0 && x$6.$low === 0)))) { - mantissa = (x$7 = new $Uint64(0, 1), new $Uint64(mantissa.$high + x$7.$high, mantissa.$low + x$7.$low)); - if ((mantissa.$high > 4194304 || (mantissa.$high === 4194304 && mantissa.$low >= 0))) { - mantissa = $shiftRightUint64(mantissa, (1)); - exp = exp + (1) >> 0; - } - } - } - mantissa = $shiftRightUint64(mantissa, (1)); - f = math.Ldexp(($flatten64(mantissa)), exp - 53 >> 0); - if (math.IsInf(f, 0)) { - exact = false; - } - $s = -1; return [f, exact]; - /* */ } return; } if ($f === undefined) { $f = { $blk: quotToFloat64 }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.ptr.prototype.Float32 = function() { - var _r$1, _tuple, b, exact, f, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = 0; - exact = false; - x = this; - b = x.b.abs; - if (b.$length === 0) { - b = b.set(natOne); - } - _r$1 = quotToFloat32(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - f = _tuple[0]; - exact = _tuple[1]; - if (x.a.neg) { - f = -f; - } - $s = -1; return [f, exact]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float32 }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Float32 = function() { return this.$val.Float32(); }; - Rat.ptr.prototype.Float64 = function() { - var _r$1, _tuple, b, exact, f, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - f = 0; - exact = false; - x = this; - b = x.b.abs; - if (b.$length === 0) { - b = b.set(natOne); - } - _r$1 = quotToFloat64(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - f = _tuple[0]; - exact = _tuple[1]; - if (x.a.neg) { - f = -f; - } - $s = -1; return [f, exact]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float64 }; } $f._r$1 = _r$1; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Float64 = function() { return this.$val.Float64(); }; - Rat.ptr.prototype.SetFrac = function(a, b) { - var _r$1, a, b, babs, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; babs = $f.babs; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - z.a.neg = !(a.neg === b.neg); - babs = b.abs; - if (babs.$length === 0) { - $panic(new $String("division by zero")); - } - if (z.a === b || alias(z.a.abs, babs)) { - babs = (nat.nil).set(babs); - } - z.a.abs = z.a.abs.set(a.abs); - z.b.abs = z.b.abs.set(babs); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFrac }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.babs = babs; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.SetFrac = function(a, b) { return this.$val.SetFrac(a, b); }; - Rat.ptr.prototype.SetFrac64 = function(a, b) { - var _r$1, a, b, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - z.a.SetInt64(a); - if ((b.$high === 0 && b.$low === 0)) { - $panic(new $String("division by zero")); - } - if ((b.$high < 0 || (b.$high === 0 && b.$low < 0))) { - b = new $Int64(-b.$high, -b.$low); - z.a.neg = !z.a.neg; - } - z.b.abs = z.b.abs.setUint64((new $Uint64(b.$high, b.$low))); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetFrac64 }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.SetFrac64 = function(a, b) { return this.$val.SetFrac64(a, b); }; - Rat.ptr.prototype.SetInt = function(x) { - var x, z; - z = this; - z.a.Set(x); - z.b.abs = $subslice(z.b.abs, 0, 0); - return z; - }; - Rat.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; - Rat.ptr.prototype.SetInt64 = function(x) { - var x, z; - z = this; - z.a.SetInt64(x); - z.b.abs = $subslice(z.b.abs, 0, 0); - return z; - }; - Rat.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); }; - Rat.ptr.prototype.Set = function(x) { - var x, z; - z = this; - if (!(z === x)) { - z.a.Set(x.a); - z.b.Set(x.b); - } - return z; - }; - Rat.prototype.Set = function(x) { return this.$val.Set(x); }; - Rat.ptr.prototype.Abs = function(x) { - var x, z; - z = this; - z.Set(x); - z.a.neg = false; - return z; - }; - Rat.prototype.Abs = function(x) { return this.$val.Abs(x); }; - Rat.ptr.prototype.Neg = function(x) { - var x, z; - z = this; - z.Set(x); - z.a.neg = z.a.abs.$length > 0 && !z.a.neg; - return z; - }; - Rat.prototype.Neg = function(x) { return this.$val.Neg(x); }; - Rat.ptr.prototype.Inv = function(x) { - var _tmp, _tmp$1, a, b, x, z; - z = this; - if (x.a.abs.$length === 0) { - $panic(new $String("division by zero")); - } - z.Set(x); - a = z.b.abs; - if (a.$length === 0) { - a = a.set(natOne); - } - b = z.a.abs; - if (b.cmp(natOne) === 0) { - b = $subslice(b, 0, 0); - } - _tmp = a; - _tmp$1 = b; - z.a.abs = _tmp; - z.b.abs = _tmp$1; - return z; - }; - Rat.prototype.Inv = function(x) { return this.$val.Inv(x); }; - Rat.ptr.prototype.Sign = function() { - var x; - x = this; - return x.a.Sign(); - }; - Rat.prototype.Sign = function() { return this.$val.Sign(); }; - Rat.ptr.prototype.IsInt = function() { - var x; - x = this; - return (x.b.abs.$length === 0) || (x.b.abs.cmp(natOne) === 0); - }; - Rat.prototype.IsInt = function() { return this.$val.IsInt(); }; - Rat.ptr.prototype.Num = function() { - var x; - x = this; - return x.a; - }; - Rat.prototype.Num = function() { return this.$val.Num(); }; - Rat.ptr.prototype.Denom = function() { - var x; - x = this; - x.b.neg = false; - if (x.b.abs.$length === 0) { - x.b.abs = x.b.abs.set(natOne); - } - return x.b; - }; - Rat.prototype.Denom = function() { return this.$val.Denom(); }; - Rat.ptr.prototype.norm = function() { - var _r$1, _r$2, _r$3, _tuple, _tuple$1, f, neg, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; f = $f.f; neg = $f.neg; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if ((z.a.abs.$length === 0)) { $s = 2; continue; } - /* */ if ((z.b.abs.$length === 0)) { $s = 3; continue; } - /* */ if ((z.b.abs.cmp(natOne) === 0)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((z.a.abs.$length === 0)) { */ case 2: - z.a.neg = false; - z.b.abs = $subslice(z.b.abs, 0, 0); - $s = 6; continue; - /* } else if ((z.b.abs.$length === 0)) { */ case 3: - $s = 6; continue; - /* } else if ((z.b.abs.cmp(natOne) === 0)) { */ case 4: - z.b.abs = $subslice(z.b.abs, 0, 0); - $s = 6; continue; - /* } else { */ case 5: - neg = z.a.neg; - z.a.neg = false; - z.b.neg = false; - _r$1 = NewInt(new $Int64(0, 0)).lehmerGCD(ptrType$1.nil, ptrType$1.nil, z.a, z.b); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - f = _r$1; - /* */ if (!((f.Cmp(intOne) === 0))) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (!((f.Cmp(intOne) === 0))) { */ case 8: - _r$2 = z.a.abs.div(nat.nil, z.a.abs, f.abs); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - z.a.abs = _tuple[0]; - _r$3 = z.b.abs.div(nat.nil, z.b.abs, f.abs); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$1 = _r$3; - z.b.abs = _tuple$1[0]; - if (z.b.abs.cmp(natOne) === 0) { - z.b.abs = $subslice(z.b.abs, 0, 0); - } - /* } */ case 9: - z.a.neg = neg; - /* } */ case 6: - case 1: - $s = -1; return z; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.norm }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.f = f; $f.neg = neg; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.norm = function() { return this.$val.norm(); }; - mulDenom = function(z, x, y) { - var x, y, z; - if ((x.$length === 0)) { - return z.set(y); - } else if ((y.$length === 0)) { - return z.set(x); - } - return z.mul(x, y); - }; - scaleDenom = function(x, f) { - var f, x, z; - z = new Int.ptr(false, nat.nil); - if (f.$length === 0) { - return z.Set(x); - } - z.abs = z.abs.mul(x.abs, f); - z.neg = x.neg; - return z; - }; - Rat.ptr.prototype.Cmp = function(y) { - var x, y; - x = this; - return scaleDenom(x.a, y.b.abs).Cmp(scaleDenom(y.a, x.b.abs)); - }; - Rat.prototype.Cmp = function(y) { return this.$val.Cmp(y); }; - Rat.ptr.prototype.Add = function(x, y) { - var _r$1, a1, a2, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a1 = $f.a1; a2 = $f.a2; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - a1 = scaleDenom(x.a, y.b.abs); - a2 = scaleDenom(y.a, x.b.abs); - z.a.Add(a1, a2); - z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Add }; } $f._r$1 = _r$1; $f.a1 = a1; $f.a2 = a2; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Add = function(x, y) { return this.$val.Add(x, y); }; - Rat.ptr.prototype.Sub = function(x, y) { - var _r$1, a1, a2, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a1 = $f.a1; a2 = $f.a2; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - a1 = scaleDenom(x.a, y.b.abs); - a2 = scaleDenom(y.a, x.b.abs); - z.a.Sub(a1, a2); - z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Sub }; } $f._r$1 = _r$1; $f.a1 = a1; $f.a2 = a2; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); }; - Rat.ptr.prototype.Mul = function(x, y) { - var _r$1, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (x === y) { - z.a.neg = false; - z.a.abs = z.a.abs.sqr(x.a.abs); - z.b.abs = z.b.abs.sqr(x.b.abs); - $s = -1; return z; - } - z.a.Mul(x.a, y.a); - z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Mul }; } $f._r$1 = _r$1; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); }; - Rat.ptr.prototype.Quo = function(x, y) { - var _r$1, a, b, x, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; a = $f.a; b = $f.b; x = $f.x; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (y.a.abs.$length === 0) { - $panic(new $String("division by zero")); - } - a = scaleDenom(x.a, y.b.abs); - b = scaleDenom(y.a, x.b.abs); - z.a.abs = a.abs; - z.b.abs = b.abs; - z.a.neg = !(a.neg === b.neg); - _r$1 = z.norm(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Quo }; } $f._r$1 = _r$1; $f.a = a; $f.b = b; $f.x = x; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); }; - ratTok = function(ch) { - var ch; - return strings.ContainsRune("+-/0123456789.eE", ch); - }; - Rat.ptr.prototype.Scan = function(s, ch) { - var _r$1, _r$2, _tuple, _tuple$1, ch, err, ok, s, tok, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ch = $f.ch; err = $f.err; ok = $f.ok; s = $f.s; tok = $f.tok; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = s.Token(true, ratTok); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - tok = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return err; - } - if (!strings.ContainsRune("efgEFGv", ch)) { - $s = -1; return errors.New("Rat.Scan: invalid verb"); - } - _r$2 = z.SetString(($bytesToString(tok))); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - ok = _tuple$1[1]; - if (!ok) { - $s = -1; return errors.New("Rat.Scan: invalid syntax"); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Scan }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ch = ch; $f.err = err; $f.ok = ok; $f.s = s; $f.tok = tok; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); }; - Rat.ptr.prototype.SetString = function(s) { - var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, ecorr, err, err$1, exp, expabs, neg, ok, powTen, r, r$1, s, sep, x, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; ecorr = $f.ecorr; err = $f.err; err$1 = $f.err$1; exp = $f.exp; expabs = $f.expabs; neg = $f.neg; ok = $f.ok; powTen = $f.powTen; r = $f.r; r$1 = $f.r$1; s = $f.s; sep = $f.sep; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (s.length === 0) { - $s = -1; return [ptrType$2.nil, false]; - } - sep = strings.Index(s, "/"); - /* */ if (sep >= 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (sep >= 0) { */ case 1: - _r$1 = z.a.SetString($substring(s, 0, sep), 0); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ok = _tuple[1]; - if (!ok) { - $s = -1; return [ptrType$2.nil, false]; - } - r = strings.NewReader($substring(s, (sep + 1 >> 0))); - err = $ifaceNil; - _r$2 = z.b.abs.scan(r, 0, false); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - z.b.abs = _tuple$1[0]; - err = _tuple$1[3]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$2.nil, false]; - } - _tuple$2 = r.ReadByte(); - err = _tuple$2[1]; - if (!($interfaceIsEqual(err, io.EOF))) { - $s = -1; return [ptrType$2.nil, false]; - } - if (z.b.abs.$length === 0) { - $s = -1; return [ptrType$2.nil, false]; - } - _r$3 = z.norm(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $s = -1; return [_r$3, true]; - /* } */ case 2: - r$1 = strings.NewReader(s); - _r$4 = scanSign(r$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$3 = _r$4; - neg = _tuple$3[0]; - err$1 = _tuple$3[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$2.nil, false]; - } - ecorr = 0; - _r$5 = z.a.abs.scan(r$1, 10, true); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$4 = _r$5; - z.a.abs = _tuple$4[0]; - ecorr = _tuple$4[2]; - err$1 = _tuple$4[3]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$2.nil, false]; - } - exp = new $Int64(0, 0); - _r$6 = scanExponent(r$1, false); /* */ $s = 8; case 8: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple$5 = _r$6; - exp = _tuple$5[0]; - err$1 = _tuple$5[2]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$2.nil, false]; - } - _tuple$6 = r$1.ReadByte(); - err$1 = _tuple$6[1]; - if (!($interfaceIsEqual(err$1, io.EOF))) { - $s = -1; return [ptrType$2.nil, false]; - } - if (z.a.abs.$length === 0) { - $s = -1; return [z, true]; - } - if (ecorr < 0) { - exp = (x = (new $Int64(0, ecorr)), new $Int64(exp.$high + x.$high, exp.$low + x.$low)); - } - expabs = exp; - if ((expabs.$high < 0 || (expabs.$high === 0 && expabs.$low < 0))) { - expabs = new $Int64(-expabs.$high, -expabs.$low); - } - _r$7 = (nat.nil).expNN(natTen, (nat.nil).setWord(((expabs.$low >>> 0))), nat.nil); /* */ $s = 9; case 9: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - powTen = _r$7; - /* */ if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if ((exp.$high < 0 || (exp.$high === 0 && exp.$low < 0))) { */ case 10: - z.b.abs = powTen; - _r$8 = z.norm(); /* */ $s = 13; case 13: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - _r$8; - $s = 12; continue; - /* } else { */ case 11: - z.a.abs = z.a.abs.mul(z.a.abs, powTen); - z.b.abs = $subslice(z.b.abs, 0, 0); - /* } */ case 12: - z.a.neg = neg && z.a.abs.$length > 0; - $s = -1; return [z, true]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetString }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.ecorr = ecorr; $f.err = err; $f.err$1 = err$1; $f.exp = exp; $f.expabs = expabs; $f.neg = neg; $f.ok = ok; $f.powTen = powTen; $f.r = r; $f.r$1 = r$1; $f.s = s; $f.sep = sep; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.SetString = function(s) { return this.$val.SetString(s); }; - scanExponent = function(r, binExpOk) { - var _1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, _tuple$1, _tuple$2, _tuple$3, base, binExpOk, ch, digits, err, exp, i, neg, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; base = $f.base; binExpOk = $f.binExpOk; ch = $f.ch; digits = $f.digits; err = $f.err; exp = $f.exp; i = $f.i; neg = $f.neg; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - exp = new $Int64(0, 0); - base = 0; - err = $ifaceNil; - base = 10; - ch = 0; - _r$1 = r.ReadByte(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ch = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - if ($interfaceIsEqual(err, io.EOF)) { - err = $ifaceNil; - } - $s = -1; return [exp, base, err]; - } - _1 = ch; - /* */ if ((_1 === (101)) || (_1 === (69))) { $s = 3; continue; } - /* */ if (_1 === (112)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((_1 === (101)) || (_1 === (69))) { */ case 3: - $s = 6; continue; - /* } else if (_1 === (112)) { */ case 4: - if (binExpOk) { - base = 2; - /* break; */ $s = 2; continue; - } - _r$2 = r.UnreadByte(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - $s = -1; return [exp, base, err]; - /* } else { */ case 5: - _r$3 = r.UnreadByte(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - $s = -1; return [exp, base, err]; - /* } */ case 6: - case 2: - neg = false; - _r$4 = scanSign(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - neg = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [exp, base, err]; - } - digits = sliceType$1.nil; - if (neg) { - digits = $append(digits, 45); - } - i = 0; - /* while (true) { */ case 10: - _r$5 = r.ReadByte(); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$2 = _r$5; - ch = _tuple$2[0]; - err = _tuple$2[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - if (!($interfaceIsEqual(err, io.EOF)) || (i === 0)) { - $s = -1; return [exp, base, err]; - } - err = $ifaceNil; - /* break; */ $s = 11; continue; - } - /* */ if (ch < 48 || 57 < ch) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (ch < 48 || 57 < ch) { */ case 13: - /* */ if (i === 0) { $s = 15; continue; } - /* */ $s = 16; continue; - /* if (i === 0) { */ case 15: - _r$6 = r.UnreadByte(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$6; - _r$7 = fmt.Errorf("invalid exponent (missing digits)", new sliceType([])); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - err = _r$7; - $s = -1; return [exp, base, err]; - /* } */ case 16: - /* break; */ $s = 11; continue; - /* } */ case 14: - digits = $append(digits, ch); - i = i + (1) >> 0; - /* } */ $s = 10; continue; case 11: - _tuple$3 = strconv.ParseInt(($bytesToString(digits)), 10, 64); - exp = _tuple$3[0]; - err = _tuple$3[1]; - $s = -1; return [exp, base, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: scanExponent }; } $f._1 = _1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.base = base; $f.binExpOk = binExpOk; $f.ch = ch; $f.digits = digits; $f.err = err; $f.exp = exp; $f.i = i; $f.neg = neg; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.ptr.prototype.String = function() { - var _r$1, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - _r$1 = x.marshal(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return ($bytesToString(_r$1)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.String }; } $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.String = function() { return this.$val.String(); }; - Rat.ptr.prototype.marshal = function() { - var _r$1, _r$2, buf, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; buf = $f.buf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - buf = sliceType$1.nil; - _r$1 = x.a.Append(buf, 10); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - buf = _r$1; - buf = $append(buf, 47); - /* */ if (!((x.b.abs.$length === 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((x.b.abs.$length === 0))) { */ case 2: - _r$2 = x.b.Append(buf, 10); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - buf = _r$2; - $s = 4; continue; - /* } else { */ case 3: - buf = $append(buf, 49); - /* } */ case 4: - $s = -1; return buf; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.marshal }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.buf = buf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.marshal = function() { return this.$val.marshal(); }; - Rat.ptr.prototype.RatString = function() { - var _r$1, _r$2, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - /* */ if (x.IsInt()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (x.IsInt()) { */ case 1: - _r$1 = x.a.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - _r$2 = x.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.RatString }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.RatString = function() { return this.$val.RatString(); }; - Rat.ptr.prototype.FloatString = function(prec) { - var _arg, _arg$1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, buf, i, i$1, p, prec, q, r, r2, rs, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; i = $f.i; i$1 = $f.i$1; p = $f.p; prec = $f.prec; q = $f.q; r = $f.r; r2 = $f.r2; rs = $f.rs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - x = this; - buf = sliceType$1.nil; - /* */ if (x.IsInt()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (x.IsInt()) { */ case 1: - _r$1 = x.a.Append(buf, 10); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - buf = _r$1; - if (prec > 0) { - buf = $append(buf, 46); - i = prec; - while (true) { - if (!(i > 0)) { break; } - buf = $append(buf, 48); - i = i - (1) >> 0; - } - } - $s = -1; return ($bytesToString(buf)); - /* } */ case 2: - _r$2 = (nat.nil).div((nat.nil), x.a.abs, x.b.abs); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - q = _tuple[0]; - r = _tuple[1]; - p = natOne; - /* */ if (prec > 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (prec > 0) { */ case 5: - _r$3 = (nat.nil).expNN(natTen, (nat.nil).setUint64((new $Uint64(0, prec))), nat.nil); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - p = _r$3; - /* } */ case 6: - r = r.mul(r, p); - _r$4 = r.div((nat.nil), r, x.b.abs); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - r = _tuple$1[0]; - r2 = _tuple$1[1]; - r2 = r2.add(r2, r2); - if (x.b.abs.cmp(r2) <= 0) { - r = r.add(r, natOne); - if (r.cmp(p) >= 0) { - q = (nat.nil).add(q, natOne); - r = (nat.nil).sub(r, p); - } - } - if (x.a.neg) { - buf = $append(buf, 45); - } - _arg = buf; - _r$5 = q.utoa(10); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$1 = _r$5; - buf = $appendSlice(_arg, _arg$1); - /* */ if (prec > 0) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (prec > 0) { */ case 10: - buf = $append(buf, 46); - _r$6 = r.utoa(10); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - rs = _r$6; - i$1 = prec - rs.$length >> 0; - while (true) { - if (!(i$1 > 0)) { break; } - buf = $append(buf, 48); - i$1 = i$1 - (1) >> 0; - } - buf = $appendSlice(buf, rs); - /* } */ case 11: - $s = -1; return ($bytesToString(buf)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.FloatString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.i = i; $f.i$1 = i$1; $f.p = p; $f.prec = prec; $f.q = q; $f.r = r; $f.r2 = r2; $f.rs = rs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.FloatString = function(prec) { return this.$val.FloatString(prec); }; - Rat.ptr.prototype.GobEncode = function() { - var b, buf, i, j, n, x; - x = this; - if (x === ptrType$2.nil) { - return [sliceType$1.nil, $ifaceNil]; - } - buf = $makeSlice(sliceType$1, (5 + ($imul(((x.a.abs.$length + x.b.abs.$length >> 0)), 4)) >> 0)); - i = x.b.abs.bytes(buf); - j = x.a.abs.bytes($subslice(buf, 0, i)); - n = i - j >> 0; - if (!((((((n >>> 0)) >> 0)) === n))) { - return [sliceType$1.nil, errors.New("Rat.GobEncode: numerator too large")]; - } - $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(buf, (j - 4 >> 0), j), ((n >>> 0))); - j = j - (5) >> 0; - b = 2; - if (x.a.neg) { - b = (b | (1)) >>> 0; - } - ((j < 0 || j >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + j] = b); - return [$subslice(buf, j), $ifaceNil]; - }; - Rat.prototype.GobEncode = function() { return this.$val.GobEncode(); }; - Rat.ptr.prototype.GobDecode = function(buf) { - var _r$1, b, buf, i, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; i = $f.i; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - if (buf.$length === 0) { - Rat.copy(z, new Rat.ptr(new Int.ptr(false, nat.nil), new Int.ptr(false, nat.nil))); - $s = -1; return $ifaceNil; - } - b = (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]); - /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1: - _r$1 = fmt.Errorf("Rat.GobDecode: encoding version %d not supported", new sliceType([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 2: - i = 5 + $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(buf, 1, 5)) >>> 0; - z.a.neg = !((((b & 1) >>> 0) === 0)); - z.a.abs = z.a.abs.setBytes($subslice(buf, 5, i)); - z.b.abs = z.b.abs.setBytes($subslice(buf, i)); - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.GobDecode }; } $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.i = i; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); }; - Rat.ptr.prototype.MarshalText = function() { - var _r$1, _r$2, _tmp, _tmp$1, _tuple, err, text, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; text = $f.text; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - text = sliceType$1.nil; - err = $ifaceNil; - x = this; - /* */ if (x.IsInt()) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (x.IsInt()) { */ case 1: - _r$1 = x.a.MarshalText(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - text = _tuple[0]; - err = _tuple[1]; - $s = -1; return [text, err]; - /* } */ case 2: - _r$2 = x.marshal(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tmp = _r$2; - _tmp$1 = $ifaceNil; - text = _tmp; - err = _tmp$1; - $s = -1; return [text, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.MarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.text = text; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.MarshalText = function() { return this.$val.MarshalText(); }; - Rat.ptr.prototype.UnmarshalText = function(text) { - var _r$1, _r$2, _tuple, ok, text, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - _r$1 = z.SetString(($bytesToString(text))); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - ok = _tuple[1]; - /* */ if (!ok) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!ok) { */ case 2: - _r$2 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", new sliceType([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* } */ case 3: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.UnmarshalText }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Rat.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); }; - RoundingMode.prototype.String = function() { - var i, x; - i = this.$val; - if (i >= 6) { - return "RoundingMode(" + strconv.FormatInt((new $Int64(0, i)), 10) + ")"; - } - return $substring("ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegativeInfToPositiveInf", ((i < 0 || i >= _RoundingMode_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _RoundingMode_index[i]), (x = i + 1 << 24 >>> 24, ((x < 0 || x >= _RoundingMode_index.length) ? ($throwRuntimeError("index out of range"), undefined) : _RoundingMode_index[x]))); - }; - $ptrType(RoundingMode).prototype.String = function() { return new RoundingMode(this.$get()).String(); }; - Float.ptr.prototype.Sqrt = function(x) { - var _1, _q, _r$1, _r$2, _r$3, _r$4, b, prec, x, x$1, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; b = $f.b; prec = $f.prec; x = $f.x; x$1 = $f.x$1; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = this; - /* */ if (false) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (false) { */ case 1: - $r = x.validate(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (z.prec === 0) { - z.prec = x.prec; - } - _r$1 = x.Sign(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1 === -1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$1 === -1) { */ case 4: - $panic((x$1 = new ErrNaN.ptr("square root of negative operand"), new x$1.constructor.elem(x$1))); - /* } */ case 5: - if (!((x.form === 1))) { - z.acc = 0; - z.form = x.form; - z.neg = x.neg; - $s = -1; return z; - } - prec = z.prec; - _r$2 = x.MantExp(z); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - b = _r$2; - z.prec = prec; - _1 = (_r$3 = b % 2, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); - if (_1 === (0)) { - } else if (_1 === (1)) { - z.exp = z.exp + (1) >> 0; - } else if (_1 === (-1)) { - z.exp = z.exp - (1) >> 0; - } - /* */ if (z.prec <= 128) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (z.prec <= 128) { */ case 8: - $r = z.sqrtDirect(z); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 10; continue; - /* } else { */ case 9: - $r = z.sqrtInverse(z); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 10: - _r$4 = z.SetMantExp(z, (_q = b / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return _r$4; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.Sqrt }; } $f._1 = _1; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.b = b; $f.prec = prec; $f.x = x; $f.x$1 = x$1; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.Sqrt = function(x) { return this.$val.Sqrt(x); }; - Float.ptr.prototype.sqrtDirect = function(x) { - var _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, ng, sq, u, x, xf, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; ng = $f.ng; sq = $f.sq; u = $f.u; x = $f.x; xf = $f.xf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - u = [u]; - x = [x]; - z = this; - u[0] = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - ng = (function(u, x) { return function $b(t) { - var _r$1, _r$2, _r$3, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - u[0].prec = t.prec; - _r$1 = u[0].Mul(t, t); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - _r$2 = u[0].Add(u[0], x[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - u[0].exp = u[0].exp - (1) >> 0; - _r$3 = t.Quo(u[0], t); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - $s = -1; return _r$3; - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; })(u, x); - _r$1 = x[0].Float64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - xf = _tuple[0]; - _r$2 = NewFloat(math.Sqrt(xf)); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - sq = _r$2; - /* */ if (z.prec > 128) { $s = 4; continue; } - /* */ if (z.prec > 64) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (z.prec > 128) { */ case 4: - $panic(new $String("sqrtDirect: only for z.prec <= 128")); - $s = 7; continue; - /* } else if (z.prec > 64) { */ case 5: - sq.prec = $imul(sq.prec, (2)) >>> 0; - _r$3 = ng(sq); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - sq = _r$3; - sq.prec = $imul(sq.prec, (2)) >>> 0; - _r$4 = ng(sq); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - sq = _r$4; - $s = 7; continue; - /* } else { */ case 6: - sq.prec = $imul(sq.prec, (2)) >>> 0; - _r$5 = ng(sq); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - sq = _r$5; - /* } */ case 7: - case 3: - _r$6 = z.Set(sq); /* */ $s = 11; case 11: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _r$6; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.sqrtDirect }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f.ng = ng; $f.sq = sq; $f.u = u; $f.x = x; $f.xf = xf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.sqrtDirect = function(x) { return this.$val.sqrtDirect(x); }; - Float.ptr.prototype.sqrtInverse = function(x) { - var _r$1, _r$2, _r$3, _r$4, _tuple, ng, prec, sqi, u, v, x, xf, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; ng = $f.ng; prec = $f.prec; sqi = $f.sqi; u = $f.u; v = $f.v; x = $f.x; xf = $f.xf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - u = [u]; - v = [v]; - x = [x]; - z = this; - u[0] = newFloat(z.prec); - v[0] = newFloat(z.prec); - ng = (function(u, v, x) { return function $b(t) { - var _r$1, _r$2, _r$3, _r$4, _r$5, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - u[0].prec = t.prec; - v[0].prec = t.prec; - _r$1 = u[0].Mul(t, t); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$1; - _r$2 = u[0].Mul(x[0], u[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - _r$3 = v[0].Sub(three, u[0]); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$3; - _r$4 = u[0].Mul(t, v[0]); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$4; - u[0].exp = u[0].exp - (1) >> 0; - _r$5 = t.Set(u[0]); /* */ $s = 5; case 5: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return _r$5; - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; })(u, v, x); - _r$1 = x[0].Float64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple = _r$1; - xf = _tuple[0]; - sqi = newFloat(z.prec); - _r$2 = sqi.SetFloat64(1 / math.Sqrt(xf)); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - prec = z.prec + 32 >>> 0; - /* while (true) { */ case 3: - /* if (!(sqi.prec < prec)) { break; } */ if(!(sqi.prec < prec)) { $s = 4; continue; } - sqi.prec = $imul(sqi.prec, (2)) >>> 0; - _r$3 = ng(sqi); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - sqi = _r$3; - /* } */ $s = 3; continue; case 4: - _r$4 = z.Mul(x[0], sqi); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$4; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Float.ptr.prototype.sqrtInverse }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.ng = ng; $f.prec = prec; $f.sqi = sqi; $f.u = u; $f.v = v; $f.x = x; $f.xf = xf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - Float.prototype.sqrtInverse = function(x) { return this.$val.sqrtInverse(x); }; - newFloat = function(prec2) { - var _q, prec2, z; - z = new Float.ptr(0, 0, 0, 0, false, nat.nil, 0); - z.mant = z.mant.make($imul((((_q = prec2 / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0)), 2)); - return z; - }; - ptrType$5.methods = [{prop: "at", name: "at", pkg: "math/big", typ: $funcType([$Int], [$Uint8], false)}, {prop: "init", name: "init", pkg: "math/big", typ: $funcType([nat, $Int], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "round", name: "round", pkg: "math/big", typ: $funcType([$Int], [], false)}, {prop: "roundUp", name: "roundUp", pkg: "math/big", typ: $funcType([$Int], [], false)}, {prop: "roundDown", name: "roundDown", pkg: "math/big", typ: $funcType([$Int], [], false)}]; - ptrType.methods = [{prop: "SetPrec", name: "SetPrec", pkg: "", typ: $funcType([$Uint], [ptrType], false)}, {prop: "SetMode", name: "SetMode", pkg: "", typ: $funcType([RoundingMode], [ptrType], false)}, {prop: "Prec", name: "Prec", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "MinPrec", name: "MinPrec", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [RoundingMode], false)}, {prop: "Acc", name: "Acc", pkg: "", typ: $funcType([], [Accuracy], false)}, {prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MantExp", name: "MantExp", pkg: "", typ: $funcType([ptrType], [$Int], false)}, {prop: "setExpAndRound", name: "setExpAndRound", pkg: "math/big", typ: $funcType([$Int64, $Uint], [], false)}, {prop: "SetMantExp", name: "SetMantExp", pkg: "", typ: $funcType([ptrType, $Int], [ptrType], false)}, {prop: "Signbit", name: "Signbit", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsInf", name: "IsInf", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsInt", name: "IsInt", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "validate", name: "validate", pkg: "math/big", typ: $funcType([], [], false)}, {prop: "round", name: "round", pkg: "math/big", typ: $funcType([$Uint], [], false)}, {prop: "setBits64", name: "setBits64", pkg: "math/big", typ: $funcType([$Bool, $Uint64], [ptrType], false)}, {prop: "SetUint64", name: "SetUint64", pkg: "", typ: $funcType([$Uint64], [ptrType], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType], false)}, {prop: "SetFloat64", name: "SetFloat64", pkg: "", typ: $funcType([$Float64], [ptrType], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([ptrType$1], [ptrType], false)}, {prop: "SetRat", name: "SetRat", pkg: "", typ: $funcType([ptrType$2], [ptrType], false)}, {prop: "SetInf", name: "SetInf", pkg: "", typ: $funcType([$Bool], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Copy", name: "Copy", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64, Accuracy], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64, Accuracy], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32, Accuracy], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, Accuracy], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([ptrType$1], [ptrType$1, Accuracy], false)}, {prop: "Rat", name: "Rat", pkg: "", typ: $funcType([ptrType$2], [ptrType$2, Accuracy], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "uadd", name: "uadd", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "usub", name: "usub", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "umul", name: "umul", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "uquo", name: "uquo", pkg: "math/big", typ: $funcType([ptrType, ptrType], [], false)}, {prop: "ucmp", name: "ucmp", pkg: "math/big", typ: $funcType([ptrType], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType], [$Int], false)}, {prop: "ord", name: "ord", pkg: "math/big", typ: $funcType([], [$Int], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [ptrType, $Bool], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType, $Int, $error], false)}, {prop: "pow5", name: "pow5", pkg: "math/big", typ: $funcType([$Uint64], [ptrType], false)}, {prop: "Parse", name: "Parse", pkg: "", typ: $funcType([$String, $Int], [ptrType, $Int, $error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "Text", name: "Text", pkg: "", typ: $funcType([$Uint8, $Int], [$String], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$1, $Uint8, $Int], [sliceType$1], false)}, {prop: "fmtB", name: "fmtB", pkg: "math/big", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "fmtP", name: "fmtP", pkg: "math/big", typ: $funcType([sliceType$1], [sliceType$1], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([fmt.State, $Int32], [], false)}, {prop: "Sqrt", name: "Sqrt", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "sqrtDirect", name: "sqrtDirect", pkg: "math/big", typ: $funcType([ptrType], [], false)}, {prop: "sqrtInverse", name: "sqrtInverse", pkg: "math/big", typ: $funcType([ptrType], [], false)}]; - ErrNaN.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - RoundingMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - Accuracy.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$1.methods = [{prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType$1], false)}, {prop: "SetUint64", name: "SetUint64", pkg: "", typ: $funcType([$Uint64], [ptrType$1], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "SetBits", name: "SetBits", pkg: "", typ: $funcType([sliceType$2], [ptrType$1], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "MulRange", name: "MulRange", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$1], false)}, {prop: "Binomial", name: "Binomial", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$1], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Rem", name: "Rem", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "QuoRem", name: "QuoRem", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1, ptrType$1], false)}, {prop: "Div", name: "Div", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Mod", name: "Mod", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "DivMod", name: "DivMod", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1, ptrType$1], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType$1], [$Int], false)}, {prop: "CmpAbs", name: "CmpAbs", pkg: "", typ: $funcType([ptrType$1], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "IsInt64", name: "IsInt64", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsUint64", name: "IsUint64", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String, $Int], [ptrType$1, $Bool], false)}, {prop: "setFromScanner", name: "setFromScanner", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType$1, $Bool], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$1], [ptrType$1], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "BitLen", name: "BitLen", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Exp", name: "Exp", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "GCD", name: "GCD", pkg: "", typ: $funcType([ptrType$1, ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "lehmerGCD", name: "lehmerGCD", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1, ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Rand", name: "Rand", pkg: "", typ: $funcType([ptrType$6, ptrType$1], [ptrType$1], false)}, {prop: "ModInverse", name: "ModInverse", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrt3Mod4Prime", name: "modSqrt3Mod4Prime", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrt5Mod8Prime", name: "modSqrt5Mod8Prime", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "modSqrtTonelliShanks", name: "modSqrtTonelliShanks", pkg: "math/big", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "ModSqrt", name: "ModSqrt", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Lsh", name: "Lsh", pkg: "", typ: $funcType([ptrType$1, $Uint], [ptrType$1], false)}, {prop: "Rsh", name: "Rsh", pkg: "", typ: $funcType([ptrType$1, $Uint], [ptrType$1], false)}, {prop: "Bit", name: "Bit", pkg: "", typ: $funcType([$Int], [$Uint], false)}, {prop: "SetBit", name: "SetBit", pkg: "", typ: $funcType([ptrType$1, $Int, $Uint], [ptrType$1], false)}, {prop: "And", name: "And", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "AndNot", name: "AndNot", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Or", name: "Or", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Xor", name: "Xor", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$1], false)}, {prop: "Not", name: "Not", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Sqrt", name: "Sqrt", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Text", name: "Text", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$1, $Int], [sliceType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([fmt.State, $Int32], [], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int], [ptrType$1, $Int, $error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "ProbablyPrime", name: "ProbablyPrime", pkg: "", typ: $funcType([$Int], [$Bool], false)}]; - byteReader.methods = [{prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}]; - nat.methods = [{prop: "clear", name: "clear", pkg: "math/big", typ: $funcType([], [], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [nat], false)}, {prop: "make", name: "make", pkg: "math/big", typ: $funcType([$Int], [nat], false)}, {prop: "setWord", name: "setWord", pkg: "math/big", typ: $funcType([Word], [nat], false)}, {prop: "setUint64", name: "setUint64", pkg: "math/big", typ: $funcType([$Uint64], [nat], false)}, {prop: "set", name: "set", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "add", name: "add", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "sub", name: "sub", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "cmp", name: "cmp", pkg: "math/big", typ: $funcType([nat], [$Int], false)}, {prop: "mulAddWW", name: "mulAddWW", pkg: "math/big", typ: $funcType([nat, Word, Word], [nat], false)}, {prop: "montgomery", name: "montgomery", pkg: "math/big", typ: $funcType([nat, nat, nat, Word, $Int], [nat], false)}, {prop: "mul", name: "mul", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "sqr", name: "sqr", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "mulRange", name: "mulRange", pkg: "math/big", typ: $funcType([$Uint64, $Uint64], [nat], false)}, {prop: "divW", name: "divW", pkg: "math/big", typ: $funcType([nat, Word], [nat, Word], false)}, {prop: "div", name: "div", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "divLarge", name: "divLarge", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "bitLen", name: "bitLen", pkg: "math/big", typ: $funcType([], [$Int], false)}, {prop: "trailingZeroBits", name: "trailingZeroBits", pkg: "math/big", typ: $funcType([], [$Uint], false)}, {prop: "shl", name: "shl", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "shr", name: "shr", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "setBit", name: "setBit", pkg: "math/big", typ: $funcType([nat, $Uint, $Uint], [nat], false)}, {prop: "bit", name: "bit", pkg: "math/big", typ: $funcType([$Uint], [$Uint], false)}, {prop: "sticky", name: "sticky", pkg: "math/big", typ: $funcType([$Uint], [$Uint], false)}, {prop: "and", name: "and", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "andNot", name: "andNot", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "or", name: "or", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "xor", name: "xor", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "modW", name: "modW", pkg: "math/big", typ: $funcType([Word], [Word], false)}, {prop: "random", name: "random", pkg: "math/big", typ: $funcType([ptrType$6, nat, $Int], [nat], false)}, {prop: "expNN", name: "expNN", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "expNNWindowed", name: "expNNWindowed", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "expNNMontgomery", name: "expNNMontgomery", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "bytes", name: "bytes", pkg: "math/big", typ: $funcType([sliceType$1], [$Int], false)}, {prop: "setBytes", name: "setBytes", pkg: "math/big", typ: $funcType([sliceType$1], [nat], false)}, {prop: "sqrt", name: "sqrt", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.ByteScanner, $Int, $Bool], [nat, $Int, $Int, $error], false)}, {prop: "utoa", name: "utoa", pkg: "math/big", typ: $funcType([$Int], [sliceType$1], false)}, {prop: "itoa", name: "itoa", pkg: "math/big", typ: $funcType([$Bool, $Int], [sliceType$1], false)}, {prop: "convertWords", name: "convertWords", pkg: "math/big", typ: $funcType([sliceType$1, Word, $Int, Word, sliceType$3], [], false)}, {prop: "expWW", name: "expWW", pkg: "math/big", typ: $funcType([Word, Word], [nat], false)}, {prop: "probablyPrimeMillerRabin", name: "probablyPrimeMillerRabin", pkg: "math/big", typ: $funcType([$Int, $Bool], [$Bool], false)}, {prop: "probablyPrimeLucas", name: "probablyPrimeLucas", pkg: "math/big", typ: $funcType([], [$Bool], false)}]; - ptrType$2.methods = [{prop: "SetFloat64", name: "SetFloat64", pkg: "", typ: $funcType([$Float64], [ptrType$2], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32, $Bool], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $Bool], false)}, {prop: "SetFrac", name: "SetFrac", pkg: "", typ: $funcType([ptrType$1, ptrType$1], [ptrType$2], false)}, {prop: "SetFrac64", name: "SetFrac64", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$2], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([ptrType$1], [ptrType$2], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType$2], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Inv", name: "Inv", pkg: "", typ: $funcType([ptrType$2], [ptrType$2], false)}, {prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "IsInt", name: "IsInt", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Num", name: "Num", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Denom", name: "Denom", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [ptrType$2], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType$2], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType$2, ptrType$2], [ptrType$2], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [ptrType$2, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "marshal", name: "marshal", pkg: "math/big", typ: $funcType([], [sliceType$1], false)}, {prop: "RatString", name: "RatString", pkg: "", typ: $funcType([], [$String], false)}, {prop: "FloatString", name: "FloatString", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$1], [$error], false)}]; - decimal.init("math/big", [{prop: "mant", name: "mant", embedded: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int, tag: ""}]); - Float.init("math/big", [{prop: "prec", name: "prec", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "mode", name: "mode", embedded: false, exported: false, typ: RoundingMode, tag: ""}, {prop: "acc", name: "acc", embedded: false, exported: false, typ: Accuracy, tag: ""}, {prop: "form", name: "form", embedded: false, exported: false, typ: form, tag: ""}, {prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "mant", name: "mant", embedded: false, exported: false, typ: nat, tag: ""}, {prop: "exp", name: "exp", embedded: false, exported: false, typ: $Int32, tag: ""}]); - ErrNaN.init("math/big", [{prop: "msg", name: "msg", embedded: false, exported: false, typ: $String, tag: ""}]); - Int.init("math/big", [{prop: "neg", name: "neg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "abs", name: "abs", embedded: false, exported: false, typ: nat, tag: ""}]); - byteReader.init("", [{prop: "ScanState", name: "ScanState", embedded: true, exported: true, typ: fmt.ScanState, tag: ""}]); - nat.init(Word); - divisor.init("math/big", [{prop: "bbb", name: "bbb", embedded: false, exported: false, typ: nat, tag: ""}, {prop: "nbits", name: "nbits", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "ndigits", name: "ndigits", embedded: false, exported: false, typ: $Int, tag: ""}]); - Rat.init("math/big", [{prop: "a", name: "a", embedded: false, exported: false, typ: Int, tag: ""}, {prop: "b", name: "b", embedded: false, exported: false, typ: Int, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = binary.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = errors.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = nosync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = bits.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = rand.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strings.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - natPool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); - cacheBase10 = new structType.ptr(new nosync.Mutex.ptr(false), arrayType.zero()); - _Accuracy_index = $toNativeArray($kindUint8, [0, 5, 10, 15]); - pow5tab = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 5), new $Uint64(0, 25), new $Uint64(0, 125), new $Uint64(0, 625), new $Uint64(0, 3125), new $Uint64(0, 15625), new $Uint64(0, 78125), new $Uint64(0, 390625), new $Uint64(0, 1953125), new $Uint64(0, 9765625), new $Uint64(0, 48828125), new $Uint64(0, 244140625), new $Uint64(0, 1220703125), new $Uint64(1, 1808548329), new $Uint64(7, 452807053), new $Uint64(35, 2264035265), new $Uint64(177, 2730241733), new $Uint64(888, 766306777), new $Uint64(4440, 3831533885), new $Uint64(22204, 1977800241), new $Uint64(111022, 1299066613), new $Uint64(555111, 2200365769), new $Uint64(2775557, 2411894253), new $Uint64(13877787, 3469536673), new $Uint64(69388939, 167814181), new $Uint64(346944695, 839070905), new $Uint64(1734723475, 4195354525)]); - natOne = new nat([1]); - intOne = new Int.ptr(false, natOne); - natTwo = new nat([2]); - natTen = new nat([10]); - karatsubaThreshold = 40; - basicSqrThreshold = 20; - karatsubaSqrThreshold = 260; - leafSize = 8; - _RoundingMode_index = $toNativeArray($kindUint8, [0, 13, 26, 32, 44, 57, 70]); - _r = NewFloat(3); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - three = _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["regexp/syntax"] = (function() { - var $pkg = {}, $init, sort, strconv, strings, unicode, utf8, patchList, frag, compiler, Error, ErrorCode, Flags, parser, charGroup, ranges, Prog, InstOp, EmptyOp, Inst, Regexp, Op, sliceType, sliceType$1, sliceType$2, sliceType$3, ptrType, sliceType$4, ptrType$1, sliceType$5, arrayType, arrayType$1, ptrType$2, ptrType$3, ptrType$4, sliceType$6, ptrType$5, ptrType$6, ptrType$7, ptrType$8, anyRuneNotNL, anyRune, _Op_index_0, anyTable, code1, code2, code3, perlGroup, code4, code5, code6, code7, code8, code9, code10, code11, code12, code13, code14, code15, code16, code17, posixGroup, instOpNames, Compile, minFoldRune, repeatIsValid, cleanAlt, literalRegexp, Parse, isValidCaptureName, isCharClass, matchRune, mergeCharClass, unicodeTable, cleanClass, appendLiteral, appendRange, appendFoldedRange, appendClass, appendFoldedClass, appendNegatedClass, appendTable, appendNegatedTable, negateClass, checkUTF8, nextRune, isalnum, unhex, IsWordChar, bw, dumpProg, u32, dumpInst, writeRegexp, escape, simplify1; - sort = $packages["sort"]; - strconv = $packages["strconv"]; - strings = $packages["strings"]; - unicode = $packages["unicode"]; - utf8 = $packages["unicode/utf8"]; - patchList = $pkg.patchList = $newType(4, $kindUint32, "syntax.patchList", true, "regexp/syntax", false, null); - frag = $pkg.frag = $newType(0, $kindStruct, "syntax.frag", true, "regexp/syntax", false, function(i_, out_) { - this.$val = this; - if (arguments.length === 0) { - this.i = 0; - this.out = 0; - return; - } - this.i = i_; - this.out = out_; - }); - compiler = $pkg.compiler = $newType(0, $kindStruct, "syntax.compiler", true, "regexp/syntax", false, function(p_) { - this.$val = this; - if (arguments.length === 0) { - this.p = ptrType.nil; - return; - } - this.p = p_; - }); - Error = $pkg.Error = $newType(0, $kindStruct, "syntax.Error", true, "regexp/syntax", true, function(Code_, Expr_) { - this.$val = this; - if (arguments.length === 0) { - this.Code = ""; - this.Expr = ""; - return; - } - this.Code = Code_; - this.Expr = Expr_; - }); - ErrorCode = $pkg.ErrorCode = $newType(8, $kindString, "syntax.ErrorCode", true, "regexp/syntax", true, null); - Flags = $pkg.Flags = $newType(2, $kindUint16, "syntax.Flags", true, "regexp/syntax", true, null); - parser = $pkg.parser = $newType(0, $kindStruct, "syntax.parser", true, "regexp/syntax", false, function(flags_, stack_, free_, numCap_, wholeRegexp_, tmpClass_) { - this.$val = this; - if (arguments.length === 0) { - this.flags = 0; - this.stack = sliceType$5.nil; - this.free = ptrType$1.nil; - this.numCap = 0; - this.wholeRegexp = ""; - this.tmpClass = sliceType.nil; - return; - } - this.flags = flags_; - this.stack = stack_; - this.free = free_; - this.numCap = numCap_; - this.wholeRegexp = wholeRegexp_; - this.tmpClass = tmpClass_; - }); - charGroup = $pkg.charGroup = $newType(0, $kindStruct, "syntax.charGroup", true, "regexp/syntax", false, function(sign_, class$1_) { - this.$val = this; - if (arguments.length === 0) { - this.sign = 0; - this.class$1 = sliceType.nil; - return; - } - this.sign = sign_; - this.class$1 = class$1_; - }); - ranges = $pkg.ranges = $newType(0, $kindStruct, "syntax.ranges", true, "regexp/syntax", false, function(p_) { - this.$val = this; - if (arguments.length === 0) { - this.p = ptrType$2.nil; - return; - } - this.p = p_; - }); - Prog = $pkg.Prog = $newType(0, $kindStruct, "syntax.Prog", true, "regexp/syntax", true, function(Inst_, Start_, NumCap_) { - this.$val = this; - if (arguments.length === 0) { - this.Inst = sliceType$4.nil; - this.Start = 0; - this.NumCap = 0; - return; - } - this.Inst = Inst_; - this.Start = Start_; - this.NumCap = NumCap_; - }); - InstOp = $pkg.InstOp = $newType(1, $kindUint8, "syntax.InstOp", true, "regexp/syntax", true, null); - EmptyOp = $pkg.EmptyOp = $newType(1, $kindUint8, "syntax.EmptyOp", true, "regexp/syntax", true, null); - Inst = $pkg.Inst = $newType(0, $kindStruct, "syntax.Inst", true, "regexp/syntax", true, function(Op_, Out_, Arg_, Rune_) { - this.$val = this; - if (arguments.length === 0) { - this.Op = 0; - this.Out = 0; - this.Arg = 0; - this.Rune = sliceType.nil; - return; - } - this.Op = Op_; - this.Out = Out_; - this.Arg = Arg_; - this.Rune = Rune_; - }); - Regexp = $pkg.Regexp = $newType(0, $kindStruct, "syntax.Regexp", true, "regexp/syntax", true, function(Op_, Flags_, Sub_, Sub0_, Rune_, Rune0_, Min_, Max_, Cap_, Name_) { - this.$val = this; - if (arguments.length === 0) { - this.Op = 0; - this.Flags = 0; - this.Sub = sliceType$5.nil; - this.Sub0 = arrayType.zero(); - this.Rune = sliceType.nil; - this.Rune0 = arrayType$1.zero(); - this.Min = 0; - this.Max = 0; - this.Cap = 0; - this.Name = ""; - return; - } - this.Op = Op_; - this.Flags = Flags_; - this.Sub = Sub_; - this.Sub0 = Sub0_; - this.Rune = Rune_; - this.Rune0 = Rune0_; - this.Min = Min_; - this.Max = Max_; - this.Cap = Cap_; - this.Name = Name_; - }); - Op = $pkg.Op = $newType(1, $kindUint8, "syntax.Op", true, "regexp/syntax", true, null); - sliceType = $sliceType($Int32); - sliceType$1 = $sliceType(unicode.Range16); - sliceType$2 = $sliceType(unicode.Range32); - sliceType$3 = $sliceType($String); - ptrType = $ptrType(Prog); - sliceType$4 = $sliceType(Inst); - ptrType$1 = $ptrType(Regexp); - sliceType$5 = $sliceType(ptrType$1); - arrayType = $arrayType(ptrType$1, 1); - arrayType$1 = $arrayType($Int32, 2); - ptrType$2 = $ptrType(sliceType); - ptrType$3 = $ptrType(unicode.RangeTable); - ptrType$4 = $ptrType(strings.Builder); - sliceType$6 = $sliceType($Uint8); - ptrType$5 = $ptrType(compiler); - ptrType$6 = $ptrType(Error); - ptrType$7 = $ptrType(parser); - ptrType$8 = $ptrType(Inst); - patchList.prototype.next = function(p) { - var i, l, p, x, x$1; - l = this.$val; - i = (x = p.Inst, x$1 = l >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (((l & 1) >>> 0) === 0) { - return ((i.Out >>> 0)); - } - return ((i.Arg >>> 0)); - }; - $ptrType(patchList).prototype.next = function(p) { return new patchList(this.$get()).next(p); }; - patchList.prototype.patch = function(p, val) { - var i, l, p, val, x, x$1; - l = this.$val; - while (true) { - if (!(!((l === 0)))) { break; } - i = (x = p.Inst, x$1 = l >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (((l & 1) >>> 0) === 0) { - l = ((i.Out >>> 0)); - i.Out = val; - } else { - l = ((i.Arg >>> 0)); - i.Arg = val; - } - } - }; - $ptrType(patchList).prototype.patch = function(p, val) { return new patchList(this.$get()).patch(p, val); }; - patchList.prototype.append = function(p, l2) { - var i, l1, l2, last, next, p, x, x$1; - l1 = this.$val; - if (l1 === 0) { - return l2; - } - if (l2 === 0) { - return l1; - } - last = l1; - while (true) { - next = new patchList(last).next(p); - if (next === 0) { - break; - } - last = next; - } - i = (x = p.Inst, x$1 = last >>> 1 >>> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (((last & 1) >>> 0) === 0) { - i.Out = ((l2 >>> 0)); - } else { - i.Arg = ((l2 >>> 0)); - } - return l1; - }; - $ptrType(patchList).prototype.append = function(p, l2) { return new patchList(this.$get()).append(p, l2); }; - Compile = function(re) { - var c, f, re; - c = new compiler.ptr(ptrType.nil); - c.init(); - f = $clone(c.compile(re), frag); - new patchList(f.out).patch(c.p, c.inst(4).i); - c.p.Start = ((f.i >> 0)); - return [c.p, $ifaceNil]; - }; - $pkg.Compile = Compile; - compiler.ptr.prototype.init = function() { - var c; - c = this; - c.p = new Prog.ptr(sliceType$4.nil, 0, 0); - c.p.NumCap = 2; - c.inst(5); - }; - compiler.prototype.init = function() { return this.$val.init(); }; - compiler.ptr.prototype.compile = function(re) { - var _1, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, bra, c, f, f$1, f$2, f1, i, j, ket, re, sub, sub$1, sub$2, x, x$1, x$2, x$3; - c = this; - _1 = re.Op; - if (_1 === (1)) { - return c.fail(); - } else if (_1 === (2)) { - return c.nop(); - } else if (_1 === (3)) { - if (re.Rune.$length === 0) { - return c.nop(); - } - f = new frag.ptr(0, 0); - _ref = re.Rune; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - j = _i; - f1 = $clone(c.rune($subslice(re.Rune, j, (j + 1 >> 0)), re.Flags), frag); - if (j === 0) { - frag.copy(f, f1); - } else { - frag.copy(f, c.cat($clone(f, frag), $clone(f1, frag))); - } - _i++; - } - return f; - } else if (_1 === (4)) { - return c.rune(re.Rune, re.Flags); - } else if (_1 === (5)) { - return c.rune(anyRuneNotNL, 0); - } else if (_1 === (6)) { - return c.rune(anyRune, 0); - } else if (_1 === (7)) { - return c.empty(1); - } else if (_1 === (8)) { - return c.empty(2); - } else if (_1 === (9)) { - return c.empty(4); - } else if (_1 === (10)) { - return c.empty(8); - } else if (_1 === (11)) { - return c.empty(16); - } else if (_1 === (12)) { - return c.empty(32); - } else if (_1 === (13)) { - bra = $clone(c.cap((((re.Cap << 1 >> 0) >>> 0))), frag); - sub = $clone(c.compile((x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))), frag); - ket = $clone(c.cap(((((re.Cap << 1 >> 0) | 1) >>> 0))), frag); - return c.cat($clone(c.cat($clone(bra, frag), $clone(sub, frag)), frag), $clone(ket, frag)); - } else if (_1 === (14)) { - return c.star($clone(c.compile((x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); - } else if (_1 === (15)) { - return c.plus($clone(c.compile((x$2 = re.Sub, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); - } else if (_1 === (16)) { - return c.quest($clone(c.compile((x$3 = re.Sub, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0]))), frag), !((((re.Flags & 32) >>> 0) === 0))); - } else if (_1 === (18)) { - if (re.Sub.$length === 0) { - return c.nop(); - } - f$1 = new frag.ptr(0, 0); - _ref$1 = re.Sub; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i = _i$1; - sub$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - if (i === 0) { - frag.copy(f$1, c.compile(sub$1)); - } else { - frag.copy(f$1, c.cat($clone(f$1, frag), $clone(c.compile(sub$1), frag))); - } - _i$1++; - } - return f$1; - } else if (_1 === (19)) { - f$2 = new frag.ptr(0, 0); - _ref$2 = re.Sub; - _i$2 = 0; - while (true) { - if (!(_i$2 < _ref$2.$length)) { break; } - sub$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$2.$array[_ref$2.$offset + _i$2]); - frag.copy(f$2, c.alt($clone(f$2, frag), $clone(c.compile(sub$2), frag))); - _i$2++; - } - return f$2; - } - $panic(new $String("regexp: unhandled case in compile")); - }; - compiler.prototype.compile = function(re) { return this.$val.compile(re); }; - compiler.ptr.prototype.inst = function(op) { - var c, f, op; - c = this; - f = new frag.ptr(((c.p.Inst.$length >>> 0)), 0); - c.p.Inst = $append(c.p.Inst, new Inst.ptr(op, 0, 0, sliceType.nil)); - return f; - }; - compiler.prototype.inst = function(op) { return this.$val.inst(op); }; - compiler.ptr.prototype.nop = function() { - var c, f; - c = this; - f = $clone(c.inst(6), frag); - f.out = (((f.i << 1 >>> 0) >>> 0)); - return f; - }; - compiler.prototype.nop = function() { return this.$val.nop(); }; - compiler.ptr.prototype.fail = function() { - var c; - c = this; - return new frag.ptr(0, 0); - }; - compiler.prototype.fail = function() { return this.$val.fail(); }; - compiler.ptr.prototype.cap = function(arg) { - var arg, c, f, x, x$1; - c = this; - f = $clone(c.inst(2), frag); - f.out = (((f.i << 1 >>> 0) >>> 0)); - (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Arg = arg; - if (c.p.NumCap < (((arg >> 0)) + 1 >> 0)) { - c.p.NumCap = ((arg >> 0)) + 1 >> 0; - } - return f; - }; - compiler.prototype.cap = function(arg) { return this.$val.cap(arg); }; - compiler.ptr.prototype.cat = function(f1, f2) { - var c, f1, f2; - c = this; - if ((f1.i === 0) || (f2.i === 0)) { - return new frag.ptr(0, 0); - } - new patchList(f1.out).patch(c.p, f2.i); - return new frag.ptr(f1.i, f2.out); - }; - compiler.prototype.cat = function(f1, f2) { return this.$val.cat(f1, f2); }; - compiler.ptr.prototype.alt = function(f1, f2) { - var c, f, f1, f2, i, x, x$1; - c = this; - if (f1.i === 0) { - return f2; - } - if (f2.i === 0) { - return f1; - } - f = $clone(c.inst(0), frag); - i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - i.Out = f1.i; - i.Arg = f2.i; - f.out = new patchList(f1.out).append(c.p, f2.out); - return f; - }; - compiler.prototype.alt = function(f1, f2) { return this.$val.alt(f1, f2); }; - compiler.ptr.prototype.quest = function(f1, nongreedy) { - var c, f, f1, i, nongreedy, x, x$1; - c = this; - f = $clone(c.inst(0), frag); - i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (nongreedy) { - i.Arg = f1.i; - f.out = (((f.i << 1 >>> 0) >>> 0)); - } else { - i.Out = f1.i; - f.out = (((((f.i << 1 >>> 0) | 1) >>> 0) >>> 0)); - } - f.out = new patchList(f.out).append(c.p, f1.out); - return f; - }; - compiler.prototype.quest = function(f1, nongreedy) { return this.$val.quest(f1, nongreedy); }; - compiler.ptr.prototype.star = function(f1, nongreedy) { - var c, f, f1, i, nongreedy, x, x$1; - c = this; - f = $clone(c.inst(0), frag); - i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (nongreedy) { - i.Arg = f1.i; - f.out = (((f.i << 1 >>> 0) >>> 0)); - } else { - i.Out = f1.i; - f.out = (((((f.i << 1 >>> 0) | 1) >>> 0) >>> 0)); - } - new patchList(f1.out).patch(c.p, f.i); - return f; - }; - compiler.prototype.star = function(f1, nongreedy) { return this.$val.star(f1, nongreedy); }; - compiler.ptr.prototype.plus = function(f1, nongreedy) { - var c, f1, nongreedy; - c = this; - return new frag.ptr(f1.i, c.star($clone(f1, frag), nongreedy).out); - }; - compiler.prototype.plus = function(f1, nongreedy) { return this.$val.plus(f1, nongreedy); }; - compiler.ptr.prototype.empty = function(op) { - var c, f, op, x, x$1; - c = this; - f = $clone(c.inst(3), frag); - (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Arg = ((op >>> 0)); - f.out = (((f.i << 1 >>> 0) >>> 0)); - return f; - }; - compiler.prototype.empty = function(op) { return this.$val.empty(op); }; - compiler.ptr.prototype.rune = function(r, flags) { - var c, f, flags, i, r, x, x$1; - c = this; - f = $clone(c.inst(7), frag); - i = (x = c.p.Inst, x$1 = f.i, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - i.Rune = r; - flags = (flags & (1)) >>> 0; - if (!((r.$length === 1)) || (unicode.SimpleFold((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0])) === (0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]))) { - flags = (flags & ~(1)) << 16 >>> 16; - } - i.Arg = ((flags >>> 0)); - f.out = (((f.i << 1 >>> 0) >>> 0)); - if ((((flags & 1) >>> 0) === 0) && ((r.$length === 1) || (r.$length === 2) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === (1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1])))) { - i.Op = 8; - } else if ((r.$length === 2) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === 0) && ((1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1]) === 1114111)) { - i.Op = 9; - } else if ((r.$length === 4) && ((0 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 0]) === 0) && ((1 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 1]) === 9) && ((2 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 2]) === 11) && ((3 >= r.$length ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + 3]) === 1114111)) { - i.Op = 10; - } - return f; - }; - compiler.prototype.rune = function(r, flags) { return this.$val.rune(r, flags); }; - Op.prototype.String = function() { - var i, x; - i = this.$val; - if (1 <= i && i <= 19) { - i = i - (1) << 24 >>> 24; - return $substring("NoMatchEmptyMatchLiteralCharClassAnyCharNotNLAnyCharBeginLineEndLineBeginTextEndTextWordBoundaryNoWordBoundaryCaptureStarPlusQuestRepeatConcatAlternate", ((i < 0 || i >= _Op_index_0.length) ? ($throwRuntimeError("index out of range"), undefined) : _Op_index_0[i]), (x = i + 1 << 24 >>> 24, ((x < 0 || x >= _Op_index_0.length) ? ($throwRuntimeError("index out of range"), undefined) : _Op_index_0[x]))); - } else if ((i === 128)) { - return "opPseudo"; - } else { - return "Op(" + strconv.FormatInt((new $Int64(0, i)), 10) + ")"; - } - }; - $ptrType(Op).prototype.String = function() { return new Op(this.$get()).String(); }; - Error.ptr.prototype.Error = function() { - var e; - e = this; - return "error parsing regexp: " + new ErrorCode(e.Code).String() + ": `" + e.Expr + "`"; - }; - Error.prototype.Error = function() { return this.$val.Error(); }; - ErrorCode.prototype.String = function() { - var e; - e = this.$val; - return (e); - }; - $ptrType(ErrorCode).prototype.String = function() { return new ErrorCode(this.$get()).String(); }; - parser.ptr.prototype.newRegexp = function(op) { - var op, p, re; - p = this; - re = p.free; - if (!(re === ptrType$1.nil)) { - p.free = re.Sub0[0]; - Regexp.copy(re, new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, "")); - } else { - re = new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - } - re.Op = op; - return re; - }; - parser.prototype.newRegexp = function(op) { return this.$val.newRegexp(op); }; - parser.ptr.prototype.reuse = function(re) { - var p, re; - p = this; - re.Sub0[0] = p.free; - p.free = re; - }; - parser.prototype.reuse = function(re) { return this.$val.reuse(re); }; - parser.ptr.prototype.push = function(re) { - var p, re, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - p = this; - if ((re.Op === 4) && (re.Rune.$length === 2) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === (x$1 = re.Rune, (1 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 1])))) { - if (p.maybeConcat((x$16 = re.Rune, (0 >= x$16.$length ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + 0])), (p.flags & ~1) << 16 >>> 16)) { - return ptrType$1.nil; - } - re.Op = 3; - re.Rune = $subslice(re.Rune, 0, 1); - re.Flags = (p.flags & ~1) << 16 >>> 16; - } else if ((re.Op === 4) && (re.Rune.$length === 4) && ((x$2 = re.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) === (x$3 = re.Rune, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1]))) && ((x$4 = re.Rune, (2 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 2])) === (x$5 = re.Rune, (3 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 3]))) && (unicode.SimpleFold((x$6 = re.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))) === (x$7 = re.Rune, (2 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 2]))) && (unicode.SimpleFold((x$8 = re.Rune, (2 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 2]))) === (x$9 = re.Rune, (0 >= x$9.$length ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + 0]))) || (re.Op === 4) && (re.Rune.$length === 2) && (((x$10 = re.Rune, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0])) + 1 >> 0) === (x$11 = re.Rune, (1 >= x$11.$length ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + 1]))) && (unicode.SimpleFold((x$12 = re.Rune, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0]))) === (x$13 = re.Rune, (1 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 1]))) && (unicode.SimpleFold((x$14 = re.Rune, (1 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 1]))) === (x$15 = re.Rune, (0 >= x$15.$length ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + 0])))) { - if (p.maybeConcat((x$17 = re.Rune, (0 >= x$17.$length ? ($throwRuntimeError("index out of range"), undefined) : x$17.$array[x$17.$offset + 0])), (p.flags | 1) >>> 0)) { - return ptrType$1.nil; - } - re.Op = 3; - re.Rune = $subslice(re.Rune, 0, 1); - re.Flags = (p.flags | 1) >>> 0; - } else { - p.maybeConcat(-1, 0); - } - p.stack = $append(p.stack, re); - return re; - }; - parser.prototype.push = function(re) { return this.$val.push(re); }; - parser.ptr.prototype.maybeConcat = function(r, flags) { - var flags, n, p, r, re1, re2, x, x$1, x$2, x$3, x$4; - p = this; - n = p.stack.$length; - if (n < 2) { - return false; - } - re1 = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - re2 = (x$2 = p.stack, x$3 = n - 2 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])); - if (!((re1.Op === 3)) || !((re2.Op === 3)) || !((((re1.Flags & 1) >>> 0) === ((re2.Flags & 1) >>> 0)))) { - return false; - } - re2.Rune = $appendSlice(re2.Rune, re1.Rune); - if (r >= 0) { - re1.Rune = $subslice(new sliceType(re1.Rune0), 0, 1); - (x$4 = re1.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0] = r)); - re1.Flags = flags; - return true; - } - p.stack = $subslice(p.stack, 0, (n - 1 >> 0)); - p.reuse(re1); - return false; - }; - parser.prototype.maybeConcat = function(r, flags) { return this.$val.maybeConcat(r, flags); }; - parser.ptr.prototype.newLiteral = function(r, flags) { - var flags, p, r, re; - p = this; - re = p.newRegexp(3); - re.Flags = flags; - if (!((((flags & 1) >>> 0) === 0))) { - r = minFoldRune(r); - } - re.Rune0[0] = r; - re.Rune = $subslice(new sliceType(re.Rune0), 0, 1); - return re; - }; - parser.prototype.newLiteral = function(r, flags) { return this.$val.newLiteral(r, flags); }; - minFoldRune = function(r) { - var min, r, r0; - if (r < 65 || r > 125251) { - return r; - } - min = r; - r0 = r; - r = unicode.SimpleFold(r); - while (true) { - if (!(!((r === r0)))) { break; } - if (min > r) { - min = r; - } - r = unicode.SimpleFold(r); - } - return min; - }; - parser.ptr.prototype.literal = function(r) { - var p, r; - p = this; - p.push(p.newLiteral(r, p.flags)); - }; - parser.prototype.literal = function(r) { return this.$val.literal(r); }; - parser.ptr.prototype.op = function(op) { - var op, p, re; - p = this; - re = p.newRegexp(op); - re.Flags = p.flags; - return p.push(re); - }; - parser.prototype.op = function(op) { return this.$val.op(op); }; - parser.ptr.prototype.repeat = function(op, min, max, before, after, lastRepeat) { - var after, before, flags, lastRepeat, max, min, n, op, p, re, sub, x, x$1, x$2, x$3, x$4; - p = this; - flags = p.flags; - if (!((((p.flags & 64) >>> 0) === 0))) { - if (after.length > 0 && (after.charCodeAt(0) === 63)) { - after = $substring(after, 1); - flags = (flags ^ (32)) << 16 >>> 16; - } - if (!(lastRepeat === "")) { - return ["", new Error.ptr("invalid nested repetition operator", $substring(lastRepeat, 0, (lastRepeat.length - after.length >> 0)))]; - } - } - n = p.stack.$length; - if (n === 0) { - return ["", new Error.ptr("missing argument to repetition operator", $substring(before, 0, (before.length - after.length >> 0)))]; - } - sub = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (sub.Op >= 128) { - return ["", new Error.ptr("missing argument to repetition operator", $substring(before, 0, (before.length - after.length >> 0)))]; - } - re = p.newRegexp(op); - re.Min = min; - re.Max = max; - re.Flags = flags; - re.Sub = $subslice(new sliceType$5(re.Sub0), 0, 1); - (x$2 = re.Sub, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0] = sub)); - (x$3 = p.stack, x$4 = n - 1 >> 0, ((x$4 < 0 || x$4 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + x$4] = re)); - if ((op === 17) && (min >= 2 || max >= 2) && !repeatIsValid(re, 1000)) { - return ["", new Error.ptr("invalid repeat count", $substring(before, 0, (before.length - after.length >> 0)))]; - } - return [after, $ifaceNil]; - }; - parser.prototype.repeat = function(op, min, max, before, after, lastRepeat) { return this.$val.repeat(op, min, max, before, after, lastRepeat); }; - repeatIsValid = function(re, n) { - var _i, _q, _ref, m, n, re, sub; - if (re.Op === 17) { - m = re.Max; - if (m === 0) { - return true; - } - if (m < 0) { - m = re.Min; - } - if (m > n) { - return false; - } - if (m > 0) { - n = (_q = n / (m), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - } - } - _ref = re.Sub; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!repeatIsValid(sub, n)) { - return false; - } - _i++; - } - return true; - }; - parser.ptr.prototype.concat = function() { - var _r, _r$1, i, p, subs, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; p = $f.p; subs = $f.subs; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - p.maybeConcat(-1, 0); - i = p.stack.$length; - while (true) { - if (!(i > 0 && (x = p.stack, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op < 128)) { break; } - i = i - (1) >> 0; - } - subs = $subslice(p.stack, i); - p.stack = $subslice(p.stack, 0, i); - if (subs.$length === 0) { - $s = -1; return p.push(p.newRegexp(2)); - } - _r = p.collapse(subs, 18); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = p.push(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.concat }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.p = p; $f.subs = subs; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.concat = function() { return this.$val.concat(); }; - parser.ptr.prototype.alternate = function() { - var _r, _r$1, i, p, subs, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; p = $f.p; subs = $f.subs; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - i = p.stack.$length; - while (true) { - if (!(i > 0 && (x = p.stack, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op < 128)) { break; } - i = i - (1) >> 0; - } - subs = $subslice(p.stack, i); - p.stack = $subslice(p.stack, 0, i); - /* */ if (subs.$length > 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (subs.$length > 0) { */ case 1: - $r = cleanAlt((x$2 = subs.$length - 1 >> 0, ((x$2 < 0 || x$2 >= subs.$length) ? ($throwRuntimeError("index out of range"), undefined) : subs.$array[subs.$offset + x$2]))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 2: - if (subs.$length === 0) { - $s = -1; return p.push(p.newRegexp(1)); - } - _r = p.collapse(subs, 19); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = p.push(_r); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.alternate }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.p = p; $f.subs = subs; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.alternate = function() { return this.$val.alternate(); }; - cleanAlt = function(re) { - var _1, _r, re, x, x$1, x$2, x$3, x$4, x$5, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; re = $f.re; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _1 = re.Op; - /* */ if (_1 === (4)) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (_1 === (4)) { */ case 2: - _r = cleanClass((re.$ptr_Rune || (re.$ptr_Rune = new ptrType$2(function() { return this.$target.Rune; }, function($v) { this.$target.Rune = $v; }, re)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - re.Rune = _r; - if ((re.Rune.$length === 2) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === 0) && ((x$1 = re.Rune, (1 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 1])) === 1114111)) { - re.Rune = sliceType.nil; - re.Op = 6; - $s = -1; return; - } - if ((re.Rune.$length === 4) && ((x$2 = re.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])) === 0) && ((x$3 = re.Rune, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1])) === 9) && ((x$4 = re.Rune, (2 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 2])) === 11) && ((x$5 = re.Rune, (3 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 3])) === 1114111)) { - re.Rune = sliceType.nil; - re.Op = 5; - $s = -1; return; - } - if ((re.Rune.$capacity - re.Rune.$length >> 0) > 100) { - re.Rune = $appendSlice($subslice(new sliceType(re.Rune0), 0, 0), re.Rune); - } - /* } */ case 3: - case 1: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: cleanAlt }; } $f._1 = _1; $f._r = _r; $f.re = re; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.ptr.prototype.collapse = function(subs, op) { - var _i, _r, _ref, old, op, p, re, sub, subs, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; old = $f.old; op = $f.op; p = $f.p; re = $f.re; sub = $f.sub; subs = $f.subs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - if (subs.$length === 1) { - $s = -1; return (0 >= subs.$length ? ($throwRuntimeError("index out of range"), undefined) : subs.$array[subs.$offset + 0]); - } - re = p.newRegexp(op); - re.Sub = $subslice(new sliceType$5(re.Sub0), 0, 0); - _ref = subs; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (sub.Op === op) { - re.Sub = $appendSlice(re.Sub, sub.Sub); - p.reuse(sub); - } else { - re.Sub = $append(re.Sub, sub); - } - _i++; - } - /* */ if (op === 19) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (op === 19) { */ case 1: - _r = p.factor(re.Sub); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - re.Sub = _r; - if (re.Sub.$length === 1) { - old = re; - re = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - p.reuse(old); - } - /* } */ case 2: - $s = -1; return re; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.collapse }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.old = old; $f.op = op; $f.p = p; $f.re = re; $f.sub = sub; $f.subs = subs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.collapse = function(subs, op) { return this.$val.collapse(subs, op); }; - parser.ptr.prototype.factor = function(sub) { - var _i, _r, _r$1, _ref, _tmp, _tmp$1, _tuple, first, i, i$1, i$2, i$3, ifirst, iflags, istr, j, j$1, j$2, j$3, max, out, p, prefix, prefix$1, re, re$1, reuse, same, start, str, strflags, sub, suffix, suffix$1, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; first = $f.first; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; ifirst = $f.ifirst; iflags = $f.iflags; istr = $f.istr; j = $f.j; j$1 = $f.j$1; j$2 = $f.j$2; j$3 = $f.j$3; max = $f.max; out = $f.out; p = $f.p; prefix = $f.prefix; prefix$1 = $f.prefix$1; re = $f.re; re$1 = $f.re$1; reuse = $f.reuse; same = $f.same; start = $f.start; str = $f.str; strflags = $f.strflags; sub = $f.sub; suffix = $f.suffix; suffix$1 = $f.suffix$1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - if (sub.$length < 2) { - $s = -1; return sub; - } - str = sliceType.nil; - strflags = 0; - start = 0; - out = $subslice(sub, 0, 0); - i = 0; - /* while (true) { */ case 1: - /* if (!(i <= sub.$length)) { break; } */ if(!(i <= sub.$length)) { $s = 2; continue; } - istr = sliceType.nil; - iflags = 0; - /* */ if (i < sub.$length) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (i < sub.$length) { */ case 3: - _tuple = p.leadingString(((i < 0 || i >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i])); - istr = _tuple[0]; - iflags = _tuple[1]; - if (iflags === strflags) { - same = 0; - while (true) { - if (!(same < str.$length && same < istr.$length && (((same < 0 || same >= str.$length) ? ($throwRuntimeError("index out of range"), undefined) : str.$array[str.$offset + same]) === ((same < 0 || same >= istr.$length) ? ($throwRuntimeError("index out of range"), undefined) : istr.$array[istr.$offset + same])))) { break; } - same = same + (1) >> 0; - } - if (same > 0) { - str = $subslice(str, 0, same); - i = i + (1) >> 0; - /* continue; */ $s = 1; continue; - } - } - /* } */ case 4: - /* */ if (i === start) { $s = 5; continue; } - /* */ if (i === (start + 1 >> 0)) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (i === start) { */ case 5: - $s = 8; continue; - /* } else if (i === (start + 1 >> 0)) { */ case 6: - out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); - $s = 8; continue; - /* } else { */ case 7: - prefix = p.newRegexp(3); - prefix.Flags = strflags; - prefix.Rune = $appendSlice($subslice(prefix.Rune, 0, 0), str); - j = start; - while (true) { - if (!(j < i)) { break; } - ((j < 0 || j >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j] = p.removeLeadingString(((j < 0 || j >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j]), str.$length)); - j = j + (1) >> 0; - } - _r = p.collapse($subslice(sub, start, i), 19); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - suffix = _r; - re = p.newRegexp(18); - re.Sub = $append($subslice(re.Sub, 0, 0), prefix, suffix); - out = $append(out, re); - /* } */ case 8: - start = i; - str = istr; - strflags = iflags; - i = i + (1) >> 0; - /* } */ $s = 1; continue; case 2: - sub = out; - start = 0; - out = $subslice(sub, 0, 0); - first = ptrType$1.nil; - i$1 = 0; - /* while (true) { */ case 10: - /* if (!(i$1 <= sub.$length)) { break; } */ if(!(i$1 <= sub.$length)) { $s = 11; continue; } - ifirst = ptrType$1.nil; - /* */ if (i$1 < sub.$length) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (i$1 < sub.$length) { */ case 12: - ifirst = p.leadingRegexp(((i$1 < 0 || i$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$1])); - if (!(first === ptrType$1.nil) && first.Equal(ifirst) && (isCharClass(first) || ((first.Op === 17) && (first.Min === first.Max) && isCharClass((x = first.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])))))) { - i$1 = i$1 + (1) >> 0; - /* continue; */ $s = 10; continue; - } - /* } */ case 13: - /* */ if (i$1 === start) { $s = 14; continue; } - /* */ if (i$1 === (start + 1 >> 0)) { $s = 15; continue; } - /* */ $s = 16; continue; - /* if (i$1 === start) { */ case 14: - $s = 17; continue; - /* } else if (i$1 === (start + 1 >> 0)) { */ case 15: - out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); - $s = 17; continue; - /* } else { */ case 16: - prefix$1 = first; - j$1 = start; - while (true) { - if (!(j$1 < i$1)) { break; } - reuse = !((j$1 === start)); - ((j$1 < 0 || j$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$1] = p.removeLeadingRegexp(((j$1 < 0 || j$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$1]), reuse)); - j$1 = j$1 + (1) >> 0; - } - _r$1 = p.collapse($subslice(sub, start, i$1), 19); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - suffix$1 = _r$1; - re$1 = p.newRegexp(18); - re$1.Sub = $append($subslice(re$1.Sub, 0, 0), prefix$1, suffix$1); - out = $append(out, re$1); - /* } */ case 17: - start = i$1; - first = ifirst; - i$1 = i$1 + (1) >> 0; - /* } */ $s = 10; continue; case 11: - sub = out; - start = 0; - out = $subslice(sub, 0, 0); - i$2 = 0; - /* while (true) { */ case 19: - /* if (!(i$2 <= sub.$length)) { break; } */ if(!(i$2 <= sub.$length)) { $s = 20; continue; } - /* */ if (i$2 < sub.$length && isCharClass(((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2]))) { $s = 21; continue; } - /* */ $s = 22; continue; - /* if (i$2 < sub.$length && isCharClass(((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2]))) { */ case 21: - i$2 = i$2 + (1) >> 0; - /* continue; */ $s = 19; continue; - /* } */ case 22: - /* */ if (i$2 === start) { $s = 23; continue; } - /* */ if (i$2 === (start + 1 >> 0)) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (i$2 === start) { */ case 23: - $s = 26; continue; - /* } else if (i$2 === (start + 1 >> 0)) { */ case 24: - out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); - $s = 26; continue; - /* } else { */ case 25: - max = start; - j$2 = start + 1 >> 0; - while (true) { - if (!(j$2 < i$2)) { break; } - if (((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Op < ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Op || (((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Op === ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Op) && ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]).Rune.$length < ((j$2 < 0 || j$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$2]).Rune.$length) { - max = j$2; - } - j$2 = j$2 + (1) >> 0; - } - _tmp = ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max]); - _tmp$1 = ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start]); - ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start] = _tmp); - ((max < 0 || max >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + max] = _tmp$1); - j$3 = start + 1 >> 0; - while (true) { - if (!(j$3 < i$2)) { break; } - mergeCharClass(((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start]), ((j$3 < 0 || j$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$3])); - p.reuse(((j$3 < 0 || j$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + j$3])); - j$3 = j$3 + (1) >> 0; - } - $r = cleanAlt(((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - out = $append(out, ((start < 0 || start >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + start])); - /* } */ case 26: - if (i$2 < sub.$length) { - out = $append(out, ((i$2 < 0 || i$2 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$2])); - } - start = i$2 + 1 >> 0; - i$2 = i$2 + (1) >> 0; - /* } */ $s = 19; continue; case 20: - sub = out; - start = 0; - out = $subslice(sub, 0, 0); - _ref = sub; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i$3 = _i; - if ((i$3 + 1 >> 0) < sub.$length && (((i$3 < 0 || i$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$3]).Op === 2) && ((x$1 = i$3 + 1 >> 0, ((x$1 < 0 || x$1 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + x$1])).Op === 2)) { - _i++; - continue; - } - out = $append(out, ((i$3 < 0 || i$3 >= sub.$length) ? ($throwRuntimeError("index out of range"), undefined) : sub.$array[sub.$offset + i$3])); - _i++; - } - sub = out; - $s = -1; return sub; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.factor }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.first = first; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.ifirst = ifirst; $f.iflags = iflags; $f.istr = istr; $f.j = j; $f.j$1 = j$1; $f.j$2 = j$2; $f.j$3 = j$3; $f.max = max; $f.out = out; $f.p = p; $f.prefix = prefix; $f.prefix$1 = prefix$1; $f.re = re; $f.re$1 = re$1; $f.reuse = reuse; $f.same = same; $f.start = start; $f.str = str; $f.strflags = strflags; $f.sub = sub; $f.suffix = suffix; $f.suffix$1 = suffix$1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.factor = function(sub) { return this.$val.factor(sub); }; - parser.ptr.prototype.leadingString = function(re) { - var p, re, x; - p = this; - if ((re.Op === 18) && re.Sub.$length > 0) { - re = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - } - if (!((re.Op === 3))) { - return [sliceType.nil, 0]; - } - return [re.Rune, (re.Flags & 1) >>> 0]; - }; - parser.prototype.leadingString = function(re) { return this.$val.leadingString(re); }; - parser.ptr.prototype.removeLeadingString = function(re, n) { - var _1, n, old, p, re, sub, x, x$1, x$2; - p = this; - if ((re.Op === 18) && re.Sub.$length > 0) { - sub = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - sub = p.removeLeadingString(sub, n); - (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = sub)); - if (sub.Op === 2) { - p.reuse(sub); - _1 = re.Sub.$length; - if ((_1 === (0)) || (_1 === (1))) { - re.Op = 2; - re.Sub = sliceType$5.nil; - } else if (_1 === (2)) { - old = re; - re = (x$2 = re.Sub, (1 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 1])); - p.reuse(old); - } else { - $copySlice(re.Sub, $subslice(re.Sub, 1)); - re.Sub = $subslice(re.Sub, 0, (re.Sub.$length - 1 >> 0)); - } - } - return re; - } - if (re.Op === 3) { - re.Rune = $subslice(re.Rune, 0, $copySlice(re.Rune, $subslice(re.Rune, n))); - if (re.Rune.$length === 0) { - re.Op = 2; - } - } - return re; - }; - parser.prototype.removeLeadingString = function(re, n) { return this.$val.removeLeadingString(re, n); }; - parser.ptr.prototype.leadingRegexp = function(re) { - var p, re, sub, x; - p = this; - if (re.Op === 2) { - return ptrType$1.nil; - } - if ((re.Op === 18) && re.Sub.$length > 0) { - sub = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); - if (sub.Op === 2) { - return ptrType$1.nil; - } - return sub; - } - return re; - }; - parser.prototype.leadingRegexp = function(re) { return this.$val.leadingRegexp(re); }; - parser.ptr.prototype.removeLeadingRegexp = function(re, reuse) { - var _1, old, p, re, reuse, x, x$1; - p = this; - if ((re.Op === 18) && re.Sub.$length > 0) { - if (reuse) { - p.reuse((x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))); - } - re.Sub = $subslice(re.Sub, 0, $copySlice(re.Sub, $subslice(re.Sub, 1))); - _1 = re.Sub.$length; - if (_1 === (0)) { - re.Op = 2; - re.Sub = sliceType$5.nil; - } else if (_1 === (1)) { - old = re; - re = (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])); - p.reuse(old); - } - return re; - } - if (reuse) { - p.reuse(re); - } - return p.newRegexp(2); - }; - parser.prototype.removeLeadingRegexp = function(re, reuse) { return this.$val.removeLeadingRegexp(re, reuse); }; - literalRegexp = function(s, flags) { - var _i, _ref, _rune, c, flags, re, s; - re = new Regexp.ptr(3, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - re.Flags = flags; - re.Rune = $subslice(new sliceType(re.Rune0), 0, 0); - _ref = s; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - c = _rune[0]; - if (re.Rune.$length >= re.Rune.$capacity) { - re.Rune = (new sliceType($stringToRunes(s))); - break; - } - re.Rune = $append(re.Rune, c); - _i += _rune[1]; - } - return re; - }; - Parse = function(s, flags) { - var _1, _2, _3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _struct, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, after, after$1, before, before$1, c, c$1, err, err$1, err$2, err$3, flags, i, lastRepeat, lit, max, min, n, ok, op, p, r, r$1, re, repeat, rest, rest$1, rest$2, s, t, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _struct = $f._struct; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; after = $f.after; after$1 = $f.after$1; before = $f.before; before$1 = $f.before$1; c = $f.c; c$1 = $f.c$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; flags = $f.flags; i = $f.i; lastRepeat = $f.lastRepeat; lit = $f.lit; max = $f.max; min = $f.min; n = $f.n; ok = $f.ok; op = $f.op; p = $f.p; r = $f.r; r$1 = $f.r$1; re = $f.re; repeat = $f.repeat; rest = $f.rest; rest$1 = $f.rest$1; rest$2 = $f.rest$2; s = $f.s; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - if (!((((flags & 2) >>> 0) === 0))) { - err = checkUTF8(s); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err]; - } - $s = -1; return [literalRegexp(s, flags), $ifaceNil]; - } - p = new parser.ptr(0, sliceType$5.nil, ptrType$1.nil, 0, "", sliceType.nil); - err$1 = $ifaceNil; - c = 0; - op = 0; - lastRepeat = ""; - p.flags = flags; - p.wholeRegexp = s; - t = s; - /* while (true) { */ case 1: - /* if (!(!(t === ""))) { break; } */ if(!(!(t === ""))) { $s = 2; continue; } - repeat = ""; - _1 = t.charCodeAt(0); - /* */ if (_1 === (40)) { $s = 4; continue; } - /* */ if (_1 === (124)) { $s = 5; continue; } - /* */ if (_1 === (41)) { $s = 6; continue; } - /* */ if (_1 === (94)) { $s = 7; continue; } - /* */ if (_1 === (36)) { $s = 8; continue; } - /* */ if (_1 === (46)) { $s = 9; continue; } - /* */ if (_1 === (91)) { $s = 10; continue; } - /* */ if ((_1 === (42)) || (_1 === (43)) || (_1 === (63))) { $s = 11; continue; } - /* */ if (_1 === (123)) { $s = 12; continue; } - /* */ if (_1 === (92)) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (_1 === (40)) { */ case 4: - if (!((((p.flags & 64) >>> 0) === 0)) && t.length >= 2 && (t.charCodeAt(1) === 63)) { - _tuple = p.parsePerlFlags(t); - t = _tuple[0]; - err$1 = _tuple[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - /* break; */ $s = 3; continue; - } - p.numCap = p.numCap + (1) >> 0; - p.op(128).Cap = p.numCap; - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (124)) { */ case 5: - _r = p.parseVerticalBar(); /* */ $s = 16; case 16: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - err$1 = _r; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (41)) { */ case 6: - _r$1 = p.parseRightParen(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - err$1 = _r$1; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (94)) { */ case 7: - if (!((((p.flags & 16) >>> 0) === 0))) { - p.op(9); - } else { - p.op(7); - } - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (36)) { */ case 8: - if (!((((p.flags & 16) >>> 0) === 0))) { - _struct = p.op(10); - _struct.Flags = (_struct.Flags | (256)) >>> 0; - } else { - p.op(8); - } - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (46)) { */ case 9: - if (!((((p.flags & 8) >>> 0) === 0))) { - p.op(6); - } else { - p.op(5); - } - t = $substring(t, 1); - $s = 15; continue; - /* } else if (_1 === (91)) { */ case 10: - _r$2 = p.parseClass(t); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$1 = _r$2; - t = _tuple$1[0]; - err$1 = _tuple$1[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - $s = 15; continue; - /* } else if ((_1 === (42)) || (_1 === (43)) || (_1 === (63))) { */ case 11: - before = t; - _2 = t.charCodeAt(0); - if (_2 === (42)) { - op = 14; - } else if (_2 === (43)) { - op = 15; - } else if (_2 === (63)) { - op = 16; - } - after = $substring(t, 1); - _tuple$2 = p.repeat(op, 0, 0, before, after, lastRepeat); - after = _tuple$2[0]; - err$1 = _tuple$2[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - repeat = before; - t = after; - $s = 15; continue; - /* } else if (_1 === (123)) { */ case 12: - op = 17; - before$1 = t; - _tuple$3 = p.parseRepeat(t); - min = _tuple$3[0]; - max = _tuple$3[1]; - after$1 = _tuple$3[2]; - ok = _tuple$3[3]; - if (!ok) { - p.literal(123); - t = $substring(t, 1); - /* break; */ $s = 3; continue; - } - if (min < 0 || min > 1000 || max > 1000 || max >= 0 && min > max) { - $s = -1; return [ptrType$1.nil, new Error.ptr("invalid repeat count", $substring(before$1, 0, (before$1.length - after$1.length >> 0)))]; - } - _tuple$4 = p.repeat(op, min, max, before$1, after$1, lastRepeat); - after$1 = _tuple$4[0]; - err$1 = _tuple$4[1]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - repeat = before$1; - t = after$1; - $s = 15; continue; - /* } else if (_1 === (92)) { */ case 13: - if (!((((p.flags & 64) >>> 0) === 0)) && t.length >= 2) { - _3 = t.charCodeAt(1); - if (_3 === (65)) { - p.op(9); - t = $substring(t, 2); - /* break BigSwitch; */ $s = 3; continue s; - } else if (_3 === (98)) { - p.op(11); - t = $substring(t, 2); - /* break BigSwitch; */ $s = 3; continue s; - } else if (_3 === (66)) { - p.op(12); - t = $substring(t, 2); - /* break BigSwitch; */ $s = 3; continue s; - } else if (_3 === (67)) { - $s = -1; return [ptrType$1.nil, new Error.ptr("invalid escape sequence", $substring(t, 0, 2))]; - } else if (_3 === (81)) { - lit = ""; - i = strings.Index(t, "\\E"); - if (i < 0) { - lit = $substring(t, 2); - t = ""; - } else { - lit = $substring(t, 2, i); - t = $substring(t, (i + 2 >> 0)); - } - while (true) { - if (!(!(lit === ""))) { break; } - _tuple$5 = nextRune(lit); - c$1 = _tuple$5[0]; - rest = _tuple$5[1]; - err$2 = _tuple$5[2]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$2]; - } - p.literal(c$1); - lit = rest; - } - /* break BigSwitch; */ $s = 3; continue s; - } else if (_3 === (122)) { - p.op(10); - t = $substring(t, 2); - /* break BigSwitch; */ $s = 3; continue s; - } - } - re = p.newRegexp(4); - re.Flags = p.flags; - /* */ if (t.length >= 2 && ((t.charCodeAt(1) === 112) || (t.charCodeAt(1) === 80))) { $s = 19; continue; } - /* */ $s = 20; continue; - /* if (t.length >= 2 && ((t.charCodeAt(1) === 112) || (t.charCodeAt(1) === 80))) { */ case 19: - _r$3 = p.parseUnicodeClass(t, $subslice(new sliceType(re.Rune0), 0, 0)); /* */ $s = 21; case 21: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$6 = _r$3; - r = _tuple$6[0]; - rest$1 = _tuple$6[1]; - err$3 = _tuple$6[2]; - if (!($interfaceIsEqual(err$3, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$3]; - } - if (!(r === sliceType.nil)) { - re.Rune = r; - t = rest$1; - p.push(re); - /* break BigSwitch; */ $s = 3; continue s; - } - /* } */ case 20: - _r$4 = p.parsePerlClassEscape(t, $subslice(new sliceType(re.Rune0), 0, 0)); /* */ $s = 22; case 22: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$7 = _r$4; - r$1 = _tuple$7[0]; - rest$2 = _tuple$7[1]; - if (!(r$1 === sliceType.nil)) { - re.Rune = r$1; - t = rest$2; - p.push(re); - /* break BigSwitch; */ $s = 3; continue s; - } - p.reuse(re); - _tuple$8 = p.parseEscape(t); - c = _tuple$8[0]; - t = _tuple$8[1]; - err$1 = _tuple$8[2]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - p.literal(c); - $s = 15; continue; - /* } else { */ case 14: - _tuple$9 = nextRune(t); - c = _tuple$9[0]; - t = _tuple$9[1]; - err$1 = _tuple$9[2]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - $s = -1; return [ptrType$1.nil, err$1]; - } - p.literal(c); - /* } */ case 15: - case 3: - lastRepeat = repeat; - /* } */ $s = 1; continue; case 2: - _r$5 = p.concat(); /* */ $s = 23; case 23: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _r$5; - _r$6 = p.swapVerticalBar(); /* */ $s = 26; case 26: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - /* */ if (_r$6) { $s = 24; continue; } - /* */ $s = 25; continue; - /* if (_r$6) { */ case 24: - p.stack = $subslice(p.stack, 0, (p.stack.$length - 1 >> 0)); - /* } */ case 25: - _r$7 = p.alternate(); /* */ $s = 27; case 27: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _r$7; - n = p.stack.$length; - if (!((n === 1))) { - $s = -1; return [ptrType$1.nil, new Error.ptr("missing closing )", s)]; - } - $s = -1; return [(x = p.stack, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])), $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._struct = _struct; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.after = after; $f.after$1 = after$1; $f.before = before; $f.before$1 = before$1; $f.c = c; $f.c$1 = c$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.flags = flags; $f.i = i; $f.lastRepeat = lastRepeat; $f.lit = lit; $f.max = max; $f.min = min; $f.n = n; $f.ok = ok; $f.op = op; $f.p = p; $f.r = r; $f.r$1 = r$1; $f.re = re; $f.repeat = repeat; $f.rest = rest; $f.rest$1 = rest$1; $f.rest$2 = rest$2; $f.s = s; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Parse = Parse; - parser.ptr.prototype.parseRepeat = function(s) { - var _tuple, _tuple$1, max, min, ok, ok1, p, rest, s; - min = 0; - max = 0; - rest = ""; - ok = false; - p = this; - if (s === "" || !((s.charCodeAt(0) === 123))) { - return [min, max, rest, ok]; - } - s = $substring(s, 1); - ok1 = false; - _tuple = p.parseInt(s); - min = _tuple[0]; - s = _tuple[1]; - ok1 = _tuple[2]; - if (!ok1) { - return [min, max, rest, ok]; - } - if (s === "") { - return [min, max, rest, ok]; - } - if (!((s.charCodeAt(0) === 44))) { - max = min; - } else { - s = $substring(s, 1); - if (s === "") { - return [min, max, rest, ok]; - } - if (s.charCodeAt(0) === 125) { - max = -1; - } else { - _tuple$1 = p.parseInt(s); - max = _tuple$1[0]; - s = _tuple$1[1]; - ok1 = _tuple$1[2]; - if (!ok1) { - return [min, max, rest, ok]; - } else if (max < 0) { - min = -1; - } - } - } - if (s === "" || !((s.charCodeAt(0) === 125))) { - return [min, max, rest, ok]; - } - rest = $substring(s, 1); - ok = true; - return [min, max, rest, ok]; - }; - parser.prototype.parseRepeat = function(s) { return this.$val.parseRepeat(s); }; - parser.ptr.prototype.parsePerlFlags = function(s) { - var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, c, capture, end, err, flags, name, p, re, rest, s, sawFlag, sign, t; - rest = ""; - err = $ifaceNil; - p = this; - t = s; - if (t.length > 4 && (t.charCodeAt(2) === 80) && (t.charCodeAt(3) === 60)) { - end = strings.IndexRune(t, 62); - if (end < 0) { - err = checkUTF8(t); - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp = ""; - _tmp$1 = err; - rest = _tmp; - err = _tmp$1; - return [rest, err]; - } - _tmp$2 = ""; - _tmp$3 = new Error.ptr("invalid named capture", s); - rest = _tmp$2; - err = _tmp$3; - return [rest, err]; - } - capture = $substring(t, 0, (end + 1 >> 0)); - name = $substring(t, 4, end); - err = checkUTF8(name); - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$4 = ""; - _tmp$5 = err; - rest = _tmp$4; - err = _tmp$5; - return [rest, err]; - } - if (!isValidCaptureName(name)) { - _tmp$6 = ""; - _tmp$7 = new Error.ptr("invalid named capture", capture); - rest = _tmp$6; - err = _tmp$7; - return [rest, err]; - } - p.numCap = p.numCap + (1) >> 0; - re = p.op(128); - re.Cap = p.numCap; - re.Name = name; - _tmp$8 = $substring(t, (end + 1 >> 0)); - _tmp$9 = $ifaceNil; - rest = _tmp$8; - err = _tmp$9; - return [rest, err]; - } - c = 0; - t = $substring(t, 2); - flags = p.flags; - sign = 1; - sawFlag = false; - Loop: - while (true) { - if (!(!(t === ""))) { break; } - _tuple = nextRune(t); - c = _tuple[0]; - t = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$10 = ""; - _tmp$11 = err; - rest = _tmp$10; - err = _tmp$11; - return [rest, err]; - } - _1 = c; - if (_1 === (105)) { - flags = (flags | (1)) >>> 0; - sawFlag = true; - } else if (_1 === (109)) { - flags = (flags & ~(16)) << 16 >>> 16; - sawFlag = true; - } else if (_1 === (115)) { - flags = (flags | (8)) >>> 0; - sawFlag = true; - } else if (_1 === (85)) { - flags = (flags | (32)) >>> 0; - sawFlag = true; - } else if (_1 === (45)) { - if (sign < 0) { - break Loop; - } - sign = -1; - flags = ~flags << 16 >>> 16; - sawFlag = false; - } else if ((_1 === (58)) || (_1 === (41))) { - if (sign < 0) { - if (!sawFlag) { - break Loop; - } - flags = ~flags << 16 >>> 16; - } - if (c === 58) { - p.op(128); - } - p.flags = flags; - _tmp$12 = t; - _tmp$13 = $ifaceNil; - rest = _tmp$12; - err = _tmp$13; - return [rest, err]; - } else { - break Loop; - } - } - _tmp$14 = ""; - _tmp$15 = new Error.ptr("invalid or unsupported Perl syntax", $substring(s, 0, (s.length - t.length >> 0))); - rest = _tmp$14; - err = _tmp$15; - return [rest, err]; - }; - parser.prototype.parsePerlFlags = function(s) { return this.$val.parsePerlFlags(s); }; - isValidCaptureName = function(name) { - var _i, _ref, _rune, c, name; - if (name === "") { - return false; - } - _ref = name; - _i = 0; - while (true) { - if (!(_i < _ref.length)) { break; } - _rune = $decodeRune(_ref, _i); - c = _rune[0]; - if (!((c === 95)) && !isalnum(c)) { - return false; - } - _i += _rune[1]; - } - return true; - }; - parser.ptr.prototype.parseInt = function(s) { - var i, n, ok, p, rest, s, t; - n = 0; - rest = ""; - ok = false; - p = this; - if (s === "" || s.charCodeAt(0) < 48 || 57 < s.charCodeAt(0)) { - return [n, rest, ok]; - } - if (s.length >= 2 && (s.charCodeAt(0) === 48) && 48 <= s.charCodeAt(1) && s.charCodeAt(1) <= 57) { - return [n, rest, ok]; - } - t = s; - while (true) { - if (!(!(s === "") && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } - s = $substring(s, 1); - } - rest = s; - ok = true; - t = $substring(t, 0, (t.length - s.length >> 0)); - i = 0; - while (true) { - if (!(i < t.length)) { break; } - if (n >= 100000000) { - n = -1; - break; - } - n = (($imul(n, 10)) + ((t.charCodeAt(i) >> 0)) >> 0) - 48 >> 0; - i = i + (1) >> 0; - } - return [n, rest, ok]; - }; - parser.prototype.parseInt = function(s) { return this.$val.parseInt(s); }; - isCharClass = function(re) { - var re; - return (re.Op === 3) && (re.Rune.$length === 1) || (re.Op === 4) || (re.Op === 5) || (re.Op === 6); - }; - matchRune = function(re, r) { - var _1, i, r, re, x, x$1, x$2, x$3; - _1 = re.Op; - if (_1 === (3)) { - return (re.Rune.$length === 1) && ((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === r); - } else if (_1 === (4)) { - i = 0; - while (true) { - if (!(i < re.Rune.$length)) { break; } - if ((x$1 = re.Rune, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])) <= r && r <= (x$2 = re.Rune, x$3 = i + 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3]))) { - return true; - } - i = i + (2) >> 0; - } - return false; - } else if (_1 === (5)) { - return !((r === 10)); - } else if (_1 === (6)) { - return true; - } - return false; - }; - parser.ptr.prototype.parseVerticalBar = function() { - var _r, _r$1, p, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _r = p.concat(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - _r$1 = p.swapVerticalBar(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!_r$1) { */ case 2: - p.op(129); - /* } */ case 3: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseVerticalBar }; } $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parseVerticalBar = function() { return this.$val.parseVerticalBar(); }; - mergeCharClass = function(dst, src) { - var _1, dst, src, x, x$1, x$2, x$3, x$4; - switch (0) { default: - _1 = dst.Op; - if (_1 === (6)) { - } else if (_1 === (5)) { - if (matchRune(src, 10)) { - dst.Op = 6; - } - } else if (_1 === (4)) { - if (src.Op === 3) { - dst.Rune = appendLiteral(dst.Rune, (x = src.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])), src.Flags); - } else { - dst.Rune = appendClass(dst.Rune, src.Rune); - } - } else if (_1 === (3)) { - if (((x$1 = src.Rune, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) === (x$2 = dst.Rune, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))) && (src.Flags === dst.Flags)) { - break; - } - dst.Op = 4; - dst.Rune = appendLiteral($subslice(dst.Rune, 0, 0), (x$3 = dst.Rune, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])), dst.Flags); - dst.Rune = appendLiteral(dst.Rune, (x$4 = src.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])), src.Flags); - } - } - }; - parser.ptr.prototype.swapVerticalBar = function() { - var _tmp, _tmp$1, n, p, re1, re1$1, re2, re3, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; n = $f.n; p = $f.p; re1 = $f.re1; re1$1 = $f.re1$1; re2 = $f.re2; re3 = $f.re3; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$17 = $f.x$17; x$18 = $f.x$18; x$19 = $f.x$19; x$2 = $f.x$2; x$20 = $f.x$20; x$21 = $f.x$21; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - n = p.stack.$length; - if (n >= 3 && ((x = p.stack, x$1 = n - 2 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op === 129) && isCharClass((x$2 = p.stack, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3]))) && isCharClass((x$4 = p.stack, x$5 = n - 3 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])))) { - re1 = (x$6 = p.stack, x$7 = n - 1 >> 0, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])); - re3 = (x$8 = p.stack, x$9 = n - 3 >> 0, ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9])); - if (re1.Op > re3.Op) { - _tmp = re3; - _tmp$1 = re1; - re1 = _tmp; - re3 = _tmp$1; - (x$10 = p.stack, x$11 = n - 3 >> 0, ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11] = re3)); - } - mergeCharClass(re3, re1); - p.reuse(re1); - p.stack = $subslice(p.stack, 0, (n - 1 >> 0)); - $s = -1; return true; - } - /* */ if (n >= 2) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (n >= 2) { */ case 1: - re1$1 = (x$12 = p.stack, x$13 = n - 1 >> 0, ((x$13 < 0 || x$13 >= x$12.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + x$13])); - re2 = (x$14 = p.stack, x$15 = n - 2 >> 0, ((x$15 < 0 || x$15 >= x$14.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + x$15])); - /* */ if (re2.Op === 129) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (re2.Op === 129) { */ case 3: - /* */ if (n >= 3) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (n >= 3) { */ case 5: - $r = cleanAlt((x$16 = p.stack, x$17 = n - 3 >> 0, ((x$17 < 0 || x$17 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + x$17]))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 6: - (x$18 = p.stack, x$19 = n - 2 >> 0, ((x$19 < 0 || x$19 >= x$18.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$18.$array[x$18.$offset + x$19] = re1$1)); - (x$20 = p.stack, x$21 = n - 1 >> 0, ((x$21 < 0 || x$21 >= x$20.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$20.$array[x$20.$offset + x$21] = re2)); - $s = -1; return true; - /* } */ case 4: - /* } */ case 2: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.swapVerticalBar }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.n = n; $f.p = p; $f.re1 = re1; $f.re1$1 = re1$1; $f.re2 = re2; $f.re3 = re3; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$17 = x$17; $f.x$18 = x$18; $f.x$19 = x$19; $f.x$2 = x$2; $f.x$20 = x$20; $f.x$21 = x$21; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.swapVerticalBar = function() { return this.$val.swapVerticalBar(); }; - parser.ptr.prototype.parseRightParen = function() { - var _r, _r$1, _r$2, n, p, re1, re2, x, x$1, x$2, x$3, x$4, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; n = $f.n; p = $f.p; re1 = $f.re1; re2 = $f.re2; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - _r = p.concat(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r; - _r$1 = p.swapVerticalBar(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (_r$1) { */ case 2: - p.stack = $subslice(p.stack, 0, (p.stack.$length - 1 >> 0)); - /* } */ case 3: - _r$2 = p.alternate(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _r$2; - n = p.stack.$length; - if (n < 2) { - $s = -1; return new Error.ptr("unexpected )", p.wholeRegexp); - } - re1 = (x = p.stack, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - re2 = (x$2 = p.stack, x$3 = n - 2 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])); - p.stack = $subslice(p.stack, 0, (n - 2 >> 0)); - if (!((re2.Op === 128))) { - $s = -1; return new Error.ptr("unexpected )", p.wholeRegexp); - } - p.flags = re2.Flags; - if (re2.Cap === 0) { - p.push(re1); - } else { - re2.Op = 13; - re2.Sub = $subslice(new sliceType$5(re2.Sub0), 0, 1); - (x$4 = re2.Sub, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0] = re1)); - p.push(re2); - } - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseRightParen }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.n = n; $f.p = p; $f.re1 = re1; $f.re2 = re2; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parseRightParen = function() { return this.$val.parseRightParen(); }; - parser.ptr.prototype.parseEscape = function(s) { - var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, c, err, i, nhex, p, r, rest, s, t, v, x, y; - r = 0; - rest = ""; - err = $ifaceNil; - p = this; - t = $substring(s, 1); - if (t === "") { - _tmp = 0; - _tmp$1 = ""; - _tmp$2 = new Error.ptr("trailing backslash at end of expression", ""); - r = _tmp; - rest = _tmp$1; - err = _tmp$2; - return [r, rest, err]; - } - _tuple = nextRune(t); - c = _tuple[0]; - t = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$3 = 0; - _tmp$4 = ""; - _tmp$5 = err; - r = _tmp$3; - rest = _tmp$4; - err = _tmp$5; - return [r, rest, err]; - } - Switch: - switch (0) { default: - _1 = c; - if ((_1 === (49)) || (_1 === (50)) || (_1 === (51)) || (_1 === (52)) || (_1 === (53)) || (_1 === (54)) || (_1 === (55))) { - if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { - break; - } - r = c - 48 >> 0; - i = 1; - while (true) { - if (!(i < 3)) { break; } - if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { - break; - } - r = (($imul(r, 8)) + ((t.charCodeAt(0) >> 0)) >> 0) - 48 >> 0; - t = $substring(t, 1); - i = i + (1) >> 0; - } - _tmp$6 = r; - _tmp$7 = t; - _tmp$8 = $ifaceNil; - r = _tmp$6; - rest = _tmp$7; - err = _tmp$8; - return [r, rest, err]; - } else if (_1 === (48)) { - r = c - 48 >> 0; - i = 1; - while (true) { - if (!(i < 3)) { break; } - if (t === "" || t.charCodeAt(0) < 48 || t.charCodeAt(0) > 55) { - break; - } - r = (($imul(r, 8)) + ((t.charCodeAt(0) >> 0)) >> 0) - 48 >> 0; - t = $substring(t, 1); - i = i + (1) >> 0; - } - _tmp$9 = r; - _tmp$10 = t; - _tmp$11 = $ifaceNil; - r = _tmp$9; - rest = _tmp$10; - err = _tmp$11; - return [r, rest, err]; - } else if (_1 === (120)) { - if (t === "") { - break; - } - _tuple$1 = nextRune(t); - c = _tuple$1[0]; - t = _tuple$1[1]; - err = _tuple$1[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$12 = 0; - _tmp$13 = ""; - _tmp$14 = err; - r = _tmp$12; - rest = _tmp$13; - err = _tmp$14; - return [r, rest, err]; - } - if (c === 123) { - nhex = 0; - r = 0; - while (true) { - if (t === "") { - break Switch; - } - _tuple$2 = nextRune(t); - c = _tuple$2[0]; - t = _tuple$2[1]; - err = _tuple$2[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$15 = 0; - _tmp$16 = ""; - _tmp$17 = err; - r = _tmp$15; - rest = _tmp$16; - err = _tmp$17; - return [r, rest, err]; - } - if (c === 125) { - break; - } - v = unhex(c); - if (v < 0) { - break Switch; - } - r = ($imul(r, 16)) + v >> 0; - if (r > 1114111) { - break Switch; - } - nhex = nhex + (1) >> 0; - } - if (nhex === 0) { - break Switch; - } - _tmp$18 = r; - _tmp$19 = t; - _tmp$20 = $ifaceNil; - r = _tmp$18; - rest = _tmp$19; - err = _tmp$20; - return [r, rest, err]; - } - x = unhex(c); - _tuple$3 = nextRune(t); - c = _tuple$3[0]; - t = _tuple$3[1]; - err = _tuple$3[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - _tmp$21 = 0; - _tmp$22 = ""; - _tmp$23 = err; - r = _tmp$21; - rest = _tmp$22; - err = _tmp$23; - return [r, rest, err]; - } - y = unhex(c); - if (x < 0 || y < 0) { - break; - } - _tmp$24 = ($imul(x, 16)) + y >> 0; - _tmp$25 = t; - _tmp$26 = $ifaceNil; - r = _tmp$24; - rest = _tmp$25; - err = _tmp$26; - return [r, rest, err]; - } else if (_1 === (97)) { - _tmp$27 = 7; - _tmp$28 = t; - _tmp$29 = err; - r = _tmp$27; - rest = _tmp$28; - err = _tmp$29; - return [r, rest, err]; - } else if (_1 === (102)) { - _tmp$30 = 12; - _tmp$31 = t; - _tmp$32 = err; - r = _tmp$30; - rest = _tmp$31; - err = _tmp$32; - return [r, rest, err]; - } else if (_1 === (110)) { - _tmp$33 = 10; - _tmp$34 = t; - _tmp$35 = err; - r = _tmp$33; - rest = _tmp$34; - err = _tmp$35; - return [r, rest, err]; - } else if (_1 === (114)) { - _tmp$36 = 13; - _tmp$37 = t; - _tmp$38 = err; - r = _tmp$36; - rest = _tmp$37; - err = _tmp$38; - return [r, rest, err]; - } else if (_1 === (116)) { - _tmp$39 = 9; - _tmp$40 = t; - _tmp$41 = err; - r = _tmp$39; - rest = _tmp$40; - err = _tmp$41; - return [r, rest, err]; - } else if (_1 === (118)) { - _tmp$42 = 11; - _tmp$43 = t; - _tmp$44 = err; - r = _tmp$42; - rest = _tmp$43; - err = _tmp$44; - return [r, rest, err]; - } else if (c < 128 && !isalnum(c)) { - _tmp$45 = c; - _tmp$46 = t; - _tmp$47 = $ifaceNil; - r = _tmp$45; - rest = _tmp$46; - err = _tmp$47; - return [r, rest, err]; - } - } - _tmp$48 = 0; - _tmp$49 = ""; - _tmp$50 = new Error.ptr("invalid escape sequence", $substring(s, 0, (s.length - t.length >> 0))); - r = _tmp$48; - rest = _tmp$49; - err = _tmp$50; - return [r, rest, err]; - }; - parser.prototype.parseEscape = function(s) { return this.$val.parseEscape(s); }; - parser.ptr.prototype.parseClassChar = function(s, wholeClass) { - var _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, err, p, r, rest, s, wholeClass; - r = 0; - rest = ""; - err = $ifaceNil; - p = this; - if (s === "") { - _tmp = 0; - _tmp$1 = ""; - _tmp$2 = new Error.ptr("missing closing ]", wholeClass); - r = _tmp; - rest = _tmp$1; - err = _tmp$2; - return [r, rest, err]; - } - if (s.charCodeAt(0) === 92) { - _tuple = p.parseEscape(s); - r = _tuple[0]; - rest = _tuple[1]; - err = _tuple[2]; - return [r, rest, err]; - } - _tuple$1 = nextRune(s); - r = _tuple$1[0]; - rest = _tuple$1[1]; - err = _tuple$1[2]; - return [r, rest, err]; - }; - parser.prototype.parseClassChar = function(s, wholeClass) { return this.$val.parseClassChar(s, wholeClass); }; - parser.ptr.prototype.parsePerlClassEscape = function(s, r) { - var _entry, _r, _tmp, _tmp$1, g, out, p, r, rest, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; g = $f.g; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - out = sliceType.nil; - rest = ""; - p = this; - if ((((p.flags & 64) >>> 0) === 0) || s.length < 2 || !((s.charCodeAt(0) === 92))) { - $s = -1; return [out, rest]; - } - g = $clone((_entry = perlGroup[$String.keyFor($substring(s, 0, 2))], _entry !== undefined ? _entry.v : new charGroup.ptr(0, sliceType.nil)), charGroup); - if (g.sign === 0) { - $s = -1; return [out, rest]; - } - _r = p.appendGroup(r, $clone(g, charGroup)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tmp = _r; - _tmp$1 = $substring(s, 2); - out = _tmp; - rest = _tmp$1; - $s = -1; return [out, rest]; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parsePerlClassEscape }; } $f._entry = _entry; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.g = g; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parsePerlClassEscape = function(s, r) { return this.$val.parsePerlClassEscape(s, r); }; - parser.ptr.prototype.parseNamedClass = function(s, r) { - var _entry, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, err, g, i, name, out, p, r, rest, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; err = $f.err; g = $f.g; i = $f.i; name = $f.name; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - out = sliceType.nil; - rest = ""; - err = $ifaceNil; - p = this; - if (s.length < 2 || !((s.charCodeAt(0) === 91)) || !((s.charCodeAt(1) === 58))) { - $s = -1; return [out, rest, err]; - } - i = strings.Index($substring(s, 2), ":]"); - if (i < 0) { - $s = -1; return [out, rest, err]; - } - i = i + (2) >> 0; - _tmp = $substring(s, 0, (i + 2 >> 0)); - _tmp$1 = $substring(s, (i + 2 >> 0)); - name = _tmp; - s = _tmp$1; - g = $clone((_entry = posixGroup[$String.keyFor(name)], _entry !== undefined ? _entry.v : new charGroup.ptr(0, sliceType.nil)), charGroup); - if (g.sign === 0) { - _tmp$2 = sliceType.nil; - _tmp$3 = ""; - _tmp$4 = new Error.ptr("invalid character class range", name); - out = _tmp$2; - rest = _tmp$3; - err = _tmp$4; - $s = -1; return [out, rest, err]; - } - _r = p.appendGroup(r, $clone(g, charGroup)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tmp$5 = _r; - _tmp$6 = s; - _tmp$7 = $ifaceNil; - out = _tmp$5; - rest = _tmp$6; - err = _tmp$7; - $s = -1; return [out, rest, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseNamedClass }; } $f._entry = _entry; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f.err = err; $f.g = g; $f.i = i; $f.name = name; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parseNamedClass = function(s, r) { return this.$val.parseNamedClass(s, r); }; - parser.ptr.prototype.appendGroup = function(r, g) { - var _r, g, p, r, tmp, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; g = $f.g; p = $f.p; r = $f.r; tmp = $f.tmp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = this; - /* */ if (((p.flags & 1) >>> 0) === 0) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (((p.flags & 1) >>> 0) === 0) { */ case 1: - if (g.sign < 0) { - r = appendNegatedClass(r, g.class$1); - } else { - r = appendClass(r, g.class$1); - } - $s = 3; continue; - /* } else { */ case 2: - tmp = $subslice(p.tmpClass, 0, 0); - tmp = appendFoldedClass(tmp, g.class$1); - p.tmpClass = tmp; - _r = cleanClass((p.$ptr_tmpClass || (p.$ptr_tmpClass = new ptrType$2(function() { return this.$target.tmpClass; }, function($v) { this.$target.tmpClass = $v; }, p)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - tmp = _r; - if (g.sign < 0) { - r = appendNegatedClass(r, tmp); - } else { - r = appendClass(r, tmp); - } - /* } */ case 3: - $s = -1; return r; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.appendGroup }; } $f._r = _r; $f.g = g; $f.p = p; $f.r = r; $f.tmp = tmp; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.appendGroup = function(r, g) { return this.$val.appendGroup(r, g); }; - unicodeTable = function(name) { - var _entry, _entry$1, _entry$2, _entry$3, name, t, t$1; - if (name === "Any") { - return [anyTable, anyTable]; - } - t = (_entry = unicode.Categories[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$3.nil); - if (!(t === ptrType$3.nil)) { - return [t, (_entry$1 = unicode.FoldCategory[$String.keyFor(name)], _entry$1 !== undefined ? _entry$1.v : ptrType$3.nil)]; - } - t$1 = (_entry$2 = unicode.Scripts[$String.keyFor(name)], _entry$2 !== undefined ? _entry$2.v : ptrType$3.nil); - if (!(t$1 === ptrType$3.nil)) { - return [t$1, (_entry$3 = unicode.FoldScript[$String.keyFor(name)], _entry$3 !== undefined ? _entry$3.v : ptrType$3.nil)]; - } - return [ptrType$3.nil, ptrType$3.nil]; - }; - parser.ptr.prototype.parseUnicodeClass = function(s, r) { - var _r, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, c, end, err, fold, name, out, p, r, rest, s, seq, sign, t, tab, tmp, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; c = $f.c; end = $f.end; err = $f.err; fold = $f.fold; name = $f.name; out = $f.out; p = $f.p; r = $f.r; rest = $f.rest; s = $f.s; seq = $f.seq; sign = $f.sign; t = $f.t; tab = $f.tab; tmp = $f.tmp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - out = sliceType.nil; - rest = ""; - err = $ifaceNil; - p = this; - if ((((p.flags & 128) >>> 0) === 0) || s.length < 2 || !((s.charCodeAt(0) === 92)) || !((s.charCodeAt(1) === 112)) && !((s.charCodeAt(1) === 80))) { - $s = -1; return [out, rest, err]; - } - sign = 1; - if (s.charCodeAt(1) === 80) { - sign = -1; - } - t = $substring(s, 2); - _tuple = nextRune(t); - c = _tuple[0]; - t = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [out, rest, err]; - } - _tmp = ""; - _tmp$1 = ""; - seq = _tmp; - name = _tmp$1; - if (!((c === 123))) { - seq = $substring(s, 0, (s.length - t.length >> 0)); - name = $substring(seq, 2); - } else { - end = strings.IndexRune(s, 125); - if (end < 0) { - err = checkUTF8(s); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [out, rest, err]; - } - _tmp$2 = sliceType.nil; - _tmp$3 = ""; - _tmp$4 = new Error.ptr("invalid character class range", s); - out = _tmp$2; - rest = _tmp$3; - err = _tmp$4; - $s = -1; return [out, rest, err]; - } - _tmp$5 = $substring(s, 0, (end + 1 >> 0)); - _tmp$6 = $substring(s, (end + 1 >> 0)); - seq = _tmp$5; - t = _tmp$6; - name = $substring(s, 3, end); - err = checkUTF8(name); - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [out, rest, err]; - } - } - if (!(name === "") && (name.charCodeAt(0) === 94)) { - sign = -sign; - name = $substring(name, 1); - } - _tuple$1 = unicodeTable(name); - tab = _tuple$1[0]; - fold = _tuple$1[1]; - if (tab === ptrType$3.nil) { - _tmp$7 = sliceType.nil; - _tmp$8 = ""; - _tmp$9 = new Error.ptr("invalid character class range", seq); - out = _tmp$7; - rest = _tmp$8; - err = _tmp$9; - $s = -1; return [out, rest, err]; - } - /* */ if ((((p.flags & 1) >>> 0) === 0) || fold === ptrType$3.nil) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if ((((p.flags & 1) >>> 0) === 0) || fold === ptrType$3.nil) { */ case 1: - if (sign > 0) { - r = appendTable(r, tab); - } else { - r = appendNegatedTable(r, tab); - } - $s = 3; continue; - /* } else { */ case 2: - tmp = $subslice(p.tmpClass, 0, 0); - tmp = appendTable(tmp, tab); - tmp = appendTable(tmp, fold); - p.tmpClass = tmp; - _r = cleanClass((p.$ptr_tmpClass || (p.$ptr_tmpClass = new ptrType$2(function() { return this.$target.tmpClass; }, function($v) { this.$target.tmpClass = $v; }, p)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - tmp = _r; - if (sign > 0) { - r = appendClass(r, tmp); - } else { - r = appendNegatedClass(r, tmp); - } - /* } */ case 3: - _tmp$10 = r; - _tmp$11 = t; - _tmp$12 = $ifaceNil; - out = _tmp$10; - rest = _tmp$11; - err = _tmp$12; - $s = -1; return [out, rest, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseUnicodeClass }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.c = c; $f.end = end; $f.err = err; $f.fold = fold; $f.name = name; $f.out = out; $f.p = p; $f.r = r; $f.rest = rest; $f.s = s; $f.seq = seq; $f.sign = sign; $f.t = t; $f.tab = tab; $f.tmp = tmp; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parseUnicodeClass = function(s, r) { return this.$val.parseUnicodeClass(s, r); }; - parser.ptr.prototype.parseClass = function(s) { - var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, class$1, err, err$1, err$2, first, hi, lo, nclass, nclass$1, nclass$2, nt, nt$1, nt$2, p, re, rest, rng, s, sign, size, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; class$1 = $f.class$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; first = $f.first; hi = $f.hi; lo = $f.lo; nclass = $f.nclass; nclass$1 = $f.nclass$1; nclass$2 = $f.nclass$2; nt = $f.nt; nt$1 = $f.nt$1; nt$2 = $f.nt$2; p = $f.p; re = $f.re; rest = $f.rest; rng = $f.rng; s = $f.s; sign = $f.sign; size = $f.size; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - rest = ""; - err = $ifaceNil; - p = this; - t = $substring(s, 1); - re = p.newRegexp(4); - re.Flags = p.flags; - re.Rune = $subslice(new sliceType(re.Rune0), 0, 0); - sign = 1; - if (!(t === "") && (t.charCodeAt(0) === 94)) { - sign = -1; - t = $substring(t, 1); - if (((p.flags & 4) >>> 0) === 0) { - re.Rune = $append(re.Rune, 10, 10); - } - } - class$1 = re.Rune; - first = true; - /* while (true) { */ case 1: - /* if (!(t === "" || !((t.charCodeAt(0) === 93)) || first)) { break; } */ if(!(t === "" || !((t.charCodeAt(0) === 93)) || first)) { $s = 2; continue; } - if (!(t === "") && (t.charCodeAt(0) === 45) && (((p.flags & 64) >>> 0) === 0) && !first && ((t.length === 1) || !((t.charCodeAt(1) === 93)))) { - _tuple = utf8.DecodeRuneInString($substring(t, 1)); - size = _tuple[1]; - _tmp = ""; - _tmp$1 = new Error.ptr("invalid character class range", $substring(t, 0, (1 + size >> 0))); - rest = _tmp; - err = _tmp$1; - $s = -1; return [rest, err]; - } - first = false; - /* */ if (t.length > 2 && (t.charCodeAt(0) === 91) && (t.charCodeAt(1) === 58)) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (t.length > 2 && (t.charCodeAt(0) === 91) && (t.charCodeAt(1) === 58)) { */ case 3: - _r = p.parseNamedClass(t, class$1); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple$1 = _r; - nclass = _tuple$1[0]; - nt = _tuple$1[1]; - err$1 = _tuple$1[2]; - if (!($interfaceIsEqual(err$1, $ifaceNil))) { - _tmp$2 = ""; - _tmp$3 = err$1; - rest = _tmp$2; - err = _tmp$3; - $s = -1; return [rest, err]; - } - if (!(nclass === sliceType.nil)) { - _tmp$4 = nclass; - _tmp$5 = nt; - class$1 = _tmp$4; - t = _tmp$5; - /* continue; */ $s = 1; continue; - } - /* } */ case 4: - _r$1 = p.parseUnicodeClass(t, class$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$2 = _r$1; - nclass$1 = _tuple$2[0]; - nt$1 = _tuple$2[1]; - err$2 = _tuple$2[2]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - _tmp$6 = ""; - _tmp$7 = err$2; - rest = _tmp$6; - err = _tmp$7; - $s = -1; return [rest, err]; - } - /* */ if (!(nclass$1 === sliceType.nil)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (!(nclass$1 === sliceType.nil)) { */ case 7: - _tmp$8 = nclass$1; - _tmp$9 = nt$1; - class$1 = _tmp$8; - t = _tmp$9; - /* continue; */ $s = 1; continue; - /* } */ case 8: - _r$2 = p.parsePerlClassEscape(t, class$1); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$3 = _r$2; - nclass$2 = _tuple$3[0]; - nt$2 = _tuple$3[1]; - if (!(nclass$2 === sliceType.nil)) { - _tmp$10 = nclass$2; - _tmp$11 = nt$2; - class$1 = _tmp$10; - t = _tmp$11; - /* continue; */ $s = 1; continue; - } - rng = t; - _tmp$12 = 0; - _tmp$13 = 0; - lo = _tmp$12; - hi = _tmp$13; - _tuple$4 = p.parseClassChar(t, s); - lo = _tuple$4[0]; - t = _tuple$4[1]; - err$2 = _tuple$4[2]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - _tmp$14 = ""; - _tmp$15 = err$2; - rest = _tmp$14; - err = _tmp$15; - $s = -1; return [rest, err]; - } - hi = lo; - if (t.length >= 2 && (t.charCodeAt(0) === 45) && !((t.charCodeAt(1) === 93))) { - t = $substring(t, 1); - _tuple$5 = p.parseClassChar(t, s); - hi = _tuple$5[0]; - t = _tuple$5[1]; - err$2 = _tuple$5[2]; - if (!($interfaceIsEqual(err$2, $ifaceNil))) { - _tmp$16 = ""; - _tmp$17 = err$2; - rest = _tmp$16; - err = _tmp$17; - $s = -1; return [rest, err]; - } - if (hi < lo) { - rng = $substring(rng, 0, (rng.length - t.length >> 0)); - _tmp$18 = ""; - _tmp$19 = new Error.ptr("invalid character class range", rng); - rest = _tmp$18; - err = _tmp$19; - $s = -1; return [rest, err]; - } - } - if (((p.flags & 1) >>> 0) === 0) { - class$1 = appendRange(class$1, lo, hi); - } else { - class$1 = appendFoldedRange(class$1, lo, hi); - } - /* } */ $s = 1; continue; case 2: - t = $substring(t, 1); - re.Rune = class$1; - _r$3 = cleanClass((re.$ptr_Rune || (re.$ptr_Rune = new ptrType$2(function() { return this.$target.Rune; }, function($v) { this.$target.Rune = $v; }, re)))); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - class$1 = _r$3; - if (sign < 0) { - class$1 = negateClass(class$1); - } - re.Rune = class$1; - p.push(re); - _tmp$20 = t; - _tmp$21 = $ifaceNil; - rest = _tmp$20; - err = _tmp$21; - $s = -1; return [rest, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseClass }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.class$1 = class$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.first = first; $f.hi = hi; $f.lo = lo; $f.nclass = nclass; $f.nclass$1 = nclass$1; $f.nclass$2 = nclass$2; $f.nt = nt; $f.nt$1 = nt$1; $f.nt$2 = nt$2; $f.p = p; $f.re = re; $f.rest = rest; $f.rng = rng; $f.s = s; $f.sign = sign; $f.size = size; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - parser.prototype.parseClass = function(s) { return this.$val.parseClass(s); }; - cleanClass = function(rp) { - var _tmp, _tmp$1, hi, i, lo, r, rp, w, x, x$1, x$2, x$3, x$4, x$5, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; hi = $f.hi; i = $f.i; lo = $f.lo; r = $f.r; rp = $f.rp; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = sort.Sort((x = new ranges.ptr(rp), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - r = rp.$get(); - if (r.$length < 2) { - $s = -1; return r; - } - w = 2; - i = 2; - while (true) { - if (!(i < r.$length)) { break; } - _tmp = ((i < 0 || i >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + i]); - _tmp$1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1])); - lo = _tmp; - hi = _tmp$1; - if (lo <= ((x$2 = w - 1 >> 0, ((x$2 < 0 || x$2 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$2])) + 1 >> 0)) { - if (hi > (x$3 = w - 1 >> 0, ((x$3 < 0 || x$3 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$3]))) { - (x$4 = w - 1 >> 0, ((x$4 < 0 || x$4 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$4] = hi)); - } - i = i + (2) >> 0; - continue; - } - ((w < 0 || w >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + w] = lo); - (x$5 = w + 1 >> 0, ((x$5 < 0 || x$5 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$5] = hi)); - w = w + (2) >> 0; - i = i + (2) >> 0; - } - $s = -1; return $subslice(r, 0, w); - /* */ } return; } if ($f === undefined) { $f = { $blk: cleanClass }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.hi = hi; $f.i = i; $f.lo = lo; $f.r = r; $f.rp = rp; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; - }; - appendLiteral = function(r, x, flags) { - var flags, r, x; - if (!((((flags & 1) >>> 0) === 0))) { - return appendFoldedRange(r, x, x); - } - return appendRange(r, x, x); - }; - appendRange = function(r, lo, hi) { - var _tmp, _tmp$1, hi, i, lo, n, r, rhi, rlo, x, x$1, x$2, x$3; - n = r.$length; - i = 2; - while (true) { - if (!(i <= 4)) { break; } - if (n >= i) { - _tmp = (x = n - i >> 0, ((x < 0 || x >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x])); - _tmp$1 = (x$1 = (n - i >> 0) + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1])); - rlo = _tmp; - rhi = _tmp$1; - if (lo <= (rhi + 1 >> 0) && rlo <= (hi + 1 >> 0)) { - if (lo < rlo) { - (x$2 = n - i >> 0, ((x$2 < 0 || x$2 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$2] = lo)); - } - if (hi > rhi) { - (x$3 = (n - i >> 0) + 1 >> 0, ((x$3 < 0 || x$3 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$3] = hi)); - } - return r; - } - } - i = i + (2) >> 0; - } - return $append(r, lo, hi); - }; - appendFoldedRange = function(r, lo, hi) { - var c, f, hi, lo, r; - if (lo <= 65 && hi >= 125251) { - return appendRange(r, lo, hi); - } - if (hi < 65 || lo > 125251) { - return appendRange(r, lo, hi); - } - if (lo < 65) { - r = appendRange(r, lo, 64); - lo = 65; - } - if (hi > 125251) { - r = appendRange(r, 125252, hi); - hi = 125251; - } - c = lo; - while (true) { - if (!(c <= hi)) { break; } - r = appendRange(r, c, c); - f = unicode.SimpleFold(c); - while (true) { - if (!(!((f === c)))) { break; } - r = appendRange(r, f, f); - f = unicode.SimpleFold(f); - } - c = c + (1) >> 0; - } - return r; - }; - appendClass = function(r, x) { - var i, r, x, x$1; - i = 0; - while (true) { - if (!(i < x.$length)) { break; } - r = appendRange(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); - i = i + (2) >> 0; - } - return r; - }; - appendFoldedClass = function(r, x) { - var i, r, x, x$1; - i = 0; - while (true) { - if (!(i < x.$length)) { break; } - r = appendFoldedRange(r, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]), (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1]))); - i = i + (2) >> 0; - } - return r; - }; - appendNegatedClass = function(r, x) { - var _tmp, _tmp$1, hi, i, lo, nextLo, r, x, x$1; - nextLo = 0; - i = 0; - while (true) { - if (!(i < x.$length)) { break; } - _tmp = ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]); - _tmp$1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - lo = _tmp; - hi = _tmp$1; - if (nextLo <= (lo - 1 >> 0)) { - r = appendRange(r, nextLo, lo - 1 >> 0); - } - nextLo = hi + 1 >> 0; - i = i + (2) >> 0; - } - if (nextLo <= 1114111) { - r = appendRange(r, nextLo, 1114111); - } - return r; - }; - appendTable = function(r, x) { - var _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, c, c$1, hi, hi$1, lo, lo$1, r, stride, stride$1, x, xr, xr$1; - _ref = x.R16; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - xr = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), unicode.Range16); - _tmp = ((xr.Lo >> 0)); - _tmp$1 = ((xr.Hi >> 0)); - _tmp$2 = ((xr.Stride >> 0)); - lo = _tmp; - hi = _tmp$1; - stride = _tmp$2; - if (stride === 1) { - r = appendRange(r, lo, hi); - _i++; - continue; - } - c = lo; - while (true) { - if (!(c <= hi)) { break; } - r = appendRange(r, c, c); - c = c + (stride) >> 0; - } - _i++; - } - _ref$1 = x.R32; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - xr$1 = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), unicode.Range32); - _tmp$3 = ((xr$1.Lo >> 0)); - _tmp$4 = ((xr$1.Hi >> 0)); - _tmp$5 = ((xr$1.Stride >> 0)); - lo$1 = _tmp$3; - hi$1 = _tmp$4; - stride$1 = _tmp$5; - if (stride$1 === 1) { - r = appendRange(r, lo$1, hi$1); - _i$1++; - continue; - } - c$1 = lo$1; - while (true) { - if (!(c$1 <= hi$1)) { break; } - r = appendRange(r, c$1, c$1); - c$1 = c$1 + (stride$1) >> 0; - } - _i$1++; - } - return r; - }; - appendNegatedTable = function(r, x) { - var _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, c, c$1, hi, hi$1, lo, lo$1, nextLo, r, stride, stride$1, x, xr, xr$1; - nextLo = 0; - _ref = x.R16; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - xr = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), unicode.Range16); - _tmp = ((xr.Lo >> 0)); - _tmp$1 = ((xr.Hi >> 0)); - _tmp$2 = ((xr.Stride >> 0)); - lo = _tmp; - hi = _tmp$1; - stride = _tmp$2; - if (stride === 1) { - if (nextLo <= (lo - 1 >> 0)) { - r = appendRange(r, nextLo, lo - 1 >> 0); - } - nextLo = hi + 1 >> 0; - _i++; - continue; - } - c = lo; - while (true) { - if (!(c <= hi)) { break; } - if (nextLo <= (c - 1 >> 0)) { - r = appendRange(r, nextLo, c - 1 >> 0); - } - nextLo = c + 1 >> 0; - c = c + (stride) >> 0; - } - _i++; - } - _ref$1 = x.R32; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - xr$1 = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), unicode.Range32); - _tmp$3 = ((xr$1.Lo >> 0)); - _tmp$4 = ((xr$1.Hi >> 0)); - _tmp$5 = ((xr$1.Stride >> 0)); - lo$1 = _tmp$3; - hi$1 = _tmp$4; - stride$1 = _tmp$5; - if (stride$1 === 1) { - if (nextLo <= (lo$1 - 1 >> 0)) { - r = appendRange(r, nextLo, lo$1 - 1 >> 0); - } - nextLo = hi$1 + 1 >> 0; - _i$1++; - continue; - } - c$1 = lo$1; - while (true) { - if (!(c$1 <= hi$1)) { break; } - if (nextLo <= (c$1 - 1 >> 0)) { - r = appendRange(r, nextLo, c$1 - 1 >> 0); - } - nextLo = c$1 + 1 >> 0; - c$1 = c$1 + (stride$1) >> 0; - } - _i$1++; - } - if (nextLo <= 1114111) { - r = appendRange(r, nextLo, 1114111); - } - return r; - }; - negateClass = function(r) { - var _tmp, _tmp$1, hi, i, lo, nextLo, r, w, x, x$1; - nextLo = 0; - w = 0; - i = 0; - while (true) { - if (!(i < r.$length)) { break; } - _tmp = ((i < 0 || i >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + i]); - _tmp$1 = (x = i + 1 >> 0, ((x < 0 || x >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x])); - lo = _tmp; - hi = _tmp$1; - if (nextLo <= (lo - 1 >> 0)) { - ((w < 0 || w >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + w] = nextLo); - (x$1 = w + 1 >> 0, ((x$1 < 0 || x$1 >= r.$length) ? ($throwRuntimeError("index out of range"), undefined) : r.$array[r.$offset + x$1] = (lo - 1 >> 0))); - w = w + (2) >> 0; - } - nextLo = hi + 1 >> 0; - i = i + (2) >> 0; - } - r = $subslice(r, 0, w); - if (nextLo <= 1114111) { - r = $append(r, nextLo, 1114111); - } - return r; - }; - ranges.ptr.prototype.Less = function(i, j) { - var i, j, p, ra, x, x$1; - ra = this; - p = ra.p.$get(); - i = $imul(i, (2)); - j = $imul(j, (2)); - return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]) || (((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) === ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j])) && (x = i + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])) > (x$1 = j + 1 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])); - }; - ranges.prototype.Less = function(i, j) { return this.$val.Less(i, j); }; - ranges.ptr.prototype.Len = function() { - var _q, ra; - ra = this; - return (_q = ra.p.$get().$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - }; - ranges.prototype.Len = function() { return this.$val.Len(); }; - ranges.ptr.prototype.Swap = function(i, j) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, i, j, p, ra, x, x$1, x$2, x$3; - ra = this; - p = ra.p.$get(); - i = $imul(i, (2)); - j = $imul(j, (2)); - _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); - _tmp$1 = (x = j + 1 >> 0, ((x < 0 || x >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x])); - _tmp$2 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); - _tmp$3 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$1])); - ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); - (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2] = _tmp$1)); - ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$2); - (x$3 = j + 1 >> 0, ((x$3 < 0 || x$3 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$3] = _tmp$3)); - }; - ranges.prototype.Swap = function(i, j) { return this.$val.Swap(i, j); }; - checkUTF8 = function(s) { - var _tuple, rune, s, size; - while (true) { - if (!(!(s === ""))) { break; } - _tuple = utf8.DecodeRuneInString(s); - rune = _tuple[0]; - size = _tuple[1]; - if ((rune === 65533) && (size === 1)) { - return new Error.ptr("invalid UTF-8", s); - } - s = $substring(s, size); - } - return $ifaceNil; - }; - nextRune = function(s) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, err, s, size, t; - c = 0; - t = ""; - err = $ifaceNil; - _tuple = utf8.DecodeRuneInString(s); - c = _tuple[0]; - size = _tuple[1]; - if ((c === 65533) && (size === 1)) { - _tmp = 0; - _tmp$1 = ""; - _tmp$2 = new Error.ptr("invalid UTF-8", s); - c = _tmp; - t = _tmp$1; - err = _tmp$2; - return [c, t, err]; - } - _tmp$3 = c; - _tmp$4 = $substring(s, size); - _tmp$5 = $ifaceNil; - c = _tmp$3; - t = _tmp$4; - err = _tmp$5; - return [c, t, err]; - }; - isalnum = function(c) { - var c; - return 48 <= c && c <= 57 || 65 <= c && c <= 90 || 97 <= c && c <= 122; - }; - unhex = function(c) { - var c; - if (48 <= c && c <= 57) { - return c - 48 >> 0; - } - if (97 <= c && c <= 102) { - return (c - 97 >> 0) + 10 >> 0; - } - if (65 <= c && c <= 70) { - return (c - 65 >> 0) + 10 >> 0; - } - return -1; - }; - InstOp.prototype.String = function() { - var i; - i = this.$val; - if (((i >>> 0)) >= ((instOpNames.$length >>> 0))) { - return ""; - } - return ((i < 0 || i >= instOpNames.$length) ? ($throwRuntimeError("index out of range"), undefined) : instOpNames.$array[instOpNames.$offset + i]); - }; - $ptrType(InstOp).prototype.String = function() { return new InstOp(this.$get()).String(); }; - IsWordChar = function(r) { - var r; - return 65 <= r && r <= 90 || 97 <= r && r <= 122 || 48 <= r && r <= 57 || (r === 95); - }; - $pkg.IsWordChar = IsWordChar; - Prog.ptr.prototype.String = function() { - var b, p; - p = this; - b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); - dumpProg(b, p); - return b.String(); - }; - Prog.prototype.String = function() { return this.$val.String(); }; - Prog.ptr.prototype.skipNop = function(pc) { - var i, p, pc, x, x$1, x$2; - p = this; - i = (x = p.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); - while (true) { - if (!((i.Op === 6) || (i.Op === 2))) { break; } - i = (x$1 = p.Inst, x$2 = i.Out, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])); - } - return i; - }; - Prog.prototype.skipNop = function(pc) { return this.$val.skipNop(pc); }; - Inst.ptr.prototype.op = function() { - var _1, i, op; - i = this; - op = i.Op; - _1 = op; - if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { - op = 7; - } - return op; - }; - Inst.prototype.op = function() { return this.$val.op(); }; - Prog.ptr.prototype.Prefix = function() { - var _tmp, _tmp$1, _tmp$2, _tmp$3, buf, complete, i, p, prefix, x; - prefix = ""; - complete = false; - p = this; - i = p.skipNop(((p.Start >>> 0))); - if (!((i.op() === 7)) || !((i.Rune.$length === 1))) { - _tmp = ""; - _tmp$1 = i.Op === 4; - prefix = _tmp; - complete = _tmp$1; - return [prefix, complete]; - } - buf = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); - while (true) { - if (!((i.op() === 7) && (i.Rune.$length === 1) && (((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { break; } - buf.WriteRune((x = i.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))); - i = p.skipNop(i.Out); - } - _tmp$2 = buf.String(); - _tmp$3 = i.Op === 4; - prefix = _tmp$2; - complete = _tmp$3; - return [prefix, complete]; - }; - Prog.prototype.Prefix = function() { return this.$val.Prefix(); }; - Prog.ptr.prototype.StartCond = function() { - var _1, flag, i, p, pc, x, x$1; - p = this; - flag = 0; - pc = ((p.Start >>> 0)); - i = (x = p.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); - Loop: - while (true) { - _1 = i.Op; - if (_1 === (3)) { - flag = (flag | (((i.Arg << 24 >>> 24)))) >>> 0; - } else if (_1 === (5)) { - return 255; - } else if ((_1 === (2)) || (_1 === (6))) { - } else { - break Loop; - } - pc = i.Out; - i = (x$1 = p.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])); - } - return flag; - }; - Prog.prototype.StartCond = function() { return this.$val.StartCond(); }; - Inst.ptr.prototype.MatchRune = function(r) { - var i, r; - i = this; - return !((i.MatchRunePos(r) === -1)); - }; - Inst.prototype.MatchRune = function(r) { return this.$val.MatchRune(r); }; - Inst.ptr.prototype.MatchRunePos = function(r) { - var _1, _q, _q$1, _q$2, c, hi, i, j, lo, m, r, r0, r1, rune, x, x$1, x$2; - i = this; - rune = i.Rune; - _1 = rune.$length; - if (_1 === (0)) { - return -1; - } else if (_1 === (1)) { - r0 = (0 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 0]); - if (r === r0) { - return 0; - } - if (!((((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { - r1 = unicode.SimpleFold(r0); - while (true) { - if (!(!((r1 === r0)))) { break; } - if (r === r1) { - return 0; - } - r1 = unicode.SimpleFold(r1); - } - } - return -1; - } else if (_1 === (2)) { - if (r >= (0 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 0]) && r <= (1 >= rune.$length ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + 1])) { - return 0; - } - return -1; - } else if ((_1 === (4)) || (_1 === (6)) || (_1 === (8))) { - j = 0; - while (true) { - if (!(j < rune.$length)) { break; } - if (r < ((j < 0 || j >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + j])) { - return -1; - } - if (r <= (x = j + 1 >> 0, ((x < 0 || x >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x]))) { - return (_q = j / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - } - j = j + (2) >> 0; - } - return -1; - } - lo = 0; - hi = (_q$1 = rune.$length / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); - while (true) { - if (!(lo < hi)) { break; } - m = lo + (_q$2 = ((hi - lo >> 0)) / 2, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; - c = (x$1 = $imul(2, m), ((x$1 < 0 || x$1 >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x$1])); - if (c <= r) { - if (r <= (x$2 = ($imul(2, m)) + 1 >> 0, ((x$2 < 0 || x$2 >= rune.$length) ? ($throwRuntimeError("index out of range"), undefined) : rune.$array[rune.$offset + x$2]))) { - return m; - } - lo = m + 1 >> 0; - } else { - hi = m; - } - } - return -1; - }; - Inst.prototype.MatchRunePos = function(r) { return this.$val.MatchRunePos(r); }; - Inst.ptr.prototype.MatchEmptyWidth = function(before, after) { - var _1, after, before, i; - i = this; - _1 = ((i.Arg << 24 >>> 24)); - if (_1 === (1)) { - return (before === 10) || (before === -1); - } else if (_1 === (2)) { - return (after === 10) || (after === -1); - } else if (_1 === (4)) { - return before === -1; - } else if (_1 === (8)) { - return after === -1; - } else if (_1 === (16)) { - return !(IsWordChar(before) === IsWordChar(after)); - } else if (_1 === (32)) { - return IsWordChar(before) === IsWordChar(after); - } - $panic(new $String("unknown empty width arg")); - }; - Inst.prototype.MatchEmptyWidth = function(before, after) { return this.$val.MatchEmptyWidth(before, after); }; - Inst.ptr.prototype.String = function() { - var b, i; - i = this; - b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); - dumpInst(b, i); - return b.String(); - }; - Inst.prototype.String = function() { return this.$val.String(); }; - bw = function(b, args) { - var _i, _ref, args, b, s; - _ref = args; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - s = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - b.WriteString(s); - _i++; - } - }; - dumpProg = function(b, p) { - var _i, _ref, b, i, j, p, pc, x; - _ref = p.Inst; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - j = _i; - i = (x = p.Inst, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); - pc = strconv.Itoa(j); - if (pc.length < 3) { - b.WriteString($substring(" ", pc.length)); - } - if (j === p.Start) { - pc = pc + ("*"); - } - bw(b, new sliceType$3([pc, "\t"])); - dumpInst(b, i); - bw(b, new sliceType$3(["\n"])); - _i++; - } - }; - u32 = function(i) { - var i; - return strconv.FormatUint((new $Uint64(0, i)), 10); - }; - dumpInst = function(b, i) { - var _1, b, i; - _1 = i.Op; - if (_1 === (0)) { - bw(b, new sliceType$3(["alt -> ", u32(i.Out), ", ", u32(i.Arg)])); - } else if (_1 === (1)) { - bw(b, new sliceType$3(["altmatch -> ", u32(i.Out), ", ", u32(i.Arg)])); - } else if (_1 === (2)) { - bw(b, new sliceType$3(["cap ", u32(i.Arg), " -> ", u32(i.Out)])); - } else if (_1 === (3)) { - bw(b, new sliceType$3(["empty ", u32(i.Arg), " -> ", u32(i.Out)])); - } else if (_1 === (4)) { - bw(b, new sliceType$3(["match"])); - } else if (_1 === (5)) { - bw(b, new sliceType$3(["fail"])); - } else if (_1 === (6)) { - bw(b, new sliceType$3(["nop -> ", u32(i.Out)])); - } else if (_1 === (7)) { - if (i.Rune === sliceType.nil) { - bw(b, new sliceType$3(["rune "])); - } - bw(b, new sliceType$3(["rune ", strconv.QuoteToASCII(($runesToString(i.Rune)))])); - if (!((((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { - bw(b, new sliceType$3(["/i"])); - } - bw(b, new sliceType$3([" -> ", u32(i.Out)])); - } else if (_1 === (8)) { - bw(b, new sliceType$3(["rune1 ", strconv.QuoteToASCII(($runesToString(i.Rune))), " -> ", u32(i.Out)])); - } else if (_1 === (9)) { - bw(b, new sliceType$3(["any -> ", u32(i.Out)])); - } else if (_1 === (10)) { - bw(b, new sliceType$3(["anynotnl -> ", u32(i.Out)])); - } - }; - Regexp.ptr.prototype.Equal = function(y) { - var _1, _i, _i$1, _ref, _ref$1, i, i$1, r, sub, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y; - x = this; - if (x === ptrType$1.nil || y === ptrType$1.nil) { - return x === y; - } - if (!((x.Op === y.Op))) { - return false; - } - _1 = x.Op; - if (_1 === (10)) { - if (!((((x.Flags & 256) >>> 0) === ((y.Flags & 256) >>> 0)))) { - return false; - } - } else if ((_1 === (3)) || (_1 === (4))) { - if (!((x.Rune.$length === y.Rune.$length))) { - return false; - } - _ref = x.Rune; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - r = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((r === (x$1 = y.Rune, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i]))))) { - return false; - } - _i++; - } - } else if ((_1 === (19)) || (_1 === (18))) { - if (!((x.Sub.$length === y.Sub.$length))) { - return false; - } - _ref$1 = x.Sub; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - sub = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - if (!sub.Equal((x$2 = y.Sub, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])))) { - return false; - } - _i$1++; - } - } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16))) { - if (!((((x.Flags & 32) >>> 0) === ((y.Flags & 32) >>> 0))) || !(x$3 = x.Sub, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).Equal((x$4 = y.Sub, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0])))) { - return false; - } - } else if (_1 === (17)) { - if (!((((x.Flags & 32) >>> 0) === ((y.Flags & 32) >>> 0))) || !((x.Min === y.Min)) || !((x.Max === y.Max)) || !(x$5 = x.Sub, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0])).Equal((x$6 = y.Sub, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0])))) { - return false; - } - } else if (_1 === (13)) { - if (!((x.Cap === y.Cap)) || !(x.Name === y.Name) || !(x$7 = x.Sub, (0 >= x$7.$length ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + 0])).Equal((x$8 = y.Sub, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0])))) { - return false; - } - } - return true; - }; - Regexp.prototype.Equal = function(y) { return this.$val.Equal(y); }; - writeRegexp = function(b, re) { - var _1, _2, _i, _i$1, _i$2, _r, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tmp$2, _tmp$3, b, hi, hi$1, i, i$1, i$2, lo, lo$1, r, re, sub, sub$1, sub$2, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - switch (0) { default: - _1 = re.Op; - if (_1 === (1)) { - b.WriteString("[^\\x00-\\x{10FFFF}]"); - } else if (_1 === (2)) { - b.WriteString("(?:)"); - } else if (_1 === (3)) { - if (!((((re.Flags & 1) >>> 0) === 0))) { - b.WriteString("(?i:"); - } - _ref = re.Rune; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - r = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - escape(b, r, false); - _i++; - } - if (!((((re.Flags & 1) >>> 0) === 0))) { - b.WriteString(")"); - } - } else if (_1 === (4)) { - if (!(((_r = re.Rune.$length % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0))) { - b.WriteString("[invalid char class]"); - break; - } - b.WriteRune(91); - if (re.Rune.$length === 0) { - b.WriteString("^\\x00-\\x{10FFFF}"); - } else if (((x = re.Rune, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])) === 0) && ((x$1 = re.Rune, x$2 = re.Rune.$length - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === 1114111)) { - b.WriteRune(94); - i = 1; - while (true) { - if (!(i < (re.Rune.$length - 1 >> 0))) { break; } - _tmp = (x$3 = re.Rune, ((i < 0 || i >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i])) + 1 >> 0; - _tmp$1 = (x$4 = re.Rune, x$5 = i + 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) - 1 >> 0; - lo = _tmp; - hi = _tmp$1; - escape(b, lo, lo === 45); - if (!((lo === hi))) { - b.WriteRune(45); - escape(b, hi, hi === 45); - } - i = i + (2) >> 0; - } - } else { - i$1 = 0; - while (true) { - if (!(i$1 < re.Rune.$length)) { break; } - _tmp$2 = (x$6 = re.Rune, ((i$1 < 0 || i$1 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i$1])); - _tmp$3 = (x$7 = re.Rune, x$8 = i$1 + 1 >> 0, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8])); - lo$1 = _tmp$2; - hi$1 = _tmp$3; - escape(b, lo$1, lo$1 === 45); - if (!((lo$1 === hi$1))) { - b.WriteRune(45); - escape(b, hi$1, hi$1 === 45); - } - i$1 = i$1 + (2) >> 0; - } - } - b.WriteRune(93); - } else if (_1 === (5)) { - b.WriteString("(?-s:.)"); - } else if (_1 === (6)) { - b.WriteString("(?s:.)"); - } else if (_1 === (7)) { - b.WriteString("(?m:^)"); - } else if (_1 === (8)) { - b.WriteString("(?m:$)"); - } else if (_1 === (9)) { - b.WriteString("\\A"); - } else if (_1 === (10)) { - if (!((((re.Flags & 256) >>> 0) === 0))) { - b.WriteString("(?-m:$)"); - } else { - b.WriteString("\\z"); - } - } else if (_1 === (11)) { - b.WriteString("\\b"); - } else if (_1 === (12)) { - b.WriteString("\\B"); - } else if (_1 === (13)) { - if (!(re.Name === "")) { - b.WriteString("(?P<"); - b.WriteString(re.Name); - b.WriteRune(62); - } else { - b.WriteRune(40); - } - if (!(((x$9 = re.Sub, (0 >= x$9.$length ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + 0])).Op === 2))) { - writeRegexp(b, (x$10 = re.Sub, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0]))); - } - b.WriteRune(41); - } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16)) || (_1 === (17))) { - sub = (x$11 = re.Sub, (0 >= x$11.$length ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + 0])); - if (sub.Op > 13 || (sub.Op === 3) && sub.Rune.$length > 1) { - b.WriteString("(?:"); - writeRegexp(b, sub); - b.WriteString(")"); - } else { - writeRegexp(b, sub); - } - _2 = re.Op; - if (_2 === (14)) { - b.WriteRune(42); - } else if (_2 === (15)) { - b.WriteRune(43); - } else if (_2 === (16)) { - b.WriteRune(63); - } else if (_2 === (17)) { - b.WriteRune(123); - b.WriteString(strconv.Itoa(re.Min)); - if (!((re.Max === re.Min))) { - b.WriteRune(44); - if (re.Max >= 0) { - b.WriteString(strconv.Itoa(re.Max)); - } - } - b.WriteRune(125); - } - if (!((((re.Flags & 32) >>> 0) === 0))) { - b.WriteRune(63); - } - } else if (_1 === (18)) { - _ref$1 = re.Sub; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - sub$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - if (sub$1.Op === 19) { - b.WriteString("(?:"); - writeRegexp(b, sub$1); - b.WriteString(")"); - } else { - writeRegexp(b, sub$1); - } - _i$1++; - } - } else if (_1 === (19)) { - _ref$2 = re.Sub; - _i$2 = 0; - while (true) { - if (!(_i$2 < _ref$2.$length)) { break; } - i$2 = _i$2; - sub$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$2.$array[_ref$2.$offset + _i$2]); - if (i$2 > 0) { - b.WriteRune(124); - } - writeRegexp(b, sub$2); - _i$2++; - } - } else { - b.WriteString("> 0))) + ">"); - } - } - }; - Regexp.ptr.prototype.String = function() { - var b, re; - re = this; - b = new strings.Builder.ptr(ptrType$4.nil, sliceType$6.nil); - writeRegexp(b, re); - return b.String(); - }; - Regexp.prototype.String = function() { return this.$val.String(); }; - escape = function(b, r, force) { - var _1, b, force, r, s; - if (unicode.IsPrint(r)) { - if (strings.ContainsRune("\\.+*?()|[]{}^$", r) || force) { - b.WriteRune(92); - } - b.WriteRune(r); - return; - } - switch (0) { default: - _1 = r; - if (_1 === (7)) { - b.WriteString("\\a"); - } else if (_1 === (12)) { - b.WriteString("\\f"); - } else if (_1 === (10)) { - b.WriteString("\\n"); - } else if (_1 === (13)) { - b.WriteString("\\r"); - } else if (_1 === (9)) { - b.WriteString("\\t"); - } else if (_1 === (11)) { - b.WriteString("\\v"); - } else { - if (r < 256) { - b.WriteString("\\x"); - s = strconv.FormatInt((new $Int64(0, r)), 16); - if (s.length === 1) { - b.WriteRune(48); - } - b.WriteString(s); - break; - } - b.WriteString("\\x{"); - b.WriteString(strconv.FormatInt((new $Int64(0, r)), 16)); - b.WriteString("}"); - } - } - }; - Regexp.ptr.prototype.MaxCap = function() { - var _i, _ref, m, n, re, sub; - re = this; - m = 0; - if (re.Op === 13) { - m = re.Cap; - } - _ref = re.Sub; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - n = sub.MaxCap(); - if (m < n) { - m = n; - } - _i++; - } - return m; - }; - Regexp.prototype.MaxCap = function() { return this.$val.MaxCap(); }; - Regexp.ptr.prototype.CapNames = function() { - var names, re; - re = this; - names = $makeSlice(sliceType$3, (re.MaxCap() + 1 >> 0)); - re.capNames(names); - return names; - }; - Regexp.prototype.CapNames = function() { return this.$val.CapNames(); }; - Regexp.ptr.prototype.capNames = function(names) { - var _i, _ref, names, re, sub, x; - re = this; - if (re.Op === 13) { - (x = re.Cap, ((x < 0 || x >= names.$length) ? ($throwRuntimeError("index out of range"), undefined) : names.$array[names.$offset + x] = re.Name)); - } - _ref = re.Sub; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - sub.capNames(names); - _i++; - } - }; - Regexp.prototype.capNames = function(names) { return this.$val.capNames(names); }; - Regexp.ptr.prototype.Simplify = function() { - var _1, _i, _ref, i, i$1, i$2, i$3, nre, nre$1, nre2, nsub, prefix, re, sub, sub$1, sub$2, suffix, x, x$1; - re = this; - if (re === ptrType$1.nil) { - return ptrType$1.nil; - } - _1 = re.Op; - if ((_1 === (13)) || (_1 === (18)) || (_1 === (19))) { - nre = re; - _ref = re.Sub; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - sub = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - nsub = sub.Simplify(); - if (nre === re && !(nsub === sub)) { - nre = new Regexp.ptr(0, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - Regexp.copy(nre, re); - nre.Rune = sliceType.nil; - nre.Sub = $appendSlice($subslice(new sliceType$5(nre.Sub0), 0, 0), $subslice(re.Sub, 0, i)); - } - if (!(nre === re)) { - nre.Sub = $append(nre.Sub, nsub); - } - _i++; - } - return nre; - } else if ((_1 === (14)) || (_1 === (15)) || (_1 === (16))) { - sub$1 = (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])).Simplify(); - return simplify1(re.Op, re.Flags, sub$1, re); - } else if (_1 === (17)) { - if ((re.Min === 0) && (re.Max === 0)) { - return new Regexp.ptr(2, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - } - sub$2 = (x$1 = re.Sub, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])).Simplify(); - if (re.Max === -1) { - if (re.Min === 0) { - return simplify1(14, re.Flags, sub$2, ptrType$1.nil); - } - if (re.Min === 1) { - return simplify1(15, re.Flags, sub$2, ptrType$1.nil); - } - nre$1 = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - nre$1.Sub = $subslice(new sliceType$5(nre$1.Sub0), 0, 0); - i$1 = 0; - while (true) { - if (!(i$1 < (re.Min - 1 >> 0))) { break; } - nre$1.Sub = $append(nre$1.Sub, sub$2); - i$1 = i$1 + (1) >> 0; - } - nre$1.Sub = $append(nre$1.Sub, simplify1(15, re.Flags, sub$2, ptrType$1.nil)); - return nre$1; - } - if ((re.Min === 1) && (re.Max === 1)) { - return sub$2; - } - prefix = ptrType$1.nil; - if (re.Min > 0) { - prefix = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - prefix.Sub = $subslice(new sliceType$5(prefix.Sub0), 0, 0); - i$2 = 0; - while (true) { - if (!(i$2 < re.Min)) { break; } - prefix.Sub = $append(prefix.Sub, sub$2); - i$2 = i$2 + (1) >> 0; - } - } - if (re.Max > re.Min) { - suffix = simplify1(16, re.Flags, sub$2, ptrType$1.nil); - i$3 = re.Min + 1 >> 0; - while (true) { - if (!(i$3 < re.Max)) { break; } - nre2 = new Regexp.ptr(18, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - nre2.Sub = $append($subslice(new sliceType$5(nre2.Sub0), 0, 0), sub$2, suffix); - suffix = simplify1(16, re.Flags, nre2, ptrType$1.nil); - i$3 = i$3 + (1) >> 0; - } - if (prefix === ptrType$1.nil) { - return suffix; - } - prefix.Sub = $append(prefix.Sub, suffix); - } - if (!(prefix === ptrType$1.nil)) { - return prefix; - } - return new Regexp.ptr(1, 0, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - } - return re; - }; - Regexp.prototype.Simplify = function() { return this.$val.Simplify(); }; - simplify1 = function(op, flags, sub, re) { - var flags, op, re, sub, x; - if (sub.Op === 2) { - return sub; - } - if ((op === sub.Op) && (((flags & 32) >>> 0) === ((sub.Flags & 32) >>> 0))) { - return sub; - } - if (!(re === ptrType$1.nil) && (re.Op === op) && (((re.Flags & 32) >>> 0) === ((flags & 32) >>> 0)) && sub === (x = re.Sub, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0]))) { - return re; - } - re = new Regexp.ptr(op, flags, sliceType$5.nil, arrayType.zero(), sliceType.nil, arrayType$1.zero(), 0, 0, 0, ""); - re.Sub = $append($subslice(new sliceType$5(re.Sub0), 0, 0), sub); - return re; - }; - patchList.methods = [{prop: "next", name: "next", pkg: "regexp/syntax", typ: $funcType([ptrType], [patchList], false)}, {prop: "patch", name: "patch", pkg: "regexp/syntax", typ: $funcType([ptrType, $Uint32], [], false)}, {prop: "append", name: "append", pkg: "regexp/syntax", typ: $funcType([ptrType, patchList], [patchList], false)}]; - ptrType$5.methods = [{prop: "init", name: "init", pkg: "regexp/syntax", typ: $funcType([], [], false)}, {prop: "compile", name: "compile", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [frag], false)}, {prop: "inst", name: "inst", pkg: "regexp/syntax", typ: $funcType([InstOp], [frag], false)}, {prop: "nop", name: "nop", pkg: "regexp/syntax", typ: $funcType([], [frag], false)}, {prop: "fail", name: "fail", pkg: "regexp/syntax", typ: $funcType([], [frag], false)}, {prop: "cap", name: "cap", pkg: "regexp/syntax", typ: $funcType([$Uint32], [frag], false)}, {prop: "cat", name: "cat", pkg: "regexp/syntax", typ: $funcType([frag, frag], [frag], false)}, {prop: "alt", name: "alt", pkg: "regexp/syntax", typ: $funcType([frag, frag], [frag], false)}, {prop: "quest", name: "quest", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "star", name: "star", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "plus", name: "plus", pkg: "regexp/syntax", typ: $funcType([frag, $Bool], [frag], false)}, {prop: "empty", name: "empty", pkg: "regexp/syntax", typ: $funcType([EmptyOp], [frag], false)}, {prop: "rune", name: "rune", pkg: "regexp/syntax", typ: $funcType([sliceType, Flags], [frag], false)}]; - ptrType$6.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; - ErrorCode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$7.methods = [{prop: "newRegexp", name: "newRegexp", pkg: "regexp/syntax", typ: $funcType([Op], [ptrType$1], false)}, {prop: "reuse", name: "reuse", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [], false)}, {prop: "push", name: "push", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "maybeConcat", name: "maybeConcat", pkg: "regexp/syntax", typ: $funcType([$Int32, Flags], [$Bool], false)}, {prop: "newLiteral", name: "newLiteral", pkg: "regexp/syntax", typ: $funcType([$Int32, Flags], [ptrType$1], false)}, {prop: "literal", name: "literal", pkg: "regexp/syntax", typ: $funcType([$Int32], [], false)}, {prop: "op", name: "op", pkg: "regexp/syntax", typ: $funcType([Op], [ptrType$1], false)}, {prop: "repeat", name: "repeat", pkg: "regexp/syntax", typ: $funcType([Op, $Int, $Int, $String, $String, $String], [$String, $error], false)}, {prop: "concat", name: "concat", pkg: "regexp/syntax", typ: $funcType([], [ptrType$1], false)}, {prop: "alternate", name: "alternate", pkg: "regexp/syntax", typ: $funcType([], [ptrType$1], false)}, {prop: "collapse", name: "collapse", pkg: "regexp/syntax", typ: $funcType([sliceType$5, Op], [ptrType$1], false)}, {prop: "factor", name: "factor", pkg: "regexp/syntax", typ: $funcType([sliceType$5], [sliceType$5], false)}, {prop: "leadingString", name: "leadingString", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [sliceType, Flags], false)}, {prop: "removeLeadingString", name: "removeLeadingString", pkg: "regexp/syntax", typ: $funcType([ptrType$1, $Int], [ptrType$1], false)}, {prop: "leadingRegexp", name: "leadingRegexp", pkg: "regexp/syntax", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "removeLeadingRegexp", name: "removeLeadingRegexp", pkg: "regexp/syntax", typ: $funcType([ptrType$1, $Bool], [ptrType$1], false)}, {prop: "parseRepeat", name: "parseRepeat", pkg: "regexp/syntax", typ: $funcType([$String], [$Int, $Int, $String, $Bool], false)}, {prop: "parsePerlFlags", name: "parsePerlFlags", pkg: "regexp/syntax", typ: $funcType([$String], [$String, $error], false)}, {prop: "parseInt", name: "parseInt", pkg: "regexp/syntax", typ: $funcType([$String], [$Int, $String, $Bool], false)}, {prop: "parseVerticalBar", name: "parseVerticalBar", pkg: "regexp/syntax", typ: $funcType([], [$error], false)}, {prop: "swapVerticalBar", name: "swapVerticalBar", pkg: "regexp/syntax", typ: $funcType([], [$Bool], false)}, {prop: "parseRightParen", name: "parseRightParen", pkg: "regexp/syntax", typ: $funcType([], [$error], false)}, {prop: "parseEscape", name: "parseEscape", pkg: "regexp/syntax", typ: $funcType([$String], [$Int32, $String, $error], false)}, {prop: "parseClassChar", name: "parseClassChar", pkg: "regexp/syntax", typ: $funcType([$String, $String], [$Int32, $String, $error], false)}, {prop: "parsePerlClassEscape", name: "parsePerlClassEscape", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String], false)}, {prop: "parseNamedClass", name: "parseNamedClass", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String, $error], false)}, {prop: "appendGroup", name: "appendGroup", pkg: "regexp/syntax", typ: $funcType([sliceType, charGroup], [sliceType], false)}, {prop: "parseUnicodeClass", name: "parseUnicodeClass", pkg: "regexp/syntax", typ: $funcType([$String, sliceType], [sliceType, $String, $error], false)}, {prop: "parseClass", name: "parseClass", pkg: "regexp/syntax", typ: $funcType([$String], [$String, $error], false)}]; - ranges.methods = [{prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; - ptrType.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "skipNop", name: "skipNop", pkg: "regexp/syntax", typ: $funcType([$Uint32], [ptrType$8], false)}, {prop: "Prefix", name: "Prefix", pkg: "", typ: $funcType([], [$String, $Bool], false)}, {prop: "StartCond", name: "StartCond", pkg: "", typ: $funcType([], [EmptyOp], false)}]; - InstOp.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$8.methods = [{prop: "op", name: "op", pkg: "regexp/syntax", typ: $funcType([], [InstOp], false)}, {prop: "MatchRune", name: "MatchRune", pkg: "", typ: $funcType([$Int32], [$Bool], false)}, {prop: "MatchRunePos", name: "MatchRunePos", pkg: "", typ: $funcType([$Int32], [$Int], false)}, {prop: "MatchEmptyWidth", name: "MatchEmptyWidth", pkg: "", typ: $funcType([$Int32, $Int32], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - ptrType$1.methods = [{prop: "Equal", name: "Equal", pkg: "", typ: $funcType([ptrType$1], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "MaxCap", name: "MaxCap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "CapNames", name: "CapNames", pkg: "", typ: $funcType([], [sliceType$3], false)}, {prop: "capNames", name: "capNames", pkg: "regexp/syntax", typ: $funcType([sliceType$3], [], false)}, {prop: "Simplify", name: "Simplify", pkg: "", typ: $funcType([], [ptrType$1], false)}]; - Op.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - frag.init("regexp/syntax", [{prop: "i", name: "i", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "out", name: "out", embedded: false, exported: false, typ: patchList, tag: ""}]); - compiler.init("regexp/syntax", [{prop: "p", name: "p", embedded: false, exported: false, typ: ptrType, tag: ""}]); - Error.init("", [{prop: "Code", name: "Code", embedded: false, exported: true, typ: ErrorCode, tag: ""}, {prop: "Expr", name: "Expr", embedded: false, exported: true, typ: $String, tag: ""}]); - parser.init("regexp/syntax", [{prop: "flags", name: "flags", embedded: false, exported: false, typ: Flags, tag: ""}, {prop: "stack", name: "stack", embedded: false, exported: false, typ: sliceType$5, tag: ""}, {prop: "free", name: "free", embedded: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "numCap", name: "numCap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "wholeRegexp", name: "wholeRegexp", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "tmpClass", name: "tmpClass", embedded: false, exported: false, typ: sliceType, tag: ""}]); - charGroup.init("regexp/syntax", [{prop: "sign", name: "sign", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "class$1", name: "class", embedded: false, exported: false, typ: sliceType, tag: ""}]); - ranges.init("regexp/syntax", [{prop: "p", name: "p", embedded: false, exported: false, typ: ptrType$2, tag: ""}]); - Prog.init("", [{prop: "Inst", name: "Inst", embedded: false, exported: true, typ: sliceType$4, tag: ""}, {prop: "Start", name: "Start", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "NumCap", name: "NumCap", embedded: false, exported: true, typ: $Int, tag: ""}]); - Inst.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: InstOp, tag: ""}, {prop: "Out", name: "Out", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Arg", name: "Arg", embedded: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Rune", name: "Rune", embedded: false, exported: true, typ: sliceType, tag: ""}]); - Regexp.init("", [{prop: "Op", name: "Op", embedded: false, exported: true, typ: Op, tag: ""}, {prop: "Flags", name: "Flags", embedded: false, exported: true, typ: Flags, tag: ""}, {prop: "Sub", name: "Sub", embedded: false, exported: true, typ: sliceType$5, tag: ""}, {prop: "Sub0", name: "Sub0", embedded: false, exported: true, typ: arrayType, tag: ""}, {prop: "Rune", name: "Rune", embedded: false, exported: true, typ: sliceType, tag: ""}, {prop: "Rune0", name: "Rune0", embedded: false, exported: true, typ: arrayType$1, tag: ""}, {prop: "Min", name: "Min", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Max", name: "Max", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Cap", name: "Cap", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "Name", name: "Name", embedded: false, exported: true, typ: $String, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = sort.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strings.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - anyRuneNotNL = new sliceType([0, 9, 11, 1114111]); - anyRune = new sliceType([0, 1114111]); - _Op_index_0 = $toNativeArray($kindUint8, [0, 7, 17, 24, 33, 45, 52, 61, 68, 77, 84, 96, 110, 117, 121, 125, 130, 136, 142, 151]); - anyTable = new unicode.RangeTable.ptr(new sliceType$1([new unicode.Range16.ptr(0, 65535, 1)]), new sliceType$2([new unicode.Range32.ptr(65536, 1114111, 1)]), 0); - code1 = new sliceType([48, 57]); - code2 = new sliceType([9, 10, 12, 13, 32, 32]); - code3 = new sliceType([48, 57, 65, 90, 95, 95, 97, 122]); - perlGroup = $makeMap($String.keyFor, [{ k: "\\d", v: new charGroup.ptr(1, code1) }, { k: "\\D", v: new charGroup.ptr(-1, code1) }, { k: "\\s", v: new charGroup.ptr(1, code2) }, { k: "\\S", v: new charGroup.ptr(-1, code2) }, { k: "\\w", v: new charGroup.ptr(1, code3) }, { k: "\\W", v: new charGroup.ptr(-1, code3) }]); - code4 = new sliceType([48, 57, 65, 90, 97, 122]); - code5 = new sliceType([65, 90, 97, 122]); - code6 = new sliceType([0, 127]); - code7 = new sliceType([9, 9, 32, 32]); - code8 = new sliceType([0, 31, 127, 127]); - code9 = new sliceType([48, 57]); - code10 = new sliceType([33, 126]); - code11 = new sliceType([97, 122]); - code12 = new sliceType([32, 126]); - code13 = new sliceType([33, 47, 58, 64, 91, 96, 123, 126]); - code14 = new sliceType([9, 13, 32, 32]); - code15 = new sliceType([65, 90]); - code16 = new sliceType([48, 57, 65, 90, 95, 95, 97, 122]); - code17 = new sliceType([48, 57, 65, 70, 97, 102]); - posixGroup = $makeMap($String.keyFor, [{ k: "[:alnum:]", v: new charGroup.ptr(1, code4) }, { k: "[:^alnum:]", v: new charGroup.ptr(-1, code4) }, { k: "[:alpha:]", v: new charGroup.ptr(1, code5) }, { k: "[:^alpha:]", v: new charGroup.ptr(-1, code5) }, { k: "[:ascii:]", v: new charGroup.ptr(1, code6) }, { k: "[:^ascii:]", v: new charGroup.ptr(-1, code6) }, { k: "[:blank:]", v: new charGroup.ptr(1, code7) }, { k: "[:^blank:]", v: new charGroup.ptr(-1, code7) }, { k: "[:cntrl:]", v: new charGroup.ptr(1, code8) }, { k: "[:^cntrl:]", v: new charGroup.ptr(-1, code8) }, { k: "[:digit:]", v: new charGroup.ptr(1, code9) }, { k: "[:^digit:]", v: new charGroup.ptr(-1, code9) }, { k: "[:graph:]", v: new charGroup.ptr(1, code10) }, { k: "[:^graph:]", v: new charGroup.ptr(-1, code10) }, { k: "[:lower:]", v: new charGroup.ptr(1, code11) }, { k: "[:^lower:]", v: new charGroup.ptr(-1, code11) }, { k: "[:print:]", v: new charGroup.ptr(1, code12) }, { k: "[:^print:]", v: new charGroup.ptr(-1, code12) }, { k: "[:punct:]", v: new charGroup.ptr(1, code13) }, { k: "[:^punct:]", v: new charGroup.ptr(-1, code13) }, { k: "[:space:]", v: new charGroup.ptr(1, code14) }, { k: "[:^space:]", v: new charGroup.ptr(-1, code14) }, { k: "[:upper:]", v: new charGroup.ptr(1, code15) }, { k: "[:^upper:]", v: new charGroup.ptr(-1, code15) }, { k: "[:word:]", v: new charGroup.ptr(1, code16) }, { k: "[:^word:]", v: new charGroup.ptr(-1, code16) }, { k: "[:xdigit:]", v: new charGroup.ptr(1, code17) }, { k: "[:^xdigit:]", v: new charGroup.ptr(-1, code17) }]); - instOpNames = new sliceType$3(["InstAlt", "InstAltMatch", "InstCapture", "InstEmptyWidth", "InstMatch", "InstFail", "InstNop", "InstRune", "InstRune1", "InstRuneAny", "InstRuneAnyNotNL"]); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["regexp"] = (function() { - var $pkg = {}, $init, bytes, nosync, io, syntax, sort, strconv, strings, unicode, utf8, job, bitState, queue, entry, thread, machine, inputs, lazyFlag, onePassMachine, onePassProg, onePassInst, queueOnePass, runeSlice, Regexp, input, inputString, inputBytes, inputReader, sliceType, arrayType, arrayType$1, arrayType$2, sliceType$1, sliceType$2, ptrType, sliceType$3, sliceType$4, sliceType$5, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, sliceType$6, ptrType$9, sliceType$7, ptrType$10, sliceType$8, ptrType$11, ptrType$12, sliceType$9, ptrType$13, sliceType$10, sliceType$11, arrayType$3, arrayType$4, sliceType$12, sliceType$13, sliceType$14, sliceType$15, ptrType$14, ptrType$15, funcType, funcType$1, funcType$2, funcType$3, ptrType$16, ptrType$17, ptrType$18, bitStatePool, onePassPool, arrayNoInts, noRune, noNext, anyRuneNotNL, anyRune, matchSize, matchPool, specialBytes, newBitState, freeBitState, maxBitStateLen, shouldBacktrack, newLazyFlag, newOnePassMachine, freeOnePassMachine, onePassPrefix, onePassNext, iop, newQueue, mergeRuneSets, cleanupOnePass, onePassCopy, makeOnePass, compileOnePass, Compile, compile, MustCompile, quote, init, extract; - bytes = $packages["bytes"]; - nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; - io = $packages["io"]; - syntax = $packages["regexp/syntax"]; - sort = $packages["sort"]; - strconv = $packages["strconv"]; - strings = $packages["strings"]; - unicode = $packages["unicode"]; - utf8 = $packages["unicode/utf8"]; - job = $pkg.job = $newType(0, $kindStruct, "regexp.job", true, "regexp", false, function(pc_, arg_, pos_) { - this.$val = this; - if (arguments.length === 0) { - this.pc = 0; - this.arg = false; - this.pos = 0; - return; - } - this.pc = pc_; - this.arg = arg_; - this.pos = pos_; - }); - bitState = $pkg.bitState = $newType(0, $kindStruct, "regexp.bitState", true, "regexp", false, function(end_, cap_, matchcap_, jobs_, visited_, inputs_) { - this.$val = this; - if (arguments.length === 0) { - this.end = 0; - this.cap = sliceType$3.nil; - this.matchcap = sliceType$3.nil; - this.jobs = sliceType$4.nil; - this.visited = sliceType$2.nil; - this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); - return; - } - this.end = end_; - this.cap = cap_; - this.matchcap = matchcap_; - this.jobs = jobs_; - this.visited = visited_; - this.inputs = inputs_; - }); - queue = $pkg.queue = $newType(0, $kindStruct, "regexp.queue", true, "regexp", false, function(sparse_, dense_) { - this.$val = this; - if (arguments.length === 0) { - this.sparse = sliceType$2.nil; - this.dense = sliceType$10.nil; - return; - } - this.sparse = sparse_; - this.dense = dense_; - }); - entry = $pkg.entry = $newType(0, $kindStruct, "regexp.entry", true, "regexp", false, function(pc_, t_) { - this.$val = this; - if (arguments.length === 0) { - this.pc = 0; - this.t = ptrType$1.nil; - return; - } - this.pc = pc_; - this.t = t_; - }); - thread = $pkg.thread = $newType(0, $kindStruct, "regexp.thread", true, "regexp", false, function(inst_, cap_) { - this.$val = this; - if (arguments.length === 0) { - this.inst = ptrType$2.nil; - this.cap = sliceType$3.nil; - return; - } - this.inst = inst_; - this.cap = cap_; - }); - machine = $pkg.machine = $newType(0, $kindStruct, "regexp.machine", true, "regexp", false, function(re_, p_, q0_, q1_, pool_, matched_, matchcap_, inputs_) { - this.$val = this; - if (arguments.length === 0) { - this.re = ptrType$11.nil; - this.p = ptrType$12.nil; - this.q0 = new queue.ptr(sliceType$2.nil, sliceType$10.nil); - this.q1 = new queue.ptr(sliceType$2.nil, sliceType$10.nil); - this.pool = sliceType$11.nil; - this.matched = false; - this.matchcap = sliceType$3.nil; - this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); - return; - } - this.re = re_; - this.p = p_; - this.q0 = q0_; - this.q1 = q1_; - this.pool = pool_; - this.matched = matched_; - this.matchcap = matchcap_; - this.inputs = inputs_; - }); - inputs = $pkg.inputs = $newType(0, $kindStruct, "regexp.inputs", true, "regexp", false, function(bytes_, string_, reader_) { - this.$val = this; - if (arguments.length === 0) { - this.bytes = new inputBytes.ptr(sliceType$5.nil); - this.string = new inputString.ptr(""); - this.reader = new inputReader.ptr($ifaceNil, false, 0); - return; - } - this.bytes = bytes_; - this.string = string_; - this.reader = reader_; - }); - lazyFlag = $pkg.lazyFlag = $newType(8, $kindUint64, "regexp.lazyFlag", true, "regexp", false, null); - onePassMachine = $pkg.onePassMachine = $newType(0, $kindStruct, "regexp.onePassMachine", true, "regexp", false, function(inputs_, matchcap_) { - this.$val = this; - if (arguments.length === 0) { - this.inputs = new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)); - this.matchcap = sliceType$3.nil; - return; - } - this.inputs = inputs_; - this.matchcap = matchcap_; - }); - onePassProg = $pkg.onePassProg = $newType(0, $kindStruct, "regexp.onePassProg", true, "regexp", false, function(Inst_, Start_, NumCap_) { - this.$val = this; - if (arguments.length === 0) { - this.Inst = sliceType$6.nil; - this.Start = 0; - this.NumCap = 0; - return; - } - this.Inst = Inst_; - this.Start = Start_; - this.NumCap = NumCap_; - }); - onePassInst = $pkg.onePassInst = $newType(0, $kindStruct, "regexp.onePassInst", true, "regexp", false, function(Inst_, Next_) { - this.$val = this; - if (arguments.length === 0) { - this.Inst = new syntax.Inst.ptr(0, 0, 0, sliceType$1.nil); - this.Next = sliceType$2.nil; - return; - } - this.Inst = Inst_; - this.Next = Next_; - }); - queueOnePass = $pkg.queueOnePass = $newType(0, $kindStruct, "regexp.queueOnePass", true, "regexp", false, function(sparse_, dense_, size_, nextIndex_) { - this.$val = this; - if (arguments.length === 0) { - this.sparse = sliceType$2.nil; - this.dense = sliceType$2.nil; - this.size = 0; - this.nextIndex = 0; - return; - } - this.sparse = sparse_; - this.dense = dense_; - this.size = size_; - this.nextIndex = nextIndex_; - }); - runeSlice = $pkg.runeSlice = $newType(12, $kindSlice, "regexp.runeSlice", true, "regexp", false, null); - Regexp = $pkg.Regexp = $newType(0, $kindStruct, "regexp.Regexp", true, "regexp", true, function(expr_, prog_, onepass_, numSubexp_, maxBitStateLen_, subexpNames_, prefix_, prefixBytes_, prefixRune_, prefixEnd_, mpool_, matchcap_, prefixComplete_, cond_, longest_) { - this.$val = this; - if (arguments.length === 0) { - this.expr = ""; - this.prog = ptrType$12.nil; - this.onepass = ptrType$6.nil; - this.numSubexp = 0; - this.maxBitStateLen = 0; - this.subexpNames = sliceType$9.nil; - this.prefix = ""; - this.prefixBytes = sliceType$5.nil; - this.prefixRune = 0; - this.prefixEnd = 0; - this.mpool = 0; - this.matchcap = 0; - this.prefixComplete = false; - this.cond = 0; - this.longest = false; - return; - } - this.expr = expr_; - this.prog = prog_; - this.onepass = onepass_; - this.numSubexp = numSubexp_; - this.maxBitStateLen = maxBitStateLen_; - this.subexpNames = subexpNames_; - this.prefix = prefix_; - this.prefixBytes = prefixBytes_; - this.prefixRune = prefixRune_; - this.prefixEnd = prefixEnd_; - this.mpool = mpool_; - this.matchcap = matchcap_; - this.prefixComplete = prefixComplete_; - this.cond = cond_; - this.longest = longest_; - }); - input = $pkg.input = $newType(8, $kindInterface, "regexp.input", true, "regexp", false, null); - inputString = $pkg.inputString = $newType(0, $kindStruct, "regexp.inputString", true, "regexp", false, function(str_) { - this.$val = this; - if (arguments.length === 0) { - this.str = ""; - return; - } - this.str = str_; - }); - inputBytes = $pkg.inputBytes = $newType(0, $kindStruct, "regexp.inputBytes", true, "regexp", false, function(str_) { - this.$val = this; - if (arguments.length === 0) { - this.str = sliceType$5.nil; - return; - } - this.str = str_; - }); - inputReader = $pkg.inputReader = $newType(0, $kindStruct, "regexp.inputReader", true, "regexp", false, function(r_, atEOT_, pos_) { - this.$val = this; - if (arguments.length === 0) { - this.r = $ifaceNil; - this.atEOT = false; - this.pos = 0; - return; - } - this.r = r_; - this.atEOT = atEOT_; - this.pos = pos_; - }); - sliceType = $sliceType($emptyInterface); - arrayType = $arrayType($Int, 0); - arrayType$1 = $arrayType(nosync.Pool, 5); - arrayType$2 = $arrayType($Uint8, 16); - sliceType$1 = $sliceType($Int32); - sliceType$2 = $sliceType($Uint32); - ptrType = $ptrType(bitState); - sliceType$3 = $sliceType($Int); - sliceType$4 = $sliceType(job); - sliceType$5 = $sliceType($Uint8); - ptrType$1 = $ptrType(thread); - ptrType$2 = $ptrType(syntax.Inst); - ptrType$3 = $ptrType(lazyFlag); - ptrType$4 = $ptrType($Int); - ptrType$5 = $ptrType(onePassMachine); - ptrType$6 = $ptrType(onePassProg); - ptrType$7 = $ptrType(strings.Builder); - ptrType$8 = $ptrType(queueOnePass); - sliceType$6 = $sliceType(onePassInst); - ptrType$9 = $ptrType($Uint32); - sliceType$7 = $sliceType(sliceType$1); - ptrType$10 = $ptrType(sliceType$1); - sliceType$8 = $sliceType($Bool); - ptrType$11 = $ptrType(Regexp); - ptrType$12 = $ptrType(syntax.Prog); - sliceType$9 = $sliceType($String); - ptrType$13 = $ptrType(machine); - sliceType$10 = $sliceType(entry); - sliceType$11 = $sliceType(ptrType$1); - arrayType$3 = $arrayType($Int, 2); - arrayType$4 = $arrayType($Int, 4); - sliceType$12 = $sliceType(sliceType$5); - sliceType$13 = $sliceType(sliceType$3); - sliceType$14 = $sliceType(sliceType$12); - sliceType$15 = $sliceType(sliceType$9); - ptrType$14 = $ptrType(queue); - ptrType$15 = $ptrType(inputs); - funcType = $funcType([$String], [$String], false); - funcType$1 = $funcType([sliceType$5, sliceType$3], [sliceType$5], false); - funcType$2 = $funcType([sliceType$5], [sliceType$5], false); - funcType$3 = $funcType([sliceType$3], [], false); - ptrType$16 = $ptrType(inputString); - ptrType$17 = $ptrType(inputBytes); - ptrType$18 = $ptrType(inputReader); - newBitState = function() { - var _r, _tuple, b, ok, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; b = $f.b; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = bitStatePool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = $assertType(_r, ptrType, true); - b = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - b = new bitState.ptr(0, sliceType$3.nil, sliceType$3.nil, sliceType$4.nil, sliceType$2.nil, new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0))); - } - $s = -1; return b; - /* */ } return; } if ($f === undefined) { $f = { $blk: newBitState }; } $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f; - }; - freeBitState = function(b) { - var b; - b.inputs.clear(); - bitStatePool.Put(b); - }; - maxBitStateLen = function(prog) { - var _q, prog; - if (!shouldBacktrack(prog)) { - return 0; - } - return (_q = 262144 / prog.Inst.$length, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - }; - shouldBacktrack = function(prog) { - var prog; - return prog.Inst.$length <= 500; - }; - bitState.ptr.prototype.reset = function(prog, end, ncap) { - var _i, _i$1, _i$2, _q, _ref, _ref$1, _ref$2, b, end, i, i$1, i$2, ncap, prog, visitedSize, x, x$1, x$2; - b = this; - b.end = end; - if (b.jobs.$capacity === 0) { - b.jobs = $makeSlice(sliceType$4, 0, 256); - } else { - b.jobs = $subslice(b.jobs, 0, 0); - } - visitedSize = (_q = (((($imul(prog.Inst.$length, ((end + 1 >> 0)))) + 32 >> 0) - 1 >> 0)) / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - if (b.visited.$capacity < visitedSize) { - b.visited = $makeSlice(sliceType$2, visitedSize, 8192); - } else { - b.visited = $subslice(b.visited, 0, visitedSize); - _ref = b.visited; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - (x = b.visited, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i] = 0)); - _i++; - } - } - if (b.cap.$capacity < ncap) { - b.cap = $makeSlice(sliceType$3, ncap); - } else { - b.cap = $subslice(b.cap, 0, ncap); - } - _ref$1 = b.cap; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - (x$1 = b.cap, ((i$1 < 0 || i$1 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i$1] = -1)); - _i$1++; - } - if (b.matchcap.$capacity < ncap) { - b.matchcap = $makeSlice(sliceType$3, ncap); - } else { - b.matchcap = $subslice(b.matchcap, 0, ncap); - } - _ref$2 = b.matchcap; - _i$2 = 0; - while (true) { - if (!(_i$2 < _ref$2.$length)) { break; } - i$2 = _i$2; - (x$2 = b.matchcap, ((i$2 < 0 || i$2 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$2] = -1)); - _i$2++; - } - }; - bitState.prototype.reset = function(prog, end, ncap) { return this.$val.reset(prog, end, ncap); }; - bitState.ptr.prototype.shouldVisit = function(pc, pos) { - var _index, _q, _q$1, b, n, pc, pos, x, x$1, x$2, x$3, y, y$1; - b = this; - n = (((($imul(((pc >> 0)), ((b.end + 1 >> 0)))) + pos >> 0) >>> 0)); - if (!(((((x = b.visited, x$1 = (_q = n / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")), ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) & (((y = (((n & 31) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) { - return false; - } - _index = (_q$1 = n / 32, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); - (x$3 = b.visited, ((_index < 0 || _index >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + _index] = (((x$2 = b.visited, ((_index < 0 || _index >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + _index])) | (((y$1 = (((n & 31) >>> 0)), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0))); - return true; - }; - bitState.prototype.shouldVisit = function(pc, pos) { return this.$val.shouldVisit(pc, pos); }; - bitState.ptr.prototype.push = function(re, pc, pos, arg) { - var arg, b, pc, pos, re, x; - b = this; - if (!(((x = re.prog.Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])).Op === 5)) && (arg || b.shouldVisit(pc, pos))) { - b.jobs = $append(b.jobs, new job.ptr(pc, arg, pos)); - } - }; - bitState.prototype.push = function(re, pc, pos, arg) { return this.$val.push(re, pc, pos, arg); }; - Regexp.ptr.prototype.tryBacktrack = function(b, i, pc, pos) { - var _1, _2, _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, _tuple$2, _tuple$3, arg, b, flag, i, inst, l, longest, old, pc, pc$1, pos, pos$1, r, r$1, r$2, r$3, re, width, width$1, width$2, width$3, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; arg = $f.arg; b = $f.b; flag = $f.flag; i = $f.i; inst = $f.inst; l = $f.l; longest = $f.longest; old = $f.old; pc = $f.pc; pc$1 = $f.pc$1; pos = $f.pos; pos$1 = $f.pos$1; r = $f.r; r$1 = $f.r$1; r$2 = $f.r$2; r$3 = $f.r$3; re = $f.re; width = $f.width; width$1 = $f.width$1; width$2 = $f.width$2; width$3 = $f.width$3; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - longest = re.longest; - b.push(re, pc, pos, false); - /* while (true) { */ case 1: - /* if (!(b.jobs.$length > 0)) { break; } */ if(!(b.jobs.$length > 0)) { $s = 2; continue; } - l = b.jobs.$length - 1 >> 0; - pc$1 = (x = b.jobs, ((l < 0 || l >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + l])).pc; - pos$1 = (x$1 = b.jobs, ((l < 0 || l >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + l])).pos; - arg = (x$2 = b.jobs, ((l < 0 || l >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + l])).arg; - b.jobs = $subslice(b.jobs, 0, l); - /* goto Skip */ $s = 3; continue; - /* CheckAndLoop: */ case 4: - if (!b.shouldVisit(pc$1, pos$1)) { - /* continue; */ $s = 1; continue; - } - /* Skip: */ case 3: - inst = $clone((x$3 = re.prog.Inst, ((pc$1 < 0 || pc$1 >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc$1])), syntax.Inst); - _1 = inst.Op; - /* */ if (_1 === (5)) { $s = 6; continue; } - /* */ if (_1 === (0)) { $s = 7; continue; } - /* */ if (_1 === (1)) { $s = 8; continue; } - /* */ if (_1 === (7)) { $s = 9; continue; } - /* */ if (_1 === (8)) { $s = 10; continue; } - /* */ if (_1 === (10)) { $s = 11; continue; } - /* */ if (_1 === (9)) { $s = 12; continue; } - /* */ if (_1 === (2)) { $s = 13; continue; } - /* */ if (_1 === (3)) { $s = 14; continue; } - /* */ if (_1 === (6)) { $s = 15; continue; } - /* */ if (_1 === (4)) { $s = 16; continue; } - /* */ $s = 17; continue; - /* if (_1 === (5)) { */ case 6: - $panic(new $String("unexpected InstFail")); - $s = 18; continue; - /* } else if (_1 === (0)) { */ case 7: - /* */ if (arg) { $s = 19; continue; } - /* */ $s = 20; continue; - /* if (arg) { */ case 19: - arg = false; - pc$1 = inst.Arg; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 21; continue; - /* } else { */ case 20: - b.push(re, pc$1, pos$1, true); - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - /* } */ case 21: - $s = 18; continue; - /* } else if (_1 === (1)) { */ case 8: - _2 = (x$4 = re.prog.Inst, x$5 = inst.Out, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])).Op; - /* */ if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10))) { $s = 23; continue; } - /* */ $s = 24; continue; - /* if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10))) { */ case 23: - b.push(re, inst.Arg, pos$1, false); - pc$1 = inst.Arg; - pos$1 = b.end; - /* goto CheckAndLoop */ $s = 4; continue; - /* } */ case 24: - case 22: - b.push(re, inst.Out, b.end, false); - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (7)) { */ case 9: - _r = i.step(pos$1); /* */ $s = 25; case 25: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - width = _tuple[1]; - /* */ if (!inst.MatchRune(r)) { $s = 26; continue; } - /* */ $s = 27; continue; - /* if (!inst.MatchRune(r)) { */ case 26: - /* continue; */ $s = 1; continue; - /* } */ case 27: - pos$1 = pos$1 + (width) >> 0; - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (8)) { */ case 10: - _r$1 = i.step(pos$1); /* */ $s = 28; case 28: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - r$1 = _tuple$1[0]; - width$1 = _tuple$1[1]; - /* */ if (!((r$1 === (x$6 = inst.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))))) { $s = 29; continue; } - /* */ $s = 30; continue; - /* if (!((r$1 === (x$6 = inst.Rune, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0]))))) { */ case 29: - /* continue; */ $s = 1; continue; - /* } */ case 30: - pos$1 = pos$1 + (width$1) >> 0; - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (10)) { */ case 11: - _r$2 = i.step(pos$1); /* */ $s = 31; case 31: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$2 = _r$2; - r$2 = _tuple$2[0]; - width$2 = _tuple$2[1]; - /* */ if ((r$2 === 10) || (r$2 === -1)) { $s = 32; continue; } - /* */ $s = 33; continue; - /* if ((r$2 === 10) || (r$2 === -1)) { */ case 32: - /* continue; */ $s = 1; continue; - /* } */ case 33: - pos$1 = pos$1 + (width$2) >> 0; - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (9)) { */ case 12: - _r$3 = i.step(pos$1); /* */ $s = 34; case 34: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$3 = _r$3; - r$3 = _tuple$3[0]; - width$3 = _tuple$3[1]; - /* */ if (r$3 === -1) { $s = 35; continue; } - /* */ $s = 36; continue; - /* if (r$3 === -1) { */ case 35: - /* continue; */ $s = 1; continue; - /* } */ case 36: - pos$1 = pos$1 + (width$3) >> 0; - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (2)) { */ case 13: - /* */ if (arg) { $s = 37; continue; } - /* */ $s = 38; continue; - /* if (arg) { */ case 37: - (x$7 = b.cap, x$8 = inst.Arg, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8] = pos$1)); - /* continue; */ $s = 1; continue; - $s = 39; continue; - /* } else { */ case 38: - if (0 <= inst.Arg && inst.Arg < ((b.cap.$length >>> 0))) { - b.push(re, pc$1, (x$9 = b.cap, x$10 = inst.Arg, ((x$10 < 0 || x$10 >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + x$10])), true); - (x$11 = b.cap, x$12 = inst.Arg, ((x$12 < 0 || x$12 >= x$11.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + x$12] = pos$1)); - } - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - /* } */ case 39: - $s = 18; continue; - /* } else if (_1 === (3)) { */ case 14: - _r$4 = i.context(pos$1); /* */ $s = 40; case 40: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - flag = _r$4; - /* */ if (!flag.match(((inst.Arg << 24 >>> 24)))) { $s = 41; continue; } - /* */ $s = 42; continue; - /* if (!flag.match(((inst.Arg << 24 >>> 24)))) { */ case 41: - /* continue; */ $s = 1; continue; - /* } */ case 42: - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (6)) { */ case 15: - pc$1 = inst.Out; - /* goto CheckAndLoop */ $s = 4; continue; - $s = 18; continue; - /* } else if (_1 === (4)) { */ case 16: - if (b.cap.$length === 0) { - $s = -1; return true; - } - if (b.cap.$length > 1) { - (x$13 = b.cap, (1 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 1] = pos$1)); - } - old = (x$14 = b.matchcap, (1 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 1])); - if ((old === -1) || (longest && pos$1 > 0 && pos$1 > old)) { - $copySlice(b.matchcap, b.cap); - } - if (!longest) { - $s = -1; return true; - } - if (pos$1 === b.end) { - $s = -1; return true; - } - /* continue; */ $s = 1; continue; - $s = 18; continue; - /* } else { */ case 17: - $panic(new $String("bad inst")); - /* } */ case 18: - case 5: - /* } */ $s = 1; continue; case 2: - $s = -1; return longest && b.matchcap.$length > 1 && (x$15 = b.matchcap, (1 >= x$15.$length ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + 1])) >= 0; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.tryBacktrack }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.arg = arg; $f.b = b; $f.flag = flag; $f.i = i; $f.inst = inst; $f.l = l; $f.longest = longest; $f.old = old; $f.pc = pc; $f.pc$1 = pc$1; $f.pos = pos; $f.pos$1 = pos$1; $f.r = r; $f.r$1 = r$1; $f.r$2 = r$2; $f.r$3 = r$3; $f.re = re; $f.width = width; $f.width$1 = width$1; $f.width$2 = width$2; $f.width$3 = width$3; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.tryBacktrack = function(b, i, pc, pos) { return this.$val.tryBacktrack(b, i, pc, pos); }; - Regexp.ptr.prototype.backtrack = function(ib, is, pos, ncap, dstCap) { - var _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, advance, b, dstCap, end, i, ib, is, ncap, pos, re, startCond, width, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; advance = $f.advance; b = $f.b; dstCap = $f.dstCap; end = $f.end; i = $f.i; ib = $f.ib; is = $f.is; ncap = $f.ncap; pos = $f.pos; re = $f.re; startCond = $f.startCond; width = $f.width; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - startCond = re.cond; - if (startCond === 255) { - $s = -1; return sliceType$3.nil; - } - if (!((((startCond & 4) >>> 0) === 0)) && !((pos === 0))) { - $s = -1; return sliceType$3.nil; - } - _r = newBitState(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - b = _r; - _tuple = b.inputs.init($ifaceNil, ib, is); - i = _tuple[0]; - end = _tuple[1]; - b.reset(re.prog, end, ncap); - /* */ if (!((((startCond & 4) >>> 0) === 0))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((((startCond & 4) >>> 0) === 0))) { */ case 2: - if (b.cap.$length > 0) { - (x = b.cap, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0] = pos)); - } - _r$1 = re.tryBacktrack(b, i, ((re.prog.Start >>> 0)), pos); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (!_r$1) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (!_r$1) { */ case 5: - freeBitState(b); - $s = -1; return sliceType$3.nil; - /* } */ case 6: - $s = 4; continue; - /* } else { */ case 3: - width = -1; - /* while (true) { */ case 8: - /* if (!(pos <= end && !((width === 0)))) { break; } */ if(!(pos <= end && !((width === 0)))) { $s = 9; continue; } - /* */ if (re.prefix.length > 0) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (re.prefix.length > 0) { */ case 10: - _r$2 = i.index(re, pos); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - advance = _r$2; - if (advance < 0) { - freeBitState(b); - $s = -1; return sliceType$3.nil; - } - pos = pos + (advance) >> 0; - /* } */ case 11: - if (b.cap.$length > 0) { - (x$1 = b.cap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = pos)); - } - _r$3 = re.tryBacktrack(b, i, ((re.prog.Start >>> 0)), pos); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (_r$3) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (_r$3) { */ case 13: - /* goto Match */ $s = 16; continue; - /* } */ case 14: - _r$4 = i.step(pos); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple$1 = _r$4; - width = _tuple$1[1]; - pos = pos + (width) >> 0; - /* } */ $s = 8; continue; case 9: - freeBitState(b); - $s = -1; return sliceType$3.nil; - /* } */ case 4: - /* Match: */ case 16: - dstCap = $appendSlice(dstCap, b.matchcap); - freeBitState(b); - $s = -1; return dstCap; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.backtrack }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.advance = advance; $f.b = b; $f.dstCap = dstCap; $f.end = end; $f.i = i; $f.ib = ib; $f.is = is; $f.ncap = ncap; $f.pos = pos; $f.re = re; $f.startCond = startCond; $f.width = width; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.backtrack = function(ib, is, pos, ncap, dstCap) { return this.$val.backtrack(ib, is, pos, ncap, dstCap); }; - inputs.ptr.prototype.newBytes = function(b) { - var b, i; - i = this; - i.bytes.str = b; - return i.bytes; - }; - inputs.prototype.newBytes = function(b) { return this.$val.newBytes(b); }; - inputs.ptr.prototype.newString = function(s) { - var i, s; - i = this; - i.string.str = s; - return i.string; - }; - inputs.prototype.newString = function(s) { return this.$val.newString(s); }; - inputs.ptr.prototype.newReader = function(r) { - var i, r; - i = this; - i.reader.r = r; - i.reader.atEOT = false; - i.reader.pos = 0; - return i.reader; - }; - inputs.prototype.newReader = function(r) { return this.$val.newReader(r); }; - inputs.ptr.prototype.clear = function() { - var i; - i = this; - if (!(i.bytes.str === sliceType$5.nil)) { - i.bytes.str = sliceType$5.nil; - } else if (!($interfaceIsEqual(i.reader.r, $ifaceNil))) { - i.reader.r = $ifaceNil; - } else { - i.string.str = ""; - } - }; - inputs.prototype.clear = function() { return this.$val.clear(); }; - inputs.ptr.prototype.init = function(r, b, s) { - var b, i, r, s; - i = this; - if (!($interfaceIsEqual(r, $ifaceNil))) { - return [i.newReader(r), 0]; - } - if (!(b === sliceType$5.nil)) { - return [i.newBytes(b), b.$length]; - } - return [i.newString(s), s.length]; - }; - inputs.prototype.init = function(r, b, s) { return this.$val.init(r, b, s); }; - machine.ptr.prototype.init = function(ncap) { - var _i, _ref, m, ncap, t; - m = this; - _ref = m.pool; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - t = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - t.cap = $subslice(t.cap, 0, ncap); - _i++; - } - m.matchcap = $subslice(m.matchcap, 0, ncap); - }; - machine.prototype.init = function(ncap) { return this.$val.init(ncap); }; - machine.ptr.prototype.alloc = function(i) { - var i, m, n, t, x, x$1; - m = this; - t = ptrType$1.nil; - n = m.pool.$length; - if (n > 0) { - t = (x = m.pool, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - m.pool = $subslice(m.pool, 0, (n - 1 >> 0)); - } else { - t = new thread.ptr(ptrType$2.nil, sliceType$3.nil); - t.cap = $makeSlice(sliceType$3, m.matchcap.$length, m.matchcap.$capacity); - } - t.inst = i; - return t; - }; - machine.prototype.alloc = function(i) { return this.$val.alloc(i); }; - newLazyFlag = function(r1, r2) { - var r1, r2, x, x$1, x$2; - return ((x = (x$1 = $shiftLeft64((new $Uint64(0, r1)), 32), x$2 = (new $Uint64(0, ((r2 >>> 0)))), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0)), new lazyFlag(x.$high, x.$low))); - }; - lazyFlag.prototype.match = function(op) { - var f, op, r1, r2; - f = this; - if (op === 0) { - return true; - } - r1 = (($shiftRightUint64(f, 32).$low >> 0)); - if (!((((op & 1) >>> 0) === 0))) { - if (!((r1 === 10)) && r1 >= 0) { - return false; - } - op = (op & ~(1)) << 24 >>> 24; - } - if (!((((op & 4) >>> 0) === 0))) { - if (r1 >= 0) { - return false; - } - op = (op & ~(4)) << 24 >>> 24; - } - if (op === 0) { - return true; - } - r2 = ((f.$low >> 0)); - if (!((((op & 2) >>> 0) === 0))) { - if (!((r2 === 10)) && r2 >= 0) { - return false; - } - op = (op & ~(2)) << 24 >>> 24; - } - if (!((((op & 8) >>> 0) === 0))) { - if (r2 >= 0) { - return false; - } - op = (op & ~(8)) << 24 >>> 24; - } - if (op === 0) { - return true; - } - if (!(syntax.IsWordChar(r1) === syntax.IsWordChar(r2))) { - op = (op & ~(16)) << 24 >>> 24; - } else { - op = (op & ~(32)) << 24 >>> 24; - } - return op === 0; - }; - $ptrType(lazyFlag).prototype.match = function(op) { return this.$get().match(op); }; - machine.ptr.prototype.match = function(i, pos) { - var _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _v, advance, flag, i, i$1, m, nextq, pos, r, r1, runq, startCond, width, width1, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _v = $f._v; advance = $f.advance; flag = $f.flag; i = $f.i; i$1 = $f.i$1; m = $f.m; nextq = $f.nextq; pos = $f.pos; r = $f.r; r1 = $f.r1; runq = $f.runq; startCond = $f.startCond; width = $f.width; width1 = $f.width1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - flag = [flag]; - m = this; - startCond = m.re.cond; - if (startCond === 255) { - $s = -1; return false; - } - m.matched = false; - _ref = m.matchcap; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i$1 = _i; - (x = m.matchcap, ((i$1 < 0 || i$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i$1] = -1)); - _i++; - } - _tmp = m.q0; - _tmp$1 = m.q1; - runq = _tmp; - nextq = _tmp$1; - _tmp$2 = -1; - _tmp$3 = -1; - r = _tmp$2; - r1 = _tmp$3; - _tmp$4 = 0; - _tmp$5 = 0; - width = _tmp$4; - width1 = _tmp$5; - _r = i.step(pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - width = _tuple[1]; - /* */ if (!((r === -1))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!((r === -1))) { */ case 2: - _r$1 = i.step(pos + width >> 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - r1 = _tuple$1[0]; - width1 = _tuple$1[1]; - /* } */ case 3: - flag[0] = new lazyFlag(0, 0); - /* */ if (pos === 0) { $s = 5; continue; } - /* */ $s = 6; continue; - /* if (pos === 0) { */ case 5: - flag[0] = newLazyFlag(-1, r); - $s = 7; continue; - /* } else { */ case 6: - _r$2 = i.context(pos); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - flag[0] = _r$2; - /* } */ case 7: - /* while (true) { */ case 9: - /* */ if (runq.dense.$length === 0) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (runq.dense.$length === 0) { */ case 11: - if (!((((startCond & 4) >>> 0) === 0)) && !((pos === 0))) { - /* break; */ $s = 10; continue; - } - if (m.matched) { - /* break; */ $s = 10; continue; - } - if (!(m.re.prefix.length > 0 && !((r1 === m.re.prefixRune)))) { _v = false; $s = 15; continue s; } - _r$3 = i.canCheckPrefix(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _v = _r$3; case 15: - /* */ if (_v) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (_v) { */ case 13: - _r$4 = i.index(m.re, pos); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - advance = _r$4; - if (advance < 0) { - /* break; */ $s = 10; continue; - } - pos = pos + (advance) >> 0; - _r$5 = i.step(pos); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$2 = _r$5; - r = _tuple$2[0]; - width = _tuple$2[1]; - _r$6 = i.step(pos + width >> 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple$3 = _r$6; - r1 = _tuple$3[0]; - width1 = _tuple$3[1]; - /* } */ case 14: - /* } */ case 12: - if (!m.matched) { - if (m.matchcap.$length > 0) { - (x$1 = m.matchcap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0] = pos)); - } - m.add(runq, ((m.p.Start >>> 0)), pos, m.matchcap, (flag.$ptr || (flag.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, flag))), ptrType$1.nil); - } - flag[0] = newLazyFlag(r, r1); - m.step(runq, nextq, pos, pos + width >> 0, r, (flag.$ptr || (flag.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, flag)))); - if (width === 0) { - /* break; */ $s = 10; continue; - } - if ((m.matchcap.$length === 0) && m.matched) { - /* break; */ $s = 10; continue; - } - pos = pos + (width) >> 0; - _tmp$6 = r1; - _tmp$7 = width1; - r = _tmp$6; - width = _tmp$7; - /* */ if (!((r === -1))) { $s = 20; continue; } - /* */ $s = 21; continue; - /* if (!((r === -1))) { */ case 20: - _r$7 = i.step(pos + width >> 0); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _tuple$4 = _r$7; - r1 = _tuple$4[0]; - width1 = _tuple$4[1]; - /* } */ case 21: - _tmp$8 = nextq; - _tmp$9 = runq; - runq = _tmp$8; - nextq = _tmp$9; - /* } */ $s = 9; continue; case 10: - m.clear(nextq); - $s = -1; return m.matched; - /* */ } return; } if ($f === undefined) { $f = { $blk: machine.ptr.prototype.match }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._v = _v; $f.advance = advance; $f.flag = flag; $f.i = i; $f.i$1 = i$1; $f.m = m; $f.nextq = nextq; $f.pos = pos; $f.r = r; $f.r1 = r1; $f.runq = runq; $f.startCond = startCond; $f.width = width; $f.width1 = width1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - machine.prototype.match = function(i, pos) { return this.$val.match(i, pos); }; - machine.ptr.prototype.clear = function(q) { - var _i, _ref, d, m, q; - m = this; - _ref = q.dense; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - d = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), entry); - if (!(d.t === ptrType$1.nil)) { - m.pool = $append(m.pool, d.t); - } - _i++; - } - q.dense = $subslice(q.dense, 0, 0); - }; - machine.prototype.clear = function(q) { return this.$val.clear(q); }; - machine.ptr.prototype.step = function(runq, nextq, pos, nextPos, c, nextCond) { - var _1, _i, _ref, add, c, d, d$1, i, j, longest, m, nextCond, nextPos, nextq, pos, runq, t, x, x$1, x$2, x$3, x$4, x$5; - m = this; - longest = m.re.longest; - j = 0; - while (true) { - if (!(j < runq.dense.$length)) { break; } - d = (x = runq.dense, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); - t = d.t; - if (t === ptrType$1.nil) { - j = j + (1) >> 0; - continue; - } - if (longest && m.matched && t.cap.$length > 0 && (x$1 = m.matchcap, (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])) < (x$2 = t.cap, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0]))) { - m.pool = $append(m.pool, t); - j = j + (1) >> 0; - continue; - } - i = t.inst; - add = false; - _1 = i.Op; - if (_1 === (4)) { - if (t.cap.$length > 0 && (!longest || !m.matched || (x$3 = m.matchcap, (1 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 1])) < pos)) { - (x$4 = t.cap, (1 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 1] = pos)); - $copySlice(m.matchcap, t.cap); - } - if (!longest) { - _ref = $subslice(runq.dense, (j + 1 >> 0)); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - d$1 = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), entry); - if (!(d$1.t === ptrType$1.nil)) { - m.pool = $append(m.pool, d$1.t); - } - _i++; - } - runq.dense = $subslice(runq.dense, 0, 0); - } - m.matched = true; - } else if (_1 === (7)) { - add = i.MatchRune(c); - } else if (_1 === (8)) { - add = c === (x$5 = i.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0])); - } else if (_1 === (9)) { - add = true; - } else if (_1 === (10)) { - add = !((c === 10)); - } else { - $panic(new $String("bad inst")); - } - if (add) { - t = m.add(nextq, i.Out, nextPos, t.cap, nextCond, t); - } - if (!(t === ptrType$1.nil)) { - m.pool = $append(m.pool, t); - } - j = j + (1) >> 0; - } - runq.dense = $subslice(runq.dense, 0, 0); - }; - machine.prototype.step = function(runq, nextq, pos, nextPos, c, nextCond) { return this.$val.step(runq, nextq, pos, nextPos, c, nextCond); }; - machine.ptr.prototype.add = function(q, pc, pos, cap, cond, t) { - var _1, cap, cond, d, i, j, j$1, m, opos, pc, pos, q, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, $s; - /* */ $s = 0; s: while (true) { switch ($s) { case 0: - m = this; - /* Again: */ case 1: - if (pc === 0) { - $s = -1; return t; - } - j = (x = q.sparse, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); - if (j < ((q.dense.$length >>> 0)) && ((x$1 = q.dense, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])).pc === pc)) { - $s = -1; return t; - } - j$1 = q.dense.$length; - q.dense = $subslice(q.dense, 0, (j$1 + 1 >> 0)); - d = (x$2 = q.dense, ((j$1 < 0 || j$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + j$1])); - d.t = ptrType$1.nil; - d.pc = pc; - (x$3 = q.sparse, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc] = ((j$1 >>> 0)))); - i = (x$4 = m.p.Inst, ((pc < 0 || pc >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + pc])); - _1 = i.Op; - /* */ if (_1 === (5)) { $s = 3; continue; } - /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 4; continue; } - /* */ if (_1 === (3)) { $s = 5; continue; } - /* */ if (_1 === (6)) { $s = 6; continue; } - /* */ if (_1 === (2)) { $s = 7; continue; } - /* */ if ((_1 === (4)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10))) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (_1 === (5)) { */ case 3: - $s = 10; continue; - /* } else if ((_1 === (0)) || (_1 === (1))) { */ case 4: - t = m.add(q, i.Out, pos, cap, cond, t); - pc = i.Arg; - /* goto Again */ $s = 1; continue; - $s = 10; continue; - /* } else if (_1 === (3)) { */ case 5: - /* */ if (cond.match(((i.Arg << 24 >>> 24)))) { $s = 11; continue; } - /* */ $s = 12; continue; - /* if (cond.match(((i.Arg << 24 >>> 24)))) { */ case 11: - pc = i.Out; - /* goto Again */ $s = 1; continue; - /* } */ case 12: - $s = 10; continue; - /* } else if (_1 === (6)) { */ case 6: - pc = i.Out; - /* goto Again */ $s = 1; continue; - $s = 10; continue; - /* } else if (_1 === (2)) { */ case 7: - /* */ if (((i.Arg >> 0)) < cap.$length) { $s = 13; continue; } - /* */ $s = 14; continue; - /* if (((i.Arg >> 0)) < cap.$length) { */ case 13: - opos = (x$5 = i.Arg, ((x$5 < 0 || x$5 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$5])); - (x$6 = i.Arg, ((x$6 < 0 || x$6 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$6] = pos)); - m.add(q, i.Out, pos, cap, cond, ptrType$1.nil); - (x$7 = i.Arg, ((x$7 < 0 || x$7 >= cap.$length) ? ($throwRuntimeError("index out of range"), undefined) : cap.$array[cap.$offset + x$7] = opos)); - $s = 15; continue; - /* } else { */ case 14: - pc = i.Out; - /* goto Again */ $s = 1; continue; - /* } */ case 15: - $s = 10; continue; - /* } else if ((_1 === (4)) || (_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10))) { */ case 8: - if (t === ptrType$1.nil) { - t = m.alloc(i); - } else { - t.inst = i; - } - if (cap.$length > 0 && !((x$8 = t.cap, $indexPtr(x$8.$array, x$8.$offset + 0, ptrType$4)) === $indexPtr(cap.$array, cap.$offset + 0, ptrType$4))) { - $copySlice(t.cap, cap); - } - d.t = t; - t = ptrType$1.nil; - $s = 10; continue; - /* } else { */ case 9: - $panic(new $String("unhandled")); - /* } */ case 10: - case 2: - $s = -1; return t; - /* */ } return; } - }; - machine.prototype.add = function(q, pc, pos, cap, cond, t) { return this.$val.add(q, pc, pos, cap, cond, t); }; - newOnePassMachine = function() { - var _r, _tuple, m, ok, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; m = $f.m; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = onePassPool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = $assertType(_r, ptrType$5, true); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = new onePassMachine.ptr(new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0)), sliceType$3.nil); - } - $s = -1; return m; - /* */ } return; } if ($f === undefined) { $f = { $blk: newOnePassMachine }; } $f._r = _r; $f._tuple = _tuple; $f.m = m; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f; - }; - freeOnePassMachine = function(m) { - var m; - m.inputs.clear(); - onePassPool.Put(m); - }; - Regexp.ptr.prototype.doOnePass = function(ir, ib, is, pos, ncap, dstCap) { - var _1, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _v, dstCap, flag, i, i$1, ib, inst, ir, is, m, matched, ncap, pc, pos, r, r1, re, startCond, width, width1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _v = $f._v; dstCap = $f.dstCap; flag = $f.flag; i = $f.i; i$1 = $f.i$1; ib = $f.ib; inst = $f.inst; ir = $f.ir; is = $f.is; m = $f.m; matched = $f.matched; ncap = $f.ncap; pc = $f.pc; pos = $f.pos; r = $f.r; r1 = $f.r1; re = $f.re; startCond = $f.startCond; width = $f.width; width1 = $f.width1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - inst = [inst]; - re = this; - startCond = re.cond; - if (startCond === 255) { - $s = -1; return sliceType$3.nil; - } - _r = newOnePassMachine(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - m = _r; - if (m.matchcap.$capacity < ncap) { - m.matchcap = $makeSlice(sliceType$3, ncap); - } else { - m.matchcap = $subslice(m.matchcap, 0, ncap); - } - matched = false; - _ref = m.matchcap; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - (x = m.matchcap, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i] = -1)); - _i++; - } - _tuple = m.inputs.init(ir, ib, is); - i$1 = _tuple[0]; - _tmp = -1; - _tmp$1 = -1; - r = _tmp; - r1 = _tmp$1; - _tmp$2 = 0; - _tmp$3 = 0; - width = _tmp$2; - width1 = _tmp$3; - _r$1 = i$1.step(pos); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - r = _tuple$1[0]; - width = _tuple$1[1]; - /* */ if (!((r === -1))) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!((r === -1))) { */ case 3: - _r$2 = i$1.step(pos + width >> 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple$2 = _r$2; - r1 = _tuple$2[0]; - width1 = _tuple$2[1]; - /* } */ case 4: - flag = new lazyFlag(0, 0); - /* */ if (pos === 0) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (pos === 0) { */ case 6: - flag = newLazyFlag(-1, r); - $s = 8; continue; - /* } else { */ case 7: - _r$3 = i$1.context(pos); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - flag = _r$3; - /* } */ case 8: - pc = re.onepass.Start; - inst[0] = $clone((x$1 = re.onepass.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])), onePassInst); - if (!((pos === 0) && flag.match(((inst[0].Inst.Arg << 24 >>> 24))) && re.prefix.length > 0)) { _v = false; $s = 12; continue s; } - _r$4 = i$1.canCheckPrefix(); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _v = _r$4; case 12: - /* */ if (_v) { $s = 10; continue; } - /* */ $s = 11; continue; - /* if (_v) { */ case 10: - _r$5 = i$1.hasPrefix(re); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - /* */ if (!_r$5) { $s = 14; continue; } - /* */ $s = 15; continue; - /* if (!_r$5) { */ case 14: - /* goto Return */ $s = 17; continue; - /* } */ case 15: - pos = pos + (re.prefix.length) >> 0; - _r$6 = i$1.step(pos); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _tuple$3 = _r$6; - r = _tuple$3[0]; - width = _tuple$3[1]; - _r$7 = i$1.step(pos + width >> 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _tuple$4 = _r$7; - r1 = _tuple$4[0]; - width1 = _tuple$4[1]; - _r$8 = i$1.context(pos); /* */ $s = 20; case 20: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - flag = _r$8; - pc = ((re.prefixEnd >> 0)); - /* } */ case 11: - /* while (true) { */ case 21: - onePassInst.copy(inst[0], (x$2 = re.onepass.Inst, ((pc < 0 || pc >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pc]))); - pc = ((inst[0].Inst.Out >> 0)); - _1 = inst[0].Inst.Op; - /* */ if (_1 === (4)) { $s = 24; continue; } - /* */ if (_1 === (7)) { $s = 25; continue; } - /* */ if (_1 === (8)) { $s = 26; continue; } - /* */ if (_1 === (9)) { $s = 27; continue; } - /* */ if (_1 === (10)) { $s = 28; continue; } - /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 29; continue; } - /* */ if (_1 === (5)) { $s = 30; continue; } - /* */ if (_1 === (6)) { $s = 31; continue; } - /* */ if (_1 === (3)) { $s = 32; continue; } - /* */ if (_1 === (2)) { $s = 33; continue; } - /* */ $s = 34; continue; - /* if (_1 === (4)) { */ case 24: - matched = true; - if (m.matchcap.$length > 0) { - (x$3 = m.matchcap, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0] = 0)); - (x$4 = m.matchcap, (1 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 1] = pos)); - } - /* goto Return */ $s = 17; continue; - $s = 35; continue; - /* } else if (_1 === (7)) { */ case 25: - /* */ if (!inst[0].Inst.MatchRune(r)) { $s = 36; continue; } - /* */ $s = 37; continue; - /* if (!inst[0].Inst.MatchRune(r)) { */ case 36: - /* goto Return */ $s = 17; continue; - /* } */ case 37: - $s = 35; continue; - /* } else if (_1 === (8)) { */ case 26: - /* */ if (!((r === (x$5 = inst[0].Inst.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0]))))) { $s = 38; continue; } - /* */ $s = 39; continue; - /* if (!((r === (x$5 = inst[0].Inst.Rune, (0 >= x$5.$length ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + 0]))))) { */ case 38: - /* goto Return */ $s = 17; continue; - /* } */ case 39: - $s = 35; continue; - /* } else if (_1 === (9)) { */ case 27: - $s = 35; continue; - /* } else if (_1 === (10)) { */ case 28: - /* */ if (r === 10) { $s = 40; continue; } - /* */ $s = 41; continue; - /* if (r === 10) { */ case 40: - /* goto Return */ $s = 17; continue; - /* } */ case 41: - $s = 35; continue; - /* } else if ((_1 === (0)) || (_1 === (1))) { */ case 29: - pc = ((onePassNext(inst[0], r) >> 0)); - /* continue; */ $s = 21; continue; - $s = 35; continue; - /* } else if (_1 === (5)) { */ case 30: - /* goto Return */ $s = 17; continue; - $s = 35; continue; - /* } else if (_1 === (6)) { */ case 31: - /* continue; */ $s = 21; continue; - $s = 35; continue; - /* } else if (_1 === (3)) { */ case 32: - /* */ if (!flag.match(((inst[0].Inst.Arg << 24 >>> 24)))) { $s = 42; continue; } - /* */ $s = 43; continue; - /* if (!flag.match(((inst[0].Inst.Arg << 24 >>> 24)))) { */ case 42: - /* goto Return */ $s = 17; continue; - /* } */ case 43: - /* continue; */ $s = 21; continue; - $s = 35; continue; - /* } else if (_1 === (2)) { */ case 33: - if (((inst[0].Inst.Arg >> 0)) < m.matchcap.$length) { - (x$6 = m.matchcap, x$7 = inst[0].Inst.Arg, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7] = pos)); - } - /* continue; */ $s = 21; continue; - $s = 35; continue; - /* } else { */ case 34: - $panic(new $String("bad inst")); - /* } */ case 35: - case 23: - if (width === 0) { - /* break; */ $s = 22; continue; - } - flag = newLazyFlag(r, r1); - pos = pos + (width) >> 0; - _tmp$4 = r1; - _tmp$5 = width1; - r = _tmp$4; - width = _tmp$5; - /* */ if (!((r === -1))) { $s = 44; continue; } - /* */ $s = 45; continue; - /* if (!((r === -1))) { */ case 44: - _r$9 = i$1.step(pos + width >> 0); /* */ $s = 46; case 46: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _tuple$5 = _r$9; - r1 = _tuple$5[0]; - width1 = _tuple$5[1]; - /* } */ case 45: - /* } */ $s = 21; continue; case 22: - /* Return: */ case 17: - if (!matched) { - freeOnePassMachine(m); - $s = -1; return sliceType$3.nil; - } - dstCap = $appendSlice(dstCap, m.matchcap); - freeOnePassMachine(m); - $s = -1; return dstCap; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doOnePass }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._v = _v; $f.dstCap = dstCap; $f.flag = flag; $f.i = i; $f.i$1 = i$1; $f.ib = ib; $f.inst = inst; $f.ir = ir; $f.is = is; $f.m = m; $f.matched = matched; $f.ncap = ncap; $f.pc = pc; $f.pos = pos; $f.r = r; $f.r1 = r1; $f.re = re; $f.startCond = startCond; $f.width = width; $f.width1 = width1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.doOnePass = function(ir, ib, is, pos, ncap, dstCap) { return this.$val.doOnePass(ir, ib, is, pos, ncap, dstCap); }; - Regexp.ptr.prototype.doMatch = function(r, b, s) { - var _r, b, r, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; r = $f.r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doExecute(r, b, s, 0, 0, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return !(_r === sliceType$3.nil); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doMatch }; } $f._r = _r; $f.b = b; $f.r = r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.doMatch = function(r, b, s) { return this.$val.doMatch(r, b, s); }; - Regexp.ptr.prototype.doExecute = function(r, b, s, pos, ncap, dstCap) { - var _r, _r$1, _r$2, _r$3, _tuple, b, dstCap, i, m, ncap, pos, r, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; b = $f.b; dstCap = $f.dstCap; i = $f.i; m = $f.m; ncap = $f.ncap; pos = $f.pos; r = $f.r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - if (dstCap === sliceType$3.nil) { - dstCap = $subslice(new sliceType$3(arrayNoInts), 0, 0, 0); - } - /* */ if (!(re.onepass === ptrType$6.nil)) { $s = 1; continue; } - /* */ $s = 2; continue; - /* if (!(re.onepass === ptrType$6.nil)) { */ case 1: - _r = re.doOnePass(r, b, s, pos, ncap, dstCap); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* } */ case 2: - /* */ if ($interfaceIsEqual(r, $ifaceNil) && (b.$length + s.length >> 0) < re.maxBitStateLen) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ($interfaceIsEqual(r, $ifaceNil) && (b.$length + s.length >> 0) < re.maxBitStateLen) { */ case 4: - _r$1 = re.backtrack(b, s, pos, ncap, dstCap); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* } */ case 5: - _r$2 = re.get(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - m = _r$2; - _tuple = m.inputs.init(r, b, s); - i = _tuple[0]; - m.init(ncap); - _r$3 = m.match(i, pos); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - /* */ if (!_r$3) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (!_r$3) { */ case 8: - re.put(m); - $s = -1; return sliceType$3.nil; - /* } */ case 9: - dstCap = $appendSlice(dstCap, m.matchcap); - re.put(m); - $s = -1; return dstCap; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.doExecute }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.b = b; $f.dstCap = dstCap; $f.i = i; $f.m = m; $f.ncap = ncap; $f.pos = pos; $f.r = r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.doExecute = function(r, b, s, pos, ncap, dstCap) { return this.$val.doExecute(r, b, s, pos, ncap, dstCap); }; - onePassPrefix = function(p) { - var _tmp, _tmp$1, _tmp$10, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, buf, complete, i, p, pc, prefix, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; - prefix = ""; - complete = false; - pc = 0; - i = (x = p.Inst, x$1 = p.Start, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - if (!((i.Op === 3)) || ((((((i.Arg << 24 >>> 24))) & 4) >>> 0) === 0)) { - _tmp = ""; - _tmp$1 = i.Op === 4; - _tmp$2 = ((p.Start >>> 0)); - prefix = _tmp; - complete = _tmp$1; - pc = _tmp$2; - return [prefix, complete, pc]; - } - pc = i.Out; - i = (x$2 = p.Inst, ((pc < 0 || pc >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pc])); - while (true) { - if (!(i.Op === 6)) { break; } - pc = i.Out; - i = (x$3 = p.Inst, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc])); - } - if (!((iop(i) === 7)) || !((i.Rune.$length === 1))) { - _tmp$3 = ""; - _tmp$4 = i.Op === 4; - _tmp$5 = ((p.Start >>> 0)); - prefix = _tmp$3; - complete = _tmp$4; - pc = _tmp$5; - return [prefix, complete, pc]; - } - buf = new strings.Builder.ptr(ptrType$7.nil, sliceType$5.nil); - while (true) { - if (!((iop(i) === 7) && (i.Rune.$length === 1) && (((((i.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { break; } - buf.WriteRune((x$4 = i.Rune, (0 >= x$4.$length ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + 0]))); - _tmp$6 = i.Out; - _tmp$7 = (x$5 = p.Inst, x$6 = i.Out, ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6])); - pc = _tmp$6; - i = _tmp$7; - } - if ((i.Op === 3) && !((((((i.Arg << 24 >>> 24)) & 8) >>> 0) === 0)) && ((x$7 = p.Inst, x$8 = i.Out, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8])).Op === 4)) { - complete = true; - } - _tmp$8 = buf.String(); - _tmp$9 = complete; - _tmp$10 = pc; - prefix = _tmp$8; - complete = _tmp$9; - pc = _tmp$10; - return [prefix, complete, pc]; - }; - onePassNext = function(i, r) { - var i, next, r, x; - next = i.Inst.MatchRunePos(r); - if (next >= 0) { - return (x = i.Next, ((next < 0 || next >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + next])); - } - if (i.Inst.Op === 1) { - return i.Inst.Out; - } - return 0; - }; - iop = function(i) { - var _1, i, op; - op = i.Op; - _1 = op; - if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { - op = 7; - } - return op; - }; - queueOnePass.ptr.prototype.empty = function() { - var q; - q = this; - return q.nextIndex >= q.size; - }; - queueOnePass.prototype.empty = function() { return this.$val.empty(); }; - queueOnePass.ptr.prototype.next = function() { - var n, q, x, x$1; - n = 0; - q = this; - n = (x = q.dense, x$1 = q.nextIndex, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); - q.nextIndex = q.nextIndex + (1) >>> 0; - return n; - }; - queueOnePass.prototype.next = function() { return this.$val.next(); }; - queueOnePass.ptr.prototype.clear = function() { - var q; - q = this; - q.size = 0; - q.nextIndex = 0; - }; - queueOnePass.prototype.clear = function() { return this.$val.clear(); }; - queueOnePass.ptr.prototype.contains = function(u) { - var q, u, x, x$1, x$2, x$3; - q = this; - if (u >= ((q.sparse.$length >>> 0))) { - return false; - } - return (x = q.sparse, ((u < 0 || u >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + u])) < q.size && ((x$1 = q.dense, x$2 = (x$3 = q.sparse, ((u < 0 || u >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + u])), ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2])) === u); - }; - queueOnePass.prototype.contains = function(u) { return this.$val.contains(u); }; - queueOnePass.ptr.prototype.insert = function(u) { - var q, u; - q = this; - if (!q.contains(u)) { - q.insertNew(u); - } - }; - queueOnePass.prototype.insert = function(u) { return this.$val.insert(u); }; - queueOnePass.ptr.prototype.insertNew = function(u) { - var q, u, x, x$1, x$2; - q = this; - if (u >= ((q.sparse.$length >>> 0))) { - return; - } - (x = q.sparse, ((u < 0 || u >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + u] = q.size)); - (x$1 = q.dense, x$2 = q.size, ((x$2 < 0 || x$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + x$2] = u)); - q.size = q.size + (1) >>> 0; - }; - queueOnePass.prototype.insertNew = function(u) { return this.$val.insertNew(u); }; - newQueue = function(size) { - var q, size; - q = ptrType$8.nil; - q = new queueOnePass.ptr($makeSlice(sliceType$2, size), $makeSlice(sliceType$2, size), 0, 0); - return q; - }; - mergeRuneSets = function(leftRunes, rightRunes, leftPC, rightPC) { - var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, extend, ix, leftLen, leftPC, leftRunes, lx, merged, next, ok, rightLen, rightPC, rightRunes, rx, x, x$1, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; extend = $f.extend; ix = $f.ix; leftLen = $f.leftLen; leftPC = $f.leftPC; leftRunes = $f.leftRunes; lx = $f.lx; merged = $f.merged; next = $f.next; ok = $f.ok; rightLen = $f.rightLen; rightPC = $f.rightPC; rightRunes = $f.rightRunes; rx = $f.rx; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - ix = [ix]; - lx = [lx]; - merged = [merged]; - next = [next]; - ok = [ok]; - rx = [rx]; - leftLen = leftRunes.$get().$length; - rightLen = rightRunes.$get().$length; - if (!(((leftLen & 1) === 0)) || !(((rightLen & 1) === 0))) { - $panic(new $String("mergeRuneSets odd length []rune")); - } - _tmp = 0; - _tmp$1 = 0; - lx[0] = _tmp; - rx[0] = _tmp$1; - merged[0] = $makeSlice(sliceType$1, 0); - next[0] = $makeSlice(sliceType$2, 0); - ok[0] = true; - $deferred.push([(function(ix, lx, merged, next, ok, rx) { return function() { - if (!ok[0]) { - merged[0] = sliceType$1.nil; - next[0] = sliceType$2.nil; - } - }; })(ix, lx, merged, next, ok, rx), []]); - ix[0] = -1; - extend = (function(ix, lx, merged, next, ok, rx) { return function(newLow, newArray, pc) { - var newArray, newLow, pc, x, x$1, x$2, x$3, x$4, x$5; - if (ix[0] > 0 && (x = newArray.$get(), x$1 = newLow.$get(), ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) <= ((ix[0] < 0 || ix[0] >= merged[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : merged[0].$array[merged[0].$offset + ix[0]])) { - return false; - } - merged[0] = $append(merged[0], (x$2 = newArray.$get(), x$3 = newLow.$get(), ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])), (x$4 = newArray.$get(), x$5 = newLow.$get() + 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5]))); - newLow.$set(newLow.$get() + (2) >> 0); - ix[0] = ix[0] + (2) >> 0; - next[0] = $append(next[0], pc); - return true; - }; })(ix, lx, merged, next, ok, rx); - /* while (true) { */ case 1: - /* if (!(lx[0] < leftLen || rx[0] < rightLen)) { break; } */ if(!(lx[0] < leftLen || rx[0] < rightLen)) { $s = 2; continue; } - /* */ if (rx[0] >= rightLen) { $s = 4; continue; } - /* */ if (lx[0] >= leftLen) { $s = 5; continue; } - /* */ if ((x = rightRunes.$get(), ((rx[0] < 0 || rx[0] >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + rx[0]])) < (x$1 = leftRunes.$get(), ((lx[0] < 0 || lx[0] >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + lx[0]]))) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if (rx[0] >= rightLen) { */ case 4: - _r = extend((lx.$ptr || (lx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, lx))), leftRunes, leftPC); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - ok[0] = _r; - $s = 8; continue; - /* } else if (lx[0] >= leftLen) { */ case 5: - _r$1 = extend((rx.$ptr || (rx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, rx))), rightRunes, rightPC); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - ok[0] = _r$1; - $s = 8; continue; - /* } else if ((x = rightRunes.$get(), ((rx[0] < 0 || rx[0] >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + rx[0]])) < (x$1 = leftRunes.$get(), ((lx[0] < 0 || lx[0] >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + lx[0]]))) { */ case 6: - _r$2 = extend((rx.$ptr || (rx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, rx))), rightRunes, rightPC); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - ok[0] = _r$2; - $s = 8; continue; - /* } else { */ case 7: - _r$3 = extend((lx.$ptr || (lx.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, lx))), leftRunes, leftPC); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - ok[0] = _r$3; - /* } */ case 8: - case 3: - if (!ok[0]) { - $s = -1; return [noRune, noNext]; - } - /* } */ $s = 1; continue; case 2: - $s = -1; return [merged[0], next[0]]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [sliceType$1.nil, sliceType$2.nil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mergeRuneSets }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.extend = extend; $f.ix = ix; $f.leftLen = leftLen; $f.leftPC = leftPC; $f.leftRunes = leftRunes; $f.lx = lx; $f.merged = merged; $f.next = next; $f.ok = ok; $f.rightLen = rightLen; $f.rightPC = rightPC; $f.rightRunes = rightRunes; $f.rx = rx; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - cleanupOnePass = function(prog, original) { - var _1, _i, _ref, instOriginal, ix, original, prog, x, x$1, x$2; - _ref = original.Inst; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - ix = _i; - instOriginal = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); - _1 = instOriginal.Op; - if ((_1 === (0)) || (_1 === (1)) || (_1 === (7))) { - } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (6)) || (_1 === (4)) || (_1 === (5))) { - (x = prog.Inst, ((ix < 0 || ix >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + ix])).Next = sliceType$2.nil; - } else if ((_1 === (8)) || (_1 === (9)) || (_1 === (10))) { - (x$1 = prog.Inst, ((ix < 0 || ix >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + ix])).Next = sliceType$2.nil; - onePassInst.copy((x$2 = prog.Inst, ((ix < 0 || ix >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + ix])), new onePassInst.ptr($clone(instOriginal, syntax.Inst), sliceType$2.nil)); - } - _i++; - } - }; - onePassCopy = function(prog) { - var _1, _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, i, inst, instAlt, instOther, p, p_A_Alt, p_A_Other, p_B_Alt, p_B_Other, patch, pc, prog, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - p = new onePassProg.ptr($makeSlice(sliceType$6, prog.Inst.$length), prog.Start, prog.NumCap); - _ref = prog.Inst; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - inst = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); - onePassInst.copy((x = p.Inst, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])), new onePassInst.ptr($clone(inst, syntax.Inst), sliceType$2.nil)); - _i++; - } - _ref$1 = p.Inst; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - pc = _i$1; - _1 = (x$1 = p.Inst, ((pc < 0 || pc >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + pc])).Inst.Op; - if ((_1 === (0)) || (_1 === (1))) { - p_A_Other = (x$2 = (x$3 = p.Inst, ((pc < 0 || pc >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + pc])), (x$2.$ptr_Out || (x$2.$ptr_Out = new ptrType$9(function() { return this.$target.Inst.Out; }, function($v) { this.$target.Inst.Out = $v; }, x$2)))); - p_A_Alt = (x$4 = (x$5 = p.Inst, ((pc < 0 || pc >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + pc])), (x$4.$ptr_Arg || (x$4.$ptr_Arg = new ptrType$9(function() { return this.$target.Inst.Arg; }, function($v) { this.$target.Inst.Arg = $v; }, x$4)))); - instAlt = $clone((x$6 = p.Inst, x$7 = p_A_Alt.$get(), ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])), onePassInst); - if (!((instAlt.Inst.Op === 0) || (instAlt.Inst.Op === 1))) { - _tmp = p_A_Other; - _tmp$1 = p_A_Alt; - p_A_Alt = _tmp; - p_A_Other = _tmp$1; - onePassInst.copy(instAlt, (x$8 = p.Inst, x$9 = p_A_Alt.$get(), ((x$9 < 0 || x$9 >= x$8.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + x$9]))); - if (!((instAlt.Inst.Op === 0) || (instAlt.Inst.Op === 1))) { - _i$1++; - continue; - } - } - instOther = $clone((x$10 = p.Inst, x$11 = p_A_Other.$get(), ((x$11 < 0 || x$11 >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + x$11])), onePassInst); - if ((instOther.Inst.Op === 0) || (instOther.Inst.Op === 1)) { - _i$1++; - continue; - } - p_B_Alt = (x$12 = (x$13 = p.Inst, x$14 = p_A_Alt.$get(), ((x$14 < 0 || x$14 >= x$13.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + x$14])), (x$12.$ptr_Out || (x$12.$ptr_Out = new ptrType$9(function() { return this.$target.Inst.Out; }, function($v) { this.$target.Inst.Out = $v; }, x$12)))); - p_B_Other = (x$15 = (x$16 = p.Inst, x$17 = p_A_Alt.$get(), ((x$17 < 0 || x$17 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + x$17])), (x$15.$ptr_Arg || (x$15.$ptr_Arg = new ptrType$9(function() { return this.$target.Inst.Arg; }, function($v) { this.$target.Inst.Arg = $v; }, x$15)))); - patch = false; - if (instAlt.Inst.Out === ((pc >>> 0))) { - patch = true; - } else if (instAlt.Inst.Arg === ((pc >>> 0))) { - patch = true; - _tmp$2 = p_B_Other; - _tmp$3 = p_B_Alt; - p_B_Alt = _tmp$2; - p_B_Other = _tmp$3; - } - if (patch) { - p_B_Alt.$set(p_A_Other.$get()); - } - if (p_A_Other.$get() === p_B_Alt.$get()) { - p_A_Alt.$set(p_B_Other.$get()); - } - } else { - _i$1++; - continue; - } - _i$1++; - } - return p; - }; - runeSlice.prototype.Len = function() { - var p; - p = this; - return p.$length; - }; - $ptrType(runeSlice).prototype.Len = function() { return this.$get().Len(); }; - runeSlice.prototype.Less = function(i, j) { - var i, j, p; - p = this; - return ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); - }; - $ptrType(runeSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; - runeSlice.prototype.Swap = function(i, j) { - var _tmp, _tmp$1, i, j, p; - p = this; - _tmp = ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j]); - _tmp$1 = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); - ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i] = _tmp); - ((j < 0 || j >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + j] = _tmp$1); - }; - $ptrType(runeSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; - makeOnePass = function(p) { - var _i, _r, _ref, check, i, instQueue, m, onePassRunes, p, pc, visitQueue, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; check = $f.check; i = $f.i; instQueue = $f.instQueue; m = $f.m; onePassRunes = $f.onePassRunes; p = $f.p; pc = $f.pc; visitQueue = $f.visitQueue; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - check = [check]; - instQueue = [instQueue]; - onePassRunes = [onePassRunes]; - p = [p]; - visitQueue = [visitQueue]; - if (p[0].Inst.$length >= 1000) { - $s = -1; return ptrType$6.nil; - } - instQueue[0] = newQueue(p[0].Inst.$length); - visitQueue[0] = newQueue(p[0].Inst.$length); - check[0] = $throwNilPointerError; - onePassRunes[0] = $makeSlice(sliceType$7, p[0].Inst.$length); - check[0] = (function(check, instQueue, onePassRunes, p, visitQueue) { return function $b(pc, m) { - var _1, _i, _i$1, _i$2, _i$3, _i$4, _q, _q$1, _q$2, _q$3, _q$4, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _v, i, i$1, i$2, i$3, i$4, inst, m, matchArg, matchOut, ok, pc, r0, r0$1, r1, r1$1, runes, runes$1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _q$4 = $f._q$4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _v = $f._v; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; inst = $f.inst; m = $f.m; matchArg = $f.matchArg; matchOut = $f.matchOut; ok = $f.ok; pc = $f.pc; r0 = $f.r0; r0$1 = $f.r0$1; r1 = $f.r1; r1$1 = $f.r1$1; runes = $f.runes; runes$1 = $f.runes$1; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ok = false; - ok = true; - inst = (x = p[0].Inst, ((pc < 0 || pc >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pc])); - if (visitQueue[0].contains(pc)) { - $s = -1; return ok; - } - visitQueue[0].insert(pc); - _1 = inst.Inst.Op; - /* */ if ((_1 === (0)) || (_1 === (1))) { $s = 2; continue; } - /* */ if ((_1 === (2)) || (_1 === (6))) { $s = 3; continue; } - /* */ if (_1 === (3)) { $s = 4; continue; } - /* */ if ((_1 === (4)) || (_1 === (5))) { $s = 5; continue; } - /* */ if (_1 === (7)) { $s = 6; continue; } - /* */ if (_1 === (8)) { $s = 7; continue; } - /* */ if (_1 === (9)) { $s = 8; continue; } - /* */ if (_1 === (10)) { $s = 9; continue; } - /* */ $s = 10; continue; - /* if ((_1 === (0)) || (_1 === (1))) { */ case 2: - _r = check[0](inst.Inst.Out, m); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - if (!(_r)) { _v = false; $s = 11; continue s; } - _r$1 = check[0](inst.Inst.Arg, m); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _v = _r$1; case 11: - ok = _v; - matchOut = (x$1 = inst.Inst.Out, ((x$1 < 0 || x$1 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$1])); - matchArg = (x$2 = inst.Inst.Arg, ((x$2 < 0 || x$2 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$2])); - if (matchOut && matchArg) { - ok = false; - /* break; */ $s = 1; continue; - } - if (matchArg) { - _tmp = inst.Inst.Arg; - _tmp$1 = inst.Inst.Out; - inst.Inst.Out = _tmp; - inst.Inst.Arg = _tmp$1; - _tmp$2 = matchArg; - _tmp$3 = matchOut; - matchOut = _tmp$2; - matchArg = _tmp$3; - } - if (matchOut) { - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = true); - inst.Inst.Op = 1; - } - _r$2 = mergeRuneSets($indexPtr(onePassRunes[0].$array, onePassRunes[0].$offset + inst.Inst.Out, ptrType$10), $indexPtr(onePassRunes[0].$array, onePassRunes[0].$offset + inst.Inst.Arg, ptrType$10), inst.Inst.Out, inst.Inst.Arg); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = _tuple[0]); - inst.Next = _tuple[1]; - if (inst.Next.$length > 0 && ((x$3 = inst.Next, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])) === 4294967295)) { - ok = false; - /* break; */ $s = 1; continue; - } - $s = 10; continue; - /* } else if ((_1 === (2)) || (_1 === (6))) { */ case 3: - _r$3 = check[0](inst.Inst.Out, m); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - ok = _r$3; - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (x$4 = inst.Inst.Out, ((x$4 < 0 || x$4 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$4]))); - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), (x$5 = inst.Inst.Out, ((x$5 < 0 || x$5 >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + x$5])))); - inst.Next = $makeSlice(sliceType$2, ((_q = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); - _ref = inst.Next; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - (x$6 = inst.Next, ((i < 0 || i >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + i] = inst.Inst.Out)); - _i++; - } - $s = 10; continue; - /* } else if (_1 === (3)) { */ case 4: - _r$4 = check[0](inst.Inst.Out, m); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - ok = _r$4; - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (x$7 = inst.Inst.Out, ((x$7 < 0 || x$7 >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + x$7]))); - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), (x$8 = inst.Inst.Out, ((x$8 < 0 || x$8 >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + x$8])))); - inst.Next = $makeSlice(sliceType$2, ((_q$1 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); - _ref$1 = inst.Next; - _i$1 = 0; - while (true) { - if (!(_i$1 < _ref$1.$length)) { break; } - i$1 = _i$1; - (x$9 = inst.Next, ((i$1 < 0 || i$1 >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + i$1] = inst.Inst.Out)); - _i$1++; - } - $s = 10; continue; - /* } else if ((_1 === (4)) || (_1 === (5))) { */ case 5: - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = (inst.Inst.Op === 4)); - $s = 10; continue; - /* } else if (_1 === (7)) { */ case 6: - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); - if (inst.Next.$length > 0) { - /* break; */ $s = 1; continue; - } - instQueue[0].insert(inst.Inst.Out); - if (inst.Inst.Rune.$length === 0) { - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = new sliceType$1([])); - inst.Next = new sliceType$2([inst.Inst.Out]); - /* break; */ $s = 1; continue; - } - runes = $makeSlice(sliceType$1, 0); - /* */ if ((inst.Inst.Rune.$length === 1) && !((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { $s = 17; continue; } - /* */ $s = 18; continue; - /* if ((inst.Inst.Rune.$length === 1) && !((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { */ case 17: - r0 = (x$10 = inst.Inst.Rune, (0 >= x$10.$length ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + 0])); - runes = $append(runes, r0, r0); - r1 = unicode.SimpleFold(r0); - while (true) { - if (!(!((r1 === r0)))) { break; } - runes = $append(runes, r1, r1); - r1 = unicode.SimpleFold(r1); - } - $r = sort.Sort(($subslice(new runeSlice(runes.$array), runes.$offset, runes.$offset + runes.$length))); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 19; continue; - /* } else { */ case 18: - runes = $appendSlice(runes, inst.Inst.Rune); - /* } */ case 19: - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = runes); - inst.Next = $makeSlice(sliceType$2, ((_q$2 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); - _ref$2 = inst.Next; - _i$2 = 0; - while (true) { - if (!(_i$2 < _ref$2.$length)) { break; } - i$2 = _i$2; - (x$11 = inst.Next, ((i$2 < 0 || i$2 >= x$11.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$11.$array[x$11.$offset + i$2] = inst.Inst.Out)); - _i$2++; - } - inst.Inst.Op = 7; - $s = 10; continue; - /* } else if (_1 === (8)) { */ case 7: - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); - if (inst.Next.$length > 0) { - /* break; */ $s = 1; continue; - } - instQueue[0].insert(inst.Inst.Out); - runes$1 = new sliceType$1([]); - /* */ if (!((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { $s = 21; continue; } - /* */ $s = 22; continue; - /* if (!((((((inst.Inst.Arg << 16 >>> 16)) & 1) >>> 0) === 0))) { */ case 21: - r0$1 = (x$12 = inst.Inst.Rune, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0])); - runes$1 = $append(runes$1, r0$1, r0$1); - r1$1 = unicode.SimpleFold(r0$1); - while (true) { - if (!(!((r1$1 === r0$1)))) { break; } - runes$1 = $append(runes$1, r1$1, r1$1); - r1$1 = unicode.SimpleFold(r1$1); - } - $r = sort.Sort(($subslice(new runeSlice(runes$1.$array), runes$1.$offset, runes$1.$offset + runes$1.$length))); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 23; continue; - /* } else { */ case 22: - runes$1 = $append(runes$1, (x$13 = inst.Inst.Rune, (0 >= x$13.$length ? ($throwRuntimeError("index out of range"), undefined) : x$13.$array[x$13.$offset + 0])), (x$14 = inst.Inst.Rune, (0 >= x$14.$length ? ($throwRuntimeError("index out of range"), undefined) : x$14.$array[x$14.$offset + 0]))); - /* } */ case 23: - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = runes$1); - inst.Next = $makeSlice(sliceType$2, ((_q$3 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); - _ref$3 = inst.Next; - _i$3 = 0; - while (true) { - if (!(_i$3 < _ref$3.$length)) { break; } - i$3 = _i$3; - (x$15 = inst.Next, ((i$3 < 0 || i$3 >= x$15.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$15.$array[x$15.$offset + i$3] = inst.Inst.Out)); - _i$3++; - } - inst.Inst.Op = 7; - $s = 10; continue; - /* } else if (_1 === (9)) { */ case 8: - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); - if (inst.Next.$length > 0) { - /* break; */ $s = 1; continue; - } - instQueue[0].insert(inst.Inst.Out); - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), anyRune)); - inst.Next = new sliceType$2([inst.Inst.Out]); - $s = 10; continue; - /* } else if (_1 === (10)) { */ case 9: - ((pc < 0 || pc >= m.$length) ? ($throwRuntimeError("index out of range"), undefined) : m.$array[m.$offset + pc] = false); - if (inst.Next.$length > 0) { - /* break; */ $s = 1; continue; - } - instQueue[0].insert(inst.Inst.Out); - ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc] = $appendSlice(new sliceType$1([]), anyRuneNotNL)); - inst.Next = $makeSlice(sliceType$2, ((_q$4 = ((pc < 0 || pc >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + pc]).$length / 2, (_q$4 === _q$4 && _q$4 !== 1/0 && _q$4 !== -1/0) ? _q$4 >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0)); - _ref$4 = inst.Next; - _i$4 = 0; - while (true) { - if (!(_i$4 < _ref$4.$length)) { break; } - i$4 = _i$4; - (x$16 = inst.Next, ((i$4 < 0 || i$4 >= x$16.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$16.$array[x$16.$offset + i$4] = inst.Inst.Out)); - _i$4++; - } - /* } */ case 10: - case 1: - $s = -1; return ok; - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._q$4 = _q$4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._v = _v; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.inst = inst; $f.m = m; $f.matchArg = matchArg; $f.matchOut = matchOut; $f.ok = ok; $f.pc = pc; $f.r0 = r0; $f.r0$1 = r0$1; $f.r1 = r1; $f.r1$1 = r1$1; $f.runes = runes; $f.runes$1 = runes$1; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; - }; })(check, instQueue, onePassRunes, p, visitQueue); - instQueue[0].clear(); - instQueue[0].insert(((p[0].Start >>> 0))); - m = $makeSlice(sliceType$8, p[0].Inst.$length); - /* while (true) { */ case 1: - /* if (!(!instQueue[0].empty())) { break; } */ if(!(!instQueue[0].empty())) { $s = 2; continue; } - visitQueue[0].clear(); - pc = instQueue[0].next(); - _r = check[0](pc, m); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (!_r) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (!_r) { */ case 3: - p[0] = ptrType$6.nil; - /* break; */ $s = 2; continue; - /* } */ case 4: - /* } */ $s = 1; continue; case 2: - if (!(p[0] === ptrType$6.nil)) { - _ref = p[0].Inst; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - (x = p[0].Inst, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])).Inst.Rune = ((i < 0 || i >= onePassRunes[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : onePassRunes[0].$array[onePassRunes[0].$offset + i]); - _i++; - } - } - $s = -1; return p[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: makeOnePass }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.check = check; $f.i = i; $f.instQueue = instQueue; $f.m = m; $f.onePassRunes = onePassRunes; $f.p = p; $f.pc = pc; $f.visitQueue = visitQueue; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - compileOnePass = function(prog) { - var _1, _i, _r, _ref, inst, opOut, p, prog, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _ref = $f._ref; inst = $f.inst; opOut = $f.opOut; p = $f.p; prog = $f.prog; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p = ptrType$6.nil; - if (prog.Start === 0) { - p = ptrType$6.nil; - $s = -1; return p; - } - if (!(((x = prog.Inst, x$1 = prog.Start, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).Op === 3)) || !(((((((x$2 = prog.Inst, x$3 = prog.Start, ((x$3 < 0 || x$3 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + x$3])).Arg << 24 >>> 24)) & 4) >>> 0) === 4))) { - p = ptrType$6.nil; - $s = -1; return p; - } - _ref = prog.Inst; - _i = 0; - /* while (true) { */ case 1: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } - inst = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), syntax.Inst); - opOut = (x$4 = prog.Inst, x$5 = inst.Out, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])).Op; - _1 = inst.Op; - if ((_1 === (0)) || (_1 === (1))) { - if ((opOut === 4) || ((x$6 = prog.Inst, x$7 = inst.Arg, ((x$7 < 0 || x$7 >= x$6.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + x$7])).Op === 4)) { - p = ptrType$6.nil; - $s = -1; return p; - } - } else if (_1 === (3)) { - if (opOut === 4) { - if (((((inst.Arg << 24 >>> 24)) & 8) >>> 0) === 8) { - _i++; - /* continue; */ $s = 1; continue; - } - p = ptrType$6.nil; - $s = -1; return p; - } - } else if (opOut === 4) { - p = ptrType$6.nil; - $s = -1; return p; - } - _i++; - /* } */ $s = 1; continue; case 2: - p = onePassCopy(prog); - _r = makeOnePass(p); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p = _r; - if (!(p === ptrType$6.nil)) { - cleanupOnePass(p, prog); - } - p = p; - $s = -1; return p; - /* */ } return; } if ($f === undefined) { $f = { $blk: compileOnePass }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.inst = inst; $f.opOut = opOut; $f.p = p; $f.prog = prog; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.ptr.prototype.String = function() { - var re; - re = this; - return re.expr; - }; - Regexp.prototype.String = function() { return this.$val.String(); }; - Regexp.ptr.prototype.Copy = function() { - var re, re2; - re = this; - re2 = $clone(re, Regexp); - return re2; - }; - Regexp.prototype.Copy = function() { return this.$val.Copy(); }; - Compile = function(expr) { - var _r, expr, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; expr = $f.expr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = compile(expr, 212, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Compile }; } $f._r = _r; $f.expr = expr; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.Compile = Compile; - Regexp.ptr.prototype.Longest = function() { - var re; - re = this; - re.longest = true; - }; - Regexp.prototype.Longest = function() { return this.$val.Longest(); }; - compile = function(expr, mode, longest) { - var _r, _r$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, capNames, err, expr, i, longest, matchcap, maxCap, mode, n, prog, re, regexp, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; capNames = $f.capNames; err = $f.err; expr = $f.expr; i = $f.i; longest = $f.longest; matchcap = $f.matchcap; maxCap = $f.maxCap; mode = $f.mode; n = $f.n; prog = $f.prog; re = $f.re; regexp = $f.regexp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = syntax.Parse(expr, mode); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - re = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$11.nil, err]; - } - maxCap = re.MaxCap(); - capNames = re.CapNames(); - re = re.Simplify(); - _tuple$1 = syntax.Compile(re); - prog = _tuple$1[0]; - err = _tuple$1[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType$11.nil, err]; - } - matchcap = prog.NumCap; - if (matchcap < 2) { - matchcap = 2; - } - _r$1 = compileOnePass(prog); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - regexp = new Regexp.ptr(expr, prog, _r$1, maxCap, 0, capNames, "", sliceType$5.nil, 0, 0, 0, matchcap, false, prog.StartCond(), longest); - if (regexp.onepass === ptrType$6.nil) { - _tuple$2 = prog.Prefix(); - regexp.prefix = _tuple$2[0]; - regexp.prefixComplete = _tuple$2[1]; - regexp.maxBitStateLen = maxBitStateLen(prog); - } else { - _tuple$3 = onePassPrefix(prog); - regexp.prefix = _tuple$3[0]; - regexp.prefixComplete = _tuple$3[1]; - regexp.prefixEnd = _tuple$3[2]; - } - if (!(regexp.prefix === "")) { - regexp.prefixBytes = (new sliceType$5($stringToBytes(regexp.prefix))); - _tuple$4 = utf8.DecodeRuneInString(regexp.prefix); - regexp.prefixRune = _tuple$4[0]; - } - n = prog.Inst.$length; - i = 0; - while (true) { - if (!(!((((i < 0 || i >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[i]) === 0)) && ((i < 0 || i >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[i]) < n)) { break; } - i = i + (1) >> 0; - } - regexp.mpool = i; - $s = -1; return [regexp, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: compile }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.capNames = capNames; $f.err = err; $f.expr = expr; $f.i = i; $f.longest = longest; $f.matchcap = matchcap; $f.maxCap = maxCap; $f.mode = mode; $f.n = n; $f.prog = prog; $f.re = re; $f.regexp = regexp; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.ptr.prototype.get = function() { - var _i, _r, _ref, _tuple, m, n, ok, re, t, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; m = $f.m; n = $f.n; ok = $f.ok; re = $f.re; t = $f.t; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = (x = re.mpool, ((x < 0 || x >= matchPool.length) ? ($throwRuntimeError("index out of range"), undefined) : matchPool[x])).Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = $assertType(_r, ptrType$13, true); - m = _tuple[0]; - ok = _tuple[1]; - if (!ok) { - m = new machine.ptr(ptrType$11.nil, ptrType$12.nil, new queue.ptr(sliceType$2.nil, sliceType$10.nil), new queue.ptr(sliceType$2.nil, sliceType$10.nil), sliceType$11.nil, false, sliceType$3.nil, new inputs.ptr(new inputBytes.ptr(sliceType$5.nil), new inputString.ptr(""), new inputReader.ptr($ifaceNil, false, 0))); - } - m.re = re; - m.p = re.prog; - if (m.matchcap.$capacity < re.matchcap) { - m.matchcap = $makeSlice(sliceType$3, re.matchcap); - _ref = m.pool; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - t = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - t.cap = $makeSlice(sliceType$3, re.matchcap); - _i++; - } - } - n = (x$1 = re.mpool, ((x$1 < 0 || x$1 >= matchSize.length) ? ($throwRuntimeError("index out of range"), undefined) : matchSize[x$1])); - if (n === 0) { - n = re.prog.Inst.$length; - } - if (m.q0.sparse.$length < n) { - queue.copy(m.q0, new queue.ptr($makeSlice(sliceType$2, n), $makeSlice(sliceType$10, 0, n))); - queue.copy(m.q1, new queue.ptr($makeSlice(sliceType$2, n), $makeSlice(sliceType$10, 0, n))); - } - $s = -1; return m; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.get }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.m = m; $f.n = n; $f.ok = ok; $f.re = re; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.get = function() { return this.$val.get(); }; - Regexp.ptr.prototype.put = function(m) { - var m, re, x; - re = this; - m.re = ptrType$11.nil; - m.p = ptrType$12.nil; - m.inputs.clear(); - (x = re.mpool, ((x < 0 || x >= matchPool.length) ? ($throwRuntimeError("index out of range"), undefined) : matchPool[x])).Put(m); - }; - Regexp.prototype.put = function(m) { return this.$val.put(m); }; - MustCompile = function(str) { - var _r, _r$1, _tuple, err, regexp, str, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; regexp = $f.regexp; str = $f.str; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = Compile(str); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - regexp = _tuple[0]; - err = _tuple[1]; - /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; } - /* */ $s = 3; continue; - /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2: - _r$1 = err.Error(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $panic(new $String("regexp: Compile(" + quote(str) + "): " + _r$1)); - /* } */ case 3: - $s = -1; return regexp; - /* */ } return; } if ($f === undefined) { $f = { $blk: MustCompile }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.regexp = regexp; $f.str = str; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.MustCompile = MustCompile; - quote = function(s) { - var s; - if (strconv.CanBackquote(s)) { - return "`" + s + "`"; - } - return strconv.Quote(s); - }; - Regexp.ptr.prototype.NumSubexp = function() { - var re; - re = this; - return re.numSubexp; - }; - Regexp.prototype.NumSubexp = function() { return this.$val.NumSubexp(); }; - Regexp.ptr.prototype.SubexpNames = function() { - var re; - re = this; - return re.subexpNames; - }; - Regexp.prototype.SubexpNames = function() { return this.$val.SubexpNames(); }; - inputString.ptr.prototype.step = function(pos) { - var c, i, pos; - i = this; - if (pos < i.str.length) { - c = i.str.charCodeAt(pos); - if (c < 128) { - return [((c >> 0)), 1]; - } - return utf8.DecodeRuneInString($substring(i.str, pos)); - } - return [-1, 0]; - }; - inputString.prototype.step = function(pos) { return this.$val.step(pos); }; - inputString.ptr.prototype.canCheckPrefix = function() { - var i; - i = this; - return true; - }; - inputString.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; - inputString.ptr.prototype.hasPrefix = function(re) { - var i, re; - i = this; - return strings.HasPrefix(i.str, re.prefix); - }; - inputString.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; - inputString.ptr.prototype.index = function(re, pos) { - var i, pos, re; - i = this; - return strings.Index($substring(i.str, pos), re.prefix); - }; - inputString.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; - inputString.ptr.prototype.context = function(pos) { - var _tmp, _tmp$1, _tuple, _tuple$1, i, pos, r1, r2; - i = this; - _tmp = -1; - _tmp$1 = -1; - r1 = _tmp; - r2 = _tmp$1; - if ((((pos - 1 >> 0) >>> 0)) < ((i.str.length >>> 0))) { - r1 = ((i.str.charCodeAt((pos - 1 >> 0)) >> 0)); - if (r1 >= 128) { - _tuple = utf8.DecodeLastRuneInString($substring(i.str, 0, pos)); - r1 = _tuple[0]; - } - } - if (((pos >>> 0)) < ((i.str.length >>> 0))) { - r2 = ((i.str.charCodeAt(pos) >> 0)); - if (r2 >= 128) { - _tuple$1 = utf8.DecodeRuneInString($substring(i.str, pos)); - r2 = _tuple$1[0]; - } - } - return newLazyFlag(r1, r2); - }; - inputString.prototype.context = function(pos) { return this.$val.context(pos); }; - inputBytes.ptr.prototype.step = function(pos) { - var c, i, pos, x; - i = this; - if (pos < i.str.$length) { - c = (x = i.str, ((pos < 0 || pos >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + pos])); - if (c < 128) { - return [((c >> 0)), 1]; - } - return utf8.DecodeRune($subslice(i.str, pos)); - } - return [-1, 0]; - }; - inputBytes.prototype.step = function(pos) { return this.$val.step(pos); }; - inputBytes.ptr.prototype.canCheckPrefix = function() { - var i; - i = this; - return true; - }; - inputBytes.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; - inputBytes.ptr.prototype.hasPrefix = function(re) { - var i, re; - i = this; - return bytes.HasPrefix(i.str, re.prefixBytes); - }; - inputBytes.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; - inputBytes.ptr.prototype.index = function(re, pos) { - var i, pos, re; - i = this; - return bytes.Index($subslice(i.str, pos), re.prefixBytes); - }; - inputBytes.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; - inputBytes.ptr.prototype.context = function(pos) { - var _tmp, _tmp$1, _tuple, _tuple$1, i, pos, r1, r2, x, x$1, x$2; - i = this; - _tmp = -1; - _tmp$1 = -1; - r1 = _tmp; - r2 = _tmp$1; - if ((((pos - 1 >> 0) >>> 0)) < ((i.str.$length >>> 0))) { - r1 = (((x = i.str, x$1 = pos - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])) >> 0)); - if (r1 >= 128) { - _tuple = utf8.DecodeLastRune($subslice(i.str, 0, pos)); - r1 = _tuple[0]; - } - } - if (((pos >>> 0)) < ((i.str.$length >>> 0))) { - r2 = (((x$2 = i.str, ((pos < 0 || pos >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + pos])) >> 0)); - if (r2 >= 128) { - _tuple$1 = utf8.DecodeRune($subslice(i.str, pos)); - r2 = _tuple$1[0]; - } - } - return newLazyFlag(r1, r2); - }; - inputBytes.prototype.context = function(pos) { return this.$val.context(pos); }; - inputReader.ptr.prototype.step = function(pos) { - var _r, _tuple, err, i, pos, r, w, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; i = $f.i; pos = $f.pos; r = $f.r; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = this; - if (!i.atEOT && !((pos === i.pos))) { - $s = -1; return [-1, 0]; - } - _r = i.r.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - r = _tuple[0]; - w = _tuple[1]; - err = _tuple[2]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - i.atEOT = true; - $s = -1; return [-1, 0]; - } - i.pos = i.pos + (w) >> 0; - $s = -1; return [r, w]; - /* */ } return; } if ($f === undefined) { $f = { $blk: inputReader.ptr.prototype.step }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.i = i; $f.pos = pos; $f.r = r; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; - }; - inputReader.prototype.step = function(pos) { return this.$val.step(pos); }; - inputReader.ptr.prototype.canCheckPrefix = function() { - var i; - i = this; - return false; - }; - inputReader.prototype.canCheckPrefix = function() { return this.$val.canCheckPrefix(); }; - inputReader.ptr.prototype.hasPrefix = function(re) { - var i, re; - i = this; - return false; - }; - inputReader.prototype.hasPrefix = function(re) { return this.$val.hasPrefix(re); }; - inputReader.ptr.prototype.index = function(re, pos) { - var i, pos, re; - i = this; - return -1; - }; - inputReader.prototype.index = function(re, pos) { return this.$val.index(re, pos); }; - inputReader.ptr.prototype.context = function(pos) { - var i, pos; - i = this; - return new lazyFlag(0, 0); - }; - inputReader.prototype.context = function(pos) { return this.$val.context(pos); }; - Regexp.ptr.prototype.LiteralPrefix = function() { - var _tmp, _tmp$1, complete, prefix, re; - prefix = ""; - complete = false; - re = this; - _tmp = re.prefix; - _tmp$1 = re.prefixComplete; - prefix = _tmp; - complete = _tmp$1; - return [prefix, complete]; - }; - Regexp.prototype.LiteralPrefix = function() { return this.$val.LiteralPrefix(); }; - Regexp.ptr.prototype.MatchReader = function(r) { - var _r, r, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doMatch(r, sliceType$5.nil, ""); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.MatchReader }; } $f._r = _r; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.MatchReader = function(r) { return this.$val.MatchReader(r); }; - Regexp.ptr.prototype.MatchString = function(s) { - var _r, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doMatch($ifaceNil, sliceType$5.nil, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.MatchString }; } $f._r = _r; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.MatchString = function(s) { return this.$val.MatchString(s); }; - Regexp.ptr.prototype.Match = function(b) { - var _r, b, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doMatch($ifaceNil, b, ""); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Match }; } $f._r = _r; $f.b = b; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.Match = function(b) { return this.$val.Match(b); }; - Regexp.ptr.prototype.ReplaceAllString = function(src, repl) { - var _r, b, n, re, repl, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; n = $f.n; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = [re]; - repl = [repl]; - src = [src]; - re[0] = this; - n = 2; - if (strings.Contains(repl[0], "$")) { - n = $imul(2, ((re[0].numSubexp + 1 >> 0))); - } - _r = re[0].replaceAll(sliceType$5.nil, src[0], n, (function(re, repl, src) { return function(dst, match) { - var dst, match; - return re[0].expand(dst, repl[0], sliceType$5.nil, src[0], match); - }; })(re, repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - b = _r; - $s = -1; return ($bytesToString(b)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllString }; } $f._r = _r; $f.b = b; $f.n = n; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAllString = function(src, repl) { return this.$val.ReplaceAllString(src, repl); }; - Regexp.ptr.prototype.ReplaceAllLiteralString = function(src, repl) { - var _r, re, repl, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - repl = [repl]; - re = this; - _r = re.replaceAll(sliceType$5.nil, src, 2, (function(repl) { return function(dst, match) { - var dst, match; - return $appendSlice(dst, repl[0]); - }; })(repl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return ($bytesToString(_r)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllLiteralString }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAllLiteralString = function(src, repl) { return this.$val.ReplaceAllLiteralString(src, repl); }; - Regexp.ptr.prototype.ReplaceAllStringFunc = function(src, repl) { - var _r, b, re, repl, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - repl = [repl]; - src = [src]; - re = this; - _r = re.replaceAll(sliceType$5.nil, src[0], 2, (function(repl, src) { return function $b(dst, match) { - var _arg, _arg$1, _r, dst, match, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; dst = $f.dst; match = $f.match; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = dst; - _r = repl[0]($substring(src[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = _r; - $s = -1; return $appendSlice(_arg, _arg$1); - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.dst = dst; $f.match = match; $f.$s = $s; $f.$r = $r; return $f; - }; })(repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - b = _r; - $s = -1; return ($bytesToString(b)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllStringFunc }; } $f._r = _r; $f.b = b; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAllStringFunc = function(src, repl) { return this.$val.ReplaceAllStringFunc(src, repl); }; - Regexp.ptr.prototype.replaceAll = function(bsrc, src, nmatch, repl) { - var _r, _r$1, _tuple, _tuple$1, a, bsrc, buf, dstCap, endPos, lastMatchEnd, nmatch, re, repl, searchPos, src, width, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; bsrc = $f.bsrc; buf = $f.buf; dstCap = $f.dstCap; endPos = $f.endPos; lastMatchEnd = $f.lastMatchEnd; nmatch = $f.nmatch; re = $f.re; repl = $f.repl; searchPos = $f.searchPos; src = $f.src; width = $f.width; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - lastMatchEnd = 0; - searchPos = 0; - buf = sliceType$5.nil; - endPos = 0; - if (!(bsrc === sliceType$5.nil)) { - endPos = bsrc.$length; - } else { - endPos = src.length; - } - if (nmatch > re.prog.NumCap) { - nmatch = re.prog.NumCap; - } - dstCap = arrayType$3.zero(); - /* while (true) { */ case 1: - /* if (!(searchPos <= endPos)) { break; } */ if(!(searchPos <= endPos)) { $s = 2; continue; } - _r = re.doExecute($ifaceNil, bsrc, src, searchPos, nmatch, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a.$length === 0) { - /* break; */ $s = 2; continue; - } - if (!(bsrc === sliceType$5.nil)) { - buf = $appendSlice(buf, $subslice(bsrc, lastMatchEnd, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]))); - } else { - buf = $appendSlice(buf, $substring(src, lastMatchEnd, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]))); - } - /* */ if ((1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]) > lastMatchEnd || ((0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) === 0)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]) > lastMatchEnd || ((0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) === 0)) { */ case 4: - _r$1 = repl(buf, a); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - buf = _r$1; - /* } */ case 5: - lastMatchEnd = (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]); - width = 0; - if (!(bsrc === sliceType$5.nil)) { - _tuple = utf8.DecodeRune($subslice(bsrc, searchPos)); - width = _tuple[1]; - } else { - _tuple$1 = utf8.DecodeRuneInString($substring(src, searchPos)); - width = _tuple$1[1]; - } - if ((searchPos + width >> 0) > (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])) { - searchPos = searchPos + (width) >> 0; - } else if ((searchPos + 1 >> 0) > (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])) { - searchPos = searchPos + (1) >> 0; - } else { - searchPos = (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]); - } - /* } */ $s = 1; continue; case 2: - if (!(bsrc === sliceType$5.nil)) { - buf = $appendSlice(buf, $subslice(bsrc, lastMatchEnd)); - } else { - buf = $appendSlice(buf, $substring(src, lastMatchEnd)); - } - $s = -1; return buf; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.replaceAll }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.bsrc = bsrc; $f.buf = buf; $f.dstCap = dstCap; $f.endPos = endPos; $f.lastMatchEnd = lastMatchEnd; $f.nmatch = nmatch; $f.re = re; $f.repl = repl; $f.searchPos = searchPos; $f.src = src; $f.width = width; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.replaceAll = function(bsrc, src, nmatch, repl) { return this.$val.replaceAll(bsrc, src, nmatch, repl); }; - Regexp.ptr.prototype.ReplaceAll = function(src, repl) { - var _r, b, n, re, repl, src, srepl, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; n = $f.n; re = $f.re; repl = $f.repl; src = $f.src; srepl = $f.srepl; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = [re]; - repl = [repl]; - src = [src]; - srepl = [srepl]; - re[0] = this; - n = 2; - if (bytes.IndexByte(repl[0], 36) >= 0) { - n = $imul(2, ((re[0].numSubexp + 1 >> 0))); - } - srepl[0] = ""; - _r = re[0].replaceAll(src[0], "", n, (function(re, repl, src, srepl) { return function(dst, match) { - var dst, match; - if (!((srepl[0].length === repl[0].$length))) { - srepl[0] = ($bytesToString(repl[0])); - } - return re[0].expand(dst, srepl[0], src[0], "", match); - }; })(re, repl, src, srepl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - b = _r; - $s = -1; return b; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAll }; } $f._r = _r; $f.b = b; $f.n = n; $f.re = re; $f.repl = repl; $f.src = src; $f.srepl = srepl; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAll = function(src, repl) { return this.$val.ReplaceAll(src, repl); }; - Regexp.ptr.prototype.ReplaceAllLiteral = function(src, repl) { - var _r, re, repl, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - repl = [repl]; - re = this; - _r = re.replaceAll(src, "", 2, (function(repl) { return function(dst, match) { - var dst, match; - return $appendSlice(dst, repl[0]); - }; })(repl)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllLiteral }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAllLiteral = function(src, repl) { return this.$val.ReplaceAllLiteral(src, repl); }; - Regexp.ptr.prototype.ReplaceAllFunc = function(src, repl) { - var _r, re, repl, src, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; re = $f.re; repl = $f.repl; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - repl = [repl]; - src = [src]; - re = this; - _r = re.replaceAll(src[0], "", 2, (function(repl, src) { return function $b(dst, match) { - var _arg, _arg$1, _r, dst, match, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; dst = $f.dst; match = $f.match; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _arg = dst; - _r = repl[0]($subslice(src[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _arg$1 = _r; - $s = -1; return $appendSlice(_arg, _arg$1); - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.dst = dst; $f.match = match; $f.$s = $s; $f.$r = $r; return $f; - }; })(repl, src)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.ReplaceAllFunc }; } $f._r = _r; $f.re = re; $f.repl = repl; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.ReplaceAllFunc = function(src, repl) { return this.$val.ReplaceAllFunc(src, repl); }; - init = function() { - var _i, _index, _q, _r, _ref, b, y; - _ref = (new sliceType$5($stringToBytes("\\.+*?()|[]{}^$"))); - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - _index = (_r = b % 16, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); - ((_index < 0 || _index >= specialBytes.length) ? ($throwRuntimeError("index out of range"), undefined) : specialBytes[_index] = ((((_index < 0 || _index >= specialBytes.length) ? ($throwRuntimeError("index out of range"), undefined) : specialBytes[_index]) | (((y = ((_q = b / 16, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"))), y < 32 ? (1 << y) : 0) << 24 >>> 24))) >>> 0)); - _i++; - } - }; - Regexp.ptr.prototype.pad = function(a) { - var a, n, re; - re = this; - if (a === sliceType$3.nil) { - return sliceType$3.nil; - } - n = $imul(((1 + re.numSubexp >> 0)), 2); - while (true) { - if (!(a.$length < n)) { break; } - a = $append(a, -1); - } - return a; - }; - Regexp.prototype.pad = function(a) { return this.$val.pad(a); }; - Regexp.ptr.prototype.allMatches = function(s, b, n, deliver) { - var _r, _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, accept, b, deliver, end, i, matches, n, pos, prevMatchEnd, re, s, width, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; accept = $f.accept; b = $f.b; deliver = $f.deliver; end = $f.end; i = $f.i; matches = $f.matches; n = $f.n; pos = $f.pos; prevMatchEnd = $f.prevMatchEnd; re = $f.re; s = $f.s; width = $f.width; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - end = 0; - if (b === sliceType$5.nil) { - end = s.length; - } else { - end = b.$length; - } - _tmp = 0; - _tmp$1 = 0; - _tmp$2 = -1; - pos = _tmp; - i = _tmp$1; - prevMatchEnd = _tmp$2; - /* while (true) { */ case 1: - /* if (!(i < n && pos <= end)) { break; } */ if(!(i < n && pos <= end)) { $s = 2; continue; } - _r = re.doExecute($ifaceNil, b, s, pos, re.prog.NumCap, sliceType$3.nil); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - matches = _r; - if (matches.$length === 0) { - /* break; */ $s = 2; continue; - } - accept = true; - if ((1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]) === pos) { - if ((0 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 0]) === prevMatchEnd) { - accept = false; - } - width = 0; - if (b === sliceType$5.nil) { - _tuple = utf8.DecodeRuneInString($substring(s, pos, end)); - width = _tuple[1]; - } else { - _tuple$1 = utf8.DecodeRune($subslice(b, pos, end)); - width = _tuple$1[1]; - } - if (width > 0) { - pos = pos + (width) >> 0; - } else { - pos = end + 1 >> 0; - } - } else { - pos = (1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]); - } - prevMatchEnd = (1 >= matches.$length ? ($throwRuntimeError("index out of range"), undefined) : matches.$array[matches.$offset + 1]); - /* */ if (accept) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (accept) { */ case 4: - $r = deliver(re.pad(matches)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - i = i + (1) >> 0; - /* } */ case 5: - /* } */ $s = 1; continue; case 2: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.allMatches }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.accept = accept; $f.b = b; $f.deliver = deliver; $f.end = end; $f.i = i; $f.matches = matches; $f.n = n; $f.pos = pos; $f.prevMatchEnd = prevMatchEnd; $f.re = re; $f.s = s; $f.width = width; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.allMatches = function(s, b, n, deliver) { return this.$val.allMatches(s, b, n, deliver); }; - Regexp.ptr.prototype.Find = function(b) { - var _r, a, b, dstCap, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; dstCap = $f.dstCap; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - dstCap = arrayType$3.zero(); - _r = re.doExecute($ifaceNil, b, "", 0, 2, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - $s = -1; return sliceType$5.nil; - } - $s = -1; return $subslice(b, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]), (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Find }; } $f._r = _r; $f.a = a; $f.b = b; $f.dstCap = dstCap; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.Find = function(b) { return this.$val.Find(b); }; - Regexp.ptr.prototype.FindIndex = function(b) { - var _r, a, b, loc, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; loc = $f.loc; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - loc = sliceType$3.nil; - re = this; - _r = re.doExecute($ifaceNil, b, "", 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - loc = sliceType$3.nil; - $s = -1; return loc; - } - loc = $subslice(a, 0, 2); - $s = -1; return loc; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindIndex }; } $f._r = _r; $f.a = a; $f.b = b; $f.loc = loc; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindIndex = function(b) { return this.$val.FindIndex(b); }; - Regexp.ptr.prototype.FindString = function(s) { - var _r, a, dstCap, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; dstCap = $f.dstCap; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - dstCap = arrayType$3.zero(); - _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, 2, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - $s = -1; return ""; - } - $s = -1; return $substring(s, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]), (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1])); - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindString }; } $f._r = _r; $f.a = a; $f.dstCap = dstCap; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindString = function(s) { return this.$val.FindString(s); }; - Regexp.ptr.prototype.FindStringIndex = function(s) { - var _r, a, loc, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; loc = $f.loc; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - loc = sliceType$3.nil; - re = this; - _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - loc = sliceType$3.nil; - $s = -1; return loc; - } - loc = $subslice(a, 0, 2); - $s = -1; return loc; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringIndex }; } $f._r = _r; $f.a = a; $f.loc = loc; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindStringIndex = function(s) { return this.$val.FindStringIndex(s); }; - Regexp.ptr.prototype.FindReaderIndex = function(r) { - var _r, a, loc, r, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; loc = $f.loc; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - loc = sliceType$3.nil; - re = this; - _r = re.doExecute(r, sliceType$5.nil, "", 0, 2, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - loc = sliceType$3.nil; - $s = -1; return loc; - } - loc = $subslice(a, 0, 2); - $s = -1; return loc; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindReaderIndex }; } $f._r = _r; $f.a = a; $f.loc = loc; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindReaderIndex = function(r) { return this.$val.FindReaderIndex(r); }; - Regexp.ptr.prototype.FindSubmatch = function(b) { - var _i, _r, _ref, a, b, dstCap, i, re, ret, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; a = $f.a; b = $f.b; dstCap = $f.dstCap; i = $f.i; re = $f.re; ret = $f.ret; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - dstCap = arrayType$4.zero(); - _r = re.doExecute($ifaceNil, b, "", 0, re.prog.NumCap, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - $s = -1; return sliceType$12.nil; - } - ret = $makeSlice(sliceType$12, (1 + re.numSubexp >> 0)); - _ref = ret; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - if (($imul(2, i)) < a.$length && (x = $imul(2, i), ((x < 0 || x >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x])) >= 0) { - ((i < 0 || i >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i] = $subslice(b, (x$1 = $imul(2, i), ((x$1 < 0 || x$1 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$1])), (x$2 = ($imul(2, i)) + 1 >> 0, ((x$2 < 0 || x$2 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$2])))); - } - _i++; - } - $s = -1; return ret; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindSubmatch }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.a = a; $f.b = b; $f.dstCap = dstCap; $f.i = i; $f.re = re; $f.ret = ret; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindSubmatch = function(b) { return this.$val.FindSubmatch(b); }; - Regexp.ptr.prototype.Expand = function(dst, template, src, match) { - var dst, match, re, src, template; - re = this; - return re.expand(dst, ($bytesToString(template)), src, "", match); - }; - Regexp.prototype.Expand = function(dst, template, src, match) { return this.$val.Expand(dst, template, src, match); }; - Regexp.ptr.prototype.ExpandString = function(dst, template, src, match) { - var dst, match, re, src, template; - re = this; - return re.expand(dst, template, sliceType$5.nil, src, match); - }; - Regexp.prototype.ExpandString = function(dst, template, src, match) { return this.$val.ExpandString(dst, template, src, match); }; - Regexp.ptr.prototype.expand = function(dst, template, bsrc, src, match) { - var _i, _ref, _tuple, bsrc, dst, i, i$1, match, name, namei, num, ok, re, rest, src, template, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - re = this; - while (true) { - if (!(template.length > 0)) { break; } - i = strings.Index(template, "$"); - if (i < 0) { - break; - } - dst = $appendSlice(dst, $substring(template, 0, i)); - template = $substring(template, i); - if (template.length > 1 && (template.charCodeAt(1) === 36)) { - dst = $append(dst, 36); - template = $substring(template, 2); - continue; - } - _tuple = extract(template); - name = _tuple[0]; - num = _tuple[1]; - rest = _tuple[2]; - ok = _tuple[3]; - if (!ok) { - dst = $append(dst, 36); - template = $substring(template, 1); - continue; - } - template = rest; - if (num >= 0) { - if ((($imul(2, num)) + 1 >> 0) < match.$length && (x = $imul(2, num), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { - if (!(bsrc === sliceType$5.nil)) { - dst = $appendSlice(dst, $subslice(bsrc, (x$1 = $imul(2, num), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, num)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); - } else { - dst = $appendSlice(dst, $substring(src, (x$3 = $imul(2, num), ((x$3 < 0 || x$3 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$3])), (x$4 = ($imul(2, num)) + 1 >> 0, ((x$4 < 0 || x$4 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$4])))); - } - } - } else { - _ref = re.subexpNames; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i$1 = _i; - namei = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (name === namei && (($imul(2, i$1)) + 1 >> 0) < match.$length && (x$5 = $imul(2, i$1), ((x$5 < 0 || x$5 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$5])) >= 0) { - if (!(bsrc === sliceType$5.nil)) { - dst = $appendSlice(dst, $subslice(bsrc, (x$6 = $imul(2, i$1), ((x$6 < 0 || x$6 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$6])), (x$7 = ($imul(2, i$1)) + 1 >> 0, ((x$7 < 0 || x$7 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$7])))); - } else { - dst = $appendSlice(dst, $substring(src, (x$8 = $imul(2, i$1), ((x$8 < 0 || x$8 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$8])), (x$9 = ($imul(2, i$1)) + 1 >> 0, ((x$9 < 0 || x$9 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$9])))); - } - break; - } - _i++; - } - } - } - dst = $appendSlice(dst, template); - return dst; - }; - Regexp.prototype.expand = function(dst, template, bsrc, src, match) { return this.$val.expand(dst, template, bsrc, src, match); }; - extract = function(str) { - var _tuple, brace, i, i$1, name, num, ok, rest, rune, size, str; - name = ""; - num = 0; - rest = ""; - ok = false; - if (str.length < 2 || !((str.charCodeAt(0) === 36))) { - return [name, num, rest, ok]; - } - brace = false; - if (str.charCodeAt(1) === 123) { - brace = true; - str = $substring(str, 2); - } else { - str = $substring(str, 1); - } - i = 0; - while (true) { - if (!(i < str.length)) { break; } - _tuple = utf8.DecodeRuneInString($substring(str, i)); - rune = _tuple[0]; - size = _tuple[1]; - if (!unicode.IsLetter(rune) && !unicode.IsDigit(rune) && !((rune === 95))) { - break; - } - i = i + (size) >> 0; - } - if (i === 0) { - return [name, num, rest, ok]; - } - name = $substring(str, 0, i); - if (brace) { - if (i >= str.length || !((str.charCodeAt(i) === 125))) { - return [name, num, rest, ok]; - } - i = i + (1) >> 0; - } - num = 0; - i$1 = 0; - while (true) { - if (!(i$1 < name.length)) { break; } - if (name.charCodeAt(i$1) < 48 || 57 < name.charCodeAt(i$1) || num >= 100000000) { - num = -1; - break; - } - num = (($imul(num, 10)) + ((name.charCodeAt(i$1) >> 0)) >> 0) - 48 >> 0; - i$1 = i$1 + (1) >> 0; - } - if ((name.charCodeAt(0) === 48) && name.length > 1) { - num = -1; - } - rest = $substring(str, i); - ok = true; - return [name, num, rest, ok]; - }; - Regexp.ptr.prototype.FindSubmatchIndex = function(b) { - var _r, _r$1, b, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doExecute($ifaceNil, b, "", 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindSubmatchIndex = function(b) { return this.$val.FindSubmatchIndex(b); }; - Regexp.ptr.prototype.FindStringSubmatch = function(s) { - var _i, _r, _ref, a, dstCap, i, re, ret, s, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; a = $f.a; dstCap = $f.dstCap; i = $f.i; re = $f.re; ret = $f.ret; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - dstCap = arrayType$4.zero(); - _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, re.prog.NumCap, $subslice(new sliceType$3(dstCap), 0, 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - a = _r; - if (a === sliceType$3.nil) { - $s = -1; return sliceType$9.nil; - } - ret = $makeSlice(sliceType$9, (1 + re.numSubexp >> 0)); - _ref = ret; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - if (($imul(2, i)) < a.$length && (x = $imul(2, i), ((x < 0 || x >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x])) >= 0) { - ((i < 0 || i >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i] = $substring(s, (x$1 = $imul(2, i), ((x$1 < 0 || x$1 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$1])), (x$2 = ($imul(2, i)) + 1 >> 0, ((x$2 < 0 || x$2 >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + x$2])))); - } - _i++; - } - $s = -1; return ret; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringSubmatch }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.a = a; $f.dstCap = dstCap; $f.i = i; $f.re = re; $f.ret = ret; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindStringSubmatch = function(s) { return this.$val.FindStringSubmatch(s); }; - Regexp.ptr.prototype.FindStringSubmatchIndex = function(s) { - var _r, _r$1, re, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; re = $f.re; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doExecute($ifaceNil, sliceType$5.nil, s, 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindStringSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.re = re; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindStringSubmatchIndex = function(s) { return this.$val.FindStringSubmatchIndex(s); }; - Regexp.ptr.prototype.FindReaderSubmatchIndex = function(r) { - var _r, _r$1, r, re, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; r = $f.r; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - _r = re.doExecute(r, sliceType$5.nil, "", 0, re.prog.NumCap, sliceType$3.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _r$1 = re.pad(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindReaderSubmatchIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.r = r; $f.re = re; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindReaderSubmatchIndex = function(r) { return this.$val.FindReaderSubmatchIndex(r); }; - Regexp.ptr.prototype.FindAll = function(b, n) { - var b, n, re, result, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - b = [b]; - result = [result]; - re = this; - if (n < 0) { - n = b[0].$length + 1 >> 0; - } - result[0] = sliceType$12.nil; - $r = re.allMatches("", b[0], n, (function(b, result) { return function(match) { - var match; - if (result[0] === sliceType$12.nil) { - result[0] = $makeSlice(sliceType$12, 0, 10); - } - result[0] = $append(result[0], $subslice(b[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); - }; })(b, result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAll }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAll = function(b, n) { return this.$val.FindAll(b, n); }; - Regexp.ptr.prototype.FindAllIndex = function(b, n) { - var b, n, re, result, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - re = this; - if (n < 0) { - n = b.$length + 1 >> 0; - } - result[0] = sliceType$13.nil; - $r = re.allMatches("", b, n, (function(result) { return function(match) { - var match; - if (result[0] === sliceType$13.nil) { - result[0] = $makeSlice(sliceType$13, 0, 10); - } - result[0] = $append(result[0], $subslice(match, 0, 2)); - }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllIndex }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllIndex = function(b, n) { return this.$val.FindAllIndex(b, n); }; - Regexp.ptr.prototype.FindAllString = function(s, n) { - var n, re, result, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - s = [s]; - re = this; - if (n < 0) { - n = s[0].length + 1 >> 0; - } - result[0] = sliceType$9.nil; - $r = re.allMatches(s[0], sliceType$5.nil, n, (function(result, s) { return function(match) { - var match; - if (result[0] === sliceType$9.nil) { - result[0] = $makeSlice(sliceType$9, 0, 10); - } - result[0] = $append(result[0], $substring(s[0], (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]), (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]))); - }; })(result, s)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllString }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllString = function(s, n) { return this.$val.FindAllString(s, n); }; - Regexp.ptr.prototype.FindAllStringIndex = function(s, n) { - var n, re, result, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - re = this; - if (n < 0) { - n = s.length + 1 >> 0; - } - result[0] = sliceType$13.nil; - $r = re.allMatches(s, sliceType$5.nil, n, (function(result) { return function(match) { - var match; - if (result[0] === sliceType$13.nil) { - result[0] = $makeSlice(sliceType$13, 0, 10); - } - result[0] = $append(result[0], $subslice(match, 0, 2)); - }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringIndex }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllStringIndex = function(s, n) { return this.$val.FindAllStringIndex(s, n); }; - Regexp.ptr.prototype.FindAllSubmatch = function(b, n) { - var b, n, re, result, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - b = [b]; - result = [result]; - re = this; - if (n < 0) { - n = b[0].$length + 1 >> 0; - } - result[0] = sliceType$14.nil; - $r = re.allMatches("", b[0], n, (function(b, result) { return function(match) { - var _i, _q, _ref, j, match, slice, x, x$1, x$2; - if (result[0] === sliceType$14.nil) { - result[0] = $makeSlice(sliceType$14, 0, 10); - } - slice = $makeSlice(sliceType$12, (_q = match.$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); - _ref = slice; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - j = _i; - if ((x = $imul(2, j), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { - ((j < 0 || j >= slice.$length) ? ($throwRuntimeError("index out of range"), undefined) : slice.$array[slice.$offset + j] = $subslice(b[0], (x$1 = $imul(2, j), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, j)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); - } - _i++; - } - result[0] = $append(result[0], slice); - }; })(b, result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllSubmatch }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllSubmatch = function(b, n) { return this.$val.FindAllSubmatch(b, n); }; - Regexp.ptr.prototype.FindAllSubmatchIndex = function(b, n) { - var b, n, re, result, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; b = $f.b; n = $f.n; re = $f.re; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - re = this; - if (n < 0) { - n = b.$length + 1 >> 0; - } - result[0] = sliceType$13.nil; - $r = re.allMatches("", b, n, (function(result) { return function(match) { - var match; - if (result[0] === sliceType$13.nil) { - result[0] = $makeSlice(sliceType$13, 0, 10); - } - result[0] = $append(result[0], match); - }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllSubmatchIndex }; } $f.b = b; $f.n = n; $f.re = re; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllSubmatchIndex = function(b, n) { return this.$val.FindAllSubmatchIndex(b, n); }; - Regexp.ptr.prototype.FindAllStringSubmatch = function(s, n) { - var n, re, result, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - s = [s]; - re = this; - if (n < 0) { - n = s[0].length + 1 >> 0; - } - result[0] = sliceType$15.nil; - $r = re.allMatches(s[0], sliceType$5.nil, n, (function(result, s) { return function(match) { - var _i, _q, _ref, j, match, slice, x, x$1, x$2; - if (result[0] === sliceType$15.nil) { - result[0] = $makeSlice(sliceType$15, 0, 10); - } - slice = $makeSlice(sliceType$9, (_q = match.$length / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); - _ref = slice; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - j = _i; - if ((x = $imul(2, j), ((x < 0 || x >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x])) >= 0) { - ((j < 0 || j >= slice.$length) ? ($throwRuntimeError("index out of range"), undefined) : slice.$array[slice.$offset + j] = $substring(s[0], (x$1 = $imul(2, j), ((x$1 < 0 || x$1 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$1])), (x$2 = ($imul(2, j)) + 1 >> 0, ((x$2 < 0 || x$2 >= match.$length) ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + x$2])))); - } - _i++; - } - result[0] = $append(result[0], slice); - }; })(result, s)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringSubmatch }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllStringSubmatch = function(s, n) { return this.$val.FindAllStringSubmatch(s, n); }; - Regexp.ptr.prototype.FindAllStringSubmatchIndex = function(s, n) { - var n, re, result, s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; n = $f.n; re = $f.re; result = $f.result; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - result = [result]; - re = this; - if (n < 0) { - n = s.length + 1 >> 0; - } - result[0] = sliceType$13.nil; - $r = re.allMatches(s, sliceType$5.nil, n, (function(result) { return function(match) { - var match; - if (result[0] === sliceType$13.nil) { - result[0] = $makeSlice(sliceType$13, 0, 10); - } - result[0] = $append(result[0], match); - }; })(result)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return result[0]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.FindAllStringSubmatchIndex }; } $f.n = n; $f.re = re; $f.result = result; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.FindAllStringSubmatchIndex = function(s, n) { return this.$val.FindAllStringSubmatchIndex(s, n); }; - Regexp.ptr.prototype.Split = function(s, n) { - var _i, _r, _ref, beg, end, match, matches, n, re, s, strings$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; beg = $f.beg; end = $f.end; match = $f.match; matches = $f.matches; n = $f.n; re = $f.re; s = $f.s; strings$1 = $f.strings$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - re = this; - if (n === 0) { - $s = -1; return sliceType$9.nil; - } - if (re.expr.length > 0 && (s.length === 0)) { - $s = -1; return new sliceType$9([""]); - } - _r = re.FindAllStringIndex(s, n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - matches = _r; - strings$1 = $makeSlice(sliceType$9, 0, matches.$length); - beg = 0; - end = 0; - _ref = matches; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - match = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (n > 0 && strings$1.$length >= (n - 1 >> 0)) { - break; - } - end = (0 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 0]); - if (!(((1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]) === 0))) { - strings$1 = $append(strings$1, $substring(s, beg, end)); - } - beg = (1 >= match.$length ? ($throwRuntimeError("index out of range"), undefined) : match.$array[match.$offset + 1]); - _i++; - } - if (!((end === s.length))) { - strings$1 = $append(strings$1, $substring(s, beg)); - } - $s = -1; return strings$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: Regexp.ptr.prototype.Split }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f.beg = beg; $f.end = end; $f.match = match; $f.matches = matches; $f.n = n; $f.re = re; $f.s = s; $f.strings$1 = strings$1; $f.$s = $s; $f.$r = $r; return $f; - }; - Regexp.prototype.Split = function(s, n) { return this.$val.Split(s, n); }; - ptrType.methods = [{prop: "reset", name: "reset", pkg: "regexp", typ: $funcType([ptrType$12, $Int, $Int], [], false)}, {prop: "shouldVisit", name: "shouldVisit", pkg: "regexp", typ: $funcType([$Uint32, $Int], [$Bool], false)}, {prop: "push", name: "push", pkg: "regexp", typ: $funcType([ptrType$11, $Uint32, $Int, $Bool], [], false)}]; - ptrType$13.methods = [{prop: "init", name: "init", pkg: "regexp", typ: $funcType([$Int], [], false)}, {prop: "alloc", name: "alloc", pkg: "regexp", typ: $funcType([ptrType$2], [ptrType$1], false)}, {prop: "match", name: "match", pkg: "regexp", typ: $funcType([input, $Int], [$Bool], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([ptrType$14], [], false)}, {prop: "step", name: "step", pkg: "regexp", typ: $funcType([ptrType$14, ptrType$14, $Int, $Int, $Int32, ptrType$3], [], false)}, {prop: "add", name: "add", pkg: "regexp", typ: $funcType([ptrType$14, $Uint32, $Int, sliceType$3, ptrType$3, ptrType$1], [ptrType$1], false)}]; - ptrType$15.methods = [{prop: "newBytes", name: "newBytes", pkg: "regexp", typ: $funcType([sliceType$5], [input], false)}, {prop: "newString", name: "newString", pkg: "regexp", typ: $funcType([$String], [input], false)}, {prop: "newReader", name: "newReader", pkg: "regexp", typ: $funcType([io.RuneReader], [input], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String], [input, $Int], false)}]; - lazyFlag.methods = [{prop: "match", name: "match", pkg: "regexp", typ: $funcType([syntax.EmptyOp], [$Bool], false)}]; - ptrType$8.methods = [{prop: "empty", name: "empty", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "next", name: "next", pkg: "regexp", typ: $funcType([], [$Uint32], false)}, {prop: "clear", name: "clear", pkg: "regexp", typ: $funcType([], [], false)}, {prop: "contains", name: "contains", pkg: "regexp", typ: $funcType([$Uint32], [$Bool], false)}, {prop: "insert", name: "insert", pkg: "regexp", typ: $funcType([$Uint32], [], false)}, {prop: "insertNew", name: "insertNew", pkg: "regexp", typ: $funcType([$Uint32], [], false)}]; - runeSlice.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}]; - ptrType$11.methods = [{prop: "tryBacktrack", name: "tryBacktrack", pkg: "regexp", typ: $funcType([ptrType, input, $Uint32, $Int], [$Bool], false)}, {prop: "backtrack", name: "backtrack", pkg: "regexp", typ: $funcType([sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "doOnePass", name: "doOnePass", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "doMatch", name: "doMatch", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String], [$Bool], false)}, {prop: "doExecute", name: "doExecute", pkg: "regexp", typ: $funcType([io.RuneReader, sliceType$5, $String, $Int, $Int, sliceType$3], [sliceType$3], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Copy", name: "Copy", pkg: "", typ: $funcType([], [ptrType$11], false)}, {prop: "Longest", name: "Longest", pkg: "", typ: $funcType([], [], false)}, {prop: "get", name: "get", pkg: "regexp", typ: $funcType([], [ptrType$13], false)}, {prop: "put", name: "put", pkg: "regexp", typ: $funcType([ptrType$13], [], false)}, {prop: "NumSubexp", name: "NumSubexp", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SubexpNames", name: "SubexpNames", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "LiteralPrefix", name: "LiteralPrefix", pkg: "", typ: $funcType([], [$String, $Bool], false)}, {prop: "MatchReader", name: "MatchReader", pkg: "", typ: $funcType([io.RuneReader], [$Bool], false)}, {prop: "MatchString", name: "MatchString", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "Match", name: "Match", pkg: "", typ: $funcType([sliceType$5], [$Bool], false)}, {prop: "ReplaceAllString", name: "ReplaceAllString", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "ReplaceAllLiteralString", name: "ReplaceAllLiteralString", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "ReplaceAllStringFunc", name: "ReplaceAllStringFunc", pkg: "", typ: $funcType([$String, funcType], [$String], false)}, {prop: "replaceAll", name: "replaceAll", pkg: "regexp", typ: $funcType([sliceType$5, $String, $Int, funcType$1], [sliceType$5], false)}, {prop: "ReplaceAll", name: "ReplaceAll", pkg: "", typ: $funcType([sliceType$5, sliceType$5], [sliceType$5], false)}, {prop: "ReplaceAllLiteral", name: "ReplaceAllLiteral", pkg: "", typ: $funcType([sliceType$5, sliceType$5], [sliceType$5], false)}, {prop: "ReplaceAllFunc", name: "ReplaceAllFunc", pkg: "", typ: $funcType([sliceType$5, funcType$2], [sliceType$5], false)}, {prop: "pad", name: "pad", pkg: "regexp", typ: $funcType([sliceType$3], [sliceType$3], false)}, {prop: "allMatches", name: "allMatches", pkg: "regexp", typ: $funcType([$String, sliceType$5, $Int, funcType$3], [], false)}, {prop: "Find", name: "Find", pkg: "", typ: $funcType([sliceType$5], [sliceType$5], false)}, {prop: "FindIndex", name: "FindIndex", pkg: "", typ: $funcType([sliceType$5], [sliceType$3], false)}, {prop: "FindString", name: "FindString", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "FindStringIndex", name: "FindStringIndex", pkg: "", typ: $funcType([$String], [sliceType$3], false)}, {prop: "FindReaderIndex", name: "FindReaderIndex", pkg: "", typ: $funcType([io.RuneReader], [sliceType$3], false)}, {prop: "FindSubmatch", name: "FindSubmatch", pkg: "", typ: $funcType([sliceType$5], [sliceType$12], false)}, {prop: "Expand", name: "Expand", pkg: "", typ: $funcType([sliceType$5, sliceType$5, sliceType$5, sliceType$3], [sliceType$5], false)}, {prop: "ExpandString", name: "ExpandString", pkg: "", typ: $funcType([sliceType$5, $String, $String, sliceType$3], [sliceType$5], false)}, {prop: "expand", name: "expand", pkg: "regexp", typ: $funcType([sliceType$5, $String, sliceType$5, $String, sliceType$3], [sliceType$5], false)}, {prop: "FindSubmatchIndex", name: "FindSubmatchIndex", pkg: "", typ: $funcType([sliceType$5], [sliceType$3], false)}, {prop: "FindStringSubmatch", name: "FindStringSubmatch", pkg: "", typ: $funcType([$String], [sliceType$9], false)}, {prop: "FindStringSubmatchIndex", name: "FindStringSubmatchIndex", pkg: "", typ: $funcType([$String], [sliceType$3], false)}, {prop: "FindReaderSubmatchIndex", name: "FindReaderSubmatchIndex", pkg: "", typ: $funcType([io.RuneReader], [sliceType$3], false)}, {prop: "FindAll", name: "FindAll", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$12], false)}, {prop: "FindAllIndex", name: "FindAllIndex", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$13], false)}, {prop: "FindAllString", name: "FindAllString", pkg: "", typ: $funcType([$String, $Int], [sliceType$9], false)}, {prop: "FindAllStringIndex", name: "FindAllStringIndex", pkg: "", typ: $funcType([$String, $Int], [sliceType$13], false)}, {prop: "FindAllSubmatch", name: "FindAllSubmatch", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$14], false)}, {prop: "FindAllSubmatchIndex", name: "FindAllSubmatchIndex", pkg: "", typ: $funcType([sliceType$5, $Int], [sliceType$13], false)}, {prop: "FindAllStringSubmatch", name: "FindAllStringSubmatch", pkg: "", typ: $funcType([$String, $Int], [sliceType$15], false)}, {prop: "FindAllStringSubmatchIndex", name: "FindAllStringSubmatchIndex", pkg: "", typ: $funcType([$String, $Int], [sliceType$13], false)}, {prop: "Split", name: "Split", pkg: "", typ: $funcType([$String, $Int], [sliceType$9], false)}]; - ptrType$16.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; - ptrType$17.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; - ptrType$18.methods = [{prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}, {prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}]; - job.init("regexp", [{prop: "pc", name: "pc", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "arg", name: "arg", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "pos", name: "pos", embedded: false, exported: false, typ: $Int, tag: ""}]); - bitState.init("regexp", [{prop: "end", name: "end", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "jobs", name: "jobs", embedded: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "visited", name: "visited", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}]); - queue.init("regexp", [{prop: "sparse", name: "sparse", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "dense", name: "dense", embedded: false, exported: false, typ: sliceType$10, tag: ""}]); - entry.init("regexp", [{prop: "pc", name: "pc", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "t", name: "t", embedded: false, exported: false, typ: ptrType$1, tag: ""}]); - thread.init("regexp", [{prop: "inst", name: "inst", embedded: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "cap", name: "cap", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); - machine.init("regexp", [{prop: "re", name: "re", embedded: false, exported: false, typ: ptrType$11, tag: ""}, {prop: "p", name: "p", embedded: false, exported: false, typ: ptrType$12, tag: ""}, {prop: "q0", name: "q0", embedded: false, exported: false, typ: queue, tag: ""}, {prop: "q1", name: "q1", embedded: false, exported: false, typ: queue, tag: ""}, {prop: "pool", name: "pool", embedded: false, exported: false, typ: sliceType$11, tag: ""}, {prop: "matched", name: "matched", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}, {prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}]); - inputs.init("regexp", [{prop: "bytes", name: "bytes", embedded: false, exported: false, typ: inputBytes, tag: ""}, {prop: "string", name: "string", embedded: false, exported: false, typ: inputString, tag: ""}, {prop: "reader", name: "reader", embedded: false, exported: false, typ: inputReader, tag: ""}]); - onePassMachine.init("regexp", [{prop: "inputs", name: "inputs", embedded: false, exported: false, typ: inputs, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: sliceType$3, tag: ""}]); - onePassProg.init("", [{prop: "Inst", name: "Inst", embedded: false, exported: true, typ: sliceType$6, tag: ""}, {prop: "Start", name: "Start", embedded: false, exported: true, typ: $Int, tag: ""}, {prop: "NumCap", name: "NumCap", embedded: false, exported: true, typ: $Int, tag: ""}]); - onePassInst.init("", [{prop: "Inst", name: "Inst", embedded: true, exported: true, typ: syntax.Inst, tag: ""}, {prop: "Next", name: "Next", embedded: false, exported: true, typ: sliceType$2, tag: ""}]); - queueOnePass.init("regexp", [{prop: "sparse", name: "sparse", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "dense", name: "dense", embedded: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "size", name: "size", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "nextIndex", name: "nextIndex", embedded: false, exported: false, typ: $Uint32, tag: ""}]); - runeSlice.init($Int32); - Regexp.init("regexp", [{prop: "expr", name: "expr", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "prog", name: "prog", embedded: false, exported: false, typ: ptrType$12, tag: ""}, {prop: "onepass", name: "onepass", embedded: false, exported: false, typ: ptrType$6, tag: ""}, {prop: "numSubexp", name: "numSubexp", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "maxBitStateLen", name: "maxBitStateLen", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "subexpNames", name: "subexpNames", embedded: false, exported: false, typ: sliceType$9, tag: ""}, {prop: "prefix", name: "prefix", embedded: false, exported: false, typ: $String, tag: ""}, {prop: "prefixBytes", name: "prefixBytes", embedded: false, exported: false, typ: sliceType$5, tag: ""}, {prop: "prefixRune", name: "prefixRune", embedded: false, exported: false, typ: $Int32, tag: ""}, {prop: "prefixEnd", name: "prefixEnd", embedded: false, exported: false, typ: $Uint32, tag: ""}, {prop: "mpool", name: "mpool", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "matchcap", name: "matchcap", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "prefixComplete", name: "prefixComplete", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "cond", name: "cond", embedded: false, exported: false, typ: syntax.EmptyOp, tag: ""}, {prop: "longest", name: "longest", embedded: false, exported: false, typ: $Bool, tag: ""}]); - input.init([{prop: "canCheckPrefix", name: "canCheckPrefix", pkg: "regexp", typ: $funcType([], [$Bool], false)}, {prop: "context", name: "context", pkg: "regexp", typ: $funcType([$Int], [lazyFlag], false)}, {prop: "hasPrefix", name: "hasPrefix", pkg: "regexp", typ: $funcType([ptrType$11], [$Bool], false)}, {prop: "index", name: "index", pkg: "regexp", typ: $funcType([ptrType$11, $Int], [$Int], false)}, {prop: "step", name: "step", pkg: "regexp", typ: $funcType([$Int], [$Int32, $Int], false)}]); - inputString.init("regexp", [{prop: "str", name: "str", embedded: false, exported: false, typ: $String, tag: ""}]); - inputBytes.init("regexp", [{prop: "str", name: "str", embedded: false, exported: false, typ: sliceType$5, tag: ""}]); - inputReader.init("regexp", [{prop: "r", name: "r", embedded: false, exported: false, typ: io.RuneReader, tag: ""}, {prop: "atEOT", name: "atEOT", embedded: false, exported: false, typ: $Bool, tag: ""}, {prop: "pos", name: "pos", embedded: false, exported: false, typ: $Int, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = nosync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = syntax.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sort.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strings.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = unicode.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = utf8.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - bitStatePool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); - onePassPool = new nosync.Pool.ptr(sliceType.nil, $throwNilPointerError); - arrayNoInts = arrayType.zero(); - matchPool = arrayType$1.zero(); - specialBytes = arrayType$2.zero(); - noRune = new sliceType$1([]); - noNext = new sliceType$2([4294967295]); - anyRuneNotNL = new sliceType$1([0, 9, 11, 1114111]); - anyRune = new sliceType$1([0, 1114111]); - matchSize = $toNativeArray($kindInt, [128, 512, 2048, 16384, 0]); - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["github.com/bonedaddy/vcaptcha/vdf"] = (function() { - var $pkg = {}, $init, bytes, sha256, binary, fmt, log, math, big, regexp, runtime, sort, time, ClassGroup, Pair, VDF, sliceType, sliceType$1, ptrType, ptrType$1, sliceType$2, arrayType, sliceType$3, sliceType$4, sliceType$5, arrayType$1, chanType, ptrType$2, residues, sieve_info, m, bigOne, CloneClassGroup, NewClassGroup, NewClassGroupFromAbDiscriminant, NewClassGroupFromBytesDiscriminant, IdentityForDiscriminant, EntropyFromSeed, CreateDiscriminant, floorDivision, decodeTwosComplement, encodeTwosComplement, signBitFill, extendedGCD, allInputValueGCD, SolveMod, primeLessThanN, checkArrayEqual, testIntLessThan, main, approximateParameters, iterateSquarings, GenerateVDF, GenerateVDFWithStopChan, VerifyVDF, hashPrime, getBlock, evalOptimized, generateProof, calculateVDF, verifyProof, timeTrack, New; - bytes = $packages["bytes"]; - sha256 = $packages["crypto/sha256"]; - binary = $packages["encoding/binary"]; - fmt = $packages["fmt"]; - log = $packages["log"]; - math = $packages["math"]; - big = $packages["math/big"]; - regexp = $packages["regexp"]; - runtime = $packages["runtime"]; - sort = $packages["sort"]; - time = $packages["time"]; - ClassGroup = $pkg.ClassGroup = $newType(0, $kindStruct, "vdf.ClassGroup", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(a_, b_, c_, d_) { - this.$val = this; - if (arguments.length === 0) { - this.a = ptrType.nil; - this.b = ptrType.nil; - this.c = ptrType.nil; - this.d = ptrType.nil; - return; - } - this.a = a_; - this.b = b_; - this.c = c_; - this.d = d_; - }); - Pair = $pkg.Pair = $newType(0, $kindStruct, "vdf.Pair", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(p_, q_) { - this.$val = this; - if (arguments.length === 0) { - this.p = new $Int64(0, 0); - this.q = new $Int64(0, 0); - return; - } - this.p = p_; - this.q = q_; - }); - VDF = $pkg.VDF = $newType(0, $kindStruct, "vdf.VDF", true, "github.com/bonedaddy/vcaptcha/vdf", true, function(difficulty_, input_, output_, outputChan_, finished_) { - this.$val = this; - if (arguments.length === 0) { - this.difficulty = 0; - this.input = arrayType.zero(); - this.output = arrayType$1.zero(); - this.outputChan = $chanNil; - this.finished = false; - return; - } - this.difficulty = difficulty_; - this.input = input_; - this.output = output_; - this.outputChan = outputChan_; - this.finished = finished_; - }); - sliceType = $sliceType($Int); - sliceType$1 = $sliceType(Pair); - ptrType = $ptrType(big.Int); - ptrType$1 = $ptrType(ClassGroup); - sliceType$2 = $sliceType($Uint8); - arrayType = $arrayType($Uint8, 32); - sliceType$3 = $sliceType($Bool); - sliceType$4 = $sliceType($emptyInterface); - sliceType$5 = $sliceType(ptrType$1); - arrayType$1 = $arrayType($Uint8, 516); - chanType = $chanType(arrayType$1, false, false); - ptrType$2 = $ptrType(VDF); - CloneClassGroup = function(cg) { - var cg; - return new ClassGroup.ptr(cg.a, cg.b, cg.c, ptrType.nil); - }; - $pkg.CloneClassGroup = CloneClassGroup; - NewClassGroup = function(a, b, c) { - var a, b, c; - return new ClassGroup.ptr(a, b, c, ptrType.nil); - }; - $pkg.NewClassGroup = NewClassGroup; - NewClassGroupFromAbDiscriminant = function(a, b, discriminant) { - var _r, a, b, c, discriminant, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; c = $f.c; discriminant = $f.discriminant; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - z = new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(b, b), discriminant); - _r = floorDivision(z, new big.Int.ptr(false, big.nat.nil).Mul(a, big.NewInt(new $Int64(0, 4)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - c = _r; - $s = -1; return NewClassGroup(a, b, c); - /* */ } return; } if ($f === undefined) { $f = { $blk: NewClassGroupFromAbDiscriminant }; } $f._r = _r; $f.a = a; $f.b = b; $f.c = c; $f.discriminant = discriminant; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewClassGroupFromAbDiscriminant = NewClassGroupFromAbDiscriminant; - NewClassGroupFromBytesDiscriminant = function(buf, discriminant) { - var _r, a, b, buf, discriminant, int_size, int_size_bits, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; buf = $f.buf; discriminant = $f.discriminant; int_size = $f.int_size; int_size_bits = $f.int_size_bits; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - int_size_bits = discriminant.BitLen(); - int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; - if (!((buf.$length === ($imul(int_size, 2))))) { - $s = -1; return [ptrType$1.nil, false]; - } - a = decodeTwosComplement($subslice(buf, 0, int_size)); - b = decodeTwosComplement($subslice(buf, int_size)); - _r = NewClassGroupFromAbDiscriminant(a, b, discriminant); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return [_r, true]; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewClassGroupFromBytesDiscriminant }; } $f._r = _r; $f.a = a; $f.b = b; $f.buf = buf; $f.discriminant = discriminant; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewClassGroupFromBytesDiscriminant = NewClassGroupFromBytesDiscriminant; - IdentityForDiscriminant = function(d) { - var _r, d, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 1)), big.NewInt(new $Int64(0, 1)), d); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: IdentityForDiscriminant }; } $f._r = _r; $f.d = d; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.IdentityForDiscriminant = IdentityForDiscriminant; - ClassGroup.ptr.prototype.Normalized = function() { - var _r, a, b, c, group, oldB, r, t, x, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; c = $f.c; group = $f.group; oldB = $f.oldB; r = $f.r; t = $f.t; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - a = new big.Int.ptr(false, big.nat.nil).Set(group.a); - b = new big.Int.ptr(false, big.nat.nil).Set(group.b); - c = new big.Int.ptr(false, big.nat.nil).Set(group.c); - if (((b.Cmp(new big.Int.ptr(false, big.nat.nil).Neg(a)) === 1)) && (b.Cmp(a) < 1)) { - $s = -1; return group; - } - r = new big.Int.ptr(false, big.nat.nil).Sub(a, b); - _r = floorDivision(r, new big.Int.ptr(false, big.nat.nil).Mul(a, big.NewInt(new $Int64(0, 2)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - t = new big.Int.ptr(false, big.nat.nil).Mul(big.NewInt(new $Int64(0, 2)), r); - t.Mul(t, a); - oldB = new big.Int.ptr(false, big.nat.nil).Set(b); - b.Add(b, t); - x = new big.Int.ptr(false, big.nat.nil).Mul(a, r); - x.Mul(x, r); - y = new big.Int.ptr(false, big.nat.nil).Mul(oldB, r); - c.Add(c, x); - c.Add(c, y); - $s = -1; return NewClassGroup(a, b, c); - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Normalized }; } $f._r = _r; $f.a = a; $f.b = b; $f.c = c; $f.group = group; $f.oldB = oldB; $f.r = r; $f.t = t; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Normalized = function() { return this.$val.Normalized(); }; - ClassGroup.ptr.prototype.Reduced = function() { - var _r, _r$1, _r$2, a, b, c, g, group, oldA, oldB, s, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; a = $f.a; b = $f.b; c = $f.c; g = $f.g; group = $f.group; oldA = $f.oldA; oldB = $f.oldB; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = group.Normalized(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - g = _r; - a = new big.Int.ptr(false, big.nat.nil).Set(g.a); - b = new big.Int.ptr(false, big.nat.nil).Set(g.b); - c = new big.Int.ptr(false, big.nat.nil).Set(g.c); - /* while (true) { */ case 2: - /* if (!(((a.Cmp(c) === 1)) || (((a.Cmp(c) === 0)) && ((b.Sign() === -1))))) { break; } */ if(!(((a.Cmp(c) === 1)) || (((a.Cmp(c) === 0)) && ((b.Sign() === -1))))) { $s = 3; continue; } - s = new big.Int.ptr(false, big.nat.nil).Add(c, b); - _r$1 = floorDivision(s, new big.Int.ptr(false, big.nat.nil).Add(c, c)); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - s = _r$1; - oldA = new big.Int.ptr(false, big.nat.nil).Set(a); - oldB = new big.Int.ptr(false, big.nat.nil).Set(b); - a = new big.Int.ptr(false, big.nat.nil).Set(c); - b.Neg(b); - x = new big.Int.ptr(false, big.nat.nil).Mul(big.NewInt(new $Int64(0, 2)), s); - x.Mul(x, c); - b.Add(b, x); - c.Mul(c, s); - c.Mul(c, s); - oldB.Mul(oldB, s); - c.Sub(c, oldB); - c.Add(c, oldA); - /* } */ $s = 2; continue; case 3: - _r$2 = NewClassGroup(a, b, c).Normalized(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Reduced }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.a = a; $f.b = b; $f.c = c; $f.g = g; $f.group = group; $f.oldA = oldA; $f.oldB = oldB; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Reduced = function() { return this.$val.Reduced(); }; - ClassGroup.ptr.prototype.identity = function() { - var _r, group, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; group = $f.group; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 1)), big.NewInt(new $Int64(0, 1)), group.Discriminant()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.identity }; } $f._r = _r; $f.group = group; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.identity = function() { return this.$val.identity(); }; - ClassGroup.ptr.prototype.Discriminant = function() { - var a, d, group; - group = this; - if (group.d === ptrType.nil) { - d = new big.Int.ptr(false, big.nat.nil).Set(group.b); - d.Mul(d, d); - a = new big.Int.ptr(false, big.nat.nil).Set(group.a); - a.Mul(a, group.c); - a.Mul(a, big.NewInt(new $Int64(0, 4))); - d.Sub(d, a); - group.d = d; - } - return group.d; - }; - ClassGroup.prototype.Discriminant = function() { return this.$val.Discriminant(); }; - ClassGroup.ptr.prototype.Multiply = function(other) { - var _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, a3, b, b3, c3, constant_factor, g, group, h, hu, j, jm, ju, k, k_temp, kl, kt, l, ls, m$1, mr, n, other, r, ru, s, sc, solvable, st, t, tuk, u, w, w1, x, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a3 = $f.a3; b = $f.b; b3 = $f.b3; c3 = $f.c3; constant_factor = $f.constant_factor; g = $f.g; group = $f.group; h = $f.h; hu = $f.hu; j = $f.j; jm = $f.jm; ju = $f.ju; k = $f.k; k_temp = $f.k_temp; kl = $f.kl; kt = $f.kt; l = $f.l; ls = $f.ls; m$1 = $f.m$1; mr = $f.mr; n = $f.n; other = $f.other; r = $f.r; ru = $f.ru; s = $f.s; sc = $f.sc; solvable = $f.solvable; st = $f.st; t = $f.t; tuk = $f.tuk; u = $f.u; w = $f.w; w1 = $f.w1; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x = _r; - _r$1 = other.Reduced(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - y = _r$1; - g = new big.Int.ptr(false, big.nat.nil).Add(x.b, y.b); - _r$2 = floorDivision(g, big.NewInt(new $Int64(0, 2))); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - g = _r$2; - h = new big.Int.ptr(false, big.nat.nil).Sub(y.b, x.b); - _r$3 = floorDivision(h, big.NewInt(new $Int64(0, 2))); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - h = _r$3; - _r$4 = allInputValueGCD(y.a, g); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - w1 = _r$4; - _r$5 = allInputValueGCD(x.a, w1); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - w = _r$5; - j = new big.Int.ptr(false, big.nat.nil).Set(w); - r = big.NewInt(new $Int64(0, 0)); - _r$6 = floorDivision(x.a, w); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - s = _r$6; - _r$7 = floorDivision(y.a, w); /* */ $s = 8; case 8: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - t = _r$7; - _r$8 = floorDivision(g, w); /* */ $s = 9; case 9: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - u = _r$8; - b = new big.Int.ptr(false, big.nat.nil).Mul(h, u); - sc = new big.Int.ptr(false, big.nat.nil).Mul(s, x.c); - b.Add(b, sc); - _r$9 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, u), b, new big.Int.ptr(false, big.nat.nil).Mul(s, t)); /* */ $s = 10; case 10: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - _tuple = _r$9; - k_temp = _tuple[0]; - constant_factor = _tuple[1]; - solvable = _tuple[2]; - if (!solvable) { - $s = -1; return ptrType$1.nil; - } - _r$10 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, constant_factor), new big.Int.ptr(false, big.nat.nil).Sub(h, new big.Int.ptr(false, big.nat.nil).Mul(t, k_temp)), s); /* */ $s = 11; case 11: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } - _tuple$1 = _r$10; - n = _tuple$1[0]; - solvable = _tuple$1[2]; - if (!solvable) { - $s = -1; return ptrType$1.nil; - } - k = new big.Int.ptr(false, big.nat.nil).Add(k_temp, new big.Int.ptr(false, big.nat.nil).Mul(constant_factor, n)); - _r$11 = floorDivision(new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(t, k), h), s); /* */ $s = 12; case 12: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } - l = _r$11; - tuk = new big.Int.ptr(false, big.nat.nil).Mul(t, u); - tuk.Mul(tuk, k); - hu = new big.Int.ptr(false, big.nat.nil).Mul(h, u); - tuk.Sub(tuk, hu); - tuk.Sub(tuk, sc); - st = new big.Int.ptr(false, big.nat.nil).Mul(s, t); - _r$12 = floorDivision(tuk, st); /* */ $s = 13; case 13: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } - m$1 = _r$12; - ru = new big.Int.ptr(false, big.nat.nil).Mul(r, u); - a3 = st.Sub(st, ru); - ju = new big.Int.ptr(false, big.nat.nil).Mul(j, u); - mr = new big.Int.ptr(false, big.nat.nil).Mul(m$1, r); - ju = ju.Add(ju, mr); - kt = new big.Int.ptr(false, big.nat.nil).Mul(k, t); - ls = new big.Int.ptr(false, big.nat.nil).Mul(l, s); - kt = kt.Add(kt, ls); - b3 = ju.Sub(ju, kt); - kl = new big.Int.ptr(false, big.nat.nil).Mul(k, l); - jm = new big.Int.ptr(false, big.nat.nil).Mul(j, m$1); - c3 = kl.Sub(kl, jm); - _r$13 = NewClassGroup(a3, b3, c3).Reduced(); /* */ $s = 14; case 14: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } - $s = -1; return _r$13; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Multiply }; } $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a3 = a3; $f.b = b; $f.b3 = b3; $f.c3 = c3; $f.constant_factor = constant_factor; $f.g = g; $f.group = group; $f.h = h; $f.hu = hu; $f.j = j; $f.jm = jm; $f.ju = ju; $f.k = k; $f.k_temp = k_temp; $f.kl = kl; $f.kt = kt; $f.l = l; $f.ls = ls; $f.m$1 = m$1; $f.mr = mr; $f.n = n; $f.other = other; $f.r = r; $f.ru = ru; $f.s = s; $f.sc = sc; $f.solvable = solvable; $f.st = st; $f.t = t; $f.tuk = tuk; $f.u = u; $f.w = w; $f.w1 = w1; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Multiply = function(other) { return this.$val.Multiply(other); }; - ClassGroup.ptr.prototype.Pow = function(n) { - var _r, _r$1, _r$2, group, items_prod, n, x, x$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; group = $f.group; items_prod = $f.items_prod; n = $f.n; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - x = CloneClassGroup(group); - _r = group.identity(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - items_prod = _r; - /* while (true) { */ case 2: - /* if (!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { break; } */ if(!((n.$high > 0 || (n.$high === 0 && n.$low > 0)))) { $s = 3; continue; } - /* */ if ((x$1 = new $Int64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((x$1 = new $Int64(n.$high & 0, (n.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) { */ case 4: - _r$1 = items_prod.Multiply(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - items_prod = _r$1; - if (items_prod === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - /* } */ case 5: - _r$2 = x.Square(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = _r$2; - if (x === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - n = $shiftRightInt64(n, (1)); - /* } */ $s = 2; continue; case 3: - $s = -1; return items_prod; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Pow }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.group = group; $f.items_prod = items_prod; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Pow = function(n) { return this.$val.Pow(n); }; - ClassGroup.ptr.prototype.BigPow = function(n) { - var _r, _r$1, _r$2, group, items_prod, n, p, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; group = $f.group; items_prod = $f.items_prod; n = $f.n; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - x = CloneClassGroup(group); - _r = group.identity(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - items_prod = _r; - p = new big.Int.ptr(false, big.nat.nil).Set(n); - /* while (true) { */ case 2: - /* if (!(p.Sign() > 0)) { break; } */ if(!(p.Sign() > 0)) { $s = 3; continue; } - /* */ if (p.Bit(0) === 1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (p.Bit(0) === 1) { */ case 4: - _r$1 = items_prod.Multiply(x); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - items_prod = _r$1; - if (items_prod === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - /* } */ case 5: - _r$2 = x.Square(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - x = _r$2; - if (x === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - p.Rsh(p, 1); - /* } */ $s = 2; continue; case 3: - $s = -1; return items_prod; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.BigPow }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.group = group; $f.items_prod = items_prod; $f.n = n; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.BigPow = function(n) { return this.$val.BigPow(n); }; - ClassGroup.ptr.prototype.Square = function() { - var A, B, C, _r, _r$1, _r$2, _tuple, au, group, m$1, solvable, u, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; A = $f.A; B = $f.B; C = $f.C; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; au = $f.au; group = $f.group; m$1 = $f.m$1; solvable = $f.solvable; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = SolveMod(group.b, group.c, group.a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - u = _tuple[0]; - solvable = _tuple[2]; - if (!solvable) { - $s = -1; return ptrType$1.nil; - } - A = new big.Int.ptr(false, big.nat.nil).Mul(group.a, group.a); - au = new big.Int.ptr(false, big.nat.nil).Mul(group.a, u); - B = new big.Int.ptr(false, big.nat.nil).Sub(group.b, new big.Int.ptr(false, big.nat.nil).Mul(au, big.NewInt(new $Int64(0, 2)))); - C = new big.Int.ptr(false, big.nat.nil).Mul(u, u); - m$1 = new big.Int.ptr(false, big.nat.nil).Mul(group.b, u); - m$1 = new big.Int.ptr(false, big.nat.nil).Sub(m$1, group.c); - _r$1 = floorDivision(m$1, group.a); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - m$1 = _r$1; - C = new big.Int.ptr(false, big.nat.nil).Sub(C, m$1); - _r$2 = NewClassGroup(A, B, C).Reduced(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $s = -1; return _r$2; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Square }; } $f.A = A; $f.B = B; $f.C = C; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.au = au; $f.group = group; $f.m$1 = m$1; $f.solvable = solvable; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Square = function() { return this.$val.Square(); }; - ClassGroup.ptr.prototype.SquareUsingMultiply = function() { - var _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tuple, _tuple$1, a3, b, b3, c3, constant_factor, g, group, h, hu, j, jm, ju, k, k_temp, kl, kt, l, ls, m$1, mr, n, r, ru, s, sc, solvable, st, t, tuk, u, w, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a3 = $f.a3; b = $f.b; b3 = $f.b3; c3 = $f.c3; constant_factor = $f.constant_factor; g = $f.g; group = $f.group; h = $f.h; hu = $f.hu; j = $f.j; jm = $f.jm; ju = $f.ju; k = $f.k; k_temp = $f.k_temp; kl = $f.kl; kt = $f.kt; l = $f.l; ls = $f.ls; m$1 = $f.m$1; mr = $f.mr; n = $f.n; r = $f.r; ru = $f.ru; s = $f.s; sc = $f.sc; solvable = $f.solvable; st = $f.st; t = $f.t; tuk = $f.tuk; u = $f.u; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x = _r; - g = x.b; - h = big.NewInt(new $Int64(0, 0)); - _r$1 = allInputValueGCD(x.a, g); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - w = _r$1; - j = new big.Int.ptr(false, big.nat.nil).Set(w); - r = big.NewInt(new $Int64(0, 0)); - _r$2 = floorDivision(x.a, w); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - s = _r$2; - t = s; - _r$3 = floorDivision(g, w); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - u = _r$3; - b = new big.Int.ptr(false, big.nat.nil).Mul(h, u); - sc = new big.Int.ptr(false, big.nat.nil).Mul(s, x.c); - b.Add(b, sc); - _r$4 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, u), b, new big.Int.ptr(false, big.nat.nil).Mul(s, t)); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _tuple = _r$4; - k_temp = _tuple[0]; - constant_factor = _tuple[1]; - solvable = _tuple[2]; - if (!solvable) { - $s = -1; return ptrType$1.nil; - } - _r$5 = SolveMod(new big.Int.ptr(false, big.nat.nil).Mul(t, constant_factor), new big.Int.ptr(false, big.nat.nil).Sub(h, new big.Int.ptr(false, big.nat.nil).Mul(t, k_temp)), s); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple$1 = _r$5; - n = _tuple$1[0]; - solvable = _tuple$1[2]; - if (!solvable) { - $s = -1; return ptrType$1.nil; - } - k = new big.Int.ptr(false, big.nat.nil).Add(k_temp, new big.Int.ptr(false, big.nat.nil).Mul(constant_factor, n)); - _r$6 = floorDivision(new big.Int.ptr(false, big.nat.nil).Sub(new big.Int.ptr(false, big.nat.nil).Mul(t, k), h), s); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - l = _r$6; - tuk = new big.Int.ptr(false, big.nat.nil).Mul(t, u); - tuk.Mul(tuk, k); - hu = new big.Int.ptr(false, big.nat.nil).Mul(h, u); - tuk.Sub(tuk, hu); - tuk.Sub(tuk, sc); - st = new big.Int.ptr(false, big.nat.nil).Mul(s, t); - _r$7 = floorDivision(tuk, st); /* */ $s = 8; case 8: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - m$1 = _r$7; - ru = new big.Int.ptr(false, big.nat.nil).Mul(r, u); - a3 = st.Sub(st, ru); - ju = new big.Int.ptr(false, big.nat.nil).Mul(j, u); - mr = new big.Int.ptr(false, big.nat.nil).Mul(m$1, r); - ju = ju.Add(ju, mr); - kt = new big.Int.ptr(false, big.nat.nil).Mul(k, t); - ls = new big.Int.ptr(false, big.nat.nil).Mul(l, s); - kt = kt.Add(kt, ls); - b3 = ju.Sub(ju, kt); - kl = new big.Int.ptr(false, big.nat.nil).Mul(k, l); - jm = new big.Int.ptr(false, big.nat.nil).Mul(j, m$1); - c3 = kl.Sub(kl, jm); - _r$8 = NewClassGroup(a3, b3, c3).Reduced(); /* */ $s = 9; case 9: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - $s = -1; return _r$8; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.SquareUsingMultiply }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a3 = a3; $f.b = b; $f.b3 = b3; $f.c3 = c3; $f.constant_factor = constant_factor; $f.g = g; $f.group = group; $f.h = h; $f.hu = hu; $f.j = j; $f.jm = jm; $f.ju = ju; $f.k = k; $f.k_temp = k_temp; $f.kl = kl; $f.kt = kt; $f.l = l; $f.ls = ls; $f.m$1 = m$1; $f.mr = mr; $f.n = n; $f.r = r; $f.ru = ru; $f.s = s; $f.sc = sc; $f.solvable = solvable; $f.st = st; $f.t = t; $f.tuk = tuk; $f.u = u; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.SquareUsingMultiply = function() { return this.$val.SquareUsingMultiply(); }; - ClassGroup.ptr.prototype.Serialize = function() { - var _r, buf, group, int_size, int_size_bits, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; buf = $f.buf; group = $f.group; int_size = $f.int_size; int_size_bits = $f.int_size_bits; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - int_size_bits = group.Discriminant().BitLen(); - int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; - buf = $makeSlice(sliceType$2, ($imul(int_size, 2))); - $copySlice($subslice(buf, 0, int_size), signBitFill(encodeTwosComplement(r.a), int_size)); - $copySlice($subslice(buf, int_size), signBitFill(encodeTwosComplement(r.b), int_size)); - $s = -1; return buf; - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Serialize }; } $f._r = _r; $f.buf = buf; $f.group = group; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Serialize = function() { return this.$val.Serialize(); }; - ClassGroup.ptr.prototype.Equal = function(other) { - var _r, _r$1, g, group, o, other, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; g = $f.g; group = $f.group; o = $f.o; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - group = this; - _r = group.Reduced(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - g = _r; - _r$1 = other.Reduced(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - o = _r$1; - $s = -1; return (g.a.Cmp(o.a) === 0) && (g.b.Cmp(o.b) === 0) && (g.c.Cmp(o.c) === 0); - /* */ } return; } if ($f === undefined) { $f = { $blk: ClassGroup.ptr.prototype.Equal }; } $f._r = _r; $f._r$1 = _r$1; $f.g = g; $f.group = group; $f.o = o; $f.other = other; $f.$s = $s; $f.$r = $r; return $f; - }; - ClassGroup.prototype.Equal = function(other) { return this.$val.Equal(other); }; - EntropyFromSeed = function(seed, byte_count) { - var _r, buffer, bufferSize, byte_count, bytes$1, extra, more_entropy, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; buffer = $f.buffer; bufferSize = $f.bufferSize; byte_count = $f.byte_count; bytes$1 = $f.bytes$1; extra = $f.extra; more_entropy = $f.more_entropy; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - buffer = new bytes.Buffer.ptr(sliceType$2.nil, 0, 0); - bufferSize = 0; - extra = 0; - bytes$1 = $makeSlice(sliceType$2, (seed.$length + 2 >> 0)); - $copySlice(bytes$1, seed); - /* while (true) { */ case 1: - /* if (!(bufferSize <= byte_count)) { break; } */ if(!(bufferSize <= byte_count)) { $s = 2; continue; } - $clone(binary.BigEndian, binary.bigEndian).PutUint16($subslice(bytes$1, seed.$length), extra); - _r = sha256.Sum256(bytes$1); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - more_entropy = $clone(_r, arrayType); - buffer.Write(new sliceType$2(more_entropy)); - bufferSize = bufferSize + (32) >> 0; - extra = extra + (1) << 16 >>> 16; - /* } */ $s = 1; continue; case 2: - $s = -1; return $subslice(buffer.Bytes(), 0, byte_count); - /* */ } return; } if ($f === undefined) { $f = { $blk: EntropyFromSeed }; } $f._r = _r; $f.buffer = buffer; $f.bufferSize = bufferSize; $f.byte_count = byte_count; $f.bytes$1 = bytes$1; $f.extra = extra; $f.more_entropy = more_entropy; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.EntropyFromSeed = EntropyFromSeed; - CreateDiscriminant = function(seed, length) { - var _arg, _arg$1, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _v, bigM, byte_count, entropy, extra, i, i$1, length, n, negN, seed, sieve, t, v, v$1, x, x$1, x$2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; bigM = $f.bigM; byte_count = $f.byte_count; entropy = $f.entropy; extra = $f.extra; i = $f.i; i$1 = $f.i$1; length = $f.length; n = $f.n; negN = $f.negN; seed = $f.seed; sieve = $f.sieve; t = $f.t; v = $f.v; v$1 = $f.v$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - extra = (((length << 24 >>> 24)) & 7) >>> 0; - byte_count = ((((length + 7 >> 0)) >> 3 >> 0)) + 2 >> 0; - _r = EntropyFromSeed(seed, byte_count); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - entropy = _r; - n = new big.Int.ptr(false, big.nat.nil); - n.SetBytes($subslice(entropy, 0, (entropy.$length - 2 >> 0))); - n = new big.Int.ptr(false, big.nat.nil).Rsh(n, (((((((8 - extra << 24 >>> 24)) & 7) >>> 0)) >>> 0))); - n = new big.Int.ptr(false, big.nat.nil).SetBit(n, length - 1 >> 0, 1); - _arg = n; - _r$1 = new big.Int.ptr(false, big.nat.nil).Mod(n, big.NewInt((new $Int64(0, m)))); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _arg$1 = _r$1; - _r$2 = new big.Int.ptr(false, big.nat.nil).Sub(_arg, _arg$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - n = _r$2; - n = new big.Int.ptr(false, big.nat.nil).Add(n, big.NewInt((new $Int64(0, (x = (_r$3 = (($clone(binary.BigEndian, binary.bigEndian).Uint16($subslice(entropy, (entropy.$length - 2 >> 0), entropy.$length)) >> 0)) % residues.$length, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")), ((x < 0 || x >= residues.$length) ? ($throwRuntimeError("index out of range"), undefined) : residues.$array[residues.$offset + x])))))); - negN = new big.Int.ptr(false, big.nat.nil).Neg(n); - /* while (true) { */ case 4: - sieve = $makeSlice(sliceType$3, 65536); - _ref = sieve_info; - _i = 0; - /* while (true) { */ case 6: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 7; continue; } - v = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), Pair); - _r$4 = new big.Int.ptr(false, big.nat.nil).Mod(negN, big.NewInt(v.p)); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - _r$5 = _r$4.Int64(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - i = $div64(($mul64(_r$5, v.q)), v.p, true); - while (true) { - if (!((x$1 = (new $Int64(0, sieve.$length)), (i.$high < x$1.$high || (i.$high === x$1.$high && i.$low < x$1.$low))))) { break; } - (($flatten64(i) < 0 || $flatten64(i) >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + $flatten64(i)] = true); - i = (x$2 = v.p, new $Int64(i.$high + x$2.$high, i.$low + x$2.$low)); - } - _i++; - /* } */ $s = 6; continue; case 7: - _ref$1 = sieve; - _i$1 = 0; - /* while (true) { */ case 10: - /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 11; continue; } - i$1 = _i$1; - v$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); - t = new big.Int.ptr(false, big.nat.nil).Add(n, big.NewInt($mul64((new $Int64(0, m)), (new $Int64(0, i$1))))); - if (!(!v$1)) { _v = false; $s = 14; continue s; } - _r$6 = t.ProbablyPrime(1); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _v = _r$6; case 14: - /* */ if (_v) { $s = 12; continue; } - /* */ $s = 13; continue; - /* if (_v) { */ case 12: - $s = -1; return new big.Int.ptr(false, big.nat.nil).Neg(t); - /* } */ case 13: - _i$1++; - /* } */ $s = 10; continue; case 11: - bigM = big.NewInt((new $Int64(0, m))); - n = new big.Int.ptr(false, big.nat.nil).Add(n, bigM.Mul(bigM, big.NewInt(new $Int64(0, 65536)))); - /* } */ $s = 4; continue; case 5: - $s = -1; return ptrType.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: CreateDiscriminant }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f.bigM = bigM; $f.byte_count = byte_count; $f.entropy = entropy; $f.extra = extra; $f.i = i; $f.i$1 = i$1; $f.length = length; $f.n = n; $f.negN = negN; $f.seed = seed; $f.sieve = sieve; $f.t = t; $f.v = v; $f.v$1 = v$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.CreateDiscriminant = CreateDiscriminant; - floorDivision = function(x, y) { - var _r, _tuple, q, r, x, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; q = $f.q; r = $f.r; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = [r]; - r[0] = new big.Int.ptr(false, big.nat.nil); - _r = new big.Int.ptr(false, big.nat.nil).QuoRem(x, y, r[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - q = _tuple[0]; - if (((r[0].Sign() === 1) && (y.Sign() === -1)) || ((r[0].Sign() === -1) && (y.Sign() === 1))) { - q.Sub(q, big.NewInt(new $Int64(0, 1))); - } - $s = -1; return q; - /* */ } return; } if ($f === undefined) { $f = { $blk: floorDivision }; } $f._r = _r; $f._tuple = _tuple; $f.q = q; $f.r = r; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - decodeTwosComplement = function(bytes$1) { - var _i, _ref, bytes$1, i, n, setyb; - if ((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0) { - return new big.Int.ptr(false, big.nat.nil).SetBytes(bytes$1); - } - setyb = $makeSlice(sliceType$2, bytes$1.$length); - _ref = bytes$1; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - ((i < 0 || i >= setyb.$length) ? ($throwRuntimeError("index out of range"), undefined) : setyb.$array[setyb.$offset + i] = ((((i < 0 || i >= bytes$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + i]) ^ 255) << 24 >>> 24)); - _i++; - } - n = new big.Int.ptr(false, big.nat.nil).SetBytes(setyb); - return n.Sub(n.Neg(n), bigOne); - }; - encodeTwosComplement = function(n) { - var _i, _ref, buf, buf$1, bytes$1, bytes$2, i, n, nMinus1; - if (n.Sign() > 0) { - bytes$1 = n.Bytes(); - if ((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0) { - return bytes$1; - } - buf = $makeSlice(sliceType$2, (bytes$1.$length + 1 >> 0)); - $copySlice($subslice(buf, 1), bytes$1); - return buf; - } - if (n.Sign() < 0) { - nMinus1 = new big.Int.ptr(false, big.nat.nil).Neg(n); - nMinus1.Sub(nMinus1, bigOne); - bytes$2 = nMinus1.Bytes(); - if (bytes$2.$length === 0) { - return new sliceType$2([255]); - } - _ref = bytes$2; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - ((i < 0 || i >= bytes$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + i] = ((((i < 0 || i >= bytes$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + i]) ^ (255)) << 24 >>> 24)); - _i++; - } - if (!(((((0 >= bytes$2.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$2.$array[bytes$2.$offset + 0]) & 128) >>> 0) === 0))) { - return bytes$2; - } - buf$1 = $makeSlice(sliceType$2, (bytes$2.$length + 1 >> 0)); - (0 >= buf$1.$length ? ($throwRuntimeError("index out of range"), undefined) : buf$1.$array[buf$1.$offset + 0] = 255); - $copySlice($subslice(buf$1, 1), bytes$2); - return buf$1; - } - return new sliceType$2([]); - }; - signBitFill = function(bytes$1, targetLen) { - var buf, bytes$1, i, offset, targetLen; - if (bytes$1.$length >= targetLen) { - return bytes$1; - } - buf = $makeSlice(sliceType$2, targetLen); - offset = targetLen - bytes$1.$length >> 0; - if (!(((((0 >= bytes$1.$length ? ($throwRuntimeError("index out of range"), undefined) : bytes$1.$array[bytes$1.$offset + 0]) & 128) >>> 0) === 0))) { - i = 0; - while (true) { - if (!(i < offset)) { break; } - ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 255); - i = i + (1) >> 0; - } - } - $copySlice($subslice(buf, offset), bytes$1); - return buf; - }; - extendedGCD = function(a, b) { - var _r, _tmp, _tmp$1, _tmp$2, _tuple, a, b, bb, oldR0, oldS0, oldS0$1, oldS1, oldT0, q, r, r$1, r0, r1, s, s0, s1, t, t0, t1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; a = $f.a; b = $f.b; bb = $f.bb; oldR0 = $f.oldR0; oldS0 = $f.oldS0; oldS0$1 = $f.oldS0$1; oldS1 = $f.oldS1; oldT0 = $f.oldT0; q = $f.q; r = $f.r; r$1 = $f.r$1; r0 = $f.r0; r1 = $f.r1; s = $f.s; s0 = $f.s0; s1 = $f.s1; t = $f.t; t0 = $f.t0; t1 = $f.t1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = ptrType.nil; - s = ptrType.nil; - t = ptrType.nil; - r0 = new big.Int.ptr(false, big.nat.nil).Set(a); - r1 = new big.Int.ptr(false, big.nat.nil).Set(b); - s0 = big.NewInt(new $Int64(0, 1)); - s1 = big.NewInt(new $Int64(0, 0)); - t0 = big.NewInt(new $Int64(0, 0)); - t1 = big.NewInt(new $Int64(0, 1)); - if (r0.Cmp(r1) === 1) { - oldR0 = new big.Int.ptr(false, big.nat.nil).Set(r0); - r0 = r1; - r1 = oldR0; - oldS0 = new big.Int.ptr(false, big.nat.nil).Set(s0); - s0 = t0; - oldS1 = new big.Int.ptr(false, big.nat.nil).Set(s1); - s1 = t1; - t0 = oldS0; - t1 = oldS1; - } - /* while (true) { */ case 1: - /* if (!(r1.Sign() === 1)) { break; } */ if(!(r1.Sign() === 1)) { $s = 2; continue; } - r$1 = big.NewInt(new $Int64(0, 1)); - bb = new big.Int.ptr(false, big.nat.nil).Set(b); - _r = bb.DivMod(r0, r1, r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - q = _tuple[0]; - r$1 = _tuple[1]; - r0 = r1; - r1 = r$1; - oldS0$1 = new big.Int.ptr(false, big.nat.nil).Set(s0); - s0 = s1; - s1 = new big.Int.ptr(false, big.nat.nil).Sub(oldS0$1, new big.Int.ptr(false, big.nat.nil).Mul(q, s1)); - oldT0 = new big.Int.ptr(false, big.nat.nil).Set(t0); - t0 = t1; - t1 = new big.Int.ptr(false, big.nat.nil).Sub(oldT0, new big.Int.ptr(false, big.nat.nil).Mul(q, t1)); - /* } */ $s = 1; continue; case 2: - _tmp = r0; - _tmp$1 = s0; - _tmp$2 = t0; - r = _tmp; - s = _tmp$1; - t = _tmp$2; - $s = -1; return [r, s, t]; - /* */ } return; } if ($f === undefined) { $f = { $blk: extendedGCD }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.bb = bb; $f.oldR0 = oldR0; $f.oldS0 = oldS0; $f.oldS0$1 = oldS0$1; $f.oldS1 = oldS1; $f.oldT0 = oldT0; $f.q = q; $f.r = r; $f.r$1 = r$1; $f.r0 = r0; $f.r1 = r1; $f.s = s; $f.s0 = s0; $f.s1 = s1; $f.t = t; $f.t0 = t0; $f.t1 = t1; $f.$s = $s; $f.$r = $r; return $f; - }; - allInputValueGCD = function(a, b) { - var _r, a, b, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; b = $f.b; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = ptrType.nil; - if (a.Sign() === 0) { - r = new big.Int.ptr(false, big.nat.nil).Abs(b); - $s = -1; return r; - } - if (b.Sign() === 0) { - r = new big.Int.ptr(false, big.nat.nil).Abs(a); - $s = -1; return r; - } - _r = new big.Int.ptr(false, big.nat.nil).GCD(ptrType.nil, ptrType.nil, new big.Int.ptr(false, big.nat.nil).Abs(a), new big.Int.ptr(false, big.nat.nil).Abs(b)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - r = _r; - $s = -1; return r; - /* */ } return; } if ($f === undefined) { $f = { $blk: allInputValueGCD }; } $f._r = _r; $f.a = a; $f.b = b; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - SolveMod = function(a, b, m$1) { - var _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, a, b, bb, d, g, m$1, q, r, s, solvable, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; b = $f.b; bb = $f.bb; d = $f.d; g = $f.g; m$1 = $f.m$1; q = $f.q; r = $f.r; s = $f.s; solvable = $f.solvable; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - s = ptrType.nil; - t = ptrType.nil; - solvable = false; - _r = extendedGCD(a, m$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - g = _tuple[0]; - d = _tuple[1]; - r = big.NewInt(new $Int64(0, 1)); - bb = new big.Int.ptr(false, big.nat.nil).Set(b); - _r$1 = bb.DivMod(b, g, r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _tuple$1 = _r$1; - q = _tuple$1[0]; - r = _tuple$1[1]; - if (!((r.Cmp(big.NewInt(new $Int64(0, 0))) === 0))) { - _tmp = ptrType.nil; - _tmp$1 = ptrType.nil; - _tmp$2 = false; - s = _tmp; - t = _tmp$1; - solvable = _tmp$2; - $s = -1; return [s, t, solvable]; - } - q.Mul(q, d); - _r$2 = q.Mod(q, m$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - s = _r$2; - _r$3 = floorDivision(m$1, g); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - t = _r$3; - _tmp$3 = s; - _tmp$4 = t; - _tmp$5 = true; - s = _tmp$3; - t = _tmp$4; - solvable = _tmp$5; - $s = -1; return [s, t, solvable]; - /* */ } return; } if ($f === undefined) { $f = { $blk: SolveMod }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.b = b; $f.bb = bb; $f.d = d; $f.g = g; $f.m$1 = m$1; $f.q = q; $f.r = r; $f.s = s; $f.solvable = solvable; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.SolveMod = SolveMod; - primeLessThanN = function(num) { - var i, i$1, j, num, primes, sieve; - sieve = $makeSlice(sliceType$3, (num + 1 >> 0)); - i = 3; - while (true) { - if (!(i <= ((math.Floor(math.Sqrt((num))) >> 0)))) { break; } - if (((i < 0 || i >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + i]) === false) { - j = $imul(i, 2); - while (true) { - if (!(j <= num)) { break; } - ((j < 0 || j >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + j] = true); - j = j + (i) >> 0; - } - } - i = i + (2) >> 0; - } - primes = $makeSlice(sliceType, 0, num); - i$1 = 3; - while (true) { - if (!(i$1 <= num)) { break; } - if (((i$1 < 0 || i$1 >= sieve.$length) ? ($throwRuntimeError("index out of range"), undefined) : sieve.$array[sieve.$offset + i$1]) === false) { - primes = $append(primes, i$1); - } - i$1 = i$1 + (2) >> 0; - } - return primes; - }; - checkArrayEqual = function(a, b) { - var _i, _ref, a, b, i, v; - if (!((a.$length === b.$length))) { - return false; - } - _ref = a; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - i = _i; - v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - if (!((v === ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i])))) { - return false; - } - _i++; - } - return true; - }; - testIntLessThan = function(num) { - var _r, i, num, primes, refPrimes, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; num = $f.num; primes = $f.primes; refPrimes = $f.refPrimes; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - refPrimes = $makeSlice(sliceType, 0, num); - i = 3; - /* while (true) { */ case 1: - /* if (!(i < num)) { break; } */ if(!(i < num)) { $s = 2; continue; } - _r = big.NewInt((new $Int64(0, i))).ProbablyPrime(1); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - /* */ if (_r) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_r) { */ case 3: - refPrimes = $append(refPrimes, i); - /* } */ case 4: - i = i + (2) >> 0; - /* } */ $s = 1; continue; case 2: - primes = primeLessThanN(num); - $r = log.Printf("%v ", new sliceType$4([primes])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ if (checkArrayEqual(refPrimes, primes)) { $s = 7; continue; } - /* */ $s = 8; continue; - /* if (checkArrayEqual(refPrimes, primes)) { */ case 7: - $r = log.Printf("OK", new sliceType$4([])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = 9; continue; - /* } else { */ case 8: - $r = log.Printf("ERROR", new sliceType$4([])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* } */ case 9: - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: testIntLessThan }; } $f._r = _r; $f.i = i; $f.num = num; $f.primes = primes; $f.refPrimes = refPrimes; $f.$s = $s; $f.$r = $r; return $f; - }; - main = function() { - var $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = testIntLessThan(65536); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: main }; } $f.$s = $s; $f.$r = $r; return $f; - }; - approximateParameters = function(T) { - var L, T, intermediate, k, log_T, log_memory, w; - log_memory = math.Log(1e+07) / math.Log(2); - log_T = math.Log((T)) / math.Log(2); - L = 1; - if (log_T - log_memory > 0) { - L = ((math.Ceil(math.Pow(2, log_memory - 20)) >> 0)); - } - intermediate = (T) * math.Log(2) / (($imul(2, L))); - k = ((math.Max(math.Round(math.Log(intermediate) - math.Log(math.Log(intermediate)) + 0.25), 1) >> 0)); - w = ((math.Floor((T) / ((T) / (k) + (L) * math.Pow(2, ((k + 1 >> 0))))) - 2 >> 0)); - return [L, k, w]; - }; - iterateSquarings = function(x, powers_to_calculate, stop) { - var _i, _key, _r, _ref, _selection, currX, current_power, i, powers_calculated, powers_to_calculate, previous_power, stop, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _key = $f._key; _r = $f._r; _ref = $f._ref; _selection = $f._selection; currX = $f.currX; current_power = $f.current_power; i = $f.i; powers_calculated = $f.powers_calculated; powers_to_calculate = $f.powers_to_calculate; previous_power = $f.previous_power; stop = $f.stop; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - powers_calculated = {}; - previous_power = 0; - currX = CloneClassGroup(x); - $r = sort.Ints(powers_to_calculate); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _ref = powers_to_calculate; - _i = 0; - /* while (true) { */ case 2: - /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } - current_power = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - i = 0; - /* while (true) { */ case 4: - /* if (!(i < (current_power - previous_power >> 0))) { break; } */ if(!(i < (current_power - previous_power >> 0))) { $s = 5; continue; } - _r = currX.Pow(new $Int64(0, 2)); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - currX = _r; - if (currX === ptrType$1.nil) { - $s = -1; return false; - } - i = i + (1) >> 0; - /* } */ $s = 4; continue; case 5: - previous_power = current_power; - _key = current_power; (powers_calculated || $throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(_key)] = { k: _key, v: currX }; - _selection = $select([[stop], []]); - if (_selection[0] === 0) { - $s = -1; return false; - } else if (_selection[0] === 1) { - } - _i++; - /* } */ $s = 2; continue; case 3: - $s = -1; return powers_calculated; - /* */ } return; } if ($f === undefined) { $f = { $blk: iterateSquarings }; } $f._i = _i; $f._key = _key; $f._r = _r; $f._ref = _ref; $f._selection = _selection; $f.currX = currX; $f.current_power = current_power; $f.i = i; $f.powers_calculated = powers_calculated; $f.powers_to_calculate = powers_to_calculate; $f.previous_power = previous_power; $f.stop = stop; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - GenerateVDF = function(seed, iterations, int_size_bits) { - var _r, int_size_bits, iterations, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; int_size_bits = $f.int_size_bits; iterations = $f.iterations; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = GenerateVDFWithStopChan(seed, iterations, int_size_bits, $chanNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: GenerateVDF }; } $f._r = _r; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.GenerateVDF = GenerateVDF; - GenerateVDFWithStopChan = function(seed, iterations, int_size_bits, stop) { - var D, _r, _r$1, _r$2, _r$3, _r$4, _tuple, int_size_bits, iterations, proof, seed, stop, x, y, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; D = $f.D; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; int_size_bits = $f.int_size_bits; iterations = $f.iterations; proof = $f.proof; seed = $f.seed; stop = $f.stop; x = $f.x; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - $deferred.push([timeTrack, [$clone(time.Now(), time.Time)]]); - _r = CreateDiscriminant(seed, int_size_bits); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - D = _r; - _r$1 = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 2)), big.NewInt(new $Int64(0, 1)), D); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - x = _r$1; - _r$2 = calculateVDF(D, x, iterations, int_size_bits, stop); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - y = _tuple[0]; - proof = _tuple[1]; - /* */ if ((y === ptrType$1.nil) || (proof === ptrType$1.nil)) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if ((y === ptrType$1.nil) || (proof === ptrType$1.nil)) { */ case 4: - $s = -1; return [sliceType$2.nil, sliceType$2.nil]; - /* } else { */ case 5: - _r$3 = y.Serialize(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _r$4 = proof.Serialize(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return [_r$3, _r$4]; - /* } */ case 6: - $s = -1; return [sliceType$2.nil, sliceType$2.nil]; - /* */ } return; } } catch(err) { $err = err; $s = -1; return [sliceType$2.nil, sliceType$2.nil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: GenerateVDFWithStopChan }; } $f.D = D; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.proof = proof; $f.seed = seed; $f.stop = stop; $f.x = x; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - $pkg.GenerateVDFWithStopChan = GenerateVDFWithStopChan; - VerifyVDF = function(seed, proof_blob, iterations, int_size_bits) { - var D, _r, _r$1, _r$2, _r$3, _r$4, _tuple, _tuple$1, int_size, int_size_bits, iterations, proof, proof_blob, seed, x, y, $s, $deferred, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; D = $f.D; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; int_size = $f.int_size; int_size_bits = $f.int_size_bits; iterations = $f.iterations; proof = $f.proof; proof_blob = $f.proof_blob; seed = $f.seed; x = $f.x; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); - $deferred.push([timeTrack, [$clone(time.Now(), time.Time)]]); - int_size = ((int_size_bits + 16 >> 0)) >> 4 >> 0; - _r = CreateDiscriminant(seed, int_size_bits); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - D = _r; - _r$1 = NewClassGroupFromAbDiscriminant(big.NewInt(new $Int64(0, 2)), big.NewInt(new $Int64(0, 1)), D); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - x = _r$1; - _r$2 = NewClassGroupFromBytesDiscriminant($subslice(proof_blob, 0, (($imul(2, int_size)))), D); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - _tuple = _r$2; - y = _tuple[0]; - _r$3 = NewClassGroupFromBytesDiscriminant($subslice(proof_blob, ($imul(2, int_size))), D); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - _tuple$1 = _r$3; - proof = _tuple$1[0]; - _r$4 = verifyProof(x, y, proof, iterations); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $s = -1; return _r$4; - /* */ } return; } } catch(err) { $err = err; $s = -1; return false; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: VerifyVDF }; } $f.D = D; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.int_size = int_size; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.proof = proof; $f.proof_blob = proof_blob; $f.seed = seed; $f.x = x; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } - }; - $pkg.VerifyVDF = VerifyVDF; - hashPrime = function(x, y) { - var _r, _r$1, checkSum, j, jBuf, s, x, x$1, y, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; checkSum = $f.checkSum; j = $f.j; jBuf = $f.jBuf; s = $f.s; x = $f.x; x$1 = $f.x$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - j = new $Uint64(0, 0); - jBuf = $makeSlice(sliceType$2, 8); - z = new big.Int.ptr(false, big.nat.nil); - /* while (true) { */ case 1: - $clone(binary.BigEndian, binary.bigEndian).PutUint64(jBuf, j); - s = $appendSlice((new sliceType$2($stringToBytes("prime"))), jBuf); - s = $appendSlice(s, x); - s = $appendSlice(s, y); - _r = sha256.Sum256(s); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - checkSum = $clone(_r, arrayType); - z.SetBytes($subslice(new sliceType$2(checkSum), 0, 16)); - _r$1 = z.ProbablyPrime(1); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - /* */ if (_r$1) { $s = 4; continue; } - /* */ $s = 5; continue; - /* if (_r$1) { */ case 4: - $s = -1; return z; - /* } */ case 5: - j = (x$1 = new $Uint64(0, 1), new $Uint64(j.$high + x$1.$high, j.$low + x$1.$low)); - /* } */ $s = 1; continue; case 2: - $s = -1; return ptrType.nil; - /* */ } return; } if ($f === undefined) { $f = { $blk: hashPrime }; } $f._r = _r; $f._r$1 = _r$1; $f.checkSum = checkSum; $f.j = j; $f.jBuf = jBuf; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - getBlock = function(i, k, T, B) { - var B, T, _r, _r$1, i, k, p1, p2, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; i = $f.i; k = $f.k; p1 = $f.p1; p2 = $f.p2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - p1 = big.NewInt((new $Int64(0, math.Pow(2, (k))))); - _r = new big.Int.ptr(false, big.nat.nil).Exp(big.NewInt(new $Int64(0, 2)), big.NewInt((new $Int64(0, (T - ($imul(k, ((i + 1 >> 0)))) >> 0)))), B); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - p2 = _r; - _r$1 = floorDivision(new big.Int.ptr(false, big.nat.nil).Mul(p1, p2), B); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - $s = -1; return _r$1; - /* */ } return; } if ($f === undefined) { $f = { $blk: getBlock }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.k = k; $f.p1 = p1; $f.p2 = p2; $f.$s = $s; $f.$r = $r; return $f; - }; - evalOptimized = function(identity, h, B, T, k, l, C) { - var B, C, T, _entry, _q, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, b, b$1, b0, b0$1, b1, b1$1, b_limit, c, d, h, i, identity, j, k, k0, k1, l, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, ys, z, z$1, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; C = $f.C; T = $f.T; _entry = $f._entry; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; b = $f.b; b$1 = $f.b$1; b0 = $f.b0; b0$1 = $f.b0$1; b1 = $f.b1; b1$1 = $f.b1$1; b_limit = $f.b_limit; c = $f.c; d = $f.d; h = $f.h; i = $f.i; identity = $f.identity; j = $f.j; k = $f.k; k0 = $f.k0; k1 = $f.k1; l = $f.l; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; ys = $f.ys; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - k1 = (_q = k / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); - k0 = k - k1 >> 0; - x = CloneClassGroup(identity); - j = l - 1 >> 0; - /* while (true) { */ case 1: - /* if (!(j > -1)) { break; } */ if(!(j > -1)) { $s = 2; continue; } - b_limit = (new $Int64(0, math.Pow(2, (k)))); - _r = x.Pow(b_limit); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x = _r; - if (x === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - ys = $makeSlice(sliceType$5, $flatten64(b_limit)); - b = new $Int64(0, 0); - while (true) { - if (!((b.$high < b_limit.$high || (b.$high === b_limit.$high && b.$low < b_limit.$low)))) { break; } - (($flatten64(b) < 0 || $flatten64(b) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b)] = identity); - b = (x$1 = new $Int64(0, 1), new $Int64(b.$high + x$1.$high, b.$low + x$1.$low)); - } - i = 0; - /* while (true) { */ case 4: - /* if (!(i < ((math.Ceil((T) / (($imul(k, l)))) >> 0)))) { break; } */ if(!(i < ((math.Ceil((T) / (($imul(k, l)))) >> 0)))) { $s = 5; continue; } - /* */ if ((T - ($imul(k, (((($imul(i, l)) + j >> 0) + 1 >> 0)))) >> 0) < 0) { $s = 6; continue; } - /* */ $s = 7; continue; - /* if ((T - ($imul(k, (((($imul(i, l)) + j >> 0) + 1 >> 0)))) >> 0) < 0) { */ case 6: - i = i + (1) >> 0; - /* continue; */ $s = 4; continue; - /* } */ case 7: - _r$1 = getBlock(($imul(i, l)) + j >> 0, k, T, B); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - _r$2 = _r$1.Int64(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - b$1 = _r$2; - _r$3 = (($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)]).Multiply((_entry = C[$Int.keyFor($imul(($imul(i, k)), l))], _entry !== undefined ? _entry.v : ptrType$1.nil)); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - (($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)] = _r$3); - if ((($flatten64(b$1) < 0 || $flatten64(b$1) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(b$1)]) === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - i = i + (1) >> 0; - /* } */ $s = 4; continue; case 5: - b1 = 0; - /* while (true) { */ case 11: - /* if (!(b1 < ((math.Pow(2, (k1)) >> 0)))) { break; } */ if(!(b1 < ((math.Pow(2, (k1)) >> 0)))) { $s = 12; continue; } - z = identity; - b0 = 0; - /* while (true) { */ case 13: - /* if (!(b0 < ((math.Pow(2, ((k0))) >> 0)))) { break; } */ if(!(b0 < ((math.Pow(2, ((k0))) >> 0)))) { $s = 14; continue; } - _r$4 = z.Multiply((x$2 = (x$3 = $mul64((new $Int64(0, b1)), (new $Int64(0, math.Pow(2, (k0))))), x$4 = (new $Int64(0, b0)), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)), (($flatten64(x$2) < 0 || $flatten64(x$2) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(x$2)]))); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - z = _r$4; - if (z === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - b0 = b0 + (1) >> 0; - /* } */ $s = 13; continue; case 14: - _r$5 = z.Pow($mul64((new $Int64(0, b1)), (new $Int64(0, math.Pow(2, (k0)))))); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - c = _r$5; - if (c === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - _r$6 = x.Multiply(c); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - x = _r$6; - if (x === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - b1 = b1 + (1) >> 0; - /* } */ $s = 11; continue; case 12: - b0$1 = 0; - /* while (true) { */ case 18: - /* if (!(b0$1 < ((math.Pow(2, (k0)) >> 0)))) { break; } */ if(!(b0$1 < ((math.Pow(2, (k0)) >> 0)))) { $s = 19; continue; } - z$1 = identity; - b1$1 = 0; - /* while (true) { */ case 20: - /* if (!(b1$1 < ((math.Pow(2, (k1)) >> 0)))) { break; } */ if(!(b1$1 < ((math.Pow(2, (k1)) >> 0)))) { $s = 21; continue; } - _r$7 = z$1.Multiply((x$5 = (x$6 = $mul64((new $Int64(0, b1$1)), (new $Int64(0, math.Pow(2, (k0))))), x$7 = (new $Int64(0, b0$1)), new $Int64(x$6.$high + x$7.$high, x$6.$low + x$7.$low)), (($flatten64(x$5) < 0 || $flatten64(x$5) >= ys.$length) ? ($throwRuntimeError("index out of range"), undefined) : ys.$array[ys.$offset + $flatten64(x$5)]))); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - z$1 = _r$7; - if (z$1 === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - b1$1 = b1$1 + (1) >> 0; - /* } */ $s = 20; continue; case 21: - _r$8 = z$1.Pow((new $Int64(0, b0$1))); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } - d = _r$8; - if (d === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - _r$9 = x.Multiply(d); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } - x = _r$9; - if (x === ptrType$1.nil) { - $s = -1; return ptrType$1.nil; - } - b0$1 = b0$1 + (1) >> 0; - /* } */ $s = 18; continue; case 19: - j = j - (1) >> 0; - /* } */ $s = 1; continue; case 2: - $s = -1; return x; - /* */ } return; } if ($f === undefined) { $f = { $blk: evalOptimized }; } $f.B = B; $f.C = C; $f.T = T; $f._entry = _entry; $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.b = b; $f.b$1 = b$1; $f.b0 = b0; $f.b0$1 = b0$1; $f.b1 = b1; $f.b1$1 = b1$1; $f.b_limit = b_limit; $f.c = c; $f.d = d; $f.h = h; $f.i = i; $f.identity = identity; $f.j = j; $f.k = k; $f.k0 = k0; $f.k1 = k1; $f.l = l; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.ys = ys; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f; - }; - generateProof = function(identity, x, y, T, k, l, powers) { - var B, T, _r, _r$1, _r$2, _r$3, identity, k, l, powers, proof, x, x_s, y, y_s, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; identity = $f.identity; k = $f.k; l = $f.l; powers = $f.powers; proof = $f.proof; x = $f.x; x_s = $f.x_s; y = $f.y; y_s = $f.y_s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = x.Serialize(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x_s = _r; - _r$1 = y.Serialize(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - y_s = _r$1; - _r$2 = hashPrime(x_s, y_s); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - B = _r$2; - _r$3 = evalOptimized(identity, x, B, T, k, l, powers); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - proof = _r$3; - $s = -1; return proof; - /* */ } return; } if ($f === undefined) { $f = { $blk: generateProof }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.identity = identity; $f.k = k; $f.l = l; $f.powers = powers; $f.proof = proof; $f.x = x; $f.x_s = x_s; $f.y = y; $f.y_s = y_s; $f.$s = $s; $f.$r = $r; return $f; - }; - calculateVDF = function(discriminant, x, iterations, int_size_bits, stop) { - var L, _entry, _r, _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, discriminant, i, identity, int_size_bits, iterations, k, loopCount, powers, powers_to_calculate, proof, stop, x, x$1, y, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; L = $f.L; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; discriminant = $f.discriminant; i = $f.i; identity = $f.identity; int_size_bits = $f.int_size_bits; iterations = $f.iterations; k = $f.k; loopCount = $f.loopCount; powers = $f.powers; powers_to_calculate = $f.powers_to_calculate; proof = $f.proof; stop = $f.stop; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - y = ptrType$1.nil; - proof = ptrType$1.nil; - _tuple = approximateParameters(iterations); - L = _tuple[0]; - k = _tuple[1]; - loopCount = ((math.Ceil((iterations) / (($imul(k, L)))) >> 0)); - powers_to_calculate = $makeSlice(sliceType, (loopCount + 2 >> 0)); - i = 0; - while (true) { - if (!(i < (loopCount + 1 >> 0))) { break; } - ((i < 0 || i >= powers_to_calculate.$length) ? ($throwRuntimeError("index out of range"), undefined) : powers_to_calculate.$array[powers_to_calculate.$offset + i] = ($imul(($imul(i, k)), L))); - i = i + (1) >> 0; - } - (x$1 = loopCount + 1 >> 0, ((x$1 < 0 || x$1 >= powers_to_calculate.$length) ? ($throwRuntimeError("index out of range"), undefined) : powers_to_calculate.$array[powers_to_calculate.$offset + x$1] = iterations)); - _r = iterateSquarings(x, powers_to_calculate, stop); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - powers = _r; - if (powers === false) { - _tmp = ptrType$1.nil; - _tmp$1 = ptrType$1.nil; - y = _tmp; - proof = _tmp$1; - $s = -1; return [y, proof]; - } - y = (_entry = powers[$Int.keyFor(iterations)], _entry !== undefined ? _entry.v : ptrType$1.nil); - _r$1 = IdentityForDiscriminant(discriminant); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - identity = _r$1; - _r$2 = generateProof(identity, x, y, iterations, k, L, powers); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - proof = _r$2; - _tmp$2 = y; - _tmp$3 = proof; - y = _tmp$2; - proof = _tmp$3; - $s = -1; return [y, proof]; - /* */ } return; } if ($f === undefined) { $f = { $blk: calculateVDF }; } $f.L = L; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.discriminant = discriminant; $f.i = i; $f.identity = identity; $f.int_size_bits = int_size_bits; $f.iterations = iterations; $f.k = k; $f.loopCount = loopCount; $f.powers = powers; $f.powers_to_calculate = powers_to_calculate; $f.proof = proof; $f.stop = stop; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; - }; - verifyProof = function(x, y, proof, T) { - var B, T, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _v, piB, proof, r, x, xR, x_s, y, y_s, z, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; B = $f.B; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _v = $f._v; piB = $f.piB; proof = $f.proof; r = $f.r; x = $f.x; xR = $f.xR; x_s = $f.x_s; y = $f.y; y_s = $f.y_s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = x.Serialize(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - x_s = _r; - _r$1 = y.Serialize(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - y_s = _r$1; - _r$2 = hashPrime(x_s, y_s); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - B = _r$2; - _r$3 = new big.Int.ptr(false, big.nat.nil).Exp(big.NewInt(new $Int64(0, 2)), big.NewInt((new $Int64(0, T))), B); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - r = _r$3; - _r$4 = proof.BigPow(B); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - piB = _r$4; - if (piB === ptrType$1.nil) { - $s = -1; return false; - } - _r$5 = x.BigPow(r); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - xR = _r$5; - if (xR === ptrType$1.nil) { - $s = -1; return false; - } - _r$6 = piB.Multiply(xR); /* */ $s = 7; case 7: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - z = _r$6; - if (!(!(z === ptrType$1.nil))) { _v = false; $s = 11; continue s; } - _r$7 = z.Equal(y); /* */ $s = 12; case 12: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } - _v = _r$7; case 11: - /* */ if (_v) { $s = 8; continue; } - /* */ $s = 9; continue; - /* if (_v) { */ case 8: - $s = -1; return true; - /* } else { */ case 9: - $s = -1; return false; - /* } */ case 10: - $s = -1; return false; - /* */ } return; } if ($f === undefined) { $f = { $blk: verifyProof }; } $f.B = B; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._v = _v; $f.piB = piB; $f.proof = proof; $f.r = r; $f.x = x; $f.xR = xR; $f.x_s = x_s; $f.y = y; $f.y_s = y_s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f; - }; - timeTrack = function(start) { - var _r, _r$1, _r$2, _tuple, elapsed, funcObj, name, pc, runtimeFunc, start, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; elapsed = $f.elapsed; funcObj = $f.funcObj; name = $f.name; pc = $f.pc; runtimeFunc = $f.runtimeFunc; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - elapsed = time.Since($clone(start, time.Time)); - _tuple = runtime.Caller(1); - pc = _tuple[0]; - funcObj = runtime.FuncForPC(pc); - _r = regexp.MustCompile("^.*\\.(.*)$"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - runtimeFunc = _r; - _r$1 = runtimeFunc.ReplaceAllString(funcObj.Name(), "$1"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - name = _r$1; - _r$2 = fmt.Sprintf("%s took %s", new sliceType$4([new $String(name), elapsed])); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - $r = log.Println(new sliceType$4([new $String(_r$2)])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: timeTrack }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.elapsed = elapsed; $f.funcObj = funcObj; $f.name = name; $f.pc = pc; $f.runtimeFunc = runtimeFunc; $f.start = start; $f.$s = $s; $f.$r = $r; return $f; - }; - New = function(difficulty, input) { - var difficulty, input; - return new VDF.ptr(difficulty, $clone(input, arrayType), arrayType$1.zero(), new $Chan(arrayType$1, 0), false); - }; - $pkg.New = New; - VDF.ptr.prototype.GetOutputChannel = function() { - var vdf; - vdf = this; - return vdf.outputChan; - }; - VDF.prototype.GetOutputChannel = function() { return this.$val.GetOutputChannel(); }; - VDF.ptr.prototype.Execute = function() { - var _r, _tuple, proofBuf, vdf, yBuf, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; proofBuf = $f.proofBuf; vdf = $f.vdf; yBuf = $f.yBuf; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - vdf = [vdf]; - vdf[0] = this; - vdf[0].finished = false; - _r = GenerateVDF(new sliceType$2(vdf[0].input), vdf[0].difficulty, 2048); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - yBuf = _tuple[0]; - proofBuf = _tuple[1]; - $copySlice(new sliceType$2(vdf[0].output), yBuf); - $copySlice($subslice(new sliceType$2(vdf[0].output), 258), proofBuf); - $go((function(vdf) { return function $b() { - var $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = $send(vdf[0].outputChan, $clone($clone(vdf[0].output, arrayType$1), arrayType$1)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; - }; })(vdf), []); - vdf[0].finished = true; - $s = -1; return; - /* */ } return; } if ($f === undefined) { $f = { $blk: VDF.ptr.prototype.Execute }; } $f._r = _r; $f._tuple = _tuple; $f.proofBuf = proofBuf; $f.vdf = vdf; $f.yBuf = yBuf; $f.$s = $s; $f.$r = $r; return $f; - }; - VDF.prototype.Execute = function() { return this.$val.Execute(); }; - VDF.ptr.prototype.Verify = function(proof) { - var _r, proof, vdf, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; proof = $f.proof; vdf = $f.vdf; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - vdf = this; - _r = VerifyVDF(new sliceType$2(vdf.input), new sliceType$2(proof), vdf.difficulty, 2048); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: VDF.ptr.prototype.Verify }; } $f._r = _r; $f.proof = proof; $f.vdf = vdf; $f.$s = $s; $f.$r = $r; return $f; - }; - VDF.prototype.Verify = function(proof) { return this.$val.Verify(proof); }; - VDF.ptr.prototype.IsFinished = function() { - var vdf; - vdf = this; - return vdf.finished; - }; - VDF.prototype.IsFinished = function() { return this.$val.IsFinished(); }; - VDF.ptr.prototype.GetOutput = function() { - var vdf; - vdf = this; - return vdf.output; - }; - VDF.prototype.GetOutput = function() { return this.$val.GetOutput(); }; - ptrType$1.methods = [{prop: "Normalized", name: "Normalized", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Reduced", name: "Reduced", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "identity", name: "identity", pkg: "github.com/bonedaddy/vcaptcha/vdf", typ: $funcType([], [ptrType$1], false)}, {prop: "Discriminant", name: "Discriminant", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([ptrType$1], [ptrType$1], false)}, {prop: "Pow", name: "Pow", pkg: "", typ: $funcType([$Int64], [ptrType$1], false)}, {prop: "BigPow", name: "BigPow", pkg: "", typ: $funcType([ptrType], [ptrType$1], false)}, {prop: "Square", name: "Square", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "SquareUsingMultiply", name: "SquareUsingMultiply", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Serialize", name: "Serialize", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([ptrType$1], [$Bool], false)}]; - ptrType$2.methods = [{prop: "GetOutputChannel", name: "GetOutputChannel", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Execute", name: "Execute", pkg: "", typ: $funcType([], [], false)}, {prop: "Verify", name: "Verify", pkg: "", typ: $funcType([arrayType$1], [$Bool], false)}, {prop: "IsFinished", name: "IsFinished", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "GetOutput", name: "GetOutput", pkg: "", typ: $funcType([], [arrayType$1], false)}]; - ClassGroup.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "a", name: "a", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "b", name: "b", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "c", name: "c", embedded: false, exported: false, typ: ptrType, tag: ""}, {prop: "d", name: "d", embedded: false, exported: false, typ: ptrType, tag: ""}]); - Pair.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "p", name: "p", embedded: false, exported: false, typ: $Int64, tag: ""}, {prop: "q", name: "q", embedded: false, exported: false, typ: $Int64, tag: ""}]); - VDF.init("github.com/bonedaddy/vcaptcha/vdf", [{prop: "difficulty", name: "difficulty", embedded: false, exported: false, typ: $Int, tag: ""}, {prop: "input", name: "input", embedded: false, exported: false, typ: arrayType, tag: ""}, {prop: "output", name: "output", embedded: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "outputChan", name: "outputChan", embedded: false, exported: false, typ: chanType, tag: ""}, {prop: "finished", name: "finished", embedded: false, exported: false, typ: $Bool, tag: ""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sha256.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = binary.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = log.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = big.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = regexp.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = runtime.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sort.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - residues = new sliceType([23, 31, 47, 71, 79, 103, 127, 151, 167, 191, 199, 223, 239, 263, 271, 311, 359, 367, 383, 391, 431, 439, 463, 479, 487, 503, 527, 551, 599, 607, 631, 647, 703, 719, 727, 743, 751, 799, 823, 839, 863, 887, 911, 919, 943, 967, 983, 991, 1007, 1031, 1039, 1063, 1087, 1103, 1151, 1159, 1207, 1223, 1231, 1247, 1271, 1279, 1303, 1319, 1327, 1343, 1367, 1399, 1423, 1439, 1447, 1471, 1487, 1511, 1543, 1559, 1567, 1583, 1591, 1607, 1663, 1679, 1711, 1751, 1759, 1783, 1823, 1831, 1847, 1871, 1879, 1919, 1927, 1943, 1951, 1999, 2039, 2047, 2063, 2071, 2087, 2111, 2143, 2159, 2183, 2207, 2231, 2239, 2263, 2279, 2287, 2311, 2351, 2383, 2399, 2407, 2423, 2447, 2479, 2503, 2543, 2551, 2567, 2591, 2599, 2623, 2647, 2663, 2671, 2687, 2711, 2719, 2759, 2767, 2791, 2831, 2839, 2879, 2887, 2903, 2911, 2927, 2983, 2999, 3007, 3023, 3071, 3079, 3103, 3119, 3127, 3151, 3167, 3191, 3239, 3247, 3271, 3287, 3319, 3343, 3359, 3383, 3391, 3407, 3431, 3439, 3463, 3503, 3511, 3527, 3551, 3559, 3583, 3599, 3607, 3623, 3631, 3671, 3719, 3727, 3743, 3767, 3791, 3799, 3823, 3847, 3863, 3911, 3919, 3943, 3959, 3967, 4007, 4031, 4063, 4079, 4087, 4111, 4127, 4159, 4183, 4223, 4231, 4247, 4271, 4327, 4343, 4351, 4391, 4399, 4423, 4439, 4447, 4463, 4471, 4519, 4559, 4567, 4583, 4591, 4607, 4639, 4663, 4679, 4687, 4703, 4727, 4751, 4759, 4783, 4799, 4831, 4847, 4871, 4903, 4919, 4943, 4951, 4967, 4999, 5023, 5039, 5063, 5087, 5111, 5119, 5143, 5167, 5183, 5191, 5207, 5231, 5263, 5279, 5287, 5303, 5311, 5351, 5359, 5399, 5407, 5431, 5471, 5479, 5503, 5519, 5527, 5543, 5567, 5591, 5623, 5639, 5647, 5671, 5711, 5743, 5767, 5783, 5791, 5807, 5839, 5879, 5903, 5911, 5927, 5959, 5983, 6007, 6023, 6031, 6047, 6079, 6103, 6119, 6143, 6151, 6191, 6199, 6239, 6247, 6263, 6271, 6287, 6311, 6319, 6343, 6359, 6367, 6407, 6431, 6439, 6463, 6511, 6527, 6551, 6583, 6599, 6607, 6623, 6631, 6647, 6679, 6703, 6719, 6751, 6767, 6791, 6823, 6847, 6863, 6871, 6887, 6911, 6943, 6959, 6967, 6983, 6991, 7031, 7039, 7079, 7087, 7103, 7127, 7151, 7159, 7199, 7207, 7223, 7247, 7279, 7303, 7327, 7351, 7367, 7391, 7439, 7463, 7471, 7487, 7519, 7543, 7559, 7583, 7591, 7607, 7639, 7663, 7687, 7703, 7727, 7751, 7759, 7783, 7807, 7823, 7831, 7871, 7879, 7919, 7927, 7951, 7967, 7991, 7999, 8023, 8039, 8087, 8111, 8119, 8143, 8159, 8167, 8191, 8207, 8231, 8263, 8279, 8287, 8303, 8311, 8383, 8399, 8423, 8431, 8447, 8471, 8479, 8527, 8543, 8551, 8599, 8623, 8639, 8647, 8663, 8711, 8719, 8759, 8783, 8791, 8807, 8831, 8839, 8863, 8887, 8903, 8927, 8951, 8959, 8999, 9007, 9047, 9071, 9103, 9127, 9143, 9151, 9167, 9199, 9223, 9239, 9263, 9271, 9287, 9311, 9319, 9343, 9367, 9391, 9407, 9431, 9439, 9463, 9479, 9487, 9511, 9551, 9599, 9623, 9631, 9671, 9679, 9703, 9719, 9727, 9743, 9767, 9791, 9799, 9839, 9847, 9871, 9887, 9943, 9959, 9967, 9983, 9991, 10007, 10039, 10063, 10079, 10103, 10111, 10151, 10159, 10183, 10207, 10223, 10247, 10271, 10279, 10303, 10319, 10327, 10343, 10391, 10399, 10447, 10463, 10471, 10487, 10511, 10519, 10559, 10567, 10583, 10607, 10631, 10639, 10663, 10679, 10687, 10711, 10727, 10783, 10799, 10807, 10823, 10831, 10847, 10903, 10919, 10943, 10951, 10991, 10999, 11023, 11047, 11071, 11087, 11111, 11119, 11159, 11183, 11191, 11239, 11279, 11287, 11303, 11311, 11327, 11351, 11359, 11383, 11399, 11423, 11447, 11471, 11503, 11519, 11527, 11551, 11567, 11591, 11623, 11639, 11647, 11663, 11719, 11743, 11783, 11807, 11831, 11839, 11863, 11887, 11903, 11911, 11927, 11951, 11959, 11983, 12007, 12031, 12071, 12079, 12119, 12127, 12143, 12151, 12167, 12191, 12223, 12239, 12247, 12263, 12319, 12343, 12359, 12367, 12391, 12407, 12431, 12479, 12487, 12503, 12511, 12527, 12559, 12583, 12599, 12631, 12647, 12671, 12679, 12703, 12743, 12751, 12767, 12791, 12799, 12823, 12839, 12847, 12863, 12871, 12911, 12919, 12959, 12967, 12983, 13007, 13031, 13063, 13087, 13103, 13127, 13151, 13159, 13183, 13199, 13207, 13231, 13271, 13303, 13319, 13327, 13367, 13399, 13423, 13439, 13463, 13471, 13487, 13511, 13543, 13567, 13583, 13591, 13631, 13639, 13679, 13687, 13703, 13711, 13751, 13759, 13799, 13807, 13823, 13831, 13847, 13879, 13903, 13919, 13927, 13943, 13967, 13991, 13999, 14023, 14039, 14071, 14087, 14111, 14143, 14159, 14167, 14191, 14207, 14239, 14263, 14279, 14303, 14327, 14351, 14359, 14383, 14407, 14423, 14431, 14447, 14471, 14479, 14503, 14519, 14527, 14543, 14551, 14591, 14639, 14647, 14671, 14687, 14711, 14719, 14743, 14759, 14767, 14783, 14831, 14863, 14879, 14887, 14951, 14983, 14999, 15007, 15023, 15031, 15047, 15079, 15143, 15151, 15167, 15199, 15247, 15263, 15271, 15287, 15311, 15319, 15343, 15359, 15383, 15391, 15439, 15479, 15487, 15503, 15511, 15527, 15551, 15559, 15583, 15599, 15607, 15623, 15647, 15671, 15679, 15703, 15727, 15751, 15767, 15791, 15823, 15839, 15863, 15871, 15887, 15919, 15943, 15959, 15991, 16007, 16031, 16039, 16063, 16087, 16103, 16111, 16127, 16151, 16183, 16199, 16207, 16223, 16231, 16271, 16279, 16319, 16327, 16343, 16351, 16391, 16399, 16439, 16447, 16463, 16487, 16519, 16543, 16559, 16567, 16591, 16607, 16631, 16663, 16703, 16711, 16727, 16759, 16799, 16823, 16831, 16847, 16871, 16879, 16903, 16927, 16943, 16967, 16999, 17023, 17047, 17063, 17071, 17111, 17119, 17159, 17167, 17183, 17191, 17207, 17231, 17239, 17263, 17279, 17287, 17327, 17351, 17359, 17383, 17399, 17431, 17447, 17471, 17503, 17519, 17527, 17543, 17551, 17599, 17623, 17639, 17663, 17671, 17687, 17711, 17767, 17783, 17791, 17807, 17839, 17863, 17879, 17887, 17903, 17911, 17951, 17959, 17999, 18023, 18047, 18071, 18079, 18103, 18119, 18127, 18143, 18167, 18191, 18199, 18223, 18247, 18287, 18311, 18367, 18383, 18391, 18407, 18439, 18463, 18479, 18503, 18511, 18527, 18559, 18583, 18607, 18631, 18647, 18671, 18679, 18703, 18719, 18727, 18743, 18751, 18791, 18839, 18847, 18871, 18911, 18919, 18943, 18959, 18983, 19007, 19031, 19039, 19079, 19087, 19111, 19127, 19183, 19199, 19207, 19223, 19231, 19247, 19303, 19319, 19343, 19351, 19367, 19391, 19399, 19423, 19447, 19463, 19471, 19511, 19519, 19543, 19559, 19567, 19583, 19631, 19639, 19687, 19703, 19711, 19727, 19751, 19759, 19783, 19807, 19823, 19847, 19871, 19879, 19919, 19927, 19951, 19967, 19991, 20023, 20039, 20047, 20063, 20071, 20087, 20143, 20159, 20183, 20191, 20231, 20239, 20263, 20287, 20303, 20311, 20327, 20351, 20359, 20399, 20407, 20431, 20479, 20519, 20543, 20551, 20567, 20591, 20599, 20623, 20639, 20663, 20687, 20711, 20719, 20743, 20759, 20767, 20791, 20807, 20831, 20863, 20879, 20887, 20903, 20927, 20959, 20983, 21023, 21031, 21071, 21079, 21103, 21127, 21143, 21167, 21191, 21199, 21223, 21239, 21247, 21271, 21311, 21319, 21367, 21383, 21391, 21407, 21431, 21479, 21487, 21503, 21551, 21559, 21583, 21599, 21607, 21631, 21647, 21719, 21727, 21743, 21751, 21767, 21799, 21823, 21839, 21863, 21871, 21887, 21911, 21919, 21943, 21991, 22007, 22031, 22039, 22063, 22079, 22103, 22111, 22151, 22159, 22199, 22207, 22223, 22247, 22271, 22279, 22303, 22327, 22343, 22367, 22391, 22423, 22439, 22447, 22471, 22487, 22511, 22543, 22559, 22567, 22591, 22639, 22663, 22679, 22703, 22727, 22751, 22783, 22807, 22823, 22831, 22871, 22879, 22903, 22927, 22943, 22951, 22991, 22999, 23039, 23047, 23063, 23071, 23087, 23119, 23143, 23159, 23167, 23183, 23207, 23239, 23263, 23279, 23311, 23327, 23351, 23383, 23399, 23407, 23423, 23431, 23447, 23479, 23503, 23519, 23567, 23591, 23599, 23623, 23663, 23671, 23687, 23711, 23719, 23743, 23759, 23767, 23783, 23791, 23831, 23839, 23879, 23887, 23911, 23927, 23951, 23983, 23999, 24007, 24023, 24047, 24071, 24103, 24119, 24127, 24151, 24191, 24223, 24239, 24247, 24263, 24287, 24319, 24359, 24383, 24391, 24407, 24439, 24463, 24487, 24503, 24511, 24527, 24551, 24559, 24599, 24623, 24631, 24671, 24679, 24719, 24727, 24743, 24751, 24767, 24799, 24823, 24839, 24847, 24863, 24887, 24911, 24919, 24943, 24967, 24991, 25007, 25031, 25063, 25079, 25087, 25111, 25127, 25159, 25183, 25199, 25231, 25247, 25271, 25279, 25303, 25327, 25343, 25351, 25367, 25391, 25423, 25439, 25447, 25463, 25471, 25511, 25559, 25567, 25583, 25591, 25607, 25631, 25639, 25679, 25687, 25703, 25759, 25783, 25799, 25807, 25847, 25871, 25903, 25919, 25943, 25951, 25967, 25999, 26023, 26063, 26071, 26087, 26111, 26119, 26167, 26183, 26207, 26231, 26239, 26263, 26287, 26303, 26311, 26359, 26399, 26407, 26423, 26431, 26447, 26471, 26479, 26503, 26519, 26527, 26567, 26591, 26599, 26623, 26639, 26647, 26671, 26687, 26711, 26743, 26759, 26783, 26791, 26839, 26863, 26879, 26903, 26911, 26927, 26951, 26959, 27007, 27023, 27031, 27047, 27103, 27119, 27127, 27143, 27151, 27191, 27199, 27239, 27263, 27271, 27311, 27319, 27343, 27359, 27367, 27383, 27407, 27431, 27439, 27463, 27479, 27487, 27527, 27551, 27583, 27607, 27623, 27631, 27647, 27679, 27719, 27743, 27751, 27767, 27791, 27799, 27823, 27847, 27871, 27887, 27919, 27943, 27959, 27967, 27983, 27991, 28031, 28079, 28087, 28103, 28111, 28151, 28159, 28183, 28199, 28207, 28247, 28271, 28279, 28319, 28351, 28367, 28423, 28439, 28447, 28463, 28471, 28487, 28519, 28543, 28559, 28583, 28591, 28607, 28631, 28663, 28687, 28703, 28711, 28727, 28751, 28759, 28783, 28799, 28807, 28823, 28871, 28879, 28927, 28943, 28967, 28991, 28999, 29023, 29039, 29047, 29063, 29087, 29111, 29119, 29143, 29167, 29191, 29207, 29231, 29279, 29287, 29303, 29311, 29327, 29383, 29399, 29423, 29431, 29479, 29503, 29527, 29543, 29551, 29567, 29591, 29599, 29639, 29647, 29663, 29671, 29719, 29759, 29767, 29791, 29807, 29831, 29839, 29863, 29879, 29903, 29927, 29951, 29959, 29983, 29999, 30007, 30031, 30047, 30071, 30103, 30119, 30127, 30143, 30167, 30223, 30263, 30271, 30287, 30311, 30319, 30343, 30367, 30383, 30391, 30431, 30439, 30463, 30479, 30487, 30551, 30559, 30599, 30607, 30623, 30631, 30647, 30671, 30703, 30727, 30743, 30791, 30799, 30839, 30847, 30871, 30887, 30911, 30959, 30967, 30983, 30991, 31007, 31039, 31063, 31079, 31103, 31111, 31127, 31151, 31159, 31183, 31223, 31231, 31247, 31271, 31279, 31303, 31319, 31327, 31351, 31391, 31399, 31439, 31463, 31487, 31511, 31519, 31543, 31567, 31583, 31607, 31631, 31639, 31663, 31679, 31687, 31711, 31727, 31751, 31783, 31799, 31807, 31831, 31847, 31879, 31903, 31919, 31943, 31951, 31991, 32023, 32047, 32063, 32111, 32119, 32143, 32159, 32167, 32183, 32191, 32231, 32239, 32287, 32303, 32311, 32327, 32359, 32399, 32407, 32423, 32447, 32471, 32479, 32503, 32519, 32551, 32567, 32623, 32639, 32647, 32663, 32671, 32687, 32719, 32743, 32759, 32783, 32807, 32831, 32839, 32863, 32887, 32911, 32927, 32951, 32959, 32983, 32999, 33023, 33031, 33071, 33079, 33119, 33127, 33151, 33167, 33191, 33199, 33223, 33239, 33247, 33263, 33287, 33311, 33343, 33359, 33367, 33391, 33431, 33463, 33479, 33487, 33503, 33511, 33559, 33599, 33623, 33647, 33679, 33703, 33727, 33743, 33751, 33767, 33791, 33799, 33823, 33863, 33871, 33911, 33919, 33959, 33967, 33983, 33991, 34007, 34031, 34039, 34063, 34079, 34087, 34103, 34127, 34159, 34183, 34207, 34231, 34247, 34271, 34303, 34319, 34327, 34343, 34351, 34367, 34399, 34423, 34439, 34471, 34487, 34511, 34519, 34543, 34583, 34591, 34607, 34631, 34663, 34679, 34687, 34703, 34711, 34751, 34759, 34799, 34807, 34823, 34831, 34847, 34871, 34919, 34927, 34943, 34967, 34999, 35023, 35039, 35047, 35071, 35111, 35143, 35159, 35183, 35207, 35239, 35263, 35279, 35303, 35311, 35327, 35351, 35359, 35383, 35407, 35423, 35447, 35471, 35479, 35527, 35543, 35551, 35591, 35599, 35639, 35647, 35663, 35671, 35687, 35719, 35743, 35759, 35767, 35807, 35831, 35839, 35863, 35879, 35887, 35911, 35927, 35951, 35983, 35999, 36007, 36031, 36079, 36103, 36119, 36143, 36151, 36167, 36191, 36199, 36247, 36263, 36271, 36287, 36319, 36343, 36359, 36367, 36383, 36391, 36431, 36479, 36503, 36511, 36527, 36551, 36559, 36583, 36599, 36607, 36623, 36671, 36679, 36703, 36719, 36727, 36767, 36791, 36823, 36847, 36863, 36871, 36887, 36919, 36943, 36983, 36991, 37007, 37031, 37039, 37087, 37111, 37127, 37151, 37159, 37183, 37199, 37207, 37223, 37231, 37319, 37327, 37343, 37351, 37391, 37399, 37423, 37439, 37447, 37463, 37487, 37511, 37519, 37559, 37567, 37591, 37607, 37663, 37679, 37703, 37711, 37727, 37759, 37783, 37799, 37823, 37831, 37847, 37871, 37879, 37903, 37927, 37943, 37951, 37967, 37991, 38023, 38039, 38047, 38063, 38111, 38119, 38167, 38183, 38191, 38231, 38239, 38263, 38279, 38287, 38303, 38327, 38351, 38359, 38383, 38399, 38407, 38431, 38447, 38471, 38503, 38527, 38543, 38551, 38567, 38639, 38663, 38671, 38711, 38719, 38743, 38767, 38783, 38791, 38807, 38839, 38879, 38887, 38903, 38911, 38959, 38999, 39007, 39023, 39031, 39047, 39071, 39079, 39103, 39119, 39167, 39191, 39199, 39223, 39239, 39271, 39287, 39311, 39343, 39359, 39367, 39383, 39407, 39439, 39463, 39503, 39511, 39527, 39551, 39583, 39607, 39623, 39631, 39647, 39671, 39679, 39703, 39719, 39727, 39751, 39791, 39799, 39839, 39847, 39863, 39887, 39911, 39943, 39959, 39967, 39983, 40031, 40039, 40063, 40087, 40111, 40127, 40151, 40199, 40207, 40223, 40231, 40247, 40279, 40303, 40319, 40343, 40351, 40367, 40399, 40423, 40463, 40471, 40487, 40511, 40519, 40543, 40559, 40567, 40583, 40591, 40631, 40639, 40679, 40687, 40727, 40751, 40759, 40783, 40823, 40847, 40871, 40879, 40903, 40919, 40927, 40951, 40967, 40991, 41023, 41039, 41047, 41071, 41087, 41143, 41159, 41183, 41191, 41207, 41231, 41263, 41287, 41303, 41311, 41351, 41359, 41383, 41399, 41407, 41423, 41471, 41479, 41519, 41527, 41543, 41551, 41567, 41599, 41623, 41647, 41663, 41687, 41711, 41719, 41759, 41791, 41807, 41831, 41863, 41879, 41887, 41903, 41911, 41927, 41959, 41983, 41999, 42023, 42047, 42071, 42079, 42103, 42127, 42143, 42151, 42167, 42191, 42199, 42223, 42239, 42247, 42271, 42311, 42319, 42359, 42391, 42407, 42431, 42439, 42463, 42479, 42487, 42503, 42527, 42551, 42583, 42599, 42607, 42631, 42671, 42703, 42719, 42727, 42743, 42751, 42767, 42799, 42839, 42863, 42871, 42919, 42943, 42967, 42983, 43007, 43031, 43039, 43063, 43079, 43103, 43111, 43151, 43159, 43207, 43223, 43231, 43247, 43271, 43279, 43319, 43327, 43343, 43367, 43391, 43399, 43423, 43447, 43471, 43487, 43543, 43559, 43567, 43583, 43591, 43607, 43639, 43663, 43679, 43711, 43727, 43751, 43759, 43783, 43807, 43831, 43847, 43871, 43903, 43919, 43943, 43951, 43991, 43999, 44039, 44047, 44063, 44071, 44087, 44111, 44119, 44159, 44167, 44183, 44207, 44263, 44279, 44287, 44311, 44327, 44351, 44383, 44399, 44423, 44431, 44479, 44503, 44519, 44543, 44567, 44591, 44599, 44623, 44647, 44663, 44687, 44711, 44719, 44743, 44767, 44783, 44791, 44831, 44839, 44879, 44887, 44903, 44911, 44927, 44951, 44959, 44983, 44999, 45007, 45047, 45079, 45103, 45119, 45127, 45151, 45167, 45191, 45223, 45239, 45247, 45263, 45271, 45319, 45343, 45359, 45391, 45407, 45431, 45439, 45503, 45511, 45527, 45559, 45583, 45599, 45607, 45623, 45631, 45671, 45679, 45719, 45743, 45751, 45767, 45791, 45823, 45839, 45847, 45863, 45887, 45911, 45919, 45943, 45959, 45967, 46031, 46063, 46087, 46103, 46127, 46159, 46183, 46199, 46223, 46231, 46247, 46271, 46279, 46303, 46327, 46351, 46367, 46391, 46399, 46439, 46447, 46463, 46471, 46511, 46559, 46567, 46583, 46591, 46639, 46663, 46679, 46687, 46703, 46727, 46751, 46759, 46799, 46807, 46831, 46847, 46903, 46919, 46927, 46951, 46967, 46999, 47023, 47039, 47063, 47071, 47087, 47111, 47119, 47143, 47167, 47183, 47191, 47207, 47231, 47239, 47263, 47279, 47287, 47303, 47351, 47407, 47423, 47431, 47447, 47471, 47479, 47503, 47519, 47527, 47543, 47591, 47599, 47623, 47639, 47647, 47687, 47711, 47743, 47759, 47767, 47783, 47791, 47807, 47863, 47903, 47911, 47951, 47959, 48007, 48023, 48031, 48047, 48071, 48079, 48119, 48127, 48143, 48151, 48199, 48239, 48247, 48263, 48271, 48287, 48311, 48319, 48343, 48359, 48383, 48407, 48431, 48439, 48463, 48479, 48487, 48511, 48527, 48551, 48583, 48599, 48623, 48647, 48679, 48703, 48743, 48751, 48767, 48791, 48799, 48823, 48847, 48863, 48871, 48887, 48911, 48943, 48959, 48967, 48991, 49031, 49039, 49079, 49087, 49103, 49111, 49151, 49183, 49199, 49207, 49223, 49271, 49279, 49303, 49319, 49327, 49351, 49367, 49391, 49447, 49463, 49471, 49487, 49519, 49559, 49583, 49591, 49607, 49631, 49639, 49663, 49703, 49711, 49727, 49759, 49783, 49799, 49807, 49823, 49831, 49871, 49879, 49919, 49927, 49943, 49967, 49991, 49999, 50023, 50047, 50087, 50111, 50119, 50143, 50159, 50191, 50207, 50231, 50263, 50279, 50287, 50311, 50327, 50359, 50383, 50399, 50423, 50431, 50447, 50471, 50503, 50527, 50543, 50551, 50591, 50599, 50623, 50639, 50647, 50663, 50671, 50711, 50719, 50759, 50767, 50783, 50807, 50839, 50863, 50879, 50887, 50903, 50927, 50951, 50959, 50983, 51031, 51047, 51071, 51119, 51127, 51143, 51151, 51167, 51199, 51223, 51239, 51263, 51287, 51319, 51343, 51367, 51383, 51391, 51407, 51431, 51439, 51463, 51479, 51487, 51503, 51511, 51551, 51559, 51599, 51607, 51631, 51647, 51671, 51679, 51703, 51719, 51743, 51767, 51791, 51823, 51839, 51847, 51871, 51911, 51943, 51959, 51967, 51983, 51991, 52007, 52079, 52103, 52111, 52127, 52159, 52183, 52207, 52223, 52231, 52271, 52279, 52303, 52319, 52343, 52391, 52399, 52439, 52447, 52463, 52471, 52487, 52511, 52519, 52543, 52567, 52583, 52607, 52631, 52639, 52687, 52711, 52727, 52751, 52783, 52799, 52807, 52823, 52831, 52847, 52879, 52903, 52919, 52951, 52967, 52991, 52999, 53023, 53047, 53063, 53071, 53087, 53111, 53143, 53159, 53167, 53191, 53231, 53239, 53279, 53303, 53311, 53327, 53351, 53359, 53399, 53407, 53423, 53447, 53479, 53503, 53519, 53527, 53551, 53567, 53591, 53623, 53639, 53663, 53671, 53687, 53719, 53743, 53759, 53783, 53791, 53831, 53839, 53863, 53887, 53903, 53927, 53951, 53959, 53983, 54007, 54023, 54031, 54071, 54079, 54127, 54143, 54151, 54167, 54191, 54199, 54239, 54247, 54287, 54311, 54319, 54343, 54359, 54367, 54391, 54407, 54463, 54479, 54487, 54503, 54511, 54559, 54583, 54599, 54623, 54631, 54647, 54671, 54679, 54727, 54751, 54767, 54799, 54823, 54839, 54863, 54871, 54911, 54919, 54959, 54983, 54991, 55007, 55031, 55039, 55063, 55079, 55087, 55103, 55127, 55151, 55183, 55199, 55207, 55247, 55271, 55303, 55327, 55343, 55351, 55399, 55423, 55439, 55463, 55487, 55511, 55519, 55543, 55567, 55591, 55607, 55631, 55639, 55663, 55687, 55703, 55711, 55751, 55799, 55807, 55823, 55831, 55871, 55879, 55903, 55919, 55927, 55943, 55967, 55999, 56039, 56047, 56071, 56087, 56143, 56159, 56167, 56183, 56191, 56207, 56239, 56263, 56279, 56311, 56327, 56351, 56359, 56383, 56423, 56431, 56447, 56471, 56479, 56503, 56519, 56527, 56543, 56591, 56599, 56647, 56663, 56671, 56687, 56711, 56743, 56759, 56767, 56783, 56807, 56831, 56839, 56863, 56879, 56887, 56911, 56951, 56983, 56999, 57007, 57023, 57047, 57103, 57119, 57143, 57151, 57191, 57199, 57223, 57247, 57263, 57271, 57287, 57311, 57319, 57359, 57367, 57383, 57391, 57439, 57479, 57487, 57503, 57511, 57527, 57559, 57583, 57599, 57623, 57647, 57671, 57679, 57703, 57719, 57727, 57751, 57767, 57791, 57823, 57839, 57847, 57887, 57919, 57943, 57983, 57991, 58007, 58031, 58039, 58063, 58087, 58103, 58111, 58127, 58151, 58159, 58183, 58199, 58207, 58231, 58271, 58319, 58327, 58343, 58351, 58367, 58391, 58423, 58439, 58447, 58463, 58511, 58519, 58543, 58559, 58567, 58607, 58631, 58679, 58687, 58703, 58711, 58727, 58759, 58783, 58823, 58831, 58847, 58871, 58879, 58943, 58951, 58967, 58991, 58999, 59023, 59039, 59047, 59063, 59071, 59119, 59159, 59167, 59183, 59207, 59231, 59239, 59263, 59287, 59303, 59327, 59351, 59359, 59383, 59399, 59407, 59431, 59447, 59471, 59503, 59519, 59551, 59567, 59599, 59623, 59639, 59663, 59671, 59687, 59711, 59743, 59767, 59783, 59791, 59831, 59863, 59879, 59887, 59903, 59911, 59951, 59959, 59999, 60007, 60023, 60031, 60079, 60103, 60119, 60127, 60143, 60167, 60191, 60199, 60223, 60239, 60271, 60287, 60311, 60343, 60367, 60383, 60391, 60407, 60439, 60479, 60503, 60527, 60551, 60559, 60583, 60607, 60623, 60631, 60647, 60679, 60703, 60719, 60727, 60743, 60751, 60791, 60799, 60839, 60847, 60871, 60887, 60911, 60919, 60943, 60959, 60967, 61007, 61031, 61063, 61079, 61111, 61151, 61183, 61199, 61207, 61223, 61231, 61247, 61279, 61319, 61343, 61351, 61367, 61423, 61447, 61463, 61471, 61487, 61511, 61519, 61543, 61559, 61583, 61591, 61631, 61639, 61679, 61687, 61703, 61727, 61751, 61759, 61783, 61799, 61807, 61823, 61847, 61871, 61879, 61903, 61927, 61951, 61967, 61991, 62039, 62047, 62063, 62071, 62087, 62119, 62143, 62159, 62191, 62207, 62239, 62263, 62287, 62303, 62311, 62327, 62351, 62383, 62399, 62407, 62423, 62431, 62471, 62479, 62519, 62527, 62551, 62567, 62591, 62599, 62639, 62663, 62687, 62719, 62743, 62759, 62767, 62791, 62807, 62831, 62863, 62879, 62903, 62911, 62927, 62983, 62999, 63023, 63031, 63047, 63071, 63079, 63103, 63127, 63143, 63191, 63199, 63223, 63247, 63263, 63311, 63319, 63359, 63367, 63383, 63391, 63407, 63431, 63439, 63463, 63487, 63527, 63551, 63559, 63599, 63607, 63631, 63647, 63671, 63703, 63719, 63727, 63743, 63751, 63799, 63823, 63839, 63863, 63871, 63887, 63911, 63919, 63967, 63983, 63991, 64007, 64039, 64063, 64079, 64087, 64111, 64151, 64159, 64199, 64223, 64231, 64247, 64271, 64279, 64303, 64319, 64327, 64343, 64367, 64391, 64399, 64423, 64439, 64447, 64487, 64511, 64543, 64567, 64583, 64591, 64607, 64639, 64663, 64679, 64703, 64711, 64751, 64759, 64783, 64807, 64847, 64871, 64879, 64903, 64919, 64927, 64943, 64951, 64991, 65047, 65063, 65071, 65111, 65119, 65159, 65167, 65183, 65207, 65231, 65239, 65279, 65287, 65311, 65327, 65383, 65399, 65407, 65423, 65431, 65447, 65479, 65503, 65519, 65543, 65551, 65567, 65591, 65599, 65623, 65647, 65671, 65687, 65711, 65719, 65743, 65759, 65783, 65831, 65839, 65887, 65903, 65911, 65927, 65951, 65959, 65983, 65999, 66007, 66023, 66047, 66071, 66103, 66119, 66127, 66151, 66167, 66191, 66223, 66239, 66247, 66263, 66271, 66343, 66359, 66383, 66431, 66439, 66463, 66487, 66503, 66511, 66527, 66551, 66559, 66607, 66623, 66631, 66679, 66719, 66727, 66743, 66751, 66767, 66791, 66799, 66823, 66839, 66863, 66887, 66919, 66943, 66959, 66967, 66991, 67007, 67031, 67063, 67079, 67087, 67103, 67127, 67159, 67183, 67231, 67247, 67271, 67279, 67303, 67343, 67351, 67367, 67391, 67399, 67423, 67439, 67447, 67471, 67511, 67519, 67559, 67567, 67583, 67591, 67607, 67631, 67663, 67679, 67687, 67703, 67751, 67759, 67783, 67799, 67807, 67831, 67871, 67919, 67927, 67943, 67967, 67999, 68023, 68039, 68063, 68071, 68087, 68111, 68119, 68143, 68183, 68191, 68207, 68231, 68239, 68279, 68287, 68303, 68311, 68351, 68359, 68399, 68407, 68423, 68447, 68479, 68503, 68527, 68543, 68567, 68591, 68599, 68623, 68639, 68647, 68671, 68687, 68711, 68743, 68759, 68767, 68791, 68807, 68839, 68863, 68879, 68903, 68911, 68927, 68951, 68983, 69007, 69023, 69031, 69071, 69079, 69103, 69119, 69127, 69143, 69151, 69191, 69239, 69247, 69263, 69271, 69287, 69319, 69343, 69359, 69367, 69383, 69431, 69439, 69463, 69479, 69527, 69551, 69583, 69599, 69607, 69623, 69631, 69647, 69679, 69703, 69743, 69767, 69791, 69799, 69847, 69863, 69871, 69887, 69911, 69919, 69943, 69959, 69967, 69983, 69991, 70039, 70079, 70087, 70111, 70127, 70151, 70159, 70183, 70199, 70207, 70223, 70247, 70271, 70303, 70319, 70327, 70351, 70391, 70423, 70439, 70463, 70471, 70487, 70519, 70559, 70583, 70591, 70607, 70639, 70663, 70687, 70703, 70711, 70727, 70751, 70783, 70799, 70823, 70831, 70871, 70879, 70919, 70927, 70943, 70951, 70991, 70999, 71023, 71039, 71047, 71063, 71087, 71111, 71119, 71143, 71167, 71191, 71207, 71231, 71263, 71287, 71303, 71311, 71327, 71359, 71399, 71431, 71447, 71471, 71479, 71503, 71527, 71543, 71551, 71567, 71623, 71639, 71647, 71663, 71671, 71711, 71719, 71759, 71767, 71783, 71791, 71807, 71831, 71839, 71879, 71887, 71927, 71959, 71983, 71999, 72031, 72047, 72071, 72103, 72119, 72143, 72151, 72167, 72199, 72223, 72239, 72263, 72271, 72287, 72311, 72343, 72367, 72383, 72407, 72431, 72439, 72463, 72487, 72503, 72511, 72551, 72559, 72599, 72607, 72623, 72647, 72671, 72679, 72703, 72719, 72727, 72767, 72791, 72799, 72823, 72847, 72871, 72887, 72911, 72959, 72967, 72983, 72991, 73039, 73063, 73079, 73103, 73111, 73127, 73159, 73207, 73223, 73231, 73247, 73279, 73303, 73319, 73327, 73343, 73351, 73391, 73399, 73439, 73471, 73487, 73511, 73519, 73543, 73559, 73583, 73607, 73631, 73639, 73663, 73679, 73687, 73727, 73751, 73783, 73807, 73823, 73831, 73847, 73903, 73919, 73943, 73951, 73967, 73991, 73999, 74023, 74047, 74071, 74111, 74119, 74143, 74159, 74167, 74183, 74231, 74279, 74287, 74303, 74311, 74351, 74359, 74383, 74407, 74423, 74447, 74471, 74479, 74519, 74527, 74551, 74567, 74623, 74639, 74647, 74663, 74671, 74687, 74719, 74743, 74759, 74783, 74791, 74807, 74831, 74839, 74863, 74887, 74903, 74911, 74927, 74951, 74959, 74983, 74999, 75007, 75071, 75079, 75143, 75151, 75167, 75191, 75199, 75223, 75239, 75247, 75263, 75287, 75311, 75319, 75343, 75359, 75367, 75391, 75407, 75431, 75463, 75479, 75487, 75503, 75511, 75527, 75583, 75599, 75623, 75631, 75671, 75679, 75703, 75727, 75743, 75767, 75791, 75799, 75839, 75847, 75863, 75871, 75919, 75967, 75983, 75991, 76007, 76031, 76039, 76079, 76103, 76127, 76151, 76159, 76183, 76199, 76207, 76231, 76247, 76303, 76319, 76327, 76343, 76367, 76399, 76423, 76463, 76471, 76487, 76511, 76519, 76543, 76567, 76591, 76607, 76631, 76639, 76663, 76679, 76711, 76751, 76759, 76799, 76807, 76823, 76831, 76847, 76871, 76903, 76919, 76927, 76943, 76991, 77023, 77039, 77047, 77071, 77087, 77111, 77159, 77167, 77183, 77191, 77239, 77263, 77279, 77303, 77327, 77351, 77359, 77383, 77423, 77431, 77447, 77471, 77479, 77503, 77527, 77543, 77551, 77591, 77599, 77639, 77647, 77663, 77687, 77711, 77719, 77743, 77767, 77783, 77807, 77839, 77863, 77879, 77887, 77911, 77927, 77951, 77983, 77999, 78007, 78031, 78047, 78079, 78103, 78119, 78151, 78167, 78191, 78223, 78263, 78271, 78311, 78319, 78343, 78359, 78367, 78383, 78391, 78431, 78439, 78479, 78487, 78503, 78511, 78527, 78583, 78599, 78607, 78623, 78647, 78671, 78679, 78703, 78719, 78751, 78791, 78823, 78839, 78847, 78863, 78887, 78919, 78943, 78959, 78983, 79007, 79031, 79039, 79063, 79087, 79103, 79111, 79127, 79151, 79159, 79199, 79207, 79223, 79231, 79271, 79279, 79319, 79327, 79351, 79367, 79399, 79423, 79439, 79447, 79463, 79487, 79511, 79543, 79559, 79567, 79591, 79631, 79663, 79679, 79687, 79711, 79727, 79759, 79799, 79823, 79831, 79847, 79879, 79903, 79927, 79943, 79951, 79967, 79991, 79999, 80023, 80039, 80063, 80071, 80111, 80159, 80167, 80183, 80191, 80207, 80231, 80239, 80263, 80279, 80287, 80303, 80351, 80359, 80383, 80407, 80447, 80471, 80503, 80519, 80527, 80543, 80551, 80567, 80599, 80623, 80671, 80687, 80711, 80719, 80767, 80783, 80791, 80807, 80831, 80863, 80879, 80887, 80903, 80911, 80959, 80999, 81007, 81023, 81031, 81047, 81071, 81079, 81119, 81127, 81143, 81167, 81199, 81223, 81239, 81247, 81271, 81287, 81311, 81343, 81359, 81383, 81391, 81407, 81439, 81463, 81479, 81503, 81511, 81527, 81551, 81559, 81583, 81607, 81623, 81647, 81671, 81703, 81727, 81743, 81751, 81791, 81799, 81839, 81847, 81863, 81871, 81911, 81919, 81943, 81959, 81967, 82007, 82031, 82039, 82063, 82079, 82087, 82111, 82127, 82151, 82183, 82207, 82223, 82231, 82279, 82319, 82343, 82351, 82367, 82391, 82399, 82447, 82463, 82471, 82487, 82519, 82543, 82559, 82567, 82583, 82591, 82631, 82639, 82679, 82703, 82711, 82727, 82751, 82759, 82783, 82799, 82807, 82847, 82871, 82879, 82903, 82919, 82967, 82991, 83023, 83047, 83063, 83071, 83087, 83119, 83143, 83159, 83183, 83191, 83207, 83231, 83263, 83287, 83311, 83327, 83351, 83359, 83383, 83399, 83407, 83423, 83431, 83471, 83519, 83527, 83543, 83591, 83599, 83623, 83639, 83647, 83663, 83687, 83711, 83719, 83767, 83791, 83807, 83879, 83887, 83903, 83911, 83927, 83959, 83983, 83999, 84023, 84031, 84047, 84079, 84103, 84127, 84143, 84151, 84167, 84191, 84199, 84223, 84239, 84247, 84263, 84311, 84319, 84367, 84391, 84407, 84431, 84439, 84463, 84479, 84503, 84527, 84551, 84559, 84583, 84599, 84607, 84631, 84647, 84671, 84703, 84719, 84727, 84743, 84751, 84767, 84823, 84839, 84863, 84871, 84911, 84919, 84943, 84967, 84983, 84991, 85031, 85039, 85079, 85087, 85103, 85159, 85199, 85207, 85223, 85231, 85247, 85271, 85279, 85303, 85343, 85367, 85391, 85399, 85439, 85447, 85471, 85487, 85511, 85543, 85559, 85567, 85583, 85607, 85639, 85663, 85703, 85711, 85727, 85751, 85759, 85783, 85807, 85823, 85831, 85847, 85871, 85879, 85903, 85919, 85927, 85951, 85991, 85999, 86039, 86063, 86071, 86087, 86111, 86143, 86159, 86167, 86183, 86231, 86239, 86263, 86279, 86287, 86311, 86327, 86351, 86399, 86407, 86423, 86431, 86447, 86479, 86503, 86519, 86543, 86551, 86591, 86599, 86623, 86663, 86687, 86711, 86719, 86743, 86759, 86767, 86783, 86791, 86831, 86839, 86887, 86903, 86927, 86951, 86959, 87007, 87023, 87047, 87071, 87079, 87103, 87119, 87127, 87151, 87167, 87223, 87239, 87247, 87271, 87287, 87319, 87343, 87359, 87383, 87391, 87407, 87431, 87463, 87487, 87511, 87551, 87559, 87583, 87599, 87623, 87631, 87671, 87679, 87719, 87727, 87743, 87751, 87767, 87799, 87823, 87839, 87847, 87863, 87887, 87911, 87943, 87959, 87991, 88007, 88031, 88063, 88079, 88087, 88103, 88111, 88159, 88183, 88199, 88223, 88247, 88271, 88279, 88303, 88327, 88343, 88351, 88367, 88391, 88399, 88423, 88447, 88463, 88471, 88511, 88519, 88559, 88567, 88591, 88607, 88631, 88639, 88663, 88679, 88687, 88703, 88727, 88783, 88799, 88807, 88831, 88871, 88903, 88919, 88927, 88943, 88951, 88967, 88999, 89039, 89071, 89087, 89119, 89143, 89183, 89191, 89207, 89231, 89239, 89263, 89279, 89303, 89311, 89351, 89359, 89399, 89407, 89423, 89431, 89447, 89471, 89503, 89519, 89527, 89543, 89567, 89591, 89599, 89623, 89647, 89671, 89711, 89743, 89759, 89767, 89783, 89807, 89839, 89863, 89879, 89911, 89927, 89951, 89959, 89983, 90007, 90023, 90031, 90047, 90071, 90119, 90127, 90143, 90151, 90191, 90199, 90239, 90247, 90263, 90271, 90287, 90319, 90359, 90367, 90383, 90407, 90439, 90463, 90479, 90487, 90511, 90527, 90551, 90583, 90599, 90631, 90647, 90679, 90703, 90719, 90743, 90751, 90767, 90791, 90799, 90823, 90847, 90863, 90887, 90911, 90919, 90943, 90967, 90983, 90991, 91031, 91079, 91087, 91103, 91111, 91127, 91151, 91159, 91183, 91199, 91207, 91271, 91279, 91303, 91319, 91327, 91367, 91391, 91423, 91439, 91447, 91463, 91471, 91519, 91543, 91583, 91591, 91607, 91631, 91639, 91687, 91703, 91711, 91727, 91759, 91783, 91799, 91807, 91823, 91831, 91879, 91919, 91943, 91951, 91967, 91991, 91999, 92023, 92039, 92047, 92063, 92087, 92111, 92119, 92143, 92159, 92167, 92207, 92231, 92263, 92303, 92311, 92327, 92359, 92383, 92399, 92423, 92431, 92447, 92471, 92479, 92503, 92527, 92551, 92567, 92591, 92623, 92639, 92647, 92663, 92671, 92711, 92759, 92767, 92783, 92791, 92831, 92839, 92863, 92879, 92887, 92903, 92927, 92951, 92959, 92999, 93007, 93031, 93047, 93103, 93127, 93143, 93151, 93167, 93199, 93239, 93263, 93271, 93287, 93311, 93319, 93343, 93367, 93383, 93391, 93407, 93439, 93463, 93479, 93487, 93503, 93551, 93559, 93607, 93623, 93631, 93647, 93671, 93679, 93703, 93719, 93727, 93767, 93791, 93799, 93823, 93839, 93871, 93887, 93911, 93943, 93959, 93967, 93983, 93991, 94007, 94063, 94079, 94103, 94111, 94151, 94183, 94207, 94223, 94231, 94247, 94271, 94279, 94319, 94327, 94343, 94351, 94399, 94439, 94447, 94463, 94487, 94511, 94519, 94543, 94559, 94583, 94607, 94631, 94639, 94663, 94687, 94711, 94727, 94751, 94799, 94807, 94823, 94847, 94879, 94903, 94943, 94951, 94967, 94999, 95023, 95047, 95063, 95071, 95087, 95111, 95119, 95143, 95159, 95167, 95191, 95231, 95239, 95279, 95287, 95311, 95327, 95351, 95383, 95399, 95423, 95471, 95479, 95503, 95519, 95527, 95551, 95567, 95591, 95639, 95647, 95663, 95671, 95687, 95743, 95759, 95783, 95791, 95807, 95831, 95839, 95863, 95903, 95911, 95951, 95959, 95983, 95999, 96007, 96023, 96071, 96079, 96119, 96127, 96143, 96167, 96191, 96199, 96223, 96247, 96263, 96287, 96311, 96319, 96359, 96367, 96391, 96407, 96431, 96463, 96479, 96487, 96511, 96527, 96559, 96583, 96599, 96623, 96631, 96647, 96671, 96703, 96727, 96743, 96751, 96791, 96799, 96823, 96839, 96847, 96871, 96911, 96919, 96959, 96983, 96991, 97007, 97039, 97063, 97079, 97087, 97103, 97127, 97151, 97159, 97183, 97199, 97231, 97247, 97271, 97303, 97319, 97327, 97343, 97351, 97367, 97399, 97423, 97439, 97463, 97511, 97519, 97543, 97567, 97583, 97607, 97631, 97639, 97663, 97679, 97687, 97703, 97711, 97751, 97759, 97807, 97831, 97847, 97871, 97879, 97919, 97927, 97943, 97967, 97991, 98023, 98039, 98047, 98071, 98143, 98159, 98167, 98183, 98191, 98207, 98239, 98279, 98303, 98311, 98327, 98359, 98383, 98407, 98431, 98447, 98471, 98479, 98503, 98519, 98543, 98551, 98591, 98599, 98639, 98647, 98663, 98671, 98687, 98711, 98719, 98743, 98759, 98767, 98783, 98807, 98831, 98863, 98887, 98911, 98927, 98951, 98983, 98999, 99007, 99023, 99031, 99079, 99103, 99119, 99167, 99191, 99199, 99223, 99247, 99263, 99271, 99287, 99311, 99343, 99367, 99383, 99391, 99431, 99439, 99479, 99487, 99503, 99511, 99527, 99551, 99559, 99599, 99607, 99623, 99647, 99679, 99703, 99719, 99727, 99751, 99767, 99791, 99823, 99839, 99863, 99871, 99887, 99919, 99943, 99959, 99991, 100007, 100031, 100039, 100063, 100103, 100127, 100151, 100159, 100183, 100207, 100223, 100231, 100271, 100279, 100319, 100327, 100343, 100351, 100367, 100391, 100423, 100439, 100447, 100487, 100511, 100519, 100543, 100559, 100567, 100591, 100631, 100663, 100679, 100687, 100703, 100759, 100783, 100799, 100823, 100831, 100847, 100871, 100879, 100927, 100943, 100951, 100967, 100999, 101039, 101047, 101063, 101071, 101111, 101119, 101159, 101183, 101191, 101207, 101239, 101263, 101279, 101287, 101303, 101327, 101351, 101359, 101383, 101399, 101407, 101447, 101471, 101503, 101527, 101551, 101567, 101599, 101623, 101639, 101663, 101671, 101687, 101711, 101719, 101743, 101767, 101791, 101807, 101831, 101839, 101863, 101879, 101887, 101903, 101911, 101951, 101999, 102007, 102023, 102031, 102071, 102079, 102103, 102119, 102127, 102143, 102191, 102199, 102239, 102247, 102287, 102343, 102359, 102367, 102383, 102391, 102407, 102439, 102463, 102503, 102511, 102527, 102551, 102559, 102607, 102623, 102631, 102647, 102671, 102679, 102703, 102719, 102727, 102743, 102799, 102847, 102863, 102871, 102887, 102911, 102919, 102943, 102959, 102967, 102983, 103007, 103031, 103039, 103063, 103079, 103087, 103111, 103127, 103151, 103183, 103199, 103223, 103231, 103247, 103303, 103319, 103343, 103351, 103391, 103399, 103423, 103447, 103463, 103471, 103487, 103511, 103559, 103567, 103583, 103591, 103639, 103679, 103687, 103703, 103711, 103751, 103759, 103783, 103799, 103823, 103847, 103871, 103879, 103903, 103919, 103927, 103951, 103967, 103991, 104023, 104047, 104063, 104087, 104119, 104183, 104191, 104207, 104231, 104239, 104263, 104287, 104303, 104311, 104327, 104359, 104383, 104399, 104407, 104431, 104471, 104479, 104519, 104527, 104543, 104551, 104567, 104591, 104623, 104639, 104647, 104711, 104719, 104743, 104759, 104791, 104807, 104831, 104879, 104887, 104903, 104911, 104927, 104959, 104983, 104999, 105023, 105031, 105047, 105071, 105103, 105143, 105151, 105167, 105191, 105199, 105223, 105239, 105247, 105263, 105271, 105311, 105319, 105359, 105367, 105383, 105407, 105431, 105439, 105463, 105487, 105503, 105527, 105551, 105559, 105583, 105607, 105631, 105647, 105671, 105719, 105727, 105751, 105767, 105799, 105823, 105839, 105863, 105871, 105887, 105943, 105967, 105983, 105991, 106031, 106039, 106063, 106079, 106087, 106103, 106111, 106151, 106159, 106199, 106207, 106231, 106247, 106279, 106303, 106319, 106343, 106367, 106391, 106399, 106423, 106439, 106471, 106487, 106511, 106543, 106559, 106567, 106583, 106591, 106607, 106663, 106679, 106703, 106727, 106751, 106759, 106783, 106807, 106823, 106831, 106871, 106879, 106903, 106919, 106927, 106943, 106991, 106999, 107039, 107047, 107071, 107087, 107111, 107119, 107143, 107167, 107183, 107207, 107231, 107279, 107287, 107311, 107351, 107383, 107399, 107407, 107423, 107431, 107447, 107479, 107519, 107543, 107551, 107567, 107599, 107623, 107647, 107663, 107671, 107687, 107711, 107719, 107743, 107759, 107791, 107831, 107839, 107879, 107903, 107911, 107927, 107951, 107959, 107983, 107999, 108007, 108023, 108047, 108071, 108079, 108103, 108127, 108151, 108167, 108191, 108223, 108239, 108247, 108263, 108271, 108287, 108319, 108343, 108359, 108391, 108431, 108439, 108463, 108487, 108503, 108527, 108551, 108583, 108599, 108607, 108623, 108631, 108671, 108679, 108727, 108743, 108751, 108767, 108791, 108799, 108839, 108847, 108863, 108887, 108919, 108943, 108959, 108967, 108991, 109007, 109063, 109079, 109103, 109111, 109127, 109159, 109183, 109199, 109223, 109231, 109247, 109271, 109279, 109303, 109327, 109367, 109391, 109399, 109423, 109463, 109471, 109511, 109519, 109559, 109567, 109583, 109591, 109607, 109631, 109639, 109663, 109679, 109687, 109727, 109751, 109783, 109799, 109807, 109831, 109847, 109871, 109903, 109919, 109927, 109943, 109951, 109999, 110023, 110039, 110063, 110087, 110111, 110119, 110167, 110183, 110191, 110207, 110239, 110263, 110287, 110303, 110311, 110351, 110359, 110399, 110423, 110431, 110447, 110471, 110479, 110503, 110519, 110527, 110543, 110567, 110599, 110623, 110639, 110647, 110687, 110711, 110743, 110767, 110783, 110791, 110807, 110839, 110863, 110879, 110911, 110927, 110951, 110959, 110983, 111031, 111047, 111071, 111079, 111103, 111119, 111127, 111143, 111151, 111191, 111239, 111247, 111263, 111271, 111311, 111343, 111359, 111367, 111383, 111407, 111431, 111439, 111479, 111487, 111511, 111583, 111599, 111607, 111623, 111647, 111679, 111703, 111719, 111743, 111751, 111767, 111791, 111799, 111823, 111847, 111863, 111871, 111887, 111911, 111919, 111959, 111967, 111983, 112031, 112039, 112087, 112103, 112111, 112127, 112159, 112183, 112199, 112207, 112223, 112247, 112271, 112279, 112303, 112319, 112327, 112351, 112367, 112391, 112423, 112439, 112447, 112471, 112487, 112543, 112559, 112583, 112591, 112631, 112639, 112663, 112687, 112703, 112711, 112727, 112751, 112759, 112799, 112807, 112823, 112831, 112919, 112927, 112943, 112951, 112967, 112991, 112999, 113023, 113039, 113063, 113111, 113119, 113143, 113159, 113167, 113207, 113231, 113263, 113279, 113287, 113303, 113327, 113359, 113383, 113423, 113431, 113447, 113471, 113479, 113527, 113543, 113551, 113567, 113591, 113599, 113623, 113639, 113647, 113671, 113719, 113759, 113767, 113783, 113791, 113807, 113831, 113863, 113879, 113887, 113903, 113951, 113959, 113983, 113999, 114007, 114031, 114047, 114071, 114119, 114143, 114151, 114167, 114199, 114223, 114239, 114263, 114271, 114287, 114311, 114319, 114343, 114383, 114391, 114407, 114431, 114463, 114479, 114487, 114503, 114511, 114551, 114559, 114599, 114607, 114623, 114671, 114679, 114703, 114727, 114743, 114767, 114791, 114799, 114823, 114839, 114847, 114871, 114887, 114911, 114943, 114967, 114991, 115007, 115039, 115079, 115103, 115111, 115127, 115151, 115183, 115207, 115223, 115231, 115279, 115303, 115319, 115327, 115343, 115351, 115391, 115399, 115439, 115447, 115463, 115471, 115487, 115519, 115543, 115559, 115567, 115607, 115631, 115639, 115663, 115679, 115711, 115727, 115751, 115783, 115799, 115807, 115823, 115831, 115847, 115879, 115903, 115919, 115943, 115967, 115991, 116023, 116047, 116063, 116071, 116087, 116111, 116119, 116143, 116159, 116167, 116183, 116191, 116231, 116239, 116279, 116287, 116327, 116351, 116359, 116383, 116399, 116407, 116423, 116447, 116471, 116503, 116527, 116551, 116591, 116639, 116647, 116663, 116671, 116687, 116719, 116759, 116783, 116791, 116807, 116839, 116863, 116887, 116903, 116911, 116927, 116951, 116959, 116983, 116999, 117023, 117031, 117071, 117079, 117119, 117127, 117151, 117167, 117191, 117199, 117223, 117239, 117263, 117287, 117311, 117319, 117343, 117367, 117391, 117407, 117431, 117463, 117479, 117487, 117503, 117511, 117527, 117583, 117599, 117631, 117647, 117671, 117679, 117703, 117727, 117743, 117751, 117791, 117823, 117839, 117847, 117863, 117911, 117919, 117959, 117967, 117983, 117991, 118007, 118031, 118039, 118087, 118103, 118127, 118159, 118199, 118207, 118231, 118247, 118271, 118303, 118319, 118343, 118351, 118367, 118399, 118423, 118439, 118463, 118471, 118487, 118511, 118519, 118543, 118567, 118583, 118607, 118631, 118639, 118663, 118687, 118711, 118751, 118759, 118799, 118823, 118831, 118847, 118871, 118879, 118903, 118919, 118927, 118967, 118991, 118999, 119023, 119039, 119047, 119071, 119087, 119111, 119143, 119159, 119167, 119183, 119191, 119239, 119263, 119279, 119303, 119311, 119351, 119359, 119407, 119423, 119447, 119479, 119503, 119519, 119527, 119543, 119551, 119591, 119599, 119663, 119671, 119687, 119711, 119719, 119759, 119767, 119783, 119807, 119831, 119839, 119863, 119879, 119887, 119927, 119983, 120007, 120023, 120031, 120047, 120079, 120103, 120119]); - sieve_info = new sliceType$1([new Pair.ptr(new $Int64(0, 17), new $Int64(0, 8)), new Pair.ptr(new $Int64(0, 19), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 23), new $Int64(0, 5)), new Pair.ptr(new $Int64(0, 29), new $Int64(0, 15)), new Pair.ptr(new $Int64(0, 31), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 37), new $Int64(0, 35)), new Pair.ptr(new $Int64(0, 41), new $Int64(0, 4)), new Pair.ptr(new $Int64(0, 43), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 47), new $Int64(0, 43)), new Pair.ptr(new $Int64(0, 53), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 59), new $Int64(0, 44)), new Pair.ptr(new $Int64(0, 61), new $Int64(0, 50)), new Pair.ptr(new $Int64(0, 67), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 71), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 73), new $Int64(0, 48)), new Pair.ptr(new $Int64(0, 79), new $Int64(0, 2)), new Pair.ptr(new $Int64(0, 83), new $Int64(0, 35)), new Pair.ptr(new $Int64(0, 89), new $Int64(0, 86)), new Pair.ptr(new $Int64(0, 97), new $Int64(0, 20)), new Pair.ptr(new $Int64(0, 101), new $Int64(0, 88)), new Pair.ptr(new $Int64(0, 103), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 107), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 109), new $Int64(0, 55)), new Pair.ptr(new $Int64(0, 113), new $Int64(0, 1)), new Pair.ptr(new $Int64(0, 127), new $Int64(0, 75)), new Pair.ptr(new $Int64(0, 131), new $Int64(0, 56)), new Pair.ptr(new $Int64(0, 137), new $Int64(0, 85)), new Pair.ptr(new $Int64(0, 139), new $Int64(0, 29)), new Pair.ptr(new $Int64(0, 149), new $Int64(0, 86)), new Pair.ptr(new $Int64(0, 151), new $Int64(0, 149)), new Pair.ptr(new $Int64(0, 157), new $Int64(0, 21)), new Pair.ptr(new $Int64(0, 163), new $Int64(0, 74)), new Pair.ptr(new $Int64(0, 167), new $Int64(0, 32)), new Pair.ptr(new $Int64(0, 173), new $Int64(0, 3)), new Pair.ptr(new $Int64(0, 179), new $Int64(0, 114)), new Pair.ptr(new $Int64(0, 181), new $Int64(0, 82)), new Pair.ptr(new $Int64(0, 191), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 193), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 197), new $Int64(0, 130)), new Pair.ptr(new $Int64(0, 199), new $Int64(0, 144)), new Pair.ptr(new $Int64(0, 211), new $Int64(0, 128)), new Pair.ptr(new $Int64(0, 223), new $Int64(0, 139)), new Pair.ptr(new $Int64(0, 227), new $Int64(0, 135)), new Pair.ptr(new $Int64(0, 229), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 233), new $Int64(0, 192)), new Pair.ptr(new $Int64(0, 239), new $Int64(0, 170)), new Pair.ptr(new $Int64(0, 241), new $Int64(0, 26)), new Pair.ptr(new $Int64(0, 251), new $Int64(0, 175)), new Pair.ptr(new $Int64(0, 257), new $Int64(0, 28)), new Pair.ptr(new $Int64(0, 263), new $Int64(0, 100)), new Pair.ptr(new $Int64(0, 269), new $Int64(0, 234)), new Pair.ptr(new $Int64(0, 271), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 277), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 281), new $Int64(0, 131)), new Pair.ptr(new $Int64(0, 283), new $Int64(0, 241)), new Pair.ptr(new $Int64(0, 293), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 307), new $Int64(0, 37)), new Pair.ptr(new $Int64(0, 311), new $Int64(0, 290)), new Pair.ptr(new $Int64(0, 313), new $Int64(0, 213)), new Pair.ptr(new $Int64(0, 317), new $Int64(0, 124)), new Pair.ptr(new $Int64(0, 331), new $Int64(0, 10)), new Pair.ptr(new $Int64(0, 337), new $Int64(0, 189)), new Pair.ptr(new $Int64(0, 347), new $Int64(0, 6)), new Pair.ptr(new $Int64(0, 349), new $Int64(0, 60)), new Pair.ptr(new $Int64(0, 353), new $Int64(0, 293)), new Pair.ptr(new $Int64(0, 359), new $Int64(0, 307)), new Pair.ptr(new $Int64(0, 367), new $Int64(0, 205)), new Pair.ptr(new $Int64(0, 373), new $Int64(0, 80)), new Pair.ptr(new $Int64(0, 379), new $Int64(0, 346)), new Pair.ptr(new $Int64(0, 383), new $Int64(0, 89)), new Pair.ptr(new $Int64(0, 389), new $Int64(0, 24)), new Pair.ptr(new $Int64(0, 397), new $Int64(0, 65)), new Pair.ptr(new $Int64(0, 401), new $Int64(0, 225)), new Pair.ptr(new $Int64(0, 409), new $Int64(0, 198)), new Pair.ptr(new $Int64(0, 419), new $Int64(0, 63)), new Pair.ptr(new $Int64(0, 421), new $Int64(0, 184)), new Pair.ptr(new $Int64(0, 431), new $Int64(0, 147)), new Pair.ptr(new $Int64(0, 433), new $Int64(0, 254)), new Pair.ptr(new $Int64(0, 439), new $Int64(0, 119)), new Pair.ptr(new $Int64(0, 443), new $Int64(0, 324)), new Pair.ptr(new $Int64(0, 449), new $Int64(0, 36)), new Pair.ptr(new $Int64(0, 457), new $Int64(0, 354)), new Pair.ptr(new $Int64(0, 461), new $Int64(0, 211)), new Pair.ptr(new $Int64(0, 463), new $Int64(0, 333)), new Pair.ptr(new $Int64(0, 467), new $Int64(0, 37)), new Pair.ptr(new $Int64(0, 479), new $Int64(0, 312)), new Pair.ptr(new $Int64(0, 487), new $Int64(0, 219)), new Pair.ptr(new $Int64(0, 491), new $Int64(0, 101)), new Pair.ptr(new $Int64(0, 499), new $Int64(0, 140)), new Pair.ptr(new $Int64(0, 503), new $Int64(0, 140)), new Pair.ptr(new $Int64(0, 509), new $Int64(0, 127)), new Pair.ptr(new $Int64(0, 521), new $Int64(0, 106)), new Pair.ptr(new $Int64(0, 523), new $Int64(0, 483)), new Pair.ptr(new $Int64(0, 541), new $Int64(0, 511)), new Pair.ptr(new $Int64(0, 547), new $Int64(0, 455)), new Pair.ptr(new $Int64(0, 557), new $Int64(0, 293)), new Pair.ptr(new $Int64(0, 563), new $Int64(0, 549)), new Pair.ptr(new $Int64(0, 569), new $Int64(0, 28)), new Pair.ptr(new $Int64(0, 571), new $Int64(0, 242)), new Pair.ptr(new $Int64(0, 577), new $Int64(0, 172)), new Pair.ptr(new $Int64(0, 587), new $Int64(0, 172)), new Pair.ptr(new $Int64(0, 593), new $Int64(0, 87)), new Pair.ptr(new $Int64(0, 599), new $Int64(0, 526)), new Pair.ptr(new $Int64(0, 601), new $Int64(0, 308)), new Pair.ptr(new $Int64(0, 607), new $Int64(0, 561)), new Pair.ptr(new $Int64(0, 613), new $Int64(0, 197)), new Pair.ptr(new $Int64(0, 617), new $Int64(0, 405)), new Pair.ptr(new $Int64(0, 619), new $Int64(0, 528)), new Pair.ptr(new $Int64(0, 631), new $Int64(0, 107)), new Pair.ptr(new $Int64(0, 641), new $Int64(0, 603)), new Pair.ptr(new $Int64(0, 643), new $Int64(0, 457)), new Pair.ptr(new $Int64(0, 647), new $Int64(0, 102)), new Pair.ptr(new $Int64(0, 653), new $Int64(0, 102)), new Pair.ptr(new $Int64(0, 659), new $Int64(0, 554)), new Pair.ptr(new $Int64(0, 661), new $Int64(0, 69)), new Pair.ptr(new $Int64(0, 673), new $Int64(0, 64)), new Pair.ptr(new $Int64(0, 677), new $Int64(0, 114)), new Pair.ptr(new $Int64(0, 683), new $Int64(0, 520)), new Pair.ptr(new $Int64(0, 691), new $Int64(0, 297)), new Pair.ptr(new $Int64(0, 701), new $Int64(0, 442)), new Pair.ptr(new $Int64(0, 709), new $Int64(0, 396)), new Pair.ptr(new $Int64(0, 719), new $Int64(0, 153)), new Pair.ptr(new $Int64(0, 727), new $Int64(0, 141)), new Pair.ptr(new $Int64(0, 733), new $Int64(0, 486)), new Pair.ptr(new $Int64(0, 739), new $Int64(0, 307)), new Pair.ptr(new $Int64(0, 743), new $Int64(0, 595)), new Pair.ptr(new $Int64(0, 751), new $Int64(0, 582)), new Pair.ptr(new $Int64(0, 757), new $Int64(0, 676)), new Pair.ptr(new $Int64(0, 761), new $Int64(0, 316)), new Pair.ptr(new $Int64(0, 769), new $Int64(0, 350)), new Pair.ptr(new $Int64(0, 773), new $Int64(0, 147)), new Pair.ptr(new $Int64(0, 787), new $Int64(0, 668)), new Pair.ptr(new $Int64(0, 797), new $Int64(0, 639)), new Pair.ptr(new $Int64(0, 809), new $Int64(0, 98)), new Pair.ptr(new $Int64(0, 811), new $Int64(0, 573)), new Pair.ptr(new $Int64(0, 821), new $Int64(0, 320)), new Pair.ptr(new $Int64(0, 823), new $Int64(0, 758)), new Pair.ptr(new $Int64(0, 827), new $Int64(0, 472)), new Pair.ptr(new $Int64(0, 829), new $Int64(0, 39)), new Pair.ptr(new $Int64(0, 839), new $Int64(0, 751)), new Pair.ptr(new $Int64(0, 853), new $Int64(0, 223)), new Pair.ptr(new $Int64(0, 857), new $Int64(0, 655)), new Pair.ptr(new $Int64(0, 859), new $Int64(0, 362)), new Pair.ptr(new $Int64(0, 863), new $Int64(0, 773)), new Pair.ptr(new $Int64(0, 877), new $Int64(0, 756)), new Pair.ptr(new $Int64(0, 881), new $Int64(0, 739)), new Pair.ptr(new $Int64(0, 883), new $Int64(0, 138)), new Pair.ptr(new $Int64(0, 887), new $Int64(0, 123)), new Pair.ptr(new $Int64(0, 907), new $Int64(0, 836)), new Pair.ptr(new $Int64(0, 911), new $Int64(0, 490)), new Pair.ptr(new $Int64(0, 919), new $Int64(0, 878)), new Pair.ptr(new $Int64(0, 929), new $Int64(0, 313)), new Pair.ptr(new $Int64(0, 937), new $Int64(0, 606)), new Pair.ptr(new $Int64(0, 941), new $Int64(0, 175)), new Pair.ptr(new $Int64(0, 947), new $Int64(0, 286)), new Pair.ptr(new $Int64(0, 953), new $Int64(0, 295)), new Pair.ptr(new $Int64(0, 967), new $Int64(0, 260)), new Pair.ptr(new $Int64(0, 971), new $Int64(0, 612)), new Pair.ptr(new $Int64(0, 977), new $Int64(0, 613)), new Pair.ptr(new $Int64(0, 983), new $Int64(0, 907)), new Pair.ptr(new $Int64(0, 991), new $Int64(0, 569)), new Pair.ptr(new $Int64(0, 997), new $Int64(0, 970)), new Pair.ptr(new $Int64(0, 1009), new $Int64(0, 556)), new Pair.ptr(new $Int64(0, 1013), new $Int64(0, 223)), new Pair.ptr(new $Int64(0, 1019), new $Int64(0, 877)), new Pair.ptr(new $Int64(0, 1021), new $Int64(0, 77)), new Pair.ptr(new $Int64(0, 1031), new $Int64(0, 364)), new Pair.ptr(new $Int64(0, 1033), new $Int64(0, 704)), new Pair.ptr(new $Int64(0, 1039), new $Int64(0, 18)), new Pair.ptr(new $Int64(0, 1049), new $Int64(0, 497)), new Pair.ptr(new $Int64(0, 1051), new $Int64(0, 79)), new Pair.ptr(new $Int64(0, 1061), new $Int64(0, 846)), new Pair.ptr(new $Int64(0, 1063), new $Int64(0, 1)), new Pair.ptr(new $Int64(0, 1069), new $Int64(0, 30)), new Pair.ptr(new $Int64(0, 1087), new $Int64(0, 251)), new Pair.ptr(new $Int64(0, 1091), new $Int64(0, 486)), new Pair.ptr(new $Int64(0, 1093), new $Int64(0, 467)), new Pair.ptr(new $Int64(0, 1097), new $Int64(0, 365)), new Pair.ptr(new $Int64(0, 1103), new $Int64(0, 134)), new Pair.ptr(new $Int64(0, 1109), new $Int64(0, 290)), new Pair.ptr(new $Int64(0, 1117), new $Int64(0, 184)), new Pair.ptr(new $Int64(0, 1123), new $Int64(0, 493)), new Pair.ptr(new $Int64(0, 1129), new $Int64(0, 524)), new Pair.ptr(new $Int64(0, 1151), new $Int64(0, 534)), new Pair.ptr(new $Int64(0, 1153), new $Int64(0, 704)), new Pair.ptr(new $Int64(0, 1163), new $Int64(0, 1033)), new Pair.ptr(new $Int64(0, 1171), new $Int64(0, 19)), new Pair.ptr(new $Int64(0, 1181), new $Int64(0, 701)), new Pair.ptr(new $Int64(0, 1187), new $Int64(0, 917)), new Pair.ptr(new $Int64(0, 1193), new $Int64(0, 790)), new Pair.ptr(new $Int64(0, 1201), new $Int64(0, 1141)), new Pair.ptr(new $Int64(0, 1213), new $Int64(0, 1066)), new Pair.ptr(new $Int64(0, 1217), new $Int64(0, 580)), new Pair.ptr(new $Int64(0, 1223), new $Int64(0, 823)), new Pair.ptr(new $Int64(0, 1229), new $Int64(0, 729)), new Pair.ptr(new $Int64(0, 1231), new $Int64(0, 1029)), new Pair.ptr(new $Int64(0, 1237), new $Int64(0, 661)), new Pair.ptr(new $Int64(0, 1249), new $Int64(0, 133)), new Pair.ptr(new $Int64(0, 1259), new $Int64(0, 1237)), new Pair.ptr(new $Int64(0, 1277), new $Int64(0, 1168)), new Pair.ptr(new $Int64(0, 1279), new $Int64(0, 1098)), new Pair.ptr(new $Int64(0, 1283), new $Int64(0, 732)), new Pair.ptr(new $Int64(0, 1289), new $Int64(0, 1167)), new Pair.ptr(new $Int64(0, 1291), new $Int64(0, 453)), new Pair.ptr(new $Int64(0, 1297), new $Int64(0, 787)), new Pair.ptr(new $Int64(0, 1301), new $Int64(0, 459)), new Pair.ptr(new $Int64(0, 1303), new $Int64(0, 518)), new Pair.ptr(new $Int64(0, 1307), new $Int64(0, 917)), new Pair.ptr(new $Int64(0, 1319), new $Int64(0, 29)), new Pair.ptr(new $Int64(0, 1321), new $Int64(0, 450)), new Pair.ptr(new $Int64(0, 1327), new $Int64(0, 1302)), new Pair.ptr(new $Int64(0, 1361), new $Int64(0, 58)), new Pair.ptr(new $Int64(0, 1367), new $Int64(0, 800)), new Pair.ptr(new $Int64(0, 1373), new $Int64(0, 353)), new Pair.ptr(new $Int64(0, 1381), new $Int64(0, 358)), new Pair.ptr(new $Int64(0, 1399), new $Int64(0, 512)), new Pair.ptr(new $Int64(0, 1409), new $Int64(0, 897)), new Pair.ptr(new $Int64(0, 1423), new $Int64(0, 651)), new Pair.ptr(new $Int64(0, 1427), new $Int64(0, 957)), new Pair.ptr(new $Int64(0, 1429), new $Int64(0, 1412)), new Pair.ptr(new $Int64(0, 1433), new $Int64(0, 1052)), new Pair.ptr(new $Int64(0, 1439), new $Int64(0, 1163)), new Pair.ptr(new $Int64(0, 1447), new $Int64(0, 457)), new Pair.ptr(new $Int64(0, 1451), new $Int64(0, 700)), new Pair.ptr(new $Int64(0, 1453), new $Int64(0, 91)), new Pair.ptr(new $Int64(0, 1459), new $Int64(0, 112)), new Pair.ptr(new $Int64(0, 1471), new $Int64(0, 126)), new Pair.ptr(new $Int64(0, 1481), new $Int64(0, 1155)), new Pair.ptr(new $Int64(0, 1483), new $Int64(0, 494)), new Pair.ptr(new $Int64(0, 1487), new $Int64(0, 432)), new Pair.ptr(new $Int64(0, 1489), new $Int64(0, 880)), new Pair.ptr(new $Int64(0, 1493), new $Int64(0, 797)), new Pair.ptr(new $Int64(0, 1499), new $Int64(0, 757)), new Pair.ptr(new $Int64(0, 1511), new $Int64(0, 1175)), new Pair.ptr(new $Int64(0, 1523), new $Int64(0, 201)), new Pair.ptr(new $Int64(0, 1531), new $Int64(0, 1097)), new Pair.ptr(new $Int64(0, 1543), new $Int64(0, 877)), new Pair.ptr(new $Int64(0, 1549), new $Int64(0, 876)), new Pair.ptr(new $Int64(0, 1553), new $Int64(0, 1092)), new Pair.ptr(new $Int64(0, 1559), new $Int64(0, 81)), new Pair.ptr(new $Int64(0, 1567), new $Int64(0, 282)), new Pair.ptr(new $Int64(0, 1571), new $Int64(0, 1009)), new Pair.ptr(new $Int64(0, 1579), new $Int64(0, 667)), new Pair.ptr(new $Int64(0, 1583), new $Int64(0, 1002)), new Pair.ptr(new $Int64(0, 1597), new $Int64(0, 287)), new Pair.ptr(new $Int64(0, 1601), new $Int64(0, 676)), new Pair.ptr(new $Int64(0, 1607), new $Int64(0, 865)), new Pair.ptr(new $Int64(0, 1609), new $Int64(0, 316)), new Pair.ptr(new $Int64(0, 1613), new $Int64(0, 1164)), new Pair.ptr(new $Int64(0, 1619), new $Int64(0, 892)), new Pair.ptr(new $Int64(0, 1621), new $Int64(0, 1455)), new Pair.ptr(new $Int64(0, 1627), new $Int64(0, 357)), new Pair.ptr(new $Int64(0, 1637), new $Int64(0, 1198)), new Pair.ptr(new $Int64(0, 1657), new $Int64(0, 729)), new Pair.ptr(new $Int64(0, 1663), new $Int64(0, 1113)), new Pair.ptr(new $Int64(0, 1667), new $Int64(0, 1476)), new Pair.ptr(new $Int64(0, 1669), new $Int64(0, 452)), new Pair.ptr(new $Int64(0, 1693), new $Int64(0, 1591)), new Pair.ptr(new $Int64(0, 1697), new $Int64(0, 1119)), new Pair.ptr(new $Int64(0, 1699), new $Int64(0, 1215)), new Pair.ptr(new $Int64(0, 1709), new $Int64(0, 143)), new Pair.ptr(new $Int64(0, 1721), new $Int64(0, 890)), new Pair.ptr(new $Int64(0, 1723), new $Int64(0, 1185)), new Pair.ptr(new $Int64(0, 1733), new $Int64(0, 1583)), new Pair.ptr(new $Int64(0, 1741), new $Int64(0, 1354)), new Pair.ptr(new $Int64(0, 1747), new $Int64(0, 413)), new Pair.ptr(new $Int64(0, 1753), new $Int64(0, 932)), new Pair.ptr(new $Int64(0, 1759), new $Int64(0, 1250)), new Pair.ptr(new $Int64(0, 1777), new $Int64(0, 1025)), new Pair.ptr(new $Int64(0, 1783), new $Int64(0, 1204)), new Pair.ptr(new $Int64(0, 1787), new $Int64(0, 1202)), new Pair.ptr(new $Int64(0, 1789), new $Int64(0, 1253)), new Pair.ptr(new $Int64(0, 1801), new $Int64(0, 1317)), new Pair.ptr(new $Int64(0, 1811), new $Int64(0, 1686)), new Pair.ptr(new $Int64(0, 1823), new $Int64(0, 267)), new Pair.ptr(new $Int64(0, 1831), new $Int64(0, 744)), new Pair.ptr(new $Int64(0, 1847), new $Int64(0, 341)), new Pair.ptr(new $Int64(0, 1861), new $Int64(0, 1676)), new Pair.ptr(new $Int64(0, 1867), new $Int64(0, 322)), new Pair.ptr(new $Int64(0, 1871), new $Int64(0, 1040)), new Pair.ptr(new $Int64(0, 1873), new $Int64(0, 1080)), new Pair.ptr(new $Int64(0, 1877), new $Int64(0, 1173)), new Pair.ptr(new $Int64(0, 1879), new $Int64(0, 1202)), new Pair.ptr(new $Int64(0, 1889), new $Int64(0, 1463)), new Pair.ptr(new $Int64(0, 1901), new $Int64(0, 213)), new Pair.ptr(new $Int64(0, 1907), new $Int64(0, 454)), new Pair.ptr(new $Int64(0, 1913), new $Int64(0, 1563)), new Pair.ptr(new $Int64(0, 1931), new $Int64(0, 131)), new Pair.ptr(new $Int64(0, 1933), new $Int64(0, 515)), new Pair.ptr(new $Int64(0, 1949), new $Int64(0, 19)), new Pair.ptr(new $Int64(0, 1951), new $Int64(0, 95)), new Pair.ptr(new $Int64(0, 1973), new $Int64(0, 525)), new Pair.ptr(new $Int64(0, 1979), new $Int64(0, 1120)), new Pair.ptr(new $Int64(0, 1987), new $Int64(0, 170)), new Pair.ptr(new $Int64(0, 1993), new $Int64(0, 1635)), new Pair.ptr(new $Int64(0, 1997), new $Int64(0, 446)), new Pair.ptr(new $Int64(0, 1999), new $Int64(0, 1788)), new Pair.ptr(new $Int64(0, 2003), new $Int64(0, 1569)), new Pair.ptr(new $Int64(0, 2011), new $Int64(0, 1903)), new Pair.ptr(new $Int64(0, 2017), new $Int64(0, 567)), new Pair.ptr(new $Int64(0, 2027), new $Int64(0, 1977)), new Pair.ptr(new $Int64(0, 2029), new $Int64(0, 888)), new Pair.ptr(new $Int64(0, 2039), new $Int64(0, 1487)), new Pair.ptr(new $Int64(0, 2053), new $Int64(0, 1474)), new Pair.ptr(new $Int64(0, 2063), new $Int64(0, 1244)), new Pair.ptr(new $Int64(0, 2069), new $Int64(0, 1806)), new Pair.ptr(new $Int64(0, 2081), new $Int64(0, 18)), new Pair.ptr(new $Int64(0, 2083), new $Int64(0, 3)), new Pair.ptr(new $Int64(0, 2087), new $Int64(0, 746)), new Pair.ptr(new $Int64(0, 2089), new $Int64(0, 836)), new Pair.ptr(new $Int64(0, 2099), new $Int64(0, 2077)), new Pair.ptr(new $Int64(0, 2111), new $Int64(0, 1030)), new Pair.ptr(new $Int64(0, 2113), new $Int64(0, 678)), new Pair.ptr(new $Int64(0, 2129), new $Int64(0, 796)), new Pair.ptr(new $Int64(0, 2131), new $Int64(0, 405)), new Pair.ptr(new $Int64(0, 2137), new $Int64(0, 415)), new Pair.ptr(new $Int64(0, 2141), new $Int64(0, 411)), new Pair.ptr(new $Int64(0, 2143), new $Int64(0, 1856)), new Pair.ptr(new $Int64(0, 2153), new $Int64(0, 1658)), new Pair.ptr(new $Int64(0, 2161), new $Int64(0, 41)), new Pair.ptr(new $Int64(0, 2179), new $Int64(0, 1038)), new Pair.ptr(new $Int64(0, 2203), new $Int64(0, 78)), new Pair.ptr(new $Int64(0, 2207), new $Int64(0, 2125)), new Pair.ptr(new $Int64(0, 2213), new $Int64(0, 863)), new Pair.ptr(new $Int64(0, 2221), new $Int64(0, 203)), new Pair.ptr(new $Int64(0, 2237), new $Int64(0, 551)), new Pair.ptr(new $Int64(0, 2239), new $Int64(0, 1524)), new Pair.ptr(new $Int64(0, 2243), new $Int64(0, 1999)), new Pair.ptr(new $Int64(0, 2251), new $Int64(0, 529)), new Pair.ptr(new $Int64(0, 2267), new $Int64(0, 585)), new Pair.ptr(new $Int64(0, 2269), new $Int64(0, 2004)), new Pair.ptr(new $Int64(0, 2273), new $Int64(0, 254)), new Pair.ptr(new $Int64(0, 2281), new $Int64(0, 180)), new Pair.ptr(new $Int64(0, 2287), new $Int64(0, 1394)), new Pair.ptr(new $Int64(0, 2293), new $Int64(0, 1699)), new Pair.ptr(new $Int64(0, 2297), new $Int64(0, 1315)), new Pair.ptr(new $Int64(0, 2309), new $Int64(0, 2087)), new Pair.ptr(new $Int64(0, 2311), new $Int64(0, 1911)), new Pair.ptr(new $Int64(0, 2333), new $Int64(0, 1898)), new Pair.ptr(new $Int64(0, 2339), new $Int64(0, 805)), new Pair.ptr(new $Int64(0, 2341), new $Int64(0, 228)), new Pair.ptr(new $Int64(0, 2347), new $Int64(0, 2175)), new Pair.ptr(new $Int64(0, 2351), new $Int64(0, 365)), new Pair.ptr(new $Int64(0, 2357), new $Int64(0, 298)), new Pair.ptr(new $Int64(0, 2371), new $Int64(0, 74)), new Pair.ptr(new $Int64(0, 2377), new $Int64(0, 350)), new Pair.ptr(new $Int64(0, 2381), new $Int64(0, 2134)), new Pair.ptr(new $Int64(0, 2383), new $Int64(0, 2071)), new Pair.ptr(new $Int64(0, 2389), new $Int64(0, 2036)), new Pair.ptr(new $Int64(0, 2393), new $Int64(0, 779)), new Pair.ptr(new $Int64(0, 2399), new $Int64(0, 2272)), new Pair.ptr(new $Int64(0, 2411), new $Int64(0, 1127)), new Pair.ptr(new $Int64(0, 2417), new $Int64(0, 937)), new Pair.ptr(new $Int64(0, 2423), new $Int64(0, 534)), new Pair.ptr(new $Int64(0, 2437), new $Int64(0, 455)), new Pair.ptr(new $Int64(0, 2441), new $Int64(0, 621)), new Pair.ptr(new $Int64(0, 2447), new $Int64(0, 530)), new Pair.ptr(new $Int64(0, 2459), new $Int64(0, 1372)), new Pair.ptr(new $Int64(0, 2467), new $Int64(0, 2370)), new Pair.ptr(new $Int64(0, 2473), new $Int64(0, 124)), new Pair.ptr(new $Int64(0, 2477), new $Int64(0, 427)), new Pair.ptr(new $Int64(0, 2503), new $Int64(0, 730)), new Pair.ptr(new $Int64(0, 2521), new $Int64(0, 1093)), new Pair.ptr(new $Int64(0, 2531), new $Int64(0, 642)), new Pair.ptr(new $Int64(0, 2539), new $Int64(0, 271)), new Pair.ptr(new $Int64(0, 2543), new $Int64(0, 1851)), new Pair.ptr(new $Int64(0, 2549), new $Int64(0, 1568)), new Pair.ptr(new $Int64(0, 2551), new $Int64(0, 1796)), new Pair.ptr(new $Int64(0, 2557), new $Int64(0, 130)), new Pair.ptr(new $Int64(0, 2579), new $Int64(0, 210)), new Pair.ptr(new $Int64(0, 2591), new $Int64(0, 1756)), new Pair.ptr(new $Int64(0, 2593), new $Int64(0, 1161)), new Pair.ptr(new $Int64(0, 2609), new $Int64(0, 1846)), new Pair.ptr(new $Int64(0, 2617), new $Int64(0, 869)), new Pair.ptr(new $Int64(0, 2621), new $Int64(0, 2192)), new Pair.ptr(new $Int64(0, 2633), new $Int64(0, 2509)), new Pair.ptr(new $Int64(0, 2647), new $Int64(0, 1230)), new Pair.ptr(new $Int64(0, 2657), new $Int64(0, 608)), new Pair.ptr(new $Int64(0, 2659), new $Int64(0, 406)), new Pair.ptr(new $Int64(0, 2663), new $Int64(0, 2364)), new Pair.ptr(new $Int64(0, 2671), new $Int64(0, 1104)), new Pair.ptr(new $Int64(0, 2677), new $Int64(0, 1032)), new Pair.ptr(new $Int64(0, 2683), new $Int64(0, 1143)), new Pair.ptr(new $Int64(0, 2687), new $Int64(0, 1041)), new Pair.ptr(new $Int64(0, 2689), new $Int64(0, 2610)), new Pair.ptr(new $Int64(0, 2693), new $Int64(0, 574)), new Pair.ptr(new $Int64(0, 2699), new $Int64(0, 2606)), new Pair.ptr(new $Int64(0, 2707), new $Int64(0, 2057)), new Pair.ptr(new $Int64(0, 2711), new $Int64(0, 1469)), new Pair.ptr(new $Int64(0, 2713), new $Int64(0, 1128)), new Pair.ptr(new $Int64(0, 2719), new $Int64(0, 1264)), new Pair.ptr(new $Int64(0, 2729), new $Int64(0, 2667)), new Pair.ptr(new $Int64(0, 2731), new $Int64(0, 931)), new Pair.ptr(new $Int64(0, 2741), new $Int64(0, 1093)), new Pair.ptr(new $Int64(0, 2749), new $Int64(0, 2384)), new Pair.ptr(new $Int64(0, 2753), new $Int64(0, 1537)), new Pair.ptr(new $Int64(0, 2767), new $Int64(0, 2303)), new Pair.ptr(new $Int64(0, 2777), new $Int64(0, 2730)), new Pair.ptr(new $Int64(0, 2789), new $Int64(0, 1763)), new Pair.ptr(new $Int64(0, 2791), new $Int64(0, 2478)), new Pair.ptr(new $Int64(0, 2797), new $Int64(0, 1204)), new Pair.ptr(new $Int64(0, 2801), new $Int64(0, 2246)), new Pair.ptr(new $Int64(0, 2803), new $Int64(0, 2289)), new Pair.ptr(new $Int64(0, 2819), new $Int64(0, 866)), new Pair.ptr(new $Int64(0, 2833), new $Int64(0, 2126)), new Pair.ptr(new $Int64(0, 2837), new $Int64(0, 2558)), new Pair.ptr(new $Int64(0, 2843), new $Int64(0, 219)), new Pair.ptr(new $Int64(0, 2851), new $Int64(0, 445)), new Pair.ptr(new $Int64(0, 2857), new $Int64(0, 1882)), new Pair.ptr(new $Int64(0, 2861), new $Int64(0, 1158)), new Pair.ptr(new $Int64(0, 2879), new $Int64(0, 1858)), new Pair.ptr(new $Int64(0, 2887), new $Int64(0, 583)), new Pair.ptr(new $Int64(0, 2897), new $Int64(0, 1016)), new Pair.ptr(new $Int64(0, 2903), new $Int64(0, 1040)), new Pair.ptr(new $Int64(0, 2909), new $Int64(0, 2051)), new Pair.ptr(new $Int64(0, 2917), new $Int64(0, 396)), new Pair.ptr(new $Int64(0, 2927), new $Int64(0, 1865)), new Pair.ptr(new $Int64(0, 2939), new $Int64(0, 1264)), new Pair.ptr(new $Int64(0, 2953), new $Int64(0, 2042)), new Pair.ptr(new $Int64(0, 2957), new $Int64(0, 2229)), new Pair.ptr(new $Int64(0, 2963), new $Int64(0, 2913)), new Pair.ptr(new $Int64(0, 2969), new $Int64(0, 155)), new Pair.ptr(new $Int64(0, 2971), new $Int64(0, 253)), new Pair.ptr(new $Int64(0, 2999), new $Int64(0, 2268)), new Pair.ptr(new $Int64(0, 3001), new $Int64(0, 1463)), new Pair.ptr(new $Int64(0, 3011), new $Int64(0, 1609)), new Pair.ptr(new $Int64(0, 3019), new $Int64(0, 467)), new Pair.ptr(new $Int64(0, 3023), new $Int64(0, 2596)), new Pair.ptr(new $Int64(0, 3037), new $Int64(0, 297)), new Pair.ptr(new $Int64(0, 3041), new $Int64(0, 2)), new Pair.ptr(new $Int64(0, 3049), new $Int64(0, 1208)), new Pair.ptr(new $Int64(0, 3061), new $Int64(0, 1136)), new Pair.ptr(new $Int64(0, 3067), new $Int64(0, 2208)), new Pair.ptr(new $Int64(0, 3079), new $Int64(0, 1579)), new Pair.ptr(new $Int64(0, 3083), new $Int64(0, 527)), new Pair.ptr(new $Int64(0, 3089), new $Int64(0, 44)), new Pair.ptr(new $Int64(0, 3109), new $Int64(0, 2485)), new Pair.ptr(new $Int64(0, 3119), new $Int64(0, 2957)), new Pair.ptr(new $Int64(0, 3121), new $Int64(0, 1905)), new Pair.ptr(new $Int64(0, 3137), new $Int64(0, 2454)), new Pair.ptr(new $Int64(0, 3163), new $Int64(0, 1496)), new Pair.ptr(new $Int64(0, 3167), new $Int64(0, 2116)), new Pair.ptr(new $Int64(0, 3169), new $Int64(0, 787)), new Pair.ptr(new $Int64(0, 3181), new $Int64(0, 2690)), new Pair.ptr(new $Int64(0, 3187), new $Int64(0, 2686)), new Pair.ptr(new $Int64(0, 3191), new $Int64(0, 1388)), new Pair.ptr(new $Int64(0, 3203), new $Int64(0, 2349)), new Pair.ptr(new $Int64(0, 3209), new $Int64(0, 2309)), new Pair.ptr(new $Int64(0, 3217), new $Int64(0, 1666)), new Pair.ptr(new $Int64(0, 3221), new $Int64(0, 1175)), new Pair.ptr(new $Int64(0, 3229), new $Int64(0, 539)), new Pair.ptr(new $Int64(0, 3251), new $Int64(0, 292)), new Pair.ptr(new $Int64(0, 3253), new $Int64(0, 3226)), new Pair.ptr(new $Int64(0, 3257), new $Int64(0, 921)), new Pair.ptr(new $Int64(0, 3259), new $Int64(0, 1992)), new Pair.ptr(new $Int64(0, 3271), new $Int64(0, 339)), new Pair.ptr(new $Int64(0, 3299), new $Int64(0, 1287)), new Pair.ptr(new $Int64(0, 3301), new $Int64(0, 1324)), new Pair.ptr(new $Int64(0, 3307), new $Int64(0, 610)), new Pair.ptr(new $Int64(0, 3313), new $Int64(0, 1116)), new Pair.ptr(new $Int64(0, 3319), new $Int64(0, 2531)), new Pair.ptr(new $Int64(0, 3323), new $Int64(0, 412)), new Pair.ptr(new $Int64(0, 3329), new $Int64(0, 2545)), new Pair.ptr(new $Int64(0, 3331), new $Int64(0, 2237)), new Pair.ptr(new $Int64(0, 3343), new $Int64(0, 2214)), new Pair.ptr(new $Int64(0, 3347), new $Int64(0, 3338)), new Pair.ptr(new $Int64(0, 3359), new $Int64(0, 2302)), new Pair.ptr(new $Int64(0, 3361), new $Int64(0, 188)), new Pair.ptr(new $Int64(0, 3371), new $Int64(0, 30)), new Pair.ptr(new $Int64(0, 3373), new $Int64(0, 2014)), new Pair.ptr(new $Int64(0, 3389), new $Int64(0, 2772)), new Pair.ptr(new $Int64(0, 3391), new $Int64(0, 1510)), new Pair.ptr(new $Int64(0, 3407), new $Int64(0, 806)), new Pair.ptr(new $Int64(0, 3413), new $Int64(0, 349)), new Pair.ptr(new $Int64(0, 3433), new $Int64(0, 1177)), new Pair.ptr(new $Int64(0, 3449), new $Int64(0, 342)), new Pair.ptr(new $Int64(0, 3457), new $Int64(0, 1849)), new Pair.ptr(new $Int64(0, 3461), new $Int64(0, 208)), new Pair.ptr(new $Int64(0, 3463), new $Int64(0, 2847)), new Pair.ptr(new $Int64(0, 3467), new $Int64(0, 150)), new Pair.ptr(new $Int64(0, 3469), new $Int64(0, 1993)), new Pair.ptr(new $Int64(0, 3491), new $Int64(0, 2005)), new Pair.ptr(new $Int64(0, 3499), new $Int64(0, 1513)), new Pair.ptr(new $Int64(0, 3511), new $Int64(0, 2998)), new Pair.ptr(new $Int64(0, 3517), new $Int64(0, 3225)), new Pair.ptr(new $Int64(0, 3527), new $Int64(0, 2427)), new Pair.ptr(new $Int64(0, 3529), new $Int64(0, 3450)), new Pair.ptr(new $Int64(0, 3533), new $Int64(0, 1766)), new Pair.ptr(new $Int64(0, 3539), new $Int64(0, 670)), new Pair.ptr(new $Int64(0, 3541), new $Int64(0, 168)), new Pair.ptr(new $Int64(0, 3547), new $Int64(0, 2100)), new Pair.ptr(new $Int64(0, 3557), new $Int64(0, 2596)), new Pair.ptr(new $Int64(0, 3559), new $Int64(0, 3322)), new Pair.ptr(new $Int64(0, 3571), new $Int64(0, 643)), new Pair.ptr(new $Int64(0, 3581), new $Int64(0, 1453)), new Pair.ptr(new $Int64(0, 3583), new $Int64(0, 1181)), new Pair.ptr(new $Int64(0, 3593), new $Int64(0, 2810)), new Pair.ptr(new $Int64(0, 3607), new $Int64(0, 732)), new Pair.ptr(new $Int64(0, 3613), new $Int64(0, 811)), new Pair.ptr(new $Int64(0, 3617), new $Int64(0, 1077)), new Pair.ptr(new $Int64(0, 3623), new $Int64(0, 2467)), new Pair.ptr(new $Int64(0, 3631), new $Int64(0, 2005)), new Pair.ptr(new $Int64(0, 3637), new $Int64(0, 2939)), new Pair.ptr(new $Int64(0, 3643), new $Int64(0, 3459)), new Pair.ptr(new $Int64(0, 3659), new $Int64(0, 817)), new Pair.ptr(new $Int64(0, 3671), new $Int64(0, 933)), new Pair.ptr(new $Int64(0, 3673), new $Int64(0, 2705)), new Pair.ptr(new $Int64(0, 3677), new $Int64(0, 2364)), new Pair.ptr(new $Int64(0, 3691), new $Int64(0, 318)), new Pair.ptr(new $Int64(0, 3697), new $Int64(0, 910)), new Pair.ptr(new $Int64(0, 3701), new $Int64(0, 2585)), new Pair.ptr(new $Int64(0, 3709), new $Int64(0, 2142)), new Pair.ptr(new $Int64(0, 3719), new $Int64(0, 2010)), new Pair.ptr(new $Int64(0, 3727), new $Int64(0, 492)), new Pair.ptr(new $Int64(0, 3733), new $Int64(0, 1636)), new Pair.ptr(new $Int64(0, 3739), new $Int64(0, 3335)), new Pair.ptr(new $Int64(0, 3761), new $Int64(0, 2610)), new Pair.ptr(new $Int64(0, 3767), new $Int64(0, 1768)), new Pair.ptr(new $Int64(0, 3769), new $Int64(0, 3406)), new Pair.ptr(new $Int64(0, 3779), new $Int64(0, 1361)), new Pair.ptr(new $Int64(0, 3793), new $Int64(0, 607)), new Pair.ptr(new $Int64(0, 3797), new $Int64(0, 738)), new Pair.ptr(new $Int64(0, 3803), new $Int64(0, 1957)), new Pair.ptr(new $Int64(0, 3821), new $Int64(0, 2310)), new Pair.ptr(new $Int64(0, 3823), new $Int64(0, 1199)), new Pair.ptr(new $Int64(0, 3833), new $Int64(0, 727)), new Pair.ptr(new $Int64(0, 3847), new $Int64(0, 896)), new Pair.ptr(new $Int64(0, 3851), new $Int64(0, 469)), new Pair.ptr(new $Int64(0, 3853), new $Int64(0, 3005)), new Pair.ptr(new $Int64(0, 3863), new $Int64(0, 2642)), new Pair.ptr(new $Int64(0, 3877), new $Int64(0, 3009)), new Pair.ptr(new $Int64(0, 3881), new $Int64(0, 2418)), new Pair.ptr(new $Int64(0, 3889), new $Int64(0, 1568)), new Pair.ptr(new $Int64(0, 3907), new $Int64(0, 627)), new Pair.ptr(new $Int64(0, 3911), new $Int64(0, 1877)), new Pair.ptr(new $Int64(0, 3917), new $Int64(0, 2937)), new Pair.ptr(new $Int64(0, 3919), new $Int64(0, 3106)), new Pair.ptr(new $Int64(0, 3923), new $Int64(0, 2152)), new Pair.ptr(new $Int64(0, 3929), new $Int64(0, 578)), new Pair.ptr(new $Int64(0, 3931), new $Int64(0, 429)), new Pair.ptr(new $Int64(0, 3943), new $Int64(0, 3734)), new Pair.ptr(new $Int64(0, 3947), new $Int64(0, 2509)), new Pair.ptr(new $Int64(0, 3967), new $Int64(0, 1669)), new Pair.ptr(new $Int64(0, 3989), new $Int64(0, 3466)), new Pair.ptr(new $Int64(0, 4001), new $Int64(0, 3512)), new Pair.ptr(new $Int64(0, 4003), new $Int64(0, 3069)), new Pair.ptr(new $Int64(0, 4007), new $Int64(0, 1024)), new Pair.ptr(new $Int64(0, 4013), new $Int64(0, 2928)), new Pair.ptr(new $Int64(0, 4019), new $Int64(0, 259)), new Pair.ptr(new $Int64(0, 4021), new $Int64(0, 954)), new Pair.ptr(new $Int64(0, 4027), new $Int64(0, 2352)), new Pair.ptr(new $Int64(0, 4049), new $Int64(0, 4046)), new Pair.ptr(new $Int64(0, 4051), new $Int64(0, 2761)), new Pair.ptr(new $Int64(0, 4057), new $Int64(0, 569)), new Pair.ptr(new $Int64(0, 4073), new $Int64(0, 1155)), new Pair.ptr(new $Int64(0, 4079), new $Int64(0, 3207)), new Pair.ptr(new $Int64(0, 4091), new $Int64(0, 1569)), new Pair.ptr(new $Int64(0, 4093), new $Int64(0, 3000)), new Pair.ptr(new $Int64(0, 4099), new $Int64(0, 3738)), new Pair.ptr(new $Int64(0, 4111), new $Int64(0, 1346)), new Pair.ptr(new $Int64(0, 4127), new $Int64(0, 2106)), new Pair.ptr(new $Int64(0, 4129), new $Int64(0, 2168)), new Pair.ptr(new $Int64(0, 4133), new $Int64(0, 4023)), new Pair.ptr(new $Int64(0, 4139), new $Int64(0, 4046)), new Pair.ptr(new $Int64(0, 4153), new $Int64(0, 1428)), new Pair.ptr(new $Int64(0, 4157), new $Int64(0, 48)), new Pair.ptr(new $Int64(0, 4159), new $Int64(0, 4015)), new Pair.ptr(new $Int64(0, 4177), new $Int64(0, 1604)), new Pair.ptr(new $Int64(0, 4201), new $Int64(0, 1792)), new Pair.ptr(new $Int64(0, 4211), new $Int64(0, 3954)), new Pair.ptr(new $Int64(0, 4217), new $Int64(0, 1896)), new Pair.ptr(new $Int64(0, 4219), new $Int64(0, 2014)), new Pair.ptr(new $Int64(0, 4229), new $Int64(0, 2424)), new Pair.ptr(new $Int64(0, 4231), new $Int64(0, 1529)), new Pair.ptr(new $Int64(0, 4241), new $Int64(0, 2816)), new Pair.ptr(new $Int64(0, 4243), new $Int64(0, 2028)), new Pair.ptr(new $Int64(0, 4253), new $Int64(0, 78)), new Pair.ptr(new $Int64(0, 4259), new $Int64(0, 3891)), new Pair.ptr(new $Int64(0, 4261), new $Int64(0, 3731)), new Pair.ptr(new $Int64(0, 4271), new $Int64(0, 3701)), new Pair.ptr(new $Int64(0, 4273), new $Int64(0, 2720)), new Pair.ptr(new $Int64(0, 4283), new $Int64(0, 3693)), new Pair.ptr(new $Int64(0, 4289), new $Int64(0, 1685)), new Pair.ptr(new $Int64(0, 4297), new $Int64(0, 285)), new Pair.ptr(new $Int64(0, 4327), new $Int64(0, 1466)), new Pair.ptr(new $Int64(0, 4337), new $Int64(0, 3813)), new Pair.ptr(new $Int64(0, 4339), new $Int64(0, 1148)), new Pair.ptr(new $Int64(0, 4349), new $Int64(0, 3088)), new Pair.ptr(new $Int64(0, 4357), new $Int64(0, 857)), new Pair.ptr(new $Int64(0, 4363), new $Int64(0, 2713)), new Pair.ptr(new $Int64(0, 4373), new $Int64(0, 3562)), new Pair.ptr(new $Int64(0, 4391), new $Int64(0, 3669)), new Pair.ptr(new $Int64(0, 4397), new $Int64(0, 4193)), new Pair.ptr(new $Int64(0, 4409), new $Int64(0, 4278)), new Pair.ptr(new $Int64(0, 4421), new $Int64(0, 1732)), new Pair.ptr(new $Int64(0, 4423), new $Int64(0, 4056)), new Pair.ptr(new $Int64(0, 4441), new $Int64(0, 417)), new Pair.ptr(new $Int64(0, 4447), new $Int64(0, 436)), new Pair.ptr(new $Int64(0, 4451), new $Int64(0, 1796)), new Pair.ptr(new $Int64(0, 4457), new $Int64(0, 2605)), new Pair.ptr(new $Int64(0, 4463), new $Int64(0, 4381)), new Pair.ptr(new $Int64(0, 4481), new $Int64(0, 1995)), new Pair.ptr(new $Int64(0, 4483), new $Int64(0, 1874)), new Pair.ptr(new $Int64(0, 4493), new $Int64(0, 630)), new Pair.ptr(new $Int64(0, 4507), new $Int64(0, 2907)), new Pair.ptr(new $Int64(0, 4513), new $Int64(0, 73)), new Pair.ptr(new $Int64(0, 4517), new $Int64(0, 2525)), new Pair.ptr(new $Int64(0, 4519), new $Int64(0, 3884)), new Pair.ptr(new $Int64(0, 4523), new $Int64(0, 981)), new Pair.ptr(new $Int64(0, 4547), new $Int64(0, 333)), new Pair.ptr(new $Int64(0, 4549), new $Int64(0, 2309)), new Pair.ptr(new $Int64(0, 4561), new $Int64(0, 1335)), new Pair.ptr(new $Int64(0, 4567), new $Int64(0, 1561)), new Pair.ptr(new $Int64(0, 4583), new $Int64(0, 424)), new Pair.ptr(new $Int64(0, 4591), new $Int64(0, 274)), new Pair.ptr(new $Int64(0, 4597), new $Int64(0, 2360)), new Pair.ptr(new $Int64(0, 4603), new $Int64(0, 2968)), new Pair.ptr(new $Int64(0, 4621), new $Int64(0, 1955)), new Pair.ptr(new $Int64(0, 4637), new $Int64(0, 577)), new Pair.ptr(new $Int64(0, 4639), new $Int64(0, 2620)), new Pair.ptr(new $Int64(0, 4643), new $Int64(0, 3688)), new Pair.ptr(new $Int64(0, 4649), new $Int64(0, 1153)), new Pair.ptr(new $Int64(0, 4651), new $Int64(0, 4299)), new Pair.ptr(new $Int64(0, 4657), new $Int64(0, 2435)), new Pair.ptr(new $Int64(0, 4663), new $Int64(0, 2832)), new Pair.ptr(new $Int64(0, 4673), new $Int64(0, 919)), new Pair.ptr(new $Int64(0, 4679), new $Int64(0, 790)), new Pair.ptr(new $Int64(0, 4691), new $Int64(0, 4475)), new Pair.ptr(new $Int64(0, 4703), new $Int64(0, 717)), new Pair.ptr(new $Int64(0, 4721), new $Int64(0, 2116)), new Pair.ptr(new $Int64(0, 4723), new $Int64(0, 4626)), new Pair.ptr(new $Int64(0, 4729), new $Int64(0, 1113)), new Pair.ptr(new $Int64(0, 4733), new $Int64(0, 588)), new Pair.ptr(new $Int64(0, 4751), new $Int64(0, 4041)), new Pair.ptr(new $Int64(0, 4759), new $Int64(0, 1542)), new Pair.ptr(new $Int64(0, 4783), new $Int64(0, 4195)), new Pair.ptr(new $Int64(0, 4787), new $Int64(0, 3679)), new Pair.ptr(new $Int64(0, 4789), new $Int64(0, 3225)), new Pair.ptr(new $Int64(0, 4793), new $Int64(0, 3217)), new Pair.ptr(new $Int64(0, 4799), new $Int64(0, 1026)), new Pair.ptr(new $Int64(0, 4801), new $Int64(0, 2729)), new Pair.ptr(new $Int64(0, 4813), new $Int64(0, 4273)), new Pair.ptr(new $Int64(0, 4817), new $Int64(0, 3364)), new Pair.ptr(new $Int64(0, 4831), new $Int64(0, 1630)), new Pair.ptr(new $Int64(0, 4861), new $Int64(0, 2581)), new Pair.ptr(new $Int64(0, 4871), new $Int64(0, 1710)), new Pair.ptr(new $Int64(0, 4877), new $Int64(0, 3345)), new Pair.ptr(new $Int64(0, 4889), new $Int64(0, 4817)), new Pair.ptr(new $Int64(0, 4903), new $Int64(0, 2101)), new Pair.ptr(new $Int64(0, 4909), new $Int64(0, 4012)), new Pair.ptr(new $Int64(0, 4919), new $Int64(0, 4521)), new Pair.ptr(new $Int64(0, 4931), new $Int64(0, 236)), new Pair.ptr(new $Int64(0, 4933), new $Int64(0, 511)), new Pair.ptr(new $Int64(0, 4937), new $Int64(0, 602)), new Pair.ptr(new $Int64(0, 4943), new $Int64(0, 2714)), new Pair.ptr(new $Int64(0, 4951), new $Int64(0, 340)), new Pair.ptr(new $Int64(0, 4957), new $Int64(0, 3352)), new Pair.ptr(new $Int64(0, 4967), new $Int64(0, 659)), new Pair.ptr(new $Int64(0, 4969), new $Int64(0, 3721)), new Pair.ptr(new $Int64(0, 4973), new $Int64(0, 4319)), new Pair.ptr(new $Int64(0, 4987), new $Int64(0, 1443)), new Pair.ptr(new $Int64(0, 4993), new $Int64(0, 1647)), new Pair.ptr(new $Int64(0, 4999), new $Int64(0, 4756)), new Pair.ptr(new $Int64(0, 5003), new $Int64(0, 1355)), new Pair.ptr(new $Int64(0, 5009), new $Int64(0, 887)), new Pair.ptr(new $Int64(0, 5011), new $Int64(0, 4837)), new Pair.ptr(new $Int64(0, 5021), new $Int64(0, 693)), new Pair.ptr(new $Int64(0, 5023), new $Int64(0, 3151)), new Pair.ptr(new $Int64(0, 5039), new $Int64(0, 4440)), new Pair.ptr(new $Int64(0, 5051), new $Int64(0, 1917)), new Pair.ptr(new $Int64(0, 5059), new $Int64(0, 4290)), new Pair.ptr(new $Int64(0, 5077), new $Int64(0, 4128)), new Pair.ptr(new $Int64(0, 5081), new $Int64(0, 2521)), new Pair.ptr(new $Int64(0, 5087), new $Int64(0, 990)), new Pair.ptr(new $Int64(0, 5099), new $Int64(0, 1164)), new Pair.ptr(new $Int64(0, 5101), new $Int64(0, 507)), new Pair.ptr(new $Int64(0, 5107), new $Int64(0, 2493)), new Pair.ptr(new $Int64(0, 5113), new $Int64(0, 144)), new Pair.ptr(new $Int64(0, 5119), new $Int64(0, 58)), new Pair.ptr(new $Int64(0, 5147), new $Int64(0, 3750)), new Pair.ptr(new $Int64(0, 5153), new $Int64(0, 1487)), new Pair.ptr(new $Int64(0, 5167), new $Int64(0, 1317)), new Pair.ptr(new $Int64(0, 5171), new $Int64(0, 1198)), new Pair.ptr(new $Int64(0, 5179), new $Int64(0, 3000)), new Pair.ptr(new $Int64(0, 5189), new $Int64(0, 3249)), new Pair.ptr(new $Int64(0, 5197), new $Int64(0, 150)), new Pair.ptr(new $Int64(0, 5209), new $Int64(0, 1814)), new Pair.ptr(new $Int64(0, 5227), new $Int64(0, 207)), new Pair.ptr(new $Int64(0, 5231), new $Int64(0, 786)), new Pair.ptr(new $Int64(0, 5233), new $Int64(0, 1883)), new Pair.ptr(new $Int64(0, 5237), new $Int64(0, 3639)), new Pair.ptr(new $Int64(0, 5261), new $Int64(0, 3128)), new Pair.ptr(new $Int64(0, 5273), new $Int64(0, 4677)), new Pair.ptr(new $Int64(0, 5279), new $Int64(0, 5047)), new Pair.ptr(new $Int64(0, 5281), new $Int64(0, 3598)), new Pair.ptr(new $Int64(0, 5297), new $Int64(0, 3133)), new Pair.ptr(new $Int64(0, 5303), new $Int64(0, 978)), new Pair.ptr(new $Int64(0, 5309), new $Int64(0, 5138)), new Pair.ptr(new $Int64(0, 5323), new $Int64(0, 4198)), new Pair.ptr(new $Int64(0, 5333), new $Int64(0, 2426)), new Pair.ptr(new $Int64(0, 5347), new $Int64(0, 1654)), new Pair.ptr(new $Int64(0, 5351), new $Int64(0, 4840)), new Pair.ptr(new $Int64(0, 5381), new $Int64(0, 4511)), new Pair.ptr(new $Int64(0, 5387), new $Int64(0, 1600)), new Pair.ptr(new $Int64(0, 5393), new $Int64(0, 1233)), new Pair.ptr(new $Int64(0, 5399), new $Int64(0, 1219)), new Pair.ptr(new $Int64(0, 5407), new $Int64(0, 1470)), new Pair.ptr(new $Int64(0, 5413), new $Int64(0, 2183)), new Pair.ptr(new $Int64(0, 5417), new $Int64(0, 2468)), new Pair.ptr(new $Int64(0, 5419), new $Int64(0, 4644)), new Pair.ptr(new $Int64(0, 5431), new $Int64(0, 2375)), new Pair.ptr(new $Int64(0, 5437), new $Int64(0, 548)), new Pair.ptr(new $Int64(0, 5441), new $Int64(0, 2330)), new Pair.ptr(new $Int64(0, 5443), new $Int64(0, 3129)), new Pair.ptr(new $Int64(0, 5449), new $Int64(0, 3400)), new Pair.ptr(new $Int64(0, 5471), new $Int64(0, 3052)), new Pair.ptr(new $Int64(0, 5477), new $Int64(0, 4818)), new Pair.ptr(new $Int64(0, 5479), new $Int64(0, 4627)), new Pair.ptr(new $Int64(0, 5483), new $Int64(0, 3435)), new Pair.ptr(new $Int64(0, 5501), new $Int64(0, 2287)), new Pair.ptr(new $Int64(0, 5503), new $Int64(0, 1495)), new Pair.ptr(new $Int64(0, 5507), new $Int64(0, 4788)), new Pair.ptr(new $Int64(0, 5519), new $Int64(0, 3865)), new Pair.ptr(new $Int64(0, 5521), new $Int64(0, 1263)), new Pair.ptr(new $Int64(0, 5527), new $Int64(0, 2756)), new Pair.ptr(new $Int64(0, 5531), new $Int64(0, 5315)), new Pair.ptr(new $Int64(0, 5557), new $Int64(0, 388)), new Pair.ptr(new $Int64(0, 5563), new $Int64(0, 4554)), new Pair.ptr(new $Int64(0, 5569), new $Int64(0, 4582)), new Pair.ptr(new $Int64(0, 5573), new $Int64(0, 5369)), new Pair.ptr(new $Int64(0, 5581), new $Int64(0, 1759)), new Pair.ptr(new $Int64(0, 5591), new $Int64(0, 4169)), new Pair.ptr(new $Int64(0, 5623), new $Int64(0, 1786)), new Pair.ptr(new $Int64(0, 5639), new $Int64(0, 3335)), new Pair.ptr(new $Int64(0, 5641), new $Int64(0, 2812)), new Pair.ptr(new $Int64(0, 5647), new $Int64(0, 1665)), new Pair.ptr(new $Int64(0, 5651), new $Int64(0, 39)), new Pair.ptr(new $Int64(0, 5653), new $Int64(0, 4070)), new Pair.ptr(new $Int64(0, 5657), new $Int64(0, 5533)), new Pair.ptr(new $Int64(0, 5659), new $Int64(0, 751)), new Pair.ptr(new $Int64(0, 5669), new $Int64(0, 3340)), new Pair.ptr(new $Int64(0, 5683), new $Int64(0, 3284)), new Pair.ptr(new $Int64(0, 5689), new $Int64(0, 4317)), new Pair.ptr(new $Int64(0, 5693), new $Int64(0, 4950)), new Pair.ptr(new $Int64(0, 5701), new $Int64(0, 2429)), new Pair.ptr(new $Int64(0, 5711), new $Int64(0, 3203)), new Pair.ptr(new $Int64(0, 5717), new $Int64(0, 363)), new Pair.ptr(new $Int64(0, 5737), new $Int64(0, 1607)), new Pair.ptr(new $Int64(0, 5741), new $Int64(0, 5025)), new Pair.ptr(new $Int64(0, 5743), new $Int64(0, 975)), new Pair.ptr(new $Int64(0, 5749), new $Int64(0, 236)), new Pair.ptr(new $Int64(0, 5779), new $Int64(0, 3209)), new Pair.ptr(new $Int64(0, 5783), new $Int64(0, 5359)), new Pair.ptr(new $Int64(0, 5791), new $Int64(0, 2544)), new Pair.ptr(new $Int64(0, 5801), new $Int64(0, 989)), new Pair.ptr(new $Int64(0, 5807), new $Int64(0, 2476)), new Pair.ptr(new $Int64(0, 5813), new $Int64(0, 1390)), new Pair.ptr(new $Int64(0, 5821), new $Int64(0, 3963)), new Pair.ptr(new $Int64(0, 5827), new $Int64(0, 2990)), new Pair.ptr(new $Int64(0, 5839), new $Int64(0, 5596)), new Pair.ptr(new $Int64(0, 5843), new $Int64(0, 561)), new Pair.ptr(new $Int64(0, 5849), new $Int64(0, 95)), new Pair.ptr(new $Int64(0, 5851), new $Int64(0, 5566)), new Pair.ptr(new $Int64(0, 5857), new $Int64(0, 3355)), new Pair.ptr(new $Int64(0, 5861), new $Int64(0, 3555)), new Pair.ptr(new $Int64(0, 5867), new $Int64(0, 5523)), new Pair.ptr(new $Int64(0, 5869), new $Int64(0, 3108)), new Pair.ptr(new $Int64(0, 5879), new $Int64(0, 3289)), new Pair.ptr(new $Int64(0, 5881), new $Int64(0, 2303)), new Pair.ptr(new $Int64(0, 5897), new $Int64(0, 3806)), new Pair.ptr(new $Int64(0, 5903), new $Int64(0, 4049)), new Pair.ptr(new $Int64(0, 5923), new $Int64(0, 760)), new Pair.ptr(new $Int64(0, 5927), new $Int64(0, 739)), new Pair.ptr(new $Int64(0, 5939), new $Int64(0, 359)), new Pair.ptr(new $Int64(0, 5953), new $Int64(0, 4622)), new Pair.ptr(new $Int64(0, 5981), new $Int64(0, 945)), new Pair.ptr(new $Int64(0, 5987), new $Int64(0, 3734)), new Pair.ptr(new $Int64(0, 6007), new $Int64(0, 901)), new Pair.ptr(new $Int64(0, 6011), new $Int64(0, 5470)), new Pair.ptr(new $Int64(0, 6029), new $Int64(0, 2215)), new Pair.ptr(new $Int64(0, 6037), new $Int64(0, 2074)), new Pair.ptr(new $Int64(0, 6043), new $Int64(0, 2997)), new Pair.ptr(new $Int64(0, 6047), new $Int64(0, 1497)), new Pair.ptr(new $Int64(0, 6053), new $Int64(0, 2814)), new Pair.ptr(new $Int64(0, 6067), new $Int64(0, 5883)), new Pair.ptr(new $Int64(0, 6073), new $Int64(0, 3884)), new Pair.ptr(new $Int64(0, 6079), new $Int64(0, 4909)), new Pair.ptr(new $Int64(0, 6089), new $Int64(0, 3481)), new Pair.ptr(new $Int64(0, 6091), new $Int64(0, 756)), new Pair.ptr(new $Int64(0, 6101), new $Int64(0, 5462)), new Pair.ptr(new $Int64(0, 6113), new $Int64(0, 677)), new Pair.ptr(new $Int64(0, 6121), new $Int64(0, 3143)), new Pair.ptr(new $Int64(0, 6131), new $Int64(0, 3117)), new Pair.ptr(new $Int64(0, 6133), new $Int64(0, 862)), new Pair.ptr(new $Int64(0, 6143), new $Int64(0, 1047)), new Pair.ptr(new $Int64(0, 6151), new $Int64(0, 1805)), new Pair.ptr(new $Int64(0, 6163), new $Int64(0, 4214)), new Pair.ptr(new $Int64(0, 6173), new $Int64(0, 4578)), new Pair.ptr(new $Int64(0, 6197), new $Int64(0, 1254)), new Pair.ptr(new $Int64(0, 6199), new $Int64(0, 2857)), new Pair.ptr(new $Int64(0, 6203), new $Int64(0, 1302)), new Pair.ptr(new $Int64(0, 6211), new $Int64(0, 4531)), new Pair.ptr(new $Int64(0, 6217), new $Int64(0, 4704)), new Pair.ptr(new $Int64(0, 6221), new $Int64(0, 2866)), new Pair.ptr(new $Int64(0, 6229), new $Int64(0, 4817)), new Pair.ptr(new $Int64(0, 6247), new $Int64(0, 1611)), new Pair.ptr(new $Int64(0, 6257), new $Int64(0, 5301)), new Pair.ptr(new $Int64(0, 6263), new $Int64(0, 4127)), new Pair.ptr(new $Int64(0, 6269), new $Int64(0, 3324)), new Pair.ptr(new $Int64(0, 6271), new $Int64(0, 155)), new Pair.ptr(new $Int64(0, 6277), new $Int64(0, 3003)), new Pair.ptr(new $Int64(0, 6287), new $Int64(0, 3874)), new Pair.ptr(new $Int64(0, 6299), new $Int64(0, 5352)), new Pair.ptr(new $Int64(0, 6301), new $Int64(0, 2137)), new Pair.ptr(new $Int64(0, 6311), new $Int64(0, 2991)), new Pair.ptr(new $Int64(0, 6317), new $Int64(0, 521)), new Pair.ptr(new $Int64(0, 6323), new $Int64(0, 5951)), new Pair.ptr(new $Int64(0, 6329), new $Int64(0, 773)), new Pair.ptr(new $Int64(0, 6337), new $Int64(0, 1142)), new Pair.ptr(new $Int64(0, 6343), new $Int64(0, 703)), new Pair.ptr(new $Int64(0, 6353), new $Int64(0, 3604)), new Pair.ptr(new $Int64(0, 6359), new $Int64(0, 6232)), new Pair.ptr(new $Int64(0, 6361), new $Int64(0, 5681)), new Pair.ptr(new $Int64(0, 6367), new $Int64(0, 6158)), new Pair.ptr(new $Int64(0, 6373), new $Int64(0, 692)), new Pair.ptr(new $Int64(0, 6379), new $Int64(0, 2325)), new Pair.ptr(new $Int64(0, 6389), new $Int64(0, 2443)), new Pair.ptr(new $Int64(0, 6397), new $Int64(0, 4428)), new Pair.ptr(new $Int64(0, 6421), new $Int64(0, 991)), new Pair.ptr(new $Int64(0, 6427), new $Int64(0, 3773)), new Pair.ptr(new $Int64(0, 6449), new $Int64(0, 5684)), new Pair.ptr(new $Int64(0, 6451), new $Int64(0, 6343)), new Pair.ptr(new $Int64(0, 6469), new $Int64(0, 5623)), new Pair.ptr(new $Int64(0, 6473), new $Int64(0, 4073)), new Pair.ptr(new $Int64(0, 6481), new $Int64(0, 6086)), new Pair.ptr(new $Int64(0, 6491), new $Int64(0, 4357)), new Pair.ptr(new $Int64(0, 6521), new $Int64(0, 5496)), new Pair.ptr(new $Int64(0, 6529), new $Int64(0, 480)), new Pair.ptr(new $Int64(0, 6547), new $Int64(0, 619)), new Pair.ptr(new $Int64(0, 6551), new $Int64(0, 3216)), new Pair.ptr(new $Int64(0, 6553), new $Int64(0, 2502)), new Pair.ptr(new $Int64(0, 6563), new $Int64(0, 499)), new Pair.ptr(new $Int64(0, 6569), new $Int64(0, 822)), new Pair.ptr(new $Int64(0, 6571), new $Int64(0, 3100)), new Pair.ptr(new $Int64(0, 6577), new $Int64(0, 3774)), new Pair.ptr(new $Int64(0, 6581), new $Int64(0, 3045)), new Pair.ptr(new $Int64(0, 6599), new $Int64(0, 1958)), new Pair.ptr(new $Int64(0, 6607), new $Int64(0, 4377)), new Pair.ptr(new $Int64(0, 6619), new $Int64(0, 3120)), new Pair.ptr(new $Int64(0, 6637), new $Int64(0, 2121)), new Pair.ptr(new $Int64(0, 6653), new $Int64(0, 4708)), new Pair.ptr(new $Int64(0, 6659), new $Int64(0, 2039)), new Pair.ptr(new $Int64(0, 6661), new $Int64(0, 6631)), new Pair.ptr(new $Int64(0, 6673), new $Int64(0, 5561)), new Pair.ptr(new $Int64(0, 6679), new $Int64(0, 1637)), new Pair.ptr(new $Int64(0, 6689), new $Int64(0, 6096)), new Pair.ptr(new $Int64(0, 6691), new $Int64(0, 1031)), new Pair.ptr(new $Int64(0, 6701), new $Int64(0, 2893)), new Pair.ptr(new $Int64(0, 6703), new $Int64(0, 4908)), new Pair.ptr(new $Int64(0, 6709), new $Int64(0, 3459)), new Pair.ptr(new $Int64(0, 6719), new $Int64(0, 188)), new Pair.ptr(new $Int64(0, 6733), new $Int64(0, 5009)), new Pair.ptr(new $Int64(0, 6737), new $Int64(0, 2181)), new Pair.ptr(new $Int64(0, 6761), new $Int64(0, 2078)), new Pair.ptr(new $Int64(0, 6763), new $Int64(0, 2996)), new Pair.ptr(new $Int64(0, 6779), new $Int64(0, 2306)), new Pair.ptr(new $Int64(0, 6781), new $Int64(0, 5084)), new Pair.ptr(new $Int64(0, 6791), new $Int64(0, 4460)), new Pair.ptr(new $Int64(0, 6793), new $Int64(0, 2709)), new Pair.ptr(new $Int64(0, 6803), new $Int64(0, 2393)), new Pair.ptr(new $Int64(0, 6823), new $Int64(0, 504)), new Pair.ptr(new $Int64(0, 6827), new $Int64(0, 3685)), new Pair.ptr(new $Int64(0, 6829), new $Int64(0, 485)), new Pair.ptr(new $Int64(0, 6833), new $Int64(0, 825)), new Pair.ptr(new $Int64(0, 6841), new $Int64(0, 4572)), new Pair.ptr(new $Int64(0, 6857), new $Int64(0, 4590)), new Pair.ptr(new $Int64(0, 6863), new $Int64(0, 2157)), new Pair.ptr(new $Int64(0, 6869), new $Int64(0, 314)), new Pair.ptr(new $Int64(0, 6871), new $Int64(0, 1879)), new Pair.ptr(new $Int64(0, 6883), new $Int64(0, 2836)), new Pair.ptr(new $Int64(0, 6899), new $Int64(0, 4635)), new Pair.ptr(new $Int64(0, 6907), new $Int64(0, 5007)), new Pair.ptr(new $Int64(0, 6911), new $Int64(0, 5533)), new Pair.ptr(new $Int64(0, 6917), new $Int64(0, 4758)), new Pair.ptr(new $Int64(0, 6947), new $Int64(0, 2334)), new Pair.ptr(new $Int64(0, 6949), new $Int64(0, 3791)), new Pair.ptr(new $Int64(0, 6959), new $Int64(0, 3198)), new Pair.ptr(new $Int64(0, 6961), new $Int64(0, 3623)), new Pair.ptr(new $Int64(0, 6967), new $Int64(0, 2437)), new Pair.ptr(new $Int64(0, 6971), new $Int64(0, 5104)), new Pair.ptr(new $Int64(0, 6977), new $Int64(0, 5444)), new Pair.ptr(new $Int64(0, 6983), new $Int64(0, 1239)), new Pair.ptr(new $Int64(0, 6991), new $Int64(0, 5327)), new Pair.ptr(new $Int64(0, 6997), new $Int64(0, 5067)), new Pair.ptr(new $Int64(0, 7001), new $Int64(0, 6544)), new Pair.ptr(new $Int64(0, 7013), new $Int64(0, 5250)), new Pair.ptr(new $Int64(0, 7019), new $Int64(0, 2598)), new Pair.ptr(new $Int64(0, 7027), new $Int64(0, 1584)), new Pair.ptr(new $Int64(0, 7039), new $Int64(0, 5853)), new Pair.ptr(new $Int64(0, 7043), new $Int64(0, 6699)), new Pair.ptr(new $Int64(0, 7057), new $Int64(0, 1589)), new Pair.ptr(new $Int64(0, 7069), new $Int64(0, 1067)), new Pair.ptr(new $Int64(0, 7079), new $Int64(0, 4222)), new Pair.ptr(new $Int64(0, 7103), new $Int64(0, 6270)), new Pair.ptr(new $Int64(0, 7109), new $Int64(0, 1930)), new Pair.ptr(new $Int64(0, 7121), new $Int64(0, 7083)), new Pair.ptr(new $Int64(0, 7127), new $Int64(0, 2099)), new Pair.ptr(new $Int64(0, 7129), new $Int64(0, 4199)), new Pair.ptr(new $Int64(0, 7151), new $Int64(0, 2639)), new Pair.ptr(new $Int64(0, 7159), new $Int64(0, 5445)), new Pair.ptr(new $Int64(0, 7177), new $Int64(0, 1193)), new Pair.ptr(new $Int64(0, 7187), new $Int64(0, 5344)), new Pair.ptr(new $Int64(0, 7193), new $Int64(0, 2320)), new Pair.ptr(new $Int64(0, 7207), new $Int64(0, 721)), new Pair.ptr(new $Int64(0, 7211), new $Int64(0, 2391)), new Pair.ptr(new $Int64(0, 7213), new $Int64(0, 3507)), new Pair.ptr(new $Int64(0, 7219), new $Int64(0, 208)), new Pair.ptr(new $Int64(0, 7229), new $Int64(0, 5949)), new Pair.ptr(new $Int64(0, 7237), new $Int64(0, 7135)), new Pair.ptr(new $Int64(0, 7243), new $Int64(0, 611)), new Pair.ptr(new $Int64(0, 7247), new $Int64(0, 5204)), new Pair.ptr(new $Int64(0, 7253), new $Int64(0, 2727)), new Pair.ptr(new $Int64(0, 7283), new $Int64(0, 3384)), new Pair.ptr(new $Int64(0, 7297), new $Int64(0, 3655)), new Pair.ptr(new $Int64(0, 7307), new $Int64(0, 3674)), new Pair.ptr(new $Int64(0, 7309), new $Int64(0, 4002)), new Pair.ptr(new $Int64(0, 7321), new $Int64(0, 6926)), new Pair.ptr(new $Int64(0, 7331), new $Int64(0, 7074)), new Pair.ptr(new $Int64(0, 7333), new $Int64(0, 3895)), new Pair.ptr(new $Int64(0, 7349), new $Int64(0, 681)), new Pair.ptr(new $Int64(0, 7351), new $Int64(0, 5616)), new Pair.ptr(new $Int64(0, 7369), new $Int64(0, 6674)), new Pair.ptr(new $Int64(0, 7393), new $Int64(0, 4322)), new Pair.ptr(new $Int64(0, 7411), new $Int64(0, 24)), new Pair.ptr(new $Int64(0, 7417), new $Int64(0, 3478)), new Pair.ptr(new $Int64(0, 7433), new $Int64(0, 1640)), new Pair.ptr(new $Int64(0, 7451), new $Int64(0, 4525)), new Pair.ptr(new $Int64(0, 7457), new $Int64(0, 4716)), new Pair.ptr(new $Int64(0, 7459), new $Int64(0, 1586)), new Pair.ptr(new $Int64(0, 7477), new $Int64(0, 1762)), new Pair.ptr(new $Int64(0, 7481), new $Int64(0, 6193)), new Pair.ptr(new $Int64(0, 7487), new $Int64(0, 6962)), new Pair.ptr(new $Int64(0, 7489), new $Int64(0, 3618)), new Pair.ptr(new $Int64(0, 7499), new $Int64(0, 5128)), new Pair.ptr(new $Int64(0, 7507), new $Int64(0, 4692)), new Pair.ptr(new $Int64(0, 7517), new $Int64(0, 6973)), new Pair.ptr(new $Int64(0, 7523), new $Int64(0, 91)), new Pair.ptr(new $Int64(0, 7529), new $Int64(0, 2123)), new Pair.ptr(new $Int64(0, 7537), new $Int64(0, 6531)), new Pair.ptr(new $Int64(0, 7541), new $Int64(0, 408)), new Pair.ptr(new $Int64(0, 7547), new $Int64(0, 5099)), new Pair.ptr(new $Int64(0, 7549), new $Int64(0, 5423)), new Pair.ptr(new $Int64(0, 7559), new $Int64(0, 6449)), new Pair.ptr(new $Int64(0, 7561), new $Int64(0, 3754)), new Pair.ptr(new $Int64(0, 7573), new $Int64(0, 5528)), new Pair.ptr(new $Int64(0, 7577), new $Int64(0, 6003)), new Pair.ptr(new $Int64(0, 7583), new $Int64(0, 747)), new Pair.ptr(new $Int64(0, 7589), new $Int64(0, 5942)), new Pair.ptr(new $Int64(0, 7591), new $Int64(0, 3858)), new Pair.ptr(new $Int64(0, 7603), new $Int64(0, 5548)), new Pair.ptr(new $Int64(0, 7607), new $Int64(0, 4353)), new Pair.ptr(new $Int64(0, 7621), new $Int64(0, 491)), new Pair.ptr(new $Int64(0, 7639), new $Int64(0, 6764)), new Pair.ptr(new $Int64(0, 7643), new $Int64(0, 2154)), new Pair.ptr(new $Int64(0, 7649), new $Int64(0, 598)), new Pair.ptr(new $Int64(0, 7669), new $Int64(0, 6283)), new Pair.ptr(new $Int64(0, 7673), new $Int64(0, 3341)), new Pair.ptr(new $Int64(0, 7681), new $Int64(0, 3146)), new Pair.ptr(new $Int64(0, 7687), new $Int64(0, 6421)), new Pair.ptr(new $Int64(0, 7691), new $Int64(0, 5708)), new Pair.ptr(new $Int64(0, 7699), new $Int64(0, 691)), new Pair.ptr(new $Int64(0, 7703), new $Int64(0, 1613)), new Pair.ptr(new $Int64(0, 7717), new $Int64(0, 1356)), new Pair.ptr(new $Int64(0, 7723), new $Int64(0, 2372)), new Pair.ptr(new $Int64(0, 7727), new $Int64(0, 5155)), new Pair.ptr(new $Int64(0, 7741), new $Int64(0, 259)), new Pair.ptr(new $Int64(0, 7753), new $Int64(0, 6097)), new Pair.ptr(new $Int64(0, 7757), new $Int64(0, 3383)), new Pair.ptr(new $Int64(0, 7759), new $Int64(0, 5289)), new Pair.ptr(new $Int64(0, 7789), new $Int64(0, 6428)), new Pair.ptr(new $Int64(0, 7793), new $Int64(0, 1735)), new Pair.ptr(new $Int64(0, 7817), new $Int64(0, 633)), new Pair.ptr(new $Int64(0, 7823), new $Int64(0, 3631)), new Pair.ptr(new $Int64(0, 7829), new $Int64(0, 2321)), new Pair.ptr(new $Int64(0, 7841), new $Int64(0, 7384)), new Pair.ptr(new $Int64(0, 7853), new $Int64(0, 5769)), new Pair.ptr(new $Int64(0, 7867), new $Int64(0, 398)), new Pair.ptr(new $Int64(0, 7873), new $Int64(0, 5688)), new Pair.ptr(new $Int64(0, 7877), new $Int64(0, 5560)), new Pair.ptr(new $Int64(0, 7879), new $Int64(0, 5725)), new Pair.ptr(new $Int64(0, 7883), new $Int64(0, 1379)), new Pair.ptr(new $Int64(0, 7901), new $Int64(0, 4524)), new Pair.ptr(new $Int64(0, 7907), new $Int64(0, 2072)), new Pair.ptr(new $Int64(0, 7919), new $Int64(0, 7658)), new Pair.ptr(new $Int64(0, 7927), new $Int64(0, 7255)), new Pair.ptr(new $Int64(0, 7933), new $Int64(0, 7249)), new Pair.ptr(new $Int64(0, 7937), new $Int64(0, 1729)), new Pair.ptr(new $Int64(0, 7949), new $Int64(0, 1491)), new Pair.ptr(new $Int64(0, 7951), new $Int64(0, 3199)), new Pair.ptr(new $Int64(0, 7963), new $Int64(0, 5580)), new Pair.ptr(new $Int64(0, 7993), new $Int64(0, 5080)), new Pair.ptr(new $Int64(0, 8009), new $Int64(0, 7475)), new Pair.ptr(new $Int64(0, 8011), new $Int64(0, 178)), new Pair.ptr(new $Int64(0, 8017), new $Int64(0, 772)), new Pair.ptr(new $Int64(0, 8039), new $Int64(0, 1020)), new Pair.ptr(new $Int64(0, 8053), new $Int64(0, 6168)), new Pair.ptr(new $Int64(0, 8059), new $Int64(0, 6995)), new Pair.ptr(new $Int64(0, 8069), new $Int64(0, 6076)), new Pair.ptr(new $Int64(0, 8081), new $Int64(0, 6391)), new Pair.ptr(new $Int64(0, 8087), new $Int64(0, 1283)), new Pair.ptr(new $Int64(0, 8089), new $Int64(0, 1225)), new Pair.ptr(new $Int64(0, 8093), new $Int64(0, 7344)), new Pair.ptr(new $Int64(0, 8101), new $Int64(0, 3403)), new Pair.ptr(new $Int64(0, 8111), new $Int64(0, 8090)), new Pair.ptr(new $Int64(0, 8117), new $Int64(0, 5178)), new Pair.ptr(new $Int64(0, 8123), new $Int64(0, 2411)), new Pair.ptr(new $Int64(0, 8147), new $Int64(0, 2786)), new Pair.ptr(new $Int64(0, 8161), new $Int64(0, 6351)), new Pair.ptr(new $Int64(0, 8167), new $Int64(0, 1380)), new Pair.ptr(new $Int64(0, 8171), new $Int64(0, 4799)), new Pair.ptr(new $Int64(0, 8179), new $Int64(0, 4174)), new Pair.ptr(new $Int64(0, 8191), new $Int64(0, 2420)), new Pair.ptr(new $Int64(0, 8209), new $Int64(0, 1522)), new Pair.ptr(new $Int64(0, 8219), new $Int64(0, 4438)), new Pair.ptr(new $Int64(0, 8221), new $Int64(0, 1778)), new Pair.ptr(new $Int64(0, 8231), new $Int64(0, 6228)), new Pair.ptr(new $Int64(0, 8233), new $Int64(0, 2798)), new Pair.ptr(new $Int64(0, 8237), new $Int64(0, 235)), new Pair.ptr(new $Int64(0, 8243), new $Int64(0, 6564)), new Pair.ptr(new $Int64(0, 8263), new $Int64(0, 5621)), new Pair.ptr(new $Int64(0, 8269), new $Int64(0, 1149)), new Pair.ptr(new $Int64(0, 8273), new $Int64(0, 6685)), new Pair.ptr(new $Int64(0, 8287), new $Int64(0, 1897)), new Pair.ptr(new $Int64(0, 8291), new $Int64(0, 8166)), new Pair.ptr(new $Int64(0, 8293), new $Int64(0, 1323)), new Pair.ptr(new $Int64(0, 8297), new $Int64(0, 1824)), new Pair.ptr(new $Int64(0, 8311), new $Int64(0, 1675)), new Pair.ptr(new $Int64(0, 8317), new $Int64(0, 8125)), new Pair.ptr(new $Int64(0, 8329), new $Int64(0, 1927)), new Pair.ptr(new $Int64(0, 8353), new $Int64(0, 3982)), new Pair.ptr(new $Int64(0, 8363), new $Int64(0, 5657)), new Pair.ptr(new $Int64(0, 8369), new $Int64(0, 6281)), new Pair.ptr(new $Int64(0, 8377), new $Int64(0, 1518)), new Pair.ptr(new $Int64(0, 8387), new $Int64(0, 388)), new Pair.ptr(new $Int64(0, 8389), new $Int64(0, 160)), new Pair.ptr(new $Int64(0, 8419), new $Int64(0, 7728)), new Pair.ptr(new $Int64(0, 8423), new $Int64(0, 7898)), new Pair.ptr(new $Int64(0, 8429), new $Int64(0, 3122)), new Pair.ptr(new $Int64(0, 8431), new $Int64(0, 4167)), new Pair.ptr(new $Int64(0, 8443), new $Int64(0, 6220)), new Pair.ptr(new $Int64(0, 8447), new $Int64(0, 3416)), new Pair.ptr(new $Int64(0, 8461), new $Int64(0, 2971)), new Pair.ptr(new $Int64(0, 8467), new $Int64(0, 2949)), new Pair.ptr(new $Int64(0, 8501), new $Int64(0, 392)), new Pair.ptr(new $Int64(0, 8513), new $Int64(0, 2278)), new Pair.ptr(new $Int64(0, 8521), new $Int64(0, 2775)), new Pair.ptr(new $Int64(0, 8527), new $Int64(0, 4976)), new Pair.ptr(new $Int64(0, 8537), new $Int64(0, 3446)), new Pair.ptr(new $Int64(0, 8539), new $Int64(0, 7096)), new Pair.ptr(new $Int64(0, 8543), new $Int64(0, 1072)), new Pair.ptr(new $Int64(0, 8563), new $Int64(0, 5145)), new Pair.ptr(new $Int64(0, 8573), new $Int64(0, 2187)), new Pair.ptr(new $Int64(0, 8581), new $Int64(0, 7968)), new Pair.ptr(new $Int64(0, 8597), new $Int64(0, 7116)), new Pair.ptr(new $Int64(0, 8599), new $Int64(0, 5140)), new Pair.ptr(new $Int64(0, 8609), new $Int64(0, 3838)), new Pair.ptr(new $Int64(0, 8623), new $Int64(0, 7606)), new Pair.ptr(new $Int64(0, 8627), new $Int64(0, 8509)), new Pair.ptr(new $Int64(0, 8629), new $Int64(0, 5673)), new Pair.ptr(new $Int64(0, 8641), new $Int64(0, 7700)), new Pair.ptr(new $Int64(0, 8647), new $Int64(0, 1392)), new Pair.ptr(new $Int64(0, 8663), new $Int64(0, 6747)), new Pair.ptr(new $Int64(0, 8669), new $Int64(0, 327)), new Pair.ptr(new $Int64(0, 8677), new $Int64(0, 4888)), new Pair.ptr(new $Int64(0, 8681), new $Int64(0, 1983)), new Pair.ptr(new $Int64(0, 8689), new $Int64(0, 5005)), new Pair.ptr(new $Int64(0, 8693), new $Int64(0, 8149)), new Pair.ptr(new $Int64(0, 8699), new $Int64(0, 3159)), new Pair.ptr(new $Int64(0, 8707), new $Int64(0, 4520)), new Pair.ptr(new $Int64(0, 8713), new $Int64(0, 2700)), new Pair.ptr(new $Int64(0, 8719), new $Int64(0, 4933)), new Pair.ptr(new $Int64(0, 8731), new $Int64(0, 508)), new Pair.ptr(new $Int64(0, 8737), new $Int64(0, 4289)), new Pair.ptr(new $Int64(0, 8741), new $Int64(0, 6961)), new Pair.ptr(new $Int64(0, 8747), new $Int64(0, 4800)), new Pair.ptr(new $Int64(0, 8753), new $Int64(0, 777)), new Pair.ptr(new $Int64(0, 8761), new $Int64(0, 7098)), new Pair.ptr(new $Int64(0, 8779), new $Int64(0, 709)), new Pair.ptr(new $Int64(0, 8783), new $Int64(0, 4682)), new Pair.ptr(new $Int64(0, 8803), new $Int64(0, 8631)), new Pair.ptr(new $Int64(0, 8807), new $Int64(0, 8383)), new Pair.ptr(new $Int64(0, 8819), new $Int64(0, 5643)), new Pair.ptr(new $Int64(0, 8821), new $Int64(0, 4102)), new Pair.ptr(new $Int64(0, 8831), new $Int64(0, 480)), new Pair.ptr(new $Int64(0, 8837), new $Int64(0, 1594)), new Pair.ptr(new $Int64(0, 8839), new $Int64(0, 7959)), new Pair.ptr(new $Int64(0, 8849), new $Int64(0, 2009)), new Pair.ptr(new $Int64(0, 8861), new $Int64(0, 3498)), new Pair.ptr(new $Int64(0, 8863), new $Int64(0, 1850)), new Pair.ptr(new $Int64(0, 8867), new $Int64(0, 4919)), new Pair.ptr(new $Int64(0, 8887), new $Int64(0, 4245)), new Pair.ptr(new $Int64(0, 8893), new $Int64(0, 6687)), new Pair.ptr(new $Int64(0, 8923), new $Int64(0, 6119)), new Pair.ptr(new $Int64(0, 8929), new $Int64(0, 4724)), new Pair.ptr(new $Int64(0, 8933), new $Int64(0, 1672)), new Pair.ptr(new $Int64(0, 8941), new $Int64(0, 7945)), new Pair.ptr(new $Int64(0, 8951), new $Int64(0, 4734)), new Pair.ptr(new $Int64(0, 8963), new $Int64(0, 2723)), new Pair.ptr(new $Int64(0, 8969), new $Int64(0, 1194)), new Pair.ptr(new $Int64(0, 8971), new $Int64(0, 8068)), new Pair.ptr(new $Int64(0, 8999), new $Int64(0, 4567)), new Pair.ptr(new $Int64(0, 9001), new $Int64(0, 3291)), new Pair.ptr(new $Int64(0, 9007), new $Int64(0, 5742)), new Pair.ptr(new $Int64(0, 9011), new $Int64(0, 3717)), new Pair.ptr(new $Int64(0, 9013), new $Int64(0, 8506)), new Pair.ptr(new $Int64(0, 9029), new $Int64(0, 79)), new Pair.ptr(new $Int64(0, 9041), new $Int64(0, 7367)), new Pair.ptr(new $Int64(0, 9043), new $Int64(0, 5858)), new Pair.ptr(new $Int64(0, 9049), new $Int64(0, 6487)), new Pair.ptr(new $Int64(0, 9059), new $Int64(0, 77)), new Pair.ptr(new $Int64(0, 9067), new $Int64(0, 4725)), new Pair.ptr(new $Int64(0, 9091), new $Int64(0, 8739)), new Pair.ptr(new $Int64(0, 9103), new $Int64(0, 9057)), new Pair.ptr(new $Int64(0, 9109), new $Int64(0, 3113)), new Pair.ptr(new $Int64(0, 9127), new $Int64(0, 6940)), new Pair.ptr(new $Int64(0, 9133), new $Int64(0, 499)), new Pair.ptr(new $Int64(0, 9137), new $Int64(0, 5459)), new Pair.ptr(new $Int64(0, 9151), new $Int64(0, 4532)), new Pair.ptr(new $Int64(0, 9157), new $Int64(0, 6000)), new Pair.ptr(new $Int64(0, 9161), new $Int64(0, 6815)), new Pair.ptr(new $Int64(0, 9173), new $Int64(0, 2001)), new Pair.ptr(new $Int64(0, 9181), new $Int64(0, 7984)), new Pair.ptr(new $Int64(0, 9187), new $Int64(0, 9147)), new Pair.ptr(new $Int64(0, 9199), new $Int64(0, 1933)), new Pair.ptr(new $Int64(0, 9203), new $Int64(0, 4745)), new Pair.ptr(new $Int64(0, 9209), new $Int64(0, 8135)), new Pair.ptr(new $Int64(0, 9221), new $Int64(0, 112)), new Pair.ptr(new $Int64(0, 9227), new $Int64(0, 4750)), new Pair.ptr(new $Int64(0, 9239), new $Int64(0, 7107)), new Pair.ptr(new $Int64(0, 9241), new $Int64(0, 4265)), new Pair.ptr(new $Int64(0, 9257), new $Int64(0, 2220)), new Pair.ptr(new $Int64(0, 9277), new $Int64(0, 2353)), new Pair.ptr(new $Int64(0, 9281), new $Int64(0, 5189)), new Pair.ptr(new $Int64(0, 9283), new $Int64(0, 6709)), new Pair.ptr(new $Int64(0, 9293), new $Int64(0, 2185)), new Pair.ptr(new $Int64(0, 9311), new $Int64(0, 4943)), new Pair.ptr(new $Int64(0, 9319), new $Int64(0, 4537)), new Pair.ptr(new $Int64(0, 9323), new $Int64(0, 6800)), new Pair.ptr(new $Int64(0, 9337), new $Int64(0, 7671)), new Pair.ptr(new $Int64(0, 9341), new $Int64(0, 4546)), new Pair.ptr(new $Int64(0, 9343), new $Int64(0, 5917)), new Pair.ptr(new $Int64(0, 9349), new $Int64(0, 7594)), new Pair.ptr(new $Int64(0, 9371), new $Int64(0, 8331)), new Pair.ptr(new $Int64(0, 9377), new $Int64(0, 1490)), new Pair.ptr(new $Int64(0, 9391), new $Int64(0, 598)), new Pair.ptr(new $Int64(0, 9397), new $Int64(0, 5594)), new Pair.ptr(new $Int64(0, 9403), new $Int64(0, 9332)), new Pair.ptr(new $Int64(0, 9413), new $Int64(0, 7404)), new Pair.ptr(new $Int64(0, 9419), new $Int64(0, 2376)), new Pair.ptr(new $Int64(0, 9421), new $Int64(0, 2094)), new Pair.ptr(new $Int64(0, 9431), new $Int64(0, 5572)), new Pair.ptr(new $Int64(0, 9433), new $Int64(0, 5835)), new Pair.ptr(new $Int64(0, 9437), new $Int64(0, 1146)), new Pair.ptr(new $Int64(0, 9439), new $Int64(0, 4652)), new Pair.ptr(new $Int64(0, 9461), new $Int64(0, 1854)), new Pair.ptr(new $Int64(0, 9463), new $Int64(0, 803)), new Pair.ptr(new $Int64(0, 9467), new $Int64(0, 1989)), new Pair.ptr(new $Int64(0, 9473), new $Int64(0, 5620)), new Pair.ptr(new $Int64(0, 9479), new $Int64(0, 180)), new Pair.ptr(new $Int64(0, 9491), new $Int64(0, 4427)), new Pair.ptr(new $Int64(0, 9497), new $Int64(0, 6879)), new Pair.ptr(new $Int64(0, 9511), new $Int64(0, 6050)), new Pair.ptr(new $Int64(0, 9521), new $Int64(0, 5171)), new Pair.ptr(new $Int64(0, 9533), new $Int64(0, 2270)), new Pair.ptr(new $Int64(0, 9539), new $Int64(0, 6199)), new Pair.ptr(new $Int64(0, 9547), new $Int64(0, 1885)), new Pair.ptr(new $Int64(0, 9551), new $Int64(0, 6702)), new Pair.ptr(new $Int64(0, 9587), new $Int64(0, 5328)), new Pair.ptr(new $Int64(0, 9601), new $Int64(0, 4153)), new Pair.ptr(new $Int64(0, 9613), new $Int64(0, 7238)), new Pair.ptr(new $Int64(0, 9619), new $Int64(0, 3602)), new Pair.ptr(new $Int64(0, 9623), new $Int64(0, 8158)), new Pair.ptr(new $Int64(0, 9629), new $Int64(0, 8001)), new Pair.ptr(new $Int64(0, 9631), new $Int64(0, 36)), new Pair.ptr(new $Int64(0, 9643), new $Int64(0, 3453)), new Pair.ptr(new $Int64(0, 9649), new $Int64(0, 960)), new Pair.ptr(new $Int64(0, 9661), new $Int64(0, 7195)), new Pair.ptr(new $Int64(0, 9677), new $Int64(0, 3911)), new Pair.ptr(new $Int64(0, 9679), new $Int64(0, 8580)), new Pair.ptr(new $Int64(0, 9689), new $Int64(0, 5994)), new Pair.ptr(new $Int64(0, 9697), new $Int64(0, 2290)), new Pair.ptr(new $Int64(0, 9719), new $Int64(0, 9321)), new Pair.ptr(new $Int64(0, 9721), new $Int64(0, 8070)), new Pair.ptr(new $Int64(0, 9733), new $Int64(0, 6638)), new Pair.ptr(new $Int64(0, 9739), new $Int64(0, 5729)), new Pair.ptr(new $Int64(0, 9743), new $Int64(0, 7958)), new Pair.ptr(new $Int64(0, 9749), new $Int64(0, 6932)), new Pair.ptr(new $Int64(0, 9767), new $Int64(0, 8243)), new Pair.ptr(new $Int64(0, 9769), new $Int64(0, 7901)), new Pair.ptr(new $Int64(0, 9781), new $Int64(0, 210)), new Pair.ptr(new $Int64(0, 9787), new $Int64(0, 2871)), new Pair.ptr(new $Int64(0, 9791), new $Int64(0, 7917)), new Pair.ptr(new $Int64(0, 9803), new $Int64(0, 7297)), new Pair.ptr(new $Int64(0, 9811), new $Int64(0, 1894)), new Pair.ptr(new $Int64(0, 9817), new $Int64(0, 5947)), new Pair.ptr(new $Int64(0, 9829), new $Int64(0, 4557)), new Pair.ptr(new $Int64(0, 9833), new $Int64(0, 2199)), new Pair.ptr(new $Int64(0, 9839), new $Int64(0, 3342)), new Pair.ptr(new $Int64(0, 9851), new $Int64(0, 8679)), new Pair.ptr(new $Int64(0, 9857), new $Int64(0, 2679)), new Pair.ptr(new $Int64(0, 9859), new $Int64(0, 9168)), new Pair.ptr(new $Int64(0, 9871), new $Int64(0, 6989)), new Pair.ptr(new $Int64(0, 9883), new $Int64(0, 3223)), new Pair.ptr(new $Int64(0, 9887), new $Int64(0, 7643)), new Pair.ptr(new $Int64(0, 9901), new $Int64(0, 4080)), new Pair.ptr(new $Int64(0, 9907), new $Int64(0, 521)), new Pair.ptr(new $Int64(0, 9923), new $Int64(0, 2975)), new Pair.ptr(new $Int64(0, 9929), new $Int64(0, 6936)), new Pair.ptr(new $Int64(0, 9931), new $Int64(0, 8852)), new Pair.ptr(new $Int64(0, 9941), new $Int64(0, 3974)), new Pair.ptr(new $Int64(0, 9949), new $Int64(0, 965)), new Pair.ptr(new $Int64(0, 9967), new $Int64(0, 9600)), new Pair.ptr(new $Int64(0, 9973), new $Int64(0, 9681)), new Pair.ptr(new $Int64(0, 10007), new $Int64(0, 278)), new Pair.ptr(new $Int64(0, 10009), new $Int64(0, 9175)), new Pair.ptr(new $Int64(0, 10037), new $Int64(0, 5731)), new Pair.ptr(new $Int64(0, 10039), new $Int64(0, 4356)), new Pair.ptr(new $Int64(0, 10061), new $Int64(0, 8565)), new Pair.ptr(new $Int64(0, 10067), new $Int64(0, 6520)), new Pair.ptr(new $Int64(0, 10069), new $Int64(0, 6670)), new Pair.ptr(new $Int64(0, 10079), new $Int64(0, 4370)), new Pair.ptr(new $Int64(0, 10091), new $Int64(0, 1360)), new Pair.ptr(new $Int64(0, 10093), new $Int64(0, 3415)), new Pair.ptr(new $Int64(0, 10099), new $Int64(0, 8917)), new Pair.ptr(new $Int64(0, 10103), new $Int64(0, 2055)), new Pair.ptr(new $Int64(0, 10111), new $Int64(0, 7967)), new Pair.ptr(new $Int64(0, 10133), new $Int64(0, 611)), new Pair.ptr(new $Int64(0, 10139), new $Int64(0, 1251)), new Pair.ptr(new $Int64(0, 10141), new $Int64(0, 3490)), new Pair.ptr(new $Int64(0, 10151), new $Int64(0, 10145)), new Pair.ptr(new $Int64(0, 10159), new $Int64(0, 5017)), new Pair.ptr(new $Int64(0, 10163), new $Int64(0, 5707)), new Pair.ptr(new $Int64(0, 10169), new $Int64(0, 9684)), new Pair.ptr(new $Int64(0, 10177), new $Int64(0, 1102)), new Pair.ptr(new $Int64(0, 10181), new $Int64(0, 5026)), new Pair.ptr(new $Int64(0, 10193), new $Int64(0, 803)), new Pair.ptr(new $Int64(0, 10211), new $Int64(0, 1723)), new Pair.ptr(new $Int64(0, 10223), new $Int64(0, 10219)), new Pair.ptr(new $Int64(0, 10243), new $Int64(0, 7587)), new Pair.ptr(new $Int64(0, 10247), new $Int64(0, 8341)), new Pair.ptr(new $Int64(0, 10253), new $Int64(0, 10144)), new Pair.ptr(new $Int64(0, 10259), new $Int64(0, 1727)), new Pair.ptr(new $Int64(0, 10267), new $Int64(0, 263)), new Pair.ptr(new $Int64(0, 10271), new $Int64(0, 1256)), new Pair.ptr(new $Int64(0, 10273), new $Int64(0, 3050)), new Pair.ptr(new $Int64(0, 10289), new $Int64(0, 126)), new Pair.ptr(new $Int64(0, 10301), new $Int64(0, 9006)), new Pair.ptr(new $Int64(0, 10303), new $Int64(0, 6350)), new Pair.ptr(new $Int64(0, 10313), new $Int64(0, 10157)), new Pair.ptr(new $Int64(0, 10321), new $Int64(0, 8764)), new Pair.ptr(new $Int64(0, 10331), new $Int64(0, 2218)), new Pair.ptr(new $Int64(0, 10333), new $Int64(0, 9184)), new Pair.ptr(new $Int64(0, 10337), new $Int64(0, 6620)), new Pair.ptr(new $Int64(0, 10343), new $Int64(0, 4439)), new Pair.ptr(new $Int64(0, 10357), new $Int64(0, 9673)), new Pair.ptr(new $Int64(0, 10369), new $Int64(0, 8003)), new Pair.ptr(new $Int64(0, 10391), new $Int64(0, 25)), new Pair.ptr(new $Int64(0, 10399), new $Int64(0, 10174)), new Pair.ptr(new $Int64(0, 10427), new $Int64(0, 5649)), new Pair.ptr(new $Int64(0, 10429), new $Int64(0, 699)), new Pair.ptr(new $Int64(0, 10433), new $Int64(0, 2896)), new Pair.ptr(new $Int64(0, 10453), new $Int64(0, 6774)), new Pair.ptr(new $Int64(0, 10457), new $Int64(0, 5788)), new Pair.ptr(new $Int64(0, 10459), new $Int64(0, 10426)), new Pair.ptr(new $Int64(0, 10463), new $Int64(0, 1407)), new Pair.ptr(new $Int64(0, 10477), new $Int64(0, 10434)), new Pair.ptr(new $Int64(0, 10487), new $Int64(0, 6242)), new Pair.ptr(new $Int64(0, 10499), new $Int64(0, 3047)), new Pair.ptr(new $Int64(0, 10501), new $Int64(0, 1285)), new Pair.ptr(new $Int64(0, 10513), new $Int64(0, 2050)), new Pair.ptr(new $Int64(0, 10529), new $Int64(0, 3863)), new Pair.ptr(new $Int64(0, 10531), new $Int64(0, 1265)), new Pair.ptr(new $Int64(0, 10559), new $Int64(0, 6730)), new Pair.ptr(new $Int64(0, 10567), new $Int64(0, 4678)), new Pair.ptr(new $Int64(0, 10589), new $Int64(0, 2568)), new Pair.ptr(new $Int64(0, 10597), new $Int64(0, 2222)), new Pair.ptr(new $Int64(0, 10601), new $Int64(0, 6160)), new Pair.ptr(new $Int64(0, 10607), new $Int64(0, 496)), new Pair.ptr(new $Int64(0, 10613), new $Int64(0, 3545)), new Pair.ptr(new $Int64(0, 10627), new $Int64(0, 6090)), new Pair.ptr(new $Int64(0, 10631), new $Int64(0, 6812)), new Pair.ptr(new $Int64(0, 10639), new $Int64(0, 4712)), new Pair.ptr(new $Int64(0, 10651), new $Int64(0, 9132)), new Pair.ptr(new $Int64(0, 10657), new $Int64(0, 792)), new Pair.ptr(new $Int64(0, 10663), new $Int64(0, 777)), new Pair.ptr(new $Int64(0, 10667), new $Int64(0, 3051)), new Pair.ptr(new $Int64(0, 10687), new $Int64(0, 909)), new Pair.ptr(new $Int64(0, 10691), new $Int64(0, 5980)), new Pair.ptr(new $Int64(0, 10709), new $Int64(0, 3239)), new Pair.ptr(new $Int64(0, 10711), new $Int64(0, 5861)), new Pair.ptr(new $Int64(0, 10723), new $Int64(0, 8521)), new Pair.ptr(new $Int64(0, 10729), new $Int64(0, 1389)), new Pair.ptr(new $Int64(0, 10733), new $Int64(0, 9032)), new Pair.ptr(new $Int64(0, 10739), new $Int64(0, 2945)), new Pair.ptr(new $Int64(0, 10753), new $Int64(0, 7715)), new Pair.ptr(new $Int64(0, 10771), new $Int64(0, 3575)), new Pair.ptr(new $Int64(0, 10781), new $Int64(0, 691)), new Pair.ptr(new $Int64(0, 10789), new $Int64(0, 292)), new Pair.ptr(new $Int64(0, 10799), new $Int64(0, 8868)), new Pair.ptr(new $Int64(0, 10831), new $Int64(0, 3319)), new Pair.ptr(new $Int64(0, 10837), new $Int64(0, 5282)), new Pair.ptr(new $Int64(0, 10847), new $Int64(0, 6673)), new Pair.ptr(new $Int64(0, 10853), new $Int64(0, 1988)), new Pair.ptr(new $Int64(0, 10859), new $Int64(0, 971)), new Pair.ptr(new $Int64(0, 10861), new $Int64(0, 4736)), new Pair.ptr(new $Int64(0, 10867), new $Int64(0, 7400)), new Pair.ptr(new $Int64(0, 10883), new $Int64(0, 2567)), new Pair.ptr(new $Int64(0, 10889), new $Int64(0, 2842)), new Pair.ptr(new $Int64(0, 10891), new $Int64(0, 8228)), new Pair.ptr(new $Int64(0, 10903), new $Int64(0, 4781)), new Pair.ptr(new $Int64(0, 10909), new $Int64(0, 6311)), new Pair.ptr(new $Int64(0, 10937), new $Int64(0, 2164)), new Pair.ptr(new $Int64(0, 10939), new $Int64(0, 2774)), new Pair.ptr(new $Int64(0, 10949), new $Int64(0, 7654)), new Pair.ptr(new $Int64(0, 10957), new $Int64(0, 2396)), new Pair.ptr(new $Int64(0, 10973), new $Int64(0, 7491)), new Pair.ptr(new $Int64(0, 10979), new $Int64(0, 203)), new Pair.ptr(new $Int64(0, 10987), new $Int64(0, 5978)), new Pair.ptr(new $Int64(0, 10993), new $Int64(0, 9227)), new Pair.ptr(new $Int64(0, 11003), new $Int64(0, 1639)), new Pair.ptr(new $Int64(0, 11027), new $Int64(0, 3176)), new Pair.ptr(new $Int64(0, 11047), new $Int64(0, 3511)), new Pair.ptr(new $Int64(0, 11057), new $Int64(0, 5855)), new Pair.ptr(new $Int64(0, 11059), new $Int64(0, 4318)), new Pair.ptr(new $Int64(0, 11069), new $Int64(0, 3370)), new Pair.ptr(new $Int64(0, 11071), new $Int64(0, 7905)), new Pair.ptr(new $Int64(0, 11083), new $Int64(0, 4024)), new Pair.ptr(new $Int64(0, 11087), new $Int64(0, 7164)), new Pair.ptr(new $Int64(0, 11093), new $Int64(0, 8260)), new Pair.ptr(new $Int64(0, 11113), new $Int64(0, 424)), new Pair.ptr(new $Int64(0, 11117), new $Int64(0, 10368)), new Pair.ptr(new $Int64(0, 11119), new $Int64(0, 1981)), new Pair.ptr(new $Int64(0, 11131), new $Int64(0, 681)), new Pair.ptr(new $Int64(0, 11149), new $Int64(0, 8967)), new Pair.ptr(new $Int64(0, 11159), new $Int64(0, 4894)), new Pair.ptr(new $Int64(0, 11161), new $Int64(0, 4248)), new Pair.ptr(new $Int64(0, 11171), new $Int64(0, 6773)), new Pair.ptr(new $Int64(0, 11173), new $Int64(0, 8993)), new Pair.ptr(new $Int64(0, 11177), new $Int64(0, 4266)), new Pair.ptr(new $Int64(0, 11197), new $Int64(0, 7717)), new Pair.ptr(new $Int64(0, 11213), new $Int64(0, 9884)), new Pair.ptr(new $Int64(0, 11239), new $Int64(0, 5730)), new Pair.ptr(new $Int64(0, 11243), new $Int64(0, 2753)), new Pair.ptr(new $Int64(0, 11251), new $Int64(0, 5454)), new Pair.ptr(new $Int64(0, 11257), new $Int64(0, 8360)), new Pair.ptr(new $Int64(0, 11261), new $Int64(0, 1408)), new Pair.ptr(new $Int64(0, 11273), new $Int64(0, 3208)), new Pair.ptr(new $Int64(0, 11279), new $Int64(0, 417)), new Pair.ptr(new $Int64(0, 11287), new $Int64(0, 9383)), new Pair.ptr(new $Int64(0, 11299), new $Int64(0, 9288)), new Pair.ptr(new $Int64(0, 11311), new $Int64(0, 3048)), new Pair.ptr(new $Int64(0, 11317), new $Int64(0, 6997)), new Pair.ptr(new $Int64(0, 11321), new $Int64(0, 5323)), new Pair.ptr(new $Int64(0, 11329), new $Int64(0, 10634)), new Pair.ptr(new $Int64(0, 11351), new $Int64(0, 9031)), new Pair.ptr(new $Int64(0, 11353), new $Int64(0, 9756)), new Pair.ptr(new $Int64(0, 11369), new $Int64(0, 11247)), new Pair.ptr(new $Int64(0, 11383), new $Int64(0, 1978)), new Pair.ptr(new $Int64(0, 11393), new $Int64(0, 9650)), new Pair.ptr(new $Int64(0, 11399), new $Int64(0, 4316)), new Pair.ptr(new $Int64(0, 11411), new $Int64(0, 4422)), new Pair.ptr(new $Int64(0, 11423), new $Int64(0, 64)), new Pair.ptr(new $Int64(0, 11437), new $Int64(0, 6717)), new Pair.ptr(new $Int64(0, 11443), new $Int64(0, 7447)), new Pair.ptr(new $Int64(0, 11447), new $Int64(0, 6619)), new Pair.ptr(new $Int64(0, 11467), new $Int64(0, 6411)), new Pair.ptr(new $Int64(0, 11471), new $Int64(0, 10960)), new Pair.ptr(new $Int64(0, 11483), new $Int64(0, 4934)), new Pair.ptr(new $Int64(0, 11489), new $Int64(0, 8921)), new Pair.ptr(new $Int64(0, 11491), new $Int64(0, 8004)), new Pair.ptr(new $Int64(0, 11497), new $Int64(0, 2382)), new Pair.ptr(new $Int64(0, 11503), new $Int64(0, 5182)), new Pair.ptr(new $Int64(0, 11519), new $Int64(0, 9068)), new Pair.ptr(new $Int64(0, 11527), new $Int64(0, 4366)), new Pair.ptr(new $Int64(0, 11549), new $Int64(0, 11327)), new Pair.ptr(new $Int64(0, 11551), new $Int64(0, 5109)), new Pair.ptr(new $Int64(0, 11579), new $Int64(0, 1313)), new Pair.ptr(new $Int64(0, 11587), new $Int64(0, 5390)), new Pair.ptr(new $Int64(0, 11593), new $Int64(0, 6372)), new Pair.ptr(new $Int64(0, 11597), new $Int64(0, 10387)), new Pair.ptr(new $Int64(0, 11617), new $Int64(0, 5285)), new Pair.ptr(new $Int64(0, 11621), new $Int64(0, 4158)), new Pair.ptr(new $Int64(0, 11633), new $Int64(0, 9156)), new Pair.ptr(new $Int64(0, 11657), new $Int64(0, 1829)), new Pair.ptr(new $Int64(0, 11677), new $Int64(0, 9366)), new Pair.ptr(new $Int64(0, 11681), new $Int64(0, 10160)), new Pair.ptr(new $Int64(0, 11689), new $Int64(0, 8508)), new Pair.ptr(new $Int64(0, 11699), new $Int64(0, 228)), new Pair.ptr(new $Int64(0, 11701), new $Int64(0, 11321)), new Pair.ptr(new $Int64(0, 11717), new $Int64(0, 8329)), new Pair.ptr(new $Int64(0, 11719), new $Int64(0, 4)), new Pair.ptr(new $Int64(0, 11731), new $Int64(0, 5089)), new Pair.ptr(new $Int64(0, 11743), new $Int64(0, 9748)), new Pair.ptr(new $Int64(0, 11777), new $Int64(0, 436)), new Pair.ptr(new $Int64(0, 11779), new $Int64(0, 10318)), new Pair.ptr(new $Int64(0, 11783), new $Int64(0, 9483)), new Pair.ptr(new $Int64(0, 11789), new $Int64(0, 904)), new Pair.ptr(new $Int64(0, 11801), new $Int64(0, 3462)), new Pair.ptr(new $Int64(0, 11807), new $Int64(0, 3784)), new Pair.ptr(new $Int64(0, 11813), new $Int64(0, 11534)), new Pair.ptr(new $Int64(0, 11821), new $Int64(0, 10020)), new Pair.ptr(new $Int64(0, 11827), new $Int64(0, 9826)), new Pair.ptr(new $Int64(0, 11831), new $Int64(0, 5288)), new Pair.ptr(new $Int64(0, 11833), new $Int64(0, 747)), new Pair.ptr(new $Int64(0, 11839), new $Int64(0, 8082)), new Pair.ptr(new $Int64(0, 11863), new $Int64(0, 1457)), new Pair.ptr(new $Int64(0, 11867), new $Int64(0, 8978)), new Pair.ptr(new $Int64(0, 11887), new $Int64(0, 6438)), new Pair.ptr(new $Int64(0, 11897), new $Int64(0, 6383)), new Pair.ptr(new $Int64(0, 11903), new $Int64(0, 2326)), new Pair.ptr(new $Int64(0, 11909), new $Int64(0, 9955)), new Pair.ptr(new $Int64(0, 11923), new $Int64(0, 8748)), new Pair.ptr(new $Int64(0, 11927), new $Int64(0, 11043)), new Pair.ptr(new $Int64(0, 11933), new $Int64(0, 8051)), new Pair.ptr(new $Int64(0, 11939), new $Int64(0, 507)), new Pair.ptr(new $Int64(0, 11941), new $Int64(0, 11756)), new Pair.ptr(new $Int64(0, 11953), new $Int64(0, 11406)), new Pair.ptr(new $Int64(0, 11959), new $Int64(0, 11079)), new Pair.ptr(new $Int64(0, 11969), new $Int64(0, 8935)), new Pair.ptr(new $Int64(0, 11971), new $Int64(0, 9606)), new Pair.ptr(new $Int64(0, 11981), new $Int64(0, 8464)), new Pair.ptr(new $Int64(0, 11987), new $Int64(0, 3692)), new Pair.ptr(new $Int64(0, 12007), new $Int64(0, 1681)), new Pair.ptr(new $Int64(0, 12011), new $Int64(0, 10810)), new Pair.ptr(new $Int64(0, 12037), new $Int64(0, 10737)), new Pair.ptr(new $Int64(0, 12041), new $Int64(0, 5024)), new Pair.ptr(new $Int64(0, 12043), new $Int64(0, 10761)), new Pair.ptr(new $Int64(0, 12049), new $Int64(0, 7783)), new Pair.ptr(new $Int64(0, 12071), new $Int64(0, 7795)), new Pair.ptr(new $Int64(0, 12073), new $Int64(0, 6274)), new Pair.ptr(new $Int64(0, 12097), new $Int64(0, 3316)), new Pair.ptr(new $Int64(0, 12101), new $Int64(0, 10483)), new Pair.ptr(new $Int64(0, 12107), new $Int64(0, 548)), new Pair.ptr(new $Int64(0, 12109), new $Int64(0, 10973)), new Pair.ptr(new $Int64(0, 12113), new $Int64(0, 6920)), new Pair.ptr(new $Int64(0, 12119), new $Int64(0, 3160)), new Pair.ptr(new $Int64(0, 12143), new $Int64(0, 1548)), new Pair.ptr(new $Int64(0, 12149), new $Int64(0, 3893)), new Pair.ptr(new $Int64(0, 12157), new $Int64(0, 5391)), new Pair.ptr(new $Int64(0, 12161), new $Int64(0, 5803)), new Pair.ptr(new $Int64(0, 12163), new $Int64(0, 8353)), new Pair.ptr(new $Int64(0, 12197), new $Int64(0, 4503)), new Pair.ptr(new $Int64(0, 12203), new $Int64(0, 9181)), new Pair.ptr(new $Int64(0, 12211), new $Int64(0, 7615)), new Pair.ptr(new $Int64(0, 12227), new $Int64(0, 7467)), new Pair.ptr(new $Int64(0, 12239), new $Int64(0, 3607)), new Pair.ptr(new $Int64(0, 12241), new $Int64(0, 9734)), new Pair.ptr(new $Int64(0, 12251), new $Int64(0, 7489)), new Pair.ptr(new $Int64(0, 12253), new $Int64(0, 9899)), new Pair.ptr(new $Int64(0, 12263), new $Int64(0, 4871)), new Pair.ptr(new $Int64(0, 12269), new $Int64(0, 9925)), new Pair.ptr(new $Int64(0, 12277), new $Int64(0, 2145)), new Pair.ptr(new $Int64(0, 12281), new $Int64(0, 9455)), new Pair.ptr(new $Int64(0, 12289), new $Int64(0, 11486)), new Pair.ptr(new $Int64(0, 12301), new $Int64(0, 12135)), new Pair.ptr(new $Int64(0, 12323), new $Int64(0, 7794)), new Pair.ptr(new $Int64(0, 12329), new $Int64(0, 1124)), new Pair.ptr(new $Int64(0, 12343), new $Int64(0, 9013)), new Pair.ptr(new $Int64(0, 12347), new $Int64(0, 4913)), new Pair.ptr(new $Int64(0, 12373), new $Int64(0, 6399)), new Pair.ptr(new $Int64(0, 12377), new $Int64(0, 6826)), new Pair.ptr(new $Int64(0, 12379), new $Int64(0, 3201)), new Pair.ptr(new $Int64(0, 12391), new $Int64(0, 10073)), new Pair.ptr(new $Int64(0, 12401), new $Int64(0, 11926)), new Pair.ptr(new $Int64(0, 12409), new $Int64(0, 10718)), new Pair.ptr(new $Int64(0, 12413), new $Int64(0, 3241)), new Pair.ptr(new $Int64(0, 12421), new $Int64(0, 4771)), new Pair.ptr(new $Int64(0, 12433), new $Int64(0, 1704)), new Pair.ptr(new $Int64(0, 12437), new $Int64(0, 9139)), new Pair.ptr(new $Int64(0, 12451), new $Int64(0, 2130)), new Pair.ptr(new $Int64(0, 12457), new $Int64(0, 1660)), new Pair.ptr(new $Int64(0, 12473), new $Int64(0, 1967)), new Pair.ptr(new $Int64(0, 12479), new $Int64(0, 9724)), new Pair.ptr(new $Int64(0, 12487), new $Int64(0, 1112)), new Pair.ptr(new $Int64(0, 12491), new $Int64(0, 6887)), new Pair.ptr(new $Int64(0, 12497), new $Int64(0, 10263)), new Pair.ptr(new $Int64(0, 12503), new $Int64(0, 11324)), new Pair.ptr(new $Int64(0, 12511), new $Int64(0, 2259)), new Pair.ptr(new $Int64(0, 12517), new $Int64(0, 7939)), new Pair.ptr(new $Int64(0, 12527), new $Int64(0, 12437)), new Pair.ptr(new $Int64(0, 12539), new $Int64(0, 69)), new Pair.ptr(new $Int64(0, 12541), new $Int64(0, 2136)), new Pair.ptr(new $Int64(0, 12547), new $Int64(0, 6175)), new Pair.ptr(new $Int64(0, 12553), new $Int64(0, 8091)), new Pair.ptr(new $Int64(0, 12569), new $Int64(0, 2841)), new Pair.ptr(new $Int64(0, 12577), new $Int64(0, 7820)), new Pair.ptr(new $Int64(0, 12583), new $Int64(0, 1558)), new Pair.ptr(new $Int64(0, 12589), new $Int64(0, 12565)), new Pair.ptr(new $Int64(0, 12601), new $Int64(0, 7490)), new Pair.ptr(new $Int64(0, 12611), new $Int64(0, 9813)), new Pair.ptr(new $Int64(0, 12613), new $Int64(0, 2680)), new Pair.ptr(new $Int64(0, 12619), new $Int64(0, 7877)), new Pair.ptr(new $Int64(0, 12637), new $Int64(0, 2675)), new Pair.ptr(new $Int64(0, 12641), new $Int64(0, 5388)), new Pair.ptr(new $Int64(0, 12647), new $Int64(0, 8829)), new Pair.ptr(new $Int64(0, 12653), new $Int64(0, 8107)), new Pair.ptr(new $Int64(0, 12659), new $Int64(0, 10857)), new Pair.ptr(new $Int64(0, 12671), new $Int64(0, 9385)), new Pair.ptr(new $Int64(0, 12689), new $Int64(0, 11019)), new Pair.ptr(new $Int64(0, 12697), new $Int64(0, 3861)), new Pair.ptr(new $Int64(0, 12703), new $Int64(0, 1649)), new Pair.ptr(new $Int64(0, 12713), new $Int64(0, 4202)), new Pair.ptr(new $Int64(0, 12721), new $Int64(0, 5833)), new Pair.ptr(new $Int64(0, 12739), new $Int64(0, 11388)), new Pair.ptr(new $Int64(0, 12743), new $Int64(0, 11134)), new Pair.ptr(new $Int64(0, 12757), new $Int64(0, 5810)), new Pair.ptr(new $Int64(0, 12763), new $Int64(0, 6062)), new Pair.ptr(new $Int64(0, 12781), new $Int64(0, 4539)), new Pair.ptr(new $Int64(0, 12791), new $Int64(0, 133)), new Pair.ptr(new $Int64(0, 12799), new $Int64(0, 7024)), new Pair.ptr(new $Int64(0, 12809), new $Int64(0, 6427)), new Pair.ptr(new $Int64(0, 12821), new $Int64(0, 271)), new Pair.ptr(new $Int64(0, 12823), new $Int64(0, 5213)), new Pair.ptr(new $Int64(0, 12829), new $Int64(0, 2872)), new Pair.ptr(new $Int64(0, 12841), new $Int64(0, 12161)), new Pair.ptr(new $Int64(0, 12853), new $Int64(0, 12772)), new Pair.ptr(new $Int64(0, 12889), new $Int64(0, 7244)), new Pair.ptr(new $Int64(0, 12893), new $Int64(0, 6947)), new Pair.ptr(new $Int64(0, 12899), new $Int64(0, 10818)), new Pair.ptr(new $Int64(0, 12907), new $Int64(0, 3451)), new Pair.ptr(new $Int64(0, 12911), new $Int64(0, 7254)), new Pair.ptr(new $Int64(0, 12917), new $Int64(0, 12279)), new Pair.ptr(new $Int64(0, 12919), new $Int64(0, 8032)), new Pair.ptr(new $Int64(0, 12923), new $Int64(0, 3074)), new Pair.ptr(new $Int64(0, 12941), new $Int64(0, 3066)), new Pair.ptr(new $Int64(0, 12953), new $Int64(0, 11476)), new Pair.ptr(new $Int64(0, 12959), new $Int64(0, 26)), new Pair.ptr(new $Int64(0, 12967), new $Int64(0, 8694)), new Pair.ptr(new $Int64(0, 12973), new $Int64(0, 11673)), new Pair.ptr(new $Int64(0, 12979), new $Int64(0, 12575)), new Pair.ptr(new $Int64(0, 12983), new $Int64(0, 4288)), new Pair.ptr(new $Int64(0, 13001), new $Int64(0, 6022)), new Pair.ptr(new $Int64(0, 13003), new $Int64(0, 3565)), new Pair.ptr(new $Int64(0, 13007), new $Int64(0, 1102)), new Pair.ptr(new $Int64(0, 13009), new $Int64(0, 8754)), new Pair.ptr(new $Int64(0, 13033), new $Int64(0, 10106)), new Pair.ptr(new $Int64(0, 13037), new $Int64(0, 8551)), new Pair.ptr(new $Int64(0, 13043), new $Int64(0, 692)), new Pair.ptr(new $Int64(0, 13049), new $Int64(0, 1320)), new Pair.ptr(new $Int64(0, 13063), new $Int64(0, 10126)), new Pair.ptr(new $Int64(0, 13093), new $Int64(0, 1147)), new Pair.ptr(new $Int64(0, 13099), new $Int64(0, 12194)), new Pair.ptr(new $Int64(0, 13103), new $Int64(0, 1906)), new Pair.ptr(new $Int64(0, 13109), new $Int64(0, 429)), new Pair.ptr(new $Int64(0, 13121), new $Int64(0, 2119)), new Pair.ptr(new $Int64(0, 13127), new $Int64(0, 1899)), new Pair.ptr(new $Int64(0, 13147), new $Int64(0, 9189)), new Pair.ptr(new $Int64(0, 13151), new $Int64(0, 10358)), new Pair.ptr(new $Int64(0, 13159), new $Int64(0, 5368)), new Pair.ptr(new $Int64(0, 13163), new $Int64(0, 2158)), new Pair.ptr(new $Int64(0, 13171), new $Int64(0, 5490)), new Pair.ptr(new $Int64(0, 13177), new $Int64(0, 7706)), new Pair.ptr(new $Int64(0, 13183), new $Int64(0, 9442)), new Pair.ptr(new $Int64(0, 13187), new $Int64(0, 9397)), new Pair.ptr(new $Int64(0, 13217), new $Int64(0, 6365)), new Pair.ptr(new $Int64(0, 13219), new $Int64(0, 8410)), new Pair.ptr(new $Int64(0, 13229), new $Int64(0, 2336)), new Pair.ptr(new $Int64(0, 13241), new $Int64(0, 6530)), new Pair.ptr(new $Int64(0, 13249), new $Int64(0, 3105)), new Pair.ptr(new $Int64(0, 13259), new $Int64(0, 6974)), new Pair.ptr(new $Int64(0, 13267), new $Int64(0, 2646)), new Pair.ptr(new $Int64(0, 13291), new $Int64(0, 10081)), new Pair.ptr(new $Int64(0, 13297), new $Int64(0, 8002)), new Pair.ptr(new $Int64(0, 13309), new $Int64(0, 4083)), new Pair.ptr(new $Int64(0, 13313), new $Int64(0, 703)), new Pair.ptr(new $Int64(0, 13327), new $Int64(0, 1280)), new Pair.ptr(new $Int64(0, 13331), new $Int64(0, 12291)), new Pair.ptr(new $Int64(0, 13337), new $Int64(0, 1533)), new Pair.ptr(new $Int64(0, 13339), new $Int64(0, 9086)), new Pair.ptr(new $Int64(0, 13367), new $Int64(0, 1680)), new Pair.ptr(new $Int64(0, 13381), new $Int64(0, 12385)), new Pair.ptr(new $Int64(0, 13397), new $Int64(0, 8399)), new Pair.ptr(new $Int64(0, 13399), new $Int64(0, 9843)), new Pair.ptr(new $Int64(0, 13411), new $Int64(0, 3567)), new Pair.ptr(new $Int64(0, 13417), new $Int64(0, 2056)), new Pair.ptr(new $Int64(0, 13421), new $Int64(0, 7202)), new Pair.ptr(new $Int64(0, 13441), new $Int64(0, 11937)), new Pair.ptr(new $Int64(0, 13451), new $Int64(0, 9526)), new Pair.ptr(new $Int64(0, 13457), new $Int64(0, 10191)), new Pair.ptr(new $Int64(0, 13463), new $Int64(0, 2456)), new Pair.ptr(new $Int64(0, 13469), new $Int64(0, 4612)), new Pair.ptr(new $Int64(0, 13477), new $Int64(0, 12937)), new Pair.ptr(new $Int64(0, 13487), new $Int64(0, 13188)), new Pair.ptr(new $Int64(0, 13499), new $Int64(0, 13371)), new Pair.ptr(new $Int64(0, 13513), new $Int64(0, 2365)), new Pair.ptr(new $Int64(0, 13523), new $Int64(0, 6459)), new Pair.ptr(new $Int64(0, 13537), new $Int64(0, 8187)), new Pair.ptr(new $Int64(0, 13553), new $Int64(0, 3058)), new Pair.ptr(new $Int64(0, 13567), new $Int64(0, 8771)), new Pair.ptr(new $Int64(0, 13577), new $Int64(0, 12981)), new Pair.ptr(new $Int64(0, 13591), new $Int64(0, 4382)), new Pair.ptr(new $Int64(0, 13597), new $Int64(0, 8950)), new Pair.ptr(new $Int64(0, 13613), new $Int64(0, 1664)), new Pair.ptr(new $Int64(0, 13619), new $Int64(0, 3245)), new Pair.ptr(new $Int64(0, 13627), new $Int64(0, 2922)), new Pair.ptr(new $Int64(0, 13633), new $Int64(0, 8147)), new Pair.ptr(new $Int64(0, 13649), new $Int64(0, 5894)), new Pair.ptr(new $Int64(0, 13669), new $Int64(0, 1913)), new Pair.ptr(new $Int64(0, 13679), new $Int64(0, 8008)), new Pair.ptr(new $Int64(0, 13681), new $Int64(0, 2337)), new Pair.ptr(new $Int64(0, 13687), new $Int64(0, 7659)), new Pair.ptr(new $Int64(0, 13691), new $Int64(0, 9737)), new Pair.ptr(new $Int64(0, 13693), new $Int64(0, 5276)), new Pair.ptr(new $Int64(0, 13697), new $Int64(0, 12220)), new Pair.ptr(new $Int64(0, 13709), new $Int64(0, 4927)), new Pair.ptr(new $Int64(0, 13711), new $Int64(0, 8434)), new Pair.ptr(new $Int64(0, 13721), new $Int64(0, 13497)), new Pair.ptr(new $Int64(0, 13723), new $Int64(0, 9959)), new Pair.ptr(new $Int64(0, 13729), new $Int64(0, 6276)), new Pair.ptr(new $Int64(0, 13751), new $Int64(0, 4168)), new Pair.ptr(new $Int64(0, 13757), new $Int64(0, 2399)), new Pair.ptr(new $Int64(0, 13759), new $Int64(0, 12884)), new Pair.ptr(new $Int64(0, 13763), new $Int64(0, 13572)), new Pair.ptr(new $Int64(0, 13781), new $Int64(0, 11842)), new Pair.ptr(new $Int64(0, 13789), new $Int64(0, 3817)), new Pair.ptr(new $Int64(0, 13799), new $Int64(0, 5142)), new Pair.ptr(new $Int64(0, 13807), new $Int64(0, 1533)), new Pair.ptr(new $Int64(0, 13829), new $Int64(0, 8493)), new Pair.ptr(new $Int64(0, 13831), new $Int64(0, 7209)), new Pair.ptr(new $Int64(0, 13841), new $Int64(0, 9218)), new Pair.ptr(new $Int64(0, 13859), new $Int64(0, 12260)), new Pair.ptr(new $Int64(0, 13873), new $Int64(0, 8332)), new Pair.ptr(new $Int64(0, 13877), new $Int64(0, 9199)), new Pair.ptr(new $Int64(0, 13879), new $Int64(0, 12109)), new Pair.ptr(new $Int64(0, 13883), new $Int64(0, 3552)), new Pair.ptr(new $Int64(0, 13901), new $Int64(0, 9376)), new Pair.ptr(new $Int64(0, 13903), new $Int64(0, 2027)), new Pair.ptr(new $Int64(0, 13907), new $Int64(0, 10049)), new Pair.ptr(new $Int64(0, 13913), new $Int64(0, 11298)), new Pair.ptr(new $Int64(0, 13921), new $Int64(0, 5521)), new Pair.ptr(new $Int64(0, 13931), new $Int64(0, 3645)), new Pair.ptr(new $Int64(0, 13933), new $Int64(0, 6482)), new Pair.ptr(new $Int64(0, 13963), new $Int64(0, 10454)), new Pair.ptr(new $Int64(0, 13967), new $Int64(0, 5146)), new Pair.ptr(new $Int64(0, 13997), new $Int64(0, 11376)), new Pair.ptr(new $Int64(0, 13999), new $Int64(0, 10997)), new Pair.ptr(new $Int64(0, 14009), new $Int64(0, 12935)), new Pair.ptr(new $Int64(0, 14011), new $Int64(0, 11131)), new Pair.ptr(new $Int64(0, 14029), new $Int64(0, 13764)), new Pair.ptr(new $Int64(0, 14033), new $Int64(0, 2942)), new Pair.ptr(new $Int64(0, 14051), new $Int64(0, 8842)), new Pair.ptr(new $Int64(0, 14057), new $Int64(0, 3329)), new Pair.ptr(new $Int64(0, 14071), new $Int64(0, 5830)), new Pair.ptr(new $Int64(0, 14081), new $Int64(0, 10883)), new Pair.ptr(new $Int64(0, 14083), new $Int64(0, 2820)), new Pair.ptr(new $Int64(0, 14087), new $Int64(0, 13254)), new Pair.ptr(new $Int64(0, 14107), new $Int64(0, 8042)), new Pair.ptr(new $Int64(0, 14143), new $Int64(0, 12588)), new Pair.ptr(new $Int64(0, 14149), new $Int64(0, 12652)), new Pair.ptr(new $Int64(0, 14153), new $Int64(0, 12624)), new Pair.ptr(new $Int64(0, 14159), new $Int64(0, 3211)), new Pair.ptr(new $Int64(0, 14173), new $Int64(0, 10190)), new Pair.ptr(new $Int64(0, 14177), new $Int64(0, 10453)), new Pair.ptr(new $Int64(0, 14197), new $Int64(0, 6324)), new Pair.ptr(new $Int64(0, 14207), new $Int64(0, 8442)), new Pair.ptr(new $Int64(0, 14221), new $Int64(0, 12168)), new Pair.ptr(new $Int64(0, 14243), new $Int64(0, 8240)), new Pair.ptr(new $Int64(0, 14249), new $Int64(0, 13484)), new Pair.ptr(new $Int64(0, 14251), new $Int64(0, 8275)), new Pair.ptr(new $Int64(0, 14281), new $Int64(0, 11185)), new Pair.ptr(new $Int64(0, 14293), new $Int64(0, 11133)), new Pair.ptr(new $Int64(0, 14303), new $Int64(0, 11011)), new Pair.ptr(new $Int64(0, 14321), new $Int64(0, 11512)), new Pair.ptr(new $Int64(0, 14323), new $Int64(0, 7547)), new Pair.ptr(new $Int64(0, 14327), new $Int64(0, 13809)), new Pair.ptr(new $Int64(0, 14341), new $Int64(0, 5838)), new Pair.ptr(new $Int64(0, 14347), new $Int64(0, 11418)), new Pair.ptr(new $Int64(0, 14369), new $Int64(0, 11875)), new Pair.ptr(new $Int64(0, 14387), new $Int64(0, 7162)), new Pair.ptr(new $Int64(0, 14389), new $Int64(0, 12191)), new Pair.ptr(new $Int64(0, 14401), new $Int64(0, 10833)), new Pair.ptr(new $Int64(0, 14407), new $Int64(0, 12538)), new Pair.ptr(new $Int64(0, 14411), new $Int64(0, 12207)), new Pair.ptr(new $Int64(0, 14419), new $Int64(0, 12789)), new Pair.ptr(new $Int64(0, 14423), new $Int64(0, 2415)), new Pair.ptr(new $Int64(0, 14431), new $Int64(0, 4451)), new Pair.ptr(new $Int64(0, 14437), new $Int64(0, 9301)), new Pair.ptr(new $Int64(0, 14447), new $Int64(0, 12568)), new Pair.ptr(new $Int64(0, 14449), new $Int64(0, 12812)), new Pair.ptr(new $Int64(0, 14461), new $Int64(0, 4630)), new Pair.ptr(new $Int64(0, 14479), new $Int64(0, 9566)), new Pair.ptr(new $Int64(0, 14489), new $Int64(0, 12640)), new Pair.ptr(new $Int64(0, 14503), new $Int64(0, 825)), new Pair.ptr(new $Int64(0, 14519), new $Int64(0, 6063)), new Pair.ptr(new $Int64(0, 14533), new $Int64(0, 1941)), new Pair.ptr(new $Int64(0, 14537), new $Int64(0, 3007)), new Pair.ptr(new $Int64(0, 14543), new $Int64(0, 13869)), new Pair.ptr(new $Int64(0, 14549), new $Int64(0, 4008)), new Pair.ptr(new $Int64(0, 14551), new $Int64(0, 98)), new Pair.ptr(new $Int64(0, 14557), new $Int64(0, 14410)), new Pair.ptr(new $Int64(0, 14561), new $Int64(0, 7501)), new Pair.ptr(new $Int64(0, 14563), new $Int64(0, 5884)), new Pair.ptr(new $Int64(0, 14591), new $Int64(0, 14320)), new Pair.ptr(new $Int64(0, 14593), new $Int64(0, 134)), new Pair.ptr(new $Int64(0, 14621), new $Int64(0, 8883)), new Pair.ptr(new $Int64(0, 14627), new $Int64(0, 8845)), new Pair.ptr(new $Int64(0, 14629), new $Int64(0, 469)), new Pair.ptr(new $Int64(0, 14633), new $Int64(0, 7848)), new Pair.ptr(new $Int64(0, 14639), new $Int64(0, 14566)), new Pair.ptr(new $Int64(0, 14653), new $Int64(0, 10418)), new Pair.ptr(new $Int64(0, 14657), new $Int64(0, 14570)), new Pair.ptr(new $Int64(0, 14669), new $Int64(0, 13625)), new Pair.ptr(new $Int64(0, 14683), new $Int64(0, 1664)), new Pair.ptr(new $Int64(0, 14699), new $Int64(0, 1285)), new Pair.ptr(new $Int64(0, 14713), new $Int64(0, 1017)), new Pair.ptr(new $Int64(0, 14717), new $Int64(0, 9550)), new Pair.ptr(new $Int64(0, 14723), new $Int64(0, 3561)), new Pair.ptr(new $Int64(0, 14731), new $Int64(0, 5375)), new Pair.ptr(new $Int64(0, 14737), new $Int64(0, 3068)), new Pair.ptr(new $Int64(0, 14741), new $Int64(0, 12932)), new Pair.ptr(new $Int64(0, 14747), new $Int64(0, 13956)), new Pair.ptr(new $Int64(0, 14753), new $Int64(0, 1457)), new Pair.ptr(new $Int64(0, 14759), new $Int64(0, 3524)), new Pair.ptr(new $Int64(0, 14767), new $Int64(0, 14179)), new Pair.ptr(new $Int64(0, 14771), new $Int64(0, 8513)), new Pair.ptr(new $Int64(0, 14779), new $Int64(0, 7867)), new Pair.ptr(new $Int64(0, 14783), new $Int64(0, 2047)), new Pair.ptr(new $Int64(0, 14797), new $Int64(0, 10139)), new Pair.ptr(new $Int64(0, 14813), new $Int64(0, 7434)), new Pair.ptr(new $Int64(0, 14821), new $Int64(0, 1251)), new Pair.ptr(new $Int64(0, 14827), new $Int64(0, 9119)), new Pair.ptr(new $Int64(0, 14831), new $Int64(0, 3073)), new Pair.ptr(new $Int64(0, 14843), new $Int64(0, 10841)), new Pair.ptr(new $Int64(0, 14851), new $Int64(0, 5671)), new Pair.ptr(new $Int64(0, 14867), new $Int64(0, 8099)), new Pair.ptr(new $Int64(0, 14869), new $Int64(0, 5334)), new Pair.ptr(new $Int64(0, 14879), new $Int64(0, 3077)), new Pair.ptr(new $Int64(0, 14887), new $Int64(0, 8970)), new Pair.ptr(new $Int64(0, 14891), new $Int64(0, 8121)), new Pair.ptr(new $Int64(0, 14897), new $Int64(0, 6549)), new Pair.ptr(new $Int64(0, 14923), new $Int64(0, 588)), new Pair.ptr(new $Int64(0, 14929), new $Int64(0, 12477)), new Pair.ptr(new $Int64(0, 14939), new $Int64(0, 5037)), new Pair.ptr(new $Int64(0, 14947), new $Int64(0, 577)), new Pair.ptr(new $Int64(0, 14951), new $Int64(0, 4935)), new Pair.ptr(new $Int64(0, 14957), new $Int64(0, 10154)), new Pair.ptr(new $Int64(0, 14969), new $Int64(0, 6793)), new Pair.ptr(new $Int64(0, 14983), new $Int64(0, 11764)), new Pair.ptr(new $Int64(0, 15013), new $Int64(0, 2815)), new Pair.ptr(new $Int64(0, 15017), new $Int64(0, 8447)), new Pair.ptr(new $Int64(0, 15031), new $Int64(0, 822)), new Pair.ptr(new $Int64(0, 15053), new $Int64(0, 10547)), new Pair.ptr(new $Int64(0, 15061), new $Int64(0, 4461)), new Pair.ptr(new $Int64(0, 15073), new $Int64(0, 1072)), new Pair.ptr(new $Int64(0, 15077), new $Int64(0, 4286)), new Pair.ptr(new $Int64(0, 15083), new $Int64(0, 10730)), new Pair.ptr(new $Int64(0, 15091), new $Int64(0, 6230)), new Pair.ptr(new $Int64(0, 15101), new $Int64(0, 13806)), new Pair.ptr(new $Int64(0, 15107), new $Int64(0, 10735)), new Pair.ptr(new $Int64(0, 15121), new $Int64(0, 10574)), new Pair.ptr(new $Int64(0, 15131), new $Int64(0, 12832)), new Pair.ptr(new $Int64(0, 15137), new $Int64(0, 10934)), new Pair.ptr(new $Int64(0, 15139), new $Int64(0, 3098)), new Pair.ptr(new $Int64(0, 15149), new $Int64(0, 7306)), new Pair.ptr(new $Int64(0, 15161), new $Int64(0, 5932)), new Pair.ptr(new $Int64(0, 15173), new $Int64(0, 3037)), new Pair.ptr(new $Int64(0, 15187), new $Int64(0, 298)), new Pair.ptr(new $Int64(0, 15193), new $Int64(0, 8290)), new Pair.ptr(new $Int64(0, 15199), new $Int64(0, 8250)), new Pair.ptr(new $Int64(0, 15217), new $Int64(0, 3776)), new Pair.ptr(new $Int64(0, 15227), new $Int64(0, 2469)), new Pair.ptr(new $Int64(0, 15233), new $Int64(0, 987)), new Pair.ptr(new $Int64(0, 15241), new $Int64(0, 1020)), new Pair.ptr(new $Int64(0, 15259), new $Int64(0, 2650)), new Pair.ptr(new $Int64(0, 15263), new $Int64(0, 12055)), new Pair.ptr(new $Int64(0, 15269), new $Int64(0, 15006)), new Pair.ptr(new $Int64(0, 15271), new $Int64(0, 7807)), new Pair.ptr(new $Int64(0, 15277), new $Int64(0, 9949)), new Pair.ptr(new $Int64(0, 15287), new $Int64(0, 10840)), new Pair.ptr(new $Int64(0, 15289), new $Int64(0, 13343)), new Pair.ptr(new $Int64(0, 15299), new $Int64(0, 5892)), new Pair.ptr(new $Int64(0, 15307), new $Int64(0, 7778)), new Pair.ptr(new $Int64(0, 15313), new $Int64(0, 1548)), new Pair.ptr(new $Int64(0, 15319), new $Int64(0, 13549)), new Pair.ptr(new $Int64(0, 15329), new $Int64(0, 13480)), new Pair.ptr(new $Int64(0, 15331), new $Int64(0, 10158)), new Pair.ptr(new $Int64(0, 15349), new $Int64(0, 12023)), new Pair.ptr(new $Int64(0, 15359), new $Int64(0, 10710)), new Pair.ptr(new $Int64(0, 15361), new $Int64(0, 12614)), new Pair.ptr(new $Int64(0, 15373), new $Int64(0, 11621)), new Pair.ptr(new $Int64(0, 15377), new $Int64(0, 600)), new Pair.ptr(new $Int64(0, 15383), new $Int64(0, 10905)), new Pair.ptr(new $Int64(0, 15391), new $Int64(0, 11620)), new Pair.ptr(new $Int64(0, 15401), new $Int64(0, 11057)), new Pair.ptr(new $Int64(0, 15413), new $Int64(0, 760)), new Pair.ptr(new $Int64(0, 15427), new $Int64(0, 5743)), new Pair.ptr(new $Int64(0, 15439), new $Int64(0, 11866)), new Pair.ptr(new $Int64(0, 15443), new $Int64(0, 10369)), new Pair.ptr(new $Int64(0, 15451), new $Int64(0, 5329)), new Pair.ptr(new $Int64(0, 15461), new $Int64(0, 15448)), new Pair.ptr(new $Int64(0, 15467), new $Int64(0, 5351)), new Pair.ptr(new $Int64(0, 15473), new $Int64(0, 11761)), new Pair.ptr(new $Int64(0, 15493), new $Int64(0, 8415)), new Pair.ptr(new $Int64(0, 15497), new $Int64(0, 9553)), new Pair.ptr(new $Int64(0, 15511), new $Int64(0, 5156)), new Pair.ptr(new $Int64(0, 15527), new $Int64(0, 10762)), new Pair.ptr(new $Int64(0, 15541), new $Int64(0, 13639)), new Pair.ptr(new $Int64(0, 15551), new $Int64(0, 1389)), new Pair.ptr(new $Int64(0, 15559), new $Int64(0, 4544)), new Pair.ptr(new $Int64(0, 15569), new $Int64(0, 6692)), new Pair.ptr(new $Int64(0, 15581), new $Int64(0, 13451)), new Pair.ptr(new $Int64(0, 15583), new $Int64(0, 13714)), new Pair.ptr(new $Int64(0, 15601), new $Int64(0, 10333)), new Pair.ptr(new $Int64(0, 15607), new $Int64(0, 9092)), new Pair.ptr(new $Int64(0, 15619), new $Int64(0, 14103)), new Pair.ptr(new $Int64(0, 15629), new $Int64(0, 15594)), new Pair.ptr(new $Int64(0, 15641), new $Int64(0, 14120)), new Pair.ptr(new $Int64(0, 15643), new $Int64(0, 3945)), new Pair.ptr(new $Int64(0, 15647), new $Int64(0, 294)), new Pair.ptr(new $Int64(0, 15649), new $Int64(0, 7951)), new Pair.ptr(new $Int64(0, 15661), new $Int64(0, 14464)), new Pair.ptr(new $Int64(0, 15667), new $Int64(0, 14018)), new Pair.ptr(new $Int64(0, 15671), new $Int64(0, 1932)), new Pair.ptr(new $Int64(0, 15679), new $Int64(0, 7931)), new Pair.ptr(new $Int64(0, 15683), new $Int64(0, 14964)), new Pair.ptr(new $Int64(0, 15727), new $Int64(0, 15415)), new Pair.ptr(new $Int64(0, 15731), new $Int64(0, 6929)), new Pair.ptr(new $Int64(0, 15733), new $Int64(0, 9677)), new Pair.ptr(new $Int64(0, 15737), new $Int64(0, 15282)), new Pair.ptr(new $Int64(0, 15739), new $Int64(0, 13095)), new Pair.ptr(new $Int64(0, 15749), new $Int64(0, 15226)), new Pair.ptr(new $Int64(0, 15761), new $Int64(0, 14496)), new Pair.ptr(new $Int64(0, 15767), new $Int64(0, 12850)), new Pair.ptr(new $Int64(0, 15773), new $Int64(0, 6214)), new Pair.ptr(new $Int64(0, 15787), new $Int64(0, 2707)), new Pair.ptr(new $Int64(0, 15791), new $Int64(0, 4108)), new Pair.ptr(new $Int64(0, 15797), new $Int64(0, 15143)), new Pair.ptr(new $Int64(0, 15803), new $Int64(0, 6064)), new Pair.ptr(new $Int64(0, 15809), new $Int64(0, 14139)), new Pair.ptr(new $Int64(0, 15817), new $Int64(0, 5426)), new Pair.ptr(new $Int64(0, 15823), new $Int64(0, 2465)), new Pair.ptr(new $Int64(0, 15859), new $Int64(0, 14795)), new Pair.ptr(new $Int64(0, 15877), new $Int64(0, 13623)), new Pair.ptr(new $Int64(0, 15881), new $Int64(0, 13591)), new Pair.ptr(new $Int64(0, 15887), new $Int64(0, 13662)), new Pair.ptr(new $Int64(0, 15889), new $Int64(0, 7565)), new Pair.ptr(new $Int64(0, 15901), new $Int64(0, 4821)), new Pair.ptr(new $Int64(0, 15907), new $Int64(0, 8941)), new Pair.ptr(new $Int64(0, 15913), new $Int64(0, 9589)), new Pair.ptr(new $Int64(0, 15919), new $Int64(0, 13698)), new Pair.ptr(new $Int64(0, 15923), new $Int64(0, 2865)), new Pair.ptr(new $Int64(0, 15937), new $Int64(0, 659)), new Pair.ptr(new $Int64(0, 15959), new $Int64(0, 5357)), new Pair.ptr(new $Int64(0, 15971), new $Int64(0, 13321)), new Pair.ptr(new $Int64(0, 15973), new $Int64(0, 8197)), new Pair.ptr(new $Int64(0, 15991), new $Int64(0, 1194)), new Pair.ptr(new $Int64(0, 16001), new $Int64(0, 12303)), new Pair.ptr(new $Int64(0, 16007), new $Int64(0, 1660)), new Pair.ptr(new $Int64(0, 16033), new $Int64(0, 15027)), new Pair.ptr(new $Int64(0, 16057), new $Int64(0, 2637)), new Pair.ptr(new $Int64(0, 16061), new $Int64(0, 14443)), new Pair.ptr(new $Int64(0, 16063), new $Int64(0, 6129)), new Pair.ptr(new $Int64(0, 16067), new $Int64(0, 21)), new Pair.ptr(new $Int64(0, 16069), new $Int64(0, 13502)), new Pair.ptr(new $Int64(0, 16073), new $Int64(0, 3177)), new Pair.ptr(new $Int64(0, 16087), new $Int64(0, 15800)), new Pair.ptr(new $Int64(0, 16091), new $Int64(0, 11042)), new Pair.ptr(new $Int64(0, 16097), new $Int64(0, 4584)), new Pair.ptr(new $Int64(0, 16103), new $Int64(0, 1345)), new Pair.ptr(new $Int64(0, 16111), new $Int64(0, 13081)), new Pair.ptr(new $Int64(0, 16127), new $Int64(0, 9744)), new Pair.ptr(new $Int64(0, 16139), new $Int64(0, 3394)), new Pair.ptr(new $Int64(0, 16141), new $Int64(0, 6861)), new Pair.ptr(new $Int64(0, 16183), new $Int64(0, 10653)), new Pair.ptr(new $Int64(0, 16187), new $Int64(0, 10419)), new Pair.ptr(new $Int64(0, 16189), new $Int64(0, 1360)), new Pair.ptr(new $Int64(0, 16193), new $Int64(0, 2586)), new Pair.ptr(new $Int64(0, 16217), new $Int64(0, 5169)), new Pair.ptr(new $Int64(0, 16223), new $Int64(0, 10366)), new Pair.ptr(new $Int64(0, 16229), new $Int64(0, 2428)), new Pair.ptr(new $Int64(0, 16231), new $Int64(0, 6125)), new Pair.ptr(new $Int64(0, 16249), new $Int64(0, 14473)), new Pair.ptr(new $Int64(0, 16253), new $Int64(0, 5916)), new Pair.ptr(new $Int64(0, 16267), new $Int64(0, 12426)), new Pair.ptr(new $Int64(0, 16273), new $Int64(0, 9367)), new Pair.ptr(new $Int64(0, 16301), new $Int64(0, 4774)), new Pair.ptr(new $Int64(0, 16319), new $Int64(0, 2201)), new Pair.ptr(new $Int64(0, 16333), new $Int64(0, 14011)), new Pair.ptr(new $Int64(0, 16339), new $Int64(0, 634)), new Pair.ptr(new $Int64(0, 16349), new $Int64(0, 9469)), new Pair.ptr(new $Int64(0, 16361), new $Int64(0, 9981)), new Pair.ptr(new $Int64(0, 16363), new $Int64(0, 7919)), new Pair.ptr(new $Int64(0, 16369), new $Int64(0, 14678)), new Pair.ptr(new $Int64(0, 16381), new $Int64(0, 5212)), new Pair.ptr(new $Int64(0, 16411), new $Int64(0, 8398)), new Pair.ptr(new $Int64(0, 16417), new $Int64(0, 10306)), new Pair.ptr(new $Int64(0, 16421), new $Int64(0, 14291)), new Pair.ptr(new $Int64(0, 16427), new $Int64(0, 842)), new Pair.ptr(new $Int64(0, 16433), new $Int64(0, 1508)), new Pair.ptr(new $Int64(0, 16447), new $Int64(0, 6706)), new Pair.ptr(new $Int64(0, 16451), new $Int64(0, 14313)), new Pair.ptr(new $Int64(0, 16453), new $Int64(0, 13062)), new Pair.ptr(new $Int64(0, 16477), new $Int64(0, 8640)), new Pair.ptr(new $Int64(0, 16481), new $Int64(0, 10614)), new Pair.ptr(new $Int64(0, 16487), new $Int64(0, 5498)), new Pair.ptr(new $Int64(0, 16493), new $Int64(0, 2395)), new Pair.ptr(new $Int64(0, 16519), new $Int64(0, 5699)), new Pair.ptr(new $Int64(0, 16529), new $Int64(0, 4281)), new Pair.ptr(new $Int64(0, 16547), new $Int64(0, 15957)), new Pair.ptr(new $Int64(0, 16553), new $Int64(0, 13078)), new Pair.ptr(new $Int64(0, 16561), new $Int64(0, 6750)), new Pair.ptr(new $Int64(0, 16567), new $Int64(0, 9403)), new Pair.ptr(new $Int64(0, 16573), new $Int64(0, 16452)), new Pair.ptr(new $Int64(0, 16603), new $Int64(0, 12613)), new Pair.ptr(new $Int64(0, 16607), new $Int64(0, 12141)), new Pair.ptr(new $Int64(0, 16619), new $Int64(0, 8044)), new Pair.ptr(new $Int64(0, 16631), new $Int64(0, 256)), new Pair.ptr(new $Int64(0, 16633), new $Int64(0, 2047)), new Pair.ptr(new $Int64(0, 16649), new $Int64(0, 13726)), new Pair.ptr(new $Int64(0, 16651), new $Int64(0, 7739)), new Pair.ptr(new $Int64(0, 16657), new $Int64(0, 123)), new Pair.ptr(new $Int64(0, 16661), new $Int64(0, 2466)), new Pair.ptr(new $Int64(0, 16673), new $Int64(0, 13939)), new Pair.ptr(new $Int64(0, 16691), new $Int64(0, 1149)), new Pair.ptr(new $Int64(0, 16693), new $Int64(0, 10601)), new Pair.ptr(new $Int64(0, 16699), new $Int64(0, 13827)), new Pair.ptr(new $Int64(0, 16703), new $Int64(0, 10923)), new Pair.ptr(new $Int64(0, 16729), new $Int64(0, 15803)), new Pair.ptr(new $Int64(0, 16741), new $Int64(0, 2266)), new Pair.ptr(new $Int64(0, 16747), new $Int64(0, 4026)), new Pair.ptr(new $Int64(0, 16759), new $Int64(0, 14538)), new Pair.ptr(new $Int64(0, 16763), new $Int64(0, 9229)), new Pair.ptr(new $Int64(0, 16787), new $Int64(0, 3594)), new Pair.ptr(new $Int64(0, 16811), new $Int64(0, 1913)), new Pair.ptr(new $Int64(0, 16823), new $Int64(0, 14598)), new Pair.ptr(new $Int64(0, 16829), new $Int64(0, 6704)), new Pair.ptr(new $Int64(0, 16831), new $Int64(0, 4670)), new Pair.ptr(new $Int64(0, 16843), new $Int64(0, 630)), new Pair.ptr(new $Int64(0, 16871), new $Int64(0, 5771)), new Pair.ptr(new $Int64(0, 16879), new $Int64(0, 16244)), new Pair.ptr(new $Int64(0, 16883), new $Int64(0, 862)), new Pair.ptr(new $Int64(0, 16889), new $Int64(0, 6517)), new Pair.ptr(new $Int64(0, 16901), new $Int64(0, 14962)), new Pair.ptr(new $Int64(0, 16903), new $Int64(0, 10232)), new Pair.ptr(new $Int64(0, 16921), new $Int64(0, 12137)), new Pair.ptr(new $Int64(0, 16927), new $Int64(0, 10233)), new Pair.ptr(new $Int64(0, 16931), new $Int64(0, 13868)), new Pair.ptr(new $Int64(0, 16937), new $Int64(0, 11219)), new Pair.ptr(new $Int64(0, 16943), new $Int64(0, 12671)), new Pair.ptr(new $Int64(0, 16963), new $Int64(0, 13039)), new Pair.ptr(new $Int64(0, 16979), new $Int64(0, 14138)), new Pair.ptr(new $Int64(0, 16981), new $Int64(0, 11018)), new Pair.ptr(new $Int64(0, 16987), new $Int64(0, 11839)), new Pair.ptr(new $Int64(0, 16993), new $Int64(0, 1599)), new Pair.ptr(new $Int64(0, 17011), new $Int64(0, 14483)), new Pair.ptr(new $Int64(0, 17021), new $Int64(0, 1312)), new Pair.ptr(new $Int64(0, 17027), new $Int64(0, 8102)), new Pair.ptr(new $Int64(0, 17029), new $Int64(0, 4884)), new Pair.ptr(new $Int64(0, 17033), new $Int64(0, 14274)), new Pair.ptr(new $Int64(0, 17041), new $Int64(0, 7201)), new Pair.ptr(new $Int64(0, 17047), new $Int64(0, 7155)), new Pair.ptr(new $Int64(0, 17053), new $Int64(0, 14799)), new Pair.ptr(new $Int64(0, 17077), new $Int64(0, 14755)), new Pair.ptr(new $Int64(0, 17093), new $Int64(0, 3353)), new Pair.ptr(new $Int64(0, 17099), new $Int64(0, 15297)), new Pair.ptr(new $Int64(0, 17107), new $Int64(0, 8761)), new Pair.ptr(new $Int64(0, 17117), new $Int64(0, 8132)), new Pair.ptr(new $Int64(0, 17123), new $Int64(0, 8264)), new Pair.ptr(new $Int64(0, 17137), new $Int64(0, 3619)), new Pair.ptr(new $Int64(0, 17159), new $Int64(0, 7354)), new Pair.ptr(new $Int64(0, 17167), new $Int64(0, 9109)), new Pair.ptr(new $Int64(0, 17183), new $Int64(0, 16009)), new Pair.ptr(new $Int64(0, 17189), new $Int64(0, 13802)), new Pair.ptr(new $Int64(0, 17191), new $Int64(0, 8239)), new Pair.ptr(new $Int64(0, 17203), new $Int64(0, 4115)), new Pair.ptr(new $Int64(0, 17207), new $Int64(0, 5910)), new Pair.ptr(new $Int64(0, 17209), new $Int64(0, 12543)), new Pair.ptr(new $Int64(0, 17231), new $Int64(0, 3467)), new Pair.ptr(new $Int64(0, 17239), new $Int64(0, 12750)), new Pair.ptr(new $Int64(0, 17257), new $Int64(0, 10954)), new Pair.ptr(new $Int64(0, 17291), new $Int64(0, 14802)), new Pair.ptr(new $Int64(0, 17293), new $Int64(0, 6594)), new Pair.ptr(new $Int64(0, 17299), new $Int64(0, 11023)), new Pair.ptr(new $Int64(0, 17317), new $Int64(0, 7264)), new Pair.ptr(new $Int64(0, 17321), new $Int64(0, 15031)), new Pair.ptr(new $Int64(0, 17327), new $Int64(0, 10746)), new Pair.ptr(new $Int64(0, 17333), new $Int64(0, 7729)), new Pair.ptr(new $Int64(0, 17341), new $Int64(0, 15288)), new Pair.ptr(new $Int64(0, 17351), new $Int64(0, 13302)), new Pair.ptr(new $Int64(0, 17359), new $Int64(0, 162)), new Pair.ptr(new $Int64(0, 17377), new $Int64(0, 1899)), new Pair.ptr(new $Int64(0, 17383), new $Int64(0, 902)), new Pair.ptr(new $Int64(0, 17387), new $Int64(0, 15308)), new Pair.ptr(new $Int64(0, 17389), new $Int64(0, 5630)), new Pair.ptr(new $Int64(0, 17393), new $Int64(0, 9363)), new Pair.ptr(new $Int64(0, 17401), new $Int64(0, 6849)), new Pair.ptr(new $Int64(0, 17417), new $Int64(0, 9362)), new Pair.ptr(new $Int64(0, 17419), new $Int64(0, 16929)), new Pair.ptr(new $Int64(0, 17431), new $Int64(0, 13195)), new Pair.ptr(new $Int64(0, 17443), new $Int64(0, 2395)), new Pair.ptr(new $Int64(0, 17449), new $Int64(0, 13973)), new Pair.ptr(new $Int64(0, 17467), new $Int64(0, 9591)), new Pair.ptr(new $Int64(0, 17471), new $Int64(0, 3812)), new Pair.ptr(new $Int64(0, 17477), new $Int64(0, 1843)), new Pair.ptr(new $Int64(0, 17483), new $Int64(0, 4508)), new Pair.ptr(new $Int64(0, 17489), new $Int64(0, 10138)), new Pair.ptr(new $Int64(0, 17491), new $Int64(0, 13022)), new Pair.ptr(new $Int64(0, 17497), new $Int64(0, 14812)), new Pair.ptr(new $Int64(0, 17509), new $Int64(0, 10514)), new Pair.ptr(new $Int64(0, 17519), new $Int64(0, 9976)), new Pair.ptr(new $Int64(0, 17539), new $Int64(0, 3484)), new Pair.ptr(new $Int64(0, 17551), new $Int64(0, 17038)), new Pair.ptr(new $Int64(0, 17569), new $Int64(0, 13525)), new Pair.ptr(new $Int64(0, 17573), new $Int64(0, 10838)), new Pair.ptr(new $Int64(0, 17579), new $Int64(0, 10177)), new Pair.ptr(new $Int64(0, 17581), new $Int64(0, 12707)), new Pair.ptr(new $Int64(0, 17597), new $Int64(0, 10786)), new Pair.ptr(new $Int64(0, 17599), new $Int64(0, 12313)), new Pair.ptr(new $Int64(0, 17609), new $Int64(0, 6443)), new Pair.ptr(new $Int64(0, 17623), new $Int64(0, 87)), new Pair.ptr(new $Int64(0, 17627), new $Int64(0, 8951)), new Pair.ptr(new $Int64(0, 17657), new $Int64(0, 4111)), new Pair.ptr(new $Int64(0, 17659), new $Int64(0, 17568)), new Pair.ptr(new $Int64(0, 17669), new $Int64(0, 11981)), new Pair.ptr(new $Int64(0, 17681), new $Int64(0, 8649)), new Pair.ptr(new $Int64(0, 17683), new $Int64(0, 6226)), new Pair.ptr(new $Int64(0, 17707), new $Int64(0, 2081)), new Pair.ptr(new $Int64(0, 17713), new $Int64(0, 2233)), new Pair.ptr(new $Int64(0, 17729), new $Int64(0, 13536)), new Pair.ptr(new $Int64(0, 17737), new $Int64(0, 10355)), new Pair.ptr(new $Int64(0, 17747), new $Int64(0, 12806)), new Pair.ptr(new $Int64(0, 17749), new $Int64(0, 17396)), new Pair.ptr(new $Int64(0, 17761), new $Int64(0, 16714)), new Pair.ptr(new $Int64(0, 17783), new $Int64(0, 10439)), new Pair.ptr(new $Int64(0, 17789), new $Int64(0, 16985)), new Pair.ptr(new $Int64(0, 17791), new $Int64(0, 8100)), new Pair.ptr(new $Int64(0, 17807), new $Int64(0, 7895)), new Pair.ptr(new $Int64(0, 17827), new $Int64(0, 17785)), new Pair.ptr(new $Int64(0, 17837), new $Int64(0, 10648)), new Pair.ptr(new $Int64(0, 17839), new $Int64(0, 3802)), new Pair.ptr(new $Int64(0, 17851), new $Int64(0, 15323)), new Pair.ptr(new $Int64(0, 17863), new $Int64(0, 11634)), new Pair.ptr(new $Int64(0, 17881), new $Int64(0, 7681)), new Pair.ptr(new $Int64(0, 17891), new $Int64(0, 8220)), new Pair.ptr(new $Int64(0, 17903), new $Int64(0, 1549)), new Pair.ptr(new $Int64(0, 17909), new $Int64(0, 6186)), new Pair.ptr(new $Int64(0, 17911), new $Int64(0, 8763)), new Pair.ptr(new $Int64(0, 17921), new $Int64(0, 15122)), new Pair.ptr(new $Int64(0, 17923), new $Int64(0, 12631)), new Pair.ptr(new $Int64(0, 17929), new $Int64(0, 15844)), new Pair.ptr(new $Int64(0, 17939), new $Int64(0, 14794)), new Pair.ptr(new $Int64(0, 17957), new $Int64(0, 4136)), new Pair.ptr(new $Int64(0, 17959), new $Int64(0, 1872)), new Pair.ptr(new $Int64(0, 17971), new $Int64(0, 2428)), new Pair.ptr(new $Int64(0, 17977), new $Int64(0, 17122)), new Pair.ptr(new $Int64(0, 17981), new $Int64(0, 1871)), new Pair.ptr(new $Int64(0, 17987), new $Int64(0, 15405)), new Pair.ptr(new $Int64(0, 17989), new $Int64(0, 5986)), new Pair.ptr(new $Int64(0, 18013), new $Int64(0, 12429)), new Pair.ptr(new $Int64(0, 18041), new $Int64(0, 4824)), new Pair.ptr(new $Int64(0, 18043), new $Int64(0, 7975)), new Pair.ptr(new $Int64(0, 18047), new $Int64(0, 10237)), new Pair.ptr(new $Int64(0, 18049), new $Int64(0, 786)), new Pair.ptr(new $Int64(0, 18059), new $Int64(0, 17112)), new Pair.ptr(new $Int64(0, 18061), new $Int64(0, 63)), new Pair.ptr(new $Int64(0, 18077), new $Int64(0, 14385)), new Pair.ptr(new $Int64(0, 18089), new $Int64(0, 13847)), new Pair.ptr(new $Int64(0, 18097), new $Int64(0, 1363)), new Pair.ptr(new $Int64(0, 18119), new $Int64(0, 13069)), new Pair.ptr(new $Int64(0, 18121), new $Int64(0, 16564)), new Pair.ptr(new $Int64(0, 18127), new $Int64(0, 10053)), new Pair.ptr(new $Int64(0, 18131), new $Int64(0, 1067)), new Pair.ptr(new $Int64(0, 18133), new $Int64(0, 3871)), new Pair.ptr(new $Int64(0, 18143), new $Int64(0, 3781)), new Pair.ptr(new $Int64(0, 18149), new $Int64(0, 5036)), new Pair.ptr(new $Int64(0, 18169), new $Int64(0, 15203)), new Pair.ptr(new $Int64(0, 18181), new $Int64(0, 9163)), new Pair.ptr(new $Int64(0, 18191), new $Int64(0, 1225)), new Pair.ptr(new $Int64(0, 18199), new $Int64(0, 5515)), new Pair.ptr(new $Int64(0, 18211), new $Int64(0, 6572)), new Pair.ptr(new $Int64(0, 18217), new $Int64(0, 14093)), new Pair.ptr(new $Int64(0, 18223), new $Int64(0, 7827)), new Pair.ptr(new $Int64(0, 18229), new $Int64(0, 8324)), new Pair.ptr(new $Int64(0, 18233), new $Int64(0, 2930)), new Pair.ptr(new $Int64(0, 18251), new $Int64(0, 15952)), new Pair.ptr(new $Int64(0, 18253), new $Int64(0, 13014)), new Pair.ptr(new $Int64(0, 18257), new $Int64(0, 13899)), new Pair.ptr(new $Int64(0, 18269), new $Int64(0, 9997)), new Pair.ptr(new $Int64(0, 18287), new $Int64(0, 16822)), new Pair.ptr(new $Int64(0, 18289), new $Int64(0, 3263)), new Pair.ptr(new $Int64(0, 18301), new $Int64(0, 16500)), new Pair.ptr(new $Int64(0, 18307), new $Int64(0, 2499)), new Pair.ptr(new $Int64(0, 18311), new $Int64(0, 13727)), new Pair.ptr(new $Int64(0, 18313), new $Int64(0, 717)), new Pair.ptr(new $Int64(0, 18329), new $Int64(0, 14342)), new Pair.ptr(new $Int64(0, 18341), new $Int64(0, 406)), new Pair.ptr(new $Int64(0, 18353), new $Int64(0, 17397)), new Pair.ptr(new $Int64(0, 18367), new $Int64(0, 4076)), new Pair.ptr(new $Int64(0, 18371), new $Int64(0, 16167)), new Pair.ptr(new $Int64(0, 18379), new $Int64(0, 12262)), new Pair.ptr(new $Int64(0, 18397), new $Int64(0, 17715)), new Pair.ptr(new $Int64(0, 18401), new $Int64(0, 5196)), new Pair.ptr(new $Int64(0, 18413), new $Int64(0, 5433)), new Pair.ptr(new $Int64(0, 18427), new $Int64(0, 9842)), new Pair.ptr(new $Int64(0, 18433), new $Int64(0, 15748)), new Pair.ptr(new $Int64(0, 18439), new $Int64(0, 5293)), new Pair.ptr(new $Int64(0, 18443), new $Int64(0, 5253)), new Pair.ptr(new $Int64(0, 18451), new $Int64(0, 11746)), new Pair.ptr(new $Int64(0, 18457), new $Int64(0, 5926)), new Pair.ptr(new $Int64(0, 18461), new $Int64(0, 14425)), new Pair.ptr(new $Int64(0, 18481), new $Int64(0, 14216)), new Pair.ptr(new $Int64(0, 18493), new $Int64(0, 11818)), new Pair.ptr(new $Int64(0, 18503), new $Int64(0, 6869)), new Pair.ptr(new $Int64(0, 18517), new $Int64(0, 6121)), new Pair.ptr(new $Int64(0, 18521), new $Int64(0, 6081)), new Pair.ptr(new $Int64(0, 18523), new $Int64(0, 3413)), new Pair.ptr(new $Int64(0, 18539), new $Int64(0, 991)), new Pair.ptr(new $Int64(0, 18541), new $Int64(0, 18050)), new Pair.ptr(new $Int64(0, 18553), new $Int64(0, 782)), new Pair.ptr(new $Int64(0, 18583), new $Int64(0, 3192)), new Pair.ptr(new $Int64(0, 18587), new $Int64(0, 1844)), new Pair.ptr(new $Int64(0, 18593), new $Int64(0, 3025)), new Pair.ptr(new $Int64(0, 18617), new $Int64(0, 17279)), new Pair.ptr(new $Int64(0, 18637), new $Int64(0, 16829)), new Pair.ptr(new $Int64(0, 18661), new $Int64(0, 14196)), new Pair.ptr(new $Int64(0, 18671), new $Int64(0, 3850)), new Pair.ptr(new $Int64(0, 18679), new $Int64(0, 17827)), new Pair.ptr(new $Int64(0, 18691), new $Int64(0, 2712)), new Pair.ptr(new $Int64(0, 18701), new $Int64(0, 15173)), new Pair.ptr(new $Int64(0, 18713), new $Int64(0, 2465)), new Pair.ptr(new $Int64(0, 18719), new $Int64(0, 8995)), new Pair.ptr(new $Int64(0, 18731), new $Int64(0, 17382)), new Pair.ptr(new $Int64(0, 18743), new $Int64(0, 17219)), new Pair.ptr(new $Int64(0, 18749), new $Int64(0, 445)), new Pair.ptr(new $Int64(0, 18757), new $Int64(0, 8730)), new Pair.ptr(new $Int64(0, 18773), new $Int64(0, 138)), new Pair.ptr(new $Int64(0, 18787), new $Int64(0, 9490)), new Pair.ptr(new $Int64(0, 18793), new $Int64(0, 8452)), new Pair.ptr(new $Int64(0, 18797), new $Int64(0, 3015)), new Pair.ptr(new $Int64(0, 18803), new $Int64(0, 6708)), new Pair.ptr(new $Int64(0, 18839), new $Int64(0, 4517)), new Pair.ptr(new $Int64(0, 18859), new $Int64(0, 2710)), new Pair.ptr(new $Int64(0, 18869), new $Int64(0, 6970)), new Pair.ptr(new $Int64(0, 18899), new $Int64(0, 13018)), new Pair.ptr(new $Int64(0, 18911), new $Int64(0, 10814)), new Pair.ptr(new $Int64(0, 18913), new $Int64(0, 15459)), new Pair.ptr(new $Int64(0, 18917), new $Int64(0, 13466)), new Pair.ptr(new $Int64(0, 18919), new $Int64(0, 8039)), new Pair.ptr(new $Int64(0, 18947), new $Int64(0, 7331)), new Pair.ptr(new $Int64(0, 18959), new $Int64(0, 682)), new Pair.ptr(new $Int64(0, 18973), new $Int64(0, 4183)), new Pair.ptr(new $Int64(0, 18979), new $Int64(0, 945)), new Pair.ptr(new $Int64(0, 19001), new $Int64(0, 18482)), new Pair.ptr(new $Int64(0, 19009), new $Int64(0, 8063)), new Pair.ptr(new $Int64(0, 19013), new $Int64(0, 12068)), new Pair.ptr(new $Int64(0, 19031), new $Int64(0, 5141)), new Pair.ptr(new $Int64(0, 19037), new $Int64(0, 17336)), new Pair.ptr(new $Int64(0, 19051), new $Int64(0, 13936)), new Pair.ptr(new $Int64(0, 19069), new $Int64(0, 17642)), new Pair.ptr(new $Int64(0, 19073), new $Int64(0, 10134)), new Pair.ptr(new $Int64(0, 19079), new $Int64(0, 12351)), new Pair.ptr(new $Int64(0, 19081), new $Int64(0, 972)), new Pair.ptr(new $Int64(0, 19087), new $Int64(0, 1490)), new Pair.ptr(new $Int64(0, 19121), new $Int64(0, 3279)), new Pair.ptr(new $Int64(0, 19139), new $Int64(0, 19034)), new Pair.ptr(new $Int64(0, 19141), new $Int64(0, 9360)), new Pair.ptr(new $Int64(0, 19157), new $Int64(0, 17962)), new Pair.ptr(new $Int64(0, 19163), new $Int64(0, 1323)), new Pair.ptr(new $Int64(0, 19181), new $Int64(0, 17996)), new Pair.ptr(new $Int64(0, 19183), new $Int64(0, 2586)), new Pair.ptr(new $Int64(0, 19207), new $Int64(0, 9635)), new Pair.ptr(new $Int64(0, 19211), new $Int64(0, 13682)), new Pair.ptr(new $Int64(0, 19213), new $Int64(0, 8305)), new Pair.ptr(new $Int64(0, 19219), new $Int64(0, 15376)), new Pair.ptr(new $Int64(0, 19231), new $Int64(0, 17862)), new Pair.ptr(new $Int64(0, 19237), new $Int64(0, 8300)), new Pair.ptr(new $Int64(0, 19249), new $Int64(0, 13203)), new Pair.ptr(new $Int64(0, 19259), new $Int64(0, 8052)), new Pair.ptr(new $Int64(0, 19267), new $Int64(0, 3015)), new Pair.ptr(new $Int64(0, 19273), new $Int64(0, 14444)), new Pair.ptr(new $Int64(0, 19289), new $Int64(0, 12723)), new Pair.ptr(new $Int64(0, 19301), new $Int64(0, 11977)), new Pair.ptr(new $Int64(0, 19309), new $Int64(0, 3879)), new Pair.ptr(new $Int64(0, 19319), new $Int64(0, 3918)), new Pair.ptr(new $Int64(0, 19333), new $Int64(0, 12490)), new Pair.ptr(new $Int64(0, 19373), new $Int64(0, 13090)), new Pair.ptr(new $Int64(0, 19379), new $Int64(0, 17298)), new Pair.ptr(new $Int64(0, 19381), new $Int64(0, 15615)), new Pair.ptr(new $Int64(0, 19387), new $Int64(0, 1465)), new Pair.ptr(new $Int64(0, 19391), new $Int64(0, 5955)), new Pair.ptr(new $Int64(0, 19403), new $Int64(0, 3433)), new Pair.ptr(new $Int64(0, 19417), new $Int64(0, 8077)), new Pair.ptr(new $Int64(0, 19421), new $Int64(0, 18551)), new Pair.ptr(new $Int64(0, 19423), new $Int64(0, 13659)), new Pair.ptr(new $Int64(0, 19427), new $Int64(0, 13339)), new Pair.ptr(new $Int64(0, 19429), new $Int64(0, 3282)), new Pair.ptr(new $Int64(0, 19433), new $Int64(0, 10500)), new Pair.ptr(new $Int64(0, 19441), new $Int64(0, 9866)), new Pair.ptr(new $Int64(0, 19447), new $Int64(0, 741)), new Pair.ptr(new $Int64(0, 19457), new $Int64(0, 16698)), new Pair.ptr(new $Int64(0, 19463), new $Int64(0, 5981)), new Pair.ptr(new $Int64(0, 19469), new $Int64(0, 6472)), new Pair.ptr(new $Int64(0, 19471), new $Int64(0, 2193)), new Pair.ptr(new $Int64(0, 19477), new $Int64(0, 2469)), new Pair.ptr(new $Int64(0, 19483), new $Int64(0, 9935)), new Pair.ptr(new $Int64(0, 19489), new $Int64(0, 18235)), new Pair.ptr(new $Int64(0, 19501), new $Int64(0, 7471)), new Pair.ptr(new $Int64(0, 19507), new $Int64(0, 12504)), new Pair.ptr(new $Int64(0, 19531), new $Int64(0, 8980)), new Pair.ptr(new $Int64(0, 19541), new $Int64(0, 3556)), new Pair.ptr(new $Int64(0, 19543), new $Int64(0, 3025)), new Pair.ptr(new $Int64(0, 19553), new $Int64(0, 14745)), new Pair.ptr(new $Int64(0, 19559), new $Int64(0, 7347)), new Pair.ptr(new $Int64(0, 19571), new $Int64(0, 14740)), new Pair.ptr(new $Int64(0, 19577), new $Int64(0, 1996)), new Pair.ptr(new $Int64(0, 19583), new $Int64(0, 9911)), new Pair.ptr(new $Int64(0, 19597), new $Int64(0, 9258)), new Pair.ptr(new $Int64(0, 19603), new $Int64(0, 4082)), new Pair.ptr(new $Int64(0, 19609), new $Int64(0, 16643)), new Pair.ptr(new $Int64(0, 19661), new $Int64(0, 19232)), new Pair.ptr(new $Int64(0, 19681), new $Int64(0, 14156)), new Pair.ptr(new $Int64(0, 19687), new $Int64(0, 6316)), new Pair.ptr(new $Int64(0, 19697), new $Int64(0, 16963)), new Pair.ptr(new $Int64(0, 19699), new $Int64(0, 10545)), new Pair.ptr(new $Int64(0, 19709), new $Int64(0, 17755)), new Pair.ptr(new $Int64(0, 19717), new $Int64(0, 15086)), new Pair.ptr(new $Int64(0, 19727), new $Int64(0, 2637)), new Pair.ptr(new $Int64(0, 19739), new $Int64(0, 7247)), new Pair.ptr(new $Int64(0, 19751), new $Int64(0, 19029)), new Pair.ptr(new $Int64(0, 19753), new $Int64(0, 14488)), new Pair.ptr(new $Int64(0, 19759), new $Int64(0, 12403)), new Pair.ptr(new $Int64(0, 19763), new $Int64(0, 14316)), new Pair.ptr(new $Int64(0, 19777), new $Int64(0, 15043)), new Pair.ptr(new $Int64(0, 19793), new $Int64(0, 4723)), new Pair.ptr(new $Int64(0, 19801), new $Int64(0, 14361)), new Pair.ptr(new $Int64(0, 19813), new $Int64(0, 13097)), new Pair.ptr(new $Int64(0, 19819), new $Int64(0, 11520)), new Pair.ptr(new $Int64(0, 19841), new $Int64(0, 3898)), new Pair.ptr(new $Int64(0, 19843), new $Int64(0, 2784)), new Pair.ptr(new $Int64(0, 19853), new $Int64(0, 12740)), new Pair.ptr(new $Int64(0, 19861), new $Int64(0, 15843)), new Pair.ptr(new $Int64(0, 19867), new $Int64(0, 3744)), new Pair.ptr(new $Int64(0, 19889), new $Int64(0, 8072)), new Pair.ptr(new $Int64(0, 19891), new $Int64(0, 12464)), new Pair.ptr(new $Int64(0, 19913), new $Int64(0, 5428)), new Pair.ptr(new $Int64(0, 19919), new $Int64(0, 19163)), new Pair.ptr(new $Int64(0, 19927), new $Int64(0, 10892)), new Pair.ptr(new $Int64(0, 19937), new $Int64(0, 8207)), new Pair.ptr(new $Int64(0, 19949), new $Int64(0, 18310)), new Pair.ptr(new $Int64(0, 19961), new $Int64(0, 1748)), new Pair.ptr(new $Int64(0, 19963), new $Int64(0, 2043)), new Pair.ptr(new $Int64(0, 19973), new $Int64(0, 18344)), new Pair.ptr(new $Int64(0, 19979), new $Int64(0, 14700)), new Pair.ptr(new $Int64(0, 19991), new $Int64(0, 6319)), new Pair.ptr(new $Int64(0, 19993), new $Int64(0, 3579)), new Pair.ptr(new $Int64(0, 19997), new $Int64(0, 12317)), new Pair.ptr(new $Int64(0, 20011), new $Int64(0, 17417)), new Pair.ptr(new $Int64(0, 20021), new $Int64(0, 16684)), new Pair.ptr(new $Int64(0, 20023), new $Int64(0, 14461)), new Pair.ptr(new $Int64(0, 20029), new $Int64(0, 15949)), new Pair.ptr(new $Int64(0, 20047), new $Int64(0, 9776)), new Pair.ptr(new $Int64(0, 20051), new $Int64(0, 539)), new Pair.ptr(new $Int64(0, 20063), new $Int64(0, 15786)), new Pair.ptr(new $Int64(0, 20071), new $Int64(0, 15414)), new Pair.ptr(new $Int64(0, 20089), new $Int64(0, 7036)), new Pair.ptr(new $Int64(0, 20101), new $Int64(0, 1034)), new Pair.ptr(new $Int64(0, 20107), new $Int64(0, 9052)), new Pair.ptr(new $Int64(0, 20113), new $Int64(0, 2415)), new Pair.ptr(new $Int64(0, 20117), new $Int64(0, 795)), new Pair.ptr(new $Int64(0, 20123), new $Int64(0, 14034)), new Pair.ptr(new $Int64(0, 20129), new $Int64(0, 6802)), new Pair.ptr(new $Int64(0, 20143), new $Int64(0, 19679)), new Pair.ptr(new $Int64(0, 20147), new $Int64(0, 8540)), new Pair.ptr(new $Int64(0, 20149), new $Int64(0, 807)), new Pair.ptr(new $Int64(0, 20161), new $Int64(0, 18469)), new Pair.ptr(new $Int64(0, 20173), new $Int64(0, 9647)), new Pair.ptr(new $Int64(0, 20177), new $Int64(0, 19513)), new Pair.ptr(new $Int64(0, 20183), new $Int64(0, 5799)), new Pair.ptr(new $Int64(0, 20201), new $Int64(0, 5785)), new Pair.ptr(new $Int64(0, 20219), new $Int64(0, 11261)), new Pair.ptr(new $Int64(0, 20231), new $Int64(0, 8901)), new Pair.ptr(new $Int64(0, 20233), new $Int64(0, 18539)), new Pair.ptr(new $Int64(0, 20249), new $Int64(0, 14752)), new Pair.ptr(new $Int64(0, 20261), new $Int64(0, 19070)), new Pair.ptr(new $Int64(0, 20269), new $Int64(0, 1723)), new Pair.ptr(new $Int64(0, 20287), new $Int64(0, 18932)), new Pair.ptr(new $Int64(0, 20297), new $Int64(0, 1380)), new Pair.ptr(new $Int64(0, 20323), new $Int64(0, 18322)), new Pair.ptr(new $Int64(0, 20327), new $Int64(0, 19389)), new Pair.ptr(new $Int64(0, 20333), new $Int64(0, 10448)), new Pair.ptr(new $Int64(0, 20341), new $Int64(0, 2672)), new Pair.ptr(new $Int64(0, 20347), new $Int64(0, 11335)), new Pair.ptr(new $Int64(0, 20353), new $Int64(0, 7039)), new Pair.ptr(new $Int64(0, 20357), new $Int64(0, 8024)), new Pair.ptr(new $Int64(0, 20359), new $Int64(0, 19288)), new Pair.ptr(new $Int64(0, 20369), new $Int64(0, 107)), new Pair.ptr(new $Int64(0, 20389), new $Int64(0, 17967)), new Pair.ptr(new $Int64(0, 20393), new $Int64(0, 975)), new Pair.ptr(new $Int64(0, 20399), new $Int64(0, 15223)), new Pair.ptr(new $Int64(0, 20407), new $Int64(0, 18412)), new Pair.ptr(new $Int64(0, 20411), new $Int64(0, 7665)), new Pair.ptr(new $Int64(0, 20431), new $Int64(0, 16711)), new Pair.ptr(new $Int64(0, 20441), new $Int64(0, 5527)), new Pair.ptr(new $Int64(0, 20443), new $Int64(0, 3971)), new Pair.ptr(new $Int64(0, 20477), new $Int64(0, 12449)), new Pair.ptr(new $Int64(0, 20479), new $Int64(0, 989)), new Pair.ptr(new $Int64(0, 20483), new $Int64(0, 11318)), new Pair.ptr(new $Int64(0, 20507), new $Int64(0, 5804)), new Pair.ptr(new $Int64(0, 20509), new $Int64(0, 4243)), new Pair.ptr(new $Int64(0, 20521), new $Int64(0, 7011)), new Pair.ptr(new $Int64(0, 20533), new $Int64(0, 527)), new Pair.ptr(new $Int64(0, 20543), new $Int64(0, 15548)), new Pair.ptr(new $Int64(0, 20549), new $Int64(0, 2130)), new Pair.ptr(new $Int64(0, 20551), new $Int64(0, 15023)), new Pair.ptr(new $Int64(0, 20563), new $Int64(0, 11102)), new Pair.ptr(new $Int64(0, 20593), new $Int64(0, 12944)), new Pair.ptr(new $Int64(0, 20599), new $Int64(0, 3279)), new Pair.ptr(new $Int64(0, 20611), new $Int64(0, 10259)), new Pair.ptr(new $Int64(0, 20627), new $Int64(0, 15626)), new Pair.ptr(new $Int64(0, 20639), new $Int64(0, 14165)), new Pair.ptr(new $Int64(0, 20641), new $Int64(0, 11506)), new Pair.ptr(new $Int64(0, 20663), new $Int64(0, 11242)), new Pair.ptr(new $Int64(0, 20681), new $Int64(0, 19393)), new Pair.ptr(new $Int64(0, 20693), new $Int64(0, 19212)), new Pair.ptr(new $Int64(0, 20707), new $Int64(0, 427)), new Pair.ptr(new $Int64(0, 20717), new $Int64(0, 322)), new Pair.ptr(new $Int64(0, 20719), new $Int64(0, 4540)), new Pair.ptr(new $Int64(0, 20731), new $Int64(0, 9656)), new Pair.ptr(new $Int64(0, 20743), new $Int64(0, 15727)), new Pair.ptr(new $Int64(0, 20747), new $Int64(0, 566)), new Pair.ptr(new $Int64(0, 20749), new $Int64(0, 3961)), new Pair.ptr(new $Int64(0, 20753), new $Int64(0, 10301)), new Pair.ptr(new $Int64(0, 20759), new $Int64(0, 5164)), new Pair.ptr(new $Int64(0, 20771), new $Int64(0, 12635)), new Pair.ptr(new $Int64(0, 20773), new $Int64(0, 10598)), new Pair.ptr(new $Int64(0, 20789), new $Int64(0, 5997)), new Pair.ptr(new $Int64(0, 20807), new $Int64(0, 14193)), new Pair.ptr(new $Int64(0, 20809), new $Int64(0, 15354)), new Pair.ptr(new $Int64(0, 20849), new $Int64(0, 18355)), new Pair.ptr(new $Int64(0, 20857), new $Int64(0, 11093)), new Pair.ptr(new $Int64(0, 20873), new $Int64(0, 1978)), new Pair.ptr(new $Int64(0, 20879), new $Int64(0, 5319)), new Pair.ptr(new $Int64(0, 20887), new $Int64(0, 8725)), new Pair.ptr(new $Int64(0, 20897), new $Int64(0, 14531)), new Pair.ptr(new $Int64(0, 20899), new $Int64(0, 3713)), new Pair.ptr(new $Int64(0, 20903), new $Int64(0, 20686)), new Pair.ptr(new $Int64(0, 20921), new $Int64(0, 8541)), new Pair.ptr(new $Int64(0, 20929), new $Int64(0, 3964)), new Pair.ptr(new $Int64(0, 20939), new $Int64(0, 16515)), new Pair.ptr(new $Int64(0, 20947), new $Int64(0, 2399)), new Pair.ptr(new $Int64(0, 20959), new $Int64(0, 12905)), new Pair.ptr(new $Int64(0, 20963), new $Int64(0, 4798)), new Pair.ptr(new $Int64(0, 20981), new $Int64(0, 695)), new Pair.ptr(new $Int64(0, 20983), new $Int64(0, 12576)), new Pair.ptr(new $Int64(0, 21001), new $Int64(0, 15567)), new Pair.ptr(new $Int64(0, 21011), new $Int64(0, 8562)), new Pair.ptr(new $Int64(0, 21013), new $Int64(0, 1379)), new Pair.ptr(new $Int64(0, 21017), new $Int64(0, 16945)), new Pair.ptr(new $Int64(0, 21019), new $Int64(0, 7094)), new Pair.ptr(new $Int64(0, 21023), new $Int64(0, 2365)), new Pair.ptr(new $Int64(0, 21031), new $Int64(0, 5100)), new Pair.ptr(new $Int64(0, 21059), new $Int64(0, 17914)), new Pair.ptr(new $Int64(0, 21061), new $Int64(0, 12992)), new Pair.ptr(new $Int64(0, 21067), new $Int64(0, 9400)), new Pair.ptr(new $Int64(0, 21089), new $Int64(0, 18166)), new Pair.ptr(new $Int64(0, 21101), new $Int64(0, 4662)), new Pair.ptr(new $Int64(0, 21107), new $Int64(0, 1356)), new Pair.ptr(new $Int64(0, 21121), new $Int64(0, 5106)), new Pair.ptr(new $Int64(0, 21139), new $Int64(0, 9732)), new Pair.ptr(new $Int64(0, 21143), new $Int64(0, 5758)), new Pair.ptr(new $Int64(0, 21149), new $Int64(0, 6291)), new Pair.ptr(new $Int64(0, 21157), new $Int64(0, 14666)), new Pair.ptr(new $Int64(0, 21163), new $Int64(0, 4132)), new Pair.ptr(new $Int64(0, 21169), new $Int64(0, 7520)), new Pair.ptr(new $Int64(0, 21179), new $Int64(0, 7416)), new Pair.ptr(new $Int64(0, 21187), new $Int64(0, 6321)), new Pair.ptr(new $Int64(0, 21191), new $Int64(0, 18003)), new Pair.ptr(new $Int64(0, 21193), new $Int64(0, 12072)), new Pair.ptr(new $Int64(0, 21211), new $Int64(0, 2336)), new Pair.ptr(new $Int64(0, 21221), new $Int64(0, 16624)), new Pair.ptr(new $Int64(0, 21227), new $Int64(0, 16335)), new Pair.ptr(new $Int64(0, 21247), new $Int64(0, 4609)), new Pair.ptr(new $Int64(0, 21269), new $Int64(0, 19989)), new Pair.ptr(new $Int64(0, 21277), new $Int64(0, 14069)), new Pair.ptr(new $Int64(0, 21283), new $Int64(0, 4283)), new Pair.ptr(new $Int64(0, 21313), new $Int64(0, 1239)), new Pair.ptr(new $Int64(0, 21317), new $Int64(0, 9382)), new Pair.ptr(new $Int64(0, 21319), new $Int64(0, 5353)), new Pair.ptr(new $Int64(0, 21323), new $Int64(0, 4923)), new Pair.ptr(new $Int64(0, 21341), new $Int64(0, 3713)), new Pair.ptr(new $Int64(0, 21347), new $Int64(0, 17387)), new Pair.ptr(new $Int64(0, 21377), new $Int64(0, 15719)), new Pair.ptr(new $Int64(0, 21379), new $Int64(0, 19368)), new Pair.ptr(new $Int64(0, 21383), new $Int64(0, 12595)), new Pair.ptr(new $Int64(0, 21391), new $Int64(0, 13842)), new Pair.ptr(new $Int64(0, 21397), new $Int64(0, 19364)), new Pair.ptr(new $Int64(0, 21401), new $Int64(0, 1981)), new Pair.ptr(new $Int64(0, 21407), new $Int64(0, 18580)), new Pair.ptr(new $Int64(0, 21419), new $Int64(0, 4269)), new Pair.ptr(new $Int64(0, 21433), new $Int64(0, 19767)), new Pair.ptr(new $Int64(0, 21467), new $Int64(0, 3202)), new Pair.ptr(new $Int64(0, 21481), new $Int64(0, 18734)), new Pair.ptr(new $Int64(0, 21487), new $Int64(0, 13419)), new Pair.ptr(new $Int64(0, 21491), new $Int64(0, 19750)), new Pair.ptr(new $Int64(0, 21493), new $Int64(0, 7444)), new Pair.ptr(new $Int64(0, 21499), new $Int64(0, 14902)), new Pair.ptr(new $Int64(0, 21503), new $Int64(0, 3579)), new Pair.ptr(new $Int64(0, 21517), new $Int64(0, 10380)), new Pair.ptr(new $Int64(0, 21521), new $Int64(0, 6636)), new Pair.ptr(new $Int64(0, 21523), new $Int64(0, 7234)), new Pair.ptr(new $Int64(0, 21529), new $Int64(0, 15154)), new Pair.ptr(new $Int64(0, 21557), new $Int64(0, 5159)), new Pair.ptr(new $Int64(0, 21559), new $Int64(0, 19348)), new Pair.ptr(new $Int64(0, 21563), new $Int64(0, 8662)), new Pair.ptr(new $Int64(0, 21569), new $Int64(0, 8603)), new Pair.ptr(new $Int64(0, 21577), new $Int64(0, 21219)), new Pair.ptr(new $Int64(0, 21587), new $Int64(0, 287)), new Pair.ptr(new $Int64(0, 21589), new $Int64(0, 649)), new Pair.ptr(new $Int64(0, 21599), new $Int64(0, 5524)), new Pair.ptr(new $Int64(0, 21601), new $Int64(0, 8200)), new Pair.ptr(new $Int64(0, 21611), new $Int64(0, 17982)), new Pair.ptr(new $Int64(0, 21613), new $Int64(0, 2865)), new Pair.ptr(new $Int64(0, 21617), new $Int64(0, 282)), new Pair.ptr(new $Int64(0, 21647), new $Int64(0, 1142)), new Pair.ptr(new $Int64(0, 21649), new $Int64(0, 8707)), new Pair.ptr(new $Int64(0, 21661), new $Int64(0, 21650)), new Pair.ptr(new $Int64(0, 21673), new $Int64(0, 9639)), new Pair.ptr(new $Int64(0, 21683), new $Int64(0, 10898)), new Pair.ptr(new $Int64(0, 21701), new $Int64(0, 11255)), new Pair.ptr(new $Int64(0, 21713), new $Int64(0, 16786)), new Pair.ptr(new $Int64(0, 21727), new $Int64(0, 13634)), new Pair.ptr(new $Int64(0, 21737), new $Int64(0, 12835)), new Pair.ptr(new $Int64(0, 21739), new $Int64(0, 16632)), new Pair.ptr(new $Int64(0, 21751), new $Int64(0, 10620)), new Pair.ptr(new $Int64(0, 21757), new $Int64(0, 20494)), new Pair.ptr(new $Int64(0, 21767), new $Int64(0, 1518)), new Pair.ptr(new $Int64(0, 21773), new $Int64(0, 7947)), new Pair.ptr(new $Int64(0, 21787), new $Int64(0, 20778)), new Pair.ptr(new $Int64(0, 21799), new $Int64(0, 21654)), new Pair.ptr(new $Int64(0, 21803), new $Int64(0, 11089)), new Pair.ptr(new $Int64(0, 21817), new $Int64(0, 5174)), new Pair.ptr(new $Int64(0, 21821), new $Int64(0, 12320)), new Pair.ptr(new $Int64(0, 21839), new $Int64(0, 9927)), new Pair.ptr(new $Int64(0, 21841), new $Int64(0, 7942)), new Pair.ptr(new $Int64(0, 21851), new $Int64(0, 5237)), new Pair.ptr(new $Int64(0, 21859), new $Int64(0, 3556)), new Pair.ptr(new $Int64(0, 21863), new $Int64(0, 12703)), new Pair.ptr(new $Int64(0, 21871), new $Int64(0, 18151)), new Pair.ptr(new $Int64(0, 21881), new $Int64(0, 16059)), new Pair.ptr(new $Int64(0, 21893), new $Int64(0, 8975)), new Pair.ptr(new $Int64(0, 21911), new $Int64(0, 6116)), new Pair.ptr(new $Int64(0, 21929), new $Int64(0, 7235)), new Pair.ptr(new $Int64(0, 21937), new $Int64(0, 18483)), new Pair.ptr(new $Int64(0, 21943), new $Int64(0, 12976)), new Pair.ptr(new $Int64(0, 21961), new $Int64(0, 21895)), new Pair.ptr(new $Int64(0, 21977), new $Int64(0, 21627)), new Pair.ptr(new $Int64(0, 21991), new $Int64(0, 13703)), new Pair.ptr(new $Int64(0, 21997), new $Int64(0, 4942)), new Pair.ptr(new $Int64(0, 22003), new $Int64(0, 1988)), new Pair.ptr(new $Int64(0, 22013), new $Int64(0, 14390)), new Pair.ptr(new $Int64(0, 22027), new $Int64(0, 21513)), new Pair.ptr(new $Int64(0, 22031), new $Int64(0, 17176)), new Pair.ptr(new $Int64(0, 22037), new $Int64(0, 2522)), new Pair.ptr(new $Int64(0, 22039), new $Int64(0, 1923)), new Pair.ptr(new $Int64(0, 22051), new $Int64(0, 7363)), new Pair.ptr(new $Int64(0, 22063), new $Int64(0, 15758)), new Pair.ptr(new $Int64(0, 22067), new $Int64(0, 1087)), new Pair.ptr(new $Int64(0, 22073), new $Int64(0, 12169)), new Pair.ptr(new $Int64(0, 22079), new $Int64(0, 7676)), new Pair.ptr(new $Int64(0, 22091), new $Int64(0, 7369)), new Pair.ptr(new $Int64(0, 22093), new $Int64(0, 11757)), new Pair.ptr(new $Int64(0, 22109), new $Int64(0, 5163)), new Pair.ptr(new $Int64(0, 22111), new $Int64(0, 17312)), new Pair.ptr(new $Int64(0, 22123), new $Int64(0, 10795)), new Pair.ptr(new $Int64(0, 22129), new $Int64(0, 3926)), new Pair.ptr(new $Int64(0, 22133), new $Int64(0, 3413)), new Pair.ptr(new $Int64(0, 22147), new $Int64(0, 12736)), new Pair.ptr(new $Int64(0, 22153), new $Int64(0, 978)), new Pair.ptr(new $Int64(0, 22157), new $Int64(0, 610)), new Pair.ptr(new $Int64(0, 22159), new $Int64(0, 5254)), new Pair.ptr(new $Int64(0, 22171), new $Int64(0, 8732)), new Pair.ptr(new $Int64(0, 22189), new $Int64(0, 17935)), new Pair.ptr(new $Int64(0, 22193), new $Int64(0, 4298)), new Pair.ptr(new $Int64(0, 22229), new $Int64(0, 17538)), new Pair.ptr(new $Int64(0, 22247), new $Int64(0, 13864)), new Pair.ptr(new $Int64(0, 22259), new $Int64(0, 11441)), new Pair.ptr(new $Int64(0, 22271), new $Int64(0, 1522)), new Pair.ptr(new $Int64(0, 22273), new $Int64(0, 6991)), new Pair.ptr(new $Int64(0, 22277), new $Int64(0, 21466)), new Pair.ptr(new $Int64(0, 22279), new $Int64(0, 16166)), new Pair.ptr(new $Int64(0, 22283), new $Int64(0, 18323)), new Pair.ptr(new $Int64(0, 22291), new $Int64(0, 15304)), new Pair.ptr(new $Int64(0, 22303), new $Int64(0, 1848)), new Pair.ptr(new $Int64(0, 22307), new $Int64(0, 9879)), new Pair.ptr(new $Int64(0, 22343), new $Int64(0, 20437)), new Pair.ptr(new $Int64(0, 22349), new $Int64(0, 7608)), new Pair.ptr(new $Int64(0, 22367), new $Int64(0, 17000)), new Pair.ptr(new $Int64(0, 22369), new $Int64(0, 14181)), new Pair.ptr(new $Int64(0, 22381), new $Int64(0, 15036)), new Pair.ptr(new $Int64(0, 22391), new $Int64(0, 19358)), new Pair.ptr(new $Int64(0, 22397), new $Int64(0, 21962)), new Pair.ptr(new $Int64(0, 22409), new $Int64(0, 15363)), new Pair.ptr(new $Int64(0, 22433), new $Int64(0, 13488)), new Pair.ptr(new $Int64(0, 22441), new $Int64(0, 21701)), new Pair.ptr(new $Int64(0, 22447), new $Int64(0, 14624)), new Pair.ptr(new $Int64(0, 22453), new $Int64(0, 21504)), new Pair.ptr(new $Int64(0, 22469), new $Int64(0, 5696)), new Pair.ptr(new $Int64(0, 22481), new $Int64(0, 711)), new Pair.ptr(new $Int64(0, 22483), new $Int64(0, 1672)), new Pair.ptr(new $Int64(0, 22501), new $Int64(0, 10531)), new Pair.ptr(new $Int64(0, 22511), new $Int64(0, 4282)), new Pair.ptr(new $Int64(0, 22531), new $Int64(0, 1491)), new Pair.ptr(new $Int64(0, 22541), new $Int64(0, 6016)), new Pair.ptr(new $Int64(0, 22543), new $Int64(0, 18488)), new Pair.ptr(new $Int64(0, 22549), new $Int64(0, 20794)), new Pair.ptr(new $Int64(0, 22567), new $Int64(0, 12583)), new Pair.ptr(new $Int64(0, 22571), new $Int64(0, 12129)), new Pair.ptr(new $Int64(0, 22573), new $Int64(0, 2654)), new Pair.ptr(new $Int64(0, 22613), new $Int64(0, 6356)), new Pair.ptr(new $Int64(0, 22619), new $Int64(0, 16891)), new Pair.ptr(new $Int64(0, 22621), new $Int64(0, 15717)), new Pair.ptr(new $Int64(0, 22637), new $Int64(0, 3744)), new Pair.ptr(new $Int64(0, 22639), new $Int64(0, 6182)), new Pair.ptr(new $Int64(0, 22643), new $Int64(0, 7716)), new Pair.ptr(new $Int64(0, 22651), new $Int64(0, 7767)), new Pair.ptr(new $Int64(0, 22669), new $Int64(0, 17553)), new Pair.ptr(new $Int64(0, 22679), new $Int64(0, 22362)), new Pair.ptr(new $Int64(0, 22691), new $Int64(0, 5597)), new Pair.ptr(new $Int64(0, 22697), new $Int64(0, 4967)), new Pair.ptr(new $Int64(0, 22699), new $Int64(0, 17820)), new Pair.ptr(new $Int64(0, 22709), new $Int64(0, 18257)), new Pair.ptr(new $Int64(0, 22717), new $Int64(0, 11322)), new Pair.ptr(new $Int64(0, 22721), new $Int64(0, 4600)), new Pair.ptr(new $Int64(0, 22727), new $Int64(0, 13482)), new Pair.ptr(new $Int64(0, 22739), new $Int64(0, 6781)), new Pair.ptr(new $Int64(0, 22741), new $Int64(0, 670)), new Pair.ptr(new $Int64(0, 22751), new $Int64(0, 3964)), new Pair.ptr(new $Int64(0, 22769), new $Int64(0, 15951)), new Pair.ptr(new $Int64(0, 22777), new $Int64(0, 8519)), new Pair.ptr(new $Int64(0, 22783), new $Int64(0, 727)), new Pair.ptr(new $Int64(0, 22787), new $Int64(0, 15168)), new Pair.ptr(new $Int64(0, 22807), new $Int64(0, 16499)), new Pair.ptr(new $Int64(0, 22811), new $Int64(0, 16451)), new Pair.ptr(new $Int64(0, 22817), new $Int64(0, 6019)), new Pair.ptr(new $Int64(0, 22853), new $Int64(0, 13341)), new Pair.ptr(new $Int64(0, 22859), new $Int64(0, 7205)), new Pair.ptr(new $Int64(0, 22861), new $Int64(0, 16272)), new Pair.ptr(new $Int64(0, 22871), new $Int64(0, 22629)), new Pair.ptr(new $Int64(0, 22877), new $Int64(0, 11257)), new Pair.ptr(new $Int64(0, 22901), new $Int64(0, 3687)), new Pair.ptr(new $Int64(0, 22907), new $Int64(0, 808)), new Pair.ptr(new $Int64(0, 22921), new $Int64(0, 10968)), new Pair.ptr(new $Int64(0, 22937), new $Int64(0, 22228)), new Pair.ptr(new $Int64(0, 22943), new $Int64(0, 4873)), new Pair.ptr(new $Int64(0, 22961), new $Int64(0, 13755)), new Pair.ptr(new $Int64(0, 22963), new $Int64(0, 18431)), new Pair.ptr(new $Int64(0, 22973), new $Int64(0, 12057)), new Pair.ptr(new $Int64(0, 22993), new $Int64(0, 5678)), new Pair.ptr(new $Int64(0, 23003), new $Int64(0, 12067)), new Pair.ptr(new $Int64(0, 23011), new $Int64(0, 8741)), new Pair.ptr(new $Int64(0, 23017), new $Int64(0, 32)), new Pair.ptr(new $Int64(0, 23021), new $Int64(0, 7386)), new Pair.ptr(new $Int64(0, 23027), new $Int64(0, 5229)), new Pair.ptr(new $Int64(0, 23029), new $Int64(0, 18775)), new Pair.ptr(new $Int64(0, 23039), new $Int64(0, 22763)), new Pair.ptr(new $Int64(0, 23041), new $Int64(0, 15606)), new Pair.ptr(new $Int64(0, 23053), new $Int64(0, 22355)), new Pair.ptr(new $Int64(0, 23057), new $Int64(0, 21469)), new Pair.ptr(new $Int64(0, 23059), new $Int64(0, 411)), new Pair.ptr(new $Int64(0, 23063), new $Int64(0, 9230)), new Pair.ptr(new $Int64(0, 23071), new $Int64(0, 6701)), new Pair.ptr(new $Int64(0, 23081), new $Int64(0, 4719)), new Pair.ptr(new $Int64(0, 23087), new $Int64(0, 12773)), new Pair.ptr(new $Int64(0, 23099), new $Int64(0, 7996)), new Pair.ptr(new $Int64(0, 23117), new $Int64(0, 6433)), new Pair.ptr(new $Int64(0, 23131), new $Int64(0, 1808)), new Pair.ptr(new $Int64(0, 23143), new $Int64(0, 17616)), new Pair.ptr(new $Int64(0, 23159), new $Int64(0, 11036)), new Pair.ptr(new $Int64(0, 23167), new $Int64(0, 10094)), new Pair.ptr(new $Int64(0, 23173), new $Int64(0, 1868)), new Pair.ptr(new $Int64(0, 23189), new $Int64(0, 1894)), new Pair.ptr(new $Int64(0, 23197), new $Int64(0, 14597)), new Pair.ptr(new $Int64(0, 23201), new $Int64(0, 15753)), new Pair.ptr(new $Int64(0, 23203), new $Int64(0, 4878)), new Pair.ptr(new $Int64(0, 23209), new $Int64(0, 9033)), new Pair.ptr(new $Int64(0, 23227), new $Int64(0, 9250)), new Pair.ptr(new $Int64(0, 23251), new $Int64(0, 9529)), new Pair.ptr(new $Int64(0, 23269), new $Int64(0, 10300)), new Pair.ptr(new $Int64(0, 23279), new $Int64(0, 10349)), new Pair.ptr(new $Int64(0, 23291), new $Int64(0, 21823)), new Pair.ptr(new $Int64(0, 23293), new $Int64(0, 9929)), new Pair.ptr(new $Int64(0, 23297), new $Int64(0, 141)), new Pair.ptr(new $Int64(0, 23311), new $Int64(0, 16831)), new Pair.ptr(new $Int64(0, 23321), new $Int64(0, 5467)), new Pair.ptr(new $Int64(0, 23327), new $Int64(0, 415)), new Pair.ptr(new $Int64(0, 23333), new $Int64(0, 3971)), new Pair.ptr(new $Int64(0, 23339), new $Int64(0, 13908)), new Pair.ptr(new $Int64(0, 23357), new $Int64(0, 21410)), new Pair.ptr(new $Int64(0, 23369), new $Int64(0, 17632)), new Pair.ptr(new $Int64(0, 23371), new $Int64(0, 10372)), new Pair.ptr(new $Int64(0, 23399), new $Int64(0, 16106)), new Pair.ptr(new $Int64(0, 23417), new $Int64(0, 6458)), new Pair.ptr(new $Int64(0, 23431), new $Int64(0, 10621)), new Pair.ptr(new $Int64(0, 23447), new $Int64(0, 21147)), new Pair.ptr(new $Int64(0, 23459), new $Int64(0, 6527)), new Pair.ptr(new $Int64(0, 23473), new $Int64(0, 2326)), new Pair.ptr(new $Int64(0, 23497), new $Int64(0, 21018)), new Pair.ptr(new $Int64(0, 23509), new $Int64(0, 21327)), new Pair.ptr(new $Int64(0, 23531), new $Int64(0, 16171)), new Pair.ptr(new $Int64(0, 23537), new $Int64(0, 17660)), new Pair.ptr(new $Int64(0, 23539), new $Int64(0, 1854)), new Pair.ptr(new $Int64(0, 23549), new $Int64(0, 19097)), new Pair.ptr(new $Int64(0, 23557), new $Int64(0, 2845)), new Pair.ptr(new $Int64(0, 23561), new $Int64(0, 20752)), new Pair.ptr(new $Int64(0, 23563), new $Int64(0, 3353)), new Pair.ptr(new $Int64(0, 23567), new $Int64(0, 10025)), new Pair.ptr(new $Int64(0, 23581), new $Int64(0, 20483)), new Pair.ptr(new $Int64(0, 23593), new $Int64(0, 6109)), new Pair.ptr(new $Int64(0, 23599), new $Int64(0, 3898)), new Pair.ptr(new $Int64(0, 23603), new $Int64(0, 3846)), new Pair.ptr(new $Int64(0, 23609), new $Int64(0, 14063)), new Pair.ptr(new $Int64(0, 23623), new $Int64(0, 919)), new Pair.ptr(new $Int64(0, 23627), new $Int64(0, 857)), new Pair.ptr(new $Int64(0, 23629), new $Int64(0, 3661)), new Pair.ptr(new $Int64(0, 23633), new $Int64(0, 1366)), new Pair.ptr(new $Int64(0, 23663), new $Int64(0, 18524)), new Pair.ptr(new $Int64(0, 23669), new $Int64(0, 20282)), new Pair.ptr(new $Int64(0, 23671), new $Int64(0, 18226)), new Pair.ptr(new $Int64(0, 23677), new $Int64(0, 4326)), new Pair.ptr(new $Int64(0, 23687), new $Int64(0, 15140)), new Pair.ptr(new $Int64(0, 23689), new $Int64(0, 11894)), new Pair.ptr(new $Int64(0, 23719), new $Int64(0, 6548)), new Pair.ptr(new $Int64(0, 23741), new $Int64(0, 17768)), new Pair.ptr(new $Int64(0, 23743), new $Int64(0, 3177)), new Pair.ptr(new $Int64(0, 23747), new $Int64(0, 22924)), new Pair.ptr(new $Int64(0, 23753), new $Int64(0, 6451)), new Pair.ptr(new $Int64(0, 23761), new $Int64(0, 5222)), new Pair.ptr(new $Int64(0, 23767), new $Int64(0, 2164)), new Pair.ptr(new $Int64(0, 23773), new $Int64(0, 21462)), new Pair.ptr(new $Int64(0, 23789), new $Int64(0, 17533)), new Pair.ptr(new $Int64(0, 23801), new $Int64(0, 23246)), new Pair.ptr(new $Int64(0, 23813), new $Int64(0, 23655)), new Pair.ptr(new $Int64(0, 23819), new $Int64(0, 488)), new Pair.ptr(new $Int64(0, 23827), new $Int64(0, 12869)), new Pair.ptr(new $Int64(0, 23831), new $Int64(0, 6890)), new Pair.ptr(new $Int64(0, 23833), new $Int64(0, 13052)), new Pair.ptr(new $Int64(0, 23857), new $Int64(0, 200)), new Pair.ptr(new $Int64(0, 23869), new $Int64(0, 19126)), new Pair.ptr(new $Int64(0, 23873), new $Int64(0, 14640)), new Pair.ptr(new $Int64(0, 23879), new $Int64(0, 10902)), new Pair.ptr(new $Int64(0, 23887), new $Int64(0, 13844)), new Pair.ptr(new $Int64(0, 23893), new $Int64(0, 4122)), new Pair.ptr(new $Int64(0, 23899), new $Int64(0, 5774)), new Pair.ptr(new $Int64(0, 23909), new $Int64(0, 5655)), new Pair.ptr(new $Int64(0, 23911), new $Int64(0, 14135)), new Pair.ptr(new $Int64(0, 23917), new $Int64(0, 15289)), new Pair.ptr(new $Int64(0, 23929), new $Int64(0, 20453)), new Pair.ptr(new $Int64(0, 23957), new $Int64(0, 2646)), new Pair.ptr(new $Int64(0, 23971), new $Int64(0, 19810)), new Pair.ptr(new $Int64(0, 23977), new $Int64(0, 6836)), new Pair.ptr(new $Int64(0, 23981), new $Int64(0, 15504)), new Pair.ptr(new $Int64(0, 23993), new $Int64(0, 9752)), new Pair.ptr(new $Int64(0, 24001), new $Int64(0, 9183)), new Pair.ptr(new $Int64(0, 24007), new $Int64(0, 17511)), new Pair.ptr(new $Int64(0, 24019), new $Int64(0, 20176)), new Pair.ptr(new $Int64(0, 24023), new $Int64(0, 14414)), new Pair.ptr(new $Int64(0, 24029), new $Int64(0, 18262)), new Pair.ptr(new $Int64(0, 24043), new $Int64(0, 3037)), new Pair.ptr(new $Int64(0, 24049), new $Int64(0, 14237)), new Pair.ptr(new $Int64(0, 24061), new $Int64(0, 13136)), new Pair.ptr(new $Int64(0, 24071), new $Int64(0, 12394)), new Pair.ptr(new $Int64(0, 24077), new $Int64(0, 23441)), new Pair.ptr(new $Int64(0, 24083), new $Int64(0, 8327)), new Pair.ptr(new $Int64(0, 24091), new $Int64(0, 16612)), new Pair.ptr(new $Int64(0, 24097), new $Int64(0, 20664)), new Pair.ptr(new $Int64(0, 24103), new $Int64(0, 15072)), new Pair.ptr(new $Int64(0, 24107), new $Int64(0, 14987)), new Pair.ptr(new $Int64(0, 24109), new $Int64(0, 23485)), new Pair.ptr(new $Int64(0, 24113), new $Int64(0, 13655)), new Pair.ptr(new $Int64(0, 24121), new $Int64(0, 19446)), new Pair.ptr(new $Int64(0, 24133), new $Int64(0, 2524)), new Pair.ptr(new $Int64(0, 24137), new $Int64(0, 5041)), new Pair.ptr(new $Int64(0, 24151), new $Int64(0, 4602)), new Pair.ptr(new $Int64(0, 24169), new $Int64(0, 3467)), new Pair.ptr(new $Int64(0, 24179), new $Int64(0, 19312)), new Pair.ptr(new $Int64(0, 24181), new $Int64(0, 17743)), new Pair.ptr(new $Int64(0, 24197), new $Int64(0, 5259)), new Pair.ptr(new $Int64(0, 24203), new $Int64(0, 5733)), new Pair.ptr(new $Int64(0, 24223), new $Int64(0, 7839)), new Pair.ptr(new $Int64(0, 24229), new $Int64(0, 14041)), new Pair.ptr(new $Int64(0, 24239), new $Int64(0, 7531)), new Pair.ptr(new $Int64(0, 24247), new $Int64(0, 19963)), new Pair.ptr(new $Int64(0, 24251), new $Int64(0, 4722)), new Pair.ptr(new $Int64(0, 24281), new $Int64(0, 17214)), new Pair.ptr(new $Int64(0, 24317), new $Int64(0, 21877)), new Pair.ptr(new $Int64(0, 24329), new $Int64(0, 7881)), new Pair.ptr(new $Int64(0, 24337), new $Int64(0, 21429)), new Pair.ptr(new $Int64(0, 24359), new $Int64(0, 2385)), new Pair.ptr(new $Int64(0, 24371), new $Int64(0, 15044)), new Pair.ptr(new $Int64(0, 24373), new $Int64(0, 18814)), new Pair.ptr(new $Int64(0, 24379), new $Int64(0, 18116)), new Pair.ptr(new $Int64(0, 24391), new $Int64(0, 3868)), new Pair.ptr(new $Int64(0, 24407), new $Int64(0, 10553)), new Pair.ptr(new $Int64(0, 24413), new $Int64(0, 16154)), new Pair.ptr(new $Int64(0, 24419), new $Int64(0, 10868)), new Pair.ptr(new $Int64(0, 24421), new $Int64(0, 18651)), new Pair.ptr(new $Int64(0, 24439), new $Int64(0, 106)), new Pair.ptr(new $Int64(0, 24443), new $Int64(0, 18341)), new Pair.ptr(new $Int64(0, 24469), new $Int64(0, 20389)), new Pair.ptr(new $Int64(0, 24473), new $Int64(0, 16646)), new Pair.ptr(new $Int64(0, 24481), new $Int64(0, 9171)), new Pair.ptr(new $Int64(0, 24499), new $Int64(0, 19331)), new Pair.ptr(new $Int64(0, 24509), new $Int64(0, 12775)), new Pair.ptr(new $Int64(0, 24517), new $Int64(0, 2765)), new Pair.ptr(new $Int64(0, 24527), new $Int64(0, 11732)), new Pair.ptr(new $Int64(0, 24533), new $Int64(0, 20841)), new Pair.ptr(new $Int64(0, 24547), new $Int64(0, 3032)), new Pair.ptr(new $Int64(0, 24551), new $Int64(0, 22231)), new Pair.ptr(new $Int64(0, 24571), new $Int64(0, 10610)), new Pair.ptr(new $Int64(0, 24593), new $Int64(0, 15966)), new Pair.ptr(new $Int64(0, 24611), new $Int64(0, 21978)), new Pair.ptr(new $Int64(0, 24623), new $Int64(0, 11773)), new Pair.ptr(new $Int64(0, 24631), new $Int64(0, 12912)), new Pair.ptr(new $Int64(0, 24659), new $Int64(0, 9817)), new Pair.ptr(new $Int64(0, 24671), new $Int64(0, 18692)), new Pair.ptr(new $Int64(0, 24677), new $Int64(0, 8790)), new Pair.ptr(new $Int64(0, 24683), new $Int64(0, 10877)), new Pair.ptr(new $Int64(0, 24691), new $Int64(0, 21811)), new Pair.ptr(new $Int64(0, 24697), new $Int64(0, 7288)), new Pair.ptr(new $Int64(0, 24709), new $Int64(0, 101)), new Pair.ptr(new $Int64(0, 24733), new $Int64(0, 3921)), new Pair.ptr(new $Int64(0, 24749), new $Int64(0, 1700)), new Pair.ptr(new $Int64(0, 24763), new $Int64(0, 382)), new Pair.ptr(new $Int64(0, 24767), new $Int64(0, 20)), new Pair.ptr(new $Int64(0, 24781), new $Int64(0, 12217)), new Pair.ptr(new $Int64(0, 24793), new $Int64(0, 1367)), new Pair.ptr(new $Int64(0, 24799), new $Int64(0, 14873)), new Pair.ptr(new $Int64(0, 24809), new $Int64(0, 12572)), new Pair.ptr(new $Int64(0, 24821), new $Int64(0, 9972)), new Pair.ptr(new $Int64(0, 24841), new $Int64(0, 3077)), new Pair.ptr(new $Int64(0, 24847), new $Int64(0, 3007)), new Pair.ptr(new $Int64(0, 24851), new $Int64(0, 4243)), new Pair.ptr(new $Int64(0, 24859), new $Int64(0, 12885)), new Pair.ptr(new $Int64(0, 24877), new $Int64(0, 11479)), new Pair.ptr(new $Int64(0, 24889), new $Int64(0, 3073)), new Pair.ptr(new $Int64(0, 24907), new $Int64(0, 8874)), new Pair.ptr(new $Int64(0, 24917), new $Int64(0, 17986)), new Pair.ptr(new $Int64(0, 24919), new $Int64(0, 24106)), new Pair.ptr(new $Int64(0, 24923), new $Int64(0, 6526)), new Pair.ptr(new $Int64(0, 24943), new $Int64(0, 13853)), new Pair.ptr(new $Int64(0, 24953), new $Int64(0, 23379)), new Pair.ptr(new $Int64(0, 24967), new $Int64(0, 14869)), new Pair.ptr(new $Int64(0, 24971), new $Int64(0, 22524)), new Pair.ptr(new $Int64(0, 24977), new $Int64(0, 12727)), new Pair.ptr(new $Int64(0, 24979), new $Int64(0, 9254)), new Pair.ptr(new $Int64(0, 24989), new $Int64(0, 14548)), new Pair.ptr(new $Int64(0, 25013), new $Int64(0, 4082)), new Pair.ptr(new $Int64(0, 25031), new $Int64(0, 19990)), new Pair.ptr(new $Int64(0, 25033), new $Int64(0, 3781)), new Pair.ptr(new $Int64(0, 25037), new $Int64(0, 10519)), new Pair.ptr(new $Int64(0, 25057), new $Int64(0, 22088)), new Pair.ptr(new $Int64(0, 25073), new $Int64(0, 1850)), new Pair.ptr(new $Int64(0, 25087), new $Int64(0, 5041)), new Pair.ptr(new $Int64(0, 25097), new $Int64(0, 16223)), new Pair.ptr(new $Int64(0, 25111), new $Int64(0, 20865)), new Pair.ptr(new $Int64(0, 25117), new $Int64(0, 15755)), new Pair.ptr(new $Int64(0, 25121), new $Int64(0, 23431)), new Pair.ptr(new $Int64(0, 25127), new $Int64(0, 8078)), new Pair.ptr(new $Int64(0, 25147), new $Int64(0, 16069)), new Pair.ptr(new $Int64(0, 25153), new $Int64(0, 1613)), new Pair.ptr(new $Int64(0, 25163), new $Int64(0, 12270)), new Pair.ptr(new $Int64(0, 25169), new $Int64(0, 5513)), new Pair.ptr(new $Int64(0, 25171), new $Int64(0, 7751)), new Pair.ptr(new $Int64(0, 25183), new $Int64(0, 2942)), new Pair.ptr(new $Int64(0, 25189), new $Int64(0, 7174)), new Pair.ptr(new $Int64(0, 25219), new $Int64(0, 14684)), new Pair.ptr(new $Int64(0, 25229), new $Int64(0, 4581)), new Pair.ptr(new $Int64(0, 25237), new $Int64(0, 1989)), new Pair.ptr(new $Int64(0, 25243), new $Int64(0, 24775)), new Pair.ptr(new $Int64(0, 25247), new $Int64(0, 22039)), new Pair.ptr(new $Int64(0, 25253), new $Int64(0, 4878)), new Pair.ptr(new $Int64(0, 25261), new $Int64(0, 3394)), new Pair.ptr(new $Int64(0, 25301), new $Int64(0, 13021)), new Pair.ptr(new $Int64(0, 25303), new $Int64(0, 11601)), new Pair.ptr(new $Int64(0, 25307), new $Int64(0, 19500)), new Pair.ptr(new $Int64(0, 25309), new $Int64(0, 7638)), new Pair.ptr(new $Int64(0, 25321), new $Int64(0, 5236)), new Pair.ptr(new $Int64(0, 25339), new $Int64(0, 20171)), new Pair.ptr(new $Int64(0, 25343), new $Int64(0, 15763)), new Pair.ptr(new $Int64(0, 25349), new $Int64(0, 20658)), new Pair.ptr(new $Int64(0, 25357), new $Int64(0, 14031)), new Pair.ptr(new $Int64(0, 25367), new $Int64(0, 3619)), new Pair.ptr(new $Int64(0, 25373), new $Int64(0, 5763)), new Pair.ptr(new $Int64(0, 25391), new $Int64(0, 4703)), new Pair.ptr(new $Int64(0, 25409), new $Int64(0, 8307)), new Pair.ptr(new $Int64(0, 25411), new $Int64(0, 16126)), new Pair.ptr(new $Int64(0, 25423), new $Int64(0, 24558)), new Pair.ptr(new $Int64(0, 25439), new $Int64(0, 17561)), new Pair.ptr(new $Int64(0, 25447), new $Int64(0, 16731)), new Pair.ptr(new $Int64(0, 25453), new $Int64(0, 14969)), new Pair.ptr(new $Int64(0, 25457), new $Int64(0, 23780)), new Pair.ptr(new $Int64(0, 25463), new $Int64(0, 10394)), new Pair.ptr(new $Int64(0, 25469), new $Int64(0, 11647)), new Pair.ptr(new $Int64(0, 25471), new $Int64(0, 23327)), new Pair.ptr(new $Int64(0, 25523), new $Int64(0, 2680)), new Pair.ptr(new $Int64(0, 25537), new $Int64(0, 15572)), new Pair.ptr(new $Int64(0, 25541), new $Int64(0, 1586)), new Pair.ptr(new $Int64(0, 25561), new $Int64(0, 153)), new Pair.ptr(new $Int64(0, 25577), new $Int64(0, 23100)), new Pair.ptr(new $Int64(0, 25579), new $Int64(0, 8863)), new Pair.ptr(new $Int64(0, 25583), new $Int64(0, 16679)), new Pair.ptr(new $Int64(0, 25589), new $Int64(0, 16789)), new Pair.ptr(new $Int64(0, 25601), new $Int64(0, 3802)), new Pair.ptr(new $Int64(0, 25603), new $Int64(0, 574)), new Pair.ptr(new $Int64(0, 25609), new $Int64(0, 9174)), new Pair.ptr(new $Int64(0, 25621), new $Int64(0, 19977)), new Pair.ptr(new $Int64(0, 25633), new $Int64(0, 20414)), new Pair.ptr(new $Int64(0, 25639), new $Int64(0, 23445)), new Pair.ptr(new $Int64(0, 25643), new $Int64(0, 3871)), new Pair.ptr(new $Int64(0, 25657), new $Int64(0, 24001)), new Pair.ptr(new $Int64(0, 25667), new $Int64(0, 3290)), new Pair.ptr(new $Int64(0, 25673), new $Int64(0, 14205)), new Pair.ptr(new $Int64(0, 25679), new $Int64(0, 24807)), new Pair.ptr(new $Int64(0, 25693), new $Int64(0, 22374)), new Pair.ptr(new $Int64(0, 25703), new $Int64(0, 10569)), new Pair.ptr(new $Int64(0, 25717), new $Int64(0, 3594)), new Pair.ptr(new $Int64(0, 25733), new $Int64(0, 17593)), new Pair.ptr(new $Int64(0, 25741), new $Int64(0, 9193)), new Pair.ptr(new $Int64(0, 25747), new $Int64(0, 22857)), new Pair.ptr(new $Int64(0, 25759), new $Int64(0, 22757)), new Pair.ptr(new $Int64(0, 25763), new $Int64(0, 80)), new Pair.ptr(new $Int64(0, 25771), new $Int64(0, 21555)), new Pair.ptr(new $Int64(0, 25793), new $Int64(0, 14426)), new Pair.ptr(new $Int64(0, 25799), new $Int64(0, 10026)), new Pair.ptr(new $Int64(0, 25801), new $Int64(0, 4562)), new Pair.ptr(new $Int64(0, 25819), new $Int64(0, 20940)), new Pair.ptr(new $Int64(0, 25841), new $Int64(0, 13286)), new Pair.ptr(new $Int64(0, 25847), new $Int64(0, 8955)), new Pair.ptr(new $Int64(0, 25849), new $Int64(0, 7504)), new Pair.ptr(new $Int64(0, 25867), new $Int64(0, 24514)), new Pair.ptr(new $Int64(0, 25873), new $Int64(0, 19106)), new Pair.ptr(new $Int64(0, 25889), new $Int64(0, 9395)), new Pair.ptr(new $Int64(0, 25903), new $Int64(0, 6209)), new Pair.ptr(new $Int64(0, 25913), new $Int64(0, 9704)), new Pair.ptr(new $Int64(0, 25919), new $Int64(0, 10953)), new Pair.ptr(new $Int64(0, 25931), new $Int64(0, 21732)), new Pair.ptr(new $Int64(0, 25933), new $Int64(0, 2505)), new Pair.ptr(new $Int64(0, 25939), new $Int64(0, 9506)), new Pair.ptr(new $Int64(0, 25943), new $Int64(0, 24948)), new Pair.ptr(new $Int64(0, 25951), new $Int64(0, 25011)), new Pair.ptr(new $Int64(0, 25969), new $Int64(0, 6553)), new Pair.ptr(new $Int64(0, 25981), new $Int64(0, 19505)), new Pair.ptr(new $Int64(0, 25997), new $Int64(0, 12117)), new Pair.ptr(new $Int64(0, 25999), new $Int64(0, 8554)), new Pair.ptr(new $Int64(0, 26003), new $Int64(0, 4315)), new Pair.ptr(new $Int64(0, 26017), new $Int64(0, 530)), new Pair.ptr(new $Int64(0, 26021), new $Int64(0, 21424)), new Pair.ptr(new $Int64(0, 26029), new $Int64(0, 22703)), new Pair.ptr(new $Int64(0, 26041), new $Int64(0, 22945)), new Pair.ptr(new $Int64(0, 26053), new $Int64(0, 981)), new Pair.ptr(new $Int64(0, 26083), new $Int64(0, 2982)), new Pair.ptr(new $Int64(0, 26099), new $Int64(0, 16726)), new Pair.ptr(new $Int64(0, 26107), new $Int64(0, 5259)), new Pair.ptr(new $Int64(0, 26111), new $Int64(0, 25000)), new Pair.ptr(new $Int64(0, 26113), new $Int64(0, 5)), new Pair.ptr(new $Int64(0, 26119), new $Int64(0, 7054)), new Pair.ptr(new $Int64(0, 26141), new $Int64(0, 9066)), new Pair.ptr(new $Int64(0, 26153), new $Int64(0, 25470)), new Pair.ptr(new $Int64(0, 26161), new $Int64(0, 20777)), new Pair.ptr(new $Int64(0, 26171), new $Int64(0, 3318)), new Pair.ptr(new $Int64(0, 26177), new $Int64(0, 25394)), new Pair.ptr(new $Int64(0, 26183), new $Int64(0, 13539)), new Pair.ptr(new $Int64(0, 26189), new $Int64(0, 11453)), new Pair.ptr(new $Int64(0, 26203), new $Int64(0, 2001)), new Pair.ptr(new $Int64(0, 26209), new $Int64(0, 3812)), new Pair.ptr(new $Int64(0, 26227), new $Int64(0, 6174)), new Pair.ptr(new $Int64(0, 26237), new $Int64(0, 15479)), new Pair.ptr(new $Int64(0, 26249), new $Int64(0, 15924)), new Pair.ptr(new $Int64(0, 26251), new $Int64(0, 10234)), new Pair.ptr(new $Int64(0, 26261), new $Int64(0, 22225)), new Pair.ptr(new $Int64(0, 26263), new $Int64(0, 7371)), new Pair.ptr(new $Int64(0, 26267), new $Int64(0, 2396)), new Pair.ptr(new $Int64(0, 26293), new $Int64(0, 12705)), new Pair.ptr(new $Int64(0, 26297), new $Int64(0, 8198)), new Pair.ptr(new $Int64(0, 26309), new $Int64(0, 21966)), new Pair.ptr(new $Int64(0, 26317), new $Int64(0, 24763)), new Pair.ptr(new $Int64(0, 26321), new $Int64(0, 4540)), new Pair.ptr(new $Int64(0, 26339), new $Int64(0, 17485)), new Pair.ptr(new $Int64(0, 26347), new $Int64(0, 7413)), new Pair.ptr(new $Int64(0, 26357), new $Int64(0, 357)), new Pair.ptr(new $Int64(0, 26371), new $Int64(0, 13890)), new Pair.ptr(new $Int64(0, 26387), new $Int64(0, 21123)), new Pair.ptr(new $Int64(0, 26393), new $Int64(0, 24860)), new Pair.ptr(new $Int64(0, 26399), new $Int64(0, 5222)), new Pair.ptr(new $Int64(0, 26407), new $Int64(0, 1824)), new Pair.ptr(new $Int64(0, 26417), new $Int64(0, 13883)), new Pair.ptr(new $Int64(0, 26423), new $Int64(0, 14455)), new Pair.ptr(new $Int64(0, 26431), new $Int64(0, 20800)), new Pair.ptr(new $Int64(0, 26437), new $Int64(0, 25589)), new Pair.ptr(new $Int64(0, 26449), new $Int64(0, 9105)), new Pair.ptr(new $Int64(0, 26459), new $Int64(0, 15080)), new Pair.ptr(new $Int64(0, 26479), new $Int64(0, 5326)), new Pair.ptr(new $Int64(0, 26489), new $Int64(0, 18610)), new Pair.ptr(new $Int64(0, 26497), new $Int64(0, 6628)), new Pair.ptr(new $Int64(0, 26501), new $Int64(0, 20469)), new Pair.ptr(new $Int64(0, 26513), new $Int64(0, 22086)), new Pair.ptr(new $Int64(0, 26539), new $Int64(0, 4662)), new Pair.ptr(new $Int64(0, 26557), new $Int64(0, 23397)), new Pair.ptr(new $Int64(0, 26561), new $Int64(0, 4661)), new Pair.ptr(new $Int64(0, 26573), new $Int64(0, 5717)), new Pair.ptr(new $Int64(0, 26591), new $Int64(0, 8113)), new Pair.ptr(new $Int64(0, 26597), new $Int64(0, 10829)), new Pair.ptr(new $Int64(0, 26627), new $Int64(0, 13202)), new Pair.ptr(new $Int64(0, 26633), new $Int64(0, 8191)), new Pair.ptr(new $Int64(0, 26641), new $Int64(0, 24831)), new Pair.ptr(new $Int64(0, 26647), new $Int64(0, 18851)), new Pair.ptr(new $Int64(0, 26669), new $Int64(0, 18510)), new Pair.ptr(new $Int64(0, 26681), new $Int64(0, 22114)), new Pair.ptr(new $Int64(0, 26683), new $Int64(0, 20084)), new Pair.ptr(new $Int64(0, 26687), new $Int64(0, 2341)), new Pair.ptr(new $Int64(0, 26693), new $Int64(0, 17796)), new Pair.ptr(new $Int64(0, 26699), new $Int64(0, 2094)), new Pair.ptr(new $Int64(0, 26701), new $Int64(0, 26314)), new Pair.ptr(new $Int64(0, 26711), new $Int64(0, 26375)), new Pair.ptr(new $Int64(0, 26713), new $Int64(0, 15243)), new Pair.ptr(new $Int64(0, 26717), new $Int64(0, 11038)), new Pair.ptr(new $Int64(0, 26723), new $Int64(0, 15113)), new Pair.ptr(new $Int64(0, 26729), new $Int64(0, 9326)), new Pair.ptr(new $Int64(0, 26731), new $Int64(0, 9620)), new Pair.ptr(new $Int64(0, 26737), new $Int64(0, 16464)), new Pair.ptr(new $Int64(0, 26759), new $Int64(0, 17296)), new Pair.ptr(new $Int64(0, 26777), new $Int64(0, 20305)), new Pair.ptr(new $Int64(0, 26783), new $Int64(0, 7401)), new Pair.ptr(new $Int64(0, 26801), new $Int64(0, 15627)), new Pair.ptr(new $Int64(0, 26813), new $Int64(0, 6224)), new Pair.ptr(new $Int64(0, 26821), new $Int64(0, 817)), new Pair.ptr(new $Int64(0, 26833), new $Int64(0, 21048)), new Pair.ptr(new $Int64(0, 26839), new $Int64(0, 8455)), new Pair.ptr(new $Int64(0, 26849), new $Int64(0, 24281)), new Pair.ptr(new $Int64(0, 26861), new $Int64(0, 13475)), new Pair.ptr(new $Int64(0, 26863), new $Int64(0, 2199)), new Pair.ptr(new $Int64(0, 26879), new $Int64(0, 6579)), new Pair.ptr(new $Int64(0, 26881), new $Int64(0, 6955)), new Pair.ptr(new $Int64(0, 26891), new $Int64(0, 2872)), new Pair.ptr(new $Int64(0, 26893), new $Int64(0, 26025)), new Pair.ptr(new $Int64(0, 26903), new $Int64(0, 6601)), new Pair.ptr(new $Int64(0, 26921), new $Int64(0, 25594)), new Pair.ptr(new $Int64(0, 26927), new $Int64(0, 15032)), new Pair.ptr(new $Int64(0, 26947), new $Int64(0, 15604)), new Pair.ptr(new $Int64(0, 26951), new $Int64(0, 6392)), new Pair.ptr(new $Int64(0, 26953), new $Int64(0, 17911)), new Pair.ptr(new $Int64(0, 26959), new $Int64(0, 19912)), new Pair.ptr(new $Int64(0, 26981), new $Int64(0, 9546)), new Pair.ptr(new $Int64(0, 26987), new $Int64(0, 4942)), new Pair.ptr(new $Int64(0, 26993), new $Int64(0, 17605)), new Pair.ptr(new $Int64(0, 27011), new $Int64(0, 16080)), new Pair.ptr(new $Int64(0, 27017), new $Int64(0, 15062)), new Pair.ptr(new $Int64(0, 27031), new $Int64(0, 26862)), new Pair.ptr(new $Int64(0, 27043), new $Int64(0, 20409)), new Pair.ptr(new $Int64(0, 27059), new $Int64(0, 17990)), new Pair.ptr(new $Int64(0, 27061), new $Int64(0, 18883)), new Pair.ptr(new $Int64(0, 27067), new $Int64(0, 20757)), new Pair.ptr(new $Int64(0, 27073), new $Int64(0, 26970)), new Pair.ptr(new $Int64(0, 27077), new $Int64(0, 1584)), new Pair.ptr(new $Int64(0, 27091), new $Int64(0, 8667)), new Pair.ptr(new $Int64(0, 27103), new $Int64(0, 3058)), new Pair.ptr(new $Int64(0, 27107), new $Int64(0, 10055)), new Pair.ptr(new $Int64(0, 27109), new $Int64(0, 21993)), new Pair.ptr(new $Int64(0, 27127), new $Int64(0, 10627)), new Pair.ptr(new $Int64(0, 27143), new $Int64(0, 14876)), new Pair.ptr(new $Int64(0, 27179), new $Int64(0, 16142)), new Pair.ptr(new $Int64(0, 27191), new $Int64(0, 7291)), new Pair.ptr(new $Int64(0, 27197), new $Int64(0, 27185)), new Pair.ptr(new $Int64(0, 27211), new $Int64(0, 12049)), new Pair.ptr(new $Int64(0, 27239), new $Int64(0, 23484)), new Pair.ptr(new $Int64(0, 27241), new $Int64(0, 3211)), new Pair.ptr(new $Int64(0, 27253), new $Int64(0, 20901)), new Pair.ptr(new $Int64(0, 27259), new $Int64(0, 8492)), new Pair.ptr(new $Int64(0, 27271), new $Int64(0, 2009)), new Pair.ptr(new $Int64(0, 27277), new $Int64(0, 5229)), new Pair.ptr(new $Int64(0, 27281), new $Int64(0, 24083)), new Pair.ptr(new $Int64(0, 27283), new $Int64(0, 5763)), new Pair.ptr(new $Int64(0, 27299), new $Int64(0, 11168)), new Pair.ptr(new $Int64(0, 27329), new $Int64(0, 10409)), new Pair.ptr(new $Int64(0, 27337), new $Int64(0, 14676)), new Pair.ptr(new $Int64(0, 27361), new $Int64(0, 18696)), new Pair.ptr(new $Int64(0, 27367), new $Int64(0, 23598)), new Pair.ptr(new $Int64(0, 27397), new $Int64(0, 21838)), new Pair.ptr(new $Int64(0, 27407), new $Int64(0, 6648)), new Pair.ptr(new $Int64(0, 27409), new $Int64(0, 25043)), new Pair.ptr(new $Int64(0, 27427), new $Int64(0, 12457)), new Pair.ptr(new $Int64(0, 27431), new $Int64(0, 22948)), new Pair.ptr(new $Int64(0, 27437), new $Int64(0, 8293)), new Pair.ptr(new $Int64(0, 27449), new $Int64(0, 12100)), new Pair.ptr(new $Int64(0, 27457), new $Int64(0, 14905)), new Pair.ptr(new $Int64(0, 27479), new $Int64(0, 1263)), new Pair.ptr(new $Int64(0, 27481), new $Int64(0, 3706)), new Pair.ptr(new $Int64(0, 27487), new $Int64(0, 608)), new Pair.ptr(new $Int64(0, 27509), new $Int64(0, 8705)), new Pair.ptr(new $Int64(0, 27527), new $Int64(0, 12617)), new Pair.ptr(new $Int64(0, 27529), new $Int64(0, 13382)), new Pair.ptr(new $Int64(0, 27539), new $Int64(0, 10826)), new Pair.ptr(new $Int64(0, 27541), new $Int64(0, 14238)), new Pair.ptr(new $Int64(0, 27551), new $Int64(0, 7938)), new Pair.ptr(new $Int64(0, 27581), new $Int64(0, 9097)), new Pair.ptr(new $Int64(0, 27583), new $Int64(0, 14713)), new Pair.ptr(new $Int64(0, 27611), new $Int64(0, 9431)), new Pair.ptr(new $Int64(0, 27617), new $Int64(0, 27122)), new Pair.ptr(new $Int64(0, 27631), new $Int64(0, 22186)), new Pair.ptr(new $Int64(0, 27647), new $Int64(0, 24355)), new Pair.ptr(new $Int64(0, 27653), new $Int64(0, 16668)), new Pair.ptr(new $Int64(0, 27673), new $Int64(0, 17256)), new Pair.ptr(new $Int64(0, 27689), new $Int64(0, 18070)), new Pair.ptr(new $Int64(0, 27691), new $Int64(0, 11238)), new Pair.ptr(new $Int64(0, 27697), new $Int64(0, 25937)), new Pair.ptr(new $Int64(0, 27701), new $Int64(0, 6729)), new Pair.ptr(new $Int64(0, 27733), new $Int64(0, 4923)), new Pair.ptr(new $Int64(0, 27737), new $Int64(0, 251)), new Pair.ptr(new $Int64(0, 27739), new $Int64(0, 18867)), new Pair.ptr(new $Int64(0, 27743), new $Int64(0, 3897)), new Pair.ptr(new $Int64(0, 27749), new $Int64(0, 18622)), new Pair.ptr(new $Int64(0, 27751), new $Int64(0, 20314)), new Pair.ptr(new $Int64(0, 27763), new $Int64(0, 13658)), new Pair.ptr(new $Int64(0, 27767), new $Int64(0, 21132)), new Pair.ptr(new $Int64(0, 27773), new $Int64(0, 17212)), new Pair.ptr(new $Int64(0, 27779), new $Int64(0, 14306)), new Pair.ptr(new $Int64(0, 27791), new $Int64(0, 1927)), new Pair.ptr(new $Int64(0, 27793), new $Int64(0, 13999)), new Pair.ptr(new $Int64(0, 27799), new $Int64(0, 24226)), new Pair.ptr(new $Int64(0, 27803), new $Int64(0, 26695)), new Pair.ptr(new $Int64(0, 27809), new $Int64(0, 18315)), new Pair.ptr(new $Int64(0, 27817), new $Int64(0, 10015)), new Pair.ptr(new $Int64(0, 27823), new $Int64(0, 21901)), new Pair.ptr(new $Int64(0, 27827), new $Int64(0, 19885)), new Pair.ptr(new $Int64(0, 27847), new $Int64(0, 14303)), new Pair.ptr(new $Int64(0, 27851), new $Int64(0, 7621)), new Pair.ptr(new $Int64(0, 27883), new $Int64(0, 6224)), new Pair.ptr(new $Int64(0, 27893), new $Int64(0, 15503)), new Pair.ptr(new $Int64(0, 27901), new $Int64(0, 10494)), new Pair.ptr(new $Int64(0, 27917), new $Int64(0, 11980)), new Pair.ptr(new $Int64(0, 27919), new $Int64(0, 7317)), new Pair.ptr(new $Int64(0, 27941), new $Int64(0, 9774)), new Pair.ptr(new $Int64(0, 27943), new $Int64(0, 10969)), new Pair.ptr(new $Int64(0, 27947), new $Int64(0, 20920)), new Pair.ptr(new $Int64(0, 27953), new $Int64(0, 20884)), new Pair.ptr(new $Int64(0, 27961), new $Int64(0, 24525)), new Pair.ptr(new $Int64(0, 27967), new $Int64(0, 4111)), new Pair.ptr(new $Int64(0, 27983), new $Int64(0, 14945)), new Pair.ptr(new $Int64(0, 27997), new $Int64(0, 21645)), new Pair.ptr(new $Int64(0, 28001), new $Int64(0, 8746)), new Pair.ptr(new $Int64(0, 28019), new $Int64(0, 22519)), new Pair.ptr(new $Int64(0, 28027), new $Int64(0, 27093)), new Pair.ptr(new $Int64(0, 28031), new $Int64(0, 23982)), new Pair.ptr(new $Int64(0, 28051), new $Int64(0, 5163)), new Pair.ptr(new $Int64(0, 28057), new $Int64(0, 13577)), new Pair.ptr(new $Int64(0, 28069), new $Int64(0, 24258)), new Pair.ptr(new $Int64(0, 28081), new $Int64(0, 20787)), new Pair.ptr(new $Int64(0, 28087), new $Int64(0, 20010)), new Pair.ptr(new $Int64(0, 28097), new $Int64(0, 13587)), new Pair.ptr(new $Int64(0, 28099), new $Int64(0, 19168)), new Pair.ptr(new $Int64(0, 28109), new $Int64(0, 27681)), new Pair.ptr(new $Int64(0, 28111), new $Int64(0, 10917)), new Pair.ptr(new $Int64(0, 28123), new $Int64(0, 14397)), new Pair.ptr(new $Int64(0, 28151), new $Int64(0, 3105)), new Pair.ptr(new $Int64(0, 28163), new $Int64(0, 16265)), new Pair.ptr(new $Int64(0, 28181), new $Int64(0, 17234)), new Pair.ptr(new $Int64(0, 28183), new $Int64(0, 15934)), new Pair.ptr(new $Int64(0, 28201), new $Int64(0, 27750)), new Pair.ptr(new $Int64(0, 28211), new $Int64(0, 3633)), new Pair.ptr(new $Int64(0, 28219), new $Int64(0, 23112)), new Pair.ptr(new $Int64(0, 28229), new $Int64(0, 529)), new Pair.ptr(new $Int64(0, 28277), new $Int64(0, 6174)), new Pair.ptr(new $Int64(0, 28279), new $Int64(0, 13118)), new Pair.ptr(new $Int64(0, 28283), new $Int64(0, 14526)), new Pair.ptr(new $Int64(0, 28289), new $Int64(0, 27505)), new Pair.ptr(new $Int64(0, 28297), new $Int64(0, 23672)), new Pair.ptr(new $Int64(0, 28307), new $Int64(0, 1762)), new Pair.ptr(new $Int64(0, 28309), new $Int64(0, 6592)), new Pair.ptr(new $Int64(0, 28319), new $Int64(0, 20511)), new Pair.ptr(new $Int64(0, 28349), new $Int64(0, 1834)), new Pair.ptr(new $Int64(0, 28351), new $Int64(0, 26616)), new Pair.ptr(new $Int64(0, 28387), new $Int64(0, 23329)), new Pair.ptr(new $Int64(0, 28393), new $Int64(0, 516)), new Pair.ptr(new $Int64(0, 28403), new $Int64(0, 15070)), new Pair.ptr(new $Int64(0, 28409), new $Int64(0, 24216)), new Pair.ptr(new $Int64(0, 28411), new $Int64(0, 5655)), new Pair.ptr(new $Int64(0, 28429), new $Int64(0, 9318)), new Pair.ptr(new $Int64(0, 28433), new $Int64(0, 16215)), new Pair.ptr(new $Int64(0, 28439), new $Int64(0, 21365)), new Pair.ptr(new $Int64(0, 28447), new $Int64(0, 3329)), new Pair.ptr(new $Int64(0, 28463), new $Int64(0, 16225)), new Pair.ptr(new $Int64(0, 28477), new $Int64(0, 1334)), new Pair.ptr(new $Int64(0, 28493), new $Int64(0, 9802)), new Pair.ptr(new $Int64(0, 28499), new $Int64(0, 954)), new Pair.ptr(new $Int64(0, 28513), new $Int64(0, 8209)), new Pair.ptr(new $Int64(0, 28517), new $Int64(0, 9702)), new Pair.ptr(new $Int64(0, 28537), new $Int64(0, 6169)), new Pair.ptr(new $Int64(0, 28541), new $Int64(0, 4538)), new Pair.ptr(new $Int64(0, 28547), new $Int64(0, 11901)), new Pair.ptr(new $Int64(0, 28549), new $Int64(0, 27696)), new Pair.ptr(new $Int64(0, 28559), new $Int64(0, 18973)), new Pair.ptr(new $Int64(0, 28571), new $Int64(0, 19235)), new Pair.ptr(new $Int64(0, 28573), new $Int64(0, 3074)), new Pair.ptr(new $Int64(0, 28579), new $Int64(0, 7647)), new Pair.ptr(new $Int64(0, 28591), new $Int64(0, 26927)), new Pair.ptr(new $Int64(0, 28597), new $Int64(0, 454)), new Pair.ptr(new $Int64(0, 28603), new $Int64(0, 2270)), new Pair.ptr(new $Int64(0, 28607), new $Int64(0, 8368)), new Pair.ptr(new $Int64(0, 28619), new $Int64(0, 12337)), new Pair.ptr(new $Int64(0, 28621), new $Int64(0, 3245)), new Pair.ptr(new $Int64(0, 28627), new $Int64(0, 24184)), new Pair.ptr(new $Int64(0, 28631), new $Int64(0, 10995)), new Pair.ptr(new $Int64(0, 28643), new $Int64(0, 20491)), new Pair.ptr(new $Int64(0, 28649), new $Int64(0, 14060)), new Pair.ptr(new $Int64(0, 28657), new $Int64(0, 14125)), new Pair.ptr(new $Int64(0, 28661), new $Int64(0, 20763)), new Pair.ptr(new $Int64(0, 28663), new $Int64(0, 4723)), new Pair.ptr(new $Int64(0, 28669), new $Int64(0, 20280)), new Pair.ptr(new $Int64(0, 28687), new $Int64(0, 23160)), new Pair.ptr(new $Int64(0, 28697), new $Int64(0, 11383)), new Pair.ptr(new $Int64(0, 28703), new $Int64(0, 22068)), new Pair.ptr(new $Int64(0, 28711), new $Int64(0, 20902)), new Pair.ptr(new $Int64(0, 28723), new $Int64(0, 1390)), new Pair.ptr(new $Int64(0, 28729), new $Int64(0, 11411)), new Pair.ptr(new $Int64(0, 28751), new $Int64(0, 25632)), new Pair.ptr(new $Int64(0, 28753), new $Int64(0, 24019)), new Pair.ptr(new $Int64(0, 28759), new $Int64(0, 27045)), new Pair.ptr(new $Int64(0, 28771), new $Int64(0, 22081)), new Pair.ptr(new $Int64(0, 28789), new $Int64(0, 5237)), new Pair.ptr(new $Int64(0, 28793), new $Int64(0, 6209)), new Pair.ptr(new $Int64(0, 28807), new $Int64(0, 2220)), new Pair.ptr(new $Int64(0, 28813), new $Int64(0, 7878)), new Pair.ptr(new $Int64(0, 28817), new $Int64(0, 25105)), new Pair.ptr(new $Int64(0, 28837), new $Int64(0, 2532)), new Pair.ptr(new $Int64(0, 28843), new $Int64(0, 28193)), new Pair.ptr(new $Int64(0, 28859), new $Int64(0, 21176)), new Pair.ptr(new $Int64(0, 28867), new $Int64(0, 24877)), new Pair.ptr(new $Int64(0, 28871), new $Int64(0, 6732)), new Pair.ptr(new $Int64(0, 28879), new $Int64(0, 8261)), new Pair.ptr(new $Int64(0, 28901), new $Int64(0, 8262)), new Pair.ptr(new $Int64(0, 28909), new $Int64(0, 17504)), new Pair.ptr(new $Int64(0, 28921), new $Int64(0, 14128)), new Pair.ptr(new $Int64(0, 28927), new $Int64(0, 18181)), new Pair.ptr(new $Int64(0, 28933), new $Int64(0, 12073)), new Pair.ptr(new $Int64(0, 28949), new $Int64(0, 10491)), new Pair.ptr(new $Int64(0, 28961), new $Int64(0, 20908)), new Pair.ptr(new $Int64(0, 28979), new $Int64(0, 19556)), new Pair.ptr(new $Int64(0, 29009), new $Int64(0, 19569)), new Pair.ptr(new $Int64(0, 29017), new $Int64(0, 15375)), new Pair.ptr(new $Int64(0, 29021), new $Int64(0, 5774)), new Pair.ptr(new $Int64(0, 29023), new $Int64(0, 16003)), new Pair.ptr(new $Int64(0, 29027), new $Int64(0, 13667)), new Pair.ptr(new $Int64(0, 29033), new $Int64(0, 22561)), new Pair.ptr(new $Int64(0, 29059), new $Int64(0, 3479)), new Pair.ptr(new $Int64(0, 29063), new $Int64(0, 13983)), new Pair.ptr(new $Int64(0, 29077), new $Int64(0, 12807)), new Pair.ptr(new $Int64(0, 29101), new $Int64(0, 12021)), new Pair.ptr(new $Int64(0, 29123), new $Int64(0, 24122)), new Pair.ptr(new $Int64(0, 29129), new $Int64(0, 5100)), new Pair.ptr(new $Int64(0, 29131), new $Int64(0, 2568)), new Pair.ptr(new $Int64(0, 29137), new $Int64(0, 6648)), new Pair.ptr(new $Int64(0, 29147), new $Int64(0, 17305)), new Pair.ptr(new $Int64(0, 29153), new $Int64(0, 25887)), new Pair.ptr(new $Int64(0, 29167), new $Int64(0, 24917)), new Pair.ptr(new $Int64(0, 29173), new $Int64(0, 28756)), new Pair.ptr(new $Int64(0, 29179), new $Int64(0, 6729)), new Pair.ptr(new $Int64(0, 29191), new $Int64(0, 24955)), new Pair.ptr(new $Int64(0, 29201), new $Int64(0, 20527)), new Pair.ptr(new $Int64(0, 29207), new $Int64(0, 24212)), new Pair.ptr(new $Int64(0, 29209), new $Int64(0, 10522)), new Pair.ptr(new $Int64(0, 29221), new $Int64(0, 18376)), new Pair.ptr(new $Int64(0, 29231), new $Int64(0, 27228)), new Pair.ptr(new $Int64(0, 29243), new $Int64(0, 26354)), new Pair.ptr(new $Int64(0, 29251), new $Int64(0, 18709)), new Pair.ptr(new $Int64(0, 29269), new $Int64(0, 9798)), new Pair.ptr(new $Int64(0, 29287), new $Int64(0, 27799)), new Pair.ptr(new $Int64(0, 29297), new $Int64(0, 2548)), new Pair.ptr(new $Int64(0, 29303), new $Int64(0, 16294)), new Pair.ptr(new $Int64(0, 29311), new $Int64(0, 15746)), new Pair.ptr(new $Int64(0, 29327), new $Int64(0, 11274)), new Pair.ptr(new $Int64(0, 29333), new $Int64(0, 16655)), new Pair.ptr(new $Int64(0, 29339), new $Int64(0, 9394)), new Pair.ptr(new $Int64(0, 29347), new $Int64(0, 29014)), new Pair.ptr(new $Int64(0, 29363), new $Int64(0, 13702)), new Pair.ptr(new $Int64(0, 29383), new $Int64(0, 17405)), new Pair.ptr(new $Int64(0, 29387), new $Int64(0, 1154)), new Pair.ptr(new $Int64(0, 29389), new $Int64(0, 23784)), new Pair.ptr(new $Int64(0, 29399), new $Int64(0, 17064)), new Pair.ptr(new $Int64(0, 29401), new $Int64(0, 6579)), new Pair.ptr(new $Int64(0, 29411), new $Int64(0, 26382)), new Pair.ptr(new $Int64(0, 29423), new $Int64(0, 24297)), new Pair.ptr(new $Int64(0, 29429), new $Int64(0, 6990)), new Pair.ptr(new $Int64(0, 29437), new $Int64(0, 17759)), new Pair.ptr(new $Int64(0, 29443), new $Int64(0, 13455)), new Pair.ptr(new $Int64(0, 29453), new $Int64(0, 13310)), new Pair.ptr(new $Int64(0, 29473), new $Int64(0, 6601)), new Pair.ptr(new $Int64(0, 29483), new $Int64(0, 27071)), new Pair.ptr(new $Int64(0, 29501), new $Int64(0, 14151)), new Pair.ptr(new $Int64(0, 29527), new $Int64(0, 13927)), new Pair.ptr(new $Int64(0, 29531), new $Int64(0, 13863)), new Pair.ptr(new $Int64(0, 29537), new $Int64(0, 24729)), new Pair.ptr(new $Int64(0, 29567), new $Int64(0, 910)), new Pair.ptr(new $Int64(0, 29569), new $Int64(0, 8643)), new Pair.ptr(new $Int64(0, 29573), new $Int64(0, 28845)), new Pair.ptr(new $Int64(0, 29581), new $Int64(0, 19814)), new Pair.ptr(new $Int64(0, 29587), new $Int64(0, 551)), new Pair.ptr(new $Int64(0, 29599), new $Int64(0, 12104)), new Pair.ptr(new $Int64(0, 29611), new $Int64(0, 17756)), new Pair.ptr(new $Int64(0, 29629), new $Int64(0, 5597)), new Pair.ptr(new $Int64(0, 29633), new $Int64(0, 17373)), new Pair.ptr(new $Int64(0, 29641), new $Int64(0, 20402)), new Pair.ptr(new $Int64(0, 29663), new $Int64(0, 5678)), new Pair.ptr(new $Int64(0, 29669), new $Int64(0, 27676)), new Pair.ptr(new $Int64(0, 29671), new $Int64(0, 26551)), new Pair.ptr(new $Int64(0, 29683), new $Int64(0, 21749)), new Pair.ptr(new $Int64(0, 29717), new $Int64(0, 2065)), new Pair.ptr(new $Int64(0, 29723), new $Int64(0, 18710)), new Pair.ptr(new $Int64(0, 29741), new $Int64(0, 19733)), new Pair.ptr(new $Int64(0, 29753), new $Int64(0, 15333)), new Pair.ptr(new $Int64(0, 29759), new $Int64(0, 12546)), new Pair.ptr(new $Int64(0, 29761), new $Int64(0, 26193)), new Pair.ptr(new $Int64(0, 29789), new $Int64(0, 19128)), new Pair.ptr(new $Int64(0, 29803), new $Int64(0, 4628)), new Pair.ptr(new $Int64(0, 29819), new $Int64(0, 4275)), new Pair.ptr(new $Int64(0, 29833), new $Int64(0, 2688)), new Pair.ptr(new $Int64(0, 29837), new $Int64(0, 13102)), new Pair.ptr(new $Int64(0, 29851), new $Int64(0, 3377)), new Pair.ptr(new $Int64(0, 29863), new $Int64(0, 16675)), new Pair.ptr(new $Int64(0, 29867), new $Int64(0, 8841)), new Pair.ptr(new $Int64(0, 29873), new $Int64(0, 18409)), new Pair.ptr(new $Int64(0, 29879), new $Int64(0, 22805)), new Pair.ptr(new $Int64(0, 29881), new $Int64(0, 5164)), new Pair.ptr(new $Int64(0, 29917), new $Int64(0, 22173)), new Pair.ptr(new $Int64(0, 29921), new $Int64(0, 7343)), new Pair.ptr(new $Int64(0, 29927), new $Int64(0, 26513)), new Pair.ptr(new $Int64(0, 29947), new $Int64(0, 9832)), new Pair.ptr(new $Int64(0, 29959), new $Int64(0, 25001)), new Pair.ptr(new $Int64(0, 29983), new $Int64(0, 25039)), new Pair.ptr(new $Int64(0, 29989), new $Int64(0, 19566)), new Pair.ptr(new $Int64(0, 30011), new $Int64(0, 6713)), new Pair.ptr(new $Int64(0, 30013), new $Int64(0, 8386)), new Pair.ptr(new $Int64(0, 30029), new $Int64(0, 22522)), new Pair.ptr(new $Int64(0, 30047), new $Int64(0, 6628)), new Pair.ptr(new $Int64(0, 30059), new $Int64(0, 8033)), new Pair.ptr(new $Int64(0, 30071), new $Int64(0, 25487)), new Pair.ptr(new $Int64(0, 30089), new $Int64(0, 14917)), new Pair.ptr(new $Int64(0, 30091), new $Int64(0, 17142)), new Pair.ptr(new $Int64(0, 30097), new $Int64(0, 25268)), new Pair.ptr(new $Int64(0, 30103), new $Int64(0, 12268)), new Pair.ptr(new $Int64(0, 30109), new $Int64(0, 23344)), new Pair.ptr(new $Int64(0, 30113), new $Int64(0, 5170)), new Pair.ptr(new $Int64(0, 30119), new $Int64(0, 21574)), new Pair.ptr(new $Int64(0, 30133), new $Int64(0, 18504)), new Pair.ptr(new $Int64(0, 30137), new $Int64(0, 9365)), new Pair.ptr(new $Int64(0, 30139), new $Int64(0, 7673)), new Pair.ptr(new $Int64(0, 30161), new $Int64(0, 5353)), new Pair.ptr(new $Int64(0, 30169), new $Int64(0, 28921)), new Pair.ptr(new $Int64(0, 30181), new $Int64(0, 22236)), new Pair.ptr(new $Int64(0, 30187), new $Int64(0, 26678)), new Pair.ptr(new $Int64(0, 30197), new $Int64(0, 28434)), new Pair.ptr(new $Int64(0, 30203), new $Int64(0, 23176)), new Pair.ptr(new $Int64(0, 30211), new $Int64(0, 6134)), new Pair.ptr(new $Int64(0, 30223), new $Int64(0, 1840)), new Pair.ptr(new $Int64(0, 30241), new $Int64(0, 10785)), new Pair.ptr(new $Int64(0, 30253), new $Int64(0, 11294)), new Pair.ptr(new $Int64(0, 30259), new $Int64(0, 19523)), new Pair.ptr(new $Int64(0, 30269), new $Int64(0, 13963)), new Pair.ptr(new $Int64(0, 30271), new $Int64(0, 25969)), new Pair.ptr(new $Int64(0, 30293), new $Int64(0, 3945)), new Pair.ptr(new $Int64(0, 30307), new $Int64(0, 29842)), new Pair.ptr(new $Int64(0, 30313), new $Int64(0, 18236)), new Pair.ptr(new $Int64(0, 30319), new $Int64(0, 25362)), new Pair.ptr(new $Int64(0, 30323), new $Int64(0, 13635)), new Pair.ptr(new $Int64(0, 30341), new $Int64(0, 20707)), new Pair.ptr(new $Int64(0, 30347), new $Int64(0, 4284)), new Pair.ptr(new $Int64(0, 30367), new $Int64(0, 9439)), new Pair.ptr(new $Int64(0, 30389), new $Int64(0, 18390)), new Pair.ptr(new $Int64(0, 30391), new $Int64(0, 17237)), new Pair.ptr(new $Int64(0, 30403), new $Int64(0, 29323)), new Pair.ptr(new $Int64(0, 30427), new $Int64(0, 27802)), new Pair.ptr(new $Int64(0, 30431), new $Int64(0, 9467)), new Pair.ptr(new $Int64(0, 30449), new $Int64(0, 27415)), new Pair.ptr(new $Int64(0, 30467), new $Int64(0, 2353)), new Pair.ptr(new $Int64(0, 30469), new $Int64(0, 642)), new Pair.ptr(new $Int64(0, 30491), new $Int64(0, 6333)), new Pair.ptr(new $Int64(0, 30493), new $Int64(0, 14308)), new Pair.ptr(new $Int64(0, 30497), new $Int64(0, 25289)), new Pair.ptr(new $Int64(0, 30509), new $Int64(0, 12245)), new Pair.ptr(new $Int64(0, 30517), new $Int64(0, 6094)), new Pair.ptr(new $Int64(0, 30529), new $Int64(0, 933)), new Pair.ptr(new $Int64(0, 30539), new $Int64(0, 30524)), new Pair.ptr(new $Int64(0, 30553), new $Int64(0, 20578)), new Pair.ptr(new $Int64(0, 30557), new $Int64(0, 1696)), new Pair.ptr(new $Int64(0, 30559), new $Int64(0, 621)), new Pair.ptr(new $Int64(0, 30577), new $Int64(0, 17790)), new Pair.ptr(new $Int64(0, 30593), new $Int64(0, 22184)), new Pair.ptr(new $Int64(0, 30631), new $Int64(0, 8040)), new Pair.ptr(new $Int64(0, 30637), new $Int64(0, 20656)), new Pair.ptr(new $Int64(0, 30643), new $Int64(0, 2187)), new Pair.ptr(new $Int64(0, 30649), new $Int64(0, 18481)), new Pair.ptr(new $Int64(0, 30661), new $Int64(0, 28195)), new Pair.ptr(new $Int64(0, 30671), new $Int64(0, 21185)), new Pair.ptr(new $Int64(0, 30677), new $Int64(0, 27844)), new Pair.ptr(new $Int64(0, 30689), new $Int64(0, 18127)), new Pair.ptr(new $Int64(0, 30697), new $Int64(0, 1024)), new Pair.ptr(new $Int64(0, 30703), new $Int64(0, 25947)), new Pair.ptr(new $Int64(0, 30707), new $Int64(0, 28201)), new Pair.ptr(new $Int64(0, 30713), new $Int64(0, 15705)), new Pair.ptr(new $Int64(0, 30727), new $Int64(0, 28644)), new Pair.ptr(new $Int64(0, 30757), new $Int64(0, 29033)), new Pair.ptr(new $Int64(0, 30763), new $Int64(0, 12706)), new Pair.ptr(new $Int64(0, 30773), new $Int64(0, 16950)), new Pair.ptr(new $Int64(0, 30781), new $Int64(0, 16159)), new Pair.ptr(new $Int64(0, 30803), new $Int64(0, 28960)), new Pair.ptr(new $Int64(0, 30809), new $Int64(0, 26508)), new Pair.ptr(new $Int64(0, 30817), new $Int64(0, 18453)), new Pair.ptr(new $Int64(0, 30829), new $Int64(0, 17527)), new Pair.ptr(new $Int64(0, 30839), new $Int64(0, 26865)), new Pair.ptr(new $Int64(0, 30841), new $Int64(0, 14080)), new Pair.ptr(new $Int64(0, 30851), new $Int64(0, 4312)), new Pair.ptr(new $Int64(0, 30853), new $Int64(0, 20703)), new Pair.ptr(new $Int64(0, 30859), new $Int64(0, 24596)), new Pair.ptr(new $Int64(0, 30869), new $Int64(0, 19914)), new Pair.ptr(new $Int64(0, 30871), new $Int64(0, 1349)), new Pair.ptr(new $Int64(0, 30881), new $Int64(0, 8319)), new Pair.ptr(new $Int64(0, 30893), new $Int64(0, 19948)), new Pair.ptr(new $Int64(0, 30911), new $Int64(0, 18201)), new Pair.ptr(new $Int64(0, 30931), new $Int64(0, 10050)), new Pair.ptr(new $Int64(0, 30937), new $Int64(0, 20781)), new Pair.ptr(new $Int64(0, 30941), new $Int64(0, 8907)), new Pair.ptr(new $Int64(0, 30949), new $Int64(0, 21831)), new Pair.ptr(new $Int64(0, 30971), new $Int64(0, 28988)), new Pair.ptr(new $Int64(0, 30977), new $Int64(0, 1611)), new Pair.ptr(new $Int64(0, 30983), new $Int64(0, 1845)), new Pair.ptr(new $Int64(0, 31013), new $Int64(0, 20862)), new Pair.ptr(new $Int64(0, 31019), new $Int64(0, 9715)), new Pair.ptr(new $Int64(0, 31033), new $Int64(0, 905)), new Pair.ptr(new $Int64(0, 31039), new $Int64(0, 9344)), new Pair.ptr(new $Int64(0, 31051), new $Int64(0, 25630)), new Pair.ptr(new $Int64(0, 31063), new $Int64(0, 13404)), new Pair.ptr(new $Int64(0, 31069), new $Int64(0, 23840)), new Pair.ptr(new $Int64(0, 31079), new $Int64(0, 6955)), new Pair.ptr(new $Int64(0, 31081), new $Int64(0, 25647)), new Pair.ptr(new $Int64(0, 31091), new $Int64(0, 17018)), new Pair.ptr(new $Int64(0, 31121), new $Int64(0, 6083)), new Pair.ptr(new $Int64(0, 31123), new $Int64(0, 5517)), new Pair.ptr(new $Int64(0, 31139), new $Int64(0, 358)), new Pair.ptr(new $Int64(0, 31147), new $Int64(0, 28491)), new Pair.ptr(new $Int64(0, 31151), new $Int64(0, 27865)), new Pair.ptr(new $Int64(0, 31153), new $Int64(0, 5888)), new Pair.ptr(new $Int64(0, 31159), new $Int64(0, 6672)), new Pair.ptr(new $Int64(0, 31177), new $Int64(0, 14277)), new Pair.ptr(new $Int64(0, 31181), new $Int64(0, 6671)), new Pair.ptr(new $Int64(0, 31183), new $Int64(0, 11244)), new Pair.ptr(new $Int64(0, 31189), new $Int64(0, 8322)), new Pair.ptr(new $Int64(0, 31193), new $Int64(0, 19908)), new Pair.ptr(new $Int64(0, 31219), new $Int64(0, 6295)), new Pair.ptr(new $Int64(0, 31223), new $Int64(0, 12870)), new Pair.ptr(new $Int64(0, 31231), new $Int64(0, 21863)), new Pair.ptr(new $Int64(0, 31237), new $Int64(0, 21435)), new Pair.ptr(new $Int64(0, 31247), new $Int64(0, 7080)), new Pair.ptr(new $Int64(0, 31249), new $Int64(0, 4108)), new Pair.ptr(new $Int64(0, 31253), new $Int64(0, 13218)), new Pair.ptr(new $Int64(0, 31259), new $Int64(0, 10727)), new Pair.ptr(new $Int64(0, 31267), new $Int64(0, 8891)), new Pair.ptr(new $Int64(0, 31271), new $Int64(0, 9947)), new Pair.ptr(new $Int64(0, 31277), new $Int64(0, 18015)), new Pair.ptr(new $Int64(0, 31307), new $Int64(0, 20808)), new Pair.ptr(new $Int64(0, 31319), new $Int64(0, 20525)), new Pair.ptr(new $Int64(0, 31321), new $Int64(0, 3160)), new Pair.ptr(new $Int64(0, 31327), new $Int64(0, 11177)), new Pair.ptr(new $Int64(0, 31333), new $Int64(0, 4623)), new Pair.ptr(new $Int64(0, 31337), new $Int64(0, 14152)), new Pair.ptr(new $Int64(0, 31357), new $Int64(0, 22927)), new Pair.ptr(new $Int64(0, 31379), new $Int64(0, 11834)), new Pair.ptr(new $Int64(0, 31387), new $Int64(0, 20464)), new Pair.ptr(new $Int64(0, 31391), new $Int64(0, 24881)), new Pair.ptr(new $Int64(0, 31393), new $Int64(0, 15875)), new Pair.ptr(new $Int64(0, 31397), new $Int64(0, 10525)), new Pair.ptr(new $Int64(0, 31469), new $Int64(0, 17566)), new Pair.ptr(new $Int64(0, 31477), new $Int64(0, 2072)), new Pair.ptr(new $Int64(0, 31481), new $Int64(0, 7317)), new Pair.ptr(new $Int64(0, 31489), new $Int64(0, 26034)), new Pair.ptr(new $Int64(0, 31511), new $Int64(0, 16697)), new Pair.ptr(new $Int64(0, 31513), new $Int64(0, 2619)), new Pair.ptr(new $Int64(0, 31517), new $Int64(0, 1277)), new Pair.ptr(new $Int64(0, 31531), new $Int64(0, 7095)), new Pair.ptr(new $Int64(0, 31541), new $Int64(0, 16642)), new Pair.ptr(new $Int64(0, 31543), new $Int64(0, 5040)), new Pair.ptr(new $Int64(0, 31547), new $Int64(0, 6691)), new Pair.ptr(new $Int64(0, 31567), new $Int64(0, 4924)), new Pair.ptr(new $Int64(0, 31573), new $Int64(0, 10052)), new Pair.ptr(new $Int64(0, 31583), new $Int64(0, 14312)), new Pair.ptr(new $Int64(0, 31601), new $Int64(0, 12396)), new Pair.ptr(new $Int64(0, 31607), new $Int64(0, 9435)), new Pair.ptr(new $Int64(0, 31627), new $Int64(0, 29404)), new Pair.ptr(new $Int64(0, 31643), new $Int64(0, 14924)), new Pair.ptr(new $Int64(0, 31649), new $Int64(0, 9525)), new Pair.ptr(new $Int64(0, 31657), new $Int64(0, 30689)), new Pair.ptr(new $Int64(0, 31663), new $Int64(0, 15371)), new Pair.ptr(new $Int64(0, 31667), new $Int64(0, 15258)), new Pair.ptr(new $Int64(0, 31687), new $Int64(0, 6019)), new Pair.ptr(new $Int64(0, 31699), new $Int64(0, 660)), new Pair.ptr(new $Int64(0, 31721), new $Int64(0, 25404)), new Pair.ptr(new $Int64(0, 31723), new $Int64(0, 21881)), new Pair.ptr(new $Int64(0, 31727), new $Int64(0, 12989)), new Pair.ptr(new $Int64(0, 31729), new $Int64(0, 14758)), new Pair.ptr(new $Int64(0, 31741), new $Int64(0, 24622)), new Pair.ptr(new $Int64(0, 31751), new $Int64(0, 8482)), new Pair.ptr(new $Int64(0, 31769), new $Int64(0, 4864)), new Pair.ptr(new $Int64(0, 31771), new $Int64(0, 16766)), new Pair.ptr(new $Int64(0, 31793), new $Int64(0, 26135)), new Pair.ptr(new $Int64(0, 31799), new $Int64(0, 22555)), new Pair.ptr(new $Int64(0, 31817), new $Int64(0, 13447)), new Pair.ptr(new $Int64(0, 31847), new $Int64(0, 21151)), new Pair.ptr(new $Int64(0, 31849), new $Int64(0, 11823)), new Pair.ptr(new $Int64(0, 31859), new $Int64(0, 16439)), new Pair.ptr(new $Int64(0, 31873), new $Int64(0, 15863)), new Pair.ptr(new $Int64(0, 31883), new $Int64(0, 30485)), new Pair.ptr(new $Int64(0, 31891), new $Int64(0, 20748)), new Pair.ptr(new $Int64(0, 31907), new $Int64(0, 11963)), new Pair.ptr(new $Int64(0, 31957), new $Int64(0, 3636)), new Pair.ptr(new $Int64(0, 31963), new $Int64(0, 525)), new Pair.ptr(new $Int64(0, 31973), new $Int64(0, 25181)), new Pair.ptr(new $Int64(0, 31981), new $Int64(0, 25543)), new Pair.ptr(new $Int64(0, 31991), new $Int64(0, 20339)), new Pair.ptr(new $Int64(0, 32003), new $Int64(0, 515)), new Pair.ptr(new $Int64(0, 32009), new $Int64(0, 10113)), new Pair.ptr(new $Int64(0, 32027), new $Int64(0, 31173)), new Pair.ptr(new $Int64(0, 32029), new $Int64(0, 20641)), new Pair.ptr(new $Int64(0, 32051), new $Int64(0, 8322)), new Pair.ptr(new $Int64(0, 32057), new $Int64(0, 23252)), new Pair.ptr(new $Int64(0, 32059), new $Int64(0, 6016)), new Pair.ptr(new $Int64(0, 32063), new $Int64(0, 23306)), new Pair.ptr(new $Int64(0, 32069), new $Int64(0, 15370)), new Pair.ptr(new $Int64(0, 32077), new $Int64(0, 30984)), new Pair.ptr(new $Int64(0, 32083), new $Int64(0, 15014)), new Pair.ptr(new $Int64(0, 32089), new $Int64(0, 8482)), new Pair.ptr(new $Int64(0, 32099), new $Int64(0, 19994)), new Pair.ptr(new $Int64(0, 32117), new $Int64(0, 3451)), new Pair.ptr(new $Int64(0, 32119), new $Int64(0, 4824)), new Pair.ptr(new $Int64(0, 32141), new $Int64(0, 7647)), new Pair.ptr(new $Int64(0, 32143), new $Int64(0, 2278)), new Pair.ptr(new $Int64(0, 32159), new $Int64(0, 3984)), new Pair.ptr(new $Int64(0, 32173), new $Int64(0, 19821)), new Pair.ptr(new $Int64(0, 32183), new $Int64(0, 16738)), new Pair.ptr(new $Int64(0, 32189), new $Int64(0, 21473)), new Pair.ptr(new $Int64(0, 32191), new $Int64(0, 24754)), new Pair.ptr(new $Int64(0, 32203), new $Int64(0, 3553)), new Pair.ptr(new $Int64(0, 32213), new $Int64(0, 31774)), new Pair.ptr(new $Int64(0, 32233), new $Int64(0, 25316)), new Pair.ptr(new $Int64(0, 32237), new $Int64(0, 22980)), new Pair.ptr(new $Int64(0, 32251), new $Int64(0, 27136)), new Pair.ptr(new $Int64(0, 32257), new $Int64(0, 17414)), new Pair.ptr(new $Int64(0, 32261), new $Int64(0, 20277)), new Pair.ptr(new $Int64(0, 32297), new $Int64(0, 260)), new Pair.ptr(new $Int64(0, 32299), new $Int64(0, 20452)), new Pair.ptr(new $Int64(0, 32303), new $Int64(0, 27837)), new Pair.ptr(new $Int64(0, 32309), new $Int64(0, 24813)), new Pair.ptr(new $Int64(0, 32321), new $Int64(0, 26498)), new Pair.ptr(new $Int64(0, 32323), new $Int64(0, 15869)), new Pair.ptr(new $Int64(0, 32327), new $Int64(0, 10425)), new Pair.ptr(new $Int64(0, 32341), new $Int64(0, 18658)), new Pair.ptr(new $Int64(0, 32353), new $Int64(0, 26897)), new Pair.ptr(new $Int64(0, 32359), new $Int64(0, 8319)), new Pair.ptr(new $Int64(0, 32363), new $Int64(0, 18238)), new Pair.ptr(new $Int64(0, 32369), new $Int64(0, 3048)), new Pair.ptr(new $Int64(0, 32371), new $Int64(0, 27431)), new Pair.ptr(new $Int64(0, 32377), new $Int64(0, 21910)), new Pair.ptr(new $Int64(0, 32381), new $Int64(0, 29313)), new Pair.ptr(new $Int64(0, 32401), new $Int64(0, 25312)), new Pair.ptr(new $Int64(0, 32411), new $Int64(0, 20946)), new Pair.ptr(new $Int64(0, 32413), new $Int64(0, 20066)), new Pair.ptr(new $Int64(0, 32423), new $Int64(0, 2449)), new Pair.ptr(new $Int64(0, 32429), new $Int64(0, 22605)), new Pair.ptr(new $Int64(0, 32441), new $Int64(0, 7054)), new Pair.ptr(new $Int64(0, 32443), new $Int64(0, 16803)), new Pair.ptr(new $Int64(0, 32467), new $Int64(0, 30412)), new Pair.ptr(new $Int64(0, 32479), new $Int64(0, 5527)), new Pair.ptr(new $Int64(0, 32491), new $Int64(0, 30811)), new Pair.ptr(new $Int64(0, 32497), new $Int64(0, 23095)), new Pair.ptr(new $Int64(0, 32503), new $Int64(0, 26007)), new Pair.ptr(new $Int64(0, 32507), new $Int64(0, 29984)), new Pair.ptr(new $Int64(0, 32531), new $Int64(0, 452)), new Pair.ptr(new $Int64(0, 32533), new $Int64(0, 1355)), new Pair.ptr(new $Int64(0, 32537), new $Int64(0, 15214)), new Pair.ptr(new $Int64(0, 32561), new $Int64(0, 119)), new Pair.ptr(new $Int64(0, 32563), new $Int64(0, 14035)), new Pair.ptr(new $Int64(0, 32569), new $Int64(0, 27903)), new Pair.ptr(new $Int64(0, 32573), new $Int64(0, 15566)), new Pair.ptr(new $Int64(0, 32579), new $Int64(0, 11896)), new Pair.ptr(new $Int64(0, 32587), new $Int64(0, 26097)), new Pair.ptr(new $Int64(0, 32603), new $Int64(0, 31206)), new Pair.ptr(new $Int64(0, 32609), new $Int64(0, 27112)), new Pair.ptr(new $Int64(0, 32611), new $Int64(0, 1930)), new Pair.ptr(new $Int64(0, 32621), new $Int64(0, 13953)), new Pair.ptr(new $Int64(0, 32633), new $Int64(0, 1495)), new Pair.ptr(new $Int64(0, 32647), new $Int64(0, 2679)), new Pair.ptr(new $Int64(0, 32653), new $Int64(0, 8406)), new Pair.ptr(new $Int64(0, 32687), new $Int64(0, 31995)), new Pair.ptr(new $Int64(0, 32693), new $Int64(0, 20849)), new Pair.ptr(new $Int64(0, 32707), new $Int64(0, 4432)), new Pair.ptr(new $Int64(0, 32713), new $Int64(0, 5758)), new Pair.ptr(new $Int64(0, 32717), new $Int64(0, 4496)), new Pair.ptr(new $Int64(0, 32719), new $Int64(0, 23578)), new Pair.ptr(new $Int64(0, 32749), new $Int64(0, 7037)), new Pair.ptr(new $Int64(0, 32771), new $Int64(0, 4875)), new Pair.ptr(new $Int64(0, 32779), new $Int64(0, 20232)), new Pair.ptr(new $Int64(0, 32783), new $Int64(0, 10107)), new Pair.ptr(new $Int64(0, 32789), new $Int64(0, 13979)), new Pair.ptr(new $Int64(0, 32797), new $Int64(0, 19098)), new Pair.ptr(new $Int64(0, 32801), new $Int64(0, 6182)), new Pair.ptr(new $Int64(0, 32803), new $Int64(0, 22331)), new Pair.ptr(new $Int64(0, 32831), new $Int64(0, 18118)), new Pair.ptr(new $Int64(0, 32833), new $Int64(0, 18604)), new Pair.ptr(new $Int64(0, 32839), new $Int64(0, 30685)), new Pair.ptr(new $Int64(0, 32843), new $Int64(0, 7878)), new Pair.ptr(new $Int64(0, 32869), new $Int64(0, 7621)), new Pair.ptr(new $Int64(0, 32887), new $Int64(0, 13442)), new Pair.ptr(new $Int64(0, 32909), new $Int64(0, 13011)), new Pair.ptr(new $Int64(0, 32911), new $Int64(0, 2556)), new Pair.ptr(new $Int64(0, 32917), new $Int64(0, 31335)), new Pair.ptr(new $Int64(0, 32933), new $Int64(0, 3565)), new Pair.ptr(new $Int64(0, 32939), new $Int64(0, 14989)), new Pair.ptr(new $Int64(0, 32941), new $Int64(0, 2945)), new Pair.ptr(new $Int64(0, 32957), new $Int64(0, 12760)), new Pair.ptr(new $Int64(0, 32969), new $Int64(0, 5937)), new Pair.ptr(new $Int64(0, 32971), new $Int64(0, 17004)), new Pair.ptr(new $Int64(0, 32983), new $Int64(0, 14562)), new Pair.ptr(new $Int64(0, 32987), new $Int64(0, 16619)), new Pair.ptr(new $Int64(0, 32993), new $Int64(0, 24188)), new Pair.ptr(new $Int64(0, 32999), new $Int64(0, 26472)), new Pair.ptr(new $Int64(0, 33013), new $Int64(0, 14567)), new Pair.ptr(new $Int64(0, 33023), new $Int64(0, 3550)), new Pair.ptr(new $Int64(0, 33029), new $Int64(0, 16721)), new Pair.ptr(new $Int64(0, 33037), new $Int64(0, 4749)), new Pair.ptr(new $Int64(0, 33049), new $Int64(0, 29899)), new Pair.ptr(new $Int64(0, 33053), new $Int64(0, 20121)), new Pair.ptr(new $Int64(0, 33071), new $Int64(0, 24825)), new Pair.ptr(new $Int64(0, 33073), new $Int64(0, 10480)), new Pair.ptr(new $Int64(0, 33083), new $Int64(0, 20131)), new Pair.ptr(new $Int64(0, 33091), new $Int64(0, 4008)), new Pair.ptr(new $Int64(0, 33107), new $Int64(0, 27660)), new Pair.ptr(new $Int64(0, 33113), new $Int64(0, 30495)), new Pair.ptr(new $Int64(0, 33119), new $Int64(0, 25311)), new Pair.ptr(new $Int64(0, 33149), new $Int64(0, 23140)), new Pair.ptr(new $Int64(0, 33151), new $Int64(0, 11947)), new Pair.ptr(new $Int64(0, 33161), new $Int64(0, 6548)), new Pair.ptr(new $Int64(0, 33179), new $Int64(0, 8005)), new Pair.ptr(new $Int64(0, 33181), new $Int64(0, 8469)), new Pair.ptr(new $Int64(0, 33191), new $Int64(0, 8303)), new Pair.ptr(new $Int64(0, 33199), new $Int64(0, 33144)), new Pair.ptr(new $Int64(0, 33203), new $Int64(0, 18247)), new Pair.ptr(new $Int64(0, 33211), new $Int64(0, 19782)), new Pair.ptr(new $Int64(0, 33223), new $Int64(0, 26915)), new Pair.ptr(new $Int64(0, 33247), new $Int64(0, 8906)), new Pair.ptr(new $Int64(0, 33287), new $Int64(0, 1091)), new Pair.ptr(new $Int64(0, 33289), new $Int64(0, 12025)), new Pair.ptr(new $Int64(0, 33301), new $Int64(0, 28427)), new Pair.ptr(new $Int64(0, 33311), new $Int64(0, 19714)), new Pair.ptr(new $Int64(0, 33317), new $Int64(0, 14497)), new Pair.ptr(new $Int64(0, 33329), new $Int64(0, 4670)), new Pair.ptr(new $Int64(0, 33331), new $Int64(0, 5036)), new Pair.ptr(new $Int64(0, 33343), new $Int64(0, 2896)), new Pair.ptr(new $Int64(0, 33347), new $Int64(0, 30992)), new Pair.ptr(new $Int64(0, 33349), new $Int64(0, 17094)), new Pair.ptr(new $Int64(0, 33353), new $Int64(0, 29150)), new Pair.ptr(new $Int64(0, 33359), new $Int64(0, 17163)), new Pair.ptr(new $Int64(0, 33377), new $Int64(0, 24943)), new Pair.ptr(new $Int64(0, 33391), new $Int64(0, 26911)), new Pair.ptr(new $Int64(0, 33403), new $Int64(0, 11594)), new Pair.ptr(new $Int64(0, 33409), new $Int64(0, 20212)), new Pair.ptr(new $Int64(0, 33413), new $Int64(0, 26482)), new Pair.ptr(new $Int64(0, 33427), new $Int64(0, 6433)), new Pair.ptr(new $Int64(0, 33457), new $Int64(0, 27387)), new Pair.ptr(new $Int64(0, 33461), new $Int64(0, 24140)), new Pair.ptr(new $Int64(0, 33469), new $Int64(0, 6523)), new Pair.ptr(new $Int64(0, 33479), new $Int64(0, 28429)), new Pair.ptr(new $Int64(0, 33487), new $Int64(0, 9539)), new Pair.ptr(new $Int64(0, 33493), new $Int64(0, 19162)), new Pair.ptr(new $Int64(0, 33503), new $Int64(0, 20738)), new Pair.ptr(new $Int64(0, 33521), new $Int64(0, 10872)), new Pair.ptr(new $Int64(0, 33529), new $Int64(0, 6116)), new Pair.ptr(new $Int64(0, 33533), new $Int64(0, 280)), new Pair.ptr(new $Int64(0, 33547), new $Int64(0, 22375)), new Pair.ptr(new $Int64(0, 33563), new $Int64(0, 8386)), new Pair.ptr(new $Int64(0, 33569), new $Int64(0, 31532)), new Pair.ptr(new $Int64(0, 33577), new $Int64(0, 11485)), new Pair.ptr(new $Int64(0, 33581), new $Int64(0, 10036)), new Pair.ptr(new $Int64(0, 33587), new $Int64(0, 16116)), new Pair.ptr(new $Int64(0, 33589), new $Int64(0, 22955)), new Pair.ptr(new $Int64(0, 33599), new $Int64(0, 23966)), new Pair.ptr(new $Int64(0, 33601), new $Int64(0, 31251)), new Pair.ptr(new $Int64(0, 33613), new $Int64(0, 2676)), new Pair.ptr(new $Int64(0, 33617), new $Int64(0, 16525)), new Pair.ptr(new $Int64(0, 33619), new $Int64(0, 17224)), new Pair.ptr(new $Int64(0, 33623), new $Int64(0, 17890)), new Pair.ptr(new $Int64(0, 33629), new $Int64(0, 23979)), new Pair.ptr(new $Int64(0, 33637), new $Int64(0, 32054)), new Pair.ptr(new $Int64(0, 33641), new $Int64(0, 31277)), new Pair.ptr(new $Int64(0, 33647), new $Int64(0, 1607)), new Pair.ptr(new $Int64(0, 33679), new $Int64(0, 26053)), new Pair.ptr(new $Int64(0, 33703), new $Int64(0, 16395)), new Pair.ptr(new $Int64(0, 33713), new $Int64(0, 7371)), new Pair.ptr(new $Int64(0, 33721), new $Int64(0, 28196)), new Pair.ptr(new $Int64(0, 33739), new $Int64(0, 11050)), new Pair.ptr(new $Int64(0, 33749), new $Int64(0, 9803)), new Pair.ptr(new $Int64(0, 33751), new $Int64(0, 22447)), new Pair.ptr(new $Int64(0, 33757), new $Int64(0, 29774)), new Pair.ptr(new $Int64(0, 33767), new $Int64(0, 567)), new Pair.ptr(new $Int64(0, 33769), new $Int64(0, 21678)), new Pair.ptr(new $Int64(0, 33773), new $Int64(0, 10505)), new Pair.ptr(new $Int64(0, 33791), new $Int64(0, 15002)), new Pair.ptr(new $Int64(0, 33797), new $Int64(0, 7413)), new Pair.ptr(new $Int64(0, 33809), new $Int64(0, 3724)), new Pair.ptr(new $Int64(0, 33811), new $Int64(0, 30205)), new Pair.ptr(new $Int64(0, 33827), new $Int64(0, 31945)), new Pair.ptr(new $Int64(0, 33829), new $Int64(0, 31703)), new Pair.ptr(new $Int64(0, 33851), new $Int64(0, 12002)), new Pair.ptr(new $Int64(0, 33857), new $Int64(0, 14343)), new Pair.ptr(new $Int64(0, 33863), new $Int64(0, 31820)), new Pair.ptr(new $Int64(0, 33871), new $Int64(0, 2123)), new Pair.ptr(new $Int64(0, 33889), new $Int64(0, 12648)), new Pair.ptr(new $Int64(0, 33893), new $Int64(0, 14707)), new Pair.ptr(new $Int64(0, 33911), new $Int64(0, 12650)), new Pair.ptr(new $Int64(0, 33923), new $Int64(0, 33215)), new Pair.ptr(new $Int64(0, 33931), new $Int64(0, 22143)), new Pair.ptr(new $Int64(0, 33937), new $Int64(0, 30899)), new Pair.ptr(new $Int64(0, 33941), new $Int64(0, 7804)), new Pair.ptr(new $Int64(0, 33961), new $Int64(0, 29177)), new Pair.ptr(new $Int64(0, 33967), new $Int64(0, 921)), new Pair.ptr(new $Int64(0, 33997), new $Int64(0, 5804)), new Pair.ptr(new $Int64(0, 34019), new $Int64(0, 21054)), new Pair.ptr(new $Int64(0, 34031), new $Int64(0, 21364)), new Pair.ptr(new $Int64(0, 34033), new $Int64(0, 17584)), new Pair.ptr(new $Int64(0, 34039), new $Int64(0, 23033)), new Pair.ptr(new $Int64(0, 34057), new $Int64(0, 11377)), new Pair.ptr(new $Int64(0, 34061), new $Int64(0, 5824)), new Pair.ptr(new $Int64(0, 34123), new $Int64(0, 16480)), new Pair.ptr(new $Int64(0, 34127), new $Int64(0, 13767)), new Pair.ptr(new $Int64(0, 34129), new $Int64(0, 22591)), new Pair.ptr(new $Int64(0, 34141), new $Int64(0, 2643)), new Pair.ptr(new $Int64(0, 34147), new $Int64(0, 4286)), new Pair.ptr(new $Int64(0, 34157), new $Int64(0, 8891)), new Pair.ptr(new $Int64(0, 34159), new $Int64(0, 9396)), new Pair.ptr(new $Int64(0, 34171), new $Int64(0, 4685)), new Pair.ptr(new $Int64(0, 34183), new $Int64(0, 3208)), new Pair.ptr(new $Int64(0, 34211), new $Int64(0, 7174)), new Pair.ptr(new $Int64(0, 34213), new $Int64(0, 5253)), new Pair.ptr(new $Int64(0, 34217), new $Int64(0, 9539)), new Pair.ptr(new $Int64(0, 34231), new $Int64(0, 6044)), new Pair.ptr(new $Int64(0, 34253), new $Int64(0, 21399)), new Pair.ptr(new $Int64(0, 34259), new $Int64(0, 11072)), new Pair.ptr(new $Int64(0, 34261), new $Int64(0, 3816)), new Pair.ptr(new $Int64(0, 34267), new $Int64(0, 32235)), new Pair.ptr(new $Int64(0, 34273), new $Int64(0, 7813)), new Pair.ptr(new $Int64(0, 34283), new $Int64(0, 26341)), new Pair.ptr(new $Int64(0, 34297), new $Int64(0, 17042)), new Pair.ptr(new $Int64(0, 34301), new $Int64(0, 21148)), new Pair.ptr(new $Int64(0, 34303), new $Int64(0, 13260)), new Pair.ptr(new $Int64(0, 34313), new $Int64(0, 21008)), new Pair.ptr(new $Int64(0, 34319), new $Int64(0, 4903)), new Pair.ptr(new $Int64(0, 34327), new $Int64(0, 28022)), new Pair.ptr(new $Int64(0, 34337), new $Int64(0, 6348)), new Pair.ptr(new $Int64(0, 34351), new $Int64(0, 31185)), new Pair.ptr(new $Int64(0, 34361), new $Int64(0, 8261)), new Pair.ptr(new $Int64(0, 34367), new $Int64(0, 21623)), new Pair.ptr(new $Int64(0, 34369), new $Int64(0, 501)), new Pair.ptr(new $Int64(0, 34381), new $Int64(0, 18358)), new Pair.ptr(new $Int64(0, 34403), new $Int64(0, 19422)), new Pair.ptr(new $Int64(0, 34421), new $Int64(0, 20156)), new Pair.ptr(new $Int64(0, 34429), new $Int64(0, 12454)), new Pair.ptr(new $Int64(0, 34439), new $Int64(0, 24806)), new Pair.ptr(new $Int64(0, 34457), new $Int64(0, 16456)), new Pair.ptr(new $Int64(0, 34469), new $Int64(0, 24819)), new Pair.ptr(new $Int64(0, 34471), new $Int64(0, 29090)), new Pair.ptr(new $Int64(0, 34483), new $Int64(0, 20581)), new Pair.ptr(new $Int64(0, 34487), new $Int64(0, 11535)), new Pair.ptr(new $Int64(0, 34499), new $Int64(0, 17043)), new Pair.ptr(new $Int64(0, 34501), new $Int64(0, 20559)), new Pair.ptr(new $Int64(0, 34511), new $Int64(0, 6737)), new Pair.ptr(new $Int64(0, 34513), new $Int64(0, 5799)), new Pair.ptr(new $Int64(0, 34519), new $Int64(0, 15116)), new Pair.ptr(new $Int64(0, 34537), new $Int64(0, 13642)), new Pair.ptr(new $Int64(0, 34543), new $Int64(0, 26466)), new Pair.ptr(new $Int64(0, 34549), new $Int64(0, 21057)), new Pair.ptr(new $Int64(0, 34583), new $Int64(0, 8209)), new Pair.ptr(new $Int64(0, 34589), new $Int64(0, 20206)), new Pair.ptr(new $Int64(0, 34591), new $Int64(0, 1477)), new Pair.ptr(new $Int64(0, 34603), new $Int64(0, 19581)), new Pair.ptr(new $Int64(0, 34607), new $Int64(0, 31558)), new Pair.ptr(new $Int64(0, 34613), new $Int64(0, 29162)), new Pair.ptr(new $Int64(0, 34631), new $Int64(0, 22398)), new Pair.ptr(new $Int64(0, 34649), new $Int64(0, 29985)), new Pair.ptr(new $Int64(0, 34651), new $Int64(0, 5997)), new Pair.ptr(new $Int64(0, 34667), new $Int64(0, 30314)), new Pair.ptr(new $Int64(0, 34673), new $Int64(0, 18873)), new Pair.ptr(new $Int64(0, 34679), new $Int64(0, 34610)), new Pair.ptr(new $Int64(0, 34687), new $Int64(0, 9465)), new Pair.ptr(new $Int64(0, 34693), new $Int64(0, 12397)), new Pair.ptr(new $Int64(0, 34703), new $Int64(0, 32852)), new Pair.ptr(new $Int64(0, 34721), new $Int64(0, 24442)), new Pair.ptr(new $Int64(0, 34729), new $Int64(0, 6890)), new Pair.ptr(new $Int64(0, 34739), new $Int64(0, 10186)), new Pair.ptr(new $Int64(0, 34747), new $Int64(0, 34561)), new Pair.ptr(new $Int64(0, 34757), new $Int64(0, 1443)), new Pair.ptr(new $Int64(0, 34759), new $Int64(0, 34250)), new Pair.ptr(new $Int64(0, 34763), new $Int64(0, 30391)), new Pair.ptr(new $Int64(0, 34781), new $Int64(0, 20888)), new Pair.ptr(new $Int64(0, 34807), new $Int64(0, 10680)), new Pair.ptr(new $Int64(0, 34819), new $Int64(0, 14743)), new Pair.ptr(new $Int64(0, 34841), new $Int64(0, 31975)), new Pair.ptr(new $Int64(0, 34843), new $Int64(0, 22223)), new Pair.ptr(new $Int64(0, 34847), new $Int64(0, 15624)), new Pair.ptr(new $Int64(0, 34849), new $Int64(0, 4442)), new Pair.ptr(new $Int64(0, 34871), new $Int64(0, 7504)), new Pair.ptr(new $Int64(0, 34877), new $Int64(0, 13364)), new Pair.ptr(new $Int64(0, 34883), new $Int64(0, 24049)), new Pair.ptr(new $Int64(0, 34897), new $Int64(0, 432)), new Pair.ptr(new $Int64(0, 34913), new $Int64(0, 30060)), new Pair.ptr(new $Int64(0, 34919), new $Int64(0, 25675)), new Pair.ptr(new $Int64(0, 34939), new $Int64(0, 19820)), new Pair.ptr(new $Int64(0, 34949), new $Int64(0, 23384)), new Pair.ptr(new $Int64(0, 34961), new $Int64(0, 27894)), new Pair.ptr(new $Int64(0, 34963), new $Int64(0, 29844)), new Pair.ptr(new $Int64(0, 34981), new $Int64(0, 28638)), new Pair.ptr(new $Int64(0, 35023), new $Int64(0, 2797)), new Pair.ptr(new $Int64(0, 35027), new $Int64(0, 12223)), new Pair.ptr(new $Int64(0, 35051), new $Int64(0, 31126)), new Pair.ptr(new $Int64(0, 35053), new $Int64(0, 13226)), new Pair.ptr(new $Int64(0, 35059), new $Int64(0, 9556)), new Pair.ptr(new $Int64(0, 35069), new $Int64(0, 22133)), new Pair.ptr(new $Int64(0, 35081), new $Int64(0, 4544)), new Pair.ptr(new $Int64(0, 35083), new $Int64(0, 34748)), new Pair.ptr(new $Int64(0, 35089), new $Int64(0, 20983)), new Pair.ptr(new $Int64(0, 35099), new $Int64(0, 8889)), new Pair.ptr(new $Int64(0, 35107), new $Int64(0, 19768)), new Pair.ptr(new $Int64(0, 35111), new $Int64(0, 8643)), new Pair.ptr(new $Int64(0, 35117), new $Int64(0, 33172)), new Pair.ptr(new $Int64(0, 35129), new $Int64(0, 34366)), new Pair.ptr(new $Int64(0, 35141), new $Int64(0, 18717)), new Pair.ptr(new $Int64(0, 35149), new $Int64(0, 26760)), new Pair.ptr(new $Int64(0, 35153), new $Int64(0, 5052)), new Pair.ptr(new $Int64(0, 35159), new $Int64(0, 1335)), new Pair.ptr(new $Int64(0, 35171), new $Int64(0, 13243)), new Pair.ptr(new $Int64(0, 35201), new $Int64(0, 34556)), new Pair.ptr(new $Int64(0, 35221), new $Int64(0, 10186)), new Pair.ptr(new $Int64(0, 35227), new $Int64(0, 27437)), new Pair.ptr(new $Int64(0, 35251), new $Int64(0, 35013)), new Pair.ptr(new $Int64(0, 35257), new $Int64(0, 27839)), new Pair.ptr(new $Int64(0, 35267), new $Int64(0, 15689)), new Pair.ptr(new $Int64(0, 35279), new $Int64(0, 247)), new Pair.ptr(new $Int64(0, 35281), new $Int64(0, 12089)), new Pair.ptr(new $Int64(0, 35291), new $Int64(0, 12160)), new Pair.ptr(new $Int64(0, 35311), new $Int64(0, 15230)), new Pair.ptr(new $Int64(0, 35317), new $Int64(0, 24270)), new Pair.ptr(new $Int64(0, 35323), new $Int64(0, 14907)), new Pair.ptr(new $Int64(0, 35327), new $Int64(0, 12063)), new Pair.ptr(new $Int64(0, 35339), new $Int64(0, 25366)), new Pair.ptr(new $Int64(0, 35353), new $Int64(0, 19043)), new Pair.ptr(new $Int64(0, 35363), new $Int64(0, 7246)), new Pair.ptr(new $Int64(0, 35381), new $Int64(0, 23157)), new Pair.ptr(new $Int64(0, 35393), new $Int64(0, 20856)), new Pair.ptr(new $Int64(0, 35401), new $Int64(0, 3607)), new Pair.ptr(new $Int64(0, 35407), new $Int64(0, 13234)), new Pair.ptr(new $Int64(0, 35419), new $Int64(0, 8628)), new Pair.ptr(new $Int64(0, 35423), new $Int64(0, 34666)), new Pair.ptr(new $Int64(0, 35437), new $Int64(0, 775)), new Pair.ptr(new $Int64(0, 35447), new $Int64(0, 7288)), new Pair.ptr(new $Int64(0, 35449), new $Int64(0, 21517)), new Pair.ptr(new $Int64(0, 35461), new $Int64(0, 6642)), new Pair.ptr(new $Int64(0, 35491), new $Int64(0, 5646)), new Pair.ptr(new $Int64(0, 35507), new $Int64(0, 22358)), new Pair.ptr(new $Int64(0, 35509), new $Int64(0, 21110)), new Pair.ptr(new $Int64(0, 35521), new $Int64(0, 28672)), new Pair.ptr(new $Int64(0, 35527), new $Int64(0, 23110)), new Pair.ptr(new $Int64(0, 35531), new $Int64(0, 5889)), new Pair.ptr(new $Int64(0, 35533), new $Int64(0, 770)), new Pair.ptr(new $Int64(0, 35537), new $Int64(0, 22013)), new Pair.ptr(new $Int64(0, 35543), new $Int64(0, 13763)), new Pair.ptr(new $Int64(0, 35569), new $Int64(0, 29194)), new Pair.ptr(new $Int64(0, 35573), new $Int64(0, 20660)), new Pair.ptr(new $Int64(0, 35591), new $Int64(0, 23730)), new Pair.ptr(new $Int64(0, 35593), new $Int64(0, 20239)), new Pair.ptr(new $Int64(0, 35597), new $Int64(0, 22388)), new Pair.ptr(new $Int64(0, 35603), new $Int64(0, 25399)), new Pair.ptr(new $Int64(0, 35617), new $Int64(0, 26700)), new Pair.ptr(new $Int64(0, 35671), new $Int64(0, 8864)), new Pair.ptr(new $Int64(0, 35677), new $Int64(0, 1600)), new Pair.ptr(new $Int64(0, 35729), new $Int64(0, 27850)), new Pair.ptr(new $Int64(0, 35731), new $Int64(0, 6291)), new Pair.ptr(new $Int64(0, 35747), new $Int64(0, 29080)), new Pair.ptr(new $Int64(0, 35753), new $Int64(0, 16032)), new Pair.ptr(new $Int64(0, 35759), new $Int64(0, 23792)), new Pair.ptr(new $Int64(0, 35771), new $Int64(0, 22367)), new Pair.ptr(new $Int64(0, 35797), new $Int64(0, 6755)), new Pair.ptr(new $Int64(0, 35801), new $Int64(0, 22806)), new Pair.ptr(new $Int64(0, 35803), new $Int64(0, 17041)), new Pair.ptr(new $Int64(0, 35809), new $Int64(0, 10932)), new Pair.ptr(new $Int64(0, 35831), new $Int64(0, 32982)), new Pair.ptr(new $Int64(0, 35837), new $Int64(0, 6321)), new Pair.ptr(new $Int64(0, 35839), new $Int64(0, 8605)), new Pair.ptr(new $Int64(0, 35851), new $Int64(0, 15445)), new Pair.ptr(new $Int64(0, 35863), new $Int64(0, 10137)), new Pair.ptr(new $Int64(0, 35869), new $Int64(0, 25409)), new Pair.ptr(new $Int64(0, 35879), new $Int64(0, 27492)), new Pair.ptr(new $Int64(0, 35897), new $Int64(0, 24818)), new Pair.ptr(new $Int64(0, 35899), new $Int64(0, 10036)), new Pair.ptr(new $Int64(0, 35911), new $Int64(0, 5085)), new Pair.ptr(new $Int64(0, 35923), new $Int64(0, 10459)), new Pair.ptr(new $Int64(0, 35933), new $Int64(0, 15664)), new Pair.ptr(new $Int64(0, 35951), new $Int64(0, 18906)), new Pair.ptr(new $Int64(0, 35963), new $Int64(0, 23105)), new Pair.ptr(new $Int64(0, 35969), new $Int64(0, 29151)), new Pair.ptr(new $Int64(0, 35977), new $Int64(0, 5549)), new Pair.ptr(new $Int64(0, 35983), new $Int64(0, 18942)), new Pair.ptr(new $Int64(0, 35993), new $Int64(0, 12472)), new Pair.ptr(new $Int64(0, 35999), new $Int64(0, 34345)), new Pair.ptr(new $Int64(0, 36007), new $Int64(0, 13782)), new Pair.ptr(new $Int64(0, 36011), new $Int64(0, 32698)), new Pair.ptr(new $Int64(0, 36013), new $Int64(0, 2975)), new Pair.ptr(new $Int64(0, 36017), new $Int64(0, 13459)), new Pair.ptr(new $Int64(0, 36037), new $Int64(0, 32433)), new Pair.ptr(new $Int64(0, 36061), new $Int64(0, 17742)), new Pair.ptr(new $Int64(0, 36067), new $Int64(0, 3374)), new Pair.ptr(new $Int64(0, 36073), new $Int64(0, 8872)), new Pair.ptr(new $Int64(0, 36083), new $Int64(0, 7754)), new Pair.ptr(new $Int64(0, 36097), new $Int64(0, 25978)), new Pair.ptr(new $Int64(0, 36107), new $Int64(0, 29445)), new Pair.ptr(new $Int64(0, 36109), new $Int64(0, 20132)), new Pair.ptr(new $Int64(0, 36131), new $Int64(0, 23314)), new Pair.ptr(new $Int64(0, 36137), new $Int64(0, 27872)), new Pair.ptr(new $Int64(0, 36151), new $Int64(0, 9525)), new Pair.ptr(new $Int64(0, 36161), new $Int64(0, 9344)), new Pair.ptr(new $Int64(0, 36187), new $Int64(0, 32089)), new Pair.ptr(new $Int64(0, 36191), new $Int64(0, 25287)), new Pair.ptr(new $Int64(0, 36209), new $Int64(0, 33216)), new Pair.ptr(new $Int64(0, 36217), new $Int64(0, 12786)), new Pair.ptr(new $Int64(0, 36229), new $Int64(0, 7640)), new Pair.ptr(new $Int64(0, 36241), new $Int64(0, 17378)), new Pair.ptr(new $Int64(0, 36251), new $Int64(0, 7638)), new Pair.ptr(new $Int64(0, 36263), new $Int64(0, 32445)), new Pair.ptr(new $Int64(0, 36269), new $Int64(0, 26260)), new Pair.ptr(new $Int64(0, 36277), new $Int64(0, 286)), new Pair.ptr(new $Int64(0, 36293), new $Int64(0, 14842)), new Pair.ptr(new $Int64(0, 36299), new $Int64(0, 10172)), new Pair.ptr(new $Int64(0, 36307), new $Int64(0, 8293)), new Pair.ptr(new $Int64(0, 36313), new $Int64(0, 19415)), new Pair.ptr(new $Int64(0, 36319), new $Int64(0, 27297)), new Pair.ptr(new $Int64(0, 36341), new $Int64(0, 8138)), new Pair.ptr(new $Int64(0, 36343), new $Int64(0, 15283)), new Pair.ptr(new $Int64(0, 36353), new $Int64(0, 25126)), new Pair.ptr(new $Int64(0, 36373), new $Int64(0, 31311)), new Pair.ptr(new $Int64(0, 36383), new $Int64(0, 11544)), new Pair.ptr(new $Int64(0, 36389), new $Int64(0, 26565)), new Pair.ptr(new $Int64(0, 36433), new $Int64(0, 16895)), new Pair.ptr(new $Int64(0, 36451), new $Int64(0, 32964)), new Pair.ptr(new $Int64(0, 36457), new $Int64(0, 12288)), new Pair.ptr(new $Int64(0, 36467), new $Int64(0, 8791)), new Pair.ptr(new $Int64(0, 36469), new $Int64(0, 17746)), new Pair.ptr(new $Int64(0, 36473), new $Int64(0, 22877)), new Pair.ptr(new $Int64(0, 36479), new $Int64(0, 23032)), new Pair.ptr(new $Int64(0, 36493), new $Int64(0, 2723)), new Pair.ptr(new $Int64(0, 36497), new $Int64(0, 13055)), new Pair.ptr(new $Int64(0, 36523), new $Int64(0, 27381)), new Pair.ptr(new $Int64(0, 36527), new $Int64(0, 3861)), new Pair.ptr(new $Int64(0, 36529), new $Int64(0, 29690)), new Pair.ptr(new $Int64(0, 36541), new $Int64(0, 8560)), new Pair.ptr(new $Int64(0, 36551), new $Int64(0, 21668)), new Pair.ptr(new $Int64(0, 36559), new $Int64(0, 30107)), new Pair.ptr(new $Int64(0, 36563), new $Int64(0, 22139)), new Pair.ptr(new $Int64(0, 36571), new $Int64(0, 3370)), new Pair.ptr(new $Int64(0, 36583), new $Int64(0, 4822)), new Pair.ptr(new $Int64(0, 36587), new $Int64(0, 14668)), new Pair.ptr(new $Int64(0, 36599), new $Int64(0, 32029)), new Pair.ptr(new $Int64(0, 36607), new $Int64(0, 11854)), new Pair.ptr(new $Int64(0, 36629), new $Int64(0, 1711)), new Pair.ptr(new $Int64(0, 36637), new $Int64(0, 15112)), new Pair.ptr(new $Int64(0, 36643), new $Int64(0, 8216)), new Pair.ptr(new $Int64(0, 36653), new $Int64(0, 35055)), new Pair.ptr(new $Int64(0, 36671), new $Int64(0, 10932)), new Pair.ptr(new $Int64(0, 36677), new $Int64(0, 30835)), new Pair.ptr(new $Int64(0, 36683), new $Int64(0, 16788)), new Pair.ptr(new $Int64(0, 36691), new $Int64(0, 27353)), new Pair.ptr(new $Int64(0, 36697), new $Int64(0, 161)), new Pair.ptr(new $Int64(0, 36709), new $Int64(0, 36529)), new Pair.ptr(new $Int64(0, 36713), new $Int64(0, 17196)), new Pair.ptr(new $Int64(0, 36721), new $Int64(0, 33199)), new Pair.ptr(new $Int64(0, 36739), new $Int64(0, 9757)), new Pair.ptr(new $Int64(0, 36749), new $Int64(0, 28590)), new Pair.ptr(new $Int64(0, 36761), new $Int64(0, 35610)), new Pair.ptr(new $Int64(0, 36767), new $Int64(0, 2711)), new Pair.ptr(new $Int64(0, 36779), new $Int64(0, 25775)), new Pair.ptr(new $Int64(0, 36781), new $Int64(0, 2039)), new Pair.ptr(new $Int64(0, 36787), new $Int64(0, 24830)), new Pair.ptr(new $Int64(0, 36791), new $Int64(0, 2110)), new Pair.ptr(new $Int64(0, 36793), new $Int64(0, 7101)), new Pair.ptr(new $Int64(0, 36809), new $Int64(0, 3319)), new Pair.ptr(new $Int64(0, 36821), new $Int64(0, 14977)), new Pair.ptr(new $Int64(0, 36833), new $Int64(0, 3748)), new Pair.ptr(new $Int64(0, 36847), new $Int64(0, 22349)), new Pair.ptr(new $Int64(0, 36857), new $Int64(0, 10680)), new Pair.ptr(new $Int64(0, 36871), new $Int64(0, 15424)), new Pair.ptr(new $Int64(0, 36877), new $Int64(0, 7143)), new Pair.ptr(new $Int64(0, 36887), new $Int64(0, 15470)), new Pair.ptr(new $Int64(0, 36899), new $Int64(0, 29361)), new Pair.ptr(new $Int64(0, 36901), new $Int64(0, 866)), new Pair.ptr(new $Int64(0, 36913), new $Int64(0, 5981)), new Pair.ptr(new $Int64(0, 36919), new $Int64(0, 2078)), new Pair.ptr(new $Int64(0, 36923), new $Int64(0, 16197)), new Pair.ptr(new $Int64(0, 36929), new $Int64(0, 15578)), new Pair.ptr(new $Int64(0, 36931), new $Int64(0, 32033)), new Pair.ptr(new $Int64(0, 36943), new $Int64(0, 8191)), new Pair.ptr(new $Int64(0, 36947), new $Int64(0, 16178)), new Pair.ptr(new $Int64(0, 36973), new $Int64(0, 35004)), new Pair.ptr(new $Int64(0, 36979), new $Int64(0, 10929)), new Pair.ptr(new $Int64(0, 36997), new $Int64(0, 3692)), new Pair.ptr(new $Int64(0, 37003), new $Int64(0, 21050)), new Pair.ptr(new $Int64(0, 37013), new $Int64(0, 34327)), new Pair.ptr(new $Int64(0, 37019), new $Int64(0, 30455)), new Pair.ptr(new $Int64(0, 37021), new $Int64(0, 18954)), new Pair.ptr(new $Int64(0, 37039), new $Int64(0, 6636)), new Pair.ptr(new $Int64(0, 37049), new $Int64(0, 4451)), new Pair.ptr(new $Int64(0, 37057), new $Int64(0, 36146)), new Pair.ptr(new $Int64(0, 37061), new $Int64(0, 9484)), new Pair.ptr(new $Int64(0, 37087), new $Int64(0, 36166)), new Pair.ptr(new $Int64(0, 37097), new $Int64(0, 25870)), new Pair.ptr(new $Int64(0, 37117), new $Int64(0, 10675)), new Pair.ptr(new $Int64(0, 37123), new $Int64(0, 19709)), new Pair.ptr(new $Int64(0, 37139), new $Int64(0, 798)), new Pair.ptr(new $Int64(0, 37159), new $Int64(0, 12597)), new Pair.ptr(new $Int64(0, 37171), new $Int64(0, 11112)), new Pair.ptr(new $Int64(0, 37181), new $Int64(0, 4426)), new Pair.ptr(new $Int64(0, 37189), new $Int64(0, 18988)), new Pair.ptr(new $Int64(0, 37199), new $Int64(0, 29321)), new Pair.ptr(new $Int64(0, 37201), new $Int64(0, 6875)), new Pair.ptr(new $Int64(0, 37217), new $Int64(0, 18369)), new Pair.ptr(new $Int64(0, 37223), new $Int64(0, 2700)), new Pair.ptr(new $Int64(0, 37243), new $Int64(0, 8797)), new Pair.ptr(new $Int64(0, 37253), new $Int64(0, 28930)), new Pair.ptr(new $Int64(0, 37273), new $Int64(0, 31099)), new Pair.ptr(new $Int64(0, 37277), new $Int64(0, 17449)), new Pair.ptr(new $Int64(0, 37307), new $Int64(0, 26473)), new Pair.ptr(new $Int64(0, 37309), new $Int64(0, 12154)), new Pair.ptr(new $Int64(0, 37313), new $Int64(0, 8009)), new Pair.ptr(new $Int64(0, 37321), new $Int64(0, 7531)), new Pair.ptr(new $Int64(0, 37337), new $Int64(0, 9439)), new Pair.ptr(new $Int64(0, 37339), new $Int64(0, 11110)), new Pair.ptr(new $Int64(0, 37357), new $Int64(0, 8990)), new Pair.ptr(new $Int64(0, 37361), new $Int64(0, 26711)), new Pair.ptr(new $Int64(0, 37363), new $Int64(0, 10505)), new Pair.ptr(new $Int64(0, 37369), new $Int64(0, 9467)), new Pair.ptr(new $Int64(0, 37379), new $Int64(0, 31498)), new Pair.ptr(new $Int64(0, 37397), new $Int64(0, 35251)), new Pair.ptr(new $Int64(0, 37409), new $Int64(0, 5877)), new Pair.ptr(new $Int64(0, 37423), new $Int64(0, 12522)), new Pair.ptr(new $Int64(0, 37441), new $Int64(0, 28202)), new Pair.ptr(new $Int64(0, 37447), new $Int64(0, 8198)), new Pair.ptr(new $Int64(0, 37463), new $Int64(0, 36363)), new Pair.ptr(new $Int64(0, 37483), new $Int64(0, 23083)), new Pair.ptr(new $Int64(0, 37489), new $Int64(0, 36088)), new Pair.ptr(new $Int64(0, 37493), new $Int64(0, 35334)), new Pair.ptr(new $Int64(0, 37501), new $Int64(0, 20998)), new Pair.ptr(new $Int64(0, 37507), new $Int64(0, 36969)), new Pair.ptr(new $Int64(0, 37511), new $Int64(0, 21675)), new Pair.ptr(new $Int64(0, 37517), new $Int64(0, 25507)), new Pair.ptr(new $Int64(0, 37529), new $Int64(0, 16281)), new Pair.ptr(new $Int64(0, 37537), new $Int64(0, 14077)), new Pair.ptr(new $Int64(0, 37547), new $Int64(0, 25443)), new Pair.ptr(new $Int64(0, 37549), new $Int64(0, 11632)), new Pair.ptr(new $Int64(0, 37561), new $Int64(0, 7692)), new Pair.ptr(new $Int64(0, 37567), new $Int64(0, 23161)), new Pair.ptr(new $Int64(0, 37571), new $Int64(0, 30211)), new Pair.ptr(new $Int64(0, 37573), new $Int64(0, 26526)), new Pair.ptr(new $Int64(0, 37579), new $Int64(0, 17601)), new Pair.ptr(new $Int64(0, 37589), new $Int64(0, 22672)), new Pair.ptr(new $Int64(0, 37591), new $Int64(0, 9266)), new Pair.ptr(new $Int64(0, 37607), new $Int64(0, 20393)), new Pair.ptr(new $Int64(0, 37619), new $Int64(0, 20050)), new Pair.ptr(new $Int64(0, 37633), new $Int64(0, 18053)), new Pair.ptr(new $Int64(0, 37643), new $Int64(0, 31555)), new Pair.ptr(new $Int64(0, 37649), new $Int64(0, 23404)), new Pair.ptr(new $Int64(0, 37657), new $Int64(0, 30035)), new Pair.ptr(new $Int64(0, 37663), new $Int64(0, 19563)), new Pair.ptr(new $Int64(0, 37691), new $Int64(0, 32642)), new Pair.ptr(new $Int64(0, 37693), new $Int64(0, 27891)), new Pair.ptr(new $Int64(0, 37699), new $Int64(0, 21461)), new Pair.ptr(new $Int64(0, 37717), new $Int64(0, 22076)), new Pair.ptr(new $Int64(0, 37747), new $Int64(0, 34943)), new Pair.ptr(new $Int64(0, 37781), new $Int64(0, 29257)), new Pair.ptr(new $Int64(0, 37783), new $Int64(0, 20267)), new Pair.ptr(new $Int64(0, 37799), new $Int64(0, 36742)), new Pair.ptr(new $Int64(0, 37811), new $Int64(0, 10913)), new Pair.ptr(new $Int64(0, 37813), new $Int64(0, 33155)), new Pair.ptr(new $Int64(0, 37831), new $Int64(0, 26899)), new Pair.ptr(new $Int64(0, 37847), new $Int64(0, 31450)), new Pair.ptr(new $Int64(0, 37853), new $Int64(0, 8106)), new Pair.ptr(new $Int64(0, 37861), new $Int64(0, 7205)), new Pair.ptr(new $Int64(0, 37871), new $Int64(0, 26196)), new Pair.ptr(new $Int64(0, 37879), new $Int64(0, 24534)), new Pair.ptr(new $Int64(0, 37889), new $Int64(0, 4022)), new Pair.ptr(new $Int64(0, 37897), new $Int64(0, 30340)), new Pair.ptr(new $Int64(0, 37907), new $Int64(0, 17280)), new Pair.ptr(new $Int64(0, 37951), new $Int64(0, 10113)), new Pair.ptr(new $Int64(0, 37957), new $Int64(0, 25250)), new Pair.ptr(new $Int64(0, 37963), new $Int64(0, 25199)), new Pair.ptr(new $Int64(0, 37967), new $Int64(0, 36746)), new Pair.ptr(new $Int64(0, 37987), new $Int64(0, 36038)), new Pair.ptr(new $Int64(0, 37991), new $Int64(0, 36792)), new Pair.ptr(new $Int64(0, 37993), new $Int64(0, 17125)), new Pair.ptr(new $Int64(0, 37997), new $Int64(0, 29857)), new Pair.ptr(new $Int64(0, 38011), new $Int64(0, 8705)), new Pair.ptr(new $Int64(0, 38039), new $Int64(0, 25993)), new Pair.ptr(new $Int64(0, 38047), new $Int64(0, 32199)), new Pair.ptr(new $Int64(0, 38053), new $Int64(0, 22113)), new Pair.ptr(new $Int64(0, 38069), new $Int64(0, 33382)), new Pair.ptr(new $Int64(0, 38083), new $Int64(0, 19648)), new Pair.ptr(new $Int64(0, 38113), new $Int64(0, 11544)), new Pair.ptr(new $Int64(0, 38119), new $Int64(0, 34362)), new Pair.ptr(new $Int64(0, 38149), new $Int64(0, 8426)), new Pair.ptr(new $Int64(0, 38153), new $Int64(0, 1786)), new Pair.ptr(new $Int64(0, 38167), new $Int64(0, 3437)), new Pair.ptr(new $Int64(0, 38177), new $Int64(0, 3511)), new Pair.ptr(new $Int64(0, 38183), new $Int64(0, 31569)), new Pair.ptr(new $Int64(0, 38189), new $Int64(0, 25590)), new Pair.ptr(new $Int64(0, 38197), new $Int64(0, 35102)), new Pair.ptr(new $Int64(0, 38201), new $Int64(0, 12886)), new Pair.ptr(new $Int64(0, 38219), new $Int64(0, 5212)), new Pair.ptr(new $Int64(0, 38231), new $Int64(0, 7425)), new Pair.ptr(new $Int64(0, 38237), new $Int64(0, 23208)), new Pair.ptr(new $Int64(0, 38239), new $Int64(0, 35769)), new Pair.ptr(new $Int64(0, 38261), new $Int64(0, 19385)), new Pair.ptr(new $Int64(0, 38273), new $Int64(0, 20909)), new Pair.ptr(new $Int64(0, 38281), new $Int64(0, 36598)), new Pair.ptr(new $Int64(0, 38287), new $Int64(0, 5169)), new Pair.ptr(new $Int64(0, 38299), new $Int64(0, 34046)), new Pair.ptr(new $Int64(0, 38303), new $Int64(0, 21375)), new Pair.ptr(new $Int64(0, 38317), new $Int64(0, 37509)), new Pair.ptr(new $Int64(0, 38321), new $Int64(0, 28163)), new Pair.ptr(new $Int64(0, 38327), new $Int64(0, 37171)), new Pair.ptr(new $Int64(0, 38329), new $Int64(0, 24567)), new Pair.ptr(new $Int64(0, 38333), new $Int64(0, 33445)), new Pair.ptr(new $Int64(0, 38351), new $Int64(0, 21624)), new Pair.ptr(new $Int64(0, 38371), new $Int64(0, 15189)), new Pair.ptr(new $Int64(0, 38377), new $Int64(0, 38277)), new Pair.ptr(new $Int64(0, 38393), new $Int64(0, 16372)), new Pair.ptr(new $Int64(0, 38431), new $Int64(0, 18073)), new Pair.ptr(new $Int64(0, 38447), new $Int64(0, 14127)), new Pair.ptr(new $Int64(0, 38449), new $Int64(0, 25681)), new Pair.ptr(new $Int64(0, 38453), new $Int64(0, 26443)), new Pair.ptr(new $Int64(0, 38459), new $Int64(0, 4630)), new Pair.ptr(new $Int64(0, 38461), new $Int64(0, 9394)), new Pair.ptr(new $Int64(0, 38501), new $Int64(0, 23199)), new Pair.ptr(new $Int64(0, 38543), new $Int64(0, 678)), new Pair.ptr(new $Int64(0, 38557), new $Int64(0, 12861)), new Pair.ptr(new $Int64(0, 38561), new $Int64(0, 31113)), new Pair.ptr(new $Int64(0, 38567), new $Int64(0, 5926)), new Pair.ptr(new $Int64(0, 38569), new $Int64(0, 22409)), new Pair.ptr(new $Int64(0, 38593), new $Int64(0, 13540)), new Pair.ptr(new $Int64(0, 38603), new $Int64(0, 197)), new Pair.ptr(new $Int64(0, 38609), new $Int64(0, 4137)), new Pair.ptr(new $Int64(0, 38611), new $Int64(0, 26200)), new Pair.ptr(new $Int64(0, 38629), new $Int64(0, 13433)), new Pair.ptr(new $Int64(0, 38639), new $Int64(0, 7566)), new Pair.ptr(new $Int64(0, 38651), new $Int64(0, 7912)), new Pair.ptr(new $Int64(0, 38653), new $Int64(0, 24431)), new Pair.ptr(new $Int64(0, 38669), new $Int64(0, 32981)), new Pair.ptr(new $Int64(0, 38671), new $Int64(0, 24792)), new Pair.ptr(new $Int64(0, 38677), new $Int64(0, 35234)), new Pair.ptr(new $Int64(0, 38693), new $Int64(0, 20462)), new Pair.ptr(new $Int64(0, 38699), new $Int64(0, 30484)), new Pair.ptr(new $Int64(0, 38707), new $Int64(0, 12128)), new Pair.ptr(new $Int64(0, 38711), new $Int64(0, 37876)), new Pair.ptr(new $Int64(0, 38713), new $Int64(0, 26538)), new Pair.ptr(new $Int64(0, 38723), new $Int64(0, 26619)), new Pair.ptr(new $Int64(0, 38729), new $Int64(0, 4382)), new Pair.ptr(new $Int64(0, 38737), new $Int64(0, 10425)), new Pair.ptr(new $Int64(0, 38747), new $Int64(0, 17121)), new Pair.ptr(new $Int64(0, 38749), new $Int64(0, 12236)), new Pair.ptr(new $Int64(0, 38767), new $Int64(0, 9339)), new Pair.ptr(new $Int64(0, 38783), new $Int64(0, 32530)), new Pair.ptr(new $Int64(0, 38791), new $Int64(0, 21730)), new Pair.ptr(new $Int64(0, 38803), new $Int64(0, 5134)), new Pair.ptr(new $Int64(0, 38821), new $Int64(0, 11072)), new Pair.ptr(new $Int64(0, 38833), new $Int64(0, 28366)), new Pair.ptr(new $Int64(0, 38839), new $Int64(0, 27833)), new Pair.ptr(new $Int64(0, 38851), new $Int64(0, 8354)), new Pair.ptr(new $Int64(0, 38861), new $Int64(0, 31258)), new Pair.ptr(new $Int64(0, 38867), new $Int64(0, 36161)), new Pair.ptr(new $Int64(0, 38873), new $Int64(0, 7839)), new Pair.ptr(new $Int64(0, 38891), new $Int64(0, 5630)), new Pair.ptr(new $Int64(0, 38903), new $Int64(0, 31387)), new Pair.ptr(new $Int64(0, 38917), new $Int64(0, 8860)), new Pair.ptr(new $Int64(0, 38921), new $Int64(0, 1542)), new Pair.ptr(new $Int64(0, 38923), new $Int64(0, 19537)), new Pair.ptr(new $Int64(0, 38933), new $Int64(0, 25334)), new Pair.ptr(new $Int64(0, 38953), new $Int64(0, 16974)), new Pair.ptr(new $Int64(0, 38959), new $Int64(0, 10872)), new Pair.ptr(new $Int64(0, 38971), new $Int64(0, 24887)), new Pair.ptr(new $Int64(0, 38977), new $Int64(0, 25948)), new Pair.ptr(new $Int64(0, 38993), new $Int64(0, 2098)), new Pair.ptr(new $Int64(0, 39019), new $Int64(0, 23070)), new Pair.ptr(new $Int64(0, 39023), new $Int64(0, 11524)), new Pair.ptr(new $Int64(0, 39041), new $Int64(0, 6344)), new Pair.ptr(new $Int64(0, 39043), new $Int64(0, 27086)), new Pair.ptr(new $Int64(0, 39047), new $Int64(0, 16961)), new Pair.ptr(new $Int64(0, 39079), new $Int64(0, 18245)), new Pair.ptr(new $Int64(0, 39089), new $Int64(0, 29649)), new Pair.ptr(new $Int64(0, 39097), new $Int64(0, 10600)), new Pair.ptr(new $Int64(0, 39103), new $Int64(0, 779)), new Pair.ptr(new $Int64(0, 39107), new $Int64(0, 35642)), new Pair.ptr(new $Int64(0, 39113), new $Int64(0, 15077)), new Pair.ptr(new $Int64(0, 39119), new $Int64(0, 2775)), new Pair.ptr(new $Int64(0, 39133), new $Int64(0, 29152)), new Pair.ptr(new $Int64(0, 39139), new $Int64(0, 3591)), new Pair.ptr(new $Int64(0, 39157), new $Int64(0, 19985)), new Pair.ptr(new $Int64(0, 39161), new $Int64(0, 12623)), new Pair.ptr(new $Int64(0, 39163), new $Int64(0, 31512)), new Pair.ptr(new $Int64(0, 39181), new $Int64(0, 9609)), new Pair.ptr(new $Int64(0, 39191), new $Int64(0, 19357)), new Pair.ptr(new $Int64(0, 39199), new $Int64(0, 14620)), new Pair.ptr(new $Int64(0, 39209), new $Int64(0, 27429)), new Pair.ptr(new $Int64(0, 39217), new $Int64(0, 29242)), new Pair.ptr(new $Int64(0, 39227), new $Int64(0, 13140)), new Pair.ptr(new $Int64(0, 39229), new $Int64(0, 37665)), new Pair.ptr(new $Int64(0, 39233), new $Int64(0, 10420)), new Pair.ptr(new $Int64(0, 39239), new $Int64(0, 24853)), new Pair.ptr(new $Int64(0, 39241), new $Int64(0, 33282)), new Pair.ptr(new $Int64(0, 39251), new $Int64(0, 29915)), new Pair.ptr(new $Int64(0, 39293), new $Int64(0, 22899)), new Pair.ptr(new $Int64(0, 39301), new $Int64(0, 9874)), new Pair.ptr(new $Int64(0, 39313), new $Int64(0, 18584)), new Pair.ptr(new $Int64(0, 39317), new $Int64(0, 29166)), new Pair.ptr(new $Int64(0, 39323), new $Int64(0, 38738)), new Pair.ptr(new $Int64(0, 39341), new $Int64(0, 11050)), new Pair.ptr(new $Int64(0, 39343), new $Int64(0, 19060)), new Pair.ptr(new $Int64(0, 39359), new $Int64(0, 944)), new Pair.ptr(new $Int64(0, 39367), new $Int64(0, 22501)), new Pair.ptr(new $Int64(0, 39371), new $Int64(0, 9318)), new Pair.ptr(new $Int64(0, 39373), new $Int64(0, 15092)), new Pair.ptr(new $Int64(0, 39383), new $Int64(0, 11709)), new Pair.ptr(new $Int64(0, 39397), new $Int64(0, 37661)), new Pair.ptr(new $Int64(0, 39409), new $Int64(0, 19590)), new Pair.ptr(new $Int64(0, 39419), new $Int64(0, 37155)), new Pair.ptr(new $Int64(0, 39439), new $Int64(0, 6081)), new Pair.ptr(new $Int64(0, 39443), new $Int64(0, 21164)), new Pair.ptr(new $Int64(0, 39451), new $Int64(0, 38357)), new Pair.ptr(new $Int64(0, 39461), new $Int64(0, 13449)), new Pair.ptr(new $Int64(0, 39499), new $Int64(0, 28523)), new Pair.ptr(new $Int64(0, 39503), new $Int64(0, 13560)), new Pair.ptr(new $Int64(0, 39509), new $Int64(0, 30382)), new Pair.ptr(new $Int64(0, 39511), new $Int64(0, 15660)), new Pair.ptr(new $Int64(0, 39521), new $Int64(0, 8554)), new Pair.ptr(new $Int64(0, 39541), new $Int64(0, 15267)), new Pair.ptr(new $Int64(0, 39551), new $Int64(0, 11593)), new Pair.ptr(new $Int64(0, 39563), new $Int64(0, 39093)), new Pair.ptr(new $Int64(0, 39569), new $Int64(0, 15822)), new Pair.ptr(new $Int64(0, 39581), new $Int64(0, 17879)), new Pair.ptr(new $Int64(0, 39607), new $Int64(0, 3171)), new Pair.ptr(new $Int64(0, 39619), new $Int64(0, 9097)), new Pair.ptr(new $Int64(0, 39623), new $Int64(0, 1647)), new Pair.ptr(new $Int64(0, 39631), new $Int64(0, 7235)), new Pair.ptr(new $Int64(0, 39659), new $Int64(0, 23039)), new Pair.ptr(new $Int64(0, 39667), new $Int64(0, 17937)), new Pair.ptr(new $Int64(0, 39671), new $Int64(0, 24548)), new Pair.ptr(new $Int64(0, 39679), new $Int64(0, 33707)), new Pair.ptr(new $Int64(0, 39703), new $Int64(0, 4202)), new Pair.ptr(new $Int64(0, 39709), new $Int64(0, 25273)), new Pair.ptr(new $Int64(0, 39719), new $Int64(0, 14642)), new Pair.ptr(new $Int64(0, 39727), new $Int64(0, 39177)), new Pair.ptr(new $Int64(0, 39733), new $Int64(0, 21700)), new Pair.ptr(new $Int64(0, 39749), new $Int64(0, 28184)), new Pair.ptr(new $Int64(0, 39761), new $Int64(0, 22707)), new Pair.ptr(new $Int64(0, 39769), new $Int64(0, 13452)), new Pair.ptr(new $Int64(0, 39779), new $Int64(0, 18340)), new Pair.ptr(new $Int64(0, 39791), new $Int64(0, 16513)), new Pair.ptr(new $Int64(0, 39799), new $Int64(0, 22239)), new Pair.ptr(new $Int64(0, 39821), new $Int64(0, 22244)), new Pair.ptr(new $Int64(0, 39827), new $Int64(0, 23248)), new Pair.ptr(new $Int64(0, 39829), new $Int64(0, 2391)), new Pair.ptr(new $Int64(0, 39839), new $Int64(0, 16517)), new Pair.ptr(new $Int64(0, 39841), new $Int64(0, 37572)), new Pair.ptr(new $Int64(0, 39847), new $Int64(0, 14177)), new Pair.ptr(new $Int64(0, 39857), new $Int64(0, 20110)), new Pair.ptr(new $Int64(0, 39863), new $Int64(0, 38812)), new Pair.ptr(new $Int64(0, 39869), new $Int64(0, 3575)), new Pair.ptr(new $Int64(0, 39877), new $Int64(0, 8481)), new Pair.ptr(new $Int64(0, 39883), new $Int64(0, 21254)), new Pair.ptr(new $Int64(0, 39887), new $Int64(0, 869)), new Pair.ptr(new $Int64(0, 39901), new $Int64(0, 18276)), new Pair.ptr(new $Int64(0, 39929), new $Int64(0, 5156)), new Pair.ptr(new $Int64(0, 39937), new $Int64(0, 32053)), new Pair.ptr(new $Int64(0, 39953), new $Int64(0, 1990)), new Pair.ptr(new $Int64(0, 39971), new $Int64(0, 5986)), new Pair.ptr(new $Int64(0, 39979), new $Int64(0, 33862)), new Pair.ptr(new $Int64(0, 39983), new $Int64(0, 37411)), new Pair.ptr(new $Int64(0, 39989), new $Int64(0, 29273)), new Pair.ptr(new $Int64(0, 40009), new $Int64(0, 18929)), new Pair.ptr(new $Int64(0, 40013), new $Int64(0, 494)), new Pair.ptr(new $Int64(0, 40031), new $Int64(0, 28170)), new Pair.ptr(new $Int64(0, 40037), new $Int64(0, 31140)), new Pair.ptr(new $Int64(0, 40039), new $Int64(0, 26693)), new Pair.ptr(new $Int64(0, 40063), new $Int64(0, 35418)), new Pair.ptr(new $Int64(0, 40087), new $Int64(0, 23313)), new Pair.ptr(new $Int64(0, 40093), new $Int64(0, 17651)), new Pair.ptr(new $Int64(0, 40099), new $Int64(0, 16538)), new Pair.ptr(new $Int64(0, 40111), new $Int64(0, 23351)), new Pair.ptr(new $Int64(0, 40123), new $Int64(0, 3545)), new Pair.ptr(new $Int64(0, 40127), new $Int64(0, 11377)), new Pair.ptr(new $Int64(0, 40129), new $Int64(0, 25400)), new Pair.ptr(new $Int64(0, 40151), new $Int64(0, 8199)), new Pair.ptr(new $Int64(0, 40153), new $Int64(0, 27124)), new Pair.ptr(new $Int64(0, 40163), new $Int64(0, 32544)), new Pair.ptr(new $Int64(0, 40169), new $Int64(0, 35083)), new Pair.ptr(new $Int64(0, 40177), new $Int64(0, 11535)), new Pair.ptr(new $Int64(0, 40189), new $Int64(0, 9800)), new Pair.ptr(new $Int64(0, 40193), new $Int64(0, 12522)), new Pair.ptr(new $Int64(0, 40213), new $Int64(0, 27506)), new Pair.ptr(new $Int64(0, 40231), new $Int64(0, 28927)), new Pair.ptr(new $Int64(0, 40237), new $Int64(0, 13140)), new Pair.ptr(new $Int64(0, 40241), new $Int64(0, 36971)), new Pair.ptr(new $Int64(0, 40253), new $Int64(0, 30174)), new Pair.ptr(new $Int64(0, 40277), new $Int64(0, 22716)), new Pair.ptr(new $Int64(0, 40283), new $Int64(0, 29784)), new Pair.ptr(new $Int64(0, 40289), new $Int64(0, 36999)), new Pair.ptr(new $Int64(0, 40343), new $Int64(0, 29647)), new Pair.ptr(new $Int64(0, 40351), new $Int64(0, 24176)), new Pair.ptr(new $Int64(0, 40357), new $Int64(0, 2334)), new Pair.ptr(new $Int64(0, 40361), new $Int64(0, 38936)), new Pair.ptr(new $Int64(0, 40387), new $Int64(0, 27623)), new Pair.ptr(new $Int64(0, 40423), new $Int64(0, 36342)), new Pair.ptr(new $Int64(0, 40427), new $Int64(0, 29737)), new Pair.ptr(new $Int64(0, 40429), new $Int64(0, 29447)), new Pair.ptr(new $Int64(0, 40433), new $Int64(0, 10254)), new Pair.ptr(new $Int64(0, 40459), new $Int64(0, 33056)), new Pair.ptr(new $Int64(0, 40471), new $Int64(0, 313)), new Pair.ptr(new $Int64(0, 40483), new $Int64(0, 16114)), new Pair.ptr(new $Int64(0, 40487), new $Int64(0, 12288)), new Pair.ptr(new $Int64(0, 40493), new $Int64(0, 35815)), new Pair.ptr(new $Int64(0, 40499), new $Int64(0, 35705)), new Pair.ptr(new $Int64(0, 40507), new $Int64(0, 30214)), new Pair.ptr(new $Int64(0, 40519), new $Int64(0, 12886)), new Pair.ptr(new $Int64(0, 40529), new $Int64(0, 1630)), new Pair.ptr(new $Int64(0, 40531), new $Int64(0, 35358)), new Pair.ptr(new $Int64(0, 40543), new $Int64(0, 38313)), new Pair.ptr(new $Int64(0, 40559), new $Int64(0, 4741)), new Pair.ptr(new $Int64(0, 40577), new $Int64(0, 40174)), new Pair.ptr(new $Int64(0, 40583), new $Int64(0, 15147)), new Pair.ptr(new $Int64(0, 40591), new $Int64(0, 6802)), new Pair.ptr(new $Int64(0, 40597), new $Int64(0, 7823)), new Pair.ptr(new $Int64(0, 40609), new $Int64(0, 29071)), new Pair.ptr(new $Int64(0, 40627), new $Int64(0, 38989)), new Pair.ptr(new $Int64(0, 40637), new $Int64(0, 32378)), new Pair.ptr(new $Int64(0, 40639), new $Int64(0, 22140)), new Pair.ptr(new $Int64(0, 40693), new $Int64(0, 33485)), new Pair.ptr(new $Int64(0, 40697), new $Int64(0, 1466)), new Pair.ptr(new $Int64(0, 40699), new $Int64(0, 20648)), new Pair.ptr(new $Int64(0, 40709), new $Int64(0, 3935)), new Pair.ptr(new $Int64(0, 40739), new $Int64(0, 2137)), new Pair.ptr(new $Int64(0, 40751), new $Int64(0, 12189)), new Pair.ptr(new $Int64(0, 40759), new $Int64(0, 35846)), new Pair.ptr(new $Int64(0, 40763), new $Int64(0, 24112)), new Pair.ptr(new $Int64(0, 40771), new $Int64(0, 34264)), new Pair.ptr(new $Int64(0, 40787), new $Int64(0, 30613)), new Pair.ptr(new $Int64(0, 40801), new $Int64(0, 3342)), new Pair.ptr(new $Int64(0, 40813), new $Int64(0, 34970)), new Pair.ptr(new $Int64(0, 40819), new $Int64(0, 31719)), new Pair.ptr(new $Int64(0, 40823), new $Int64(0, 2798)), new Pair.ptr(new $Int64(0, 40829), new $Int64(0, 23321)), new Pair.ptr(new $Int64(0, 40841), new $Int64(0, 28587)), new Pair.ptr(new $Int64(0, 40847), new $Int64(0, 2767)), new Pair.ptr(new $Int64(0, 40849), new $Int64(0, 32181)), new Pair.ptr(new $Int64(0, 40853), new $Int64(0, 40786)), new Pair.ptr(new $Int64(0, 40867), new $Int64(0, 9702)), new Pair.ptr(new $Int64(0, 40879), new $Int64(0, 22965)), new Pair.ptr(new $Int64(0, 40883), new $Int64(0, 38151)), new Pair.ptr(new $Int64(0, 40897), new $Int64(0, 17625)), new Pair.ptr(new $Int64(0, 40903), new $Int64(0, 23003)), new Pair.ptr(new $Int64(0, 40927), new $Int64(0, 32960)), new Pair.ptr(new $Int64(0, 40933), new $Int64(0, 7716)), new Pair.ptr(new $Int64(0, 40939), new $Int64(0, 13449)), new Pair.ptr(new $Int64(0, 40949), new $Int64(0, 931)), new Pair.ptr(new $Int64(0, 40961), new $Int64(0, 10748)), new Pair.ptr(new $Int64(0, 40973), new $Int64(0, 17288)), new Pair.ptr(new $Int64(0, 40993), new $Int64(0, 40018)), new Pair.ptr(new $Int64(0, 41011), new $Int64(0, 12178)), new Pair.ptr(new $Int64(0, 41017), new $Int64(0, 12063)), new Pair.ptr(new $Int64(0, 41023), new $Int64(0, 24177)), new Pair.ptr(new $Int64(0, 41039), new $Int64(0, 7011)), new Pair.ptr(new $Int64(0, 41047), new $Int64(0, 35517)), new Pair.ptr(new $Int64(0, 41051), new $Int64(0, 3113)), new Pair.ptr(new $Int64(0, 41057), new $Int64(0, 1561)), new Pair.ptr(new $Int64(0, 41077), new $Int64(0, 2786)), new Pair.ptr(new $Int64(0, 41081), new $Int64(0, 18495)), new Pair.ptr(new $Int64(0, 41113), new $Int64(0, 4649)), new Pair.ptr(new $Int64(0, 41117), new $Int64(0, 16289)), new Pair.ptr(new $Int64(0, 41131), new $Int64(0, 4612)), new Pair.ptr(new $Int64(0, 41141), new $Int64(0, 3089)), new Pair.ptr(new $Int64(0, 41143), new $Int64(0, 32427)), new Pair.ptr(new $Int64(0, 41149), new $Int64(0, 38193)), new Pair.ptr(new $Int64(0, 41161), new $Int64(0, 33389)), new Pair.ptr(new $Int64(0, 41177), new $Int64(0, 21681)), new Pair.ptr(new $Int64(0, 41179), new $Int64(0, 22825)), new Pair.ptr(new $Int64(0, 41183), new $Int64(0, 1177)), new Pair.ptr(new $Int64(0, 41189), new $Int64(0, 7767)), new Pair.ptr(new $Int64(0, 41201), new $Int64(0, 14680)), new Pair.ptr(new $Int64(0, 41203), new $Int64(0, 22863)), new Pair.ptr(new $Int64(0, 41213), new $Int64(0, 16607)), new Pair.ptr(new $Int64(0, 41221), new $Int64(0, 10727)), new Pair.ptr(new $Int64(0, 41227), new $Int64(0, 18107)), new Pair.ptr(new $Int64(0, 41231), new $Int64(0, 38900)), new Pair.ptr(new $Int64(0, 41233), new $Int64(0, 13560)), new Pair.ptr(new $Int64(0, 41243), new $Int64(0, 26044)), new Pair.ptr(new $Int64(0, 41257), new $Int64(0, 5910)), new Pair.ptr(new $Int64(0, 41263), new $Int64(0, 14013)), new Pair.ptr(new $Int64(0, 41269), new $Int64(0, 10723)), new Pair.ptr(new $Int64(0, 41281), new $Int64(0, 9691)), new Pair.ptr(new $Int64(0, 41299), new $Int64(0, 26811)), new Pair.ptr(new $Int64(0, 41333), new $Int64(0, 36847)), new Pair.ptr(new $Int64(0, 41341), new $Int64(0, 805)), new Pair.ptr(new $Int64(0, 41351), new $Int64(0, 9105)), new Pair.ptr(new $Int64(0, 41357), new $Int64(0, 26713)), new Pair.ptr(new $Int64(0, 41381), new $Int64(0, 22578)), new Pair.ptr(new $Int64(0, 41387), new $Int64(0, 33296)), new Pair.ptr(new $Int64(0, 41389), new $Int64(0, 12160)), new Pair.ptr(new $Int64(0, 41399), new $Int64(0, 30605)), new Pair.ptr(new $Int64(0, 41411), new $Int64(0, 19895)), new Pair.ptr(new $Int64(0, 41413), new $Int64(0, 38256)), new Pair.ptr(new $Int64(0, 41443), new $Int64(0, 23700)), new Pair.ptr(new $Int64(0, 41453), new $Int64(0, 31322)), new Pair.ptr(new $Int64(0, 41467), new $Int64(0, 13987)), new Pair.ptr(new $Int64(0, 41479), new $Int64(0, 19697)), new Pair.ptr(new $Int64(0, 41491), new $Int64(0, 6186)), new Pair.ptr(new $Int64(0, 41507), new $Int64(0, 19004)), new Pair.ptr(new $Int64(0, 41513), new $Int64(0, 7459)), new Pair.ptr(new $Int64(0, 41519), new $Int64(0, 21859)), new Pair.ptr(new $Int64(0, 41521), new $Int64(0, 18541)), new Pair.ptr(new $Int64(0, 41539), new $Int64(0, 7131)), new Pair.ptr(new $Int64(0, 41543), new $Int64(0, 7039)), new Pair.ptr(new $Int64(0, 41549), new $Int64(0, 22321)), new Pair.ptr(new $Int64(0, 41579), new $Int64(0, 30385)), new Pair.ptr(new $Int64(0, 41593), new $Int64(0, 15382)), new Pair.ptr(new $Int64(0, 41597), new $Int64(0, 33974)), new Pair.ptr(new $Int64(0, 41603), new $Int64(0, 7444)), new Pair.ptr(new $Int64(0, 41609), new $Int64(0, 35925)), new Pair.ptr(new $Int64(0, 41611), new $Int64(0, 12855)), new Pair.ptr(new $Int64(0, 41617), new $Int64(0, 8955)), new Pair.ptr(new $Int64(0, 41621), new $Int64(0, 8863)), new Pair.ptr(new $Int64(0, 41627), new $Int64(0, 26877)), new Pair.ptr(new $Int64(0, 41641), new $Int64(0, 3702)), new Pair.ptr(new $Int64(0, 41647), new $Int64(0, 8535)), new Pair.ptr(new $Int64(0, 41651), new $Int64(0, 4490)), new Pair.ptr(new $Int64(0, 41659), new $Int64(0, 9066)), new Pair.ptr(new $Int64(0, 41669), new $Int64(0, 9814)), new Pair.ptr(new $Int64(0, 41681), new $Int64(0, 34713)), new Pair.ptr(new $Int64(0, 41687), new $Int64(0, 37806)), new Pair.ptr(new $Int64(0, 41719), new $Int64(0, 19936)), new Pair.ptr(new $Int64(0, 41729), new $Int64(0, 32110)), new Pair.ptr(new $Int64(0, 41737), new $Int64(0, 13609)), new Pair.ptr(new $Int64(0, 41759), new $Int64(0, 24989)), new Pair.ptr(new $Int64(0, 41761), new $Int64(0, 7676)), new Pair.ptr(new $Int64(0, 41771), new $Int64(0, 13433)), new Pair.ptr(new $Int64(0, 41777), new $Int64(0, 32389)), new Pair.ptr(new $Int64(0, 41801), new $Int64(0, 22661)), new Pair.ptr(new $Int64(0, 41809), new $Int64(0, 26171)), new Pair.ptr(new $Int64(0, 41813), new $Int64(0, 23198)), new Pair.ptr(new $Int64(0, 41843), new $Int64(0, 30394)), new Pair.ptr(new $Int64(0, 41849), new $Int64(0, 5822)), new Pair.ptr(new $Int64(0, 41851), new $Int64(0, 25012)), new Pair.ptr(new $Int64(0, 41863), new $Int64(0, 34040)), new Pair.ptr(new $Int64(0, 41879), new $Int64(0, 41712)), new Pair.ptr(new $Int64(0, 41887), new $Int64(0, 35658)), new Pair.ptr(new $Int64(0, 41893), new $Int64(0, 36565)), new Pair.ptr(new $Int64(0, 41897), new $Int64(0, 21223)), new Pair.ptr(new $Int64(0, 41903), new $Int64(0, 10114)), new Pair.ptr(new $Int64(0, 41911), new $Int64(0, 9326)), new Pair.ptr(new $Int64(0, 41927), new $Int64(0, 12013)), new Pair.ptr(new $Int64(0, 41941), new $Int64(0, 32660)), new Pair.ptr(new $Int64(0, 41947), new $Int64(0, 37951)), new Pair.ptr(new $Int64(0, 41953), new $Int64(0, 20293)), new Pair.ptr(new $Int64(0, 41957), new $Int64(0, 28358)), new Pair.ptr(new $Int64(0, 41959), new $Int64(0, 1188)), new Pair.ptr(new $Int64(0, 41969), new $Int64(0, 33259)), new Pair.ptr(new $Int64(0, 41981), new $Int64(0, 34858)), new Pair.ptr(new $Int64(0, 41983), new $Int64(0, 29566)), new Pair.ptr(new $Int64(0, 41999), new $Int64(0, 20853)), new Pair.ptr(new $Int64(0, 42013), new $Int64(0, 39188)), new Pair.ptr(new $Int64(0, 42017), new $Int64(0, 2437)), new Pair.ptr(new $Int64(0, 42019), new $Int64(0, 9774)), new Pair.ptr(new $Int64(0, 42023), new $Int64(0, 38816)), new Pair.ptr(new $Int64(0, 42043), new $Int64(0, 18919)), new Pair.ptr(new $Int64(0, 42061), new $Int64(0, 7416)), new Pair.ptr(new $Int64(0, 42071), new $Int64(0, 7036)), new Pair.ptr(new $Int64(0, 42073), new $Int64(0, 27076)), new Pair.ptr(new $Int64(0, 42083), new $Int64(0, 23043)), new Pair.ptr(new $Int64(0, 42089), new $Int64(0, 15358)), new Pair.ptr(new $Int64(0, 42101), new $Int64(0, 16662)), new Pair.ptr(new $Int64(0, 42131), new $Int64(0, 25965)), new Pair.ptr(new $Int64(0, 42139), new $Int64(0, 27651)), new Pair.ptr(new $Int64(0, 42157), new $Int64(0, 17431)), new Pair.ptr(new $Int64(0, 42169), new $Int64(0, 1710)), new Pair.ptr(new $Int64(0, 42179), new $Int64(0, 2971)), new Pair.ptr(new $Int64(0, 42181), new $Int64(0, 36218)), new Pair.ptr(new $Int64(0, 42187), new $Int64(0, 8161)), new Pair.ptr(new $Int64(0, 42193), new $Int64(0, 18428)), new Pair.ptr(new $Int64(0, 42197), new $Int64(0, 35813)), new Pair.ptr(new $Int64(0, 42209), new $Int64(0, 27082)), new Pair.ptr(new $Int64(0, 42221), new $Int64(0, 12112)), new Pair.ptr(new $Int64(0, 42223), new $Int64(0, 38129)), new Pair.ptr(new $Int64(0, 42227), new $Int64(0, 5033)), new Pair.ptr(new $Int64(0, 42239), new $Int64(0, 4642)), new Pair.ptr(new $Int64(0, 42257), new $Int64(0, 15242)), new Pair.ptr(new $Int64(0, 42281), new $Int64(0, 15276)), new Pair.ptr(new $Int64(0, 42283), new $Int64(0, 23589)), new Pair.ptr(new $Int64(0, 42293), new $Int64(0, 6226)), new Pair.ptr(new $Int64(0, 42299), new $Int64(0, 23643)), new Pair.ptr(new $Int64(0, 42307), new $Int64(0, 39122)), new Pair.ptr(new $Int64(0, 42323), new $Int64(0, 38776)), new Pair.ptr(new $Int64(0, 42331), new $Int64(0, 31177)), new Pair.ptr(new $Int64(0, 42337), new $Int64(0, 10125)), new Pair.ptr(new $Int64(0, 42349), new $Int64(0, 24161)), new Pair.ptr(new $Int64(0, 42359), new $Int64(0, 35631)), new Pair.ptr(new $Int64(0, 42373), new $Int64(0, 20348)), new Pair.ptr(new $Int64(0, 42379), new $Int64(0, 459)), new Pair.ptr(new $Int64(0, 42391), new $Int64(0, 34842)), new Pair.ptr(new $Int64(0, 42397), new $Int64(0, 33625)), new Pair.ptr(new $Int64(0, 42403), new $Int64(0, 11329)), new Pair.ptr(new $Int64(0, 42407), new $Int64(0, 12786)), new Pair.ptr(new $Int64(0, 42409), new $Int64(0, 364)), new Pair.ptr(new $Int64(0, 42433), new $Int64(0, 42102)), new Pair.ptr(new $Int64(0, 42437), new $Int64(0, 21009)), new Pair.ptr(new $Int64(0, 42443), new $Int64(0, 471)), new Pair.ptr(new $Int64(0, 42451), new $Int64(0, 5693)), new Pair.ptr(new $Int64(0, 42457), new $Int64(0, 2307)), new Pair.ptr(new $Int64(0, 42461), new $Int64(0, 33984)), new Pair.ptr(new $Int64(0, 42463), new $Int64(0, 37667)), new Pair.ptr(new $Int64(0, 42467), new $Int64(0, 20589)), new Pair.ptr(new $Int64(0, 42473), new $Int64(0, 33599)), new Pair.ptr(new $Int64(0, 42487), new $Int64(0, 37527)), new Pair.ptr(new $Int64(0, 42491), new $Int64(0, 31026)), new Pair.ptr(new $Int64(0, 42499), new $Int64(0, 9546)), new Pair.ptr(new $Int64(0, 42509), new $Int64(0, 22497)), new Pair.ptr(new $Int64(0, 42533), new $Int64(0, 27889)), new Pair.ptr(new $Int64(0, 42557), new $Int64(0, 31612)), new Pair.ptr(new $Int64(0, 42569), new $Int64(0, 32161)), new Pair.ptr(new $Int64(0, 42571), new $Int64(0, 39179)), new Pair.ptr(new $Int64(0, 42577), new $Int64(0, 10310)), new Pair.ptr(new $Int64(0, 42589), new $Int64(0, 12002)), new Pair.ptr(new $Int64(0, 42611), new $Int64(0, 29794)), new Pair.ptr(new $Int64(0, 42641), new $Int64(0, 22520)), new Pair.ptr(new $Int64(0, 42643), new $Int64(0, 41043)), new Pair.ptr(new $Int64(0, 42649), new $Int64(0, 15960)), new Pair.ptr(new $Int64(0, 42667), new $Int64(0, 41032)), new Pair.ptr(new $Int64(0, 42677), new $Int64(0, 19124)), new Pair.ptr(new $Int64(0, 42683), new $Int64(0, 16677)), new Pair.ptr(new $Int64(0, 42689), new $Int64(0, 25940)), new Pair.ptr(new $Int64(0, 42697), new $Int64(0, 38235)), new Pair.ptr(new $Int64(0, 42701), new $Int64(0, 20952)), new Pair.ptr(new $Int64(0, 42703), new $Int64(0, 23674)), new Pair.ptr(new $Int64(0, 42709), new $Int64(0, 31321)), new Pair.ptr(new $Int64(0, 42719), new $Int64(0, 26417)), new Pair.ptr(new $Int64(0, 42727), new $Int64(0, 2311)), new Pair.ptr(new $Int64(0, 42737), new $Int64(0, 14177)), new Pair.ptr(new $Int64(0, 42743), new $Int64(0, 3442)), new Pair.ptr(new $Int64(0, 42751), new $Int64(0, 8915)), new Pair.ptr(new $Int64(0, 42767), new $Int64(0, 5076)), new Pair.ptr(new $Int64(0, 42773), new $Int64(0, 26679)), new Pair.ptr(new $Int64(0, 42787), new $Int64(0, 8790)), new Pair.ptr(new $Int64(0, 42793), new $Int64(0, 9627)), new Pair.ptr(new $Int64(0, 42797), new $Int64(0, 8874)), new Pair.ptr(new $Int64(0, 42821), new $Int64(0, 32561)), new Pair.ptr(new $Int64(0, 42829), new $Int64(0, 12797)), new Pair.ptr(new $Int64(0, 42839), new $Int64(0, 10785)), new Pair.ptr(new $Int64(0, 42841), new $Int64(0, 20072)), new Pair.ptr(new $Int64(0, 42853), new $Int64(0, 6708)), new Pair.ptr(new $Int64(0, 42859), new $Int64(0, 41739)), new Pair.ptr(new $Int64(0, 42863), new $Int64(0, 35995)), new Pair.ptr(new $Int64(0, 42899), new $Int64(0, 9193)), new Pair.ptr(new $Int64(0, 42901), new $Int64(0, 3064)), new Pair.ptr(new $Int64(0, 42923), new $Int64(0, 12397)), new Pair.ptr(new $Int64(0, 42929), new $Int64(0, 25271)), new Pair.ptr(new $Int64(0, 42937), new $Int64(0, 746)), new Pair.ptr(new $Int64(0, 42943), new $Int64(0, 1070)), new Pair.ptr(new $Int64(0, 42953), new $Int64(0, 42432)), new Pair.ptr(new $Int64(0, 42961), new $Int64(0, 26008)), new Pair.ptr(new $Int64(0, 42967), new $Int64(0, 13055)), new Pair.ptr(new $Int64(0, 42979), new $Int64(0, 4158)), new Pair.ptr(new $Int64(0, 42989), new $Int64(0, 32328)), new Pair.ptr(new $Int64(0, 43003), new $Int64(0, 27943)), new Pair.ptr(new $Int64(0, 43013), new $Int64(0, 3453)), new Pair.ptr(new $Int64(0, 43019), new $Int64(0, 3331)), new Pair.ptr(new $Int64(0, 43037), new $Int64(0, 35924)), new Pair.ptr(new $Int64(0, 43049), new $Int64(0, 27922)), new Pair.ptr(new $Int64(0, 43051), new $Int64(0, 8655)), new Pair.ptr(new $Int64(0, 43063), new $Int64(0, 22626)), new Pair.ptr(new $Int64(0, 43067), new $Int64(0, 17481)), new Pair.ptr(new $Int64(0, 43093), new $Int64(0, 22631)), new Pair.ptr(new $Int64(0, 43103), new $Int64(0, 10662)), new Pair.ptr(new $Int64(0, 43117), new $Int64(0, 32430)), new Pair.ptr(new $Int64(0, 43133), new $Int64(0, 38624)), new Pair.ptr(new $Int64(0, 43151), new $Int64(0, 39332)), new Pair.ptr(new $Int64(0, 43159), new $Int64(0, 26531)), new Pair.ptr(new $Int64(0, 43177), new $Int64(0, 19384)), new Pair.ptr(new $Int64(0, 43189), new $Int64(0, 6821)), new Pair.ptr(new $Int64(0, 43201), new $Int64(0, 7207)), new Pair.ptr(new $Int64(0, 43207), new $Int64(0, 14466)), new Pair.ptr(new $Int64(0, 43223), new $Int64(0, 1883)), new Pair.ptr(new $Int64(0, 43237), new $Int64(0, 27337)), new Pair.ptr(new $Int64(0, 43261), new $Int64(0, 1361)), new Pair.ptr(new $Int64(0, 43271), new $Int64(0, 10522)), new Pair.ptr(new $Int64(0, 43283), new $Int64(0, 783)), new Pair.ptr(new $Int64(0, 43291), new $Int64(0, 32749)), new Pair.ptr(new $Int64(0, 43313), new $Int64(0, 11244)), new Pair.ptr(new $Int64(0, 43319), new $Int64(0, 15796)), new Pair.ptr(new $Int64(0, 43321), new $Int64(0, 22028)), new Pair.ptr(new $Int64(0, 43331), new $Int64(0, 24064)), new Pair.ptr(new $Int64(0, 43391), new $Int64(0, 12025)), new Pair.ptr(new $Int64(0, 43397), new $Int64(0, 38002)), new Pair.ptr(new $Int64(0, 43399), new $Int64(0, 15276)), new Pair.ptr(new $Int64(0, 43403), new $Int64(0, 21381)), new Pair.ptr(new $Int64(0, 43411), new $Int64(0, 29327)), new Pair.ptr(new $Int64(0, 43427), new $Int64(0, 16369)), new Pair.ptr(new $Int64(0, 43441), new $Int64(0, 694)), new Pair.ptr(new $Int64(0, 43451), new $Int64(0, 12454)), new Pair.ptr(new $Int64(0, 43457), new $Int64(0, 32172)), new Pair.ptr(new $Int64(0, 43481), new $Int64(0, 19923)), new Pair.ptr(new $Int64(0, 43487), new $Int64(0, 22061)), new Pair.ptr(new $Int64(0, 43499), new $Int64(0, 4020)), new Pair.ptr(new $Int64(0, 43517), new $Int64(0, 31673)), new Pair.ptr(new $Int64(0, 43541), new $Int64(0, 6749)), new Pair.ptr(new $Int64(0, 43543), new $Int64(0, 40278)), new Pair.ptr(new $Int64(0, 43573), new $Int64(0, 7256)), new Pair.ptr(new $Int64(0, 43577), new $Int64(0, 41577)), new Pair.ptr(new $Int64(0, 43579), new $Int64(0, 37303)), new Pair.ptr(new $Int64(0, 43591), new $Int64(0, 9395)), new Pair.ptr(new $Int64(0, 43597), new $Int64(0, 17286)), new Pair.ptr(new $Int64(0, 43607), new $Int64(0, 30791)), new Pair.ptr(new $Int64(0, 43609), new $Int64(0, 27472)), new Pair.ptr(new $Int64(0, 43613), new $Int64(0, 4024)), new Pair.ptr(new $Int64(0, 43627), new $Int64(0, 17810)), new Pair.ptr(new $Int64(0, 43633), new $Int64(0, 19580)), new Pair.ptr(new $Int64(0, 43649), new $Int64(0, 43137)), new Pair.ptr(new $Int64(0, 43651), new $Int64(0, 36946)), new Pair.ptr(new $Int64(0, 43661), new $Int64(0, 8774)), new Pair.ptr(new $Int64(0, 43669), new $Int64(0, 29233)), new Pair.ptr(new $Int64(0, 43691), new $Int64(0, 26359)), new Pair.ptr(new $Int64(0, 43711), new $Int64(0, 40250)), new Pair.ptr(new $Int64(0, 43717), new $Int64(0, 13534)), new Pair.ptr(new $Int64(0, 43721), new $Int64(0, 20164)), new Pair.ptr(new $Int64(0, 43753), new $Int64(0, 20814)), new Pair.ptr(new $Int64(0, 43759), new $Int64(0, 9064)), new Pair.ptr(new $Int64(0, 43777), new $Int64(0, 40864)), new Pair.ptr(new $Int64(0, 43781), new $Int64(0, 2325)), new Pair.ptr(new $Int64(0, 43783), new $Int64(0, 9970)), new Pair.ptr(new $Int64(0, 43787), new $Int64(0, 40476)), new Pair.ptr(new $Int64(0, 43789), new $Int64(0, 30057)), new Pair.ptr(new $Int64(0, 43793), new $Int64(0, 32237)), new Pair.ptr(new $Int64(0, 43801), new $Int64(0, 15796)), new Pair.ptr(new $Int64(0, 43853), new $Int64(0, 16707)), new Pair.ptr(new $Int64(0, 43867), new $Int64(0, 14928)), new Pair.ptr(new $Int64(0, 43889), new $Int64(0, 27853)), new Pair.ptr(new $Int64(0, 43891), new $Int64(0, 34606)), new Pair.ptr(new $Int64(0, 43913), new $Int64(0, 257)), new Pair.ptr(new $Int64(0, 43933), new $Int64(0, 39355)), new Pair.ptr(new $Int64(0, 43943), new $Int64(0, 24698)), new Pair.ptr(new $Int64(0, 43951), new $Int64(0, 6443)), new Pair.ptr(new $Int64(0, 43961), new $Int64(0, 512)), new Pair.ptr(new $Int64(0, 43963), new $Int64(0, 9462)), new Pair.ptr(new $Int64(0, 43969), new $Int64(0, 35781)), new Pair.ptr(new $Int64(0, 43973), new $Int64(0, 22771)), new Pair.ptr(new $Int64(0, 43987), new $Int64(0, 13299)), new Pair.ptr(new $Int64(0, 43991), new $Int64(0, 29023)), new Pair.ptr(new $Int64(0, 43997), new $Int64(0, 5211)), new Pair.ptr(new $Int64(0, 44017), new $Int64(0, 16683)), new Pair.ptr(new $Int64(0, 44021), new $Int64(0, 9506)), new Pair.ptr(new $Int64(0, 44027), new $Int64(0, 24776)), new Pair.ptr(new $Int64(0, 44029), new $Int64(0, 23580)), new Pair.ptr(new $Int64(0, 44041), new $Int64(0, 23978)), new Pair.ptr(new $Int64(0, 44053), new $Int64(0, 17458)), new Pair.ptr(new $Int64(0, 44059), new $Int64(0, 32212)), new Pair.ptr(new $Int64(0, 44071), new $Int64(0, 3863)), new Pair.ptr(new $Int64(0, 44087), new $Int64(0, 43506)), new Pair.ptr(new $Int64(0, 44089), new $Int64(0, 29360)), new Pair.ptr(new $Int64(0, 44101), new $Int64(0, 7247)), new Pair.ptr(new $Int64(0, 44111), new $Int64(0, 23065)), new Pair.ptr(new $Int64(0, 44119), new $Int64(0, 19981)), new Pair.ptr(new $Int64(0, 44123), new $Int64(0, 20237)), new Pair.ptr(new $Int64(0, 44129), new $Int64(0, 35632)), new Pair.ptr(new $Int64(0, 44131), new $Int64(0, 2215)), new Pair.ptr(new $Int64(0, 44159), new $Int64(0, 8691)), new Pair.ptr(new $Int64(0, 44171), new $Int64(0, 1055)), new Pair.ptr(new $Int64(0, 44179), new $Int64(0, 28460)), new Pair.ptr(new $Int64(0, 44189), new $Int64(0, 43163)), new Pair.ptr(new $Int64(0, 44201), new $Int64(0, 25066)), new Pair.ptr(new $Int64(0, 44203), new $Int64(0, 20730)), new Pair.ptr(new $Int64(0, 44207), new $Int64(0, 21543)), new Pair.ptr(new $Int64(0, 44221), new $Int64(0, 5588)), new Pair.ptr(new $Int64(0, 44249), new $Int64(0, 18268)), new Pair.ptr(new $Int64(0, 44257), new $Int64(0, 5146)), new Pair.ptr(new $Int64(0, 44263), new $Int64(0, 23964)), new Pair.ptr(new $Int64(0, 44267), new $Int64(0, 29068)), new Pair.ptr(new $Int64(0, 44269), new $Int64(0, 10618)), new Pair.ptr(new $Int64(0, 44273), new $Int64(0, 14545)), new Pair.ptr(new $Int64(0, 44279), new $Int64(0, 30832)), new Pair.ptr(new $Int64(0, 44281), new $Int64(0, 14642)), new Pair.ptr(new $Int64(0, 44293), new $Int64(0, 30341)), new Pair.ptr(new $Int64(0, 44351), new $Int64(0, 24564)), new Pair.ptr(new $Int64(0, 44357), new $Int64(0, 31664)), new Pair.ptr(new $Int64(0, 44371), new $Int64(0, 6970)), new Pair.ptr(new $Int64(0, 44381), new $Int64(0, 44122)), new Pair.ptr(new $Int64(0, 44383), new $Int64(0, 24295)), new Pair.ptr(new $Int64(0, 44389), new $Int64(0, 16722)), new Pair.ptr(new $Int64(0, 44417), new $Int64(0, 11007)), new Pair.ptr(new $Int64(0, 44449), new $Int64(0, 28312)), new Pair.ptr(new $Int64(0, 44453), new $Int64(0, 40783)), new Pair.ptr(new $Int64(0, 44483), new $Int64(0, 31334)), new Pair.ptr(new $Int64(0, 44491), new $Int64(0, 3122)), new Pair.ptr(new $Int64(0, 44497), new $Int64(0, 11175)), new Pair.ptr(new $Int64(0, 44501), new $Int64(0, 9254)), new Pair.ptr(new $Int64(0, 44507), new $Int64(0, 33494)), new Pair.ptr(new $Int64(0, 44519), new $Int64(0, 27708)), new Pair.ptr(new $Int64(0, 44531), new $Int64(0, 39322)), new Pair.ptr(new $Int64(0, 44533), new $Int64(0, 35933)), new Pair.ptr(new $Int64(0, 44537), new $Int64(0, 42137)), new Pair.ptr(new $Int64(0, 44543), new $Int64(0, 31799)), new Pair.ptr(new $Int64(0, 44549), new $Int64(0, 7466)), new Pair.ptr(new $Int64(0, 44563), new $Int64(0, 39374)), new Pair.ptr(new $Int64(0, 44579), new $Int64(0, 1136)), new Pair.ptr(new $Int64(0, 44587), new $Int64(0, 32990)), new Pair.ptr(new $Int64(0, 44617), new $Int64(0, 36968)), new Pair.ptr(new $Int64(0, 44621), new $Int64(0, 32637)), new Pair.ptr(new $Int64(0, 44623), new $Int64(0, 33877)), new Pair.ptr(new $Int64(0, 44633), new $Int64(0, 5701)), new Pair.ptr(new $Int64(0, 44641), new $Int64(0, 25152)), new Pair.ptr(new $Int64(0, 44647), new $Int64(0, 20122)), new Pair.ptr(new $Int64(0, 44651), new $Int64(0, 15965)), new Pair.ptr(new $Int64(0, 44657), new $Int64(0, 15840)), new Pair.ptr(new $Int64(0, 44683), new $Int64(0, 20598)), new Pair.ptr(new $Int64(0, 44687), new $Int64(0, 33250)), new Pair.ptr(new $Int64(0, 44699), new $Int64(0, 30343)), new Pair.ptr(new $Int64(0, 44701), new $Int64(0, 35881)), new Pair.ptr(new $Int64(0, 44711), new $Int64(0, 32044)), new Pair.ptr(new $Int64(0, 44729), new $Int64(0, 37457)), new Pair.ptr(new $Int64(0, 44741), new $Int64(0, 27540)), new Pair.ptr(new $Int64(0, 44753), new $Int64(0, 44389)), new Pair.ptr(new $Int64(0, 44771), new $Int64(0, 28084)), new Pair.ptr(new $Int64(0, 44773), new $Int64(0, 35411)), new Pair.ptr(new $Int64(0, 44777), new $Int64(0, 31181)), new Pair.ptr(new $Int64(0, 44789), new $Int64(0, 44286)), new Pair.ptr(new $Int64(0, 44797), new $Int64(0, 31814)), new Pair.ptr(new $Int64(0, 44809), new $Int64(0, 12650)), new Pair.ptr(new $Int64(0, 44819), new $Int64(0, 19410)), new Pair.ptr(new $Int64(0, 44839), new $Int64(0, 39479)), new Pair.ptr(new $Int64(0, 44843), new $Int64(0, 11294)), new Pair.ptr(new $Int64(0, 44851), new $Int64(0, 37424)), new Pair.ptr(new $Int64(0, 44867), new $Int64(0, 42819)), new Pair.ptr(new $Int64(0, 44879), new $Int64(0, 15782)), new Pair.ptr(new $Int64(0, 44887), new $Int64(0, 13459)), new Pair.ptr(new $Int64(0, 44893), new $Int64(0, 27209)), new Pair.ptr(new $Int64(0, 44909), new $Int64(0, 42969)), new Pair.ptr(new $Int64(0, 44917), new $Int64(0, 15835)), new Pair.ptr(new $Int64(0, 44927), new $Int64(0, 8519)), new Pair.ptr(new $Int64(0, 44939), new $Int64(0, 35983)), new Pair.ptr(new $Int64(0, 44953), new $Int64(0, 35486)), new Pair.ptr(new $Int64(0, 44959), new $Int64(0, 26335)), new Pair.ptr(new $Int64(0, 44963), new $Int64(0, 17478)), new Pair.ptr(new $Int64(0, 44971), new $Int64(0, 32133)), new Pair.ptr(new $Int64(0, 44983), new $Int64(0, 9704)), new Pair.ptr(new $Int64(0, 44987), new $Int64(0, 19294)), new Pair.ptr(new $Int64(0, 45007), new $Int64(0, 35976)), new Pair.ptr(new $Int64(0, 45013), new $Int64(0, 24089)), new Pair.ptr(new $Int64(0, 45053), new $Int64(0, 44349)), new Pair.ptr(new $Int64(0, 45061), new $Int64(0, 36260)), new Pair.ptr(new $Int64(0, 45077), new $Int64(0, 32223)), new Pair.ptr(new $Int64(0, 45083), new $Int64(0, 20317)), new Pair.ptr(new $Int64(0, 45119), new $Int64(0, 24160)), new Pair.ptr(new $Int64(0, 45121), new $Int64(0, 7347)), new Pair.ptr(new $Int64(0, 45127), new $Int64(0, 38867)), new Pair.ptr(new $Int64(0, 45131), new $Int64(0, 29978)), new Pair.ptr(new $Int64(0, 45137), new $Int64(0, 20790)), new Pair.ptr(new $Int64(0, 45139), new $Int64(0, 40397)), new Pair.ptr(new $Int64(0, 45161), new $Int64(0, 27009)), new Pair.ptr(new $Int64(0, 45179), new $Int64(0, 10494)), new Pair.ptr(new $Int64(0, 45181), new $Int64(0, 13247)), new Pair.ptr(new $Int64(0, 45191), new $Int64(0, 6384)), new Pair.ptr(new $Int64(0, 45197), new $Int64(0, 29103)), new Pair.ptr(new $Int64(0, 45233), new $Int64(0, 40030)), new Pair.ptr(new $Int64(0, 45247), new $Int64(0, 45163)), new Pair.ptr(new $Int64(0, 45259), new $Int64(0, 43805)), new Pair.ptr(new $Int64(0, 45263), new $Int64(0, 36880)), new Pair.ptr(new $Int64(0, 45281), new $Int64(0, 43818)), new Pair.ptr(new $Int64(0, 45289), new $Int64(0, 41832)), new Pair.ptr(new $Int64(0, 45293), new $Int64(0, 24450)), new Pair.ptr(new $Int64(0, 45307), new $Int64(0, 18179)), new Pair.ptr(new $Int64(0, 45317), new $Int64(0, 20805)), new Pair.ptr(new $Int64(0, 45319), new $Int64(0, 28221)), new Pair.ptr(new $Int64(0, 45329), new $Int64(0, 6125)), new Pair.ptr(new $Int64(0, 45337), new $Int64(0, 11703)), new Pair.ptr(new $Int64(0, 45341), new $Int64(0, 1819)), new Pair.ptr(new $Int64(0, 45343), new $Int64(0, 38591)), new Pair.ptr(new $Int64(0, 45361), new $Int64(0, 18715)), new Pair.ptr(new $Int64(0, 45377), new $Int64(0, 17546)), new Pair.ptr(new $Int64(0, 45389), new $Int64(0, 20303)), new Pair.ptr(new $Int64(0, 45403), new $Int64(0, 22971)), new Pair.ptr(new $Int64(0, 45413), new $Int64(0, 20840)), new Pair.ptr(new $Int64(0, 45427), new $Int64(0, 43777)), new Pair.ptr(new $Int64(0, 45433), new $Int64(0, 40676)), new Pair.ptr(new $Int64(0, 45439), new $Int64(0, 40552)), new Pair.ptr(new $Int64(0, 45481), new $Int64(0, 4316)), new Pair.ptr(new $Int64(0, 45491), new $Int64(0, 34080)), new Pair.ptr(new $Int64(0, 45497), new $Int64(0, 4366)), new Pair.ptr(new $Int64(0, 45503), new $Int64(0, 23211)), new Pair.ptr(new $Int64(0, 45523), new $Int64(0, 13345)), new Pair.ptr(new $Int64(0, 45533), new $Int64(0, 1108)), new Pair.ptr(new $Int64(0, 45541), new $Int64(0, 3753)), new Pair.ptr(new $Int64(0, 45553), new $Int64(0, 13843)), new Pair.ptr(new $Int64(0, 45557), new $Int64(0, 20187)), new Pair.ptr(new $Int64(0, 45569), new $Int64(0, 6294)), new Pair.ptr(new $Int64(0, 45587), new $Int64(0, 27430)), new Pair.ptr(new $Int64(0, 45589), new $Int64(0, 1917)), new Pair.ptr(new $Int64(0, 45599), new $Int64(0, 8200)), new Pair.ptr(new $Int64(0, 45613), new $Int64(0, 28739)), new Pair.ptr(new $Int64(0, 45631), new $Int64(0, 18815)), new Pair.ptr(new $Int64(0, 45641), new $Int64(0, 27980)), new Pair.ptr(new $Int64(0, 45659), new $Int64(0, 34142)), new Pair.ptr(new $Int64(0, 45667), new $Int64(0, 41271)), new Pair.ptr(new $Int64(0, 45673), new $Int64(0, 100)), new Pair.ptr(new $Int64(0, 45677), new $Int64(0, 35116)), new Pair.ptr(new $Int64(0, 45691), new $Int64(0, 30776)), new Pair.ptr(new $Int64(0, 45697), new $Int64(0, 29463)), new Pair.ptr(new $Int64(0, 45707), new $Int64(0, 32114)), new Pair.ptr(new $Int64(0, 45737), new $Int64(0, 44506)), new Pair.ptr(new $Int64(0, 45751), new $Int64(0, 10409)), new Pair.ptr(new $Int64(0, 45757), new $Int64(0, 33410)), new Pair.ptr(new $Int64(0, 45763), new $Int64(0, 16707)), new Pair.ptr(new $Int64(0, 45767), new $Int64(0, 33002)), new Pair.ptr(new $Int64(0, 45779), new $Int64(0, 32814)), new Pair.ptr(new $Int64(0, 45817), new $Int64(0, 42219)), new Pair.ptr(new $Int64(0, 45821), new $Int64(0, 465)), new Pair.ptr(new $Int64(0, 45823), new $Int64(0, 27189)), new Pair.ptr(new $Int64(0, 45827), new $Int64(0, 32473)), new Pair.ptr(new $Int64(0, 45833), new $Int64(0, 6129)), new Pair.ptr(new $Int64(0, 45841), new $Int64(0, 38376)), new Pair.ptr(new $Int64(0, 45853), new $Int64(0, 41533)), new Pair.ptr(new $Int64(0, 45863), new $Int64(0, 2502)), new Pair.ptr(new $Int64(0, 45869), new $Int64(0, 5671)), new Pair.ptr(new $Int64(0, 45887), new $Int64(0, 35839)), new Pair.ptr(new $Int64(0, 45893), new $Int64(0, 26241)), new Pair.ptr(new $Int64(0, 45943), new $Int64(0, 16199)), new Pair.ptr(new $Int64(0, 45949), new $Int64(0, 28051)), new Pair.ptr(new $Int64(0, 45953), new $Int64(0, 42733)), new Pair.ptr(new $Int64(0, 45959), new $Int64(0, 9183)), new Pair.ptr(new $Int64(0, 45971), new $Int64(0, 36644)), new Pair.ptr(new $Int64(0, 45979), new $Int64(0, 33432)), new Pair.ptr(new $Int64(0, 45989), new $Int64(0, 3940)), new Pair.ptr(new $Int64(0, 46021), new $Int64(0, 37952)), new Pair.ptr(new $Int64(0, 46027), new $Int64(0, 13364)), new Pair.ptr(new $Int64(0, 46049), new $Int64(0, 32490)), new Pair.ptr(new $Int64(0, 46051), new $Int64(0, 26556)), new Pair.ptr(new $Int64(0, 46061), new $Int64(0, 32908)), new Pair.ptr(new $Int64(0, 46073), new $Int64(0, 40129)), new Pair.ptr(new $Int64(0, 46091), new $Int64(0, 29925)), new Pair.ptr(new $Int64(0, 46093), new $Int64(0, 6064)), new Pair.ptr(new $Int64(0, 46099), new $Int64(0, 27210)), new Pair.ptr(new $Int64(0, 46103), new $Int64(0, 43690)), new Pair.ptr(new $Int64(0, 46133), new $Int64(0, 38453)), new Pair.ptr(new $Int64(0, 46141), new $Int64(0, 25928)), new Pair.ptr(new $Int64(0, 46147), new $Int64(0, 31747)), new Pair.ptr(new $Int64(0, 46153), new $Int64(0, 35880)), new Pair.ptr(new $Int64(0, 46171), new $Int64(0, 8083)), new Pair.ptr(new $Int64(0, 46181), new $Int64(0, 28980)), new Pair.ptr(new $Int64(0, 46183), new $Int64(0, 38660)), new Pair.ptr(new $Int64(0, 46187), new $Int64(0, 41541)), new Pair.ptr(new $Int64(0, 46199), new $Int64(0, 21323)), new Pair.ptr(new $Int64(0, 46219), new $Int64(0, 38547)), new Pair.ptr(new $Int64(0, 46229), new $Int64(0, 45248)), new Pair.ptr(new $Int64(0, 46237), new $Int64(0, 40181)), new Pair.ptr(new $Int64(0, 46261), new $Int64(0, 5892)), new Pair.ptr(new $Int64(0, 46271), new $Int64(0, 10327)), new Pair.ptr(new $Int64(0, 46273), new $Int64(0, 37545)), new Pair.ptr(new $Int64(0, 46279), new $Int64(0, 29651)), new Pair.ptr(new $Int64(0, 46301), new $Int64(0, 26095)), new Pair.ptr(new $Int64(0, 46307), new $Int64(0, 1032)), new Pair.ptr(new $Int64(0, 46309), new $Int64(0, 9118)), new Pair.ptr(new $Int64(0, 46327), new $Int64(0, 13104)), new Pair.ptr(new $Int64(0, 46337), new $Int64(0, 35878)), new Pair.ptr(new $Int64(0, 46349), new $Int64(0, 41013)), new Pair.ptr(new $Int64(0, 46351), new $Int64(0, 6517)), new Pair.ptr(new $Int64(0, 46381), new $Int64(0, 42419)), new Pair.ptr(new $Int64(0, 46399), new $Int64(0, 30006)), new Pair.ptr(new $Int64(0, 46411), new $Int64(0, 3164)), new Pair.ptr(new $Int64(0, 46439), new $Int64(0, 18743)), new Pair.ptr(new $Int64(0, 46441), new $Int64(0, 12155)), new Pair.ptr(new $Int64(0, 46447), new $Int64(0, 17546)), new Pair.ptr(new $Int64(0, 46451), new $Int64(0, 28813)), new Pair.ptr(new $Int64(0, 46457), new $Int64(0, 37224)), new Pair.ptr(new $Int64(0, 46471), new $Int64(0, 11687)), new Pair.ptr(new $Int64(0, 46477), new $Int64(0, 7331)), new Pair.ptr(new $Int64(0, 46489), new $Int64(0, 25478)), new Pair.ptr(new $Int64(0, 46499), new $Int64(0, 1603)), new Pair.ptr(new $Int64(0, 46507), new $Int64(0, 12760)), new Pair.ptr(new $Int64(0, 46511), new $Int64(0, 18326)), new Pair.ptr(new $Int64(0, 46523), new $Int64(0, 41648)), new Pair.ptr(new $Int64(0, 46549), new $Int64(0, 4422)), new Pair.ptr(new $Int64(0, 46559), new $Int64(0, 419)), new Pair.ptr(new $Int64(0, 46567), new $Int64(0, 937)), new Pair.ptr(new $Int64(0, 46573), new $Int64(0, 24319)), new Pair.ptr(new $Int64(0, 46589), new $Int64(0, 24377)), new Pair.ptr(new $Int64(0, 46591), new $Int64(0, 7342)), new Pair.ptr(new $Int64(0, 46601), new $Int64(0, 22563)), new Pair.ptr(new $Int64(0, 46619), new $Int64(0, 28526)), new Pair.ptr(new $Int64(0, 46633), new $Int64(0, 23768)), new Pair.ptr(new $Int64(0, 46639), new $Int64(0, 44931)), new Pair.ptr(new $Int64(0, 46643), new $Int64(0, 16174)), new Pair.ptr(new $Int64(0, 46649), new $Int64(0, 10917)), new Pair.ptr(new $Int64(0, 46663), new $Int64(0, 40740)), new Pair.ptr(new $Int64(0, 46679), new $Int64(0, 26814)), new Pair.ptr(new $Int64(0, 46681), new $Int64(0, 10026)), new Pair.ptr(new $Int64(0, 46687), new $Int64(0, 35360)), new Pair.ptr(new $Int64(0, 46691), new $Int64(0, 41929)), new Pair.ptr(new $Int64(0, 46703), new $Int64(0, 27369)), new Pair.ptr(new $Int64(0, 46723), new $Int64(0, 17991)), new Pair.ptr(new $Int64(0, 46727), new $Int64(0, 21464)), new Pair.ptr(new $Int64(0, 46747), new $Int64(0, 20905)), new Pair.ptr(new $Int64(0, 46751), new $Int64(0, 9033)), new Pair.ptr(new $Int64(0, 46757), new $Int64(0, 20999)), new Pair.ptr(new $Int64(0, 46769), new $Int64(0, 34680)), new Pair.ptr(new $Int64(0, 46771), new $Int64(0, 41409)), new Pair.ptr(new $Int64(0, 46807), new $Int64(0, 10855)), new Pair.ptr(new $Int64(0, 46811), new $Int64(0, 12435)), new Pair.ptr(new $Int64(0, 46817), new $Int64(0, 45136)), new Pair.ptr(new $Int64(0, 46819), new $Int64(0, 320)), new Pair.ptr(new $Int64(0, 46829), new $Int64(0, 10234)), new Pair.ptr(new $Int64(0, 46831), new $Int64(0, 15146)), new Pair.ptr(new $Int64(0, 46853), new $Int64(0, 28943)), new Pair.ptr(new $Int64(0, 46861), new $Int64(0, 1287)), new Pair.ptr(new $Int64(0, 46867), new $Int64(0, 9675)), new Pair.ptr(new $Int64(0, 46877), new $Int64(0, 36741)), new Pair.ptr(new $Int64(0, 46889), new $Int64(0, 3900)), new Pair.ptr(new $Int64(0, 46901), new $Int64(0, 4318)), new Pair.ptr(new $Int64(0, 46919), new $Int64(0, 6375)), new Pair.ptr(new $Int64(0, 46933), new $Int64(0, 16677)), new Pair.ptr(new $Int64(0, 46957), new $Int64(0, 16648)), new Pair.ptr(new $Int64(0, 46993), new $Int64(0, 24374)), new Pair.ptr(new $Int64(0, 46997), new $Int64(0, 34065)), new Pair.ptr(new $Int64(0, 47017), new $Int64(0, 21014)), new Pair.ptr(new $Int64(0, 47041), new $Int64(0, 28290)), new Pair.ptr(new $Int64(0, 47051), new $Int64(0, 38915)), new Pair.ptr(new $Int64(0, 47057), new $Int64(0, 10627)), new Pair.ptr(new $Int64(0, 47059), new $Int64(0, 1732)), new Pair.ptr(new $Int64(0, 47087), new $Int64(0, 28262)), new Pair.ptr(new $Int64(0, 47093), new $Int64(0, 39065)), new Pair.ptr(new $Int64(0, 47111), new $Int64(0, 7220)), new Pair.ptr(new $Int64(0, 47119), new $Int64(0, 12396)), new Pair.ptr(new $Int64(0, 47123), new $Int64(0, 44586)), new Pair.ptr(new $Int64(0, 47129), new $Int64(0, 30380)), new Pair.ptr(new $Int64(0, 47137), new $Int64(0, 12356)), new Pair.ptr(new $Int64(0, 47143), new $Int64(0, 25900)), new Pair.ptr(new $Int64(0, 47147), new $Int64(0, 10612)), new Pair.ptr(new $Int64(0, 47149), new $Int64(0, 44233)), new Pair.ptr(new $Int64(0, 47161), new $Int64(0, 31189)), new Pair.ptr(new $Int64(0, 47189), new $Int64(0, 8427)), new Pair.ptr(new $Int64(0, 47207), new $Int64(0, 23901)), new Pair.ptr(new $Int64(0, 47221), new $Int64(0, 10826)), new Pair.ptr(new $Int64(0, 47237), new $Int64(0, 4415)), new Pair.ptr(new $Int64(0, 47251), new $Int64(0, 47168)), new Pair.ptr(new $Int64(0, 47269), new $Int64(0, 23143)), new Pair.ptr(new $Int64(0, 47279), new $Int64(0, 6849)), new Pair.ptr(new $Int64(0, 47287), new $Int64(0, 18194)), new Pair.ptr(new $Int64(0, 47293), new $Int64(0, 2017)), new Pair.ptr(new $Int64(0, 47297), new $Int64(0, 1184)), new Pair.ptr(new $Int64(0, 47303), new $Int64(0, 2108)), new Pair.ptr(new $Int64(0, 47309), new $Int64(0, 8732)), new Pair.ptr(new $Int64(0, 47317), new $Int64(0, 29633)), new Pair.ptr(new $Int64(0, 47339), new $Int64(0, 1963)), new Pair.ptr(new $Int64(0, 47351), new $Int64(0, 29253)), new Pair.ptr(new $Int64(0, 47353), new $Int64(0, 43483)), new Pair.ptr(new $Int64(0, 47363), new $Int64(0, 9279)), new Pair.ptr(new $Int64(0, 47381), new $Int64(0, 24479)), new Pair.ptr(new $Int64(0, 47387), new $Int64(0, 32963)), new Pair.ptr(new $Int64(0, 47389), new $Int64(0, 35984)), new Pair.ptr(new $Int64(0, 47407), new $Int64(0, 40736)), new Pair.ptr(new $Int64(0, 47417), new $Int64(0, 29893)), new Pair.ptr(new $Int64(0, 47419), new $Int64(0, 3498)), new Pair.ptr(new $Int64(0, 47431), new $Int64(0, 6811)), new Pair.ptr(new $Int64(0, 47441), new $Int64(0, 41548)), new Pair.ptr(new $Int64(0, 47459), new $Int64(0, 42979)), new Pair.ptr(new $Int64(0, 47491), new $Int64(0, 13011)), new Pair.ptr(new $Int64(0, 47497), new $Int64(0, 14206)), new Pair.ptr(new $Int64(0, 47501), new $Int64(0, 45990)), new Pair.ptr(new $Int64(0, 47507), new $Int64(0, 40640)), new Pair.ptr(new $Int64(0, 47513), new $Int64(0, 373)), new Pair.ptr(new $Int64(0, 47521), new $Int64(0, 23499)), new Pair.ptr(new $Int64(0, 47527), new $Int64(0, 28352)), new Pair.ptr(new $Int64(0, 47533), new $Int64(0, 24108)), new Pair.ptr(new $Int64(0, 47543), new $Int64(0, 41160)), new Pair.ptr(new $Int64(0, 47563), new $Int64(0, 32284)), new Pair.ptr(new $Int64(0, 47569), new $Int64(0, 45126)), new Pair.ptr(new $Int64(0, 47581), new $Int64(0, 34295)), new Pair.ptr(new $Int64(0, 47591), new $Int64(0, 1208)), new Pair.ptr(new $Int64(0, 47599), new $Int64(0, 24743)), new Pair.ptr(new $Int64(0, 47609), new $Int64(0, 15660)), new Pair.ptr(new $Int64(0, 47623), new $Int64(0, 36440)), new Pair.ptr(new $Int64(0, 47629), new $Int64(0, 21416)), new Pair.ptr(new $Int64(0, 47639), new $Int64(0, 5521)), new Pair.ptr(new $Int64(0, 47653), new $Int64(0, 35975)), new Pair.ptr(new $Int64(0, 47657), new $Int64(0, 12286)), new Pair.ptr(new $Int64(0, 47659), new $Int64(0, 25655)), new Pair.ptr(new $Int64(0, 47681), new $Int64(0, 11511)), new Pair.ptr(new $Int64(0, 47699), new $Int64(0, 20419)), new Pair.ptr(new $Int64(0, 47701), new $Int64(0, 37336)), new Pair.ptr(new $Int64(0, 47711), new $Int64(0, 11411)), new Pair.ptr(new $Int64(0, 47713), new $Int64(0, 4871)), new Pair.ptr(new $Int64(0, 47717), new $Int64(0, 36732)), new Pair.ptr(new $Int64(0, 47737), new $Int64(0, 41413)), new Pair.ptr(new $Int64(0, 47741), new $Int64(0, 32439)), new Pair.ptr(new $Int64(0, 47743), new $Int64(0, 41826)), new Pair.ptr(new $Int64(0, 47777), new $Int64(0, 22531)), new Pair.ptr(new $Int64(0, 47779), new $Int64(0, 34884)), new Pair.ptr(new $Int64(0, 47791), new $Int64(0, 33026)), new Pair.ptr(new $Int64(0, 47797), new $Int64(0, 4913)), new Pair.ptr(new $Int64(0, 47807), new $Int64(0, 33088)), new Pair.ptr(new $Int64(0, 47809), new $Int64(0, 42488)), new Pair.ptr(new $Int64(0, 47819), new $Int64(0, 33703)), new Pair.ptr(new $Int64(0, 47837), new $Int64(0, 9250)), new Pair.ptr(new $Int64(0, 47843), new $Int64(0, 29686)), new Pair.ptr(new $Int64(0, 47857), new $Int64(0, 35780)), new Pair.ptr(new $Int64(0, 47869), new $Int64(0, 46104)), new Pair.ptr(new $Int64(0, 47881), new $Int64(0, 29130)), new Pair.ptr(new $Int64(0, 47903), new $Int64(0, 2709)), new Pair.ptr(new $Int64(0, 47911), new $Int64(0, 8603)), new Pair.ptr(new $Int64(0, 47917), new $Int64(0, 17850)), new Pair.ptr(new $Int64(0, 47933), new $Int64(0, 40097)), new Pair.ptr(new $Int64(0, 47939), new $Int64(0, 4574)), new Pair.ptr(new $Int64(0, 47947), new $Int64(0, 44529)), new Pair.ptr(new $Int64(0, 47951), new $Int64(0, 28474)), new Pair.ptr(new $Int64(0, 47963), new $Int64(0, 10834)), new Pair.ptr(new $Int64(0, 47969), new $Int64(0, 27567)), new Pair.ptr(new $Int64(0, 47977), new $Int64(0, 42436)), new Pair.ptr(new $Int64(0, 47981), new $Int64(0, 34088)), new Pair.ptr(new $Int64(0, 48017), new $Int64(0, 29120)), new Pair.ptr(new $Int64(0, 48023), new $Int64(0, 29198)), new Pair.ptr(new $Int64(0, 48029), new $Int64(0, 3539)), new Pair.ptr(new $Int64(0, 48049), new $Int64(0, 28829)), new Pair.ptr(new $Int64(0, 48073), new $Int64(0, 9230)), new Pair.ptr(new $Int64(0, 48079), new $Int64(0, 38153)), new Pair.ptr(new $Int64(0, 48091), new $Int64(0, 36236)), new Pair.ptr(new $Int64(0, 48109), new $Int64(0, 20190)), new Pair.ptr(new $Int64(0, 48119), new $Int64(0, 24805)), new Pair.ptr(new $Int64(0, 48121), new $Int64(0, 22017)), new Pair.ptr(new $Int64(0, 48131), new $Int64(0, 10670)), new Pair.ptr(new $Int64(0, 48157), new $Int64(0, 14668)), new Pair.ptr(new $Int64(0, 48163), new $Int64(0, 46404)), new Pair.ptr(new $Int64(0, 48179), new $Int64(0, 1324)), new Pair.ptr(new $Int64(0, 48187), new $Int64(0, 416)), new Pair.ptr(new $Int64(0, 48193), new $Int64(0, 35829)), new Pair.ptr(new $Int64(0, 48197), new $Int64(0, 18179)), new Pair.ptr(new $Int64(0, 48221), new $Int64(0, 39413)), new Pair.ptr(new $Int64(0, 48239), new $Int64(0, 31469)), new Pair.ptr(new $Int64(0, 48247), new $Int64(0, 25263)), new Pair.ptr(new $Int64(0, 48259), new $Int64(0, 9972)), new Pair.ptr(new $Int64(0, 48271), new $Int64(0, 20434)), new Pair.ptr(new $Int64(0, 48281), new $Int64(0, 30129)), new Pair.ptr(new $Int64(0, 48299), new $Int64(0, 14355)), new Pair.ptr(new $Int64(0, 48311), new $Int64(0, 8707)), new Pair.ptr(new $Int64(0, 48313), new $Int64(0, 22935)), new Pair.ptr(new $Int64(0, 48337), new $Int64(0, 42851)), new Pair.ptr(new $Int64(0, 48341), new $Int64(0, 24154)), new Pair.ptr(new $Int64(0, 48353), new $Int64(0, 44675)), new Pair.ptr(new $Int64(0, 48371), new $Int64(0, 37349)), new Pair.ptr(new $Int64(0, 48383), new $Int64(0, 33767)), new Pair.ptr(new $Int64(0, 48397), new $Int64(0, 47038)), new Pair.ptr(new $Int64(0, 48407), new $Int64(0, 31714)), new Pair.ptr(new $Int64(0, 48409), new $Int64(0, 20195)), new Pair.ptr(new $Int64(0, 48413), new $Int64(0, 41224)), new Pair.ptr(new $Int64(0, 48437), new $Int64(0, 41738)), new Pair.ptr(new $Int64(0, 48449), new $Int64(0, 7805)), new Pair.ptr(new $Int64(0, 48463), new $Int64(0, 29288)), new Pair.ptr(new $Int64(0, 48473), new $Int64(0, 1688)), new Pair.ptr(new $Int64(0, 48479), new $Int64(0, 45622)), new Pair.ptr(new $Int64(0, 48481), new $Int64(0, 18743)), new Pair.ptr(new $Int64(0, 48487), new $Int64(0, 3446)), new Pair.ptr(new $Int64(0, 48491), new $Int64(0, 25767)), new Pair.ptr(new $Int64(0, 48497), new $Int64(0, 42686)), new Pair.ptr(new $Int64(0, 48523), new $Int64(0, 18878)), new Pair.ptr(new $Int64(0, 48527), new $Int64(0, 21903)), new Pair.ptr(new $Int64(0, 48533), new $Int64(0, 5884)), new Pair.ptr(new $Int64(0, 48539), new $Int64(0, 39108)), new Pair.ptr(new $Int64(0, 48541), new $Int64(0, 34599)), new Pair.ptr(new $Int64(0, 48563), new $Int64(0, 14220)), new Pair.ptr(new $Int64(0, 48571), new $Int64(0, 35142)), new Pair.ptr(new $Int64(0, 48589), new $Int64(0, 26459)), new Pair.ptr(new $Int64(0, 48593), new $Int64(0, 45722)), new Pair.ptr(new $Int64(0, 48611), new $Int64(0, 37680)), new Pair.ptr(new $Int64(0, 48619), new $Int64(0, 1158)), new Pair.ptr(new $Int64(0, 48623), new $Int64(0, 44378)), new Pair.ptr(new $Int64(0, 48647), new $Int64(0, 32989)), new Pair.ptr(new $Int64(0, 48649), new $Int64(0, 5472)), new Pair.ptr(new $Int64(0, 48661), new $Int64(0, 5906)), new Pair.ptr(new $Int64(0, 48673), new $Int64(0, 24905)), new Pair.ptr(new $Int64(0, 48677), new $Int64(0, 15880)), new Pair.ptr(new $Int64(0, 48679), new $Int64(0, 37462)), new Pair.ptr(new $Int64(0, 48731), new $Int64(0, 27355)), new Pair.ptr(new $Int64(0, 48733), new $Int64(0, 29439)), new Pair.ptr(new $Int64(0, 48751), new $Int64(0, 8072)), new Pair.ptr(new $Int64(0, 48757), new $Int64(0, 17481)), new Pair.ptr(new $Int64(0, 48761), new $Int64(0, 33059)), new Pair.ptr(new $Int64(0, 48767), new $Int64(0, 624)), new Pair.ptr(new $Int64(0, 48779), new $Int64(0, 37742)), new Pair.ptr(new $Int64(0, 48781), new $Int64(0, 22587)), new Pair.ptr(new $Int64(0, 48787), new $Int64(0, 10510)), new Pair.ptr(new $Int64(0, 48799), new $Int64(0, 18298)), new Pair.ptr(new $Int64(0, 48809), new $Int64(0, 744)), new Pair.ptr(new $Int64(0, 48817), new $Int64(0, 12455)), new Pair.ptr(new $Int64(0, 48821), new $Int64(0, 48341)), new Pair.ptr(new $Int64(0, 48823), new $Int64(0, 9752)), new Pair.ptr(new $Int64(0, 48847), new $Int64(0, 30213)), new Pair.ptr(new $Int64(0, 48857), new $Int64(0, 45004)), new Pair.ptr(new $Int64(0, 48859), new $Int64(0, 14977)), new Pair.ptr(new $Int64(0, 48869), new $Int64(0, 48369)), new Pair.ptr(new $Int64(0, 48871), new $Int64(0, 35237)), new Pair.ptr(new $Int64(0, 48883), new $Int64(0, 5784)), new Pair.ptr(new $Int64(0, 48889), new $Int64(0, 43692)), new Pair.ptr(new $Int64(0, 48907), new $Int64(0, 10829)), new Pair.ptr(new $Int64(0, 48947), new $Int64(0, 22606)), new Pair.ptr(new $Int64(0, 48953), new $Int64(0, 12268)), new Pair.ptr(new $Int64(0, 48973), new $Int64(0, 41815)), new Pair.ptr(new $Int64(0, 48989), new $Int64(0, 38504)), new Pair.ptr(new $Int64(0, 48991), new $Int64(0, 9580)), new Pair.ptr(new $Int64(0, 49003), new $Int64(0, 47556)), new Pair.ptr(new $Int64(0, 49009), new $Int64(0, 39197)), new Pair.ptr(new $Int64(0, 49019), new $Int64(0, 11288)), new Pair.ptr(new $Int64(0, 49031), new $Int64(0, 35434)), new Pair.ptr(new $Int64(0, 49033), new $Int64(0, 10394)), new Pair.ptr(new $Int64(0, 49037), new $Int64(0, 17810)), new Pair.ptr(new $Int64(0, 49043), new $Int64(0, 18868)), new Pair.ptr(new $Int64(0, 49057), new $Int64(0, 17221)), new Pair.ptr(new $Int64(0, 49069), new $Int64(0, 33142)), new Pair.ptr(new $Int64(0, 49081), new $Int64(0, 23633)), new Pair.ptr(new $Int64(0, 49103), new $Int64(0, 13814)), new Pair.ptr(new $Int64(0, 49109), new $Int64(0, 19514)), new Pair.ptr(new $Int64(0, 49117), new $Int64(0, 40672)), new Pair.ptr(new $Int64(0, 49121), new $Int64(0, 12104)), new Pair.ptr(new $Int64(0, 49123), new $Int64(0, 14842)), new Pair.ptr(new $Int64(0, 49139), new $Int64(0, 2234)), new Pair.ptr(new $Int64(0, 49157), new $Int64(0, 3023)), new Pair.ptr(new $Int64(0, 49169), new $Int64(0, 36607)), new Pair.ptr(new $Int64(0, 49171), new $Int64(0, 11752)), new Pair.ptr(new $Int64(0, 49177), new $Int64(0, 12989)), new Pair.ptr(new $Int64(0, 49193), new $Int64(0, 40291)), new Pair.ptr(new $Int64(0, 49199), new $Int64(0, 3146)), new Pair.ptr(new $Int64(0, 49201), new $Int64(0, 20201)), new Pair.ptr(new $Int64(0, 49207), new $Int64(0, 15590)), new Pair.ptr(new $Int64(0, 49211), new $Int64(0, 33868)), new Pair.ptr(new $Int64(0, 49223), new $Int64(0, 620)), new Pair.ptr(new $Int64(0, 49253), new $Int64(0, 38495)), new Pair.ptr(new $Int64(0, 49261), new $Int64(0, 33439)), new Pair.ptr(new $Int64(0, 49277), new $Int64(0, 19374)), new Pair.ptr(new $Int64(0, 49279), new $Int64(0, 21481)), new Pair.ptr(new $Int64(0, 49297), new $Int64(0, 44687)), new Pair.ptr(new $Int64(0, 49307), new $Int64(0, 38584)), new Pair.ptr(new $Int64(0, 49331), new $Int64(0, 18279)), new Pair.ptr(new $Int64(0, 49333), new $Int64(0, 44488)), new Pair.ptr(new $Int64(0, 49339), new $Int64(0, 46916)), new Pair.ptr(new $Int64(0, 49363), new $Int64(0, 19550)), new Pair.ptr(new $Int64(0, 49367), new $Int64(0, 40579)), new Pair.ptr(new $Int64(0, 49369), new $Int64(0, 46439)), new Pair.ptr(new $Int64(0, 49391), new $Int64(0, 36681)), new Pair.ptr(new $Int64(0, 49393), new $Int64(0, 10569)), new Pair.ptr(new $Int64(0, 49409), new $Int64(0, 31751)), new Pair.ptr(new $Int64(0, 49411), new $Int64(0, 27457)), new Pair.ptr(new $Int64(0, 49417), new $Int64(0, 40797)), new Pair.ptr(new $Int64(0, 49429), new $Int64(0, 42471)), new Pair.ptr(new $Int64(0, 49433), new $Int64(0, 45821)), new Pair.ptr(new $Int64(0, 49451), new $Int64(0, 34873)), new Pair.ptr(new $Int64(0, 49459), new $Int64(0, 45449)), new Pair.ptr(new $Int64(0, 49463), new $Int64(0, 14360)), new Pair.ptr(new $Int64(0, 49477), new $Int64(0, 38993)), new Pair.ptr(new $Int64(0, 49481), new $Int64(0, 26429)), new Pair.ptr(new $Int64(0, 49499), new $Int64(0, 4080)), new Pair.ptr(new $Int64(0, 49523), new $Int64(0, 13759)), new Pair.ptr(new $Int64(0, 49529), new $Int64(0, 18815)), new Pair.ptr(new $Int64(0, 49531), new $Int64(0, 6593)), new Pair.ptr(new $Int64(0, 49537), new $Int64(0, 19369)), new Pair.ptr(new $Int64(0, 49547), new $Int64(0, 15112)), new Pair.ptr(new $Int64(0, 49549), new $Int64(0, 3717)), new Pair.ptr(new $Int64(0, 49559), new $Int64(0, 18715)), new Pair.ptr(new $Int64(0, 49597), new $Int64(0, 18129)), new Pair.ptr(new $Int64(0, 49603), new $Int64(0, 46949)), new Pair.ptr(new $Int64(0, 49613), new $Int64(0, 12706)), new Pair.ptr(new $Int64(0, 49627), new $Int64(0, 11038)), new Pair.ptr(new $Int64(0, 49633), new $Int64(0, 47560)), new Pair.ptr(new $Int64(0, 49639), new $Int64(0, 29721)), new Pair.ptr(new $Int64(0, 49663), new $Int64(0, 25548)), new Pair.ptr(new $Int64(0, 49667), new $Int64(0, 17431)), new Pair.ptr(new $Int64(0, 49669), new $Int64(0, 24715)), new Pair.ptr(new $Int64(0, 49681), new $Int64(0, 26602)), new Pair.ptr(new $Int64(0, 49697), new $Int64(0, 37437)), new Pair.ptr(new $Int64(0, 49711), new $Int64(0, 23328)), new Pair.ptr(new $Int64(0, 49727), new $Int64(0, 30393)), new Pair.ptr(new $Int64(0, 49739), new $Int64(0, 32373)), new Pair.ptr(new $Int64(0, 49741), new $Int64(0, 36796)), new Pair.ptr(new $Int64(0, 49747), new $Int64(0, 25626)), new Pair.ptr(new $Int64(0, 49757), new $Int64(0, 43969)), new Pair.ptr(new $Int64(0, 49783), new $Int64(0, 24068)), new Pair.ptr(new $Int64(0, 49787), new $Int64(0, 10112)), new Pair.ptr(new $Int64(0, 49789), new $Int64(0, 18806)), new Pair.ptr(new $Int64(0, 49801), new $Int64(0, 16517)), new Pair.ptr(new $Int64(0, 49807), new $Int64(0, 25433)), new Pair.ptr(new $Int64(0, 49811), new $Int64(0, 43437)), new Pair.ptr(new $Int64(0, 49823), new $Int64(0, 49256)), new Pair.ptr(new $Int64(0, 49831), new $Int64(0, 23683)), new Pair.ptr(new $Int64(0, 49843), new $Int64(0, 20487)), new Pair.ptr(new $Int64(0, 49853), new $Int64(0, 46036)), new Pair.ptr(new $Int64(0, 49871), new $Int64(0, 47201)), new Pair.ptr(new $Int64(0, 49877), new $Int64(0, 28230)), new Pair.ptr(new $Int64(0, 49891), new $Int64(0, 27325)), new Pair.ptr(new $Int64(0, 49919), new $Int64(0, 7780)), new Pair.ptr(new $Int64(0, 49921), new $Int64(0, 18801)), new Pair.ptr(new $Int64(0, 49927), new $Int64(0, 21953)), new Pair.ptr(new $Int64(0, 49937), new $Int64(0, 28688)), new Pair.ptr(new $Int64(0, 49939), new $Int64(0, 2287)), new Pair.ptr(new $Int64(0, 49943), new $Int64(0, 1128)), new Pair.ptr(new $Int64(0, 49957), new $Int64(0, 14817)), new Pair.ptr(new $Int64(0, 49991), new $Int64(0, 41871)), new Pair.ptr(new $Int64(0, 49993), new $Int64(0, 42611)), new Pair.ptr(new $Int64(0, 49999), new $Int64(0, 32434)), new Pair.ptr(new $Int64(0, 50021), new $Int64(0, 3306)), new Pair.ptr(new $Int64(0, 50023), new $Int64(0, 46472)), new Pair.ptr(new $Int64(0, 50033), new $Int64(0, 5641)), new Pair.ptr(new $Int64(0, 50047), new $Int64(0, 34755)), new Pair.ptr(new $Int64(0, 50051), new $Int64(0, 29196)), new Pair.ptr(new $Int64(0, 50053), new $Int64(0, 23636)), new Pair.ptr(new $Int64(0, 50069), new $Int64(0, 5490)), new Pair.ptr(new $Int64(0, 50077), new $Int64(0, 11901)), new Pair.ptr(new $Int64(0, 50087), new $Int64(0, 26510)), new Pair.ptr(new $Int64(0, 50093), new $Int64(0, 26891)), new Pair.ptr(new $Int64(0, 50101), new $Int64(0, 25951)), new Pair.ptr(new $Int64(0, 50111), new $Int64(0, 20195)), new Pair.ptr(new $Int64(0, 50119), new $Int64(0, 5024)), new Pair.ptr(new $Int64(0, 50123), new $Int64(0, 12073)), new Pair.ptr(new $Int64(0, 50129), new $Int64(0, 30511)), new Pair.ptr(new $Int64(0, 50131), new $Int64(0, 40177)), new Pair.ptr(new $Int64(0, 50147), new $Int64(0, 39592)), new Pair.ptr(new $Int64(0, 50153), new $Int64(0, 22439)), new Pair.ptr(new $Int64(0, 50159), new $Int64(0, 4410)), new Pair.ptr(new $Int64(0, 50177), new $Int64(0, 8725)), new Pair.ptr(new $Int64(0, 50207), new $Int64(0, 36003)), new Pair.ptr(new $Int64(0, 50221), new $Int64(0, 8052)), new Pair.ptr(new $Int64(0, 50227), new $Int64(0, 13881)), new Pair.ptr(new $Int64(0, 50231), new $Int64(0, 1827)), new Pair.ptr(new $Int64(0, 50261), new $Int64(0, 9548)), new Pair.ptr(new $Int64(0, 50263), new $Int64(0, 33489)), new Pair.ptr(new $Int64(0, 50273), new $Int64(0, 10389)), new Pair.ptr(new $Int64(0, 50287), new $Int64(0, 24171)), new Pair.ptr(new $Int64(0, 50291), new $Int64(0, 34762)), new Pair.ptr(new $Int64(0, 50311), new $Int64(0, 39693)), new Pair.ptr(new $Int64(0, 50321), new $Int64(0, 45880)), new Pair.ptr(new $Int64(0, 50329), new $Int64(0, 34169)), new Pair.ptr(new $Int64(0, 50333), new $Int64(0, 21891)), new Pair.ptr(new $Int64(0, 50341), new $Int64(0, 27232)), new Pair.ptr(new $Int64(0, 50359), new $Int64(0, 21499)), new Pair.ptr(new $Int64(0, 50363), new $Int64(0, 13288)), new Pair.ptr(new $Int64(0, 50377), new $Int64(0, 15470)), new Pair.ptr(new $Int64(0, 50383), new $Int64(0, 4829)), new Pair.ptr(new $Int64(0, 50387), new $Int64(0, 7264)), new Pair.ptr(new $Int64(0, 50411), new $Int64(0, 20190)), new Pair.ptr(new $Int64(0, 50417), new $Int64(0, 7155)), new Pair.ptr(new $Int64(0, 50423), new $Int64(0, 40228)), new Pair.ptr(new $Int64(0, 50441), new $Int64(0, 6332)), new Pair.ptr(new $Int64(0, 50459), new $Int64(0, 3403)), new Pair.ptr(new $Int64(0, 50461), new $Int64(0, 28658)), new Pair.ptr(new $Int64(0, 50497), new $Int64(0, 11118)), new Pair.ptr(new $Int64(0, 50503), new $Int64(0, 40460)), new Pair.ptr(new $Int64(0, 50513), new $Int64(0, 15283)), new Pair.ptr(new $Int64(0, 50527), new $Int64(0, 13232)), new Pair.ptr(new $Int64(0, 50539), new $Int64(0, 48360)), new Pair.ptr(new $Int64(0, 50543), new $Int64(0, 25075)), new Pair.ptr(new $Int64(0, 50549), new $Int64(0, 43669)), new Pair.ptr(new $Int64(0, 50551), new $Int64(0, 4633)), new Pair.ptr(new $Int64(0, 50581), new $Int64(0, 24330)), new Pair.ptr(new $Int64(0, 50587), new $Int64(0, 45869)), new Pair.ptr(new $Int64(0, 50591), new $Int64(0, 26706)), new Pair.ptr(new $Int64(0, 50593), new $Int64(0, 14667)), new Pair.ptr(new $Int64(0, 50599), new $Int64(0, 15384)), new Pair.ptr(new $Int64(0, 50627), new $Int64(0, 44624)), new Pair.ptr(new $Int64(0, 50647), new $Int64(0, 36133)), new Pair.ptr(new $Int64(0, 50651), new $Int64(0, 4853)), new Pair.ptr(new $Int64(0, 50671), new $Int64(0, 15578)), new Pair.ptr(new $Int64(0, 50683), new $Int64(0, 17288)), new Pair.ptr(new $Int64(0, 50707), new $Int64(0, 48308)), new Pair.ptr(new $Int64(0, 50723), new $Int64(0, 34412)), new Pair.ptr(new $Int64(0, 50741), new $Int64(0, 667)), new Pair.ptr(new $Int64(0, 50753), new $Int64(0, 48160)), new Pair.ptr(new $Int64(0, 50767), new $Int64(0, 13447)), new Pair.ptr(new $Int64(0, 50773), new $Int64(0, 25802)), new Pair.ptr(new $Int64(0, 50777), new $Int64(0, 39468)), new Pair.ptr(new $Int64(0, 50789), new $Int64(0, 50726)), new Pair.ptr(new $Int64(0, 50821), new $Int64(0, 37138)), new Pair.ptr(new $Int64(0, 50833), new $Int64(0, 50081)), new Pair.ptr(new $Int64(0, 50839), new $Int64(0, 24802)), new Pair.ptr(new $Int64(0, 50849), new $Int64(0, 20434)), new Pair.ptr(new $Int64(0, 50857), new $Int64(0, 50064)), new Pair.ptr(new $Int64(0, 50867), new $Int64(0, 5453)), new Pair.ptr(new $Int64(0, 50873), new $Int64(0, 25658)), new Pair.ptr(new $Int64(0, 50891), new $Int64(0, 44633)), new Pair.ptr(new $Int64(0, 50893), new $Int64(0, 43251)), new Pair.ptr(new $Int64(0, 50909), new $Int64(0, 242)), new Pair.ptr(new $Int64(0, 50923), new $Int64(0, 45960)), new Pair.ptr(new $Int64(0, 50929), new $Int64(0, 47245)), new Pair.ptr(new $Int64(0, 50951), new $Int64(0, 8063)), new Pair.ptr(new $Int64(0, 50957), new $Int64(0, 25736)), new Pair.ptr(new $Int64(0, 50969), new $Int64(0, 27458)), new Pair.ptr(new $Int64(0, 50971), new $Int64(0, 9127)), new Pair.ptr(new $Int64(0, 50989), new $Int64(0, 18648)), new Pair.ptr(new $Int64(0, 50993), new $Int64(0, 49916)), new Pair.ptr(new $Int64(0, 51001), new $Int64(0, 25067)), new Pair.ptr(new $Int64(0, 51031), new $Int64(0, 25069)), new Pair.ptr(new $Int64(0, 51043), new $Int64(0, 41632)), new Pair.ptr(new $Int64(0, 51047), new $Int64(0, 28395)), new Pair.ptr(new $Int64(0, 51059), new $Int64(0, 6861)), new Pair.ptr(new $Int64(0, 51061), new $Int64(0, 50678)), new Pair.ptr(new $Int64(0, 51071), new $Int64(0, 33643)), new Pair.ptr(new $Int64(0, 51109), new $Int64(0, 49633)), new Pair.ptr(new $Int64(0, 51131), new $Int64(0, 49645)), new Pair.ptr(new $Int64(0, 51133), new $Int64(0, 21030)), new Pair.ptr(new $Int64(0, 51137), new $Int64(0, 41638)), new Pair.ptr(new $Int64(0, 51151), new $Int64(0, 50729)), new Pair.ptr(new $Int64(0, 51157), new $Int64(0, 30658)), new Pair.ptr(new $Int64(0, 51169), new $Int64(0, 10765)), new Pair.ptr(new $Int64(0, 51193), new $Int64(0, 48390)), new Pair.ptr(new $Int64(0, 51197), new $Int64(0, 14912)), new Pair.ptr(new $Int64(0, 51199), new $Int64(0, 5388)), new Pair.ptr(new $Int64(0, 51203), new $Int64(0, 9929)), new Pair.ptr(new $Int64(0, 51217), new $Int64(0, 2476)), new Pair.ptr(new $Int64(0, 51229), new $Int64(0, 22830)), new Pair.ptr(new $Int64(0, 51239), new $Int64(0, 1792)), new Pair.ptr(new $Int64(0, 51241), new $Int64(0, 44074)), new Pair.ptr(new $Int64(0, 51257), new $Int64(0, 26630)), new Pair.ptr(new $Int64(0, 51263), new $Int64(0, 23691)), new Pair.ptr(new $Int64(0, 51283), new $Int64(0, 46746)), new Pair.ptr(new $Int64(0, 51287), new $Int64(0, 6036)), new Pair.ptr(new $Int64(0, 51307), new $Int64(0, 21099)), new Pair.ptr(new $Int64(0, 51329), new $Int64(0, 22678)), new Pair.ptr(new $Int64(0, 51341), new $Int64(0, 47964)), new Pair.ptr(new $Int64(0, 51343), new $Int64(0, 41492)), new Pair.ptr(new $Int64(0, 51347), new $Int64(0, 9762)), new Pair.ptr(new $Int64(0, 51349), new $Int64(0, 56)), new Pair.ptr(new $Int64(0, 51361), new $Int64(0, 7029)), new Pair.ptr(new $Int64(0, 51383), new $Int64(0, 48129)), new Pair.ptr(new $Int64(0, 51407), new $Int64(0, 24949)), new Pair.ptr(new $Int64(0, 51413), new $Int64(0, 17430)), new Pair.ptr(new $Int64(0, 51419), new $Int64(0, 31309)), new Pair.ptr(new $Int64(0, 51421), new $Int64(0, 20419)), new Pair.ptr(new $Int64(0, 51427), new $Int64(0, 33684)), new Pair.ptr(new $Int64(0, 51431), new $Int64(0, 43334)), new Pair.ptr(new $Int64(0, 51437), new $Int64(0, 31785)), new Pair.ptr(new $Int64(0, 51439), new $Int64(0, 2330)), new Pair.ptr(new $Int64(0, 51449), new $Int64(0, 48841)), new Pair.ptr(new $Int64(0, 51461), new $Int64(0, 46431)), new Pair.ptr(new $Int64(0, 51473), new $Int64(0, 2101)), new Pair.ptr(new $Int64(0, 51479), new $Int64(0, 29417)), new Pair.ptr(new $Int64(0, 51481), new $Int64(0, 7354)), new Pair.ptr(new $Int64(0, 51487), new $Int64(0, 12609)), new Pair.ptr(new $Int64(0, 51503), new $Int64(0, 33269)), new Pair.ptr(new $Int64(0, 51511), new $Int64(0, 32046)), new Pair.ptr(new $Int64(0, 51517), new $Int64(0, 19294)), new Pair.ptr(new $Int64(0, 51521), new $Int64(0, 34467)), new Pair.ptr(new $Int64(0, 51539), new $Int64(0, 8985)), new Pair.ptr(new $Int64(0, 51551), new $Int64(0, 3008)), new Pair.ptr(new $Int64(0, 51563), new $Int64(0, 51208)), new Pair.ptr(new $Int64(0, 51577), new $Int64(0, 40107)), new Pair.ptr(new $Int64(0, 51581), new $Int64(0, 15467)), new Pair.ptr(new $Int64(0, 51593), new $Int64(0, 7827)), new Pair.ptr(new $Int64(0, 51599), new $Int64(0, 7681)), new Pair.ptr(new $Int64(0, 51607), new $Int64(0, 37849)), new Pair.ptr(new $Int64(0, 51613), new $Int64(0, 4934)), new Pair.ptr(new $Int64(0, 51631), new $Int64(0, 6692)), new Pair.ptr(new $Int64(0, 51637), new $Int64(0, 29037)), new Pair.ptr(new $Int64(0, 51647), new $Int64(0, 39409)), new Pair.ptr(new $Int64(0, 51659), new $Int64(0, 40280)), new Pair.ptr(new $Int64(0, 51673), new $Int64(0, 23446)), new Pair.ptr(new $Int64(0, 51679), new $Int64(0, 7865)), new Pair.ptr(new $Int64(0, 51683), new $Int64(0, 16476)), new Pair.ptr(new $Int64(0, 51691), new $Int64(0, 38742)), new Pair.ptr(new $Int64(0, 51713), new $Int64(0, 13063)), new Pair.ptr(new $Int64(0, 51719), new $Int64(0, 44176)), new Pair.ptr(new $Int64(0, 51721), new $Int64(0, 27746)), new Pair.ptr(new $Int64(0, 51749), new $Int64(0, 15445)), new Pair.ptr(new $Int64(0, 51767), new $Int64(0, 17625)), new Pair.ptr(new $Int64(0, 51769), new $Int64(0, 26665)), new Pair.ptr(new $Int64(0, 51787), new $Int64(0, 35834)), new Pair.ptr(new $Int64(0, 51797), new $Int64(0, 42460)), new Pair.ptr(new $Int64(0, 51803), new $Int64(0, 5957)), new Pair.ptr(new $Int64(0, 51817), new $Int64(0, 36463)), new Pair.ptr(new $Int64(0, 51827), new $Int64(0, 8300)), new Pair.ptr(new $Int64(0, 51829), new $Int64(0, 38527)), new Pair.ptr(new $Int64(0, 51839), new $Int64(0, 14708)), new Pair.ptr(new $Int64(0, 51853), new $Int64(0, 33344)), new Pair.ptr(new $Int64(0, 51859), new $Int64(0, 2893)), new Pair.ptr(new $Int64(0, 51869), new $Int64(0, 10610)), new Pair.ptr(new $Int64(0, 51871), new $Int64(0, 5894)), new Pair.ptr(new $Int64(0, 51893), new $Int64(0, 17178)), new Pair.ptr(new $Int64(0, 51899), new $Int64(0, 37460)), new Pair.ptr(new $Int64(0, 51907), new $Int64(0, 21968)), new Pair.ptr(new $Int64(0, 51913), new $Int64(0, 8204)), new Pair.ptr(new $Int64(0, 51929), new $Int64(0, 11582)), new Pair.ptr(new $Int64(0, 51941), new $Int64(0, 1513)), new Pair.ptr(new $Int64(0, 51949), new $Int64(0, 26109)), new Pair.ptr(new $Int64(0, 51971), new $Int64(0, 18115)), new Pair.ptr(new $Int64(0, 51973), new $Int64(0, 17741)), new Pair.ptr(new $Int64(0, 51977), new $Int64(0, 49228)), new Pair.ptr(new $Int64(0, 51991), new $Int64(0, 38837)), new Pair.ptr(new $Int64(0, 52009), new $Int64(0, 21489)), new Pair.ptr(new $Int64(0, 52021), new $Int64(0, 19410)), new Pair.ptr(new $Int64(0, 52027), new $Int64(0, 50709)), new Pair.ptr(new $Int64(0, 52051), new $Int64(0, 29496)), new Pair.ptr(new $Int64(0, 52057), new $Int64(0, 37828)), new Pair.ptr(new $Int64(0, 52067), new $Int64(0, 45009)), new Pair.ptr(new $Int64(0, 52069), new $Int64(0, 43595)), new Pair.ptr(new $Int64(0, 52081), new $Int64(0, 4370)), new Pair.ptr(new $Int64(0, 52103), new $Int64(0, 15699)), new Pair.ptr(new $Int64(0, 52121), new $Int64(0, 4356)), new Pair.ptr(new $Int64(0, 52127), new $Int64(0, 30558)), new Pair.ptr(new $Int64(0, 52147), new $Int64(0, 37125)), new Pair.ptr(new $Int64(0, 52153), new $Int64(0, 12410)), new Pair.ptr(new $Int64(0, 52163), new $Int64(0, 47166)), new Pair.ptr(new $Int64(0, 52177), new $Int64(0, 16961)), new Pair.ptr(new $Int64(0, 52181), new $Int64(0, 40356)), new Pair.ptr(new $Int64(0, 52183), new $Int64(0, 41441)), new Pair.ptr(new $Int64(0, 52189), new $Int64(0, 51516)), new Pair.ptr(new $Int64(0, 52201), new $Int64(0, 7509)), new Pair.ptr(new $Int64(0, 52223), new $Int64(0, 49281)), new Pair.ptr(new $Int64(0, 52237), new $Int64(0, 1873)), new Pair.ptr(new $Int64(0, 52249), new $Int64(0, 1388)), new Pair.ptr(new $Int64(0, 52253), new $Int64(0, 32331)), new Pair.ptr(new $Int64(0, 52259), new $Int64(0, 28166)), new Pair.ptr(new $Int64(0, 52267), new $Int64(0, 14497)), new Pair.ptr(new $Int64(0, 52289), new $Int64(0, 13804)), new Pair.ptr(new $Int64(0, 52291), new $Int64(0, 14535)), new Pair.ptr(new $Int64(0, 52301), new $Int64(0, 42800)), new Pair.ptr(new $Int64(0, 52313), new $Int64(0, 29938)), new Pair.ptr(new $Int64(0, 52321), new $Int64(0, 22841)), new Pair.ptr(new $Int64(0, 52361), new $Int64(0, 21481)), new Pair.ptr(new $Int64(0, 52363), new $Int64(0, 15664)), new Pair.ptr(new $Int64(0, 52369), new $Int64(0, 39687)), new Pair.ptr(new $Int64(0, 52379), new $Int64(0, 4736)), new Pair.ptr(new $Int64(0, 52387), new $Int64(0, 3383)), new Pair.ptr(new $Int64(0, 52391), new $Int64(0, 35664)), new Pair.ptr(new $Int64(0, 52433), new $Int64(0, 23721)), new Pair.ptr(new $Int64(0, 52453), new $Int64(0, 48664)), new Pair.ptr(new $Int64(0, 52457), new $Int64(0, 40407)), new Pair.ptr(new $Int64(0, 52489), new $Int64(0, 36422)), new Pair.ptr(new $Int64(0, 52501), new $Int64(0, 33960)), new Pair.ptr(new $Int64(0, 52511), new $Int64(0, 41044)), new Pair.ptr(new $Int64(0, 52517), new $Int64(0, 28570)), new Pair.ptr(new $Int64(0, 52529), new $Int64(0, 2375)), new Pair.ptr(new $Int64(0, 52541), new $Int64(0, 49400)), new Pair.ptr(new $Int64(0, 52543), new $Int64(0, 30074)), new Pair.ptr(new $Int64(0, 52553), new $Int64(0, 45983)), new Pair.ptr(new $Int64(0, 52561), new $Int64(0, 42899)), new Pair.ptr(new $Int64(0, 52567), new $Int64(0, 34667)), new Pair.ptr(new $Int64(0, 52571), new $Int64(0, 888)), new Pair.ptr(new $Int64(0, 52579), new $Int64(0, 35342)), new Pair.ptr(new $Int64(0, 52583), new $Int64(0, 13900)), new Pair.ptr(new $Int64(0, 52609), new $Int64(0, 46964)), new Pair.ptr(new $Int64(0, 52627), new $Int64(0, 14702)), new Pair.ptr(new $Int64(0, 52631), new $Int64(0, 46974)), new Pair.ptr(new $Int64(0, 52639), new $Int64(0, 34725)), new Pair.ptr(new $Int64(0, 52667), new $Int64(0, 48211)), new Pair.ptr(new $Int64(0, 52673), new $Int64(0, 4781)), new Pair.ptr(new $Int64(0, 52691), new $Int64(0, 31315)), new Pair.ptr(new $Int64(0, 52697), new $Int64(0, 2530)), new Pair.ptr(new $Int64(0, 52709), new $Int64(0, 38795)), new Pair.ptr(new $Int64(0, 52711), new $Int64(0, 21471)), new Pair.ptr(new $Int64(0, 52721), new $Int64(0, 52545)), new Pair.ptr(new $Int64(0, 52727), new $Int64(0, 51084)), new Pair.ptr(new $Int64(0, 52733), new $Int64(0, 493)), new Pair.ptr(new $Int64(0, 52747), new $Int64(0, 13102)), new Pair.ptr(new $Int64(0, 52757), new $Int64(0, 18107)), new Pair.ptr(new $Int64(0, 52769), new $Int64(0, 2544)), new Pair.ptr(new $Int64(0, 52783), new $Int64(0, 28524)), new Pair.ptr(new $Int64(0, 52807), new $Int64(0, 6549)), new Pair.ptr(new $Int64(0, 52813), new $Int64(0, 41295)), new Pair.ptr(new $Int64(0, 52817), new $Int64(0, 21953)), new Pair.ptr(new $Int64(0, 52837), new $Int64(0, 25014)), new Pair.ptr(new $Int64(0, 52859), new $Int64(0, 40582)), new Pair.ptr(new $Int64(0, 52861), new $Int64(0, 36358)), new Pair.ptr(new $Int64(0, 52879), new $Int64(0, 49569)), new Pair.ptr(new $Int64(0, 52883), new $Int64(0, 17651)), new Pair.ptr(new $Int64(0, 52889), new $Int64(0, 3448)), new Pair.ptr(new $Int64(0, 52901), new $Int64(0, 39116)), new Pair.ptr(new $Int64(0, 52903), new $Int64(0, 46875)), new Pair.ptr(new $Int64(0, 52919), new $Int64(0, 50329)), new Pair.ptr(new $Int64(0, 52937), new $Int64(0, 41570)), new Pair.ptr(new $Int64(0, 52951), new $Int64(0, 12100)), new Pair.ptr(new $Int64(0, 52957), new $Int64(0, 32689)), new Pair.ptr(new $Int64(0, 52963), new $Int64(0, 47907)), new Pair.ptr(new $Int64(0, 52967), new $Int64(0, 38088)), new Pair.ptr(new $Int64(0, 52973), new $Int64(0, 50981)), new Pair.ptr(new $Int64(0, 52981), new $Int64(0, 47873)), new Pair.ptr(new $Int64(0, 52999), new $Int64(0, 35439)), new Pair.ptr(new $Int64(0, 53003), new $Int64(0, 14567)), new Pair.ptr(new $Int64(0, 53017), new $Int64(0, 29098)), new Pair.ptr(new $Int64(0, 53047), new $Int64(0, 39859)), new Pair.ptr(new $Int64(0, 53051), new $Int64(0, 3758)), new Pair.ptr(new $Int64(0, 53069), new $Int64(0, 39166)), new Pair.ptr(new $Int64(0, 53077), new $Int64(0, 17121)), new Pair.ptr(new $Int64(0, 53087), new $Int64(0, 36159)), new Pair.ptr(new $Int64(0, 53089), new $Int64(0, 40763)), new Pair.ptr(new $Int64(0, 53093), new $Int64(0, 7975)), new Pair.ptr(new $Int64(0, 53101), new $Int64(0, 2148)), new Pair.ptr(new $Int64(0, 53113), new $Int64(0, 8712)), new Pair.ptr(new $Int64(0, 53117), new $Int64(0, 16108)), new Pair.ptr(new $Int64(0, 53129), new $Int64(0, 5109)), new Pair.ptr(new $Int64(0, 53147), new $Int64(0, 1503)), new Pair.ptr(new $Int64(0, 53149), new $Int64(0, 37172)), new Pair.ptr(new $Int64(0, 53161), new $Int64(0, 44026)), new Pair.ptr(new $Int64(0, 53171), new $Int64(0, 10300)), new Pair.ptr(new $Int64(0, 53173), new $Int64(0, 27181)), new Pair.ptr(new $Int64(0, 53189), new $Int64(0, 12049)), new Pair.ptr(new $Int64(0, 53197), new $Int64(0, 9879)), new Pair.ptr(new $Int64(0, 53201), new $Int64(0, 4712)), new Pair.ptr(new $Int64(0, 53231), new $Int64(0, 22835)), new Pair.ptr(new $Int64(0, 53233), new $Int64(0, 51116)), new Pair.ptr(new $Int64(0, 53239), new $Int64(0, 7411)), new Pair.ptr(new $Int64(0, 53267), new $Int64(0, 5391)), new Pair.ptr(new $Int64(0, 53269), new $Int64(0, 44919)), new Pair.ptr(new $Int64(0, 53279), new $Int64(0, 39973)), new Pair.ptr(new $Int64(0, 53281), new $Int64(0, 8516)), new Pair.ptr(new $Int64(0, 53299), new $Int64(0, 10268)), new Pair.ptr(new $Int64(0, 53309), new $Int64(0, 10372)), new Pair.ptr(new $Int64(0, 53323), new $Int64(0, 9399)), new Pair.ptr(new $Int64(0, 53327), new $Int64(0, 40318)), new Pair.ptr(new $Int64(0, 53353), new $Int64(0, 38386)), new Pair.ptr(new $Int64(0, 53359), new $Int64(0, 3643)), new Pair.ptr(new $Int64(0, 53377), new $Int64(0, 41720)), new Pair.ptr(new $Int64(0, 53381), new $Int64(0, 13607)), new Pair.ptr(new $Int64(0, 53401), new $Int64(0, 10349)), new Pair.ptr(new $Int64(0, 53407), new $Int64(0, 42317)), new Pair.ptr(new $Int64(0, 53411), new $Int64(0, 34144)), new Pair.ptr(new $Int64(0, 53419), new $Int64(0, 50849)), new Pair.ptr(new $Int64(0, 53437), new $Int64(0, 15689)), new Pair.ptr(new $Int64(0, 53441), new $Int64(0, 1530)), new Pair.ptr(new $Int64(0, 53453), new $Int64(0, 44768)), new Pair.ptr(new $Int64(0, 53479), new $Int64(0, 1995)), new Pair.ptr(new $Int64(0, 53503), new $Int64(0, 45429)), new Pair.ptr(new $Int64(0, 53507), new $Int64(0, 6324)), new Pair.ptr(new $Int64(0, 53527), new $Int64(0, 34498)), new Pair.ptr(new $Int64(0, 53549), new $Int64(0, 843)), new Pair.ptr(new $Int64(0, 53551), new $Int64(0, 3838)), new Pair.ptr(new $Int64(0, 53569), new $Int64(0, 44396)), new Pair.ptr(new $Int64(0, 53591), new $Int64(0, 33804)), new Pair.ptr(new $Int64(0, 53593), new $Int64(0, 47821)), new Pair.ptr(new $Int64(0, 53597), new $Int64(0, 9400)), new Pair.ptr(new $Int64(0, 53609), new $Int64(0, 27702)), new Pair.ptr(new $Int64(0, 53611), new $Int64(0, 33165)), new Pair.ptr(new $Int64(0, 53617), new $Int64(0, 33391)), new Pair.ptr(new $Int64(0, 53623), new $Int64(0, 479)), new Pair.ptr(new $Int64(0, 53629), new $Int64(0, 49080)), new Pair.ptr(new $Int64(0, 53633), new $Int64(0, 48964)), new Pair.ptr(new $Int64(0, 53639), new $Int64(0, 18541)), new Pair.ptr(new $Int64(0, 53653), new $Int64(0, 42327)), new Pair.ptr(new $Int64(0, 53657), new $Int64(0, 42189)), new Pair.ptr(new $Int64(0, 53681), new $Int64(0, 7275)), new Pair.ptr(new $Int64(0, 53693), new $Int64(0, 28609)), new Pair.ptr(new $Int64(0, 53699), new $Int64(0, 32590)), new Pair.ptr(new $Int64(0, 53717), new $Int64(0, 20905)), new Pair.ptr(new $Int64(0, 53719), new $Int64(0, 13542)), new Pair.ptr(new $Int64(0, 53731), new $Int64(0, 20303)), new Pair.ptr(new $Int64(0, 53759), new $Int64(0, 8647)), new Pair.ptr(new $Int64(0, 53773), new $Int64(0, 47525)), new Pair.ptr(new $Int64(0, 53777), new $Int64(0, 38469)), new Pair.ptr(new $Int64(0, 53783), new $Int64(0, 1161)), new Pair.ptr(new $Int64(0, 53791), new $Int64(0, 52165)), new Pair.ptr(new $Int64(0, 53813), new $Int64(0, 13029)), new Pair.ptr(new $Int64(0, 53819), new $Int64(0, 26211)), new Pair.ptr(new $Int64(0, 53831), new $Int64(0, 39118)), new Pair.ptr(new $Int64(0, 53849), new $Int64(0, 41490)), new Pair.ptr(new $Int64(0, 53857), new $Int64(0, 15624)), new Pair.ptr(new $Int64(0, 53861), new $Int64(0, 2107)), new Pair.ptr(new $Int64(0, 53881), new $Int64(0, 17924)), new Pair.ptr(new $Int64(0, 53887), new $Int64(0, 40867)), new Pair.ptr(new $Int64(0, 53891), new $Int64(0, 48287)), new Pair.ptr(new $Int64(0, 53897), new $Int64(0, 43993)), new Pair.ptr(new $Int64(0, 53899), new $Int64(0, 29714)), new Pair.ptr(new $Int64(0, 53917), new $Int64(0, 17769)), new Pair.ptr(new $Int64(0, 53923), new $Int64(0, 49745)), new Pair.ptr(new $Int64(0, 53927), new $Int64(0, 19384)), new Pair.ptr(new $Int64(0, 53939), new $Int64(0, 53212)), new Pair.ptr(new $Int64(0, 53951), new $Int64(0, 26216)), new Pair.ptr(new $Int64(0, 53959), new $Int64(0, 32631)), new Pair.ptr(new $Int64(0, 53987), new $Int64(0, 46453)), new Pair.ptr(new $Int64(0, 53993), new $Int64(0, 28634)), new Pair.ptr(new $Int64(0, 54001), new $Int64(0, 31127)), new Pair.ptr(new $Int64(0, 54011), new $Int64(0, 21416)), new Pair.ptr(new $Int64(0, 54013), new $Int64(0, 13635)), new Pair.ptr(new $Int64(0, 54037), new $Int64(0, 25906)), new Pair.ptr(new $Int64(0, 54049), new $Int64(0, 31889)), new Pair.ptr(new $Int64(0, 54059), new $Int64(0, 27570)), new Pair.ptr(new $Int64(0, 54083), new $Int64(0, 46903)), new Pair.ptr(new $Int64(0, 54091), new $Int64(0, 16008)), new Pair.ptr(new $Int64(0, 54101), new $Int64(0, 14331)), new Pair.ptr(new $Int64(0, 54121), new $Int64(0, 23789)), new Pair.ptr(new $Int64(0, 54133), new $Int64(0, 20317)), new Pair.ptr(new $Int64(0, 54139), new $Int64(0, 39203)), new Pair.ptr(new $Int64(0, 54151), new $Int64(0, 30118)), new Pair.ptr(new $Int64(0, 54163), new $Int64(0, 46287)), new Pair.ptr(new $Int64(0, 54167), new $Int64(0, 51938)), new Pair.ptr(new $Int64(0, 54181), new $Int64(0, 50960)), new Pair.ptr(new $Int64(0, 54193), new $Int64(0, 30274)), new Pair.ptr(new $Int64(0, 54217), new $Int64(0, 21903)), new Pair.ptr(new $Int64(0, 54251), new $Int64(0, 537)), new Pair.ptr(new $Int64(0, 54269), new $Int64(0, 3294)), new Pair.ptr(new $Int64(0, 54277), new $Int64(0, 31118)), new Pair.ptr(new $Int64(0, 54287), new $Int64(0, 42020)), new Pair.ptr(new $Int64(0, 54293), new $Int64(0, 3328)), new Pair.ptr(new $Int64(0, 54311), new $Int64(0, 24926)), new Pair.ptr(new $Int64(0, 54319), new $Int64(0, 33934)), new Pair.ptr(new $Int64(0, 54323), new $Int64(0, 11945)), new Pair.ptr(new $Int64(0, 54331), new $Int64(0, 31765)), new Pair.ptr(new $Int64(0, 54347), new $Int64(0, 35307)), new Pair.ptr(new $Int64(0, 54361), new $Int64(0, 25578)), new Pair.ptr(new $Int64(0, 54367), new $Int64(0, 34279)), new Pair.ptr(new $Int64(0, 54371), new $Int64(0, 40298)), new Pair.ptr(new $Int64(0, 54377), new $Int64(0, 50143)), new Pair.ptr(new $Int64(0, 54401), new $Int64(0, 19981)), new Pair.ptr(new $Int64(0, 54403), new $Int64(0, 28394)), new Pair.ptr(new $Int64(0, 54409), new $Int64(0, 26829)), new Pair.ptr(new $Int64(0, 54413), new $Int64(0, 11163)), new Pair.ptr(new $Int64(0, 54419), new $Int64(0, 82)), new Pair.ptr(new $Int64(0, 54421), new $Int64(0, 49446)), new Pair.ptr(new $Int64(0, 54437), new $Int64(0, 9928)), new Pair.ptr(new $Int64(0, 54443), new $Int64(0, 22414)), new Pair.ptr(new $Int64(0, 54449), new $Int64(0, 10621)), new Pair.ptr(new $Int64(0, 54469), new $Int64(0, 41088)), new Pair.ptr(new $Int64(0, 54493), new $Int64(0, 33844)), new Pair.ptr(new $Int64(0, 54497), new $Int64(0, 37133)), new Pair.ptr(new $Int64(0, 54499), new $Int64(0, 31787)), new Pair.ptr(new $Int64(0, 54503), new $Int64(0, 23446)), new Pair.ptr(new $Int64(0, 54517), new $Int64(0, 36484)), new Pair.ptr(new $Int64(0, 54521), new $Int64(0, 23402)), new Pair.ptr(new $Int64(0, 54539), new $Int64(0, 14793)), new Pair.ptr(new $Int64(0, 54541), new $Int64(0, 43616)), new Pair.ptr(new $Int64(0, 54547), new $Int64(0, 47062)), new Pair.ptr(new $Int64(0, 54559), new $Int64(0, 4597)), new Pair.ptr(new $Int64(0, 54563), new $Int64(0, 32711)), new Pair.ptr(new $Int64(0, 54577), new $Int64(0, 47674)), new Pair.ptr(new $Int64(0, 54581), new $Int64(0, 35778)), new Pair.ptr(new $Int64(0, 54583), new $Int64(0, 33859)), new Pair.ptr(new $Int64(0, 54601), new $Int64(0, 9927)), new Pair.ptr(new $Int64(0, 54617), new $Int64(0, 50528)), new Pair.ptr(new $Int64(0, 54623), new $Int64(0, 21806)), new Pair.ptr(new $Int64(0, 54629), new $Int64(0, 3425)), new Pair.ptr(new $Int64(0, 54631), new $Int64(0, 35406)), new Pair.ptr(new $Int64(0, 54647), new $Int64(0, 5285)), new Pair.ptr(new $Int64(0, 54667), new $Int64(0, 14835)), new Pair.ptr(new $Int64(0, 54673), new $Int64(0, 11098)), new Pair.ptr(new $Int64(0, 54679), new $Int64(0, 36180)), new Pair.ptr(new $Int64(0, 54709), new $Int64(0, 32579)), new Pair.ptr(new $Int64(0, 54713), new $Int64(0, 10432)), new Pair.ptr(new $Int64(0, 54721), new $Int64(0, 34658)), new Pair.ptr(new $Int64(0, 54727), new $Int64(0, 2468)), new Pair.ptr(new $Int64(0, 54751), new $Int64(0, 29139)), new Pair.ptr(new $Int64(0, 54767), new $Int64(0, 45346)), new Pair.ptr(new $Int64(0, 54773), new $Int64(0, 30826)), new Pair.ptr(new $Int64(0, 54779), new $Int64(0, 44847)), new Pair.ptr(new $Int64(0, 54787), new $Int64(0, 33586)), new Pair.ptr(new $Int64(0, 54799), new $Int64(0, 49617)), new Pair.ptr(new $Int64(0, 54829), new $Int64(0, 19176)), new Pair.ptr(new $Int64(0, 54833), new $Int64(0, 25245)), new Pair.ptr(new $Int64(0, 54851), new $Int64(0, 8324)), new Pair.ptr(new $Int64(0, 54869), new $Int64(0, 52718)), new Pair.ptr(new $Int64(0, 54877), new $Int64(0, 47799)), new Pair.ptr(new $Int64(0, 54881), new $Int64(0, 50531)), new Pair.ptr(new $Int64(0, 54907), new $Int64(0, 11609)), new Pair.ptr(new $Int64(0, 54917), new $Int64(0, 46444)), new Pair.ptr(new $Int64(0, 54919), new $Int64(0, 47970)), new Pair.ptr(new $Int64(0, 54941), new $Int64(0, 26848)), new Pair.ptr(new $Int64(0, 54949), new $Int64(0, 39419)), new Pair.ptr(new $Int64(0, 54959), new $Int64(0, 22017)), new Pair.ptr(new $Int64(0, 54973), new $Int64(0, 16788)), new Pair.ptr(new $Int64(0, 54979), new $Int64(0, 211)), new Pair.ptr(new $Int64(0, 54983), new $Int64(0, 37769)), new Pair.ptr(new $Int64(0, 55001), new $Int64(0, 35861)), new Pair.ptr(new $Int64(0, 55009), new $Int64(0, 6627)), new Pair.ptr(new $Int64(0, 55021), new $Int64(0, 34051)), new Pair.ptr(new $Int64(0, 55049), new $Int64(0, 29436)), new Pair.ptr(new $Int64(0, 55051), new $Int64(0, 17777)), new Pair.ptr(new $Int64(0, 55057), new $Int64(0, 12617)), new Pair.ptr(new $Int64(0, 55061), new $Int64(0, 30207)), new Pair.ptr(new $Int64(0, 55073), new $Int64(0, 11601)), new Pair.ptr(new $Int64(0, 55079), new $Int64(0, 5833)), new Pair.ptr(new $Int64(0, 55103), new $Int64(0, 45393)), new Pair.ptr(new $Int64(0, 55109), new $Int64(0, 23770)), new Pair.ptr(new $Int64(0, 55117), new $Int64(0, 52413)), new Pair.ptr(new $Int64(0, 55127), new $Int64(0, 21853)), new Pair.ptr(new $Int64(0, 55147), new $Int64(0, 20805)), new Pair.ptr(new $Int64(0, 55163), new $Int64(0, 33732)), new Pair.ptr(new $Int64(0, 55171), new $Int64(0, 28398)), new Pair.ptr(new $Int64(0, 55201), new $Int64(0, 3198)), new Pair.ptr(new $Int64(0, 55207), new $Int64(0, 30948)), new Pair.ptr(new $Int64(0, 55213), new $Int64(0, 47860)), new Pair.ptr(new $Int64(0, 55217), new $Int64(0, 46284)), new Pair.ptr(new $Int64(0, 55219), new $Int64(0, 1922)), new Pair.ptr(new $Int64(0, 55229), new $Int64(0, 8980)), new Pair.ptr(new $Int64(0, 55243), new $Int64(0, 44285)), new Pair.ptr(new $Int64(0, 55249), new $Int64(0, 18357)), new Pair.ptr(new $Int64(0, 55259), new $Int64(0, 51478)), new Pair.ptr(new $Int64(0, 55291), new $Int64(0, 48897)), new Pair.ptr(new $Int64(0, 55313), new $Int64(0, 18393)), new Pair.ptr(new $Int64(0, 55331), new $Int64(0, 14643)), new Pair.ptr(new $Int64(0, 55333), new $Int64(0, 11536)), new Pair.ptr(new $Int64(0, 55337), new $Int64(0, 28805)), new Pair.ptr(new $Int64(0, 55339), new $Int64(0, 2866)), new Pair.ptr(new $Int64(0, 55343), new $Int64(0, 14132)), new Pair.ptr(new $Int64(0, 55351), new $Int64(0, 52959)), new Pair.ptr(new $Int64(0, 55373), new $Int64(0, 20598)), new Pair.ptr(new $Int64(0, 55381), new $Int64(0, 18340)), new Pair.ptr(new $Int64(0, 55399), new $Int64(0, 20164)), new Pair.ptr(new $Int64(0, 55411), new $Int64(0, 13963)), new Pair.ptr(new $Int64(0, 55439), new $Int64(0, 4265)), new Pair.ptr(new $Int64(0, 55441), new $Int64(0, 21323)), new Pair.ptr(new $Int64(0, 55457), new $Int64(0, 47427)), new Pair.ptr(new $Int64(0, 55469), new $Int64(0, 24424)), new Pair.ptr(new $Int64(0, 55487), new $Int64(0, 37960)), new Pair.ptr(new $Int64(0, 55501), new $Int64(0, 36954)), new Pair.ptr(new $Int64(0, 55511), new $Int64(0, 55090)), new Pair.ptr(new $Int64(0, 55529), new $Int64(0, 23757)), new Pair.ptr(new $Int64(0, 55541), new $Int64(0, 35575)), new Pair.ptr(new $Int64(0, 55547), new $Int64(0, 26875)), new Pair.ptr(new $Int64(0, 55579), new $Int64(0, 3045)), new Pair.ptr(new $Int64(0, 55589), new $Int64(0, 36361)), new Pair.ptr(new $Int64(0, 55603), new $Int64(0, 50906)), new Pair.ptr(new $Int64(0, 55609), new $Int64(0, 5366)), new Pair.ptr(new $Int64(0, 55619), new $Int64(0, 22587)), new Pair.ptr(new $Int64(0, 55621), new $Int64(0, 29477)), new Pair.ptr(new $Int64(0, 55631), new $Int64(0, 49985)), new Pair.ptr(new $Int64(0, 55633), new $Int64(0, 42972)), new Pair.ptr(new $Int64(0, 55639), new $Int64(0, 6022)), new Pair.ptr(new $Int64(0, 55661), new $Int64(0, 49442)), new Pair.ptr(new $Int64(0, 55663), new $Int64(0, 30414)), new Pair.ptr(new $Int64(0, 55667), new $Int64(0, 37388)), new Pair.ptr(new $Int64(0, 55673), new $Int64(0, 50159)), new Pair.ptr(new $Int64(0, 55681), new $Int64(0, 31706)), new Pair.ptr(new $Int64(0, 55691), new $Int64(0, 4557)), new Pair.ptr(new $Int64(0, 55697), new $Int64(0, 48912)), new Pair.ptr(new $Int64(0, 55711), new $Int64(0, 44009)), new Pair.ptr(new $Int64(0, 55717), new $Int64(0, 34504)), new Pair.ptr(new $Int64(0, 55721), new $Int64(0, 13118)), new Pair.ptr(new $Int64(0, 55733), new $Int64(0, 8984)), new Pair.ptr(new $Int64(0, 55763), new $Int64(0, 24183)), new Pair.ptr(new $Int64(0, 55787), new $Int64(0, 48169)), new Pair.ptr(new $Int64(0, 55793), new $Int64(0, 42018)), new Pair.ptr(new $Int64(0, 55799), new $Int64(0, 34840)), new Pair.ptr(new $Int64(0, 55807), new $Int64(0, 26880)), new Pair.ptr(new $Int64(0, 55813), new $Int64(0, 3384)), new Pair.ptr(new $Int64(0, 55817), new $Int64(0, 1230)), new Pair.ptr(new $Int64(0, 55819), new $Int64(0, 46665)), new Pair.ptr(new $Int64(0, 55823), new $Int64(0, 17266)), new Pair.ptr(new $Int64(0, 55829), new $Int64(0, 7739)), new Pair.ptr(new $Int64(0, 55837), new $Int64(0, 34913)), new Pair.ptr(new $Int64(0, 55843), new $Int64(0, 2814)), new Pair.ptr(new $Int64(0, 55849), new $Int64(0, 31333)), new Pair.ptr(new $Int64(0, 55871), new $Int64(0, 14758)), new Pair.ptr(new $Int64(0, 55889), new $Int64(0, 30276)), new Pair.ptr(new $Int64(0, 55897), new $Int64(0, 38999)), new Pair.ptr(new $Int64(0, 55901), new $Int64(0, 29886)), new Pair.ptr(new $Int64(0, 55903), new $Int64(0, 27306)), new Pair.ptr(new $Int64(0, 55921), new $Int64(0, 29217)), new Pair.ptr(new $Int64(0, 55927), new $Int64(0, 29452)), new Pair.ptr(new $Int64(0, 55931), new $Int64(0, 54529)), new Pair.ptr(new $Int64(0, 55933), new $Int64(0, 55357)), new Pair.ptr(new $Int64(0, 55949), new $Int64(0, 9656)), new Pair.ptr(new $Int64(0, 55967), new $Int64(0, 42929)), new Pair.ptr(new $Int64(0, 55987), new $Int64(0, 12117)), new Pair.ptr(new $Int64(0, 55997), new $Int64(0, 55301)), new Pair.ptr(new $Int64(0, 56003), new $Int64(0, 20147)), new Pair.ptr(new $Int64(0, 56009), new $Int64(0, 45840)), new Pair.ptr(new $Int64(0, 56039), new $Int64(0, 14724)), new Pair.ptr(new $Int64(0, 56041), new $Int64(0, 24409)), new Pair.ptr(new $Int64(0, 56053), new $Int64(0, 13702)), new Pair.ptr(new $Int64(0, 56081), new $Int64(0, 18245)), new Pair.ptr(new $Int64(0, 56087), new $Int64(0, 51986)), new Pair.ptr(new $Int64(0, 56093), new $Int64(0, 4447)), new Pair.ptr(new $Int64(0, 56099), new $Int64(0, 38530)), new Pair.ptr(new $Int64(0, 56101), new $Int64(0, 31749)), new Pair.ptr(new $Int64(0, 56113), new $Int64(0, 48500)), new Pair.ptr(new $Int64(0, 56123), new $Int64(0, 12509)), new Pair.ptr(new $Int64(0, 56131), new $Int64(0, 19808)), new Pair.ptr(new $Int64(0, 56149), new $Int64(0, 1127)), new Pair.ptr(new $Int64(0, 56167), new $Int64(0, 15214)), new Pair.ptr(new $Int64(0, 56171), new $Int64(0, 5438)), new Pair.ptr(new $Int64(0, 56179), new $Int64(0, 49267)), new Pair.ptr(new $Int64(0, 56197), new $Int64(0, 45861)), new Pair.ptr(new $Int64(0, 56207), new $Int64(0, 40474)), new Pair.ptr(new $Int64(0, 56209), new $Int64(0, 21259)), new Pair.ptr(new $Int64(0, 56237), new $Int64(0, 10481)), new Pair.ptr(new $Int64(0, 56239), new $Int64(0, 50359)), new Pair.ptr(new $Int64(0, 56249), new $Int64(0, 2487)), new Pair.ptr(new $Int64(0, 56263), new $Int64(0, 17196)), new Pair.ptr(new $Int64(0, 56267), new $Int64(0, 19129)), new Pair.ptr(new $Int64(0, 56269), new $Int64(0, 45931)), new Pair.ptr(new $Int64(0, 56299), new $Int64(0, 45379)), new Pair.ptr(new $Int64(0, 56311), new $Int64(0, 27044)), new Pair.ptr(new $Int64(0, 56333), new $Int64(0, 20730)), new Pair.ptr(new $Int64(0, 56359), new $Int64(0, 45174)), new Pair.ptr(new $Int64(0, 56369), new $Int64(0, 23328)), new Pair.ptr(new $Int64(0, 56377), new $Int64(0, 1768)), new Pair.ptr(new $Int64(0, 56383), new $Int64(0, 48325)), new Pair.ptr(new $Int64(0, 56393), new $Int64(0, 39146)), new Pair.ptr(new $Int64(0, 56401), new $Int64(0, 15607)), new Pair.ptr(new $Int64(0, 56417), new $Int64(0, 31058)), new Pair.ptr(new $Int64(0, 56431), new $Int64(0, 28060)), new Pair.ptr(new $Int64(0, 56437), new $Int64(0, 46226)), new Pair.ptr(new $Int64(0, 56443), new $Int64(0, 11415)), new Pair.ptr(new $Int64(0, 56453), new $Int64(0, 16770)), new Pair.ptr(new $Int64(0, 56467), new $Int64(0, 40539)), new Pair.ptr(new $Int64(0, 56473), new $Int64(0, 42831)), new Pair.ptr(new $Int64(0, 56477), new $Int64(0, 9623)), new Pair.ptr(new $Int64(0, 56479), new $Int64(0, 5323)), new Pair.ptr(new $Int64(0, 56489), new $Int64(0, 18073)), new Pair.ptr(new $Int64(0, 56501), new $Int64(0, 32013)), new Pair.ptr(new $Int64(0, 56503), new $Int64(0, 43517)), new Pair.ptr(new $Int64(0, 56509), new $Int64(0, 53748)), new Pair.ptr(new $Int64(0, 56519), new $Int64(0, 25578)), new Pair.ptr(new $Int64(0, 56527), new $Int64(0, 8)), new Pair.ptr(new $Int64(0, 56531), new $Int64(0, 29531)), new Pair.ptr(new $Int64(0, 56533), new $Int64(0, 45898)), new Pair.ptr(new $Int64(0, 56543), new $Int64(0, 32966)), new Pair.ptr(new $Int64(0, 56569), new $Int64(0, 52364)), new Pair.ptr(new $Int64(0, 56591), new $Int64(0, 52374)), new Pair.ptr(new $Int64(0, 56597), new $Int64(0, 38366)), new Pair.ptr(new $Int64(0, 56599), new $Int64(0, 24898)), new Pair.ptr(new $Int64(0, 56611), new $Int64(0, 22692)), new Pair.ptr(new $Int64(0, 56629), new $Int64(0, 29932)), new Pair.ptr(new $Int64(0, 56633), new $Int64(0, 24433)), new Pair.ptr(new $Int64(0, 56659), new $Int64(0, 8538)), new Pair.ptr(new $Int64(0, 56663), new $Int64(0, 3261)), new Pair.ptr(new $Int64(0, 56671), new $Int64(0, 38653)), new Pair.ptr(new $Int64(0, 56681), new $Int64(0, 36560)), new Pair.ptr(new $Int64(0, 56687), new $Int64(0, 51183)), new Pair.ptr(new $Int64(0, 56701), new $Int64(0, 46193)), new Pair.ptr(new $Int64(0, 56711), new $Int64(0, 32826)), new Pair.ptr(new $Int64(0, 56713), new $Int64(0, 28509)), new Pair.ptr(new $Int64(0, 56731), new $Int64(0, 41726)), new Pair.ptr(new $Int64(0, 56737), new $Int64(0, 21334)), new Pair.ptr(new $Int64(0, 56747), new $Int64(0, 9258)), new Pair.ptr(new $Int64(0, 56767), new $Int64(0, 20764)), new Pair.ptr(new $Int64(0, 56773), new $Int64(0, 46263)), new Pair.ptr(new $Int64(0, 56779), new $Int64(0, 37371)), new Pair.ptr(new $Int64(0, 56783), new $Int64(0, 18584)), new Pair.ptr(new $Int64(0, 56807), new $Int64(0, 28875)), new Pair.ptr(new $Int64(0, 56809), new $Int64(0, 23302)), new Pair.ptr(new $Int64(0, 56813), new $Int64(0, 1496)), new Pair.ptr(new $Int64(0, 56821), new $Int64(0, 10359)), new Pair.ptr(new $Int64(0, 56827), new $Int64(0, 50051)), new Pair.ptr(new $Int64(0, 56843), new $Int64(0, 55827)), new Pair.ptr(new $Int64(0, 56857), new $Int64(0, 43588)), new Pair.ptr(new $Int64(0, 56873), new $Int64(0, 37377)), new Pair.ptr(new $Int64(0, 56891), new $Int64(0, 14317)), new Pair.ptr(new $Int64(0, 56893), new $Int64(0, 47327)), new Pair.ptr(new $Int64(0, 56897), new $Int64(0, 1538)), new Pair.ptr(new $Int64(0, 56909), new $Int64(0, 56611)), new Pair.ptr(new $Int64(0, 56911), new $Int64(0, 497)), new Pair.ptr(new $Int64(0, 56921), new $Int64(0, 48770)), new Pair.ptr(new $Int64(0, 56923), new $Int64(0, 40855)), new Pair.ptr(new $Int64(0, 56929), new $Int64(0, 2991)), new Pair.ptr(new $Int64(0, 56941), new $Int64(0, 31428)), new Pair.ptr(new $Int64(0, 56951), new $Int64(0, 39906)), new Pair.ptr(new $Int64(0, 56957), new $Int64(0, 17557)), new Pair.ptr(new $Int64(0, 56963), new $Int64(0, 3136)), new Pair.ptr(new $Int64(0, 56983), new $Int64(0, 23621)), new Pair.ptr(new $Int64(0, 56989), new $Int64(0, 27845)), new Pair.ptr(new $Int64(0, 56993), new $Int64(0, 44459)), new Pair.ptr(new $Int64(0, 56999), new $Int64(0, 7346)), new Pair.ptr(new $Int64(0, 57037), new $Int64(0, 36575)), new Pair.ptr(new $Int64(0, 57041), new $Int64(0, 19697)), new Pair.ptr(new $Int64(0, 57047), new $Int64(0, 17542)), new Pair.ptr(new $Int64(0, 57059), new $Int64(0, 713)), new Pair.ptr(new $Int64(0, 57073), new $Int64(0, 28804)), new Pair.ptr(new $Int64(0, 57077), new $Int64(0, 46161)), new Pair.ptr(new $Int64(0, 57089), new $Int64(0, 23683)), new Pair.ptr(new $Int64(0, 57097), new $Int64(0, 29512)), new Pair.ptr(new $Int64(0, 57107), new $Int64(0, 46171)), new Pair.ptr(new $Int64(0, 57119), new $Int64(0, 41941)), new Pair.ptr(new $Int64(0, 57131), new $Int64(0, 24879)), new Pair.ptr(new $Int64(0, 57139), new $Int64(0, 32071)), new Pair.ptr(new $Int64(0, 57143), new $Int64(0, 20814)), new Pair.ptr(new $Int64(0, 57149), new $Int64(0, 9178)), new Pair.ptr(new $Int64(0, 57163), new $Int64(0, 8534)), new Pair.ptr(new $Int64(0, 57173), new $Int64(0, 17041)), new Pair.ptr(new $Int64(0, 57179), new $Int64(0, 9854)), new Pair.ptr(new $Int64(0, 57191), new $Int64(0, 7565)), new Pair.ptr(new $Int64(0, 57193), new $Int64(0, 56804)), new Pair.ptr(new $Int64(0, 57203), new $Int64(0, 48123)), new Pair.ptr(new $Int64(0, 57221), new $Int64(0, 1038)), new Pair.ptr(new $Int64(0, 57223), new $Int64(0, 34239)), new Pair.ptr(new $Int64(0, 57241), new $Int64(0, 11036)), new Pair.ptr(new $Int64(0, 57251), new $Int64(0, 18068)), new Pair.ptr(new $Int64(0, 57259), new $Int64(0, 39975)), new Pair.ptr(new $Int64(0, 57269), new $Int64(0, 35057)), new Pair.ptr(new $Int64(0, 57271), new $Int64(0, 49704)), new Pair.ptr(new $Int64(0, 57283), new $Int64(0, 29611)), new Pair.ptr(new $Int64(0, 57287), new $Int64(0, 32610)), new Pair.ptr(new $Int64(0, 57301), new $Int64(0, 47197)), new Pair.ptr(new $Int64(0, 57329), new $Int64(0, 9121)), new Pair.ptr(new $Int64(0, 57331), new $Int64(0, 29968)), new Pair.ptr(new $Int64(0, 57347), new $Int64(0, 4830)), new Pair.ptr(new $Int64(0, 57349), new $Int64(0, 54948)), new Pair.ptr(new $Int64(0, 57367), new $Int64(0, 16456)), new Pair.ptr(new $Int64(0, 57373), new $Int64(0, 6459)), new Pair.ptr(new $Int64(0, 57383), new $Int64(0, 6570)), new Pair.ptr(new $Int64(0, 57389), new $Int64(0, 4974)), new Pair.ptr(new $Int64(0, 57397), new $Int64(0, 35143)), new Pair.ptr(new $Int64(0, 57413), new $Int64(0, 2028)), new Pair.ptr(new $Int64(0, 57427), new $Int64(0, 31418)), new Pair.ptr(new $Int64(0, 57457), new $Int64(0, 11732)), new Pair.ptr(new $Int64(0, 57467), new $Int64(0, 3003)), new Pair.ptr(new $Int64(0, 57487), new $Int64(0, 16835)), new Pair.ptr(new $Int64(0, 57493), new $Int64(0, 45701)), new Pair.ptr(new $Int64(0, 57503), new $Int64(0, 25828)), new Pair.ptr(new $Int64(0, 57527), new $Int64(0, 47114)), new Pair.ptr(new $Int64(0, 57529), new $Int64(0, 14172)), new Pair.ptr(new $Int64(0, 57557), new $Int64(0, 11992)), new Pair.ptr(new $Int64(0, 57559), new $Int64(0, 13590)), new Pair.ptr(new $Int64(0, 57571), new $Int64(0, 15370)), new Pair.ptr(new $Int64(0, 57587), new $Int64(0, 25906)), new Pair.ptr(new $Int64(0, 57593), new $Int64(0, 31061)), new Pair.ptr(new $Int64(0, 57601), new $Int64(0, 54263)), new Pair.ptr(new $Int64(0, 57637), new $Int64(0, 16116)), new Pair.ptr(new $Int64(0, 57641), new $Int64(0, 5278)), new Pair.ptr(new $Int64(0, 57649), new $Int64(0, 1877)), new Pair.ptr(new $Int64(0, 57653), new $Int64(0, 18048)), new Pair.ptr(new $Int64(0, 57667), new $Int64(0, 10061)), new Pair.ptr(new $Int64(0, 57679), new $Int64(0, 34823)), new Pair.ptr(new $Int64(0, 57689), new $Int64(0, 27044)), new Pair.ptr(new $Int64(0, 57697), new $Int64(0, 51898)), new Pair.ptr(new $Int64(0, 57709), new $Int64(0, 19895)), new Pair.ptr(new $Int64(0, 57713), new $Int64(0, 33086)), new Pair.ptr(new $Int64(0, 57719), new $Int64(0, 23238)), new Pair.ptr(new $Int64(0, 57727), new $Int64(0, 39627)), new Pair.ptr(new $Int64(0, 57731), new $Int64(0, 57322)), new Pair.ptr(new $Int64(0, 57737), new $Int64(0, 24171)), new Pair.ptr(new $Int64(0, 57751), new $Int64(0, 34428)), new Pair.ptr(new $Int64(0, 57773), new $Int64(0, 51445)), new Pair.ptr(new $Int64(0, 57781), new $Int64(0, 27851)), new Pair.ptr(new $Int64(0, 57787), new $Int64(0, 22436)), new Pair.ptr(new $Int64(0, 57791), new $Int64(0, 35645)), new Pair.ptr(new $Int64(0, 57793), new $Int64(0, 13983)), new Pair.ptr(new $Int64(0, 57803), new $Int64(0, 21372)), new Pair.ptr(new $Int64(0, 57809), new $Int64(0, 15319)), new Pair.ptr(new $Int64(0, 57829), new $Int64(0, 35939)), new Pair.ptr(new $Int64(0, 57839), new $Int64(0, 23633)), new Pair.ptr(new $Int64(0, 57847), new $Int64(0, 6365)), new Pair.ptr(new $Int64(0, 57853), new $Int64(0, 31076)), new Pair.ptr(new $Int64(0, 57859), new $Int64(0, 45885)), new Pair.ptr(new $Int64(0, 57881), new $Int64(0, 1368)), new Pair.ptr(new $Int64(0, 57899), new $Int64(0, 27851)), new Pair.ptr(new $Int64(0, 57901), new $Int64(0, 33751)), new Pair.ptr(new $Int64(0, 57917), new $Int64(0, 36715)), new Pair.ptr(new $Int64(0, 57923), new $Int64(0, 17713)), new Pair.ptr(new $Int64(0, 57943), new $Int64(0, 43642)), new Pair.ptr(new $Int64(0, 57947), new $Int64(0, 10380)), new Pair.ptr(new $Int64(0, 57973), new $Int64(0, 8264)), new Pair.ptr(new $Int64(0, 57977), new $Int64(0, 28905)), new Pair.ptr(new $Int64(0, 57991), new $Int64(0, 36367)), new Pair.ptr(new $Int64(0, 58013), new $Int64(0, 16480)), new Pair.ptr(new $Int64(0, 58027), new $Int64(0, 30355)), new Pair.ptr(new $Int64(0, 58031), new $Int64(0, 3618)), new Pair.ptr(new $Int64(0, 58043), new $Int64(0, 12705)), new Pair.ptr(new $Int64(0, 58049), new $Int64(0, 32142)), new Pair.ptr(new $Int64(0, 58057), new $Int64(0, 41608)), new Pair.ptr(new $Int64(0, 58061), new $Int64(0, 35159)), new Pair.ptr(new $Int64(0, 58067), new $Int64(0, 39464)), new Pair.ptr(new $Int64(0, 58073), new $Int64(0, 24068)), new Pair.ptr(new $Int64(0, 58099), new $Int64(0, 35686)), new Pair.ptr(new $Int64(0, 58109), new $Int64(0, 26225)), new Pair.ptr(new $Int64(0, 58111), new $Int64(0, 28489)), new Pair.ptr(new $Int64(0, 58129), new $Int64(0, 25121)), new Pair.ptr(new $Int64(0, 58147), new $Int64(0, 39712)), new Pair.ptr(new $Int64(0, 58151), new $Int64(0, 198)), new Pair.ptr(new $Int64(0, 58153), new $Int64(0, 15232)), new Pair.ptr(new $Int64(0, 58169), new $Int64(0, 3153)), new Pair.ptr(new $Int64(0, 58171), new $Int64(0, 42204)), new Pair.ptr(new $Int64(0, 58189), new $Int64(0, 54939)), new Pair.ptr(new $Int64(0, 58193), new $Int64(0, 19060)), new Pair.ptr(new $Int64(0, 58199), new $Int64(0, 34885)), new Pair.ptr(new $Int64(0, 58207), new $Int64(0, 17104)), new Pair.ptr(new $Int64(0, 58211), new $Int64(0, 21046)), new Pair.ptr(new $Int64(0, 58217), new $Int64(0, 43797)), new Pair.ptr(new $Int64(0, 58229), new $Int64(0, 5454)), new Pair.ptr(new $Int64(0, 58231), new $Int64(0, 42742)), new Pair.ptr(new $Int64(0, 58237), new $Int64(0, 20589)), new Pair.ptr(new $Int64(0, 58243), new $Int64(0, 34122)), new Pair.ptr(new $Int64(0, 58271), new $Int64(0, 46594)), new Pair.ptr(new $Int64(0, 58309), new $Int64(0, 12471)), new Pair.ptr(new $Int64(0, 58313), new $Int64(0, 15371)), new Pair.ptr(new $Int64(0, 58321), new $Int64(0, 5651)), new Pair.ptr(new $Int64(0, 58337), new $Int64(0, 47384)), new Pair.ptr(new $Int64(0, 58363), new $Int64(0, 49060)), new Pair.ptr(new $Int64(0, 58367), new $Int64(0, 32700)), new Pair.ptr(new $Int64(0, 58369), new $Int64(0, 26216)), new Pair.ptr(new $Int64(0, 58379), new $Int64(0, 47561)), new Pair.ptr(new $Int64(0, 58391), new $Int64(0, 13382)), new Pair.ptr(new $Int64(0, 58393), new $Int64(0, 35887)), new Pair.ptr(new $Int64(0, 58403), new $Int64(0, 3507)), new Pair.ptr(new $Int64(0, 58411), new $Int64(0, 31933)), new Pair.ptr(new $Int64(0, 58417), new $Int64(0, 33404)), new Pair.ptr(new $Int64(0, 58427), new $Int64(0, 44670)), new Pair.ptr(new $Int64(0, 58439), new $Int64(0, 35204)), new Pair.ptr(new $Int64(0, 58441), new $Int64(0, 55463)), new Pair.ptr(new $Int64(0, 58451), new $Int64(0, 17746)), new Pair.ptr(new $Int64(0, 58453), new $Int64(0, 56216)), new Pair.ptr(new $Int64(0, 58477), new $Int64(0, 50701)), new Pair.ptr(new $Int64(0, 58481), new $Int64(0, 4537)), new Pair.ptr(new $Int64(0, 58511), new $Int64(0, 54677)), new Pair.ptr(new $Int64(0, 58537), new $Int64(0, 21543)), new Pair.ptr(new $Int64(0, 58543), new $Int64(0, 2219)), new Pair.ptr(new $Int64(0, 58549), new $Int64(0, 42294)), new Pair.ptr(new $Int64(0, 58567), new $Int64(0, 56586)), new Pair.ptr(new $Int64(0, 58573), new $Int64(0, 12270)), new Pair.ptr(new $Int64(0, 58579), new $Int64(0, 42184)), new Pair.ptr(new $Int64(0, 58601), new $Int64(0, 24802)), new Pair.ptr(new $Int64(0, 58603), new $Int64(0, 50257)), new Pair.ptr(new $Int64(0, 58613), new $Int64(0, 10795)), new Pair.ptr(new $Int64(0, 58631), new $Int64(0, 30013)), new Pair.ptr(new $Int64(0, 58657), new $Int64(0, 34889)), new Pair.ptr(new $Int64(0, 58661), new $Int64(0, 7862)), new Pair.ptr(new $Int64(0, 58679), new $Int64(0, 14128)), new Pair.ptr(new $Int64(0, 58687), new $Int64(0, 14255)), new Pair.ptr(new $Int64(0, 58693), new $Int64(0, 53691)), new Pair.ptr(new $Int64(0, 58699), new $Int64(0, 26848)), new Pair.ptr(new $Int64(0, 58711), new $Int64(0, 51247)), new Pair.ptr(new $Int64(0, 58727), new $Int64(0, 8613)), new Pair.ptr(new $Int64(0, 58733), new $Int64(0, 30473)), new Pair.ptr(new $Int64(0, 58741), new $Int64(0, 28079)), new Pair.ptr(new $Int64(0, 58757), new $Int64(0, 6020)), new Pair.ptr(new $Int64(0, 58763), new $Int64(0, 52488)), new Pair.ptr(new $Int64(0, 58771), new $Int64(0, 34948)), new Pair.ptr(new $Int64(0, 58787), new $Int64(0, 4364)), new Pair.ptr(new $Int64(0, 58789), new $Int64(0, 40588)), new Pair.ptr(new $Int64(0, 58831), new $Int64(0, 53350)), new Pair.ptr(new $Int64(0, 58889), new $Int64(0, 28489)), new Pair.ptr(new $Int64(0, 58897), new $Int64(0, 36032)), new Pair.ptr(new $Int64(0, 58901), new $Int64(0, 57910)), new Pair.ptr(new $Int64(0, 58907), new $Int64(0, 52393)), new Pair.ptr(new $Int64(0, 58909), new $Int64(0, 2124)), new Pair.ptr(new $Int64(0, 58913), new $Int64(0, 46663)), new Pair.ptr(new $Int64(0, 58921), new $Int64(0, 36082)), new Pair.ptr(new $Int64(0, 58937), new $Int64(0, 3595)), new Pair.ptr(new $Int64(0, 58943), new $Int64(0, 19762)), new Pair.ptr(new $Int64(0, 58963), new $Int64(0, 9863)), new Pair.ptr(new $Int64(0, 58967), new $Int64(0, 4289)), new Pair.ptr(new $Int64(0, 58979), new $Int64(0, 6629)), new Pair.ptr(new $Int64(0, 58991), new $Int64(0, 27840)), new Pair.ptr(new $Int64(0, 58997), new $Int64(0, 29443)), new Pair.ptr(new $Int64(0, 59009), new $Int64(0, 25069)), new Pair.ptr(new $Int64(0, 59011), new $Int64(0, 1547)), new Pair.ptr(new $Int64(0, 59021), new $Int64(0, 28488)), new Pair.ptr(new $Int64(0, 59023), new $Int64(0, 5834)), new Pair.ptr(new $Int64(0, 59029), new $Int64(0, 8674)), new Pair.ptr(new $Int64(0, 59051), new $Int64(0, 56037)), new Pair.ptr(new $Int64(0, 59053), new $Int64(0, 17798)), new Pair.ptr(new $Int64(0, 59063), new $Int64(0, 31131)), new Pair.ptr(new $Int64(0, 59069), new $Int64(0, 54688)), new Pair.ptr(new $Int64(0, 59077), new $Int64(0, 34106)), new Pair.ptr(new $Int64(0, 59083), new $Int64(0, 51554)), new Pair.ptr(new $Int64(0, 59093), new $Int64(0, 13658)), new Pair.ptr(new $Int64(0, 59107), new $Int64(0, 11257)), new Pair.ptr(new $Int64(0, 59113), new $Int64(0, 11704)), new Pair.ptr(new $Int64(0, 59119), new $Int64(0, 18565)), new Pair.ptr(new $Int64(0, 59123), new $Int64(0, 50447)), new Pair.ptr(new $Int64(0, 59141), new $Int64(0, 32209)), new Pair.ptr(new $Int64(0, 59149), new $Int64(0, 56909)), new Pair.ptr(new $Int64(0, 59159), new $Int64(0, 54727)), new Pair.ptr(new $Int64(0, 59167), new $Int64(0, 57875)), new Pair.ptr(new $Int64(0, 59183), new $Int64(0, 37757)), new Pair.ptr(new $Int64(0, 59197), new $Int64(0, 35772)), new Pair.ptr(new $Int64(0, 59207), new $Int64(0, 14125)), new Pair.ptr(new $Int64(0, 59209), new $Int64(0, 58061)), new Pair.ptr(new $Int64(0, 59219), new $Int64(0, 12217)), new Pair.ptr(new $Int64(0, 59221), new $Int64(0, 35822)), new Pair.ptr(new $Int64(0, 59233), new $Int64(0, 55043)), new Pair.ptr(new $Int64(0, 59239), new $Int64(0, 6530)), new Pair.ptr(new $Int64(0, 59243), new $Int64(0, 57829)), new Pair.ptr(new $Int64(0, 59263), new $Int64(0, 41380)), new Pair.ptr(new $Int64(0, 59273), new $Int64(0, 38599)), new Pair.ptr(new $Int64(0, 59281), new $Int64(0, 23096)), new Pair.ptr(new $Int64(0, 59333), new $Int64(0, 18159)), new Pair.ptr(new $Int64(0, 59341), new $Int64(0, 17043)), new Pair.ptr(new $Int64(0, 59351), new $Int64(0, 55877)), new Pair.ptr(new $Int64(0, 59357), new $Int64(0, 7979)), new Pair.ptr(new $Int64(0, 59359), new $Int64(0, 51611)), new Pair.ptr(new $Int64(0, 59369), new $Int64(0, 4167)), new Pair.ptr(new $Int64(0, 59377), new $Int64(0, 43859)), new Pair.ptr(new $Int64(0, 59387), new $Int64(0, 24046)), new Pair.ptr(new $Int64(0, 59393), new $Int64(0, 12867)), new Pair.ptr(new $Int64(0, 59399), new $Int64(0, 23499)), new Pair.ptr(new $Int64(0, 59407), new $Int64(0, 20424)), new Pair.ptr(new $Int64(0, 59417), new $Int64(0, 46896)), new Pair.ptr(new $Int64(0, 59419), new $Int64(0, 33232)), new Pair.ptr(new $Int64(0, 59441), new $Int64(0, 38459)), new Pair.ptr(new $Int64(0, 59443), new $Int64(0, 50146)), new Pair.ptr(new $Int64(0, 59447), new $Int64(0, 10619)), new Pair.ptr(new $Int64(0, 59453), new $Int64(0, 34232)), new Pair.ptr(new $Int64(0, 59467), new $Int64(0, 21009)), new Pair.ptr(new $Int64(0, 59471), new $Int64(0, 47910)), new Pair.ptr(new $Int64(0, 59473), new $Int64(0, 12310)), new Pair.ptr(new $Int64(0, 59497), new $Int64(0, 31228)), new Pair.ptr(new $Int64(0, 59509), new $Int64(0, 59455)), new Pair.ptr(new $Int64(0, 59513), new $Int64(0, 39766)), new Pair.ptr(new $Int64(0, 59539), new $Int64(0, 17656)), new Pair.ptr(new $Int64(0, 59557), new $Int64(0, 13202)), new Pair.ptr(new $Int64(0, 59561), new $Int64(0, 13070)), new Pair.ptr(new $Int64(0, 59567), new $Int64(0, 34979)), new Pair.ptr(new $Int64(0, 59581), new $Int64(0, 50563)), new Pair.ptr(new $Int64(0, 59611), new $Int64(0, 25026)), new Pair.ptr(new $Int64(0, 59617), new $Int64(0, 45823)), new Pair.ptr(new $Int64(0, 59621), new $Int64(0, 13649)), new Pair.ptr(new $Int64(0, 59627), new $Int64(0, 54463)), new Pair.ptr(new $Int64(0, 59629), new $Int64(0, 9477)), new Pair.ptr(new $Int64(0, 59651), new $Int64(0, 948)), new Pair.ptr(new $Int64(0, 59659), new $Int64(0, 56014)), new Pair.ptr(new $Int64(0, 59663), new $Int64(0, 20063)), new Pair.ptr(new $Int64(0, 59669), new $Int64(0, 57151)), new Pair.ptr(new $Int64(0, 59671), new $Int64(0, 26154)), new Pair.ptr(new $Int64(0, 59693), new $Int64(0, 56196)), new Pair.ptr(new $Int64(0, 59699), new $Int64(0, 40764)), new Pair.ptr(new $Int64(0, 59707), new $Int64(0, 40002)), new Pair.ptr(new $Int64(0, 59723), new $Int64(0, 56090)), new Pair.ptr(new $Int64(0, 59729), new $Int64(0, 28060)), new Pair.ptr(new $Int64(0, 59743), new $Int64(0, 6502)), new Pair.ptr(new $Int64(0, 59747), new $Int64(0, 48962)), new Pair.ptr(new $Int64(0, 59753), new $Int64(0, 22675)), new Pair.ptr(new $Int64(0, 59771), new $Int64(0, 24715)), new Pair.ptr(new $Int64(0, 59779), new $Int64(0, 2021)), new Pair.ptr(new $Int64(0, 59791), new $Int64(0, 37675)), new Pair.ptr(new $Int64(0, 59797), new $Int64(0, 7162)), new Pair.ptr(new $Int64(0, 59809), new $Int64(0, 48014)), new Pair.ptr(new $Int64(0, 59833), new $Int64(0, 54166)), new Pair.ptr(new $Int64(0, 59863), new $Int64(0, 50291)), new Pair.ptr(new $Int64(0, 59879), new $Int64(0, 2812)), new Pair.ptr(new $Int64(0, 59887), new $Int64(0, 28905)), new Pair.ptr(new $Int64(0, 59921), new $Int64(0, 17459)), new Pair.ptr(new $Int64(0, 59929), new $Int64(0, 4346)), new Pair.ptr(new $Int64(0, 59951), new $Int64(0, 59676)), new Pair.ptr(new $Int64(0, 59957), new $Int64(0, 38128)), new Pair.ptr(new $Int64(0, 59971), new $Int64(0, 32007)), new Pair.ptr(new $Int64(0, 59981), new $Int64(0, 28472)), new Pair.ptr(new $Int64(0, 59999), new $Int64(0, 40819)), new Pair.ptr(new $Int64(0, 60013), new $Int64(0, 35114)), new Pair.ptr(new $Int64(0, 60017), new $Int64(0, 32800)), new Pair.ptr(new $Int64(0, 60029), new $Int64(0, 18396)), new Pair.ptr(new $Int64(0, 60037), new $Int64(0, 16967)), new Pair.ptr(new $Int64(0, 60041), new $Int64(0, 58461)), new Pair.ptr(new $Int64(0, 60077), new $Int64(0, 58310)), new Pair.ptr(new $Int64(0, 60083), new $Int64(0, 43103)), new Pair.ptr(new $Int64(0, 60089), new $Int64(0, 1036)), new Pair.ptr(new $Int64(0, 60091), new $Int64(0, 41676)), new Pair.ptr(new $Int64(0, 60101), new $Int64(0, 35914)), new Pair.ptr(new $Int64(0, 60103), new $Int64(0, 27256)), new Pair.ptr(new $Int64(0, 60107), new $Int64(0, 24938)), new Pair.ptr(new $Int64(0, 60127), new $Int64(0, 35448)), new Pair.ptr(new $Int64(0, 60133), new $Int64(0, 9473)), new Pair.ptr(new $Int64(0, 60139), new $Int64(0, 31592)), new Pair.ptr(new $Int64(0, 60149), new $Int64(0, 28047)), new Pair.ptr(new $Int64(0, 60161), new $Int64(0, 22337)), new Pair.ptr(new $Int64(0, 60167), new $Int64(0, 3655)), new Pair.ptr(new $Int64(0, 60169), new $Int64(0, 276)), new Pair.ptr(new $Int64(0, 60209), new $Int64(0, 4647)), new Pair.ptr(new $Int64(0, 60217), new $Int64(0, 38163)), new Pair.ptr(new $Int64(0, 60223), new $Int64(0, 57452)), new Pair.ptr(new $Int64(0, 60251), new $Int64(0, 33280)), new Pair.ptr(new $Int64(0, 60257), new $Int64(0, 9635)), new Pair.ptr(new $Int64(0, 60259), new $Int64(0, 13475)), new Pair.ptr(new $Int64(0, 60271), new $Int64(0, 6427)), new Pair.ptr(new $Int64(0, 60289), new $Int64(0, 23826)), new Pair.ptr(new $Int64(0, 60293), new $Int64(0, 19537)), new Pair.ptr(new $Int64(0, 60317), new $Int64(0, 36730)), new Pair.ptr(new $Int64(0, 60331), new $Int64(0, 49979)), new Pair.ptr(new $Int64(0, 60337), new $Int64(0, 44327)), new Pair.ptr(new $Int64(0, 60343), new $Int64(0, 21216)), new Pair.ptr(new $Int64(0, 60353), new $Int64(0, 12050)), new Pair.ptr(new $Int64(0, 60373), new $Int64(0, 10898)), new Pair.ptr(new $Int64(0, 60383), new $Int64(0, 28509)), new Pair.ptr(new $Int64(0, 60397), new $Int64(0, 3674)), new Pair.ptr(new $Int64(0, 60413), new $Int64(0, 19938)), new Pair.ptr(new $Int64(0, 60427), new $Int64(0, 3540)), new Pair.ptr(new $Int64(0, 60443), new $Int64(0, 44267)), new Pair.ptr(new $Int64(0, 60449), new $Int64(0, 33954)), new Pair.ptr(new $Int64(0, 60457), new $Int64(0, 40127)), new Pair.ptr(new $Int64(0, 60493), new $Int64(0, 5239)), new Pair.ptr(new $Int64(0, 60497), new $Int64(0, 50045)), new Pair.ptr(new $Int64(0, 60509), new $Int64(0, 35106)), new Pair.ptr(new $Int64(0, 60521), new $Int64(0, 57961)), new Pair.ptr(new $Int64(0, 60527), new $Int64(0, 35059)), new Pair.ptr(new $Int64(0, 60539), new $Int64(0, 9163)), new Pair.ptr(new $Int64(0, 60589), new $Int64(0, 46673)), new Pair.ptr(new $Int64(0, 60601), new $Int64(0, 26940)), new Pair.ptr(new $Int64(0, 60607), new $Int64(0, 20110)), new Pair.ptr(new $Int64(0, 60611), new $Int64(0, 55)), new Pair.ptr(new $Int64(0, 60617), new $Int64(0, 1578)), new Pair.ptr(new $Int64(0, 60623), new $Int64(0, 28804)), new Pair.ptr(new $Int64(0, 60631), new $Int64(0, 56012)), new Pair.ptr(new $Int64(0, 60637), new $Int64(0, 48394)), new Pair.ptr(new $Int64(0, 60647), new $Int64(0, 48094)), new Pair.ptr(new $Int64(0, 60649), new $Int64(0, 11790)), new Pair.ptr(new $Int64(0, 60659), new $Int64(0, 22937)), new Pair.ptr(new $Int64(0, 60661), new $Int64(0, 757)), new Pair.ptr(new $Int64(0, 60679), new $Int64(0, 21419)), new Pair.ptr(new $Int64(0, 60689), new $Int64(0, 1592)), new Pair.ptr(new $Int64(0, 60703), new $Int64(0, 12792)), new Pair.ptr(new $Int64(0, 60719), new $Int64(0, 20685)), new Pair.ptr(new $Int64(0, 60727), new $Int64(0, 47571)), new Pair.ptr(new $Int64(0, 60733), new $Int64(0, 36142)), new Pair.ptr(new $Int64(0, 60737), new $Int64(0, 40596)), new Pair.ptr(new $Int64(0, 60757), new $Int64(0, 41449)), new Pair.ptr(new $Int64(0, 60761), new $Int64(0, 7931)), new Pair.ptr(new $Int64(0, 60763), new $Int64(0, 52595)), new Pair.ptr(new $Int64(0, 60773), new $Int64(0, 22971)), new Pair.ptr(new $Int64(0, 60779), new $Int64(0, 43323)), new Pair.ptr(new $Int64(0, 60793), new $Int64(0, 9911)), new Pair.ptr(new $Int64(0, 60811), new $Int64(0, 16721)), new Pair.ptr(new $Int64(0, 60821), new $Int64(0, 55666)), new Pair.ptr(new $Int64(0, 60859), new $Int64(0, 19385)), new Pair.ptr(new $Int64(0, 60869), new $Int64(0, 37808)), new Pair.ptr(new $Int64(0, 60887), new $Int64(0, 4307)), new Pair.ptr(new $Int64(0, 60889), new $Int64(0, 33309)), new Pair.ptr(new $Int64(0, 60899), new $Int64(0, 24062)), new Pair.ptr(new $Int64(0, 60901), new $Int64(0, 48337)), new Pair.ptr(new $Int64(0, 60913), new $Int64(0, 46381)), new Pair.ptr(new $Int64(0, 60917), new $Int64(0, 16100)), new Pair.ptr(new $Int64(0, 60919), new $Int64(0, 56132)), new Pair.ptr(new $Int64(0, 60923), new $Int64(0, 24108)), new Pair.ptr(new $Int64(0, 60937), new $Int64(0, 22061)), new Pair.ptr(new $Int64(0, 60943), new $Int64(0, 39996)), new Pair.ptr(new $Int64(0, 60953), new $Int64(0, 1331)), new Pair.ptr(new $Int64(0, 60961), new $Int64(0, 4567)), new Pair.ptr(new $Int64(0, 61001), new $Int64(0, 41845)), new Pair.ptr(new $Int64(0, 61007), new $Int64(0, 48928)), new Pair.ptr(new $Int64(0, 61027), new $Int64(0, 46922)), new Pair.ptr(new $Int64(0, 61031), new $Int64(0, 7951)), new Pair.ptr(new $Int64(0, 61043), new $Int64(0, 25802)), new Pair.ptr(new $Int64(0, 61051), new $Int64(0, 4528)), new Pair.ptr(new $Int64(0, 61057), new $Int64(0, 28875)), new Pair.ptr(new $Int64(0, 61091), new $Int64(0, 52114)), new Pair.ptr(new $Int64(0, 61099), new $Int64(0, 31608)), new Pair.ptr(new $Int64(0, 61121), new $Int64(0, 18175)), new Pair.ptr(new $Int64(0, 61129), new $Int64(0, 32280)), new Pair.ptr(new $Int64(0, 61141), new $Int64(0, 54269)), new Pair.ptr(new $Int64(0, 61151), new $Int64(0, 57816)), new Pair.ptr(new $Int64(0, 61153), new $Int64(0, 56705)), new Pair.ptr(new $Int64(0, 61169), new $Int64(0, 46580)), new Pair.ptr(new $Int64(0, 61211), new $Int64(0, 59004)), new Pair.ptr(new $Int64(0, 61223), new $Int64(0, 23768)), new Pair.ptr(new $Int64(0, 61231), new $Int64(0, 31609)), new Pair.ptr(new $Int64(0, 61253), new $Int64(0, 9935)), new Pair.ptr(new $Int64(0, 61261), new $Int64(0, 27570)), new Pair.ptr(new $Int64(0, 61283), new $Int64(0, 10598)), new Pair.ptr(new $Int64(0, 61291), new $Int64(0, 20588)), new Pair.ptr(new $Int64(0, 61297), new $Int64(0, 2106)), new Pair.ptr(new $Int64(0, 61331), new $Int64(0, 18988)), new Pair.ptr(new $Int64(0, 61333), new $Int64(0, 56780)), new Pair.ptr(new $Int64(0, 61339), new $Int64(0, 21989)), new Pair.ptr(new $Int64(0, 61343), new $Int64(0, 4327)), new Pair.ptr(new $Int64(0, 61357), new $Int64(0, 6552)), new Pair.ptr(new $Int64(0, 61363), new $Int64(0, 55076)), new Pair.ptr(new $Int64(0, 61379), new $Int64(0, 32039)), new Pair.ptr(new $Int64(0, 61381), new $Int64(0, 51600)), new Pair.ptr(new $Int64(0, 61403), new $Int64(0, 27181)), new Pair.ptr(new $Int64(0, 61409), new $Int64(0, 7807)), new Pair.ptr(new $Int64(0, 61417), new $Int64(0, 24689)), new Pair.ptr(new $Int64(0, 61441), new $Int64(0, 46648)), new Pair.ptr(new $Int64(0, 61463), new $Int64(0, 24905)), new Pair.ptr(new $Int64(0, 61469), new $Int64(0, 8398)), new Pair.ptr(new $Int64(0, 61471), new $Int64(0, 50340)), new Pair.ptr(new $Int64(0, 61483), new $Int64(0, 58869)), new Pair.ptr(new $Int64(0, 61487), new $Int64(0, 10492)), new Pair.ptr(new $Int64(0, 61493), new $Int64(0, 14397)), new Pair.ptr(new $Int64(0, 61507), new $Int64(0, 50179)), new Pair.ptr(new $Int64(0, 61511), new $Int64(0, 60430)), new Pair.ptr(new $Int64(0, 61519), new $Int64(0, 35482)), new Pair.ptr(new $Int64(0, 61543), new $Int64(0, 51272)), new Pair.ptr(new $Int64(0, 61547), new $Int64(0, 48654)), new Pair.ptr(new $Int64(0, 61553), new $Int64(0, 2082)), new Pair.ptr(new $Int64(0, 61559), new $Int64(0, 308)), new Pair.ptr(new $Int64(0, 61561), new $Int64(0, 60023)), new Pair.ptr(new $Int64(0, 61583), new $Int64(0, 38919)), new Pair.ptr(new $Int64(0, 61603), new $Int64(0, 4212)), new Pair.ptr(new $Int64(0, 61609), new $Int64(0, 4037)), new Pair.ptr(new $Int64(0, 61613), new $Int64(0, 12517)), new Pair.ptr(new $Int64(0, 61627), new $Int64(0, 41904)), new Pair.ptr(new $Int64(0, 61631), new $Int64(0, 8768)), new Pair.ptr(new $Int64(0, 61637), new $Int64(0, 2990)), new Pair.ptr(new $Int64(0, 61643), new $Int64(0, 8197)), new Pair.ptr(new $Int64(0, 61651), new $Int64(0, 30748)), new Pair.ptr(new $Int64(0, 61657), new $Int64(0, 41909)), new Pair.ptr(new $Int64(0, 61667), new $Int64(0, 2360)), new Pair.ptr(new $Int64(0, 61673), new $Int64(0, 13669)), new Pair.ptr(new $Int64(0, 61681), new $Int64(0, 24524)), new Pair.ptr(new $Int64(0, 61687), new $Int64(0, 44379)), new Pair.ptr(new $Int64(0, 61703), new $Int64(0, 26420)), new Pair.ptr(new $Int64(0, 61717), new $Int64(0, 58011)), new Pair.ptr(new $Int64(0, 61723), new $Int64(0, 10448)), new Pair.ptr(new $Int64(0, 61729), new $Int64(0, 47582)), new Pair.ptr(new $Int64(0, 61751), new $Int64(0, 34016)), new Pair.ptr(new $Int64(0, 61757), new $Int64(0, 9844)), new Pair.ptr(new $Int64(0, 61781), new $Int64(0, 1059)), new Pair.ptr(new $Int64(0, 61813), new $Int64(0, 1957)), new Pair.ptr(new $Int64(0, 61819), new $Int64(0, 13021)), new Pair.ptr(new $Int64(0, 61837), new $Int64(0, 4750)), new Pair.ptr(new $Int64(0, 61843), new $Int64(0, 10839)), new Pair.ptr(new $Int64(0, 61861), new $Int64(0, 14306)), new Pair.ptr(new $Int64(0, 61871), new $Int64(0, 26665)), new Pair.ptr(new $Int64(0, 61879), new $Int64(0, 7501)), new Pair.ptr(new $Int64(0, 61909), new $Int64(0, 39526)), new Pair.ptr(new $Int64(0, 61927), new $Int64(0, 41644)), new Pair.ptr(new $Int64(0, 61933), new $Int64(0, 4745)), new Pair.ptr(new $Int64(0, 61949), new $Int64(0, 17004)), new Pair.ptr(new $Int64(0, 61961), new $Int64(0, 37923)), new Pair.ptr(new $Int64(0, 61967), new $Int64(0, 45736)), new Pair.ptr(new $Int64(0, 61979), new $Int64(0, 53404)), new Pair.ptr(new $Int64(0, 61981), new $Int64(0, 16439)), new Pair.ptr(new $Int64(0, 61987), new $Int64(0, 53543)), new Pair.ptr(new $Int64(0, 61991), new $Int64(0, 35201)), new Pair.ptr(new $Int64(0, 62003), new $Int64(0, 33331)), new Pair.ptr(new $Int64(0, 62011), new $Int64(0, 34025)), new Pair.ptr(new $Int64(0, 62017), new $Int64(0, 40357)), new Pair.ptr(new $Int64(0, 62039), new $Int64(0, 4091)), new Pair.ptr(new $Int64(0, 62047), new $Int64(0, 36332)), new Pair.ptr(new $Int64(0, 62053), new $Int64(0, 19880)), new Pair.ptr(new $Int64(0, 62057), new $Int64(0, 44888)), new Pair.ptr(new $Int64(0, 62071), new $Int64(0, 27702)), new Pair.ptr(new $Int64(0, 62081), new $Int64(0, 599)), new Pair.ptr(new $Int64(0, 62099), new $Int64(0, 14238)), new Pair.ptr(new $Int64(0, 62119), new $Int64(0, 890)), new Pair.ptr(new $Int64(0, 62129), new $Int64(0, 23167)), new Pair.ptr(new $Int64(0, 62131), new $Int64(0, 15)), new Pair.ptr(new $Int64(0, 62137), new $Int64(0, 31248)), new Pair.ptr(new $Int64(0, 62141), new $Int64(0, 31608)), new Pair.ptr(new $Int64(0, 62143), new $Int64(0, 31161)), new Pair.ptr(new $Int64(0, 62171), new $Int64(0, 61420)), new Pair.ptr(new $Int64(0, 62189), new $Int64(0, 54346)), new Pair.ptr(new $Int64(0, 62191), new $Int64(0, 42915)), new Pair.ptr(new $Int64(0, 62201), new $Int64(0, 43041)), new Pair.ptr(new $Int64(0, 62207), new $Int64(0, 1666)), new Pair.ptr(new $Int64(0, 62213), new $Int64(0, 16803)), new Pair.ptr(new $Int64(0, 62219), new $Int64(0, 25951)), new Pair.ptr(new $Int64(0, 62233), new $Int64(0, 53541)), new Pair.ptr(new $Int64(0, 62273), new $Int64(0, 55421)), new Pair.ptr(new $Int64(0, 62297), new $Int64(0, 46493)), new Pair.ptr(new $Int64(0, 62299), new $Int64(0, 11255)), new Pair.ptr(new $Int64(0, 62303), new $Int64(0, 24374)), new Pair.ptr(new $Int64(0, 62311), new $Int64(0, 45799)), new Pair.ptr(new $Int64(0, 62323), new $Int64(0, 30473)), new Pair.ptr(new $Int64(0, 62327), new $Int64(0, 47247)), new Pair.ptr(new $Int64(0, 62347), new $Int64(0, 6829)), new Pair.ptr(new $Int64(0, 62351), new $Int64(0, 35530)), new Pair.ptr(new $Int64(0, 62383), new $Int64(0, 36267)), new Pair.ptr(new $Int64(0, 62401), new $Int64(0, 37278)), new Pair.ptr(new $Int64(0, 62417), new $Int64(0, 39100)), new Pair.ptr(new $Int64(0, 62423), new $Int64(0, 6274)), new Pair.ptr(new $Int64(0, 62459), new $Int64(0, 27923)), new Pair.ptr(new $Int64(0, 62467), new $Int64(0, 42912)), new Pair.ptr(new $Int64(0, 62473), new $Int64(0, 16738)), new Pair.ptr(new $Int64(0, 62477), new $Int64(0, 55459)), new Pair.ptr(new $Int64(0, 62483), new $Int64(0, 45012)), new Pair.ptr(new $Int64(0, 62497), new $Int64(0, 42917)), new Pair.ptr(new $Int64(0, 62501), new $Int64(0, 47151)), new Pair.ptr(new $Int64(0, 62507), new $Int64(0, 44792)), new Pair.ptr(new $Int64(0, 62533), new $Int64(0, 34402)), new Pair.ptr(new $Int64(0, 62539), new $Int64(0, 60155)), new Pair.ptr(new $Int64(0, 62549), new $Int64(0, 45850)), new Pair.ptr(new $Int64(0, 62563), new $Int64(0, 49528)), new Pair.ptr(new $Int64(0, 62581), new $Int64(0, 58423)), new Pair.ptr(new $Int64(0, 62591), new $Int64(0, 47172)), new Pair.ptr(new $Int64(0, 62597), new $Int64(0, 4725)), new Pair.ptr(new $Int64(0, 62603), new $Int64(0, 14266)), new Pair.ptr(new $Int64(0, 62617), new $Int64(0, 34492)), new Pair.ptr(new $Int64(0, 62627), new $Int64(0, 12845)), new Pair.ptr(new $Int64(0, 62633), new $Int64(0, 44291)), new Pair.ptr(new $Int64(0, 62639), new $Int64(0, 36420)), new Pair.ptr(new $Int64(0, 62653), new $Int64(0, 59379)), new Pair.ptr(new $Int64(0, 62659), new $Int64(0, 25905)), new Pair.ptr(new $Int64(0, 62683), new $Int64(0, 466)), new Pair.ptr(new $Int64(0, 62687), new $Int64(0, 49837)), new Pair.ptr(new $Int64(0, 62701), new $Int64(0, 32039)), new Pair.ptr(new $Int64(0, 62723), new $Int64(0, 24319)), new Pair.ptr(new $Int64(0, 62731), new $Int64(0, 57294)), new Pair.ptr(new $Int64(0, 62743), new $Int64(0, 58101)), new Pair.ptr(new $Int64(0, 62753), new $Int64(0, 44752)), new Pair.ptr(new $Int64(0, 62761), new $Int64(0, 54547)), new Pair.ptr(new $Int64(0, 62773), new $Int64(0, 57486)), new Pair.ptr(new $Int64(0, 62791), new $Int64(0, 52801)), new Pair.ptr(new $Int64(0, 62801), new $Int64(0, 56443)), new Pair.ptr(new $Int64(0, 62819), new $Int64(0, 11077)), new Pair.ptr(new $Int64(0, 62827), new $Int64(0, 20878)), new Pair.ptr(new $Int64(0, 62851), new $Int64(0, 24377)), new Pair.ptr(new $Int64(0, 62861), new $Int64(0, 18975)), new Pair.ptr(new $Int64(0, 62869), new $Int64(0, 43028)), new Pair.ptr(new $Int64(0, 62873), new $Int64(0, 62236)), new Pair.ptr(new $Int64(0, 62897), new $Int64(0, 25263)), new Pair.ptr(new $Int64(0, 62903), new $Int64(0, 36297)), new Pair.ptr(new $Int64(0, 62921), new $Int64(0, 56928)), new Pair.ptr(new $Int64(0, 62927), new $Int64(0, 428)), new Pair.ptr(new $Int64(0, 62929), new $Int64(0, 54605)), new Pair.ptr(new $Int64(0, 62939), new $Int64(0, 9149)), new Pair.ptr(new $Int64(0, 62969), new $Int64(0, 12912)), new Pair.ptr(new $Int64(0, 62971), new $Int64(0, 52858)), new Pair.ptr(new $Int64(0, 62981), new $Int64(0, 27631)), new Pair.ptr(new $Int64(0, 62983), new $Int64(0, 55366)), new Pair.ptr(new $Int64(0, 62987), new $Int64(0, 8640)), new Pair.ptr(new $Int64(0, 62989), new $Int64(0, 35559)), new Pair.ptr(new $Int64(0, 63029), new $Int64(0, 34805)), new Pair.ptr(new $Int64(0, 63031), new $Int64(0, 36883)), new Pair.ptr(new $Int64(0, 63059), new $Int64(0, 16159)), new Pair.ptr(new $Int64(0, 63067), new $Int64(0, 56366)), new Pair.ptr(new $Int64(0, 63073), new $Int64(0, 43678)), new Pair.ptr(new $Int64(0, 63079), new $Int64(0, 41297)), new Pair.ptr(new $Int64(0, 63097), new $Int64(0, 37719)), new Pair.ptr(new $Int64(0, 63103), new $Int64(0, 4220)), new Pair.ptr(new $Int64(0, 63113), new $Int64(0, 22626)), new Pair.ptr(new $Int64(0, 63127), new $Int64(0, 13883)), new Pair.ptr(new $Int64(0, 63131), new $Int64(0, 32285)), new Pair.ptr(new $Int64(0, 63149), new $Int64(0, 32474)), new Pair.ptr(new $Int64(0, 63179), new $Int64(0, 28308)), new Pair.ptr(new $Int64(0, 63197), new $Int64(0, 17839)), new Pair.ptr(new $Int64(0, 63199), new $Int64(0, 9050)), new Pair.ptr(new $Int64(0, 63211), new $Int64(0, 331)), new Pair.ptr(new $Int64(0, 63241), new $Int64(0, 21859)), new Pair.ptr(new $Int64(0, 63247), new $Int64(0, 21681)), new Pair.ptr(new $Int64(0, 63277), new $Int64(0, 1131)), new Pair.ptr(new $Int64(0, 63281), new $Int64(0, 54725)), new Pair.ptr(new $Int64(0, 63299), new $Int64(0, 51759)), new Pair.ptr(new $Int64(0, 63311), new $Int64(0, 37342)), new Pair.ptr(new $Int64(0, 63313), new $Int64(0, 31131)), new Pair.ptr(new $Int64(0, 63317), new $Int64(0, 49563)), new Pair.ptr(new $Int64(0, 63331), new $Int64(0, 38229)), new Pair.ptr(new $Int64(0, 63337), new $Int64(0, 42608)), new Pair.ptr(new $Int64(0, 63347), new $Int64(0, 11727)), new Pair.ptr(new $Int64(0, 63353), new $Int64(0, 40180)), new Pair.ptr(new $Int64(0, 63361), new $Int64(0, 57094)), new Pair.ptr(new $Int64(0, 63367), new $Int64(0, 43372)), new Pair.ptr(new $Int64(0, 63377), new $Int64(0, 43057)), new Pair.ptr(new $Int64(0, 63389), new $Int64(0, 16766)), new Pair.ptr(new $Int64(0, 63391), new $Int64(0, 10876)), new Pair.ptr(new $Int64(0, 63397), new $Int64(0, 36980)), new Pair.ptr(new $Int64(0, 63409), new $Int64(0, 26706)), new Pair.ptr(new $Int64(0, 63419), new $Int64(0, 11753)), new Pair.ptr(new $Int64(0, 63421), new $Int64(0, 35258)), new Pair.ptr(new $Int64(0, 63439), new $Int64(0, 22520)), new Pair.ptr(new $Int64(0, 63443), new $Int64(0, 34422)), new Pair.ptr(new $Int64(0, 63463), new $Int64(0, 47863)), new Pair.ptr(new $Int64(0, 63467), new $Int64(0, 46748)), new Pair.ptr(new $Int64(0, 63473), new $Int64(0, 38227)), new Pair.ptr(new $Int64(0, 63487), new $Int64(0, 36097)), new Pair.ptr(new $Int64(0, 63493), new $Int64(0, 53515)), new Pair.ptr(new $Int64(0, 63499), new $Int64(0, 60000)), new Pair.ptr(new $Int64(0, 63521), new $Int64(0, 35578)), new Pair.ptr(new $Int64(0, 63527), new $Int64(0, 34512)), new Pair.ptr(new $Int64(0, 63533), new $Int64(0, 23443)), new Pair.ptr(new $Int64(0, 63541), new $Int64(0, 21804)), new Pair.ptr(new $Int64(0, 63559), new $Int64(0, 59263)), new Pair.ptr(new $Int64(0, 63577), new $Int64(0, 26510)), new Pair.ptr(new $Int64(0, 63587), new $Int64(0, 11962)), new Pair.ptr(new $Int64(0, 63589), new $Int64(0, 30371)), new Pair.ptr(new $Int64(0, 63599), new $Int64(0, 43840)), new Pair.ptr(new $Int64(0, 63601), new $Int64(0, 34818)), new Pair.ptr(new $Int64(0, 63607), new $Int64(0, 5855)), new Pair.ptr(new $Int64(0, 63611), new $Int64(0, 3108)), new Pair.ptr(new $Int64(0, 63617), new $Int64(0, 14621)), new Pair.ptr(new $Int64(0, 63629), new $Int64(0, 29479)), new Pair.ptr(new $Int64(0, 63647), new $Int64(0, 15375)), new Pair.ptr(new $Int64(0, 63649), new $Int64(0, 16697)), new Pair.ptr(new $Int64(0, 63659), new $Int64(0, 29477)), new Pair.ptr(new $Int64(0, 63667), new $Int64(0, 44754)), new Pair.ptr(new $Int64(0, 63671), new $Int64(0, 43279)), new Pair.ptr(new $Int64(0, 63689), new $Int64(0, 32020)), new Pair.ptr(new $Int64(0, 63691), new $Int64(0, 3324)), new Pair.ptr(new $Int64(0, 63697), new $Int64(0, 19624)), new Pair.ptr(new $Int64(0, 63703), new $Int64(0, 28634)), new Pair.ptr(new $Int64(0, 63709), new $Int64(0, 33356)), new Pair.ptr(new $Int64(0, 63719), new $Int64(0, 46087)), new Pair.ptr(new $Int64(0, 63727), new $Int64(0, 19490)), new Pair.ptr(new $Int64(0, 63737), new $Int64(0, 9109)), new Pair.ptr(new $Int64(0, 63743), new $Int64(0, 61744)), new Pair.ptr(new $Int64(0, 63761), new $Int64(0, 12654)), new Pair.ptr(new $Int64(0, 63773), new $Int64(0, 19709)), new Pair.ptr(new $Int64(0, 63781), new $Int64(0, 26474)), new Pair.ptr(new $Int64(0, 63793), new $Int64(0, 59854)), new Pair.ptr(new $Int64(0, 63799), new $Int64(0, 25006)), new Pair.ptr(new $Int64(0, 63803), new $Int64(0, 3895)), new Pair.ptr(new $Int64(0, 63809), new $Int64(0, 33164)), new Pair.ptr(new $Int64(0, 63823), new $Int64(0, 10134)), new Pair.ptr(new $Int64(0, 63839), new $Int64(0, 54911)), new Pair.ptr(new $Int64(0, 63841), new $Int64(0, 41072)), new Pair.ptr(new $Int64(0, 63853), new $Int64(0, 42145)), new Pair.ptr(new $Int64(0, 63857), new $Int64(0, 44340)), new Pair.ptr(new $Int64(0, 63863), new $Int64(0, 932)), new Pair.ptr(new $Int64(0, 63901), new $Int64(0, 51931)), new Pair.ptr(new $Int64(0, 63907), new $Int64(0, 46838)), new Pair.ptr(new $Int64(0, 63913), new $Int64(0, 17890)), new Pair.ptr(new $Int64(0, 63929), new $Int64(0, 29139)), new Pair.ptr(new $Int64(0, 63949), new $Int64(0, 57758)), new Pair.ptr(new $Int64(0, 63977), new $Int64(0, 15982)), new Pair.ptr(new $Int64(0, 63997), new $Int64(0, 49733)), new Pair.ptr(new $Int64(0, 64007), new $Int64(0, 8684)), new Pair.ptr(new $Int64(0, 64013), new $Int64(0, 21254)), new Pair.ptr(new $Int64(0, 64019), new $Int64(0, 27789)), new Pair.ptr(new $Int64(0, 64033), new $Int64(0, 4682)), new Pair.ptr(new $Int64(0, 64037), new $Int64(0, 13598)), new Pair.ptr(new $Int64(0, 64063), new $Int64(0, 17084)), new Pair.ptr(new $Int64(0, 64067), new $Int64(0, 48406)), new Pair.ptr(new $Int64(0, 64081), new $Int64(0, 47244)), new Pair.ptr(new $Int64(0, 64091), new $Int64(0, 59027)), new Pair.ptr(new $Int64(0, 64109), new $Int64(0, 32007)), new Pair.ptr(new $Int64(0, 64123), new $Int64(0, 797)), new Pair.ptr(new $Int64(0, 64151), new $Int64(0, 56679)), new Pair.ptr(new $Int64(0, 64153), new $Int64(0, 14945)), new Pair.ptr(new $Int64(0, 64157), new $Int64(0, 9842)), new Pair.ptr(new $Int64(0, 64171), new $Int64(0, 53096)), new Pair.ptr(new $Int64(0, 64187), new $Int64(0, 661)), new Pair.ptr(new $Int64(0, 64189), new $Int64(0, 1609)), new Pair.ptr(new $Int64(0, 64217), new $Int64(0, 32850)), new Pair.ptr(new $Int64(0, 64223), new $Int64(0, 19415)), new Pair.ptr(new $Int64(0, 64231), new $Int64(0, 29436)), new Pair.ptr(new $Int64(0, 64237), new $Int64(0, 56786)), new Pair.ptr(new $Int64(0, 64271), new $Int64(0, 28213)), new Pair.ptr(new $Int64(0, 64279), new $Int64(0, 62824)), new Pair.ptr(new $Int64(0, 64283), new $Int64(0, 24089)), new Pair.ptr(new $Int64(0, 64301), new $Int64(0, 10545)), new Pair.ptr(new $Int64(0, 64303), new $Int64(0, 62886)), new Pair.ptr(new $Int64(0, 64319), new $Int64(0, 26602)), new Pair.ptr(new $Int64(0, 64327), new $Int64(0, 15882)), new Pair.ptr(new $Int64(0, 64333), new $Int64(0, 8785)), new Pair.ptr(new $Int64(0, 64373), new $Int64(0, 7097)), new Pair.ptr(new $Int64(0, 64381), new $Int64(0, 42352)), new Pair.ptr(new $Int64(0, 64399), new $Int64(0, 49238)), new Pair.ptr(new $Int64(0, 64403), new $Int64(0, 24520)), new Pair.ptr(new $Int64(0, 64433), new $Int64(0, 20267)), new Pair.ptr(new $Int64(0, 64439), new $Int64(0, 27746)), new Pair.ptr(new $Int64(0, 64451), new $Int64(0, 21628)), new Pair.ptr(new $Int64(0, 64453), new $Int64(0, 21164)), new Pair.ptr(new $Int64(0, 64483), new $Int64(0, 26891)), new Pair.ptr(new $Int64(0, 64489), new $Int64(0, 6545)), new Pair.ptr(new $Int64(0, 64499), new $Int64(0, 30317)), new Pair.ptr(new $Int64(0, 64513), new $Int64(0, 22376)), new Pair.ptr(new $Int64(0, 64553), new $Int64(0, 41328)), new Pair.ptr(new $Int64(0, 64567), new $Int64(0, 9362)), new Pair.ptr(new $Int64(0, 64577), new $Int64(0, 3810)), new Pair.ptr(new $Int64(0, 64579), new $Int64(0, 23215)), new Pair.ptr(new $Int64(0, 64591), new $Int64(0, 36957)), new Pair.ptr(new $Int64(0, 64601), new $Int64(0, 38119)), new Pair.ptr(new $Int64(0, 64609), new $Int64(0, 490)), new Pair.ptr(new $Int64(0, 64613), new $Int64(0, 63797)), new Pair.ptr(new $Int64(0, 64621), new $Int64(0, 51225)), new Pair.ptr(new $Int64(0, 64627), new $Int64(0, 54403)), new Pair.ptr(new $Int64(0, 64633), new $Int64(0, 20416)), new Pair.ptr(new $Int64(0, 64661), new $Int64(0, 25655)), new Pair.ptr(new $Int64(0, 64663), new $Int64(0, 9363)), new Pair.ptr(new $Int64(0, 64667), new $Int64(0, 18367)), new Pair.ptr(new $Int64(0, 64679), new $Int64(0, 39803)), new Pair.ptr(new $Int64(0, 64693), new $Int64(0, 51295)), new Pair.ptr(new $Int64(0, 64709), new $Int64(0, 48403)), new Pair.ptr(new $Int64(0, 64717), new $Int64(0, 1480)), new Pair.ptr(new $Int64(0, 64747), new $Int64(0, 40662)), new Pair.ptr(new $Int64(0, 64763), new $Int64(0, 42255)), new Pair.ptr(new $Int64(0, 64781), new $Int64(0, 61426)), new Pair.ptr(new $Int64(0, 64783), new $Int64(0, 31061)), new Pair.ptr(new $Int64(0, 64793), new $Int64(0, 40446)), new Pair.ptr(new $Int64(0, 64811), new $Int64(0, 22720)), new Pair.ptr(new $Int64(0, 64817), new $Int64(0, 35229)), new Pair.ptr(new $Int64(0, 64849), new $Int64(0, 11246)), new Pair.ptr(new $Int64(0, 64853), new $Int64(0, 11102)), new Pair.ptr(new $Int64(0, 64871), new $Int64(0, 43317)), new Pair.ptr(new $Int64(0, 64877), new $Int64(0, 12869)), new Pair.ptr(new $Int64(0, 64879), new $Int64(0, 56929)), new Pair.ptr(new $Int64(0, 64891), new $Int64(0, 54340)), new Pair.ptr(new $Int64(0, 64901), new $Int64(0, 62642)), new Pair.ptr(new $Int64(0, 64919), new $Int64(0, 61158)), new Pair.ptr(new $Int64(0, 64921), new $Int64(0, 2010)), new Pair.ptr(new $Int64(0, 64927), new $Int64(0, 49499)), new Pair.ptr(new $Int64(0, 64937), new $Int64(0, 12070)), new Pair.ptr(new $Int64(0, 64951), new $Int64(0, 26327)), new Pair.ptr(new $Int64(0, 64969), new $Int64(0, 20613)), new Pair.ptr(new $Int64(0, 64997), new $Int64(0, 40424)), new Pair.ptr(new $Int64(0, 65003), new $Int64(0, 3189)), new Pair.ptr(new $Int64(0, 65011), new $Int64(0, 36970)), new Pair.ptr(new $Int64(0, 65027), new $Int64(0, 41141)), new Pair.ptr(new $Int64(0, 65029), new $Int64(0, 16182)), new Pair.ptr(new $Int64(0, 65033), new $Int64(0, 23964)), new Pair.ptr(new $Int64(0, 65053), new $Int64(0, 53985)), new Pair.ptr(new $Int64(0, 65063), new $Int64(0, 50153)), new Pair.ptr(new $Int64(0, 65071), new $Int64(0, 30276)), new Pair.ptr(new $Int64(0, 65089), new $Int64(0, 1469)), new Pair.ptr(new $Int64(0, 65099), new $Int64(0, 24811)), new Pair.ptr(new $Int64(0, 65101), new $Int64(0, 43476)), new Pair.ptr(new $Int64(0, 65111), new $Int64(0, 57267)), new Pair.ptr(new $Int64(0, 65119), new $Int64(0, 22661)), new Pair.ptr(new $Int64(0, 65123), new $Int64(0, 42620)), new Pair.ptr(new $Int64(0, 65129), new $Int64(0, 212)), new Pair.ptr(new $Int64(0, 65141), new $Int64(0, 64891)), new Pair.ptr(new $Int64(0, 65147), new $Int64(0, 45252)), new Pair.ptr(new $Int64(0, 65167), new $Int64(0, 64395)), new Pair.ptr(new $Int64(0, 65171), new $Int64(0, 18419)), new Pair.ptr(new $Int64(0, 65173), new $Int64(0, 34422)), new Pair.ptr(new $Int64(0, 65179), new $Int64(0, 33328)), new Pair.ptr(new $Int64(0, 65183), new $Int64(0, 58255)), new Pair.ptr(new $Int64(0, 65203), new $Int64(0, 10060)), new Pair.ptr(new $Int64(0, 65213), new $Int64(0, 51425)), new Pair.ptr(new $Int64(0, 65239), new $Int64(0, 5171)), new Pair.ptr(new $Int64(0, 65257), new $Int64(0, 34512)), new Pair.ptr(new $Int64(0, 65267), new $Int64(0, 54268)), new Pair.ptr(new $Int64(0, 65269), new $Int64(0, 55364)), new Pair.ptr(new $Int64(0, 65287), new $Int64(0, 35229)), new Pair.ptr(new $Int64(0, 65293), new $Int64(0, 56141)), new Pair.ptr(new $Int64(0, 65309), new $Int64(0, 49439)), new Pair.ptr(new $Int64(0, 65323), new $Int64(0, 16278)), new Pair.ptr(new $Int64(0, 65327), new $Int64(0, 15324)), new Pair.ptr(new $Int64(0, 65353), new $Int64(0, 11242)), new Pair.ptr(new $Int64(0, 65357), new $Int64(0, 5978)), new Pair.ptr(new $Int64(0, 65371), new $Int64(0, 63297)), new Pair.ptr(new $Int64(0, 65381), new $Int64(0, 16078)), new Pair.ptr(new $Int64(0, 65393), new $Int64(0, 62444)), new Pair.ptr(new $Int64(0, 65407), new $Int64(0, 52936)), new Pair.ptr(new $Int64(0, 65413), new $Int64(0, 58466)), new Pair.ptr(new $Int64(0, 65419), new $Int64(0, 32209)), new Pair.ptr(new $Int64(0, 65423), new $Int64(0, 22196)), new Pair.ptr(new $Int64(0, 65437), new $Int64(0, 8099)), new Pair.ptr(new $Int64(0, 65447), new $Int64(0, 52162)), new Pair.ptr(new $Int64(0, 65449), new $Int64(0, 65030)), new Pair.ptr(new $Int64(0, 65479), new $Int64(0, 23375)), new Pair.ptr(new $Int64(0, 65497), new $Int64(0, 39350)), new Pair.ptr(new $Int64(0, 65519), new $Int64(0, 53607)), new Pair.ptr(new $Int64(0, 65521), new $Int64(0, 59564))]); - m = 120120; - bigOne = big.NewInt(new $Int64(0, 1)); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["crypto/rand"] = (function() { - var $pkg = {}, $init, errors, js, io, big, rngReader, sliceType, ptrType$1, smallPrimesProduct, init; - errors = $packages["errors"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - io = $packages["io"]; - big = $packages["math/big"]; - rngReader = $pkg.rngReader = $newType(0, $kindStruct, "rand.rngReader", true, "crypto/rand", false, function() { - this.$val = this; - if (arguments.length === 0) { - return; - } - }); - sliceType = $sliceType($Uint8); - ptrType$1 = $ptrType(rngReader); - init = function() { - $pkg.Reader = new rngReader.ptr(); - }; - rngReader.ptr.prototype.Read = function(b) { - var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, array, b, crypto, err, n, offset, r, randomBytes, require; - n = 0; - err = $ifaceNil; - r = this; - array = b.$array; - offset = $parseInt(b.$offset) >> 0; - crypto = $global.crypto; - if (crypto === undefined) { - crypto = $global.msCrypto; - } - if (!(crypto === undefined)) { - if (!(crypto.getRandomValues === undefined)) { - n = b.$length; - if (n > 65536) { - n = 65536; - } - crypto.getRandomValues(array.subarray(offset, offset + n >> 0)); - _tmp = n; - _tmp$1 = $ifaceNil; - n = _tmp; - err = _tmp$1; - return [n, err]; - } - } - require = $global.require; - if (!(require === undefined)) { - randomBytes = require($externalize("crypto", $String)).randomBytes; - if (!(randomBytes === undefined)) { - array.set(randomBytes(b.$length), offset); - _tmp$2 = b.$length; - _tmp$3 = $ifaceNil; - n = _tmp$2; - err = _tmp$3; - return [n, err]; - } - } - _tmp$4 = 0; - _tmp$5 = errors.New("crypto/rand not available in this environment"); - n = _tmp$4; - err = _tmp$5; - return [n, err]; - }; - rngReader.prototype.Read = function(b) { return this.$val.Read(b); }; - ptrType$1.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]; - rngReader.init("", []); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = big.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.Reader = $ifaceNil; - smallPrimesProduct = new big.Int.ptr(false, big.nat.nil).SetUint64(new $Uint64(3793877372, 820596253)); - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["context"] = (function() { - var $pkg = {}, $init, errors, fmt, reflect, sync, time, emptyCtx, ptrType, structType, ptrType$1, chanType, background, todo, closedchan, init; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - reflect = $packages["reflect"]; - sync = $packages["sync"]; - time = $packages["time"]; - emptyCtx = $pkg.emptyCtx = $newType(4, $kindInt, "context.emptyCtx", true, "context", false, null); - ptrType = $ptrType(emptyCtx); - structType = $structType("", []); - ptrType$1 = $ptrType(time.Location); - chanType = $chanType(structType, false, true); - $ptrType(emptyCtx).prototype.Deadline = function() { - var deadline, ok; - deadline = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$1.nil); - ok = false; - return [deadline, ok]; - }; - $ptrType(emptyCtx).prototype.Done = function() { - return $chanNil; - }; - $ptrType(emptyCtx).prototype.Err = function() { - return $ifaceNil; - }; - $ptrType(emptyCtx).prototype.Value = function(key) { - var key; - return $ifaceNil; - }; - $ptrType(emptyCtx).prototype.String = function() { - var _1, e; - e = this; - _1 = e; - if (_1 === (background)) { - return "context.Background"; - } else if (_1 === (todo)) { - return "context.TODO"; - } - return "unknown empty Context"; - }; - init = function() { - $close(closedchan); - }; - ptrType.methods = [{prop: "Deadline", name: "Deadline", pkg: "", typ: $funcType([], [time.Time, $Bool], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = reflect.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.Canceled = errors.New("context canceled"); - background = $newDataPointer(0, ptrType); - todo = $newDataPointer(0, ptrType); - closedchan = new $Chan(structType, 0); - init(); - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["database/sql/driver"] = (function() { - var $pkg = {}, $init, context, errors, fmt, reflect, strconv, time, Value, Valuer, ptrType, valuerReflectType, _r; - context = $packages["context"]; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - reflect = $packages["reflect"]; - strconv = $packages["strconv"]; - time = $packages["time"]; - Value = $pkg.Value = $newType(8, $kindInterface, "driver.Value", true, "database/sql/driver", true, null); - Valuer = $pkg.Valuer = $newType(8, $kindInterface, "driver.Valuer", true, "database/sql/driver", true, null); - ptrType = $ptrType(Valuer); - Value.init([]); - Valuer.init([{prop: "Value", name: "Value", pkg: "", typ: $funcType([], [Value, $error], false)}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = context.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = strconv.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.ErrSkip = errors.New("driver: skip fast-path; continue as if unimplemented"); - $pkg.ErrBadConn = errors.New("driver: bad connection"); - $pkg.ErrRemoveArgument = errors.New("driver: remove argument from query"); - _r = reflect.TypeOf((ptrType.nil)).Elem(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - valuerReflectType = _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["github.com/segmentio/ksuid"] = (function() { - var $pkg = {}, $init, bytes, rand, driver, binary, errors, fmt, io, math, rand$1, sync, time, KSUID, randSourceReader, uint128, arrayType, arrayType$1, sliceType, sliceType$1, arrayType$2, sliceType$2, arrayType$3, ptrType, arrayType$4, arrayType$5, ptrType$1, errShortBuffer, rander, randMutex, randBuffer, errSize, errStrSize, errStrValue, errPayloadSize, _r, _r$1, _r$2, _r$3, _r$4, base62Value, fastEncodeBase62, fastAppendEncodeBase62, fastDecodeBase62, reserve, Parse, timeToCorrectedUTCTimestamp, correctedUTCTimestampToTime, NewRandom, NewRandomWithTime, FromBytes, newRBG, newRandomBitsGenerator, readCryptoRandomSeed, uint128Payload, makeUint128, makeUint128FromPayload, add128, sub128; - bytes = $packages["bytes"]; - rand = $packages["crypto/rand"]; - driver = $packages["database/sql/driver"]; - binary = $packages["encoding/binary"]; - errors = $packages["errors"]; - fmt = $packages["fmt"]; - io = $packages["io"]; - math = $packages["math"]; - rand$1 = $packages["math/rand"]; - sync = $packages["sync"]; - time = $packages["time"]; - KSUID = $pkg.KSUID = $newType(20, $kindArray, "ksuid.KSUID", true, "github.com/segmentio/ksuid", true, null); - randSourceReader = $pkg.randSourceReader = $newType(0, $kindStruct, "ksuid.randSourceReader", true, "github.com/segmentio/ksuid", false, function(source_) { - this.$val = this; - if (arguments.length === 0) { - this.source = $ifaceNil; - return; - } - this.source = source_; - }); - uint128 = $pkg.uint128 = $newType(16, $kindArray, "ksuid.uint128", true, "github.com/segmentio/ksuid", false, null); - arrayType = $arrayType($Uint8, 20); - arrayType$1 = $arrayType($Uint8, 16); - sliceType = $sliceType($emptyInterface); - sliceType$1 = $sliceType($Uint32); - arrayType$2 = $arrayType($Uint32, 5); - sliceType$2 = $sliceType($Uint8); - arrayType$3 = $arrayType($Uint8, 27); - ptrType = $ptrType(KSUID); - arrayType$4 = $arrayType($Uint8, 8); - arrayType$5 = $arrayType($Uint64, 2); - ptrType$1 = $ptrType(randSourceReader); - base62Value = function(digit) { - var digit; - if (digit >= 48 && digit <= 57) { - return digit - 48 << 24 >>> 24; - } else if (digit >= 65 && digit <= 90) { - return 10 + ((digit - 65 << 24 >>> 24)) << 24 >>> 24; - } else { - return 36 + ((digit - 97 << 24 >>> 24)) << 24 >>> 24; - } - }; - fastEncodeBase62 = function(dst, src) { - var _i, _ref, bp, bq, c, digit, dst, n, parts, quotient, remainder, src, value, x, x$1; - parts = $toNativeArray($kindUint32, [(((((((((0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0]) >>> 0)) << 24 >>> 0) | ((((1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2]) >>> 0)) << 8 >>> 0)) >>> 0) | (((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3]) >>> 0))) >>> 0, (((((((((4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4]) >>> 0)) << 24 >>> 0) | ((((5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6]) >>> 0)) << 8 >>> 0)) >>> 0) | (((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7]) >>> 0))) >>> 0, (((((((((8 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 8]) >>> 0)) << 24 >>> 0) | ((((9 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 9]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((10 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 10]) >>> 0)) << 8 >>> 0)) >>> 0) | (((11 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 11]) >>> 0))) >>> 0, (((((((((12 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 12]) >>> 0)) << 24 >>> 0) | ((((13 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 13]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((14 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 14]) >>> 0)) << 8 >>> 0)) >>> 0) | (((15 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 15]) >>> 0))) >>> 0, (((((((((16 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 16]) >>> 0)) << 24 >>> 0) | ((((17 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 17]) >>> 0)) << 16 >>> 0)) >>> 0) | ((((18 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 18]) >>> 0)) << 8 >>> 0)) >>> 0) | (((19 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 19]) >>> 0))) >>> 0]); - n = dst.$length; - bp = new sliceType$1(parts); - bq = arrayType$2.zero(); - while (true) { - if (!(!((bp.$length === 0)))) { break; } - quotient = $subslice(new sliceType$1(bq), 0, 0); - remainder = new $Uint64(0, 0); - _ref = bp; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - value = (x = (new $Uint64(0, c)), x$1 = $mul64((remainder), new $Uint64(1, 0)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); - digit = $div64(value, new $Uint64(0, 62), false); - remainder = $div64(value, new $Uint64(0, 62), true); - if (!((quotient.$length === 0)) || !((digit.$high === 0 && digit.$low === 0))) { - quotient = $append(quotient, ((digit.$low >>> 0))); - } - _i++; - } - n = n - (1) >> 0; - ((n < 0 || n >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + n] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".charCodeAt($flatten64(remainder))); - bp = quotient; - } - $copyString($subslice(dst, 0, n), "000000000000000000000000000"); - }; - fastAppendEncodeBase62 = function(dst, src) { - var dst, n, src; - dst = reserve(dst, 27); - n = dst.$length; - fastEncodeBase62($subslice(dst, n, (n + 27 >> 0)), src); - return $subslice(dst, 0, (n + 27 >> 0)); - }; - fastDecodeBase62 = function(dst, src) { - var _i, _ref, bp, bq, c, digit, dst, n, parts, quotient, remainder, src, value, x, x$1, x$2, x$3, x$4, x$5, zero; - $unused((26 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 26])); - parts = $toNativeArray($kindUint8, [base62Value((0 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 0])), base62Value((1 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 1])), base62Value((2 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 2])), base62Value((3 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 3])), base62Value((4 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 4])), base62Value((5 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 5])), base62Value((6 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 6])), base62Value((7 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 7])), base62Value((8 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 8])), base62Value((9 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 9])), base62Value((10 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 10])), base62Value((11 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 11])), base62Value((12 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 12])), base62Value((13 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 13])), base62Value((14 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 14])), base62Value((15 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 15])), base62Value((16 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 16])), base62Value((17 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 17])), base62Value((18 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 18])), base62Value((19 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 19])), base62Value((20 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 20])), base62Value((21 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 21])), base62Value((22 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 22])), base62Value((23 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 23])), base62Value((24 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 24])), base62Value((25 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 25])), base62Value((26 >= src.$length ? ($throwRuntimeError("index out of range"), undefined) : src.$array[src.$offset + 26]))]); - n = dst.$length; - bp = new sliceType$2(parts); - bq = arrayType$3.zero(); - while (true) { - if (!(bp.$length > 0)) { break; } - quotient = $subslice(new sliceType$2(bq), 0, 0); - remainder = new $Uint64(0, 0); - _ref = bp; - _i = 0; - while (true) { - if (!(_i < _ref.$length)) { break; } - c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); - value = (x = (new $Uint64(0, c)), x$1 = $mul64((remainder), new $Uint64(0, 62)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); - digit = $div64(value, new $Uint64(1, 0), false); - remainder = $div64(value, new $Uint64(1, 0), true); - if (!((quotient.$length === 0)) || !((digit.$high === 0 && digit.$low === 0))) { - quotient = $append(quotient, ((digit.$low << 24 >>> 24))); - } - _i++; - } - if (n < 4) { - return errShortBuffer; - } - (x$2 = n - 4 >> 0, ((x$2 < 0 || x$2 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$2] = (($shiftRightUint64(remainder, 24).$low << 24 >>> 24)))); - (x$3 = n - 3 >> 0, ((x$3 < 0 || x$3 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$3] = (($shiftRightUint64(remainder, 16).$low << 24 >>> 24)))); - (x$4 = n - 2 >> 0, ((x$4 < 0 || x$4 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$4] = (($shiftRightUint64(remainder, 8).$low << 24 >>> 24)))); - (x$5 = n - 1 >> 0, ((x$5 < 0 || x$5 >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + x$5] = ((remainder.$low << 24 >>> 24)))); - n = n - (4) >> 0; - bp = quotient; - } - zero = arrayType.zero(); - $copySlice($subslice(dst, 0, n), new sliceType$2(zero)); - return $ifaceNil; - }; - reserve = function(dst, nbytes) { - var avail, b, c, dst, n, nbytes; - c = dst.$capacity; - n = dst.$length; - avail = c - n >> 0; - if (avail < nbytes) { - c = $imul(c, (2)); - if (((c - n >> 0)) < nbytes) { - c = n + nbytes >> 0; - } - b = $makeSlice(sliceType$2, n, c); - $copySlice(b, dst); - dst = b; - } - return dst; - }; - KSUID.prototype.Append = function(b) { - var b, i; - i = this.$val; - return fastAppendEncodeBase62(b, new sliceType$2(i)); - }; - $ptrType(KSUID).prototype.Append = function(b) { return new KSUID(this.$get()).Append(b); }; - KSUID.prototype.Time = function() { - var i; - i = this.$val; - return correctedUTCTimestampToTime(new KSUID($clone(i, KSUID)).Timestamp()); - }; - $ptrType(KSUID).prototype.Time = function() { return new KSUID(this.$get()).Time(); }; - KSUID.prototype.Timestamp = function() { - var i; - i = this.$val; - return $clone(binary.BigEndian, binary.bigEndian).Uint32($subslice(new sliceType$2(i), 0, 4)); - }; - $ptrType(KSUID).prototype.Timestamp = function() { return new KSUID(this.$get()).Timestamp(); }; - KSUID.prototype.Payload = function() { - var i; - i = this.$val; - return $subslice(new sliceType$2(i), 4); - }; - $ptrType(KSUID).prototype.Payload = function() { return new KSUID(this.$get()).Payload(); }; - KSUID.prototype.String = function() { - var i; - i = this.$val; - return ($bytesToString(new KSUID($clone(i, KSUID)).Append($makeSlice(sliceType$2, 0, 27)))); - }; - $ptrType(KSUID).prototype.String = function() { return new KSUID(this.$get()).String(); }; - KSUID.prototype.Bytes = function() { - var i; - i = this.$val; - return new sliceType$2(i); - }; - $ptrType(KSUID).prototype.Bytes = function() { return new KSUID(this.$get()).Bytes(); }; - KSUID.prototype.IsNil = function() { - var i; - i = this.$val; - return $equal(i, $pkg.Nil, KSUID); - }; - $ptrType(KSUID).prototype.IsNil = function() { return new KSUID(this.$get()).IsNil(); }; - KSUID.prototype.Get = function() { - var i; - i = this.$val; - return new KSUID(i); - }; - $ptrType(KSUID).prototype.Get = function() { return new KSUID(this.$get()).Get(); }; - KSUID.prototype.Set = function(s) { - var i, s; - i = this.$val; - return new ptrType(i).UnmarshalText((new sliceType$2($stringToBytes(s)))); - }; - $ptrType(KSUID).prototype.Set = function(s) { return (new KSUID(this.$get())).Set(s); }; - KSUID.prototype.MarshalText = function() { - var i; - i = this.$val; - return [(new sliceType$2($stringToBytes(new KSUID($clone(i, KSUID)).String()))), $ifaceNil]; - }; - $ptrType(KSUID).prototype.MarshalText = function() { return new KSUID(this.$get()).MarshalText(); }; - KSUID.prototype.MarshalBinary = function() { - var i; - i = this.$val; - return [new KSUID($clone(i, KSUID)).Bytes(), $ifaceNil]; - }; - $ptrType(KSUID).prototype.MarshalBinary = function() { return new KSUID(this.$get()).MarshalBinary(); }; - KSUID.prototype.UnmarshalText = function(b) { - var _tuple, b, err, i, id; - i = this.$val; - _tuple = Parse(($bytesToString(b))); - id = $clone(_tuple[0], KSUID); - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - KSUID.copy(i, id); - return $ifaceNil; - }; - $ptrType(KSUID).prototype.UnmarshalText = function(b) { return (new KSUID(this.$get())).UnmarshalText(b); }; - KSUID.prototype.UnmarshalBinary = function(b) { - var _tuple, b, err, i, id; - i = this.$val; - _tuple = FromBytes(b); - id = $clone(_tuple[0], KSUID); - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - return err; - } - KSUID.copy(i, id); - return $ifaceNil; - }; - $ptrType(KSUID).prototype.UnmarshalBinary = function(b) { return (new KSUID(this.$get())).UnmarshalBinary(b); }; - KSUID.prototype.Value = function() { - var i; - i = this.$val; - if (new KSUID($clone(i, KSUID)).IsNil()) { - return [$ifaceNil, $ifaceNil]; - } - return [new $String(new KSUID($clone(i, KSUID)).String()), $ifaceNil]; - }; - $ptrType(KSUID).prototype.Value = function() { return new KSUID(this.$get()).Value(); }; - KSUID.prototype.Scan = function(src) { - var _r$5, _ref, i, src, v, v$1, v$2, v$3, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _ref = $f._ref; i = $f.i; src = $f.src; v = $f.v; v$1 = $f.v$1; v$2 = $f.v$2; v$3 = $f.v$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - i = this.$val; - _ref = src; - /* */ if (_ref === $ifaceNil) { $s = 1; continue; } - /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 2; continue; } - /* */ if ($assertType(_ref, $String, true)[1]) { $s = 3; continue; } - /* */ $s = 4; continue; - /* if (_ref === $ifaceNil) { */ case 1: - v = _ref; - $s = -1; return new ptrType(i).scan(sliceType$2.nil); - /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 2: - v$1 = _ref.$val; - $s = -1; return new ptrType(i).scan(v$1); - /* } else if ($assertType(_ref, $String, true)[1]) { */ case 3: - v$2 = _ref.$val; - $s = -1; return new ptrType(i).scan((new sliceType$2($stringToBytes(v$2)))); - /* } else { */ case 4: - v$3 = _ref; - _r$5 = fmt.Errorf("Scan: unable to scan type %T into KSUID", new sliceType([v$3])); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return _r$5; - /* } */ case 5: - $s = -1; return $ifaceNil; - /* */ } return; } if ($f === undefined) { $f = { $blk: KSUID.prototype.Scan }; } $f._r$5 = _r$5; $f._ref = _ref; $f.i = i; $f.src = src; $f.v = v; $f.v$1 = v$1; $f.v$2 = v$2; $f.v$3 = v$3; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(KSUID).prototype.Scan = function(src) { return (new KSUID(this.$get())).Scan(src); }; - KSUID.prototype.scan = function(b) { - var _1, b, i; - i = this.$val; - _1 = b.$length; - if (_1 === (0)) { - KSUID.copy(i, $pkg.Nil); - return $ifaceNil; - } else if (_1 === (20)) { - return new ptrType(i).UnmarshalBinary(b); - } else if (_1 === (27)) { - return new ptrType(i).UnmarshalText(b); - } else { - return errSize; - } - }; - $ptrType(KSUID).prototype.scan = function(b) { return (new KSUID(this.$get())).scan(b); }; - Parse = function(s) { - var dst, err, s, src; - if (!((s.length === 27))) { - return [$pkg.Nil, errStrSize]; - } - src = arrayType$3.zero(); - dst = arrayType.zero(); - $copyString(new sliceType$2(src), s); - err = fastDecodeBase62(new sliceType$2(dst), new sliceType$2(src)); - if (!($interfaceIsEqual(err, $ifaceNil))) { - return [$pkg.Nil, errStrValue]; - } - return FromBytes(new sliceType$2(dst)); - }; - $pkg.Parse = Parse; - timeToCorrectedUTCTimestamp = function(t) { - var t, x; - return (((x = $clone(t, time.Time).Unix(), new $Int64(x.$high - 0, x.$low - 1400000000)).$low >>> 0)); - }; - correctedUTCTimestampToTime = function(ts) { - var ts, x; - return time.Unix((x = (new $Int64(0, ts)), new $Int64(x.$high + 0, x.$low + 1400000000)), new $Int64(0, 0)); - }; - NewRandom = function() { - var _r$5, _tuple, err, ksuid, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; ksuid = $f.ksuid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ksuid = arrayType.zero(); - err = $ifaceNil; - _r$5 = NewRandomWithTime($clone(time.Now(), time.Time)); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple = _r$5; - KSUID.copy(ksuid, _tuple[0]); - err = _tuple[1]; - $s = -1; return [ksuid, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewRandom }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.ksuid = ksuid; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewRandom = NewRandom; - NewRandomWithTime = function(t) { - var _r$5, _tuple, err, ksuid, t, ts, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; ksuid = $f.ksuid; t = $f.t; ts = $f.ts; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - ksuid = arrayType.zero(); - err = $ifaceNil; - $r = randMutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r$5 = io.ReadAtLeast(rander, new sliceType$2(randBuffer), 16); /* */ $s = 2; case 2: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple = _r$5; - err = _tuple[1]; - $copySlice($subslice(new sliceType$2(ksuid), 4), new sliceType$2(randBuffer)); - $r = randMutex.Unlock(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - if (!($interfaceIsEqual(err, $ifaceNil))) { - KSUID.copy(ksuid, $pkg.Nil); - $s = -1; return [ksuid, err]; - } - ts = timeToCorrectedUTCTimestamp($clone(t, time.Time)); - $clone(binary.BigEndian, binary.bigEndian).PutUint32($subslice(new sliceType$2(ksuid), 0, 4), ts); - $s = -1; return [ksuid, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewRandomWithTime }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.ksuid = ksuid; $f.t = t; $f.ts = ts; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewRandomWithTime = NewRandomWithTime; - FromBytes = function(b) { - var b, ksuid; - ksuid = arrayType.zero(); - if (!((b.$length === 20))) { - return [$pkg.Nil, errSize]; - } - $copySlice(new sliceType$2(ksuid), b); - return [ksuid, $ifaceNil]; - }; - $pkg.FromBytes = FromBytes; - KSUID.prototype.Next = function() { - var id, t, u, v, zero; - id = this.$val; - zero = $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 0)), uint128); - t = new KSUID($clone(id, KSUID)).Timestamp(); - u = $clone(uint128Payload($clone(id, KSUID)), uint128); - v = $clone(add128($clone(u, uint128), $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 1)), uint128)), uint128); - if ($equal(v, zero, uint128)) { - t = t + (1) >>> 0; - } - return new uint128($clone(v, uint128)).ksuid(t); - }; - $ptrType(KSUID).prototype.Next = function() { return new KSUID(this.$get()).Next(); }; - KSUID.prototype.Prev = function() { - var id, max, t, u, v; - id = this.$val; - max = $clone(makeUint128(new $Uint64(4294967295, 4294967295), new $Uint64(4294967295, 4294967295)), uint128); - t = new KSUID($clone(id, KSUID)).Timestamp(); - u = $clone(uint128Payload($clone(id, KSUID)), uint128); - v = $clone(sub128($clone(u, uint128), $clone(makeUint128(new $Uint64(0, 0), new $Uint64(0, 1)), uint128)), uint128); - if ($equal(v, max, uint128)) { - t = t - (1) >>> 0; - } - return new uint128($clone(v, uint128)).ksuid(t); - }; - $ptrType(KSUID).prototype.Prev = function() { return new KSUID(this.$get()).Prev(); }; - newRBG = function() { - var _r$5, _tuple, err, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r$5 = newRandomBitsGenerator(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple = _r$5; - r = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $panic(err); - } - $s = -1; return r; - /* */ } return; } if ($f === undefined) { $f = { $blk: newRBG }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - newRandomBitsGenerator = function() { - var _r$5, _tuple, err, r, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; err = $f.err; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = $ifaceNil; - err = $ifaceNil; - seed = new $Int64(0, 0); - _r$5 = readCryptoRandomSeed(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple = _r$5; - seed = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [r, err]; - } - r = new randSourceReader.ptr($assertType(rand$1.NewSource(seed), rand$1.Source64)); - $s = -1; return [r, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: newRandomBitsGenerator }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - readCryptoRandomSeed = function() { - var _r$5, _tuple, b, err, seed, x, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; _tuple = $f._tuple; b = $f.b; err = $f.err; seed = $f.seed; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - seed = new $Int64(0, 0); - err = $ifaceNil; - b = arrayType$4.zero(); - _r$5 = io.ReadFull(rand.Reader, new sliceType$2(b)); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _tuple = _r$5; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [seed, err]; - } - seed = ((x = $clone(binary.LittleEndian, binary.littleEndian).Uint64(new sliceType$2(b)), new $Int64(x.$high, x.$low))); - $s = -1; return [seed, err]; - /* */ } return; } if ($f === undefined) { $f = { $blk: readCryptoRandomSeed }; } $f._r$5 = _r$5; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.seed = seed; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; - }; - randSourceReader.ptr.prototype.Read = function(b) { - var _arg, _arg$1, _arg$2, _arg$3, _r$5, _r$6, b, r, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$5 = $f._r$5; _r$6 = $f._r$6; b = $f.b; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - r = this; - _arg = $subslice(b, 0, 8); - _r$5 = r.source.Uint64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - _arg$1 = _r$5; - $r = $clone(binary.LittleEndian, binary.littleEndian).PutUint64(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _arg$2 = $subslice(b, 8); - _r$6 = r.source.Uint64(); /* */ $s = 3; case 3: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } - _arg$3 = _r$6; - $r = $clone(binary.LittleEndian, binary.littleEndian).PutUint64(_arg$2, _arg$3); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $s = -1; return [16, $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: randSourceReader.ptr.prototype.Read }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.b = b; $f.r = r; $f.$s = $s; $f.$r = $r; return $f; - }; - randSourceReader.prototype.Read = function(b) { return this.$val.Read(b); }; - uint128Payload = function(ksuid) { - var ksuid; - return makeUint128FromPayload($subslice(new sliceType$2(ksuid), 4)); - }; - makeUint128 = function(high, low) { - var high, low; - return $toNativeArray($kindUint64, [low, high]); - }; - makeUint128FromPayload = function(payload) { - var payload, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$25, x$26, x$27, x$3, x$4, x$5, x$6, x$7, x$8, x$9; - return $toNativeArray($kindUint64, [(x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = $shiftLeft64((new $Uint64(0, (8 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 8]))), 56), x$7 = $shiftLeft64((new $Uint64(0, (9 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 9]))), 48), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Uint64(0, (10 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 10]))), 40), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Uint64(0, (11 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 11]))), 32), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Uint64(0, (12 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 12]))), 24), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Uint64(0, (13 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 13]))), 16), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Uint64(0, (14 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 14]))), 8), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = (new $Uint64(0, (15 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 15]))), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)), (x$14 = (x$15 = (x$16 = (x$17 = (x$18 = (x$19 = (x$20 = $shiftLeft64((new $Uint64(0, (0 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 0]))), 56), x$21 = $shiftLeft64((new $Uint64(0, (1 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 1]))), 48), new $Uint64(x$20.$high | x$21.$high, (x$20.$low | x$21.$low) >>> 0)), x$22 = $shiftLeft64((new $Uint64(0, (2 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 2]))), 40), new $Uint64(x$19.$high | x$22.$high, (x$19.$low | x$22.$low) >>> 0)), x$23 = $shiftLeft64((new $Uint64(0, (3 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 3]))), 32), new $Uint64(x$18.$high | x$23.$high, (x$18.$low | x$23.$low) >>> 0)), x$24 = $shiftLeft64((new $Uint64(0, (4 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 4]))), 24), new $Uint64(x$17.$high | x$24.$high, (x$17.$low | x$24.$low) >>> 0)), x$25 = $shiftLeft64((new $Uint64(0, (5 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 5]))), 16), new $Uint64(x$16.$high | x$25.$high, (x$16.$low | x$25.$low) >>> 0)), x$26 = $shiftLeft64((new $Uint64(0, (6 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 6]))), 8), new $Uint64(x$15.$high | x$26.$high, (x$15.$low | x$26.$low) >>> 0)), x$27 = (new $Uint64(0, (7 >= payload.$length ? ($throwRuntimeError("index out of range"), undefined) : payload.$array[payload.$offset + 7]))), new $Uint64(x$14.$high | x$27.$high, (x$14.$low | x$27.$low) >>> 0))]); - }; - uint128.prototype.ksuid = function(timestamp) { - var timestamp, v; - v = this.$val; - return $toNativeArray($kindUint8, [(((timestamp >>> 24 >>> 0) << 24 >>> 24)), (((timestamp >>> 16 >>> 0) << 24 >>> 24)), (((timestamp >>> 8 >>> 0) << 24 >>> 24)), ((timestamp << 24 >>> 24)), (($shiftRightUint64(v[1], 56).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 48).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 40).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 32).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 24).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 16).$low << 24 >>> 24)), (($shiftRightUint64(v[1], 8).$low << 24 >>> 24)), ((v[1].$low << 24 >>> 24)), (($shiftRightUint64(v[0], 56).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 48).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 40).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 32).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 24).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 16).$low << 24 >>> 24)), (($shiftRightUint64(v[0], 8).$low << 24 >>> 24)), ((v[0].$low << 24 >>> 24))]); - }; - $ptrType(uint128).prototype.ksuid = function(timestamp) { return new uint128(this.$get()).ksuid(timestamp); }; - uint128.prototype.String = function() { - var _r$5, v, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$5 = $f._r$5; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - v = this.$val; - _r$5 = fmt.Sprintf("0x%016X%016X", new sliceType([v[0], v[1]])); /* */ $s = 1; case 1: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } - $s = -1; return _r$5; - /* */ } return; } if ($f === undefined) { $f = { $blk: uint128.prototype.String }; } $f._r$5 = _r$5; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; - }; - $ptrType(uint128).prototype.String = function() { return new uint128(this.$get()).String(); }; - add128 = function(x, y) { - var c, x, x$1, x$2, x$3, x$4, x$5, x$6, x0, y, y0, z, z0; - z = arrayType$5.zero(); - x0 = x[0]; - y0 = y[0]; - z0 = new $Uint64(x0.$high + y0.$high, x0.$low + y0.$low); - z[0] = z0; - c = $shiftRightUint64(((x$1 = new $Uint64(x0.$high & y0.$high, (x0.$low & y0.$low) >>> 0), x$2 = (x$3 = new $Uint64(x0.$high | y0.$high, (x0.$low | y0.$low) >>> 0), new $Uint64(x$3.$high & ~z0.$high, (x$3.$low & ~z0.$low) >>> 0)), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0))), 63); - z[1] = (x$4 = (x$5 = x[1], x$6 = y[1], new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), new $Uint64(x$4.$high + c.$high, x$4.$low + c.$low)); - return z; - }; - sub128 = function(x, y) { - var c, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x0, y, y0, z, z0; - z = arrayType$5.zero(); - x0 = x[0]; - y0 = y[0]; - z0 = new $Uint64(x0.$high - y0.$high, x0.$low - y0.$low); - z[0] = z0; - c = $shiftRightUint64(((x$1 = new $Uint64(y0.$high & ~x0.$high, (y0.$low & ~x0.$low) >>> 0), x$2 = (x$3 = (x$4 = new $Uint64(~x0.$high, ~x0.$low >>> 0), new $Uint64(y0.$high | x$4.$high, (y0.$low | x$4.$low) >>> 0)), new $Uint64(x$3.$high & z0.$high, (x$3.$low & z0.$low) >>> 0)), new $Uint64(x$1.$high | x$2.$high, (x$1.$low | x$2.$low) >>> 0))), 63); - z[1] = (x$5 = (x$6 = x[1], x$7 = y[1], new $Uint64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), new $Uint64(x$5.$high - c.$high, x$5.$low - c.$low)); - return z; - }; - KSUID.methods = [{prop: "Append", name: "Append", pkg: "", typ: $funcType([sliceType$2], [sliceType$2], false)}, {prop: "Time", name: "Time", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Timestamp", name: "Timestamp", pkg: "", typ: $funcType([], [$Uint32], false)}, {prop: "Payload", name: "Payload", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$2, $error], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$2, $error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([], [driver.Value, $error], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([], [KSUID], false)}, {prop: "Prev", name: "Prev", pkg: "", typ: $funcType([], [KSUID], false)}]; - ptrType.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "scan", name: "scan", pkg: "github.com/segmentio/ksuid", typ: $funcType([sliceType$2], [$error], false)}]; - ptrType$1.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}]; - uint128.methods = [{prop: "ksuid", name: "ksuid", pkg: "github.com/segmentio/ksuid", typ: $funcType([$Uint32], [KSUID], false)}, {prop: "bytes", name: "bytes", pkg: "github.com/segmentio/ksuid", typ: $funcType([], [arrayType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; - KSUID.init($Uint8, 20); - randSourceReader.init("github.com/segmentio/ksuid", [{prop: "source", name: "source", embedded: false, exported: false, typ: rand$1.Source64, tag: ""}]); - uint128.init($Uint64, 2); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = rand.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = driver.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = binary.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = errors.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = fmt.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = math.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = rand$1.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = sync.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = time.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $pkg.Nil = arrayType.zero(); - errShortBuffer = errors.New("the output buffer is too small to hold to decoded value"); - rander = rand.Reader; - randMutex = new sync.Mutex.ptr(0, 0); - randBuffer = arrayType$1.zero(); - _r = fmt.Errorf("Valid KSUIDs are %v bytes", new sliceType([new $Int(20)])); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - errSize = _r; - _r$1 = fmt.Errorf("Valid encoded KSUIDs are %v characters", new sliceType([new $Int(27)])); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - errStrSize = _r$1; - _r$2 = fmt.Errorf("Valid encoded KSUIDs are bounded by %s and %s", new sliceType([new $String("000000000000000000000000000"), new $String("aWgEPTl1tmebfsQzFP4bxwgy80V")])); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } - errStrValue = _r$2; - _r$3 = fmt.Errorf("Valid KSUID payloads are %v bytes", new sliceType([new $Int(16)])); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } - errPayloadSize = _r$3; - _r$4 = newRBG(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } - $pkg.FastRander = _r$4; - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["github.com/bonedaddy/vcaptcha/ticket"] = (function() { - var $pkg = {}, $init, sha256, hex, json, vdf, ksuid, Ticket, arrayType, ptrType, arrayType$1, sliceType, NewTicket, NewSeed, IDToBytes32; - sha256 = $packages["crypto/sha256"]; - hex = $packages["encoding/hex"]; - json = $packages["encoding/json"]; - vdf = $packages["github.com/bonedaddy/vcaptcha/vdf"]; - ksuid = $packages["github.com/segmentio/ksuid"]; - Ticket = $pkg.Ticket = $newType(0, $kindStruct, "ticket.Ticket", true, "github.com/bonedaddy/vcaptcha/ticket", true, function(Seed_, Difficulty_, Proof_) { - this.$val = this; - if (arguments.length === 0) { - this.Seed = arrayType.zero(); - this.Difficulty = 0; - this.Proof = arrayType$1.zero(); - return; - } - this.Seed = Seed_; - this.Difficulty = Difficulty_; - this.Proof = Proof_; - }); - arrayType = $arrayType($Uint8, 32); - ptrType = $ptrType(Ticket); - arrayType$1 = $arrayType($Uint8, 516); - sliceType = $sliceType($Uint8); - NewTicket = function(diff) { - var _r, _tuple, diff, err, seed, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; diff = $f.diff; err = $f.err; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = NewSeed(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - seed = $clone(_tuple[0], arrayType); - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [ptrType.nil, err]; - } - $s = -1; return [new Ticket.ptr($clone(seed, arrayType), diff, arrayType$1.zero()), $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewTicket }; } $f._r = _r; $f._tuple = _tuple; $f.diff = diff; $f.err = err; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewTicket = NewTicket; - Ticket.ptr.prototype.Encode = function() { - var _r, _tuple, data, err, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = t.Marshal(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - data = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return ["", err]; - } - $s = -1; return [hex.EncodeToString(data), $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Encode }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Ticket.prototype.Encode = function() { return this.$val.Encode(); }; - Ticket.ptr.prototype.Marshal = function() { - var _r, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = json.Marshal(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Marshal }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Ticket.prototype.Marshal = function() { return this.$val.Marshal(); }; - Ticket.ptr.prototype.Hash = function() { - var _r, _r$1, _tuple, bytes, dt, err, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; bytes = $f.bytes; dt = $f.dt; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - _r = json.Marshal(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - bytes = _tuple[0]; - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return ""; - } - _r$1 = sha256.Sum256(bytes); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } - dt = $clone(_r$1, arrayType); - $s = -1; return hex.EncodeToString(new sliceType(dt)); - /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Hash }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.bytes = bytes; $f.dt = dt; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Ticket.prototype.Hash = function() { return this.$val.Hash(); }; - Ticket.ptr.prototype.Verify = function(proof) { - var _r, gvdf, proof, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; gvdf = $f.gvdf; proof = $f.proof; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - gvdf = vdf.New(t.Difficulty, $clone(t.Seed, arrayType)); - _r = gvdf.Verify($clone(proof, arrayType$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - $s = -1; return _r; - /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Verify }; } $f._r = _r; $f.gvdf = gvdf; $f.proof = proof; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Ticket.prototype.Verify = function(proof) { return this.$val.Verify(proof); }; - Ticket.ptr.prototype.Solve = function() { - var _r, gvdf, proof, t, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; gvdf = $f.gvdf; proof = $f.proof; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - t = this; - gvdf = vdf.New(t.Difficulty, $clone(t.Seed, arrayType)); - $r = gvdf.Execute(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - _r = $recv(gvdf.GetOutputChannel()); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - proof = $clone(_r[0], arrayType$1); - arrayType$1.copy(t.Proof, proof); - $s = -1; return proof; - /* */ } return; } if ($f === undefined) { $f = { $blk: Ticket.ptr.prototype.Solve }; } $f._r = _r; $f.gvdf = gvdf; $f.proof = proof; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; - }; - Ticket.prototype.Solve = function() { return this.$val.Solve(); }; - NewSeed = function() { - var _r, _tuple, err, kid, $s, $r; - /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; kid = $f.kid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - _r = ksuid.NewRandom(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } - _tuple = _r; - kid = $clone(_tuple[0], ksuid.KSUID); - err = _tuple[1]; - if (!($interfaceIsEqual(err, $ifaceNil))) { - $s = -1; return [arrayType.zero(), err]; - } - $s = -1; return [IDToBytes32($clone(kid, ksuid.KSUID)), $ifaceNil]; - /* */ } return; } if ($f === undefined) { $f = { $blk: NewSeed }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.kid = kid; $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.NewSeed = NewSeed; - IDToBytes32 = function(kid) { - var combined, i, id, kid; - id = arrayType.zero(); - combined = sliceType.nil; - combined = $appendSlice(combined, new ksuid.KSUID($clone(kid, ksuid.KSUID)).Bytes()); - combined = $appendSlice(combined, $subslice(new ksuid.KSUID($clone(kid, ksuid.KSUID)).Payload(), 0, 12)); - i = 0; - while (true) { - if (!(i < combined.$length)) { break; } - ((i < 0 || i >= id.length) ? ($throwRuntimeError("index out of range"), undefined) : id[i] = ((i < 0 || i >= combined.$length) ? ($throwRuntimeError("index out of range"), undefined) : combined.$array[combined.$offset + i])); - i = i + (1) >> 0; - } - return id; - }; - $pkg.IDToBytes32 = IDToBytes32; - ptrType.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([], [$String, $error], false)}, {prop: "Marshal", name: "Marshal", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "Hash", name: "Hash", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Verify", name: "Verify", pkg: "", typ: $funcType([arrayType$1], [$Bool], false)}, {prop: "Solve", name: "Solve", pkg: "", typ: $funcType([], [arrayType$1], false)}]; - Ticket.init("", [{prop: "Seed", name: "Seed", embedded: false, exported: true, typ: arrayType, tag: "json:\"seed\""}, {prop: "Difficulty", name: "Difficulty", embedded: false, exported: true, typ: $Int, tag: "json:\"difficulty\""}, {prop: "Proof", name: "Proof", embedded: false, exported: true, typ: arrayType$1, tag: "json:\"proof\""}]); - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = sha256.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = hex.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = json.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = vdf.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = ksuid.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); -$packages["."] = (function() { - var $pkg = {}, $init, ticket, js, ptrType, funcType, mapType, main; - ticket = $packages["github.com/bonedaddy/vcaptcha/ticket"]; - js = $packages["github.com/gopherjs/gopherjs/js"]; - ptrType = $ptrType(ticket.Ticket); - funcType = $funcType([$Int], [ptrType, $error], false); - mapType = $mapType($String, $emptyInterface); - main = function() { - $global.ticket = $externalize($makeMap($String.keyFor, [{ k: "New", v: new funcType(ticket.NewTicket) }]), mapType); - }; - $init = function() { - $pkg.$init = function() {}; - /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: - $r = ticket.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } - if ($pkg === $mainPkg) { - main(); - $mainFinished = true; - } - /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; - }; - $pkg.$init = $init; - return $pkg; -})(); +var $global,$module;if(Error.stackTraceLimit=1/0,"undefined"!=typeof window?$global=window:"undefined"!=typeof self?$global=self:"undefined"!=typeof global?($global=global).require=require:$global=this,void 0===$global||void 0===$global.Array)throw new Error("no global object found");"undefined"!=typeof module&&($module=module);var $throwRuntimeError,$packages={},$idCounter=0,$keys=function(e){return e?Object.keys(e):[]},$flushConsole=function(){},$throwNilPointerError=function(){$throwRuntimeError("invalid memory address or nil pointer dereference")},$call=function(e,n,r){return e.apply(n,r)},$makeFunc=function(e){return function(){return $externalize(e(this,new($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments,[]))),$emptyInterface)}},$unused=function(e){},$mapArray=function(e,n){for(var r=new e.constructor(e.length),t=0;te.$capacity||t>e.$capacity)&&$throwRuntimeError("slice bounds out of range"),e===e.constructor.nil)return e;var i=new e.constructor(e.$array);return i.$offset=e.$offset+n,i.$length=r-n,i.$capacity=t-n,i},$substring=function(e,n,r){return(n<0||re.length)&&$throwRuntimeError("slice bounds out of range"),e.substring(n,r)},$sliceToArray=function(e){return e.$array.constructor!==Array?e.$array.subarray(e.$offset,e.$offset+e.$length):e.$array.slice(e.$offset,e.$offset+e.$length)},$decodeRune=function(e,n){var r=e.charCodeAt(n);if(r<128)return[r,1];if(r!=r||r<192)return[65533,1];var t=e.charCodeAt(n+1);if(t!=t||t<128||192<=t)return[65533,1];if(r<224)return(a=(31&r)<<6|63&t)<=127?[65533,1]:[a,2];var i=e.charCodeAt(n+2);if(i!=i||i<128||192<=i)return[65533,1];if(r<240)return(a=(15&r)<<12|(63&t)<<6|63&i)<=2047?[65533,1]:55296<=a&&a<=57343?[65533,1]:[a,3];var a,o=e.charCodeAt(n+3);return o!=o||o<128||192<=o?[65533,1]:r<248?(a=(7&r)<<18|(63&t)<<12|(63&i)<<6|63&o)<=65535||11141111114111||55296<=e&&e<=57343)&&(e=65533),e<=127?String.fromCharCode(e):e<=2047?String.fromCharCode(192|e>>6,128|63&e):e<=65535?String.fromCharCode(224|e>>12,128|e>>6&63,128|63&e):String.fromCharCode(240|e>>18,128|e>>12&63,128|e>>6&63,128|63&e)},$stringToBytes=function(e){for(var n=new Uint8Array(e.length),r=0;rt){for(var o=i-1;o>=0;o--)a.copy(e[r+o],n[t+o]);return}for(o=0;ot)for(o=i-1;o>=0;o--)e[r+o]=n[t+o];else for(o=0;o$)if(a=0,$=Math.max(o,e.$capacity<1024?2*e.$capacity:Math.floor(5*e.$capacity/4)),e.$array.constructor===Array){(i=e.$array.slice(e.$offset,e.$offset+e.$length)).length=$;for(var c=e.constructor.elem.zero,u=e.$length;u<$;u++)i[u]=c()}else(i=new e.$array.constructor($)).set(e.$array.subarray(e.$offset,e.$offset+e.$length));$copyArray(i,n,a+e.$length,r,t,e.constructor.elem);var l=new e.constructor(i);return l.$offset=a,l.$length=o,l.$capacity=$,l},$equal=function(e,n,r){if(r===$jsObjectPtr)return e===n;switch(r.kind){case $kindComplex64:case $kindComplex128:return e.$real===n.$real&&e.$imag===n.$imag;case $kindInt64:case $kindUint64:return e.$high===n.$high&&e.$low===n.$low;case $kindArray:if(e.length!==n.length)return!1;for(var t=0;t>>16&65535)*t+r*(n>>>16&65535)<<16>>>0)>>0},$floatKey=function(e){return e!=e?"NaN$"+ ++$idCounter:String(e)},$flatten64=function(e){return 4294967296*e.$high+e.$low},$shiftLeft64=function(e,n){return 0===n?e:n<32?new e.constructor(e.$high<>>32-n,e.$low<>>0):n<64?new e.constructor(e.$low<>n,(e.$low>>>n|e.$high<<32-n)>>>0):n<64?new e.constructor(e.$high>>31,e.$high>>n-32>>>0):e.$high<0?new e.constructor(-1,4294967295):new e.constructor(0,0)},$shiftRightUint64=function(e,n){return 0===n?e:n<32?new e.constructor(e.$high>>>n,(e.$low>>>n|e.$high<<32-n)>>>0):n<64?new e.constructor(0,e.$high>>>n-32):new e.constructor(0,0)},$mul64=function(e,n){var r=0,t=0;0!=(1&n.$low)&&(r=e.$high,t=e.$low);for(var i=1;i<32;i++)0!=(n.$low&1<>>32-i,t+=e.$low<>>0);for(i=0;i<32;i++)0!=(n.$high&1<$||a===$&&o>c);)$=($<<1|c>>>31)>>>0,c=c<<1>>>0,s++;for(var f=0;f<=s;f++)u=u<<1|l>>>31,l=l<<1>>>0,(a>$||a===$&&o>=c)&&(a-=$,(o-=c)<0&&(a--,o+=4294967296),4294967296===++l&&(u++,l=0)),c=(c>>>1|$<<31)>>>0,$>>>=1;return r?new e.constructor(a*i,o*i):new e.constructor(u*t,l*t)},$divComplex=function(e,n){var r=e.$real===1/0||e.$real===-1/0||e.$imag===1/0||e.$imag===-1/0,t=n.$real===1/0||n.$real===-1/0||n.$imag===1/0||n.$imag===-1/0,i=!r&&(e.$real!=e.$real||e.$imag!=e.$imag),a=!t&&(n.$real!=n.$real||n.$imag!=n.$imag);if(i||a)return new e.constructor(NaN,NaN);if(r&&!t)return new e.constructor(1/0,1/0);if(!r&&t)return new e.constructor(0,0);if(0===n.$real&&0===n.$imag)return 0===e.$real&&0===e.$imag?new e.constructor(NaN,NaN):new e.constructor(1/0,1/0);if(Math.abs(n.$real)<=Math.abs(n.$imag)){var o=n.$real/n.$imag,$=n.$real*o+n.$imag;return new e.constructor((e.$real*o+e.$imag)/$,(e.$imag*o-e.$real)/$)}o=n.$imag/n.$real,$=n.$imag*o+n.$real;return new e.constructor((e.$imag*o+e.$real)/$,(e.$imag-e.$real*o)/$)},$kindBool=1,$kindInt=2,$kindInt8=3,$kindInt16=4,$kindInt32=5,$kindInt64=6,$kindUint=7,$kindUint8=8,$kindUint16=9,$kindUint32=10,$kindUint64=11,$kindUintptr=12,$kindFloat32=13,$kindFloat64=14,$kindComplex64=15,$kindComplex128=16,$kindArray=17,$kindChan=18,$kindFunc=19,$kindInterface=20,$kindMap=21,$kindPtr=22,$kindSlice=23,$kindString=24,$kindStruct=25,$kindUnsafePointer=26,$methodSynthesizers=[],$addMethodSynthesizer=function(e){null!==$methodSynthesizers?$methodSynthesizers.push(e):e()},$synthesizeMethods=function(){$methodSynthesizers.forEach(function(e){e()}),$methodSynthesizers=null},$ifaceKeyFor=function(e){if(e===$ifaceNil)return"nil";var n=e.constructor;return n.string+"$"+n.keyFor(e.$val)},$identity=function(e){return e},$typeIDCounter=0,$idKey=function(e){return void 0===e.$id&&($idCounter++,e.$id=$idCounter),String(e.$id)},$newType=function(e,n,r,t,i,a,o){var $;switch(n){case $kindBool:case $kindInt:case $kindInt8:case $kindInt16:case $kindInt32:case $kindUint:case $kindUint8:case $kindUint16:case $kindUint32:case $kindUintptr:case $kindUnsafePointer:($=function(e){this.$val=e}).wrapped=!0,$.keyFor=$identity;break;case $kindString:($=function(e){this.$val=e}).wrapped=!0,$.keyFor=function(e){return"$"+e};break;case $kindFloat32:case $kindFloat64:($=function(e){this.$val=e}).wrapped=!0,$.keyFor=function(e){return $floatKey(e)};break;case $kindInt64:($=function(e,n){this.$high=e+Math.floor(Math.ceil(n)/4294967296)>>0,this.$low=n>>>0,this.$val=this}).keyFor=function(e){return e.$high+"$"+e.$low};break;case $kindUint64:($=function(e,n){this.$high=e+Math.floor(Math.ceil(n)/4294967296)>>>0,this.$low=n>>>0,this.$val=this}).keyFor=function(e){return e.$high+"$"+e.$low};break;case $kindComplex64:($=function(e,n){this.$real=$fround(e),this.$imag=$fround(n),this.$val=this}).keyFor=function(e){return e.$real+"$"+e.$imag};break;case $kindComplex128:($=function(e,n){this.$real=e,this.$imag=n,this.$val=this}).keyFor=function(e){return e.$real+"$"+e.$imag};break;case $kindArray:($=function(e){this.$val=e}).wrapped=!0,$.ptr=$newType(4,$kindPtr,"*"+r,!1,"",!1,function(e){this.$get=function(){return e},this.$set=function(e){$.copy(this,e)},this.$val=e}),$.init=function(e,n){$.elem=e,$.len=n,$.comparable=e.comparable,$.keyFor=function(n){return Array.prototype.join.call($mapArray(n,function(n){return String(e.keyFor(n)).replace(/\\/g,"\\\\").replace(/\$/g,"\\$")}),"$")},$.copy=function(n,r){$copyArray(n,r,0,0,r.length,e)},$.ptr.init($),Object.defineProperty($.ptr.nil,"nilCheck",{get:$throwNilPointerError})};break;case $kindChan:($=function(e){this.$val=e}).wrapped=!0,$.keyFor=$idKey,$.init=function(e,n,r){$.elem=e,$.sendOnly=n,$.recvOnly=r};break;case $kindFunc:($=function(e){this.$val=e}).wrapped=!0,$.init=function(e,n,r){$.params=e,$.results=n,$.variadic=r,$.comparable=!1};break;case $kindInterface:($={implementedBy:{},missingMethodFor:{}}).keyFor=$ifaceKeyFor,$.init=function(e){$.methods=e,e.forEach(function(e){$ifaceNil[e.prop]=$throwNilPointerError})};break;case $kindMap:($=function(e){this.$val=e}).wrapped=!0,$.init=function(e,n){$.key=e,$.elem=n,$.comparable=!1};break;case $kindPtr:($=o||function(e,n,r){this.$get=e,this.$set=n,this.$target=r,this.$val=this}).keyFor=$idKey,$.init=function(e){$.elem=e,$.wrapped=e.kind===$kindArray,$.nil=new $($throwNilPointerError,$throwNilPointerError)};break;case $kindSlice:($=function(e){e.constructor!==$.nativeArray&&(e=new $.nativeArray(e)),this.$array=e,this.$offset=0,this.$length=e.length,this.$capacity=e.length,this.$val=this}).init=function(e){$.elem=e,$.comparable=!1,$.nativeArray=$nativeArray(e.kind),$.nil=new $([])};break;case $kindStruct:($=function(e){this.$val=e}).wrapped=!0,$.ptr=$newType(4,$kindPtr,"*"+r,!1,i,a,o),$.ptr.elem=$,$.ptr.prototype.$get=function(){return this},$.ptr.prototype.$set=function(e){$.copy(this,e)},$.init=function(e,n){$.pkgPath=e,$.fields=n,n.forEach(function(e){e.typ.comparable||($.comparable=!1)}),$.keyFor=function(e){var r=e.$val;return $mapArray(n,function(e){return String(e.typ.keyFor(r[e.prop])).replace(/\\/g,"\\\\").replace(/\$/g,"\\$")}).join("$")},$.copy=function(e,r){for(var t=0;t0;){var a=[],o=[];t.forEach(function(e){if(!i[e.typ.string])switch(i[e.typ.string]=!0,e.typ.named&&(o=o.concat(e.typ.methods),e.indirect&&(o=o.concat($ptrType(e.typ).methods))),e.typ.kind){case $kindStruct:e.typ.fields.forEach(function(n){if(n.embedded){var r=n.typ,t=r.kind===$kindPtr;a.push({typ:t?r.elem:r,indirect:e.indirect||t})}});break;case $kindInterface:o=o.concat(e.typ.methods)}}),o.forEach(function(e){void 0===n[e.name]&&(n[e.name]=e)}),t=a}return e.methodSetCache=[],Object.keys(n).sort().forEach(function(r){e.methodSetCache.push(n[r])}),e.methodSetCache},$Bool=$newType(1,$kindBool,"bool",!0,"",!1,null),$Int=$newType(4,$kindInt,"int",!0,"",!1,null),$Int8=$newType(1,$kindInt8,"int8",!0,"",!1,null),$Int16=$newType(2,$kindInt16,"int16",!0,"",!1,null),$Int32=$newType(4,$kindInt32,"int32",!0,"",!1,null),$Int64=$newType(8,$kindInt64,"int64",!0,"",!1,null),$Uint=$newType(4,$kindUint,"uint",!0,"",!1,null),$Uint8=$newType(1,$kindUint8,"uint8",!0,"",!1,null),$Uint16=$newType(2,$kindUint16,"uint16",!0,"",!1,null),$Uint32=$newType(4,$kindUint32,"uint32",!0,"",!1,null),$Uint64=$newType(8,$kindUint64,"uint64",!0,"",!1,null),$Uintptr=$newType(4,$kindUintptr,"uintptr",!0,"",!1,null),$Float32=$newType(4,$kindFloat32,"float32",!0,"",!1,null),$Float64=$newType(8,$kindFloat64,"float64",!0,"",!1,null),$Complex64=$newType(8,$kindComplex64,"complex64",!0,"",!1,null),$Complex128=$newType(16,$kindComplex128,"complex128",!0,"",!1,null),$String=$newType(8,$kindString,"string",!0,"",!1,null),$UnsafePointer=$newType(4,$kindUnsafePointer,"unsafe.Pointer",!0,"",!1,null),$nativeArray=function(e){switch(e){case $kindInt:return Int32Array;case $kindInt8:return Int8Array;case $kindInt16:return Int16Array;case $kindInt32:return Int32Array;case $kindUint:return Uint32Array;case $kindUint8:return Uint8Array;case $kindUint16:return Uint16Array;case $kindUint32:case $kindUintptr:return Uint32Array;case $kindFloat32:return Float32Array;case $kindFloat64:return Float64Array;default:return Array}},$toNativeArray=function(e,n){var r=$nativeArray(e);return r===Array?n:new r(n)},$arrayTypes={},$arrayType=function(e,n){var r=e.id+"$"+n,t=$arrayTypes[r];return void 0===t&&(t=$newType(12,$kindArray,"["+n+"]"+e.string,!1,"",!1,null),$arrayTypes[r]=t,t.init(e,n)),t},$chanType=function(e,n,r){var t=(r?"<-":"")+"chan"+(n?"<- ":" ")+e.string,i=n?"SendChan":r?"RecvChan":"Chan",a=e[i];return void 0===a&&(a=$newType(4,$kindChan,t,!1,"",!1,null),e[i]=a,a.init(e,n,r)),a},$Chan=function(e,n){(n<0||n>2147483647)&&$throwRuntimeError("makechan: size out of range"),this.$elem=e,this.$capacity=n,this.$buffer=[],this.$sendQueue=[],this.$recvQueue=[],this.$closed=!1},$chanNil=new $Chan(null,0);$chanNil.$sendQueue=$chanNil.$recvQueue={length:0,push:function(){},shift:function(){},indexOf:function(){return-1}};var $funcTypes={},$funcType=function(e,n,r){var t=$mapArray(e,function(e){return e.id}).join(",")+"$"+$mapArray(n,function(e){return e.id}).join(",")+"$"+r,i=$funcTypes[t];if(void 0===i){var a=$mapArray(e,function(e){return e.string});r&&(a[a.length-1]="..."+a[a.length-1].substr(2));var o="func("+a.join(", ")+")";1===n.length?o+=" "+n[0].string:n.length>1&&(o+=" ("+$mapArray(n,function(e){return e.string}).join(", ")+")"),i=$newType(4,$kindFunc,o,!1,"",!1,null),$funcTypes[t]=i,i.init(e,n,r)}return i},$interfaceTypes={},$interfaceType=function(e){var n=$mapArray(e,function(e){return e.pkg+","+e.name+","+e.typ.id}).join("$"),r=$interfaceTypes[n];if(void 0===r){var t="interface {}";0!==e.length&&(t="interface { "+$mapArray(e,function(e){return(""!==e.pkg?e.pkg+".":"")+e.name+e.typ.string.substr(4)}).join("; ")+" }"),r=$newType(8,$kindInterface,t,!1,"",!1,null),$interfaceTypes[n]=r,r.init(e)}return r},$emptyInterface=$interfaceType([]),$ifaceNil={},$error=$newType(8,$kindInterface,"error",!0,"",!1,null);$error.init([{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],!1)}]);var $panicValue,$jsObjectPtr,$jsErrorPtr,$mapTypes={},$mapType=function(e,n){var r=e.id+"$"+n.id,t=$mapTypes[r];return void 0===t&&(t=$newType(4,$kindMap,"map["+e.string+"]"+n.string,!1,"",!1,null),$mapTypes[r]=t,t.init(e,n)),t},$makeMap=function(e,n){for(var r={},t=0;t2147483647)&&$throwRuntimeError("makeslice: len out of range"),(r<0||r2147483647)&&$throwRuntimeError("makeslice: cap out of range");var t=new e.nativeArray(r);if(e.nativeArray===Array)for(var i=0;i=$curGoroutine.deferStack.length)throw n;if(null!==n){var t=null;try{$curGoroutine.deferStack.push(e),$panic(new $jsErrorPtr(n))}catch(e){t=e}return $curGoroutine.deferStack.pop(),void $callDeferred(e,t)}if(!$curGoroutine.asleep){$stackDepthOffset--;var i=$panicStackDepth,a=$panicValue,o=$curGoroutine.panicStack.pop();void 0!==o&&($panicStackDepth=$getStackDepth(),$panicValue=o);try{for(;;){if(null===e&&void 0===(e=$curGoroutine.deferStack[$curGoroutine.deferStack.length-1])){if($panicStackDepth=null,o.Object instanceof Error)throw o.Object;var $;throw $=o.constructor===$String?o.$val:void 0!==o.Error?o.Error():void 0!==o.String?o.String():o,new Error($)}var c=e.pop();if(void 0===c){if($curGoroutine.deferStack.pop(),void 0!==o){e=null;continue}return}var u=c[0].apply(c[2],c[1]);if(u&&void 0!==u.$blk){if(e.push([u.$blk,[],u]),r)throw null;return}if(void 0!==o&&null===$panicStackDepth)throw null}}finally{void 0!==o&&(null!==$panicStackDepth&&$curGoroutine.panicStack.push(o),$panicStackDepth=i,$panicValue=a),$stackDepthOffset++}}},$panic=function(e){$curGoroutine.panicStack.push(e),$callDeferred(null,null,!0)},$recover=function(){return null===$panicStackDepth||void 0!==$panicStackDepth&&$panicStackDepth!==$getStackDepth()-2?$ifaceNil:($panicStackDepth=null,$panicValue)},$throw=function(e){throw e},$noGoroutine={asleep:!1,exit:!1,deferStack:[],panicStack:[]},$curGoroutine=$noGoroutine,$totalGoroutines=0,$awakeGoroutines=0,$checkForDeadlock=!0,$mainFinished=!1,$go=function(e,n){$totalGoroutines++,$awakeGoroutines++;var r=function(){try{$curGoroutine=r;var t=e.apply(void 0,n);if(t&&void 0!==t.$blk)return e=function(){return t.$blk()},void(n=[]);r.exit=!0}catch(e){if(!r.exit)throw e}finally{$curGoroutine=$noGoroutine,r.exit&&($totalGoroutines--,r.asleep=!0),r.asleep&&($awakeGoroutines--,!$mainFinished&&0===$awakeGoroutines&&$checkForDeadlock&&(console.error("fatal error: all goroutines are asleep - deadlock!"),void 0!==$global.process&&$global.process.exit(2)))}};r.asleep=!1,r.exit=!1,r.deferStack=[],r.panicStack=[],$schedule(r)},$scheduled=[],$runScheduled=function(){try{for(var e;void 0!==(e=$scheduled.shift());)e()}finally{$scheduled.length>0&&setTimeout($runScheduled,0)}},$schedule=function(e){e.asleep&&(e.asleep=!1,$awakeGoroutines++),$scheduled.push(e),$curGoroutine===$noGoroutine&&$runScheduled()},$setTimeout=function(e,n){return $awakeGoroutines++,setTimeout(function(){$awakeGoroutines--,e()},n)},$block=function(){$curGoroutine===$noGoroutine&&$throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine"),$curGoroutine.asleep=!0},$send=function(e,n){e.$closed&&$throwRuntimeError("send on closed channel");var r=e.$recvQueue.shift();if(void 0===r){if(!(e.$buffer.length65535){var u=Math.floor((c-65536)/1024)+55296,l=(c-65536)%1024+56320;$+=String.fromCharCode(u,l)}else $+=String.fromCharCode(c)}return $;case $kindStruct:var s=$packages.time;if(void 0!==s&&e.constructor===s.Time.ptr){var f=$div64(e.UnixNano(),new $Int64(0,1e6));return new Date($flatten64(f))}var d={},p=function(e,n){if(n===$jsObjectPtr)return e;switch(n.kind){case $kindPtr:return e===n.nil?d:p(e.$get(),n.elem);case $kindStruct:var r=n.fields[0];return p(e[r.prop],r.typ);case $kindInterface:return p(e.$val,e.constructor);default:return d}},h=p(e,n);if(h!==d)return h;h={};for(i=0;i>24;case $kindInt16:return parseInt(e)<<16>>16;case $kindInt32:return parseInt(e)>>0;case $kindUint:return parseInt(e);case $kindUint8:return parseInt(e)<<24>>>24;case $kindUint16:return parseInt(e)<<16>>>16;case $kindUint32:case $kindUintptr:return parseInt(e)>>>0;case $kindInt64:case $kindUint64:return new n(0,e);case $kindFloat32:case $kindFloat64:return parseFloat(e);case $kindArray:return e.length!==n.len&&$throwRuntimeError("got array with wrong size from JavaScript native"),$mapArray(e,function(e){return $internalize(e,n.elem)});case $kindFunc:return function(){for(var t=[],i=0;i=128)return!1;return!0}; + +$packages["github.com/gopherjs/gopherjs/js"]=(function(){var $pkg={},$init,A,B,L,N,O,P,Q,E,G,K;A=$pkg.Object=$newType(0,$kindStruct,"js.Object",true,"github.com/gopherjs/gopherjs/js",true,function(object_){this.$val=this;if(arguments.length===0){this.object=null;return;}this.object=object_;});B=$pkg.Error=$newType(0,$kindStruct,"js.Error",true,"github.com/gopherjs/gopherjs/js",true,function(Object_){this.$val=this;if(arguments.length===0){this.Object=null;return;}this.Object=Object_;});L=$sliceType($emptyInterface);N=$ptrType(A);O=$sliceType(N);P=$funcType([O],[N],true);Q=$ptrType(B);A.ptr.prototype.Get=function(a){var a,b;b=this;return b.object[$externalize(a,$String)];};A.prototype.Get=function(a){return this.$val.Get(a);};A.ptr.prototype.Set=function(a,b){var a,b,c;c=this;c.object[$externalize(a,$String)]=$externalize(b,$emptyInterface);};A.prototype.Set=function(a,b){return this.$val.Set(a,b);};A.ptr.prototype.Delete=function(a){var a,b;b=this;delete b.object[$externalize(a,$String)];};A.prototype.Delete=function(a){return this.$val.Delete(a);};A.ptr.prototype.Length=function(){var a;a=this;return $parseInt(a.object.length);};A.prototype.Length=function(){return this.$val.Length();};A.ptr.prototype.Index=function(a){var a,b;b=this;return b.object[a];};A.prototype.Index=function(a){return this.$val.Index(a);};A.ptr.prototype.SetIndex=function(a,b){var a,b,c;c=this;c.object[a]=$externalize(b,$emptyInterface);};A.prototype.SetIndex=function(a,b){return this.$val.SetIndex(a,b);};A.ptr.prototype.Call=function(a,b){var a,b,c,d;c=this;return(d=c.object,d[$externalize(a,$String)].apply(d,$externalize(b,L)));};A.prototype.Call=function(a,b){return this.$val.Call(a,b);};A.ptr.prototype.Invoke=function(a){var a,b;b=this;return b.object.apply(undefined,$externalize(a,L));};A.prototype.Invoke=function(a){return this.$val.Invoke(a);};A.ptr.prototype.New=function(a){var a,b;b=this;return new($global.Function.prototype.bind.apply(b.object,[undefined].concat($externalize(a,L))));};A.prototype.New=function(a){return this.$val.New(a);};A.ptr.prototype.Bool=function(){var a;a=this;return!!(a.object);};A.prototype.Bool=function(){return this.$val.Bool();};A.ptr.prototype.String=function(){var a;a=this;return $internalize(a.object,$String);};A.prototype.String=function(){return this.$val.String();};A.ptr.prototype.Int=function(){var a;a=this;return $parseInt(a.object)>>0;};A.prototype.Int=function(){return this.$val.Int();};A.ptr.prototype.Int64=function(){var a;a=this;return $internalize(a.object,$Int64);};A.prototype.Int64=function(){return this.$val.Int64();};A.ptr.prototype.Uint64=function(){var a;a=this;return $internalize(a.object,$Uint64);};A.prototype.Uint64=function(){return this.$val.Uint64();};A.ptr.prototype.Float=function(){var a;a=this;return $parseFloat(a.object);};A.prototype.Float=function(){return this.$val.Float();};A.ptr.prototype.Interface=function(){var a;a=this;return $internalize(a.object,$emptyInterface);};A.prototype.Interface=function(){return this.$val.Interface();};A.ptr.prototype.Unsafe=function(){var a;a=this;return a.object;};A.prototype.Unsafe=function(){return this.$val.Unsafe();};B.ptr.prototype.Error=function(){var a;a=this;return"JavaScript error: "+$internalize(a.Object.message,$String);};B.prototype.Error=function(){return this.$val.Error();};B.ptr.prototype.Stack=function(){var a;a=this;return $internalize(a.Object.stack,$String);};B.prototype.Stack=function(){return this.$val.Stack();};E=function(a){var a;return $makeFunc(a);};$pkg.MakeFunc=E;G=function(a){var a,b,c,d,e,f;b=a;c=new($global.Object)();c.__internal_object__=b;d=b.constructor.methods;e=0;while(true){if(!(e<$parseInt(d.length))){break;}f=[f];f[0]=d[e];if(!($internalize(f[0].pkg,$String)==="")){e=e+(1)>>0;continue;}c[$externalize($internalize(f[0].name,$String),$String)]=$externalize((function(f){return function(g){var g;return $externalizeFunction(b[$externalize($internalize(f[0].prop,$String),$String)],f[0].typ,$externalize(true,$Bool)).apply(b,$externalize(g,O));};})(f),P);e=e+(1)>>0;}return c;};$pkg.MakeWrapper=G;K=function(){var a;a=new B.ptr(null);$unused(a);};N.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([$String],[N],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([$String,$emptyInterface],[],false)},{prop:"Delete",name:"Delete",pkg:"",typ:$funcType([$String],[],false)},{prop:"Length",name:"Length",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Index",name:"Index",pkg:"",typ:$funcType([$Int],[N],false)},{prop:"SetIndex",name:"SetIndex",pkg:"",typ:$funcType([$Int,$emptyInterface],[],false)},{prop:"Call",name:"Call",pkg:"",typ:$funcType([$String,L],[N],true)},{prop:"Invoke",name:"Invoke",pkg:"",typ:$funcType([L],[N],true)},{prop:"New",name:"New",pkg:"",typ:$funcType([L],[N],true)},{prop:"Bool",name:"Bool",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Int",name:"Int",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Int64",name:"Int64",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"Float",name:"Float",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Interface",name:"Interface",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Unsafe",name:"Unsafe",pkg:"",typ:$funcType([],[$Uintptr],false)}];Q.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Stack",name:"Stack",pkg:"",typ:$funcType([],[$String],false)}];A.init("github.com/gopherjs/gopherjs/js",[{prop:"object",name:"object",embedded:false,exported:false,typ:N,tag:""}]);B.init("",[{prop:"Object",name:"Object",embedded:true,exported:true,typ:N,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:K();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/cpu"]=(function(){var $pkg={},$init;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/bytealg"]=(function(){var $pkg={},$init,A,I,K,M;A=$packages["internal/cpu"];I=function(b,c){var b,c;$panic(new $String("unimplemented"));};$pkg.Index=I;K=function(b){var b;$panic(new $String("unimplemented"));};$pkg.Cutover=K;M=function(b,c){var b,c,d;d=0;while(true){if(!(d>0;}return-1;};$pkg.IndexByteString=M;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.MaxLen=0;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["runtime/internal/sys"]=(function(){var $pkg={},$init;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["runtime"]=(function(){var $pkg={},$init,B,C,A,E,W,AQ,AR,AX,AY,AZ,BF,F,G,I,O,V,X,AJ,AK;B=$packages["github.com/gopherjs/gopherjs/js"];C=$packages["internal/bytealg"];A=$packages["runtime/internal/sys"];E=$pkg._type=$newType(0,$kindStruct,"runtime._type",true,"runtime",false,function(str_){this.$val=this;if(arguments.length===0){this.str="";return;}this.str=str_;});W=$pkg.Func=$newType(0,$kindStruct,"runtime.Func",true,"runtime",true,function(opaque_){this.$val=this;if(arguments.length===0){this.opaque=new AZ.ptr();return;}this.opaque=opaque_;});AQ=$pkg.TypeAssertionError=$newType(0,$kindStruct,"runtime.TypeAssertionError",true,"runtime",true,function(_interface_,concrete_,asserted_,missingMethod_){this.$val=this;if(arguments.length===0){this._interface=AX.nil;this.concrete=AX.nil;this.asserted=AX.nil;this.missingMethod="";return;}this._interface=_interface_;this.concrete=concrete_;this.asserted=asserted_;this.missingMethod=missingMethod_;});AR=$pkg.errorString=$newType(8,$kindString,"runtime.errorString",true,"runtime",false,null);AX=$ptrType(E);AY=$ptrType(W);AZ=$structType("",[]);BF=$ptrType(AQ);E.ptr.prototype.string=function(){var a;a=this;return a.str;};E.prototype.string=function(){return this.$val.string();};E.ptr.prototype.pkgpath=function(){var a;a=this;return"";};E.prototype.pkgpath=function(){return this.$val.pkgpath();};F=function(){var a,b;a=$packages[$externalize("github.com/gopherjs/gopherjs/js",$String)];$jsObjectPtr=a.Object.ptr;$jsErrorPtr=a.Error.ptr;$throwRuntimeError=AK;b=$ifaceNil;b=new AQ.ptr(AX.nil,AX.nil,AX.nil,"");$unused(b);};G=function(){var a,b,c;a=$global.process;if(a===undefined){return"/";}b=a.env.GOPHERJS_GOROOT;if(!(b===undefined)){return $internalize(b,$String);}else{c=a.env.GOROOT;if(!(c===undefined)){return $internalize(c,$String);}}return"/usr/local/go";};$pkg.GOROOT=G;I=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c="";d=0;e=false;f=new($global.Error)().stack.split($externalize("\n",$String))[(a+2>>0)];if(f===undefined){g=0;h="";i=0;j=false;b=g;c=h;d=i;e=j;return[b,c,d,e];}k=f.substring(($parseInt(f.indexOf($externalize("(",$String)))>>0)+1>>0,$parseInt(f.indexOf($externalize(")",$String)))>>0).split($externalize(":",$String));l=0;m=$internalize(k[0],$String);n=$parseInt(k[1])>>0;o=true;b=l;c=m;d=n;e=o;return[b,c,d,e];};$pkg.Caller=I;O=function(){$curGoroutine.exit=$externalize(true,$Bool);$throw(null);};$pkg.Goexit=O;V=function(a,b){var a,b;};$pkg.SetFinalizer=V;W.ptr.prototype.Entry=function(){return 0;};W.prototype.Entry=function(){return this.$val.Entry();};W.ptr.prototype.FileLine=function(a){var a,b,c,d,e;b="";c=0;d="";e=0;b=d;c=e;return[b,c];};W.prototype.FileLine=function(a){return this.$val.FileLine(a);};W.ptr.prototype.Name=function(){return"";};W.prototype.Name=function(){return this.$val.Name();};X=function(a){var a;return AY.nil;};$pkg.FuncForPC=X;AJ=function(a){var a;};$pkg.KeepAlive=AJ;AK=function(a){var a;$panic(new AR((a)));};AQ.ptr.prototype.RuntimeError=function(){};AQ.prototype.RuntimeError=function(){return this.$val.RuntimeError();};AQ.ptr.prototype.Error=function(){var a,b,c,d,e;a=this;b="interface";if(!(a._interface===AX.nil)){b=a._interface.string();}c=a.asserted.string();if(a.concrete===AX.nil){return"interface conversion: "+b+" is nil, not "+c;}d=a.concrete.string();if(a.missingMethod===""){e="interface conversion: "+b+" is "+d+", not "+c;if(d===c){if(!(a.concrete.pkgpath()===a.asserted.pkgpath())){e=e+(" (types from different packages)");}else{e=e+(" (types from different scopes)");}}return e;}return"interface conversion: "+d+" is not "+c+": missing method "+a.missingMethod;};AQ.prototype.Error=function(){return this.$val.Error();};AR.prototype.RuntimeError=function(){var a;a=this.$val;};$ptrType(AR).prototype.RuntimeError=function(){return new AR(this.$get()).RuntimeError();};AR.prototype.Error=function(){var a;a=this.$val;return"runtime error: "+(a);};$ptrType(AR).prototype.Error=function(){return new AR(this.$get()).Error();};AX.methods=[{prop:"string",name:"string",pkg:"runtime",typ:$funcType([],[$String],false)},{prop:"pkgpath",name:"pkgpath",pkg:"runtime",typ:$funcType([],[$String],false)}];AY.methods=[{prop:"Entry",name:"Entry",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"FileLine",name:"FileLine",pkg:"",typ:$funcType([$Uintptr],[$String,$Int],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)}];BF.methods=[{prop:"RuntimeError",name:"RuntimeError",pkg:"",typ:$funcType([],[],false)},{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];AR.methods=[{prop:"RuntimeError",name:"RuntimeError",pkg:"",typ:$funcType([],[],false)},{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];E.init("runtime",[{prop:"str",name:"str",embedded:false,exported:false,typ:$String,tag:""}]);W.init("runtime",[{prop:"opaque",name:"opaque",embedded:false,exported:false,typ:AZ,tag:""}]);AQ.init("runtime",[{prop:"_interface",name:"_interface",embedded:false,exported:false,typ:AX,tag:""},{prop:"concrete",name:"concrete",embedded:false,exported:false,typ:AX,tag:""},{prop:"asserted",name:"asserted",embedded:false,exported:false,typ:AX,tag:""},{prop:"missingMethod",name:"missingMethod",embedded:false,exported:false,typ:$String,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}F();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["errors"]=(function(){var $pkg={},$init,B,C,A;B=$pkg.errorString=$newType(0,$kindStruct,"errors.errorString",true,"errors",false,function(s_){this.$val=this;if(arguments.length===0){this.s="";return;}this.s=s_;});C=$ptrType(B);A=function(a){var a;return new B.ptr(a);};$pkg.New=A;B.ptr.prototype.Error=function(){var a;a=this;return a.s;};B.prototype.Error=function(){return this.$val.Error();};C.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];B.init("errors",[{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/race"]=(function(){var $pkg={},$init,A,B,C,D,E,H,I;A=function(a){var a;};$pkg.Acquire=A;B=function(a){var a;};$pkg.Release=B;C=function(a){var a;};$pkg.ReleaseMerge=C;D=function(){};$pkg.Disable=D;E=function(){};$pkg.Enable=E;H=function(a,b){var a,b;};$pkg.ReadRange=H;I=function(a,b){var a,b;};$pkg.WriteRange=I;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["sync/atomic"]=(function(){var $pkg={},$init,A,AF,AJ,H,K,N,S,V,Y,AA;A=$packages["github.com/gopherjs/gopherjs/js"];AF=$pkg.Value=$newType(0,$kindStruct,"atomic.Value",true,"sync/atomic",true,function(v_){this.$val=this;if(arguments.length===0){this.v=$ifaceNil;return;}this.v=v_;});AJ=$ptrType(AF);H=function(ad,ae,af){var ad,ae,af;if(ad.$get()===ae){ad.$set(af);return true;}return false;};$pkg.CompareAndSwapInt32=H;K=function(ad,ae,af){var ad,ae,af,ag;if((ag=ad.$get(),(ag.$high===ae.$high&&ag.$low===ae.$low))){ad.$set(af);return true;}return false;};$pkg.CompareAndSwapUint64=K;N=function(ad,ae){var ad,ae,af;af=ad.$get()+ae>>0;ad.$set(af);return af;};$pkg.AddInt32=N;S=function(ad){var ad;return ad.$get();};$pkg.LoadInt32=S;V=function(ad){var ad;return ad.$get();};$pkg.LoadUint64=V;Y=function(ad,ae){var ad,ae;ad.$set(ae);};$pkg.StoreInt32=Y;AA=function(ad,ae){var ad,ae;ad.$set(ae);};$pkg.StoreUint32=AA;AF.ptr.prototype.Load=function(){var ad,ae;ad=$ifaceNil;ae=this;ad=ae.v;return ad;};AF.prototype.Load=function(){return this.$val.Load();};AF.ptr.prototype.Store=function(ad){var ad,ae;ae=this;if($interfaceIsEqual(ad,$ifaceNil)){$panic(new $String("sync/atomic: store of nil value into Value"));}if(!($interfaceIsEqual(ae.v,$ifaceNil))&&!(ad.constructor===ae.v.constructor)){$panic(new $String("sync/atomic: store of inconsistently typed value into Value"));}ae.v=ad;};AF.prototype.Store=function(ad){return this.$val.Store(ad);};AJ.methods=[{prop:"Load",name:"Load",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Store",name:"Store",pkg:"",typ:$funcType([$emptyInterface],[],false)}];AF.init("sync/atomic",[{prop:"v",name:"v",embedded:false,exported:false,typ:$emptyInterface,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["sync"]=(function(){var $pkg={},$init,A,C,D,B,F,Z,AA,AC,AD,AO,AV,AW,AY,AZ,BA,BB,BC,BI,BL,BM,BN,BO,BR,CA,CD,H,I,W,AJ,G,K,L,M,N,O,P,AH,AK,AL,AT,AU;A=$packages["github.com/gopherjs/gopherjs/js"];C=$packages["internal/race"];D=$packages["runtime"];B=$packages["sync/atomic"];F=$pkg.Pool=$newType(0,$kindStruct,"sync.Pool",true,"sync",true,function(local_,localSize_,store_,New_){this.$val=this;if(arguments.length===0){this.local=0;this.localSize=0;this.store=BM.nil;this.New=$throwNilPointerError;return;}this.local=local_;this.localSize=localSize_;this.store=store_;this.New=New_;});Z=$pkg.Mutex=$newType(0,$kindStruct,"sync.Mutex",true,"sync",true,function(state_,sema_){this.$val=this;if(arguments.length===0){this.state=0;this.sema=0;return;}this.state=state_;this.sema=sema_;});AA=$pkg.Locker=$newType(8,$kindInterface,"sync.Locker",true,"sync",true,null);AC=$pkg.poolLocalInternal=$newType(0,$kindStruct,"sync.poolLocalInternal",true,"sync",false,function(private$0_,shared_,Mutex_){this.$val=this;if(arguments.length===0){this.private$0=$ifaceNil;this.shared=BM.nil;this.Mutex=new Z.ptr(0,0);return;}this.private$0=private$0_;this.shared=shared_;this.Mutex=Mutex_;});AD=$pkg.poolLocal=$newType(0,$kindStruct,"sync.poolLocal",true,"sync",false,function(poolLocalInternal_,pad_){this.$val=this;if(arguments.length===0){this.poolLocalInternal=new AC.ptr($ifaceNil,BM.nil,new Z.ptr(0,0));this.pad=CD.zero();return;}this.poolLocalInternal=poolLocalInternal_;this.pad=pad_;});AO=$pkg.notifyList=$newType(0,$kindStruct,"sync.notifyList",true,"sync",false,function(wait_,notify_,lock_,head_,tail_){this.$val=this;if(arguments.length===0){this.wait=0;this.notify=0;this.lock=0;this.head=0;this.tail=0;return;}this.wait=wait_;this.notify=notify_;this.lock=lock_;this.head=head_;this.tail=tail_;});AV=$pkg.RWMutex=$newType(0,$kindStruct,"sync.RWMutex",true,"sync",true,function(w_,writerSem_,readerSem_,readerCount_,readerWait_){this.$val=this;if(arguments.length===0){this.w=new Z.ptr(0,0);this.writerSem=0;this.readerSem=0;this.readerCount=0;this.readerWait=0;return;}this.w=w_;this.writerSem=writerSem_;this.readerSem=readerSem_;this.readerCount=readerCount_;this.readerWait=readerWait_;});AW=$pkg.rlocker=$newType(0,$kindStruct,"sync.rlocker",true,"sync",false,function(w_,writerSem_,readerSem_,readerCount_,readerWait_){this.$val=this;if(arguments.length===0){this.w=new Z.ptr(0,0);this.writerSem=0;this.readerSem=0;this.readerCount=0;this.readerWait=0;return;}this.w=w_;this.writerSem=writerSem_;this.readerSem=readerSem_;this.readerCount=readerCount_;this.readerWait=readerWait_;});AY=$ptrType(F);AZ=$sliceType(AY);BA=$ptrType($Uint32);BB=$chanType($Bool,false,false);BC=$sliceType(BB);BI=$ptrType($Int32);BL=$ptrType(AD);BM=$sliceType($emptyInterface);BN=$ptrType(AW);BO=$ptrType(AV);BR=$funcType([],[$emptyInterface],false);CA=$ptrType(Z);CD=$arrayType($Uint8,100);F.ptr.prototype.Get=function(){var l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(l.store.$length===0){$s=1;continue;}$s=2;continue;case 1:if(!(l.New===$throwNilPointerError)){$s=3;continue;}$s=4;continue;case 3:m=l.New();$s=5;case 5:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return m;case 4:$s=-1;return $ifaceNil;case 2:p=(n=l.store,o=l.store.$length-1>>0,((o<0||o>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]));l.store=$subslice(l.store,0,(l.store.$length-1>>0));$s=-1;return p;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Get};}$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Get=function(){return this.$val.Get();};F.ptr.prototype.Put=function(l){var l,m;m=this;if($interfaceIsEqual(l,$ifaceNil)){return;}m.store=$append(m.store,l);};F.prototype.Put=function(l){return this.$val.Put(l);};G=function(l){var l;};K=function(l,m){var l,m,n,o,p,q,r,s,t,u,v,w,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(((l.$get()-(n=I[BA.keyFor(l)],n!==undefined?n.v:0)>>>0))===0){$s=1;continue;}$s=2;continue;case 1:o=new $Chan($Bool,0);if(m){p=l;(H||$throwRuntimeError("assignment to entry in nil map"))[BA.keyFor(p)]={k:p,v:$appendSlice(new BC([o]),(q=H[BA.keyFor(l)],q!==undefined?q.v:BC.nil))};}else{r=l;(H||$throwRuntimeError("assignment to entry in nil map"))[BA.keyFor(r)]={k:r,v:$append((s=H[BA.keyFor(l)],s!==undefined?s.v:BC.nil),o)};}t=$recv(o);$s=3;case 3:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}t[0];u=l;(I||$throwRuntimeError("assignment to entry in nil map"))[BA.keyFor(u)]={k:u,v:(v=I[BA.keyFor(l)],v!==undefined?v.v:0)-(1)>>>0};if((w=I[BA.keyFor(l)],w!==undefined?w.v:0)===0){delete I[BA.keyFor(l)];}case 2:l.$set(l.$get()-(1)>>>0);$s=-1;return;}return;}if($f===undefined){$f={$blk:K};}$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.$s=$s;$f.$r=$r;return $f;};L=function(l,m){var l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l.$set(l.$get()+(1)>>>0);o=(n=H[BA.keyFor(l)],n!==undefined?n.v:BC.nil);if(o.$length===0){$s=-1;return;}p=(0>=o.$length?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+0]);o=$subslice(o,1);q=l;(H||$throwRuntimeError("assignment to entry in nil map"))[BA.keyFor(q)]={k:q,v:o};if(o.$length===0){delete H[BA.keyFor(l)];}r=l;(I||$throwRuntimeError("assignment to entry in nil map"))[BA.keyFor(r)]={k:r,v:(s=I[BA.keyFor(l)],s!==undefined?s.v:0)+(1)>>>0};$r=$send(p,true);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:L};}$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};M=function(l){var l;};N=function(l){var l;return false;};O=function(){return $mul64($internalize(new($global.Date)().getTime(),$Int64),new $Int64(0,1000000));};P=function(l){var l;$throwRuntimeError($externalize(l,$String));};Z.ptr.prototype.Lock=function(){var l,m,n,o,p,q,r,s,t,u,v,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(B.CompareAndSwapInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),0,1)){if(false){C.Acquire((l));}$s=-1;return;}m=new $Int64(0,0);n=false;o=false;p=0;q=l.state;case 1:if(((q&5)===1)&&N(p)){$s=3;continue;}$s=4;continue;case 3:if(!o&&((q&2)===0)&&!(((q>>3>>0)===0))&&B.CompareAndSwapInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),q,q|2)){o=true;}AU();p=p+(1)>>0;q=l.state;$s=1;continue;case 4:r=q;if((q&4)===0){r=r|(1);}if(!(((q&5)===0))){r=r+(8)>>0;}if(n&&!(((q&1)===0))){r=r|(4);}if(o){if((r&2)===0){P("sync: inconsistent mutex state");}r=(r&~(2))>>0;}if(B.CompareAndSwapInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),q,r)){$s=5;continue;}$s=6;continue;case 5:if((q&5)===0){$s=2;continue;}s=!((m.$high===0&&m.$low===0));if((m.$high===0&&m.$low===0)){m=O();}$r=K((l.$ptr_sema||(l.$ptr_sema=new BA(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},l))),s);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}n=n||(t=(u=O(),new $Int64(u.$high-m.$high,u.$low-m.$low)),(t.$high>0||(t.$high===0&&t.$low>1000000)));q=l.state;if(!(((q&4)===0))){if(!(((q&3)===0))||((q>>3>>0)===0)){P("sync: inconsistent mutex state");}v=-7;if(!n||((q>>3>>0)===1)){v=v-(4)>>0;}B.AddInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),v);$s=2;continue;}o=true;p=0;$s=7;continue;case 6:q=l.state;case 7:$s=1;continue;case 2:if(false){C.Acquire((l));}$s=-1;return;}return;}if($f===undefined){$f={$blk:Z.ptr.prototype.Lock};}$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.$s=$s;$f.$r=$r;return $f;};Z.prototype.Lock=function(){return this.$val.Lock();};Z.ptr.prototype.Unlock=function(){var l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(false){$unused(l.state);C.Release((l));}m=B.AddInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),-1);if((((m+1>>0))&1)===0){P("sync: unlock of unlocked mutex");}if((m&4)===0){$s=1;continue;}$s=2;continue;case 1:n=m;case 4:if(((n>>3>>0)===0)||!(((n&7)===0))){$s=-1;return;}m=((n-8>>0))|2;if(B.CompareAndSwapInt32((l.$ptr_state||(l.$ptr_state=new BI(function(){return this.$target.state;},function($v){this.$target.state=$v;},l))),n,m)){$s=6;continue;}$s=7;continue;case 6:$r=L((l.$ptr_sema||(l.$ptr_sema=new BA(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},l))),false);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 7:n=l.state;$s=4;continue;case 5:$s=3;continue;case 2:$r=L((l.$ptr_sema||(l.$ptr_sema=new BA(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},l))),true);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:$s=-1;return;}return;}if($f===undefined){$f={$blk:Z.ptr.prototype.Unlock};}$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};Z.prototype.Unlock=function(){return this.$val.Unlock();};AH=function(){var l,m,n,o,p,q,r,s,t,u;l=AJ;m=0;while(true){if(!(m=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]);((n<0||n>=AJ.$length)?($throwRuntimeError("index out of range"),undefined):AJ.$array[AJ.$offset+n]=AY.nil);p=0;while(true){if(!(p<((o.localSize>>0)))){break;}q=AL(o.local,p);q.poolLocalInternal.private$0=$ifaceNil;r=q.poolLocalInternal.shared;s=0;while(true){if(!(s=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+t]=$ifaceNil));s++;}q.poolLocalInternal.shared=BM.nil;p=p+(1)>>0;}o.local=0;o.localSize=0;m++;}AJ=new AZ([]);};AK=function(){G(AH);};AL=function(l,m){var l,m,n;n=(((l)+($imul(((m>>>0)),128)>>>0)>>>0));return($pointerOfStructConversion(n,BL));};AT=function(){var l;l=new AO.ptr(0,0,0,0,0);M(20);};AU=function(){$throwRuntimeError("native function not implemented: sync.runtime_doSpin");};AV.ptr.prototype.RLock=function(){var l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(false){$unused(l.w.state);C.Disable();}if(B.AddInt32((l.$ptr_readerCount||(l.$ptr_readerCount=new BI(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},l))),1)<0){$s=1;continue;}$s=2;continue;case 1:$r=K((l.$ptr_readerSem||(l.$ptr_readerSem=new BA(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},l))),false);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(false){C.Enable();C.Acquire(((l.$ptr_readerSem||(l.$ptr_readerSem=new BA(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},l)))));}$s=-1;return;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.RLock};}$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.RLock=function(){return this.$val.RLock();};AV.ptr.prototype.RUnlock=function(){var l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(false){$unused(l.w.state);C.ReleaseMerge(((l.$ptr_writerSem||(l.$ptr_writerSem=new BA(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},l)))));C.Disable();}m=B.AddInt32((l.$ptr_readerCount||(l.$ptr_readerCount=new BI(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},l))),-1);if(m<0){$s=1;continue;}$s=2;continue;case 1:if(((m+1>>0)===0)||((m+1>>0)===-1073741824)){C.Enable();P("sync: RUnlock of unlocked RWMutex");}if(B.AddInt32((l.$ptr_readerWait||(l.$ptr_readerWait=new BI(function(){return this.$target.readerWait;},function($v){this.$target.readerWait=$v;},l))),-1)===0){$s=3;continue;}$s=4;continue;case 3:$r=L((l.$ptr_writerSem||(l.$ptr_writerSem=new BA(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},l))),false);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 4:case 2:if(false){C.Enable();}$s=-1;return;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.RUnlock};}$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.RUnlock=function(){return this.$val.RUnlock();};AV.ptr.prototype.Lock=function(){var l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(false){$unused(l.w.state);C.Disable();}$r=l.w.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}m=B.AddInt32((l.$ptr_readerCount||(l.$ptr_readerCount=new BI(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},l))),-1073741824)+1073741824>>0;if(!((m===0))&&!((B.AddInt32((l.$ptr_readerWait||(l.$ptr_readerWait=new BI(function(){return this.$target.readerWait;},function($v){this.$target.readerWait=$v;},l))),m)===0))){$s=2;continue;}$s=3;continue;case 2:$r=K((l.$ptr_writerSem||(l.$ptr_writerSem=new BA(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},l))),false);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:if(false){C.Enable();C.Acquire(((l.$ptr_readerSem||(l.$ptr_readerSem=new BA(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},l)))));C.Acquire(((l.$ptr_writerSem||(l.$ptr_writerSem=new BA(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},l)))));}$s=-1;return;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.Lock};}$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.Lock=function(){return this.$val.Lock();};AV.ptr.prototype.Unlock=function(){var l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;if(false){$unused(l.w.state);C.Release(((l.$ptr_readerSem||(l.$ptr_readerSem=new BA(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},l)))));C.Disable();}m=B.AddInt32((l.$ptr_readerCount||(l.$ptr_readerCount=new BI(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},l))),1073741824);if(m>=1073741824){C.Enable();P("sync: Unlock of unlocked RWMutex");}n=0;case 1:if(!(n<((m>>0)))){$s=2;continue;}$r=L((l.$ptr_readerSem||(l.$ptr_readerSem=new BA(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},l))),false);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}n=n+(1)>>0;$s=1;continue;case 2:$r=l.w.Unlock();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(false){C.Enable();}$s=-1;return;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.Unlock};}$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.Unlock=function(){return this.$val.Unlock();};AV.ptr.prototype.RLocker=function(){var l;l=this;return($pointerOfStructConversion(l,BN));};AV.prototype.RLocker=function(){return this.$val.RLocker();};AW.ptr.prototype.Lock=function(){var l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;$r=($pointerOfStructConversion(l,BO)).RLock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AW.ptr.prototype.Lock};}$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AW.prototype.Lock=function(){return this.$val.Lock();};AW.ptr.prototype.Unlock=function(){var l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;$r=($pointerOfStructConversion(l,BO)).RUnlock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AW.ptr.prototype.Unlock};}$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AW.prototype.Unlock=function(){return this.$val.Unlock();};AY.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Put",name:"Put",pkg:"",typ:$funcType([$emptyInterface],[],false)},{prop:"getSlow",name:"getSlow",pkg:"sync",typ:$funcType([],[$emptyInterface],false)},{prop:"pin",name:"pin",pkg:"sync",typ:$funcType([],[BL],false)},{prop:"pinSlow",name:"pinSlow",pkg:"sync",typ:$funcType([],[BL],false)}];CA.methods=[{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}];BO.methods=[{prop:"RLock",name:"RLock",pkg:"",typ:$funcType([],[],false)},{prop:"RUnlock",name:"RUnlock",pkg:"",typ:$funcType([],[],false)},{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)},{prop:"RLocker",name:"RLocker",pkg:"",typ:$funcType([],[AA],false)}];BN.methods=[{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}];F.init("sync",[{prop:"local",name:"local",embedded:false,exported:false,typ:$UnsafePointer,tag:""},{prop:"localSize",name:"localSize",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"store",name:"store",embedded:false,exported:false,typ:BM,tag:""},{prop:"New",name:"New",embedded:false,exported:true,typ:BR,tag:""}]);Z.init("sync",[{prop:"state",name:"state",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"sema",name:"sema",embedded:false,exported:false,typ:$Uint32,tag:""}]);AA.init([{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}]);AC.init("sync",[{prop:"private$0",name:"private",embedded:false,exported:false,typ:$emptyInterface,tag:""},{prop:"shared",name:"shared",embedded:false,exported:false,typ:BM,tag:""},{prop:"Mutex",name:"Mutex",embedded:true,exported:true,typ:Z,tag:""}]);AD.init("sync",[{prop:"poolLocalInternal",name:"poolLocalInternal",embedded:true,exported:false,typ:AC,tag:""},{prop:"pad",name:"pad",embedded:false,exported:false,typ:CD,tag:""}]);AO.init("sync",[{prop:"wait",name:"wait",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"notify",name:"notify",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"lock",name:"lock",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"head",name:"head",embedded:false,exported:false,typ:$UnsafePointer,tag:""},{prop:"tail",name:"tail",embedded:false,exported:false,typ:$UnsafePointer,tag:""}]);AV.init("sync",[{prop:"w",name:"w",embedded:false,exported:false,typ:Z,tag:""},{prop:"writerSem",name:"writerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerSem",name:"readerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerCount",name:"readerCount",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"readerWait",name:"readerWait",embedded:false,exported:false,typ:$Int32,tag:""}]);AW.init("sync",[{prop:"w",name:"w",embedded:false,exported:false,typ:Z,tag:""},{prop:"writerSem",name:"writerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerSem",name:"readerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerCount",name:"readerCount",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"readerWait",name:"readerWait",embedded:false,exported:false,typ:$Int32,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}AJ=AZ.nil;H={};I={};W=(new Uint8Array(8));AK();AT();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["io"]=(function(){var $pkg={},$init,A,B,C,D,E,T,V,W,X,AY,AJ,AK,Y,Z,AA;A=$packages["errors"];B=$packages["sync"];C=$packages["sync/atomic"];D=$pkg.Reader=$newType(8,$kindInterface,"io.Reader",true,"io",true,null);E=$pkg.Writer=$newType(8,$kindInterface,"io.Writer",true,"io",true,null);T=$pkg.ByteScanner=$newType(8,$kindInterface,"io.ByteScanner",true,"io",true,null);V=$pkg.RuneReader=$newType(8,$kindInterface,"io.RuneReader",true,"io",true,null);W=$pkg.RuneScanner=$newType(8,$kindInterface,"io.RuneScanner",true,"io",true,null);X=$pkg.StringWriter=$newType(8,$kindInterface,"io.StringWriter",true,"io",true,null);AY=$sliceType($Uint8);Y=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=$ifaceNil;e=$assertType(a,X,true);f=e[0];g=e[1];if(g){$s=1;continue;}$s=2;continue;case 1:i=f.WriteString(b);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;c=h[0];d=h[1];$s=-1;return[c,d];case 2:k=a.Write((new AY($stringToBytes(b))));$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;c=j[0];d=j[1];$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:Y};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};$pkg.WriteString=Y;Z=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;if(b.$length>0;$s=1;continue;case 2:if(d>=c){e=$ifaceNil;}else if(d>0&&$interfaceIsEqual(e,$pkg.EOF)){e=$pkg.ErrUnexpectedEOF;}$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:Z};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};$pkg.ReadAtLeast=Z;AA=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=$ifaceNil;f=Z(a,b,b.$length);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;c=e[0];d=e[1];$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:AA};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};$pkg.ReadFull=AA;D.init([{prop:"Read",name:"Read",pkg:"",typ:$funcType([AY],[$Int,$error],false)}]);E.init([{prop:"Write",name:"Write",pkg:"",typ:$funcType([AY],[$Int,$error],false)}]);T.init([{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)}]);V.init([{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)}]);W.init([{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)}]);X.init([{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrShortWrite=A.New("short write");$pkg.ErrShortBuffer=A.New("short buffer");$pkg.EOF=A.New("EOF");$pkg.ErrUnexpectedEOF=A.New("unexpected EOF");$pkg.ErrNoProgress=A.New("multiple Read calls return no data or error");AJ=A.New("Seek: invalid whence");AK=A.New("Seek: invalid offset");$pkg.ErrClosedPipe=A.New("io: read/write on closed pipe");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["hash"]=(function(){var $pkg={},$init,A,B,E;A=$packages["io"];B=$pkg.Hash=$newType(8,$kindInterface,"hash.Hash",true,"hash",true,null);E=$sliceType($Uint8);B.init([{prop:"BlockSize",name:"BlockSize",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Sum",name:"Sum",pkg:"",typ:$funcType([E],[E],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([E],[$Int,$error],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["math/bits"]=(function(){var $pkg={},$init,I,J,BC,D,H,K,N,O,AI,AL,AM;D=function(a){var a;return 32-AI(a)>>0;};$pkg.LeadingZeros=D;H=function(a){var a;return 64-AM(a)>>0;};$pkg.LeadingZeros64=H;K=function(a){var a;if(true){return N(((a>>>0)));}return O((new $Uint64(0,a)));};$pkg.TrailingZeros=K;N=function(a){var a,b;if(a===0){return 32;}return(((b=($imul((((a&(-a>>>0))>>>0)),125613361)>>>0)>>>27>>>0,((b<0||b>=I.length)?($throwRuntimeError("index out of range"),undefined):I[b]))>>0));};$pkg.TrailingZeros32=N;O=function(a){var a,b,c;if((a.$high===0&&a.$low===0)){return 64;}return(((b=$shiftRightUint64($mul64(((c=new $Uint64(-a.$high,-a.$low),new $Uint64(a.$high&c.$high,(a.$low&c.$low)>>>0))),new $Uint64(66559345,3033172745)),58),(($flatten64(b)<0||$flatten64(b)>=J.length)?($throwRuntimeError("index out of range"),undefined):J[$flatten64(b)]))>>0));};$pkg.TrailingZeros64=O;AI=function(a){var a;if(true){return AL(((a>>>0)));}return AM((new $Uint64(0,a)));};$pkg.Len=AI;AL=function(a){var a,b,c,d;b=0;if(a>=65536){a=(c=(16),c<32?(a>>>c):0)>>>0;b=16;}if(a>=256){a=(d=(8),d<32?(a>>>d):0)>>>0;b=b+(8)>>0;}b=b+((((a<0||a>=BC.length)?($throwRuntimeError("index out of range"),undefined):BC[a])>>0))>>0;return b;};$pkg.Len32=AL;AM=function(a){var a,b;b=0;if((a.$high>1||(a.$high===1&&a.$low>=0))){a=$shiftRightUint64(a,(32));b=32;}if((a.$high>0||(a.$high===0&&a.$low>=65536))){a=$shiftRightUint64(a,(16));b=b+(16)>>0;}if((a.$high>0||(a.$high===0&&a.$low>=256))){a=$shiftRightUint64(a,(8));b=b+(8)>>0;}b=b+(((($flatten64(a)<0||$flatten64(a)>=BC.length)?($throwRuntimeError("index out of range"),undefined):BC[$flatten64(a)])>>0))>>0;return b;};$pkg.Len64=AM;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:I=$toNativeArray($kindUint8,[0,1,28,2,29,14,24,3,30,22,20,15,25,17,4,8,31,27,13,23,21,19,16,7,26,12,18,6,11,5,10,9]);J=$toNativeArray($kindUint8,[0,1,56,2,57,49,28,3,61,58,42,50,38,29,17,4,62,47,59,36,45,43,51,22,53,39,33,30,24,18,12,5,63,55,48,27,60,41,37,16,46,35,44,21,52,32,23,11,54,26,40,15,34,20,31,10,25,14,19,9,13,8,7,6]);BC=$toNativeArray($kindUint8,[0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["math"]=(function(){var $pkg={},$init,A,B,FV,FW,FX,FY,C,D,E,F,G,AY,P,Q,V,Y,Z,AB,AC,AD,AE,AF,AI,AJ,AN,AO,AQ,AU,AZ,BA,BB,BC,BD,BE,BO,BR,CE,CG,EE,EQ;A=$packages["github.com/gopherjs/gopherjs/js"];B=$packages["math/bits"];FV=$arrayType($Uint32,2);FW=$arrayType($Float32,2);FX=$arrayType($Float64,1);FY=$structType("math",[{prop:"uint32array",name:"uint32array",embedded:false,exported:false,typ:FV,tag:""},{prop:"float32array",name:"float32array",embedded:false,exported:false,typ:FW,tag:""},{prop:"float64array",name:"float64array",embedded:false,exported:false,typ:FX,tag:""}]);P=function(av){var av;return $parseFloat(C.ceil(av));};$pkg.Ceil=P;Q=function(av,aw){var av,aw;if(!((av<0||(1/av===F))===(aw<0||(1/aw===F)))){return-av;}return av;};$pkg.Copysign=Q;V=function(av){var av;return $parseFloat(C.exp(av));};$pkg.Exp=V;Y=function(av){var av;return $parseFloat(C.floor(av));};$pkg.Floor=Y;Z=function(av){var av,aw,ax,ay;aw=0;ax=0;ay=CG(av);aw=ay[0];ax=ay[1];return[aw,ax];};$pkg.Frexp=Z;AB=function(av){var av;if(av>=0){return E;}else{return F;}};$pkg.Inf=AB;AC=function(av,aw){var av,aw;if(av===E){return aw>=0;}if(av===F){return aw<=0;}return false;};$pkg.IsInf=AC;AD=function(av){var av,aw;aw=false;aw=!((av===av));return aw;};$pkg.IsNaN=AD;AE=function(av,aw){var av,aw;if(-1024>>0));AY.uint32array[1]=(($shiftRightUint64(av,32).$low>>>0));return AY.float64array[0];};$pkg.Float64frombits=BD;BE=function(av){var av,aw;return BD((aw=BC(av),new $Uint64(aw.$high&~2147483648,(aw.$low&~0)>>>0)));};$pkg.Abs=BE;BO=function(av){var av,aw,ax,ay,az,ba,bb;aw=0;ax=0;if(BE(av)<2.2250738585072014e-308){ay=av*4.503599627370496e+15;az=-52;aw=ay;ax=az;return[aw,ax];}ba=av;bb=0;aw=ba;ax=bb;return[aw,ax];};BR=function(av,aw){var av,aw;if(AC(av,1)||AC(aw,1)){return AB(1);}else if(AD(av)||AD(aw)){return AN();}else if((av===0)&&(av===aw)){if(AQ(av)){return aw;}return av;}if(av>aw){return av;}return aw;};CE=function(av){var av,aw,ax,ay,az,ba,bb;aw=BC(av);ax=((($shiftRightUint64(aw,52).$low>>>0))&2047)>>>0;if(ax<1023){aw=(ay=new $Uint64(2147483648,0),new $Uint64(aw.$high&ay.$high,(aw.$low&ay.$low)>>>0));if(ax===1022){aw=(az=new $Uint64(1072693248,0),new $Uint64(aw.$high|az.$high,(aw.$low|az.$low)>>>0));}}else if(ax<1075){ax=ax-(1023)>>>0;aw=(ba=$shiftRightUint64(new $Uint64(524288,0),ax),new $Uint64(aw.$high+ba.$high,aw.$low+ba.$low));aw=(bb=$shiftRightUint64(new $Uint64(1048575,4294967295),ax),new $Uint64(aw.$high&~bb.$high,(aw.$low&~bb.$low)>>>0));}return BD(aw);};$pkg.Round=CE;CG=function(av){var av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg;aw=0;ax=0;if((av===0)){ay=av;az=0;aw=ay;ax=az;return[aw,ax];}else if(AC(av,0)||AD(av)){ba=av;bb=0;aw=ba;ax=bb;return[aw,ax];}bc=BO(av);av=bc[0];ax=bc[1];bd=BC(av);ax=ax+((((((be=$shiftRightUint64(bd,52),new $Uint64(be.$high&0,(be.$low&2047)>>>0)).$low>>0))-1023>>0)+1>>0))>>0;bd=(bf=new $Uint64(2146435072,0),new $Uint64(bd.$high&~bf.$high,(bd.$low&~bf.$low)>>>0));bd=(bg=new $Uint64(1071644672,0),new $Uint64(bd.$high|bg.$high,(bd.$low|bg.$low)>>>0));aw=BD(bd);return[aw,ax];};EE=function(av,aw){var av,aw,ax,ay,az,ba,bb,bc;if((av===0)){return av;}else if(AC(av,0)||AD(av)){return av;}ax=BO(av);av=ax[0];ay=ax[1];aw=aw+(ay)>>0;az=BC(av);aw=aw+((((($shiftRightUint64(az,52).$low>>0))&2047)-1023>>0))>>0;if(aw<-1075){return Q(0,av);}if(aw>1023){if(av<0){return AB(-1);}return AB(1);}ba=1;if(aw<-1022){aw=aw+(53)>>0;ba=1.1102230246251565e-16;}az=(bb=new $Uint64(2146435072,0),new $Uint64(az.$high&~bb.$high,(az.$low&~bb.$low)>>>0));az=(bc=$shiftLeft64((new $Uint64(0,(aw+1023>>0))),52),new $Uint64(az.$high|bc.$high,(az.$low|bc.$low)>>>0));return ba*BD(az);};EQ=function(av){var av,aw,ax,ay;aw=Z(av);ax=aw[0];ay=aw[1];if(ax===0.5){return((ay-1>>0));}return AF(ax)*1.4426950408889634+(ay);};$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}AY=new FY.ptr(FV.zero(),FW.zero(),FX.zero());C=$global.Math;D=0;E=1/D;F=-1/D;G=0/D;AZ();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["unicode/utf8"]=(function(){var $pkg={},$init,B,A,C,F,G,H,I,J,K,L,M,N,P,Q;B=$pkg.acceptRange=$newType(0,$kindStruct,"utf8.acceptRange",true,"unicode/utf8",false,function(lo_,hi_){this.$val=this;if(arguments.length===0){this.lo=0;this.hi=0;return;}this.lo=lo_;this.hi=hi_;});F=function(a){var a,aa,ab,ac,ad,ae,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;b=0;c=0;d=a.$length;if(d<1){e=65533;f=0;b=e;c=f;return[b,c];}g=(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]);h=((g<0||g>=A.length)?($throwRuntimeError("index out of range"),undefined):A[g]);if(h>=240){i=(((h>>0))<<31>>0)>>31>>0;j=(((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])>>0))&~i)>>0)|(65533&i);k=1;b=j;c=k;return[b,c];}l=(h&7)>>>0;n=$clone((m=h>>>4<<24>>>24,((m<0||m>=C.length)?($throwRuntimeError("index out of range"),undefined):C[m])),B);if(d<((l>>0))){o=65533;p=1;b=o;c=p;return[b,c];}q=(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]);if(q>>0)>>0))<<6>>0)|((((q&63)>>>0)>>0));u=2;b=t;c=u;return[b,c];}v=(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]);if(v<128||191>>0)>>0))<<12>>0)|(((((q&63)>>>0)>>0))<<6>>0))|((((v&63)>>>0)>>0));z=3;b=y;c=z;return[b,c];}aa=(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]);if(aa<128||191>>0)>>0))<<18>>0)|(((((q&63)>>>0)>>0))<<12>>0))|(((((v&63)>>>0)>>0))<<6>>0))|((((aa&63)>>>0)>>0));ae=4;b=ad;c=ae;return[b,c];};$pkg.DecodeRune=F;G=function(a){var a,aa,ab,ac,ad,ae,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;b=0;c=0;d=a.length;if(d<1){e=65533;f=0;b=e;c=f;return[b,c];}g=a.charCodeAt(0);h=((g<0||g>=A.length)?($throwRuntimeError("index out of range"),undefined):A[g]);if(h>=240){i=(((h>>0))<<31>>0)>>31>>0;j=((((a.charCodeAt(0)>>0))&~i)>>0)|(65533&i);k=1;b=j;c=k;return[b,c];}l=(h&7)>>>0;n=$clone((m=h>>>4<<24>>>24,((m<0||m>=C.length)?($throwRuntimeError("index out of range"),undefined):C[m])),B);if(d<((l>>0))){o=65533;p=1;b=o;c=p;return[b,c];}q=a.charCodeAt(1);if(q>>0)>>0))<<6>>0)|((((q&63)>>>0)>>0));u=2;b=t;c=u;return[b,c];}v=a.charCodeAt(2);if(v<128||191>>0)>>0))<<12>>0)|(((((q&63)>>>0)>>0))<<6>>0))|((((v&63)>>>0)>>0));z=3;b=y;c=z;return[b,c];}aa=a.charCodeAt(3);if(aa<128||191>>0)>>0))<<18>>0)|(((((q&63)>>>0)>>0))<<12>>0))|(((((v&63)>>>0)>>0))<<6>>0))|((((aa&63)>>>0)>>0));ae=4;b=ad;c=ae;return[b,c];};$pkg.DecodeRuneInString=G;H=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c=0;d=a.$length;if(d===0){e=65533;f=0;b=e;c=f;return[b,c];}g=d-1>>0;b=((((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g])>>0));if(b<128){h=b;i=1;b=h;c=i;return[b,c];}j=d-4>>0;if(j<0){j=0;}g=g-(1)>>0;while(true){if(!(g>=j)){break;}if(N(((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]))){break;}g=g-(1)>>0;}if(g<0){g=0;}k=F($subslice(a,g,d));b=k[0];c=k[1];if(!(((g+c>>0)===d))){l=65533;m=1;b=l;c=m;return[b,c];}n=b;o=c;b=n;c=o;return[b,c];};$pkg.DecodeLastRune=H;I=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c=0;d=a.length;if(d===0){e=65533;f=0;b=e;c=f;return[b,c];}g=d-1>>0;b=((a.charCodeAt(g)>>0));if(b<128){h=b;i=1;b=h;c=i;return[b,c];}j=d-4>>0;if(j<0){j=0;}g=g-(1)>>0;while(true){if(!(g>=j)){break;}if(N(a.charCodeAt(g))){break;}g=g-(1)>>0;}if(g<0){g=0;}k=G($substring(a,g,d));b=k[0];c=k[1];if(!(((g+c>>0)===d))){l=65533;m=1;b=l;c=m;return[b,c];}n=b;o=c;b=n;c=o;return[b,c];};$pkg.DecodeLastRuneInString=I;J=function(a){var a;if(a<0){return-1;}else if(a<=127){return 1;}else if(a<=2047){return 2;}else if(55296<=a&&a<=57343){return-1;}else if(a<=65535){return 3;}else if(a<=1114111){return 4;}return-1;};$pkg.RuneLen=J;K=function(a,b){var a,b,c;c=((b>>>0));if(c<=127){(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((b<<24>>>24)));return 1;}else if(c<=2047){$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((192|(((b>>6>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 2;}else if((c>1114111)||(55296<=c&&c<=57343)){b=65533;$unused((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((224|(((b>>12>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 3;}else if(c<=65535){$unused((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((224|(((b>>12>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 3;}else{$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((240|(((b>>18>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>12>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 4;}};$pkg.EncodeRune=K;L=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=a.$length;c=0;d=0;while(true){if(!(d>0;e=((d<0||d>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+d]);if(e<128){d=d+(1)>>0;continue;}f=((e<0||e>=A.length)?($throwRuntimeError("index out of range"),undefined):A[e]);if(f===241){d=d+(1)>>0;continue;}g=((((f&7)>>>0)>>0));if((d+g>>0)>b){d=d+(1)>>0;continue;}i=$clone((h=f>>>4<<24>>>24,((h<0||h>=C.length)?($throwRuntimeError("index out of range"),undefined):C[h])),B);k=(j=d+1>>0,((j<0||j>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+j]));if(k>0,((l<0||l>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+l]));if(m<128||191>0,((n<0||n>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+n]));if(o<128||191>0;}return c;};$pkg.RuneCount=L;M=function(a){var a,b,c,d,e,f,g,h,i,j,k,l;b=0;c=a.length;d=0;while(true){if(!(d>0;b=b+(1)>>0;continue;}f=((e<0||e>=A.length)?($throwRuntimeError("index out of range"),undefined):A[e]);if(f===241){d=d+(1)>>0;b=b+(1)>>0;continue;}g=((((f&7)>>>0)>>0));if((d+g>>0)>c){d=d+(1)>>0;b=b+(1)>>0;continue;}i=$clone((h=f>>>4<<24>>>24,((h<0||h>=C.length)?($throwRuntimeError("index out of range"),undefined):C[h])),B);j=a.charCodeAt((d+1>>0));if(j>0));if(k<128||191>0));if(l<128||191>0;b=b+(1)>>0;}b=b;return b;};$pkg.RuneCountInString=M;N=function(a){var a;return!((((a&192)>>>0)===128));};$pkg.RuneStart=N;P=function(a){var a,b,c,d,e,f,g,h,i,j,k;b=a.length;c=0;while(true){if(!(c>0;continue;}e=((d<0||d>=A.length)?($throwRuntimeError("index out of range"),undefined):A[d]);if(e===241){return false;}f=((((e&7)>>>0)>>0));if((c+f>>0)>b){return false;}h=$clone((g=e>>>4<<24>>>24,((g<0||g>=C.length)?($throwRuntimeError("index out of range"),undefined):C[g])),B);i=a.charCodeAt((c+1>>0));if(i>0));if(j<128||191>0));if(k<128||191>0;}return true;};$pkg.ValidString=P;Q=function(a){var a;if(0<=a&&a<55296){return true;}else if(57343>>24;}e=b.charCodeAt(c);if(65<=e&&e<=90){e=e+(32)<<24>>>24;}if(!((d===e))){return false;}c=c+(1)>>0;}return true;};K=function(a){var a,b,c,d,e,f,g,h,i,j,k,l;b=0;c=false;if(a.length===0){return[b,c];}d=a.charCodeAt(0);if(d===(43)){if(J(a,"+inf")||J(a,"+infinity")){e=A.Inf(1);f=true;b=e;c=f;return[b,c];}}else if(d===(45)){if(J(a,"-inf")||J(a,"-infinity")){g=A.Inf(-1);h=true;b=g;c=h;return[b,c];}}else if((d===(110))||(d===(78))){if(J(a,"nan")){i=A.NaN();j=true;b=i;c=j;return[b,c];}}else if((d===(105))||(d===(73))){if(J(a,"inf")||J(a,"infinity")){k=A.Inf(1);l=true;b=k;c=l;return[b,c];}}else{return[b,c];}return[b,c];};AC.ptr.prototype.set=function(a){var a,b,c,d,e,f,g,h,i,j;b=false;c=this;d=0;c.neg=false;c.trunc=false;if(d>=a.length){return b;}if((a.charCodeAt(d)===43)){d=d+(1)>>0;}else if((a.charCodeAt(d)===45)){c.neg=true;d=d+(1)>>0;}e=false;f=false;while(true){if(!(d>0;continue;}else if(48<=a.charCodeAt(d)&&a.charCodeAt(d)<=57){f=true;if((a.charCodeAt(d)===48)&&(c.nd===0)){c.dp=c.dp-(1)>>0;d=d+(1)>>0;continue;}if(c.nd<800){(g=c.d,h=c.nd,((h<0||h>=g.length)?($throwRuntimeError("index out of range"),undefined):g[h]=a.charCodeAt(d)));c.nd=c.nd+(1)>>0;}else if(!((a.charCodeAt(d)===48))){c.trunc=true;}d=d+(1)>>0;continue;}break;}if(!f){return b;}if(!e){c.dp=c.nd;}if(d>0;if(d>=a.length){return b;}i=1;if(a.charCodeAt(d)===43){d=d+(1)>>0;}else if(a.charCodeAt(d)===45){d=d+(1)>>0;i=-1;}if(d>=a.length||a.charCodeAt(d)<48||a.charCodeAt(d)>57){return b;}j=0;while(true){if(!(d>0))>>0)-48>>0;}d=d+(1)>>0;}c.dp=c.dp+(($imul(j,i)))>>0;}if(!((d===a.length))){return b;}b=true;return b;};AC.prototype.set=function(a){return this.$val.set(a);};L=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;b=new $Uint64(0,0);c=0;d=false;e=false;f=false;g=0;if(g>=a.length){return[b,c,d,e,f];}if((a.charCodeAt(g)===43)){g=g+(1)>>0;}else if((a.charCodeAt(g)===45)){d=true;g=g+(1)>>0;}h=false;i=false;j=0;k=0;l=0;while(true){if(!(g>0;continue;}else if(n===(48<=m&&m<=57)){i=true;if((m===48)&&(j===0)){l=l-(1)>>0;g=g+(1)>>0;continue;}j=j+(1)>>0;if(k<19){b=$mul64(b,(new $Uint64(0,10)));b=(o=(new $Uint64(0,(m-48<<24>>>24))),new $Uint64(b.$high+o.$high,b.$low+o.$low));k=k+(1)>>0;}else if(!((a.charCodeAt(g)===48))){e=true;}g=g+(1)>>0;continue;}break;}if(!i){return[b,c,d,e,f];}if(!h){l=j;}if(g>0;if(g>=a.length){return[b,c,d,e,f];}p=1;if(a.charCodeAt(g)===43){g=g+(1)>>0;}else if(a.charCodeAt(g)===45){g=g+(1)>>0;p=-1;}if(g>=a.length||a.charCodeAt(g)<48||a.charCodeAt(g)>57){return[b,c,d,e,f];}q=0;while(true){if(!(g>0))>>0)-48>>0;}g=g+(1)>>0;}l=l+(($imul(q,p)))>>0;}if(!((g===a.length))){return[b,c,d,e,f];}if(!((b.$high===0&&b.$low===0))){c=l-k>>0;}f=true;return[b,c,d,e,f];};AC.ptr.prototype.floatBits=function(a){var 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,$s;$s=0;s:while(true){switch($s){case 0:b=new $Uint64(0,0);c=false;d=this;e=0;f=new $Uint64(0,0);if(d.nd===0){$s=1;continue;}$s=2;continue;case 1:f=new $Uint64(0,0);e=a.bias;$s=3;continue;case 2:if(d.dp>310){$s=4;continue;}$s=5;continue;case 4:$s=6;continue;case 5:if(d.dp<-330){$s=7;continue;}$s=8;continue;case 7:f=new $Uint64(0,0);e=a.bias;$s=3;continue;case 8:e=0;while(true){if(!(d.dp>0)){break;}g=0;if(d.dp>=M.$length){g=27;}else{g=(h=d.dp,((h<0||h>=M.$length)?($throwRuntimeError("index out of range"),undefined):M.$array[M.$offset+h]));}d.Shift(-g);e=e+(g)>>0;}while(true){if(!(d.dp<0||(d.dp===0)&&d.d[0]<53)){break;}i=0;if(-d.dp>=M.$length){i=27;}else{i=(j=-d.dp,((j<0||j>=M.$length)?($throwRuntimeError("index out of range"),undefined):M.$array[M.$offset+j]));}d.Shift(i);e=e-(i)>>0;}e=e-(1)>>0;if(e<(a.bias+1>>0)){k=(a.bias+1>>0)-e>>0;d.Shift(-k);e=e+(k)>>0;}if((e-a.bias>>0)>=(((l=a.expbits,l<32?(1<>0)-1>>0)){$s=9;continue;}$s=10;continue;case 9:$s=6;continue;case 10:d.Shift((((1+a.mantbits>>>0)>>0)));f=d.RoundedInteger();if((m=$shiftLeft64(new $Uint64(0,2),a.mantbits),(f.$high===m.$high&&f.$low===m.$low))){$s=11;continue;}$s=12;continue;case 11:f=$shiftRightUint64(f,(1));e=e+(1)>>0;if((e-a.bias>>0)>=(((n=a.expbits,n<32?(1<>0)-1>>0)){$s=13;continue;}$s=14;continue;case 13:$s=6;continue;case 14:case 12:if((o=(p=$shiftLeft64(new $Uint64(0,1),a.mantbits),new $Uint64(f.$high&p.$high,(f.$low&p.$low)>>>0)),(o.$high===0&&o.$low===0))){e=a.bias;}$s=3;continue;case 6:f=new $Uint64(0,0);e=(((q=a.expbits,q<32?(1<>0)-1>>0)+a.bias>>0;c=true;case 3:t=(r=(s=$shiftLeft64(new $Uint64(0,1),a.mantbits),new $Uint64(s.$high-0,s.$low-1)),new $Uint64(f.$high&r.$high,(f.$low&r.$low)>>>0));t=(u=$shiftLeft64((new $Uint64(0,(((e-a.bias>>0))&((((v=a.expbits,v<32?(1<>0)-1>>0))))),a.mantbits),new $Uint64(t.$high|u.$high,(t.$low|u.$low)>>>0));if(d.neg){t=(w=$shiftLeft64($shiftLeft64(new $Uint64(0,1),a.mantbits),a.expbits),new $Uint64(t.$high|w.$high,(t.$low|w.$low)>>>0));}x=t;y=c;b=x;c=y;$s=-1;return[b,c];}return;}};AC.prototype.floatBits=function(a){return this.$val.floatBits(a);};P=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n;d=0;e=false;if(!((f=$shiftRightUint64(a,AU.mantbits),(f.$high===0&&f.$low===0)))){return[d,e];}d=($flatten64(a));if(c){d=-d;}if((b===0)){g=d;h=true;d=g;e=h;return[d,e];}else if(b>0&&b<=37){if(b>22){d=d*((i=b-22>>0,((i<0||i>=N.$length)?($throwRuntimeError("index out of range"),undefined):N.$array[N.$offset+i])));b=22;}if(d>1e+15||d<-1e+15){return[d,e];}j=d*((b<0||b>=N.$length)?($throwRuntimeError("index out of range"),undefined):N.$array[N.$offset+b]);k=true;d=j;e=k;return[d,e];}else if(b<0&&b>=-22){l=d/(m=-b,((m<0||m>=N.$length)?($throwRuntimeError("index out of range"),undefined):N.$array[N.$offset+m]));n=true;d=l;e=n;return[d,e];}return[d,e];};Q=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n;d=0;e=false;if(!((f=$shiftRightUint64(a,AT.mantbits),(f.$high===0&&f.$low===0)))){return[d,e];}d=($flatten64(a));if(c){d=-d;}if((b===0)){g=d;h=true;d=g;e=h;return[d,e];}else if(b>0&&b<=17){if(b>10){d=$fround(d*((i=b-10>>0,((i<0||i>=O.$length)?($throwRuntimeError("index out of range"),undefined):O.$array[O.$offset+i]))));b=10;}if(d>1e+07||d<-1e+07){return[d,e];}j=$fround(d*((b<0||b>=O.$length)?($throwRuntimeError("index out of range"),undefined):O.$array[O.$offset+b]));k=true;d=j;e=k;return[d,e];}else if(b<0&&b>=-10){l=$fround(d/(m=-b,((m<0||m>=O.$length)?($throwRuntimeError("index out of range"),undefined):O.$array[O.$offset+m])));n=true;d=l;e=n;return[d,e];}return[d,e];};R=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,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;b=0;c=$ifaceNil;d=K(a);e=d[0];f=d[1];if(f){g=($fround(e));h=$ifaceNil;b=g;c=h;return[b,c];}if(I){i=L(a);j=i[0];k=i[1];l=i[2];m=i[3];n=i[4];if(n){if(!m){o=Q(j,k,l);p=o[0];q=o[1];if(q){r=p;s=$ifaceNil;b=r;c=s;return[b,c];}}t=new AL.ptr(new $Uint64(0,0),0,false);u=t.AssignDecimal(j,k,l,m,AT);if(u){v=t.floatBits(AT);w=v[0];x=v[1];b=A.Float32frombits(((w.$low>>>0)));if(x){c=W("ParseFloat",a);}y=b;z=c;b=y;c=z;return[b,c];}}}aa=new AC.ptr(DD.zero(),0,0,false,false);if(!aa.set(a)){ab=0;ac=V("ParseFloat",a);b=ab;c=ac;return[b,c];}ad=aa.floatBits(AT);ae=ad[0];af=ad[1];b=A.Float32frombits(((ae.$low>>>0)));if(af){c=W("ParseFloat",a);}ag=b;ah=c;b=ag;c=ah;return[b,c];};S=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,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;b=0;c=$ifaceNil;d=K(a);e=d[0];f=d[1];if(f){g=e;h=$ifaceNil;b=g;c=h;return[b,c];}if(I){i=L(a);j=i[0];k=i[1];l=i[2];m=i[3];n=i[4];if(n){if(!m){o=P(j,k,l);p=o[0];q=o[1];if(q){r=p;s=$ifaceNil;b=r;c=s;return[b,c];}}t=new AL.ptr(new $Uint64(0,0),0,false);u=t.AssignDecimal(j,k,l,m,AU);if(u){v=t.floatBits(AU);w=v[0];x=v[1];b=A.Float64frombits(w);if(x){c=W("ParseFloat",a);}y=b;z=c;b=y;c=z;return[b,c];}}}aa=new AC.ptr(DD.zero(),0,0,false,false);if(!aa.set(a)){ab=0;ac=V("ParseFloat",a);b=ab;c=ac;return[b,c];}ad=aa.floatBits(AU);ae=ad[0];af=ad[1];b=A.Float64frombits(ae);if(af){c=W("ParseFloat",a);}ag=b;ah=c;b=ag;c=ah;return[b,c];};T=function(a,b){var a,b,c,d,e;if(b===32){c=R(a);d=c[0];e=c[1];return[(d),e];}return S(a);};$pkg.ParseFloat=T;U.ptr.prototype.Error=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Err.Error();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return"strconv."+a.Func+": "+"parsing "+BZ(a.Num)+": "+b;}return;}if($f===undefined){$f={$blk:U.ptr.prototype.Error};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};U.prototype.Error=function(){return this.$val.Error();};V=function(a,b){var a,b;return new U.ptr(a,b,$pkg.ErrSyntax);};W=function(a,b){var a,b;return new U.ptr(a,b,$pkg.ErrRange);};X=function(a,b,c){var a,b,c;return new U.ptr(a,b,B.New("invalid base "+BO(c)));};Y=function(a,b,c){var a,b,c;return new U.ptr(a,b,B.New("invalid bit size "+BO(c)));};Z=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p;if(a.length===0){return[new $Uint64(0,0),V("ParseUint",a)];}d=a;if(2<=b&&b<=36){}else if((b===0)){if((a.charCodeAt(0)===48)&&a.length>1&&((a.charCodeAt(1)===120)||(a.charCodeAt(1)===88))){if(a.length<3){return[new $Uint64(0,0),V("ParseUint",d)];}b=16;a=$substring(a,2);}else if((a.charCodeAt(0)===48)){b=8;a=$substring(a,1);}else{b=10;}}else{return[new $Uint64(0,0),X("ParseUint",d,b)];}if(c===0){c=32;}else if(c<0||c>64){return[new $Uint64(0,0),Y("ParseUint",d,c)];}e=new $Uint64(0,0);f=b;if(f===(10)){e=new $Uint64(429496729,2576980378);}else if(f===(16)){e=new $Uint64(268435456,0);}else{e=(g=$div64(new $Uint64(4294967295,4294967295),(new $Uint64(0,b)),false),new $Uint64(g.$high+0,g.$low+1));}i=(h=$shiftLeft64(new $Uint64(0,1),((c>>>0))),new $Uint64(h.$high-0,h.$low-1));j=new $Uint64(0,0);k=(new DE($stringToBytes(a)));l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);n=0;if(48<=m&&m<=57){n=m-48<<24>>>24;}else if(97<=m&&m<=122){n=(m-97<<24>>>24)+10<<24>>>24;}else if(65<=m&&m<=90){n=(m-65<<24>>>24)+10<<24>>>24;}else{return[new $Uint64(0,0),V("ParseUint",d)];}if(n>=((b<<24>>>24))){return[new $Uint64(0,0),V("ParseUint",d)];}if((j.$high>e.$high||(j.$high===e.$high&&j.$low>=e.$low))){return[i,W("ParseUint",d)];}j=$mul64(j,((new $Uint64(0,b))));p=(o=(new $Uint64(0,n)),new $Uint64(j.$high+o.$high,j.$low+o.$low));if((p.$highi.$high||(p.$high===i.$high&&p.$low>i.$low))){return[i,W("ParseUint",d)];}j=p;l++;}return[j,$ifaceNil];};$pkg.ParseUint=Z;AA=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;d=new $Int64(0,0);e=$ifaceNil;if(a.length===0){f=new $Int64(0,0);g=V("ParseInt",a);d=f;e=g;return[d,e];}h=a;i=false;if(a.charCodeAt(0)===43){a=$substring(a,1);}else if(a.charCodeAt(0)===45){i=true;a=$substring(a,1);}j=new $Uint64(0,0);k=Z(a,b,c);j=k[0];e=k[1];if(!($interfaceIsEqual(e,$ifaceNil))&&!($interfaceIsEqual($assertType(e,DF).Err,$pkg.ErrRange))){$assertType(e,DF).Func="ParseInt";$assertType(e,DF).Num=h;l=new $Int64(0,0);m=e;d=l;e=m;return[d,e];}if(c===0){c=32;}n=($shiftLeft64(new $Uint64(0,1),(((c-1>>0)>>>0))));if(!i&&(j.$high>n.$high||(j.$high===n.$high&&j.$low>=n.$low))){o=((p=new $Uint64(n.$high-0,n.$low-1),new $Int64(p.$high,p.$low)));q=W("ParseInt",h);d=o;e=q;return[d,e];}if(i&&(j.$high>n.$high||(j.$high===n.$high&&j.$low>n.$low))){r=(s=(new $Int64(n.$high,n.$low)),new $Int64(-s.$high,-s.$low));t=W("ParseInt",h);d=r;e=t;return[d,e];}u=(new $Int64(j.$high,j.$low));if(i){u=new $Int64(-u.$high,-u.$low);}v=u;w=$ifaceNil;d=v;e=w;return[d,e];};$pkg.ParseInt=AA;AC.ptr.prototype.String=function(){var a,b,c,d;a=this;b=10+a.nd>>0;if(a.dp>0){b=b+(a.dp)>>0;}if(a.dp<0){b=b+(-a.dp)>>0;}c=$makeSlice(DE,b);d=0;if((a.nd===0)){return"0";}else if(a.dp<=0){((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=48);d=d+(1)>>0;((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=46);d=d+(1)>>0;d=d+(AD($subslice(c,d,(d+-a.dp>>0))))>>0;d=d+($copySlice($subslice(c,d),$subslice(new DE(a.d),0,a.nd)))>>0;}else if(a.dp>0;((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=46);d=d+(1)>>0;d=d+($copySlice($subslice(c,d),$subslice(new DE(a.d),a.dp,a.nd)))>>0;}else{d=d+($copySlice($subslice(c,d),$subslice(new DE(a.d),0,a.nd)))>>0;d=d+(AD($subslice(c,d,((d+a.dp>>0)-a.nd>>0))))>>0;}return($bytesToString($subslice(c,0,d)));};AC.prototype.String=function(){return this.$val.String();};AD=function(a){var a,b,c,d;b=a;c=0;while(true){if(!(c=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+d]=48);c++;}return a.$length;};AE=function(a){var a,b,c;while(true){if(!(a.nd>0&&((b=a.d,c=a.nd-1>>0,((c<0||c>=b.length)?($throwRuntimeError("index out of range"),undefined):b[c]))===48))){break;}a.nd=a.nd-(1)>>0;}if(a.nd===0){a.dp=0;}};AC.ptr.prototype.Assign=function(a){var a,b,c,d,e,f,g,h;b=this;c=DG.zero();d=0;while(true){if(!((a.$high>0||(a.$high===0&&a.$low>0)))){break;}e=$div64(a,new $Uint64(0,10),false);a=(f=$mul64(new $Uint64(0,10),e),new $Uint64(a.$high-f.$high,a.$low-f.$low));((d<0||d>=c.length)?($throwRuntimeError("index out of range"),undefined):c[d]=((new $Uint64(a.$high+0,a.$low+48).$low<<24>>>24)));d=d+(1)>>0;a=e;}b.nd=0;d=d-(1)>>0;while(true){if(!(d>=0)){break;}(g=b.d,h=b.nd,((h<0||h>=g.length)?($throwRuntimeError("index out of range"),undefined):g[h]=((d<0||d>=c.length)?($throwRuntimeError("index out of range"),undefined):c[d])));b.nd=b.nd+(1)>>0;d=d-(1)>>0;}b.dp=b.nd;AE(b);};AC.prototype.Assign=function(a){return this.$val.Assign(a);};AF=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;c=0;d=0;e=0;while(true){if(!(((f=b,f<32?(e>>>f):0)>>>0)===0)){break;}if(c>=a.nd){if(e===0){a.nd=0;return;}while(true){if(!(((g=b,g<32?(e>>>g):0)>>>0)===0)){break;}e=e*10>>>0;c=c+(1)>>0;}break;}i=(((h=a.d,((c<0||c>=h.length)?($throwRuntimeError("index out of range"),undefined):h[c]))>>>0));e=((e*10>>>0)+i>>>0)-48>>>0;c=c+(1)>>0;}a.dp=a.dp-((c-1>>0))>>0;k=(((j=b,j<32?(1<>>0))-1>>>0;while(true){if(!(c=l.length)?($throwRuntimeError("index out of range"),undefined):l[c]))>>>0));o=(n=b,n<32?(e>>>n):0)>>>0;e=(e&(k))>>>0;(p=a.d,((d<0||d>=p.length)?($throwRuntimeError("index out of range"),undefined):p[d]=(((o+48>>>0)<<24>>>24))));d=d+(1)>>0;e=((e*10>>>0)+m>>>0)-48>>>0;c=c+(1)>>0;}while(true){if(!(e>0)){break;}r=(q=b,q<32?(e>>>q):0)>>>0;e=(e&(k))>>>0;if(d<800){(s=a.d,((d<0||d>=s.length)?($throwRuntimeError("index out of range"),undefined):s[d]=(((r+48>>>0)<<24>>>24))));d=d+(1)>>0;}else if(r>0){a.trunc=true;}e=e*10>>>0;}a.nd=d;AE(a);};AI=function(a,b){var a,b,c;c=0;while(true){if(!(c=a.$length){return true;}if(!((((c<0||c>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+c])===b.charCodeAt(c)))){return((c<0||c>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+c])>0;}return false;};AJ=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p;c=((b<0||b>=AH.$length)?($throwRuntimeError("index out of range"),undefined):AH.$array[AH.$offset+b]).delta;if(AI($subslice(new DE(a.d),0,a.nd),((b<0||b>=AH.$length)?($throwRuntimeError("index out of range"),undefined):AH.$array[AH.$offset+b]).cutoff)){c=c-(1)>>0;}d=a.nd;e=a.nd+c>>0;f=0;d=d-(1)>>0;while(true){if(!(d>=0)){break;}f=f+(((g=b,g<32?((((((h=a.d,((d<0||d>=h.length)?($throwRuntimeError("index out of range"),undefined):h[d]))>>>0))-48>>>0))<>>0))>>>0;j=(i=f/10,(i===i&&i!==1/0&&i!==-1/0)?i>>>0:$throwRuntimeError("integer divide by zero"));k=f-(10*j>>>0)>>>0;e=e-(1)>>0;if(e<800){(l=a.d,((e<0||e>=l.length)?($throwRuntimeError("index out of range"),undefined):l[e]=(((k+48>>>0)<<24>>>24))));}else if(!((k===0))){a.trunc=true;}f=j;d=d-(1)>>0;}while(true){if(!(f>0)){break;}n=(m=f/10,(m===m&&m!==1/0&&m!==-1/0)?m>>>0:$throwRuntimeError("integer divide by zero"));o=f-(10*n>>>0)>>>0;e=e-(1)>>0;if(e<800){(p=a.d,((e<0||e>=p.length)?($throwRuntimeError("index out of range"),undefined):p[e]=(((o+48>>>0)<<24>>>24))));}else if(!((o===0))){a.trunc=true;}f=n;}a.nd=a.nd+(c)>>0;if(a.nd>=800){a.nd=800;}a.dp=a.dp+(c)>>0;AE(a);};AC.ptr.prototype.Shift=function(a){var a,b;b=this;if((b.nd===0)){}else if(a>0){while(true){if(!(a>28)){break;}AJ(b,28);a=a-(28)>>0;}AJ(b,((a>>>0)));}else if(a<0){while(true){if(!(a<-28)){break;}AF(b,28);a=a+(28)>>0;}AF(b,((-a>>>0)));}};AC.prototype.Shift=function(a){return this.$val.Shift(a);};AK=function(a,b){var a,b,c,d,e,f,g;if(b<0||b>=a.nd){return false;}if(((c=a.d,((b<0||b>=c.length)?($throwRuntimeError("index out of range"),undefined):c[b]))===53)&&((b+1>>0)===a.nd)){if(a.trunc){return true;}return b>0&&!(((d=(((e=a.d,f=b-1>>0,((f<0||f>=e.length)?($throwRuntimeError("index out of range"),undefined):e[f]))-48<<24>>>24))%2,d===d?d:$throwRuntimeError("integer divide by zero"))===0));}return(g=a.d,((b<0||b>=g.length)?($throwRuntimeError("index out of range"),undefined):g[b]))>=53;};AC.ptr.prototype.Round=function(a){var a,b;b=this;if(a<0||a>=b.nd){return;}if(AK(b,a)){b.RoundUp(a);}else{b.RoundDown(a);}};AC.prototype.Round=function(a){return this.$val.Round(a);};AC.ptr.prototype.RoundDown=function(a){var a,b;b=this;if(a<0||a>=b.nd){return;}b.nd=a;AE(b);};AC.prototype.RoundDown=function(a){return this.$val.RoundDown(a);};AC.ptr.prototype.RoundUp=function(a){var a,b,c,d,e,f,g;b=this;if(a<0||a>=b.nd){return;}c=a-1>>0;while(true){if(!(c>=0)){break;}e=(d=b.d,((c<0||c>=d.length)?($throwRuntimeError("index out of range"),undefined):d[c]));if(e<57){(g=b.d,((c<0||c>=g.length)?($throwRuntimeError("index out of range"),undefined):g[c]=((f=b.d,((c<0||c>=f.length)?($throwRuntimeError("index out of range"),undefined):f[c]))+(1)<<24>>>24)));b.nd=c+1>>0;return;}c=c-(1)>>0;}b.d[0]=49;b.nd=1;b.dp=b.dp+(1)>>0;};AC.prototype.RoundUp=function(a){return this.$val.RoundUp(a);};AC.ptr.prototype.RoundedInteger=function(){var a,b,c,d,e,f,g;a=this;if(a.dp>20){return new $Uint64(4294967295,4294967295);}b=0;c=new $Uint64(0,0);b=0;while(true){if(!(b=f.length)?($throwRuntimeError("index out of range"),undefined):f[b]))-48<<24>>>24))),new $Uint64(d.$high+e.$high,d.$low+e.$low));b=b+(1)>>0;}while(true){if(!(b>0;}if(AK(a,a.dp)){c=(g=new $Uint64(0,1),new $Uint64(c.$high+g.$high,c.$low+g.$low));}return c;};AC.prototype.RoundedInteger=function(){return this.$val.RoundedInteger();};AL.ptr.prototype.floatBits=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;b=new $Uint64(0,0);c=false;d=this;d.Normalize();e=d.exp+63>>0;if(e<(a.bias+1>>0)){f=(a.bias+1>>0)-e>>0;d.mant=$shiftRightUint64(d.mant,(((f>>>0))));e=e+(f)>>0;}g=$shiftRightUint64(d.mant,((63-a.mantbits>>>0)));if(!((h=(i=d.mant,j=$shiftLeft64(new $Uint64(0,1),((62-a.mantbits>>>0))),new $Uint64(i.$high&j.$high,(i.$low&j.$low)>>>0)),(h.$high===0&&h.$low===0)))){g=(k=new $Uint64(0,1),new $Uint64(g.$high+k.$high,g.$low+k.$low));}if((l=$shiftLeft64(new $Uint64(0,2),a.mantbits),(g.$high===l.$high&&g.$low===l.$low))){g=$shiftRightUint64(g,(1));e=e+(1)>>0;}if((e-a.bias>>0)>=(((m=a.expbits,m<32?(1<>0)-1>>0)){g=new $Uint64(0,0);e=(((p=a.expbits,p<32?(1<>0)-1>>0)+a.bias>>0;c=true;}else if((n=(o=$shiftLeft64(new $Uint64(0,1),a.mantbits),new $Uint64(g.$high&o.$high,(g.$low&o.$low)>>>0)),(n.$high===0&&n.$low===0))){e=a.bias;}b=(q=(r=$shiftLeft64(new $Uint64(0,1),a.mantbits),new $Uint64(r.$high-0,r.$low-1)),new $Uint64(g.$high&q.$high,(g.$low&q.$low)>>>0));b=(s=$shiftLeft64((new $Uint64(0,(((e-a.bias>>0))&((((t=a.expbits,t<32?(1<>0)-1>>0))))),a.mantbits),new $Uint64(b.$high|s.$high,(b.$low|s.$low)>>>0));if(d.neg){b=(u=$shiftLeft64(new $Uint64(0,1),((a.mantbits+a.expbits>>>0))),new $Uint64(b.$high|u.$high,(b.$low|u.$low)>>>0));}return[b,c];};AL.prototype.floatBits=function(a){return this.$val.floatBits(a);};AL.ptr.prototype.AssignComputeBounds=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;e=new AL.ptr(new $Uint64(0,0),0,false);f=new AL.ptr(new $Uint64(0,0),0,false);g=this;g.mant=a;g.exp=b-((d.mantbits>>0))>>0;g.neg=c;if(g.exp<=0&&(h=$shiftLeft64(($shiftRightUint64(a,((-g.exp>>>0)))),((-g.exp>>>0))),(a.$high===h.$high&&a.$low===h.$low))){g.mant=$shiftRightUint64(g.mant,(((-g.exp>>>0))));g.exp=0;i=$clone(g,AL);j=$clone(g,AL);AL.copy(e,i);AL.copy(f,j);return[e,f];}k=b-d.bias>>0;AL.copy(f,new AL.ptr((l=$mul64(new $Uint64(0,2),g.mant),new $Uint64(l.$high+0,l.$low+1)),g.exp-1>>0,g.neg));if(!((m=$shiftLeft64(new $Uint64(0,1),d.mantbits),(a.$high===m.$high&&a.$low===m.$low)))||(k===1)){AL.copy(e,new AL.ptr((n=$mul64(new $Uint64(0,2),g.mant),new $Uint64(n.$high-0,n.$low-1)),g.exp-1>>0,g.neg));}else{AL.copy(e,new AL.ptr((o=$mul64(new $Uint64(0,4),g.mant),new $Uint64(o.$high-0,o.$low-1)),g.exp-2>>0,g.neg));}return[e,f];};AL.prototype.AssignComputeBounds=function(a,b,c,d){return this.$val.AssignComputeBounds(a,b,c,d);};AL.ptr.prototype.Normalize=function(){var a,b,c;a=this;if((b=a.mant,(b.$high===0&&b.$low===0))){return 0;}c=C.LeadingZeros64(a.mant);a.mant=$shiftLeft64(a.mant,(((c>>>0))));a.exp=a.exp-(c)>>0;return((c>>>0));};AL.prototype.Normalize=function(){return this.$val.Normalize();};AL.ptr.prototype.Multiply=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;b=this;c=$shiftRightUint64(b.mant,32);d=(new $Uint64(0,((b.mant.$low>>>0))));e=c;f=d;g=$shiftRightUint64(a.mant,32);h=(new $Uint64(0,((a.mant.$low>>>0))));i=g;j=h;k=$mul64(e,j);l=$mul64(f,i);b.mant=(m=(n=$mul64(e,i),o=$shiftRightUint64(k,32),new $Uint64(n.$high+o.$high,n.$low+o.$low)),p=$shiftRightUint64(l,32),new $Uint64(m.$high+p.$high,m.$low+p.$low));u=(q=(r=(new $Uint64(0,((k.$low>>>0)))),s=(new $Uint64(0,((l.$low>>>0)))),new $Uint64(r.$high+s.$high,r.$low+s.$low)),t=$shiftRightUint64(($mul64(f,j)),32),new $Uint64(q.$high+t.$high,q.$low+t.$low));u=(v=new $Uint64(0,2147483648),new $Uint64(u.$high+v.$high,u.$low+v.$low));b.mant=(w=b.mant,x=($shiftRightUint64(u,32)),new $Uint64(w.$high+x.$high,w.$low+x.$low));b.exp=(b.exp+a.exp>>0)+64>>0;};AL.prototype.Multiply=function(a){return this.$val.Multiply(a);};AL.ptr.prototype.AssignDecimal=function(a,b,c,d,e){var a,aa,ab,ac,ad,ae,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;f=false;g=this;h=0;if(d){h=h+(4)>>0;}g.mant=a;g.exp=0;g.neg=c;j=(i=((b- -348>>0))/8,(i===i&&i!==1/0&&i!==-1/0)?i>>0:$throwRuntimeError("integer divide by zero"));if(b<-348||j>=87){f=false;return f;}l=(k=((b- -348>>0))%8,k===k?k:$throwRuntimeError("integer divide by zero"));if(l<19&&(m=(n=19-l>>0,((n<0||n>=AO.length)?($throwRuntimeError("index out of range"),undefined):AO[n])),(a.$high=AO.length)?($throwRuntimeError("index out of range"),undefined):AO[l])));g.Normalize();}else{g.Normalize();g.Multiply($clone(((l<0||l>=AM.length)?($throwRuntimeError("index out of range"),undefined):AM[l]),AL));h=h+(4)>>0;}g.Multiply($clone(((j<0||j>=AN.length)?($throwRuntimeError("index out of range"),undefined):AN[j]),AL));if(h>0){h=h+(1)>>0;}h=h+(4)>>0;o=g.Normalize();h=(p=(o),p<32?(h<>0;q=e.bias-63>>0;r=0;if(g.exp<=q){r=((63-e.mantbits>>>0)+1>>>0)+(((q-g.exp>>0)>>>0))>>>0;}else{r=63-e.mantbits>>>0;}s=$shiftLeft64(new $Uint64(0,1),((r-1>>>0)));w=(t=g.mant,u=(v=$shiftLeft64(new $Uint64(0,1),r),new $Uint64(v.$high-0,v.$low-1)),new $Uint64(t.$high&u.$high,(t.$low&u.$low)>>>0));if((x=(y=(new $Int64(s.$high,s.$low)),z=(new $Int64(0,h)),new $Int64(y.$high-z.$high,y.$low-z.$low)),aa=(new $Int64(w.$high,w.$low)),(x.$high>0)),28))/93,(d===d&&d!==1/0&&d!==-1/0)?d>>0:$throwRuntimeError("integer divide by zero"));g=(f=((e- -348>>0))/8,(f===f&&f!==1/0&&f!==-1/0)?f>>0:$throwRuntimeError("integer divide by zero"));Loop:while(true){h=(c.exp+((g<0||g>=AN.length)?($throwRuntimeError("index out of range"),undefined):AN[g]).exp>>0)+64>>0;if(h<-60){g=g+(1)>>0;}else if(h>-32){g=g-(1)>>0;}else{break Loop;}}c.Multiply($clone(((g<0||g>=AN.length)?($throwRuntimeError("index out of range"),undefined):AN[g]),AL));i=-((-348+($imul(g,8))>>0));j=g;a=i;b=j;return[a,b];};AL.prototype.frexp10=function(){return this.$val.frexp10();};AP=function(a,b,c){var a,b,c,d,e,f;d=0;e=c.frexp10();d=e[0];f=e[1];a.Multiply($clone(((f<0||f>=AN.length)?($throwRuntimeError("index out of range"),undefined):AN[f]),AL));b.Multiply($clone(((f<0||f>=AN.length)?($throwRuntimeError("index out of range"),undefined):AN[f]),AL));return d;};AL.ptr.prototype.FixedDecimal=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,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;c=this;if((d=c.mant,(d.$high===0&&d.$low===0))){a.nd=0;a.dp=0;a.neg=c.neg;return true;}if(b===0){$panic(new $String("strconv: internal error: extFloat.FixedDecimal called with n == 0"));}c.Normalize();e=c.frexp10();f=e[0];g=((-c.exp>>>0));h=(($shiftRightUint64(c.mant,g).$low>>>0));k=(i=c.mant,j=$shiftLeft64((new $Uint64(0,h)),g),new $Uint64(i.$high-j.$high,i.$low-j.$low));l=new $Uint64(0,1);m=b;n=0;o=new $Uint64(0,1);p=0;q=new $Uint64(0,1);r=p;s=q;while(true){if(!(r<20)){break;}if((t=(new $Uint64(0,h)),(s.$high>t.$high||(s.$high===t.$high&&s.$low>t.$low)))){n=r;break;}s=$mul64(s,(new $Uint64(0,10)));r=r+(1)>>0;}u=h;if(n>m){o=(v=n-m>>0,((v<0||v>=AO.length)?($throwRuntimeError("index out of range"),undefined):AO[v]));h=(w=h/(((o.$low>>>0))),(w===w&&w!==1/0&&w!==-1/0)?w>>>0:$throwRuntimeError("integer divide by zero"));u=u-(($imul(h,((o.$low>>>0)))>>>0))>>>0;}else{u=0;}x=DH.zero();y=32;z=h;while(true){if(!(z>0)){break;}ab=(aa=z/10,(aa===aa&&aa!==1/0&&aa!==-1/0)?aa>>>0:$throwRuntimeError("integer divide by zero"));z=z-(($imul(10,ab)>>>0))>>>0;y=y-(1)>>0;((y<0||y>=x.length)?($throwRuntimeError("index out of range"),undefined):x[y]=(((z+48>>>0)<<24>>>24)));z=ab;}ac=y;while(true){if(!(ac<32)){break;}(ad=a.d,ae=ac-y>>0,((ae<0||ae>=ad.$length)?($throwRuntimeError("index out of range"),undefined):ad.$array[ad.$offset+ae]=((ac<0||ac>=x.length)?($throwRuntimeError("index out of range"),undefined):x[ac])));ac=ac+(1)>>0;}af=32-y>>0;a.nd=af;a.dp=n+f>>0;m=m-(af)>>0;if(m>0){if(!((u===0))||!((o.$high===0&&o.$low===1))){$panic(new $String("strconv: internal error, rest != 0 but needed > 0"));}while(true){if(!(m>0)){break;}k=$mul64(k,(new $Uint64(0,10)));l=$mul64(l,(new $Uint64(0,10)));if((ag=$mul64(new $Uint64(0,2),l),ah=$shiftLeft64(new $Uint64(0,1),g),(ag.$high>ah.$high||(ag.$high===ah.$high&&ag.$low>ah.$low)))){return false;}ai=$shiftRightUint64(k,g);(aj=a.d,((af<0||af>=aj.$length)?($throwRuntimeError("index out of range"),undefined):aj.$array[aj.$offset+af]=((new $Uint64(ai.$high+0,ai.$low+48).$low<<24>>>24))));k=(ak=$shiftLeft64(ai,g),new $Uint64(k.$high-ak.$high,k.$low-ak.$low));af=af+(1)>>0;m=m-(1)>>0;}a.nd=af;}am=AQ(a,(al=$shiftLeft64((new $Uint64(0,u)),g),new $Uint64(al.$high|k.$high,(al.$low|k.$low)>>>0)),o,g,l);if(!am){return false;}an=a.nd-1>>0;while(true){if(!(an>=0)){break;}if(!(((ao=a.d,((an<0||an>=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+an]))===48))){a.nd=an+1>>0;break;}an=an-(1)>>0;}return true;};AL.prototype.FixedDecimal=function(a,b){return this.$val.FixedDecimal(a,b);};AQ=function(a,b,c,d,e){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;if((f=$shiftLeft64(c,d),(b.$high>f.$high||(b.$high===f.$high&&b.$low>f.$low)))){$panic(new $String("strconv: num > den<h.$high||(g.$high===h.$high&&g.$low>h.$low)))){$panic(new $String("strconv: \xCE\xB5 > (den<l.$high||(k.$high===l.$high&&k.$low>l.$low)))){m=a.nd-1>>0;while(true){if(!(m>=0)){break;}if((n=a.d,((m<0||m>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+m]))===57){a.nd=a.nd-(1)>>0;}else{break;}m=m-(1)>>0;}if(m<0){(o=a.d,(0>=o.$length?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+0]=49));a.nd=1;a.dp=a.dp+(1)>>0;}else{(q=a.d,((m<0||m>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+m]=((p=a.d,((m<0||m>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+m]))+(1)<<24>>>24)));}return true;}return false;};AL.ptr.prototype.ShortestDecimal=function(a,b,c){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,bb,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;d=this;if((e=d.mant,(e.$high===0&&e.$low===0))){a.nd=0;a.dp=0;a.neg=d.neg;return true;}if((d.exp===0)&&$equal(b,d,AL)&&$equal(b,c,AL)){f=DG.zero();g=23;h=d.mant;while(true){if(!((h.$high>0||(h.$high===0&&h.$low>0)))){break;}i=$div64(h,new $Uint64(0,10),false);h=(j=$mul64(new $Uint64(0,10),i),new $Uint64(h.$high-j.$high,h.$low-j.$low));((g<0||g>=f.length)?($throwRuntimeError("index out of range"),undefined):f[g]=((new $Uint64(h.$high+0,h.$low+48).$low<<24>>>24)));g=g-(1)>>0;h=i;}k=(24-g>>0)-1>>0;l=0;while(true){if(!(l=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+l]=(m=(g+1>>0)+l>>0,((m<0||m>=f.length)?($throwRuntimeError("index out of range"),undefined):f[m]))));l=l+(1)>>0;}o=k;p=k;a.nd=o;a.dp=p;while(true){if(!(a.nd>0&&((q=a.d,r=a.nd-1>>0,((r<0||r>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r]))===48))){break;}a.nd=a.nd-(1)>>0;}if(a.nd===0){a.dp=0;}a.neg=d.neg;return true;}c.Normalize();if(d.exp>c.exp){d.mant=$shiftLeft64(d.mant,((((d.exp-c.exp>>0)>>>0))));d.exp=c.exp;}if(b.exp>c.exp){b.mant=$shiftLeft64(b.mant,((((b.exp-c.exp>>0)>>>0))));b.exp=c.exp;}s=AP(b,d,c);c.mant=(t=c.mant,u=new $Uint64(0,1),new $Uint64(t.$high+u.$high,t.$low+u.$low));b.mant=(v=b.mant,w=new $Uint64(0,1),new $Uint64(v.$high-w.$high,v.$low-w.$low));x=((-c.exp>>>0));y=(($shiftRightUint64(c.mant,x).$low>>>0));ab=(z=c.mant,aa=$shiftLeft64((new $Uint64(0,y)),x),new $Uint64(z.$high-aa.$high,z.$low-aa.$low));ae=(ac=c.mant,ad=b.mant,new $Uint64(ac.$high-ad.$high,ac.$low-ad.$low));ah=(af=c.mant,ag=d.mant,new $Uint64(af.$high-ag.$high,af.$low-ag.$low));ai=0;aj=0;ak=new $Uint64(0,1);al=aj;am=ak;while(true){if(!(al<20)){break;}if((an=(new $Uint64(0,y)),(am.$high>an.$high||(am.$high===an.$high&&am.$low>an.$low)))){ai=al;break;}am=$mul64(am,(new $Uint64(0,10)));al=al+(1)>>0;}ao=0;while(true){if(!(ao>0)-1>>0,((ap<0||ap>=AO.length)?($throwRuntimeError("index out of range"),undefined):AO[ap]));as=(ar=y/((aq.$low>>>0)),(ar===ar&&ar!==1/0&&ar!==-1/0)?ar>>>0:$throwRuntimeError("integer divide by zero"));(at=a.d,((ao<0||ao>=at.$length)?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+ao]=(((as+48>>>0)<<24>>>24))));y=y-(($imul(as,((aq.$low>>>0)))>>>0))>>>0;av=(au=$shiftLeft64((new $Uint64(0,y)),x),new $Uint64(au.$high+ab.$high,au.$low+ab.$low));if((av.$high>0;a.dp=ai+s>>0;a.neg=d.neg;return AR(a,av,ah,ae,$shiftLeft64(aq,x),new $Uint64(0,2));}ao=ao+(1)>>0;}a.nd=ai;a.dp=a.nd+s>>0;a.neg=d.neg;aw=0;ax=new $Uint64(0,1);while(true){ab=$mul64(ab,(new $Uint64(0,10)));ax=$mul64(ax,(new $Uint64(0,10)));aw=(($shiftRightUint64(ab,x).$low>>0));(ay=a.d,az=a.nd,((az<0||az>=ay.$length)?($throwRuntimeError("index out of range"),undefined):ay.$array[ay.$offset+az]=(((aw+48>>0)<<24>>>24))));a.nd=a.nd+(1)>>0;ab=(ba=$shiftLeft64((new $Uint64(0,aw)),x),new $Uint64(ab.$high-ba.$high,ab.$low-ba.$low));if((bb=$mul64(ae,ax),(ab.$high>0;(m=a.d,((k<0||k>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+k]=((l=a.d,((k<0||k>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+k]))-(1)<<24>>>24)));b=(n=e,new $Uint64(b.$high+n.$high,b.$low+n.$low));}if((o=new $Uint64(b.$high+e.$high,b.$low+e.$low),p=(q=(r=$div64(e,new $Uint64(0,2),false),new $Uint64(c.$high+r.$high,c.$low+r.$low)),new $Uint64(q.$high+f.$high,q.$low+f.$low)),(o.$highs.$high||(b.$high===s.$high&&b.$low>s.$low)))){return false;}if((a.nd===1)&&((t=a.d,(0>=t.$length?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+0]))===48)){a.nd=0;a.dp=0;}return true;};AV=function(a,b,c,d){var a,b,c,d;return($bytesToString(AX($makeSlice(DE,0,BG(c+4>>0,24)),a,b,c,d)));};$pkg.FormatFloat=AV;AW=function(a,b,c,d,e){var a,b,c,d,e;return AX(a,b,c,d,e);};$pkg.AppendFloat=AW;AX=function(a,b,c,d,e){var a,aa,ab,ac,ad,ae,af,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;f=new $Uint64(0,0);g=DI.nil;h=e;if(h===(32)){f=(new $Uint64(0,A.Float32bits(($fround(b)))));g=AT;}else if(h===(64)){f=A.Float64bits(b);g=AU;}else{$panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize"));}j=!((i=$shiftRightUint64(f,((g.expbits+g.mantbits>>>0))),(i.$high===0&&i.$low===0)));l=(($shiftRightUint64(f,g.mantbits).$low>>0))&((((k=g.expbits,k<32?(1<>0)-1>>0));o=(m=(n=$shiftLeft64(new $Uint64(0,1),g.mantbits),new $Uint64(n.$high-0,n.$low-1)),new $Uint64(f.$high&m.$high,(f.$low&m.$low)>>>0));p=l;if(p===((((q=g.expbits,q<32?(1<>0)-1>>0))){r="";if(!((o.$high===0&&o.$low===0))){r="NaN";}else if(j){r="-Inf";}else{r="+Inf";}return $appendSlice(a,r);}else if(p===(0)){l=l+(1)>>0;}else{o=(s=$shiftLeft64(new $Uint64(0,1),g.mantbits),new $Uint64(o.$high|s.$high,(o.$low|s.$low)>>>0));}l=l+(g.bias)>>0;if(c===98){return BE(a,j,o,l,g);}if(!I){return AY(a,d,c,j,o,l,g);}t=new BB.ptr(DE.nil,0,0,false);u=false;v=d<0;if(v){w=new AL.ptr(new $Uint64(0,0),0,false);x=w.AssignComputeBounds(o,l,j,g);y=$clone(x[0],AL);z=$clone(x[1],AL);aa=DH.zero();t.d=new DE(aa);u=w.ShortestDecimal(t,y,z);if(!u){return AY(a,d,c,j,o,l,g);}ab=c;if((ab===(101))||(ab===(69))){d=BG(t.nd-1>>0,0);}else if(ab===(102)){d=BG(t.nd-t.dp>>0,0);}else if((ab===(103))||(ab===(71))){d=t.nd;}}else if(!((c===102))){ac=d;ad=c;if((ad===(101))||(ad===(69))){ac=ac+(1)>>0;}else if((ad===(103))||(ad===(71))){if(d===0){d=1;}ac=d;}if(ac<=15){ae=DG.zero();t.d=new DE(ae);af=new AL.ptr(o,l-((g.mantbits>>0))>>0,j);u=af.FixedDecimal(t,ac);}}if(!u){return AY(a,d,c,j,o,l,g);}return AZ(a,v,j,$clone(t,BB),d,c);};AY=function(a,b,c,d,e,f,g){var a,b,c,d,e,f,g,h,i,j,k,l;h=new AC.ptr(DD.zero(),0,0,false,false);h.Assign(e);h.Shift(f-((g.mantbits>>0))>>0);i=new BB.ptr(DE.nil,0,0,false);j=b<0;if(j){BA(h,e,f,g);BB.copy(i,new BB.ptr(new DE(h.d),h.nd,h.dp,false));k=c;if((k===(101))||(k===(69))){b=i.nd-1>>0;}else if(k===(102)){b=BG(i.nd-i.dp>>0,0);}else if((k===(103))||(k===(71))){b=i.nd;}}else{l=c;if((l===(101))||(l===(69))){h.Round(b+1>>0);}else if(l===(102)){h.Round(h.dp+b>>0);}else if((l===(103))||(l===(71))){if(b===0){b=1;}h.Round(b);}BB.copy(i,new BB.ptr(new DE(h.d),h.nd,h.dp,false));}return AZ(a,j,d,$clone(i,BB),b,c);};AZ=function(a,b,c,d,e,f){var a,b,c,d,e,f,g,h,i;g=f;if((g===(101))||(g===(69))){return BC(a,c,$clone(d,BB),e,f);}else if(g===(102)){return BD(a,c,$clone(d,BB),e);}else if((g===(103))||(g===(71))){h=e;if(h>d.nd&&d.nd>=d.dp){h=d.nd;}if(b){h=6;}i=d.dp-1>>0;if(i<-4||i>=h){if(e>d.nd){e=d.nd;}return BC(a,c,$clone(d,BB),e-1>>0,(f+101<<24>>>24)-103<<24>>>24);}if(e>d.dp){e=d.nd;}return BD(a,c,$clone(d,BB),BG(e-d.dp>>0,0));}return $append(a,37,f);};BA=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;if((b.$high===0&&b.$low===0)){a.nd=0;return;}e=d.bias+1>>0;if(c>e&&($imul(332,((a.dp-a.nd>>0))))>=($imul(100,((c-((d.mantbits>>0))>>0))))){return;}f=new AC.ptr(DD.zero(),0,0,false,false);f.Assign((g=$mul64(b,new $Uint64(0,2)),new $Uint64(g.$high+0,g.$low+1)));f.Shift((c-((d.mantbits>>0))>>0)-1>>0);h=new $Uint64(0,0);i=0;if((j=$shiftLeft64(new $Uint64(0,1),d.mantbits),(b.$high>j.$high||(b.$high===j.$high&&b.$low>j.$low)))||(c===e)){h=new $Uint64(b.$high-0,b.$low-1);i=c;}else{h=(k=$mul64(b,new $Uint64(0,2)),new $Uint64(k.$high-0,k.$low-1));i=c-1>>0;}l=new AC.ptr(DD.zero(),0,0,false,false);l.Assign((m=$mul64(h,new $Uint64(0,2)),new $Uint64(m.$high+0,m.$low+1)));l.Shift((i-((d.mantbits>>0))>>0)-1>>0);o=(n=$div64(b,new $Uint64(0,2),true),(n.$high===0&&n.$low===0));p=0;while(true){if(!(p=r.length)?($throwRuntimeError("index out of range"),undefined):r[p]));}t=(s=a.d,((p<0||p>=s.length)?($throwRuntimeError("index out of range"),undefined):s[p]));u=48;if(p=v.length)?($throwRuntimeError("index out of range"),undefined):v[p]));}w=!((q===t))||o&&((p+1>>0)===l.nd);x=!((t===u))&&(o||(t+1<<24>>>24)>0)>0);return;}else if(w){a.RoundDown(p+1>>0);return;}else if(x){a.RoundUp(p+1>>0);return;}p=p+(1)>>0;}};BC=function(a,b,c,d,e){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p;if(b){a=$append(a,45);}f=48;if(!((c.nd===0))){f=(g=c.d,(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]));}a=$append(a,f);if(d>0){a=$append(a,46);h=1;i=BF(c.nd,d+1>>0);if(h>0;}}a=$append(a,e);j=c.dp-1>>0;if(c.nd===0){j=0;}if(j<0){f=45;j=-j;}else{f=43;}a=$append(a,f);if(j<10){a=$append(a,48,((j<<24>>>24))+48<<24>>>24);}else if(j<100){a=$append(a,(((k=j/10,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((l=j%10,l===l?l:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}else{a=$append(a,(((m=j/100,(m===m&&m!==1/0&&m!==-1/0)?m>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(n=(((o=j/10,(o===o&&o!==1/0&&o!==-1/0)?o>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))%10,n===n?n:$throwRuntimeError("integer divide by zero"))+48<<24>>>24,(((p=j%10,p===p?p:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}return a;};BD=function(a,b,c,d){var a,b,c,d,e,f,g,h,i;if(b){a=$append(a,45);}if(c.dp>0){e=BF(c.nd,c.dp);a=$appendSlice(a,$subslice(c.d,0,e));while(true){if(!(e>0;}}else{a=$append(a,48);}if(d>0){a=$append(a,46);f=0;while(true){if(!(f>0;if(0<=h&&h=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+h]));}a=$append(a,g);f=f+(1)>>0;}}return a;};BE=function(a,b,c,d,e){var a,b,c,d,e,f,g;if(b){a=$append(a,45);}f=BS(a,c,10,false,true);a=f[0];a=$append(a,112);d=d-(((e.mantbits>>0)))>>0;if(d>=0){a=$append(a,43);}g=BS(a,(new $Uint64(0,d)),10,d<0,true);a=g[0];return a;};BF=function(a,b){var a,b;if(ab){return a;}return b;};BM=function(a,b){var a,b,c,d;if(true&&(a.$high<0||(a.$high===0&&a.$low<100))&&(b===10)){return BR(((a.$low>>0)));}c=BS(DE.nil,a,b,false,false);d=c[1];return d;};$pkg.FormatUint=BM;BN=function(a,b){var a,b,c,d;if(true&&(0>31)*4294967296))>>0)));}c=BS(DE.nil,(new $Uint64(a.$high,a.$low)),b,(a.$high<0||(a.$high===0&&a.$low<0)),false);d=c[1];return d;};$pkg.FormatInt=BN;BO=function(a){var a;return BN((new $Int64(0,a)),10);};$pkg.Itoa=BO;BP=function(a,b,c){var a,b,c,d;if(true&&(0>31)*4294967296))>>0))));}d=BS(a,(new $Uint64(b.$high,b.$low)),c,(b.$high<0||(b.$high===0&&b.$low<0)),true);a=d[0];return a;};$pkg.AppendInt=BP;BQ=function(a,b,c){var a,b,c,d;if(true&&(b.$high<0||(b.$high===0&&b.$low<100))&&(c===10)){return $appendSlice(a,BR(((b.$low>>0))));}d=BS(a,b,c,false,true);a=d[0];return a;};$pkg.AppendUint=BQ;BR=function(a){var a;if(a<10){return $substring("0123456789abcdefghijklmnopqrstuvwxyz",a,(a+1>>0));}return $substring("00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899",($imul(a,2)),(($imul(a,2))+2>>0));};BS=function(a,b,c,d,e){var a,aa,ab,ac,ad,ae,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;f=DE.nil;g="";if(c<2||c>36){$panic(new $String("strconv: illegal AppendInt/FormatInt base"));}h=DJ.zero();i=65;if(d){b=new $Uint64(-b.$high,-b.$low);}if(c===10){if(true){while(true){if(!((b.$high>0||(b.$high===0&&b.$low>=1000000000)))){break;}j=$div64(b,new $Uint64(0,1000000000),false);l=(((k=$mul64(j,new $Uint64(0,1000000000)),new $Uint64(b.$high-k.$high,b.$low-k.$low)).$low>>>0));m=4;while(true){if(!(m>0)){break;}o=(n=l%100,n===n?n:$throwRuntimeError("integer divide by zero"))*2>>>0;l=(p=l/(100),(p===p&&p!==1/0&&p!==-1/0)?p>>>0:$throwRuntimeError("integer divide by zero"));i=i-(2)>>0;(q=i+1>>0,((q<0||q>=h.length)?($throwRuntimeError("index out of range"),undefined):h[q]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((o+1>>>0))));(r=i+0>>0,((r<0||r>=h.length)?($throwRuntimeError("index out of range"),undefined):h[r]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((o+0>>>0))));m=m-(1)>>0;}i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(((l*2>>>0)+1>>>0)));b=j;}}s=((b.$low>>>0));while(true){if(!(s>=100)){break;}u=(t=s%100,t===t?t:$throwRuntimeError("integer divide by zero"))*2>>>0;s=(v=s/(100),(v===v&&v!==1/0&&v!==-1/0)?v>>>0:$throwRuntimeError("integer divide by zero"));i=i-(2)>>0;(w=i+1>>0,((w<0||w>=h.length)?($throwRuntimeError("index out of range"),undefined):h[w]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((u+1>>>0))));(x=i+0>>0,((x<0||x>=h.length)?($throwRuntimeError("index out of range"),undefined):h[x]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((u+0>>>0))));}y=s*2>>>0;i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((y+1>>>0)));if(s>=10){i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(y));}}else if(BT(c)){z=(((C.TrailingZeros(((c>>>0)))>>>0))&7)>>>0;aa=(new $Uint64(0,c));ab=((c>>>0))-1>>>0;while(true){if(!((b.$high>aa.$high||(b.$high===aa.$high&&b.$low>=aa.$low)))){break;}i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((((b.$low>>>0))&ab)>>>0)));b=$shiftRightUint64(b,(z));}i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((b.$low>>>0))));}else{ac=(new $Uint64(0,c));while(true){if(!((b.$high>ac.$high||(b.$high===ac.$high&&b.$low>=ac.$low)))){break;}i=i-(1)>>0;ad=$div64(b,ac,false);((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((ae=$mul64(ad,ac),new $Uint64(b.$high-ae.$high,b.$low-ae.$low)).$low>>>0))));b=ad;}i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((b.$low>>>0))));}if(d){i=i-(1)>>0;((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]=45);}if(e){f=$appendSlice(a,$subslice(new DE(h),i));return[f,g];}g=($bytesToString($subslice(new DE(h),i)));return[f,g];};BT=function(a){var a;return(a&((a-1>>0)))===0;};BU=function(a,b,c,d){var a,b,c,d,e;return($bytesToString(BW($makeSlice(DE,0,(e=($imul(3,a.length))/2,(e===e&&e!==1/0&&e!==-1/0)?e>>0:$throwRuntimeError("integer divide by zero"))),a,b,c,d)));};BW=function(a,b,c,d,e){var a,b,c,d,e,f,g,h;a=$append(a,c);f=0;while(true){if(!(b.length>0)){break;}g=((b.charCodeAt(0)>>0));f=1;if(g>=128){h=E.DecodeRuneInString(b);g=h[0];f=h[1];}if((f===1)&&(g===65533)){a=$appendSlice(a,"\\x");a=$append(a,"0123456789abcdef".charCodeAt((b.charCodeAt(0)>>>4<<24>>>24)));a=$append(a,"0123456789abcdef".charCodeAt(((b.charCodeAt(0)&15)>>>0)));b=$substring(b,f);continue;}a=BY(a,g,c,d,e);b=$substring(b,f);}a=$append(a,c);return a;};BX=function(a,b,c,d,e){var a,b,c,d,e;a=$append(a,c);if(!E.ValidRune(b)){b=65533;}a=BY(a,b,c,d,e);a=$append(a,c);return a;};BY=function(a,b,c,d,e){var a,b,c,d,e,f,g,h,i,j;f=DK.zero();if((b===((c>>0)))||(b===92)){a=$append(a,92);a=$append(a,((b<<24>>>24)));return a;}if(d){if(b<128&&CS(b)){a=$append(a,((b<<24>>>24)));return a;}}else if(CS(b)||e&&CU(b)){g=E.EncodeRune(new DE(f),b);a=$appendSlice(a,$subslice(new DE(f),0,g));return a;}h=b;if(h===(7)){a=$appendSlice(a,"\\a");}else if(h===(8)){a=$appendSlice(a,"\\b");}else if(h===(12)){a=$appendSlice(a,"\\f");}else if(h===(10)){a=$appendSlice(a,"\\n");}else if(h===(13)){a=$appendSlice(a,"\\r");}else if(h===(9)){a=$appendSlice(a,"\\t");}else if(h===(11)){a=$appendSlice(a,"\\v");}else{if(b<32){a=$appendSlice(a,"\\x");a=$append(a,"0123456789abcdef".charCodeAt((((b<<24>>>24))>>>4<<24>>>24)));a=$append(a,"0123456789abcdef".charCodeAt(((((b<<24>>>24))&15)>>>0)));}else if(b>1114111){b=65533;a=$appendSlice(a,"\\u");i=12;while(true){if(!(i>=0)){break;}a=$append(a,"0123456789abcdef".charCodeAt((((b>>$min(((i>>>0)),31))>>0)&15)));i=i-(4)>>0;}}else if(b<65536){a=$appendSlice(a,"\\u");i=12;while(true){if(!(i>=0)){break;}a=$append(a,"0123456789abcdef".charCodeAt((((b>>$min(((i>>>0)),31))>>0)&15)));i=i-(4)>>0;}}else{a=$appendSlice(a,"\\U");j=28;while(true){if(!(j>=0)){break;}a=$append(a,"0123456789abcdef".charCodeAt((((b>>$min(((j>>>0)),31))>>0)&15)));j=j-(4)>>0;}}}return a;};BZ=function(a){var a;return BU(a,34,false,false);};$pkg.Quote=BZ;CA=function(a,b){var a,b;return BW(a,b,34,false,false);};$pkg.AppendQuote=CA;CB=function(a){var a;return BU(a,34,true,false);};$pkg.QuoteToASCII=CB;CC=function(a,b){var a,b;return BW(a,b,34,true,false);};$pkg.AppendQuoteToASCII=CC;CG=function(a,b){var a,b;return BX(a,b,39,false,false);};$pkg.AppendQuoteRune=CG;CI=function(a,b){var a,b;return BX(a,b,39,true,false);};$pkg.AppendQuoteRuneToASCII=CI;CL=function(a){var a,b,c,d;while(true){if(!(a.length>0)){break;}b=E.DecodeRuneInString(a);c=b[0];d=b[1];a=$substring(a,d);if(d>1){if(c===65279){return false;}continue;}if(c===65533){return false;}if((c<32&&!((c===9)))||(c===96)||(c===127)){return false;}}return true;};$pkg.CanBackquote=CL;CM=function(a){var a,b,c,d,e,f,g,h,i,j;b=0;c=false;d=((a>>0));if(48<=d&&d<=57){e=d-48>>0;f=true;b=e;c=f;return[b,c];}else if(97<=d&&d<=102){g=(d-97>>0)+10>>0;h=true;b=g;c=h;return[b,c];}else if(65<=d&&d<=70){i=(d-65>>0)+10>>0;j=true;b=i;c=j;return[b,c];}return[b,c];};CN=function(a,b){var a,aa,ab,ac,ad,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;c=0;d=false;e="";f=$ifaceNil;if(a.length===0){f=$pkg.ErrSyntax;return[c,d,e,f];}g=a.charCodeAt(0);if((g===b)&&((b===39)||(b===34))){f=$pkg.ErrSyntax;return[c,d,e,f];}else if(g>=128){h=E.DecodeRuneInString(a);i=h[0];j=h[1];k=i;l=true;m=$substring(a,j);n=$ifaceNil;c=k;d=l;e=m;f=n;return[c,d,e,f];}else if(!((g===92))){o=((a.charCodeAt(0)>>0));p=false;q=$substring(a,1);r=$ifaceNil;c=o;d=p;e=q;f=r;return[c,d,e,f];}if(a.length<=1){f=$pkg.ErrSyntax;return[c,d,e,f];}s=a.charCodeAt(1);a=$substring(a,2);switch(0){default:t=s;if(t===(97)){c=7;}else if(t===(98)){c=8;}else if(t===(102)){c=12;}else if(t===(110)){c=10;}else if(t===(114)){c=13;}else if(t===(116)){c=9;}else if(t===(118)){c=11;}else if((t===(120))||(t===(117))||(t===(85))){u=0;v=s;if(v===(120)){u=2;}else if(v===(117)){u=4;}else if(v===(85)){u=8;}w=0;if(a.length>0)|z;x=x+(1)>>0;}a=$substring(a,u);if(s===120){c=w;break;}if(w>1114111){f=$pkg.ErrSyntax;return[c,d,e,f];}c=w;d=true;}else if((t===(48))||(t===(49))||(t===(50))||(t===(51))||(t===(52))||(t===(53))||(t===(54))||(t===(55))){ab=((s>>0))-48>>0;if(a.length<2){f=$pkg.ErrSyntax;return[c,d,e,f];}ac=0;while(true){if(!(ac<2)){break;}ad=((a.charCodeAt(ac)>>0))-48>>0;if(ad<0||ad>7){f=$pkg.ErrSyntax;return[c,d,e,f];}ab=((ab<<3>>0))|ad;ac=ac+(1)>>0;}a=$substring(a,2);if(ab>255){f=$pkg.ErrSyntax;return[c,d,e,f];}c=ab;}else if(t===(92)){c=92;}else if((t===(39))||(t===(34))){if(!((s===b))){f=$pkg.ErrSyntax;return[c,d,e,f];}c=((s>>0));}else{f=$pkg.ErrSyntax;return[c,d,e,f];}}e=a;return[c,d,e,f];};$pkg.UnquoteChar=CN;CO=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;b=a.length;if(b<2){return["",$pkg.ErrSyntax];}c=a.charCodeAt(0);if(!((c===a.charCodeAt((b-1>>0))))){return["",$pkg.ErrSyntax];}a=$substring(a,1,(b-1>>0));if(c===96){if(CP(a,96)){return["",$pkg.ErrSyntax];}if(CP(a,13)){d=$makeSlice(DE,0,(a.length-1>>0));e=0;while(true){if(!(e>0;}return[($bytesToString(d)),$ifaceNil];}return[a,$ifaceNil];}if(!((c===34))&&!((c===39))){return["",$pkg.ErrSyntax];}if(CP(a,10)){return["",$pkg.ErrSyntax];}if(!CP(a,92)&&!CP(a,c)){f=c;if(f===(34)){if(E.ValidString(a)){return[a,$ifaceNil];}}else if(f===(39)){g=E.DecodeRuneInString(a);h=g[0];i=g[1];if((i===a.length)&&(!((h===65533))||!((i===1)))){return[a,$ifaceNil];}}}j=DK.zero();l=$makeSlice(DE,0,(k=($imul(3,a.length))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero")));while(true){if(!(a.length>0)){break;}m=CN(a,c);n=m[0];o=m[1];p=m[2];q=m[3];if(!($interfaceIsEqual(q,$ifaceNil))){return["",q];}a=p;if(n<128||!o){l=$append(l,((n<<24>>>24)));}else{r=E.EncodeRune(new DE(j),n);l=$appendSlice(l,$subslice(new DE(j),0,r));}if((c===39)&&!((a.length===0))){return["",$pkg.ErrSyntax];}}return[($bytesToString(l)),$ifaceNil];};$pkg.Unquote=CO;CP=function(a,b){var a,b;return!((D.IndexByteString(a,b)===-1));};CQ=function(a,b){var a,b,c,d,e,f,g,h;c=0;d=a.$length;e=c;f=d;while(true){if(!(e>0))/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"))>>0;if(((h<0||h>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+h])>0;}else{f=h;}}return e;};CR=function(a,b){var a,b,c,d,e,f,g,h;c=0;d=a.$length;e=c;f=d;while(true){if(!(e>0))/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"))>>0;if(((h<0||h>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+h])>0;}else{f=h;}}return e;};CS=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;if(a<=255){if(32<=a&&a<=126){return true;}if(161<=a&&a<=255){return!((a===173));}return false;}if(0<=a&&a<65536){b=((a<<16>>>16));c=BH;d=BI;e=b;f=c;g=d;h=CQ(f,e);if(h>=f.$length||e<(i=(h&~1)>>0,((i<0||i>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+i]))||(j=h|1,((j<0||j>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+j]))=g.$length||!((((k<0||k>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+k])===e));}l=((a>>>0));m=BJ;n=BK;o=l;p=m;q=n;r=CR(p,o);if(r>=p.$length||o<(s=(r&~1)>>0,((s<0||s>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+s]))||(t=r|1,((t<0||t>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+t]))=131072){return true;}a=a-(65536)>>0;u=CQ(q,((a<<16>>>16)));return u>=q.$length||!((((u<0||u>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+u])===((a<<16>>>16))));};$pkg.IsPrint=CS;CU=function(a){var a,b,c;if(a>65535){return false;}b=((a<<16>>>16));c=CQ(BL,b);return c=BL.$length)?($throwRuntimeError("index out of range"),undefined):BL.$array[BL.$offset+c]));};DF.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];DL.methods=[{prop:"set",name:"set",pkg:"strconv",typ:$funcType([$String],[$Bool],false)},{prop:"floatBits",name:"floatBits",pkg:"strconv",typ:$funcType([DI],[$Uint64,$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Assign",name:"Assign",pkg:"",typ:$funcType([$Uint64],[],false)},{prop:"Shift",name:"Shift",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Round",name:"Round",pkg:"",typ:$funcType([$Int],[],false)},{prop:"RoundDown",name:"RoundDown",pkg:"",typ:$funcType([$Int],[],false)},{prop:"RoundUp",name:"RoundUp",pkg:"",typ:$funcType([$Int],[],false)},{prop:"RoundedInteger",name:"RoundedInteger",pkg:"",typ:$funcType([],[$Uint64],false)}];DN.methods=[{prop:"floatBits",name:"floatBits",pkg:"strconv",typ:$funcType([DI],[$Uint64,$Bool],false)},{prop:"AssignComputeBounds",name:"AssignComputeBounds",pkg:"",typ:$funcType([$Uint64,$Int,$Bool,DI],[AL,AL],false)},{prop:"Normalize",name:"Normalize",pkg:"",typ:$funcType([],[$Uint],false)},{prop:"Multiply",name:"Multiply",pkg:"",typ:$funcType([AL],[],false)},{prop:"AssignDecimal",name:"AssignDecimal",pkg:"",typ:$funcType([$Uint64,$Int,$Bool,$Bool,DI],[$Bool],false)},{prop:"frexp10",name:"frexp10",pkg:"strconv",typ:$funcType([],[$Int,$Int],false)},{prop:"FixedDecimal",name:"FixedDecimal",pkg:"",typ:$funcType([DM,$Int],[$Bool],false)},{prop:"ShortestDecimal",name:"ShortestDecimal",pkg:"",typ:$funcType([DM,DN,DN],[$Bool],false)}];U.init("",[{prop:"Func",name:"Func",embedded:false,exported:true,typ:$String,tag:""},{prop:"Num",name:"Num",embedded:false,exported:true,typ:$String,tag:""},{prop:"Err",name:"Err",embedded:false,exported:true,typ:$error,tag:""}]);AC.init("strconv",[{prop:"d",name:"d",embedded:false,exported:false,typ:DD,tag:""},{prop:"nd",name:"nd",embedded:false,exported:false,typ:$Int,tag:""},{prop:"dp",name:"dp",embedded:false,exported:false,typ:$Int,tag:""},{prop:"neg",name:"neg",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"trunc",name:"trunc",embedded:false,exported:false,typ:$Bool,tag:""}]);AG.init("strconv",[{prop:"delta",name:"delta",embedded:false,exported:false,typ:$Int,tag:""},{prop:"cutoff",name:"cutoff",embedded:false,exported:false,typ:$String,tag:""}]);AL.init("strconv",[{prop:"mant",name:"mant",embedded:false,exported:false,typ:$Uint64,tag:""},{prop:"exp",name:"exp",embedded:false,exported:false,typ:$Int,tag:""},{prop:"neg",name:"neg",embedded:false,exported:false,typ:$Bool,tag:""}]);AS.init("strconv",[{prop:"mantbits",name:"mantbits",embedded:false,exported:false,typ:$Uint,tag:""},{prop:"expbits",name:"expbits",embedded:false,exported:false,typ:$Uint,tag:""},{prop:"bias",name:"bias",embedded:false,exported:false,typ:$Int,tag:""}]);BB.init("strconv",[{prop:"d",name:"d",embedded:false,exported:false,typ:DE,tag:""},{prop:"nd",name:"nd",embedded:false,exported:false,typ:$Int,tag:""},{prop:"dp",name:"dp",embedded:false,exported:false,typ:$Int,tag:""},{prop:"neg",name:"neg",embedded:false,exported:false,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}I=true;M=new CX([1,3,6,9,13,16,19,23,26]);N=new CY([1,10,100,1000,10000,100000,1e+06,1e+07,1e+08,1e+09,1e+10,1e+11,1e+12,1e+13,1e+14,1e+15,1e+16,1e+17,1e+18,1e+19,1e+20,1e+21,1e+22]);O=new CZ([1,10,100,1000,10000,100000,1e+06,1e+07,1e+08,1e+09,1e+10]);$pkg.ErrRange=B.New("value out of range");$pkg.ErrSyntax=B.New("invalid syntax");AH=new DA([new AG.ptr(0,""),new AG.ptr(1,"5"),new AG.ptr(1,"25"),new AG.ptr(1,"125"),new AG.ptr(2,"625"),new AG.ptr(2,"3125"),new AG.ptr(2,"15625"),new AG.ptr(3,"78125"),new AG.ptr(3,"390625"),new AG.ptr(3,"1953125"),new AG.ptr(4,"9765625"),new AG.ptr(4,"48828125"),new AG.ptr(4,"244140625"),new AG.ptr(4,"1220703125"),new AG.ptr(5,"6103515625"),new AG.ptr(5,"30517578125"),new AG.ptr(5,"152587890625"),new AG.ptr(6,"762939453125"),new AG.ptr(6,"3814697265625"),new AG.ptr(6,"19073486328125"),new AG.ptr(7,"95367431640625"),new AG.ptr(7,"476837158203125"),new AG.ptr(7,"2384185791015625"),new AG.ptr(7,"11920928955078125"),new AG.ptr(8,"59604644775390625"),new AG.ptr(8,"298023223876953125"),new AG.ptr(8,"1490116119384765625"),new AG.ptr(9,"7450580596923828125"),new AG.ptr(9,"37252902984619140625"),new AG.ptr(9,"186264514923095703125"),new AG.ptr(10,"931322574615478515625"),new AG.ptr(10,"4656612873077392578125"),new AG.ptr(10,"23283064365386962890625"),new AG.ptr(10,"116415321826934814453125"),new AG.ptr(11,"582076609134674072265625"),new AG.ptr(11,"2910383045673370361328125"),new AG.ptr(11,"14551915228366851806640625"),new AG.ptr(12,"72759576141834259033203125"),new AG.ptr(12,"363797880709171295166015625"),new AG.ptr(12,"1818989403545856475830078125"),new AG.ptr(13,"9094947017729282379150390625"),new AG.ptr(13,"45474735088646411895751953125"),new AG.ptr(13,"227373675443232059478759765625"),new AG.ptr(13,"1136868377216160297393798828125"),new AG.ptr(14,"5684341886080801486968994140625"),new AG.ptr(14,"28421709430404007434844970703125"),new AG.ptr(14,"142108547152020037174224853515625"),new AG.ptr(15,"710542735760100185871124267578125"),new AG.ptr(15,"3552713678800500929355621337890625"),new AG.ptr(15,"17763568394002504646778106689453125"),new AG.ptr(16,"88817841970012523233890533447265625"),new AG.ptr(16,"444089209850062616169452667236328125"),new AG.ptr(16,"2220446049250313080847263336181640625"),new AG.ptr(16,"11102230246251565404236316680908203125"),new AG.ptr(17,"55511151231257827021181583404541015625"),new AG.ptr(17,"277555756156289135105907917022705078125"),new AG.ptr(17,"1387778780781445675529539585113525390625"),new AG.ptr(18,"6938893903907228377647697925567626953125"),new AG.ptr(18,"34694469519536141888238489627838134765625"),new AG.ptr(18,"173472347597680709441192448139190673828125"),new AG.ptr(19,"867361737988403547205962240695953369140625")]);AM=$toNativeArray($kindStruct,[new AL.ptr(new $Uint64(2147483648,0),-63,false),new AL.ptr(new $Uint64(2684354560,0),-60,false),new AL.ptr(new $Uint64(3355443200,0),-57,false),new AL.ptr(new $Uint64(4194304000,0),-54,false),new AL.ptr(new $Uint64(2621440000,0),-50,false),new AL.ptr(new $Uint64(3276800000,0),-47,false),new AL.ptr(new $Uint64(4096000000,0),-44,false),new AL.ptr(new $Uint64(2560000000,0),-40,false)]);AN=$toNativeArray($kindStruct,[new AL.ptr(new $Uint64(4203730336,136053384),-1220,false),new AL.ptr(new $Uint64(3132023167,2722021238),-1193,false),new AL.ptr(new $Uint64(2333539104,810921078),-1166,false),new AL.ptr(new $Uint64(3477244234,1573795306),-1140,false),new AL.ptr(new $Uint64(2590748842,1432697645),-1113,false),new AL.ptr(new $Uint64(3860516611,1025131999),-1087,false),new AL.ptr(new $Uint64(2876309015,3348809418),-1060,false),new AL.ptr(new $Uint64(4286034428,3200048207),-1034,false),new AL.ptr(new $Uint64(3193344495,1097586188),-1007,false),new AL.ptr(new $Uint64(2379227053,2424306748),-980,false),new AL.ptr(new $Uint64(3545324584,827693699),-954,false),new AL.ptr(new $Uint64(2641472655,2913388981),-927,false),new AL.ptr(new $Uint64(3936100983,602835915),-901,false),new AL.ptr(new $Uint64(2932623761,1081627501),-874,false),new AL.ptr(new $Uint64(2184974969,1572261463),-847,false),new AL.ptr(new $Uint64(3255866422,1308317239),-821,false),new AL.ptr(new $Uint64(2425809519,944281679),-794,false),new AL.ptr(new $Uint64(3614737867,629291719),-768,false),new AL.ptr(new $Uint64(2693189581,2545915892),-741,false),new AL.ptr(new $Uint64(4013165208,388672741),-715,false),new AL.ptr(new $Uint64(2990041083,708162190),-688,false),new AL.ptr(new $Uint64(2227754207,3536207675),-661,false),new AL.ptr(new $Uint64(3319612455,450088378),-635,false),new AL.ptr(new $Uint64(2473304014,3139815830),-608,false),new AL.ptr(new $Uint64(3685510180,2103616900),-582,false),new AL.ptr(new $Uint64(2745919064,224385782),-555,false),new AL.ptr(new $Uint64(4091738259,3737383206),-529,false),new AL.ptr(new $Uint64(3048582568,2868871352),-502,false),new AL.ptr(new $Uint64(2271371013,1820084875),-475,false),new AL.ptr(new $Uint64(3384606560,885076051),-449,false),new AL.ptr(new $Uint64(2521728396,2444895829),-422,false),new AL.ptr(new $Uint64(3757668132,1881767613),-396,false),new AL.ptr(new $Uint64(2799680927,3102062735),-369,false),new AL.ptr(new $Uint64(4171849679,2289335700),-343,false),new AL.ptr(new $Uint64(3108270227,2410191823),-316,false),new AL.ptr(new $Uint64(2315841784,3205436779),-289,false),new AL.ptr(new $Uint64(3450873173,1697722806),-263,false),new AL.ptr(new $Uint64(2571100870,3497754540),-236,false),new AL.ptr(new $Uint64(3831238852,707476230),-210,false),new AL.ptr(new $Uint64(2854495385,1769181907),-183,false),new AL.ptr(new $Uint64(4253529586,2197867022),-157,false),new AL.ptr(new $Uint64(3169126500,2450594539),-130,false),new AL.ptr(new $Uint64(2361183241,1867548876),-103,false),new AL.ptr(new $Uint64(3518437208,3793315116),-77,false),new AL.ptr(new $Uint64(2621440000,0),-50,false),new AL.ptr(new $Uint64(3906250000,0),-24,false),new AL.ptr(new $Uint64(2910383045,2892103680),3,false),new AL.ptr(new $Uint64(2168404344,4170451332),30,false),new AL.ptr(new $Uint64(3231174267,3372684723),56,false),new AL.ptr(new $Uint64(2407412430,2078956656),83,false),new AL.ptr(new $Uint64(3587324068,2884206696),109,false),new AL.ptr(new $Uint64(2672764710,395977285),136,false),new AL.ptr(new $Uint64(3982729777,3569679143),162,false),new AL.ptr(new $Uint64(2967364920,2361961896),189,false),new AL.ptr(new $Uint64(2210859150,447440347),216,false),new AL.ptr(new $Uint64(3294436857,1114709402),242,false),new AL.ptr(new $Uint64(2454546732,2786846552),269,false),new AL.ptr(new $Uint64(3657559652,443583978),295,false),new AL.ptr(new $Uint64(2725094297,2599384906),322,false),new AL.ptr(new $Uint64(4060706939,3028118405),348,false),new AL.ptr(new $Uint64(3025462433,2044532855),375,false),new AL.ptr(new $Uint64(2254145170,1536935362),402,false),new AL.ptr(new $Uint64(3358938053,3365297469),428,false),new AL.ptr(new $Uint64(2502603868,4204241075),455,false),new AL.ptr(new $Uint64(3729170365,2577424355),481,false),new AL.ptr(new $Uint64(2778448436,3677981733),508,false),new AL.ptr(new $Uint64(4140210802,2744688476),534,false),new AL.ptr(new $Uint64(3084697427,1424604878),561,false),new AL.ptr(new $Uint64(2298278679,4062331362),588,false),new AL.ptr(new $Uint64(3424702107,3546052773),614,false),new AL.ptr(new $Uint64(2551601907,2065781727),641,false),new AL.ptr(new $Uint64(3802183132,2535403578),667,false),new AL.ptr(new $Uint64(2832847187,1558426518),694,false),new AL.ptr(new $Uint64(4221271257,2762425404),720,false),new AL.ptr(new $Uint64(3145092172,2812560400),747,false),new AL.ptr(new $Uint64(2343276271,3057687578),774,false),new AL.ptr(new $Uint64(3491753744,2790753324),800,false),new AL.ptr(new $Uint64(2601559269,3918606633),827,false),new AL.ptr(new $Uint64(3876625403,2711358621),853,false),new AL.ptr(new $Uint64(2888311001,1648096297),880,false),new AL.ptr(new $Uint64(2151959390,2057817989),907,false),new AL.ptr(new $Uint64(3206669376,61660461),933,false),new AL.ptr(new $Uint64(2389154863,1581580175),960,false),new AL.ptr(new $Uint64(3560118173,2626467905),986,false),new AL.ptr(new $Uint64(2652494738,3034782633),1013,false),new AL.ptr(new $Uint64(3952525166,3135207385),1039,false),new AL.ptr(new $Uint64(2944860731,2616258155),1066,false)]);AO=$toNativeArray($kindUint64,[new $Uint64(0,1),new $Uint64(0,10),new $Uint64(0,100),new $Uint64(0,1000),new $Uint64(0,10000),new $Uint64(0,100000),new $Uint64(0,1000000),new $Uint64(0,10000000),new $Uint64(0,100000000),new $Uint64(0,1000000000),new $Uint64(2,1410065408),new $Uint64(23,1215752192),new $Uint64(232,3567587328),new $Uint64(2328,1316134912),new $Uint64(23283,276447232),new $Uint64(232830,2764472320),new $Uint64(2328306,1874919424),new $Uint64(23283064,1569325056),new $Uint64(232830643,2808348672),new $Uint64(2328306436,2313682944)]);AT=new AS.ptr(23,8,-127);AU=new AS.ptr(52,11,-1023);BH=new DB([32,126,161,887,890,895,900,1366,1369,1418,1421,1479,1488,1514,1520,1524,1542,1563,1566,1805,1808,1866,1869,1969,1984,2042,2048,2093,2096,2139,2142,2154,2208,2237,2260,2444,2447,2448,2451,2482,2486,2489,2492,2500,2503,2504,2507,2510,2519,2519,2524,2531,2534,2557,2561,2570,2575,2576,2579,2617,2620,2626,2631,2632,2635,2637,2641,2641,2649,2654,2662,2677,2689,2745,2748,2765,2768,2768,2784,2787,2790,2801,2809,2828,2831,2832,2835,2873,2876,2884,2887,2888,2891,2893,2902,2903,2908,2915,2918,2935,2946,2954,2958,2965,2969,2975,2979,2980,2984,2986,2990,3001,3006,3010,3014,3021,3024,3024,3031,3031,3046,3066,3072,3129,3133,3149,3157,3162,3168,3171,3174,3183,3192,3257,3260,3277,3285,3286,3294,3299,3302,3314,3328,3407,3412,3427,3430,3455,3458,3478,3482,3517,3520,3526,3530,3530,3535,3551,3558,3567,3570,3572,3585,3642,3647,3675,3713,3716,3719,3722,3725,3725,3732,3751,3754,3773,3776,3789,3792,3801,3804,3807,3840,3948,3953,4058,4096,4295,4301,4301,4304,4685,4688,4701,4704,4749,4752,4789,4792,4805,4808,4885,4888,4954,4957,4988,4992,5017,5024,5109,5112,5117,5120,5788,5792,5880,5888,5908,5920,5942,5952,5971,5984,6003,6016,6109,6112,6121,6128,6137,6144,6157,6160,6169,6176,6263,6272,6314,6320,6389,6400,6443,6448,6459,6464,6464,6468,6509,6512,6516,6528,6571,6576,6601,6608,6618,6622,6683,6686,6780,6783,6793,6800,6809,6816,6829,6832,6846,6912,6987,6992,7036,7040,7155,7164,7223,7227,7241,7245,7304,7360,7367,7376,7417,7424,7957,7960,7965,7968,8005,8008,8013,8016,8061,8064,8147,8150,8175,8178,8190,8208,8231,8240,8286,8304,8305,8308,8348,8352,8383,8400,8432,8448,8587,8592,9254,9280,9290,9312,11123,11126,11157,11160,11193,11197,11218,11244,11247,11264,11507,11513,11559,11565,11565,11568,11623,11631,11632,11647,11670,11680,11849,11904,12019,12032,12245,12272,12283,12289,12438,12441,12543,12549,12590,12593,12730,12736,12771,12784,19893,19904,40938,40960,42124,42128,42182,42192,42539,42560,42743,42752,42935,42999,43051,43056,43065,43072,43127,43136,43205,43214,43225,43232,43261,43264,43347,43359,43388,43392,43481,43486,43574,43584,43597,43600,43609,43612,43714,43739,43766,43777,43782,43785,43790,43793,43798,43808,43877,43888,44013,44016,44025,44032,55203,55216,55238,55243,55291,63744,64109,64112,64217,64256,64262,64275,64279,64285,64449,64467,64831,64848,64911,64914,64967,65008,65021,65024,65049,65056,65131,65136,65276,65281,65470,65474,65479,65482,65487,65490,65495,65498,65500,65504,65518,65532,65533]);BI=new DB([173,907,909,930,1328,1376,1416,1424,1757,2111,2143,2229,2274,2436,2473,2481,2526,2564,2601,2609,2612,2615,2621,2653,2692,2702,2706,2729,2737,2740,2758,2762,2816,2820,2857,2865,2868,2910,2948,2961,2971,2973,3017,3076,3085,3089,3113,3141,3145,3159,3204,3213,3217,3241,3252,3269,3273,3295,3312,3332,3341,3345,3397,3401,3460,3506,3516,3541,3543,3715,3721,3736,3744,3748,3750,3756,3770,3781,3783,3912,3992,4029,4045,4294,4681,4695,4697,4745,4785,4799,4801,4823,4881,5760,5901,5997,6001,6431,6751,7674,8024,8026,8028,8030,8117,8133,8156,8181,8335,11209,11311,11359,11558,11687,11695,11703,11711,11719,11727,11735,11743,11930,12352,12687,12831,13055,42927,43470,43519,43815,43823,64311,64317,64319,64322,64325,65107,65127,65141,65511]);BJ=new DC([65536,65613,65616,65629,65664,65786,65792,65794,65799,65843,65847,65947,65952,65952,66000,66045,66176,66204,66208,66256,66272,66299,66304,66339,66349,66378,66384,66426,66432,66499,66504,66517,66560,66717,66720,66729,66736,66771,66776,66811,66816,66855,66864,66915,66927,66927,67072,67382,67392,67413,67424,67431,67584,67589,67592,67640,67644,67644,67647,67742,67751,67759,67808,67829,67835,67867,67871,67897,67903,67903,67968,68023,68028,68047,68050,68102,68108,68147,68152,68154,68159,68167,68176,68184,68192,68255,68288,68326,68331,68342,68352,68405,68409,68437,68440,68466,68472,68497,68505,68508,68521,68527,68608,68680,68736,68786,68800,68850,68858,68863,69216,69246,69632,69709,69714,69743,69759,69825,69840,69864,69872,69881,69888,69955,69968,70006,70016,70093,70096,70132,70144,70206,70272,70313,70320,70378,70384,70393,70400,70412,70415,70416,70419,70457,70460,70468,70471,70472,70475,70477,70480,70480,70487,70487,70493,70499,70502,70508,70512,70516,70656,70749,70784,70855,70864,70873,71040,71093,71096,71133,71168,71236,71248,71257,71264,71276,71296,71351,71360,71369,71424,71449,71453,71467,71472,71487,71840,71922,71935,71935,72192,72263,72272,72323,72326,72354,72384,72440,72704,72773,72784,72812,72816,72847,72850,72886,72960,73014,73018,73031,73040,73049,73728,74649,74752,74868,74880,75075,77824,78894,82944,83526,92160,92728,92736,92777,92782,92783,92880,92909,92912,92917,92928,92997,93008,93047,93053,93071,93952,94020,94032,94078,94095,94111,94176,94177,94208,100332,100352,101106,110592,110878,110960,111355,113664,113770,113776,113788,113792,113800,113808,113817,113820,113823,118784,119029,119040,119078,119081,119154,119163,119272,119296,119365,119552,119638,119648,119665,119808,119967,119970,119970,119973,119974,119977,120074,120077,120134,120138,120485,120488,120779,120782,121483,121499,121519,122880,122904,122907,122922,124928,125124,125127,125142,125184,125258,125264,125273,125278,125279,126464,126500,126503,126523,126530,126530,126535,126548,126551,126564,126567,126619,126625,126651,126704,126705,126976,127019,127024,127123,127136,127150,127153,127221,127232,127244,127248,127339,127344,127404,127462,127490,127504,127547,127552,127560,127568,127569,127584,127589,127744,128724,128736,128748,128752,128760,128768,128883,128896,128980,129024,129035,129040,129095,129104,129113,129120,129159,129168,129197,129280,129291,129296,129356,129360,129387,129408,129431,129472,129472,129488,129510,131072,173782,173824,177972,177984,178205,178208,183969,183984,191456,194560,195101,917760,917999]);BK=new DB([12,39,59,62,399,926,2057,2102,2134,2291,2564,2580,2584,4285,4405,4576,4626,4743,4745,4750,4766,4868,4905,4913,4916,5210,5212,6813,7177,7223,7336,7431,7434,7483,7486,9327,27231,27482,27490,54357,54429,54445,54458,54460,54468,54534,54549,54557,54586,54591,54597,54609,55968,57351,57378,57381,60932,60960,60963,60968,60979,60984,60986,61000,61002,61004,61008,61011,61016,61018,61020,61022,61024,61027,61035,61043,61048,61053,61055,61066,61092,61098,61632,61648,61743,63807]);BL=new DB([160,5760,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["crypto"]=(function(){var $pkg={},$init,A,B,C,O,P,F,G;A=$packages["hash"];B=$packages["io"];C=$packages["strconv"];O=$funcType([],[A.Hash],false);P=$sliceType(O);G=function(a,b){var a,b;if(a>=20){$panic(new $String("crypto: RegisterHash of unknown hash function"));}((a<0||a>=F.$length)?($throwRuntimeError("index out of range"),undefined):F.$array[F.$offset+a]=b);};$pkg.RegisterHash=G;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}F=$makeSlice(P,20);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["crypto/sha256"]=(function(){var $pkg={},$init,A,B,C,E,S,T,U,V,W,X,Y,AA,AB,P,R,D,F,G,H,I,J,K,L,M,N,Q;A=$packages["crypto"];B=$packages["errors"];C=$packages["hash"];E=$pkg.digest=$newType(0,$kindStruct,"sha256.digest",true,"crypto/sha256",false,function(h_,x_,nx_,len_,is224_){this.$val=this;if(arguments.length===0){this.h=W.zero();this.x=X.zero();this.nx=0;this.len=new $Uint64(0,0);this.is224=false;return;}this.h=h_;this.x=x_;this.nx=nx_;this.len=len_;this.is224=is224_;});S=$sliceType($Uint32);T=$sliceType($Uint8);U=$arrayType($Uint8,8);V=$arrayType($Uint8,4);W=$arrayType($Uint32,8);X=$arrayType($Uint8,64);Y=$arrayType($Uint8,32);AA=$arrayType($Uint32,64);AB=$ptrType(E);D=function(){A.RegisterHash(4,M);A.RegisterHash(5,L);};E.ptr.prototype.MarshalBinary=function(){var a,b;a=this;b=$makeSlice(T,0,108);if(a.is224){b=$appendSlice(b,"sha\x02");}else{b=$appendSlice(b,"sha\x03");}b=I(b,a.h[0]);b=I(b,a.h[1]);b=I(b,a.h[2]);b=I(b,a.h[3]);b=I(b,a.h[4]);b=I(b,a.h[5]);b=I(b,a.h[6]);b=I(b,a.h[7]);b=$appendSlice(b,$subslice(new T(a.x),0,a.nx));b=$subslice(b,0,((b.$length+64>>0)-(a.nx)>>0));b=H(b,a.len);return[b,$ifaceNil];};E.prototype.MarshalBinary=function(){return this.$val.MarshalBinary();};E.ptr.prototype.UnmarshalBinary=function(a){var a,b,c,d,e,f,g,h,i,j,k;b=this;if(a.$length<4||(b.is224&&!(($bytesToString($subslice(a,0,4)))==="sha\x02"))||(!b.is224&&!(($bytesToString($subslice(a,0,4)))==="sha\x03"))){return B.New("crypto/sha256: invalid hash state identifier");}if(!((a.$length===108))){return B.New("crypto/sha256: invalid hash state size");}a=$subslice(a,4);c=K(a);a=c[0];b.h[0]=c[1];d=K(a);a=d[0];b.h[1]=d[1];e=K(a);a=e[0];b.h[2]=e[1];f=K(a);a=f[0];b.h[3]=f[1];g=K(a);a=g[0];b.h[4]=g[1];h=K(a);a=h[0];b.h[5]=h[1];i=K(a);a=i[0];b.h[6]=i[1];j=K(a);a=j[0];b.h[7]=j[1];a=$subslice(a,$copySlice(new T(b.x),a));k=J(a);a=k[0];b.len=k[1];b.nx=(($div64(b.len,new $Uint64(0,64),true).$low>>0));return $ifaceNil;};E.prototype.UnmarshalBinary=function(a){return this.$val.UnmarshalBinary(a);};F=function(a,b){var a,b;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=(((b>>>24>>>0)<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(((b>>>16>>>0)<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(((b>>>8>>>0)<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=((b<<24>>>24)));};G=function(a,b){var a,b;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=(($shiftRightUint64(b,56).$low<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(($shiftRightUint64(b,48).$low<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(($shiftRightUint64(b,40).$low<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=(($shiftRightUint64(b,32).$low<<24>>>24)));(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]=(($shiftRightUint64(b,24).$low<<24>>>24)));(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]=(($shiftRightUint64(b,16).$low<<24>>>24)));(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]=(($shiftRightUint64(b,8).$low<<24>>>24)));(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]=((b.$low<<24>>>24)));};H=function(a,b){var a,b,c;c=U.zero();G(new T(c),b);return $appendSlice(a,new T(c));};I=function(a,b){var a,b,c;c=V.zero();F(new T(c),b);return $appendSlice(a,new T(c));};J=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));p=(b=(c=(d=(e=(f=(g=(h=(new $Uint64(0,(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]))),i=$shiftLeft64((new $Uint64(0,(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]))),8),new $Uint64(h.$high|i.$high,(h.$low|i.$low)>>>0)),j=$shiftLeft64((new $Uint64(0,(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]))),16),new $Uint64(g.$high|j.$high,(g.$low|j.$low)>>>0)),k=$shiftLeft64((new $Uint64(0,(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]))),24),new $Uint64(f.$high|k.$high,(f.$low|k.$low)>>>0)),l=$shiftLeft64((new $Uint64(0,(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]))),32),new $Uint64(e.$high|l.$high,(e.$low|l.$low)>>>0)),m=$shiftLeft64((new $Uint64(0,(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]))),40),new $Uint64(d.$high|m.$high,(d.$low|m.$low)>>>0)),n=$shiftLeft64((new $Uint64(0,(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]))),48),new $Uint64(c.$high|n.$high,(c.$low|n.$low)>>>0)),o=$shiftLeft64((new $Uint64(0,(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]))),56),new $Uint64(b.$high|o.$high,(b.$low|o.$low)>>>0));return[$subslice(a,8),p];};K=function(a){var a,b;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));b=((((((((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3])>>>0))|((((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2])>>>0))<<8>>>0))>>>0)|((((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])>>>0))<<16>>>0))>>>0)|((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])>>>0))<<24>>>0))>>>0;return[$subslice(a,4),b];};E.ptr.prototype.Reset=function(){var a;a=this;if(!a.is224){a.h[0]=1779033703;a.h[1]=3144134277;a.h[2]=1013904242;a.h[3]=2773480762;a.h[4]=1359893119;a.h[5]=2600822924;a.h[6]=528734635;a.h[7]=1541459225;}else{a.h[0]=3238371032;a.h[1]=914150663;a.h[2]=812702999;a.h[3]=4144912697;a.h[4]=4290775857;a.h[5]=1750603025;a.h[6]=1694076839;a.h[7]=3204075428;}a.nx=0;a.len=new $Uint64(0,0);};E.prototype.Reset=function(){return this.$val.Reset();};L=function(){var a;a=new E.ptr(W.zero(),X.zero(),0,new $Uint64(0,0),false);a.Reset();return a;};$pkg.New=L;M=function(){var a;a=new E.ptr(W.zero(),X.zero(),0,new $Uint64(0,0),false);a.is224=true;a.Reset();return a;};$pkg.New224=M;E.ptr.prototype.Size=function(){var a;a=this;if(!a.is224){return 32;}return 28;};E.prototype.Size=function(){return this.$val.Size();};E.ptr.prototype.BlockSize=function(){var a;a=this;return 64;};E.prototype.BlockSize=function(){return this.$val.BlockSize();};E.ptr.prototype.Write=function(a){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=0;c=$ifaceNil;d=this;b=a.$length;d.len=(e=d.len,f=(new $Uint64(0,b)),new $Uint64(e.$high+f.$high,e.$low+f.$low));if(d.nx>0){$s=1;continue;}$s=2;continue;case 1:g=$copySlice($subslice(new T(d.x),d.nx),a);d.nx=d.nx+(g)>>0;if(d.nx===64){$s=3;continue;}$s=4;continue;case 3:$r=R(d,new T(d.x));$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d.nx=0;case 4:a=$subslice(a,g);case 2:if(a.$length>=64){$s=6;continue;}$s=7;continue;case 6:h=(a.$length&~63)>>0;$r=R(d,$subslice(a,0,h));$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}a=$subslice(a,h);case 7:if(a.$length>0){d.nx=$copySlice(new T(d.x),a);}$s=-1;return[b,c];}return;}if($f===undefined){$f={$blk:E.ptr.prototype.Write};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};E.prototype.Write=function(a){return this.$val.Write(a);};E.ptr.prototype.Sum=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=$clone(b,E);d=c.checkSum();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=$clone(d,Y);if(c.is224){$s=-1;return $appendSlice(a,$subslice(new T(e),0,28));}$s=-1;return $appendSlice(a,new T(e));}return;}if($f===undefined){$f={$blk:E.ptr.prototype.Sum};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};E.prototype.Sum=function(a){return this.$val.Sum(a);};E.ptr.prototype.checkSum=function(){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.len;c=X.zero();c[0]=128;if((d=$div64(b,new $Uint64(0,64),true),(d.$high<0||(d.$high===0&&d.$low<56)))){$s=1;continue;}$s=2;continue;case 1:f=a.Write($subslice(new T(c),0,$flatten64((e=$div64(b,new $Uint64(0,64),true),new $Uint64(0-e.$high,56-e.$low)))));$s=4;case 4:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;$s=3;continue;case 2:h=a.Write($subslice(new T(c),0,$flatten64((g=$div64(b,new $Uint64(0,64),true),new $Uint64(0-g.$high,120-g.$low)))));$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;case 3:b=$shiftLeft64(b,(3));G(new T(c),b);i=a.Write($subslice(new T(c),0,8));$s=6;case 6:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;if(!((a.nx===0))){$panic(new $String("d.nx != 0"));}j=Y.zero();F($subslice(new T(j),0),a.h[0]);F($subslice(new T(j),4),a.h[1]);F($subslice(new T(j),8),a.h[2]);F($subslice(new T(j),12),a.h[3]);F($subslice(new T(j),16),a.h[4]);F($subslice(new T(j),20),a.h[5]);F($subslice(new T(j),24),a.h[6]);if(!a.is224){F($subslice(new T(j),28),a.h[7]);}$s=-1;return j;}return;}if($f===undefined){$f={$blk:E.ptr.prototype.checkSum};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};E.prototype.checkSum=function(){return this.$val.checkSum();};N=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=new E.ptr(W.zero(),X.zero(),0,new $Uint64(0,0),false);b.Reset();c=b.Write(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}c;d=b.checkSum();$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:N};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sum256=N;Q=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,bb,bc,bd,be,bf,bg,bh,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;c=AA.zero();d=a.h[0];e=a.h[1];f=a.h[2];g=a.h[3];h=a.h[4];i=a.h[5];j=a.h[6];k=a.h[7];l=d;m=e;n=f;o=g;p=h;q=i;r=j;s=k;while(true){if(!(b.$length>=64)){break;}t=0;while(true){if(!(t<16)){break;}u=$imul(t,4);((t<0||t>=c.length)?($throwRuntimeError("index out of range"),undefined):c[t]=(((((((((((u<0||u>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+u])>>>0))<<24>>>0)|((((v=u+1>>0,((v<0||v>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+v]))>>>0))<<16>>>0))>>>0)|((((w=u+2>>0,((w<0||w>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+w]))>>>0))<<8>>>0))>>>0)|(((x=u+3>>0,((x<0||x>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+x]))>>>0)))>>>0));t=t+(1)>>0;}y=16;while(true){if(!(y<64)){break;}aa=(z=y-2>>0,((z<0||z>=c.length)?($throwRuntimeError("index out of range"),undefined):c[z]));ab=(((((((aa>>>17>>>0)|(aa<<15>>>0))>>>0))^((((aa>>>19>>>0)|(aa<<13>>>0))>>>0)))>>>0)^((aa>>>10>>>0)))>>>0;ad=(ac=y-15>>0,((ac<0||ac>=c.length)?($throwRuntimeError("index out of range"),undefined):c[ac]));ae=(((((((ad>>>7>>>0)|(ad<<25>>>0))>>>0))^((((ad>>>18>>>0)|(ad<<14>>>0))>>>0)))>>>0)^((ad>>>3>>>0)))>>>0;((y<0||y>=c.length)?($throwRuntimeError("index out of range"),undefined):c[y]=(((ab+(af=y-7>>0,((af<0||af>=c.length)?($throwRuntimeError("index out of range"),undefined):c[af]))>>>0)+ae>>>0)+(ag=y-16>>0,((ag<0||ag>=c.length)?($throwRuntimeError("index out of range"),undefined):c[ag]))>>>0));y=y+(1)>>0;}ah=l;ai=m;aj=n;ak=o;al=p;am=q;an=r;ao=s;ap=ah;aq=ai;ar=aj;as=ak;at=al;au=am;av=an;aw=ao;ax=0;while(true){if(!(ax<64)){break;}ay=(((aw+(((((((((at>>>6>>>0)|(at<<26>>>0))>>>0))^((((at>>>11>>>0)|(at<<21>>>0))>>>0)))>>>0)^((((at>>>25>>>0)|(at<<7>>>0))>>>0)))>>>0))>>>0)+((((((at&au)>>>0))^((((~at>>>0)&av)>>>0)))>>>0))>>>0)+((ax<0||ax>=P.$length)?($throwRuntimeError("index out of range"),undefined):P.$array[P.$offset+ax])>>>0)+((ax<0||ax>=c.length)?($throwRuntimeError("index out of range"),undefined):c[ax])>>>0;az=(((((((((ap>>>2>>>0)|(ap<<30>>>0))>>>0))^((((ap>>>13>>>0)|(ap<<19>>>0))>>>0)))>>>0)^((((ap>>>22>>>0)|(ap<<10>>>0))>>>0)))>>>0))+((((((((ap&aq)>>>0))^(((ap&ar)>>>0)))>>>0)^(((aq&ar)>>>0)))>>>0))>>>0;aw=av;av=au;au=at;at=as+ay>>>0;as=ar;ar=aq;aq=ap;ap=ay+az>>>0;ax=ax+(1)>>0;}l=l+(ap)>>>0;m=m+(aq)>>>0;n=n+(ar)>>>0;o=o+(as)>>>0;p=p+(at)>>>0;q=q+(au)>>>0;r=r+(av)>>>0;s=s+(aw)>>>0;b=$subslice(b,64);}ba=l;bb=m;bc=n;bd=o;be=p;bf=q;bg=r;bh=s;a.h[0]=ba;a.h[1]=bb;a.h[2]=bc;a.h[3]=bd;a.h[4]=be;a.h[5]=bf;a.h[6]=bg;a.h[7]=bh;};AB.methods=[{prop:"MarshalBinary",name:"MarshalBinary",pkg:"",typ:$funcType([],[T,$error],false)},{prop:"UnmarshalBinary",name:"UnmarshalBinary",pkg:"",typ:$funcType([T],[$error],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int],false)},{prop:"BlockSize",name:"BlockSize",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([T],[$Int,$error],false)},{prop:"Sum",name:"Sum",pkg:"",typ:$funcType([T],[T],false)},{prop:"checkSum",name:"checkSum",pkg:"crypto/sha256",typ:$funcType([],[Y],false)}];E.init("crypto/sha256",[{prop:"h",name:"h",embedded:false,exported:false,typ:W,tag:""},{prop:"x",name:"x",embedded:false,exported:false,typ:X,tag:""},{prop:"nx",name:"nx",embedded:false,exported:false,typ:$Int,tag:""},{prop:"len",name:"len",embedded:false,exported:false,typ:$Uint64,tag:""},{prop:"is224",name:"is224",embedded:false,exported:false,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}P=new S([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]);R=Q;D();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["unicode"]=(function(){var $pkg={},$init,O,P,Q,R,T,AF,IX,IY,IZ,JA,JB,JC,JD,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR,AS,AT,AU,AV,AW,AX,AY,AZ,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,CA,CB,CC,CD,CE,CF,CG,CH,CI,CJ,CK,CL,CM,CN,CO,CP,CQ,CR,CS,CT,CU,CV,CW,CX,CY,CZ,DA,DB,DC,DD,DE,DF,DG,DH,DI,DJ,DK,DL,DM,DN,DO,DP,DQ,DR,DS,DT,DU,DV,DW,DX,DY,DZ,EA,EB,EC,ED,EE,EF,EG,EH,EI,EJ,EK,EL,EM,EN,EO,EP,EQ,ER,ES,ET,EU,EV,EW,EX,EY,EZ,FA,FB,FC,FD,FE,FF,FG,FH,FI,FJ,FK,FL,FM,FN,FO,FP,FQ,FR,FS,FT,FU,FV,FW,FX,FY,FZ,GA,GB,GC,GD,GE,GF,GG,GH,GI,GJ,GK,GL,GM,GN,GO,GP,GQ,GR,GS,GT,GU,GV,GW,GX,GY,GZ,HA,HB,IK,IL,IM,IN,IO,IP,IQ,IR,IS,IT,IU,IV,IW,A,C,E,G,I,U,V,W,X,AB,AC,AD,AG;O=$pkg.RangeTable=$newType(0,$kindStruct,"unicode.RangeTable",true,"unicode",true,function(R16_,R32_,LatinOffset_){this.$val=this;if(arguments.length===0){this.R16=IY.nil;this.R32=IZ.nil;this.LatinOffset=0;return;}this.R16=R16_;this.R32=R32_;this.LatinOffset=LatinOffset_;});P=$pkg.Range16=$newType(0,$kindStruct,"unicode.Range16",true,"unicode",true,function(Lo_,Hi_,Stride_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Stride=0;return;}this.Lo=Lo_;this.Hi=Hi_;this.Stride=Stride_;});Q=$pkg.Range32=$newType(0,$kindStruct,"unicode.Range32",true,"unicode",true,function(Lo_,Hi_,Stride_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Stride=0;return;}this.Lo=Lo_;this.Hi=Hi_;this.Stride=Stride_;});R=$pkg.CaseRange=$newType(0,$kindStruct,"unicode.CaseRange",true,"unicode",true,function(Lo_,Hi_,Delta_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Delta=IX.zero();return;}this.Lo=Lo_;this.Hi=Hi_;this.Delta=Delta_;});T=$pkg.d=$newType(12,$kindArray,"unicode.d",true,"unicode",false,null);AF=$pkg.foldPair=$newType(0,$kindStruct,"unicode.foldPair",true,"unicode",false,function(From_,To_){this.$val=this;if(arguments.length===0){this.From=0;this.To=0;return;}this.From=From_;this.To=To_;});IX=$arrayType($Int32,3);IY=$sliceType(P);IZ=$sliceType(Q);JA=$ptrType(O);JB=$sliceType(JA);JC=$sliceType(R);JD=$sliceType(AF);A=function(b,c,d){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;e=0;f=false;if(b<0||3<=b){g=65533;h=false;e=g;f=h;return[e,f];}i=0;j=d.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l]);if(((m.Lo>>0))<=c&&c<=((m.Hi>>0))){o=((n=m.Delta,((b<0||b>=n.length)?($throwRuntimeError("index out of range"),undefined):n[b])));if(o>1114111){p=((m.Lo>>0))+((((((c-((m.Lo>>0))>>0))&~1)>>0)|(((b&1)>>0))))>>0;q=true;e=p;f=q;return[e,f];}r=c+o>>0;s=true;e=r;f=s;return[e,f];}if(c<((m.Lo>>0))){j=l;}else{i=l+1>>0;}}t=c;u=false;e=t;f=u;return[e,f];};C=function(b){var b;if(b<=255){return 48<=b&&b<=57;}return X($pkg.Digit,b);};$pkg.IsDigit=C;E=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=IL.length)?($throwRuntimeError("index out of range"),undefined):IL[c]))&128)>>>0)===0));}return G(b,$pkg.PrintRanges);};$pkg.IsPrint=E;G=function(b,c){var b,c,d,e,f;d=c;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);if(W(f,b)){return true;}e++;}return false;};$pkg.In=G;I=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=IL.length)?($throwRuntimeError("index out of range"),undefined):IL[c]))&96)>>>0)===0));}return X($pkg.Letter,b);};$pkg.IsLetter=I;U=function(b,c){var b,c,d,e,f,g,h,i,j,k,l,m,n;if(b.$length<=18||c<=255){d=b;e=0;while(true){if(!(e=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f]);if(c>>16))%g.Stride,h===h?h:$throwRuntimeError("integer divide by zero"))===0);}e++;}return false;}i=0;j=b.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=((l<0||l>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+l]);if(m.Lo<=c&&c<=m.Hi){return(m.Stride===1)||((n=((c-m.Lo<<16>>>16))%m.Stride,n===n?n:$throwRuntimeError("integer divide by zero"))===0);}if(c>0;}}return false;};V=function(b,c){var b,c,d,e,f,g,h,i,j,k,l,m,n;if(b.$length<=18){d=b;e=0;while(true){if(!(e=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f]);if(c>>0))%g.Stride,h===h?h:$throwRuntimeError("integer divide by zero"))===0);}e++;}return false;}i=0;j=b.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=$clone(((l<0||l>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+l]),Q);if(m.Lo<=c&&c<=m.Hi){return(m.Stride===1)||((n=((c-m.Lo>>>0))%m.Stride,n===n?n:$throwRuntimeError("integer divide by zero"))===0);}if(c>0;}}return false;};W=function(b,c){var b,c,d,e,f;d=b.R16;if(d.$length>0&&c<=(((e=d.$length-1>>0,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e])).Hi>>0))){return U(d,((c<<16>>>16)));}f=b.R32;if(f.$length>0&&c>=(((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).Lo>>0))){return V(f,((c>>>0)));}return false;};$pkg.Is=W;X=function(b,c){var b,c,d,e,f,g;d=b.R16;e=b.LatinOffset;if(d.$length>e&&c<=(((f=d.$length-1>>0,((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])).Hi>>0))){return U($subslice(d,e),((c<<16>>>16)));}g=b.R32;if(g.$length>0&&c>=(((0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]).Lo>>0))){return V(g,((c>>>0)));}return false;};AB=function(b,c){var b,c,d;d=A(b,c,$pkg.CaseRanges);c=d[0];return c;};$pkg.To=AB;AC=function(b){var b;if(b<=127){if(97<=b&&b<=122){b=b-(32)>>0;}return b;}return AB(0,b);};$pkg.ToUpper=AC;AD=function(b){var b;if(b<=127){if(65<=b&&b<=90){b=b+(32)>>0;}return b;}return AB(1,b);};$pkg.ToLower=AD;AG=function(b){var b,c,d,e,f,g;if(b<0||b>1114111){return b;}if(((b>>0))<128){return((((b<0||b>=IM.length)?($throwRuntimeError("index out of range"),undefined):IM[b])>>0));}c=0;d=IN.$length;while(true){if(!(c>0))/2,(e===e&&e!==1/0&&e!==-1/0)?e>>0:$throwRuntimeError("integer divide by zero"))>>0;if(((((f<0||f>=IN.$length)?($throwRuntimeError("index out of range"),undefined):IN.$array[IN.$offset+f]).From>>0))>0;}else{d=f;}}if(c=IN.$length)?($throwRuntimeError("index out of range"),undefined):IN.$array[IN.$offset+c]).From>>0))===b)){return((((c<0||c>=IN.$length)?($throwRuntimeError("index out of range"),undefined):IN.$array[IN.$offset+c]).To>>0));}g=AD(b);if(!((g===b))){return g;}return AC(b);};$pkg.SimpleFold=AG;O.init("",[{prop:"R16",name:"R16",embedded:false,exported:true,typ:IY,tag:""},{prop:"R32",name:"R32",embedded:false,exported:true,typ:IZ,tag:""},{prop:"LatinOffset",name:"LatinOffset",embedded:false,exported:true,typ:$Int,tag:""}]);P.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Stride",name:"Stride",embedded:false,exported:true,typ:$Uint16,tag:""}]);Q.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Stride",name:"Stride",embedded:false,exported:true,typ:$Uint32,tag:""}]);R.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Delta",name:"Delta",embedded:false,exported:true,typ:T,tag:""}]);T.init($Int32,3);AF.init("",[{prop:"From",name:"From",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"To",name:"To",embedded:false,exported:true,typ:$Uint16,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:AH=new O.ptr(new IY([new P.ptr(0,31,1),new P.ptr(127,159,1),new P.ptr(173,1536,1363),new P.ptr(1537,1541,1),new P.ptr(1564,1757,193),new P.ptr(1807,2274,467),new P.ptr(6158,8203,2045),new P.ptr(8204,8207,1),new P.ptr(8234,8238,1),new P.ptr(8288,8292,1),new P.ptr(8294,8303,1),new P.ptr(55296,63743,1),new P.ptr(65279,65529,250),new P.ptr(65530,65531,1)]),new IZ([new Q.ptr(69821,113824,44003),new Q.ptr(113825,113827,1),new Q.ptr(119155,119162,1),new Q.ptr(917505,917536,31),new Q.ptr(917537,917631,1),new Q.ptr(983040,1048573,1),new Q.ptr(1048576,1114109,1)]),2);AI=new O.ptr(new IY([new P.ptr(0,31,1),new P.ptr(127,159,1)]),IZ.nil,2);AJ=new O.ptr(new IY([new P.ptr(173,1536,1363),new P.ptr(1537,1541,1),new P.ptr(1564,1757,193),new P.ptr(1807,2274,467),new P.ptr(6158,8203,2045),new P.ptr(8204,8207,1),new P.ptr(8234,8238,1),new P.ptr(8288,8292,1),new P.ptr(8294,8303,1),new P.ptr(65279,65529,250),new P.ptr(65530,65531,1)]),new IZ([new Q.ptr(69821,113824,44003),new Q.ptr(113825,113827,1),new Q.ptr(119155,119162,1),new Q.ptr(917505,917536,31),new Q.ptr(917537,917631,1)]),0);AK=new O.ptr(new IY([new P.ptr(57344,63743,1)]),new IZ([new Q.ptr(983040,1048573,1),new Q.ptr(1048576,1114109,1)]),0);AL=new O.ptr(new IY([new P.ptr(55296,57343,1)]),IZ.nil,0);AM=new O.ptr(new IY([new P.ptr(65,90,1),new P.ptr(97,122,1),new P.ptr(170,181,11),new P.ptr(186,192,6),new P.ptr(193,214,1),new P.ptr(216,246,1),new P.ptr(248,705,1),new P.ptr(710,721,1),new P.ptr(736,740,1),new P.ptr(748,750,2),new P.ptr(880,884,1),new P.ptr(886,887,1),new P.ptr(890,893,1),new P.ptr(895,902,7),new P.ptr(904,906,1),new P.ptr(908,910,2),new P.ptr(911,929,1),new P.ptr(931,1013,1),new P.ptr(1015,1153,1),new P.ptr(1162,1327,1),new P.ptr(1329,1366,1),new P.ptr(1369,1377,8),new P.ptr(1378,1415,1),new P.ptr(1488,1514,1),new P.ptr(1520,1522,1),new P.ptr(1568,1610,1),new P.ptr(1646,1647,1),new P.ptr(1649,1747,1),new P.ptr(1749,1765,16),new P.ptr(1766,1774,8),new P.ptr(1775,1786,11),new P.ptr(1787,1788,1),new P.ptr(1791,1808,17),new P.ptr(1810,1839,1),new P.ptr(1869,1957,1),new P.ptr(1969,1994,25),new P.ptr(1995,2026,1),new P.ptr(2036,2037,1),new P.ptr(2042,2048,6),new P.ptr(2049,2069,1),new P.ptr(2074,2084,10),new P.ptr(2088,2112,24),new P.ptr(2113,2136,1),new P.ptr(2144,2154,1),new P.ptr(2208,2228,1),new P.ptr(2230,2237,1),new P.ptr(2308,2361,1),new P.ptr(2365,2384,19),new P.ptr(2392,2401,1),new P.ptr(2417,2432,1),new P.ptr(2437,2444,1),new P.ptr(2447,2448,1),new P.ptr(2451,2472,1),new P.ptr(2474,2480,1),new P.ptr(2482,2486,4),new P.ptr(2487,2489,1),new P.ptr(2493,2510,17),new P.ptr(2524,2525,1),new P.ptr(2527,2529,1),new P.ptr(2544,2545,1),new P.ptr(2556,2565,9),new P.ptr(2566,2570,1),new P.ptr(2575,2576,1),new P.ptr(2579,2600,1),new P.ptr(2602,2608,1),new P.ptr(2610,2611,1),new P.ptr(2613,2614,1),new P.ptr(2616,2617,1),new P.ptr(2649,2652,1),new P.ptr(2654,2674,20),new P.ptr(2675,2676,1),new P.ptr(2693,2701,1),new P.ptr(2703,2705,1),new P.ptr(2707,2728,1),new P.ptr(2730,2736,1),new P.ptr(2738,2739,1),new P.ptr(2741,2745,1),new P.ptr(2749,2768,19),new P.ptr(2784,2785,1),new P.ptr(2809,2821,12),new P.ptr(2822,2828,1),new P.ptr(2831,2832,1),new P.ptr(2835,2856,1),new P.ptr(2858,2864,1),new P.ptr(2866,2867,1),new P.ptr(2869,2873,1),new P.ptr(2877,2908,31),new P.ptr(2909,2911,2),new P.ptr(2912,2913,1),new P.ptr(2929,2947,18),new P.ptr(2949,2954,1),new P.ptr(2958,2960,1),new P.ptr(2962,2965,1),new P.ptr(2969,2970,1),new P.ptr(2972,2974,2),new P.ptr(2975,2979,4),new P.ptr(2980,2984,4),new P.ptr(2985,2986,1),new P.ptr(2990,3001,1),new P.ptr(3024,3077,53),new P.ptr(3078,3084,1),new P.ptr(3086,3088,1),new P.ptr(3090,3112,1),new P.ptr(3114,3129,1),new P.ptr(3133,3160,27),new P.ptr(3161,3162,1),new P.ptr(3168,3169,1),new P.ptr(3200,3205,5),new P.ptr(3206,3212,1),new P.ptr(3214,3216,1),new P.ptr(3218,3240,1),new P.ptr(3242,3251,1),new P.ptr(3253,3257,1),new P.ptr(3261,3294,33),new P.ptr(3296,3297,1),new P.ptr(3313,3314,1),new P.ptr(3333,3340,1),new P.ptr(3342,3344,1),new P.ptr(3346,3386,1),new P.ptr(3389,3406,17),new P.ptr(3412,3414,1),new P.ptr(3423,3425,1),new P.ptr(3450,3455,1),new P.ptr(3461,3478,1),new P.ptr(3482,3505,1),new P.ptr(3507,3515,1),new P.ptr(3517,3520,3),new P.ptr(3521,3526,1),new P.ptr(3585,3632,1),new P.ptr(3634,3635,1),new P.ptr(3648,3654,1),new P.ptr(3713,3714,1),new P.ptr(3716,3719,3),new P.ptr(3720,3722,2),new P.ptr(3725,3732,7),new P.ptr(3733,3735,1),new P.ptr(3737,3743,1),new P.ptr(3745,3747,1),new P.ptr(3749,3751,2),new P.ptr(3754,3755,1),new P.ptr(3757,3760,1),new P.ptr(3762,3763,1),new P.ptr(3773,3776,3),new P.ptr(3777,3780,1),new P.ptr(3782,3804,22),new P.ptr(3805,3807,1),new P.ptr(3840,3904,64),new P.ptr(3905,3911,1),new P.ptr(3913,3948,1),new P.ptr(3976,3980,1),new P.ptr(4096,4138,1),new P.ptr(4159,4176,17),new P.ptr(4177,4181,1),new P.ptr(4186,4189,1),new P.ptr(4193,4197,4),new P.ptr(4198,4206,8),new P.ptr(4207,4208,1),new P.ptr(4213,4225,1),new P.ptr(4238,4256,18),new P.ptr(4257,4293,1),new P.ptr(4295,4301,6),new P.ptr(4304,4346,1),new P.ptr(4348,4680,1),new P.ptr(4682,4685,1),new P.ptr(4688,4694,1),new P.ptr(4696,4698,2),new P.ptr(4699,4701,1),new P.ptr(4704,4744,1),new P.ptr(4746,4749,1),new P.ptr(4752,4784,1),new P.ptr(4786,4789,1),new P.ptr(4792,4798,1),new P.ptr(4800,4802,2),new P.ptr(4803,4805,1),new P.ptr(4808,4822,1),new P.ptr(4824,4880,1),new P.ptr(4882,4885,1),new P.ptr(4888,4954,1),new P.ptr(4992,5007,1),new P.ptr(5024,5109,1),new P.ptr(5112,5117,1),new P.ptr(5121,5740,1),new P.ptr(5743,5759,1),new P.ptr(5761,5786,1),new P.ptr(5792,5866,1),new P.ptr(5873,5880,1),new P.ptr(5888,5900,1),new P.ptr(5902,5905,1),new P.ptr(5920,5937,1),new P.ptr(5952,5969,1),new P.ptr(5984,5996,1),new P.ptr(5998,6000,1),new P.ptr(6016,6067,1),new P.ptr(6103,6108,5),new P.ptr(6176,6263,1),new P.ptr(6272,6276,1),new P.ptr(6279,6312,1),new P.ptr(6314,6320,6),new P.ptr(6321,6389,1),new P.ptr(6400,6430,1),new P.ptr(6480,6509,1),new P.ptr(6512,6516,1),new P.ptr(6528,6571,1),new P.ptr(6576,6601,1),new P.ptr(6656,6678,1),new P.ptr(6688,6740,1),new P.ptr(6823,6917,94),new P.ptr(6918,6963,1),new P.ptr(6981,6987,1),new P.ptr(7043,7072,1),new P.ptr(7086,7087,1),new P.ptr(7098,7141,1),new P.ptr(7168,7203,1),new P.ptr(7245,7247,1),new P.ptr(7258,7293,1),new P.ptr(7296,7304,1),new P.ptr(7401,7404,1),new P.ptr(7406,7409,1),new P.ptr(7413,7414,1),new P.ptr(7424,7615,1),new P.ptr(7680,7957,1),new P.ptr(7960,7965,1),new P.ptr(7968,8005,1),new P.ptr(8008,8013,1),new P.ptr(8016,8023,1),new P.ptr(8025,8031,2),new P.ptr(8032,8061,1),new P.ptr(8064,8116,1),new P.ptr(8118,8124,1),new P.ptr(8126,8130,4),new P.ptr(8131,8132,1),new P.ptr(8134,8140,1),new P.ptr(8144,8147,1),new P.ptr(8150,8155,1),new P.ptr(8160,8172,1),new P.ptr(8178,8180,1),new P.ptr(8182,8188,1),new P.ptr(8305,8319,14),new P.ptr(8336,8348,1),new P.ptr(8450,8455,5),new P.ptr(8458,8467,1),new P.ptr(8469,8473,4),new P.ptr(8474,8477,1),new P.ptr(8484,8490,2),new P.ptr(8491,8493,1),new P.ptr(8495,8505,1),new P.ptr(8508,8511,1),new P.ptr(8517,8521,1),new P.ptr(8526,8579,53),new P.ptr(8580,11264,2684),new P.ptr(11265,11310,1),new P.ptr(11312,11358,1),new P.ptr(11360,11492,1),new P.ptr(11499,11502,1),new P.ptr(11506,11507,1),new P.ptr(11520,11557,1),new P.ptr(11559,11565,6),new P.ptr(11568,11623,1),new P.ptr(11631,11648,17),new P.ptr(11649,11670,1),new P.ptr(11680,11686,1),new P.ptr(11688,11694,1),new P.ptr(11696,11702,1),new P.ptr(11704,11710,1),new P.ptr(11712,11718,1),new P.ptr(11720,11726,1),new P.ptr(11728,11734,1),new P.ptr(11736,11742,1),new P.ptr(11823,12293,470),new P.ptr(12294,12337,43),new P.ptr(12338,12341,1),new P.ptr(12347,12348,1),new P.ptr(12353,12438,1),new P.ptr(12445,12447,1),new P.ptr(12449,12538,1),new P.ptr(12540,12543,1),new P.ptr(12549,12590,1),new P.ptr(12593,12686,1),new P.ptr(12704,12730,1),new P.ptr(12784,12799,1),new P.ptr(13312,19893,1),new P.ptr(19968,40938,1),new P.ptr(40960,42124,1),new P.ptr(42192,42237,1),new P.ptr(42240,42508,1),new P.ptr(42512,42527,1),new P.ptr(42538,42539,1),new P.ptr(42560,42606,1),new P.ptr(42623,42653,1),new P.ptr(42656,42725,1),new P.ptr(42775,42783,1),new P.ptr(42786,42888,1),new P.ptr(42891,42926,1),new P.ptr(42928,42935,1),new P.ptr(42999,43009,1),new P.ptr(43011,43013,1),new P.ptr(43015,43018,1),new P.ptr(43020,43042,1),new P.ptr(43072,43123,1),new P.ptr(43138,43187,1),new P.ptr(43250,43255,1),new P.ptr(43259,43261,2),new P.ptr(43274,43301,1),new P.ptr(43312,43334,1),new P.ptr(43360,43388,1),new P.ptr(43396,43442,1),new P.ptr(43471,43488,17),new P.ptr(43489,43492,1),new P.ptr(43494,43503,1),new P.ptr(43514,43518,1),new P.ptr(43520,43560,1),new P.ptr(43584,43586,1),new P.ptr(43588,43595,1),new P.ptr(43616,43638,1),new P.ptr(43642,43646,4),new P.ptr(43647,43695,1),new P.ptr(43697,43701,4),new P.ptr(43702,43705,3),new P.ptr(43706,43709,1),new P.ptr(43712,43714,2),new P.ptr(43739,43741,1),new P.ptr(43744,43754,1),new P.ptr(43762,43764,1),new P.ptr(43777,43782,1),new P.ptr(43785,43790,1),new P.ptr(43793,43798,1),new P.ptr(43808,43814,1),new P.ptr(43816,43822,1),new P.ptr(43824,43866,1),new P.ptr(43868,43877,1),new P.ptr(43888,44002,1),new P.ptr(44032,55203,1),new P.ptr(55216,55238,1),new P.ptr(55243,55291,1),new P.ptr(63744,64109,1),new P.ptr(64112,64217,1),new P.ptr(64256,64262,1),new P.ptr(64275,64279,1),new P.ptr(64285,64287,2),new P.ptr(64288,64296,1),new P.ptr(64298,64310,1),new P.ptr(64312,64316,1),new P.ptr(64318,64320,2),new P.ptr(64321,64323,2),new P.ptr(64324,64326,2),new P.ptr(64327,64433,1),new P.ptr(64467,64829,1),new P.ptr(64848,64911,1),new P.ptr(64914,64967,1),new P.ptr(65008,65019,1),new P.ptr(65136,65140,1),new P.ptr(65142,65276,1),new P.ptr(65313,65338,1),new P.ptr(65345,65370,1),new P.ptr(65382,65470,1),new P.ptr(65474,65479,1),new P.ptr(65482,65487,1),new P.ptr(65490,65495,1),new P.ptr(65498,65500,1)]),new IZ([new Q.ptr(65536,65547,1),new Q.ptr(65549,65574,1),new Q.ptr(65576,65594,1),new Q.ptr(65596,65597,1),new Q.ptr(65599,65613,1),new Q.ptr(65616,65629,1),new Q.ptr(65664,65786,1),new Q.ptr(66176,66204,1),new Q.ptr(66208,66256,1),new Q.ptr(66304,66335,1),new Q.ptr(66349,66368,1),new Q.ptr(66370,66377,1),new Q.ptr(66384,66421,1),new Q.ptr(66432,66461,1),new Q.ptr(66464,66499,1),new Q.ptr(66504,66511,1),new Q.ptr(66560,66717,1),new Q.ptr(66736,66771,1),new Q.ptr(66776,66811,1),new Q.ptr(66816,66855,1),new Q.ptr(66864,66915,1),new Q.ptr(67072,67382,1),new Q.ptr(67392,67413,1),new Q.ptr(67424,67431,1),new Q.ptr(67584,67589,1),new Q.ptr(67592,67594,2),new Q.ptr(67595,67637,1),new Q.ptr(67639,67640,1),new Q.ptr(67644,67647,3),new Q.ptr(67648,67669,1),new Q.ptr(67680,67702,1),new Q.ptr(67712,67742,1),new Q.ptr(67808,67826,1),new Q.ptr(67828,67829,1),new Q.ptr(67840,67861,1),new Q.ptr(67872,67897,1),new Q.ptr(67968,68023,1),new Q.ptr(68030,68031,1),new Q.ptr(68096,68112,16),new Q.ptr(68113,68115,1),new Q.ptr(68117,68119,1),new Q.ptr(68121,68147,1),new Q.ptr(68192,68220,1),new Q.ptr(68224,68252,1),new Q.ptr(68288,68295,1),new Q.ptr(68297,68324,1),new Q.ptr(68352,68405,1),new Q.ptr(68416,68437,1),new Q.ptr(68448,68466,1),new Q.ptr(68480,68497,1),new Q.ptr(68608,68680,1),new Q.ptr(68736,68786,1),new Q.ptr(68800,68850,1),new Q.ptr(69635,69687,1),new Q.ptr(69763,69807,1),new Q.ptr(69840,69864,1),new Q.ptr(69891,69926,1),new Q.ptr(69968,70002,1),new Q.ptr(70006,70019,13),new Q.ptr(70020,70066,1),new Q.ptr(70081,70084,1),new Q.ptr(70106,70108,2),new Q.ptr(70144,70161,1),new Q.ptr(70163,70187,1),new Q.ptr(70272,70278,1),new Q.ptr(70280,70282,2),new Q.ptr(70283,70285,1),new Q.ptr(70287,70301,1),new Q.ptr(70303,70312,1),new Q.ptr(70320,70366,1),new Q.ptr(70405,70412,1),new Q.ptr(70415,70416,1),new Q.ptr(70419,70440,1),new Q.ptr(70442,70448,1),new Q.ptr(70450,70451,1),new Q.ptr(70453,70457,1),new Q.ptr(70461,70480,19),new Q.ptr(70493,70497,1),new Q.ptr(70656,70708,1),new Q.ptr(70727,70730,1),new Q.ptr(70784,70831,1),new Q.ptr(70852,70853,1),new Q.ptr(70855,71040,185),new Q.ptr(71041,71086,1),new Q.ptr(71128,71131,1),new Q.ptr(71168,71215,1),new Q.ptr(71236,71296,60),new Q.ptr(71297,71338,1),new Q.ptr(71424,71449,1),new Q.ptr(71840,71903,1),new Q.ptr(71935,72192,257),new Q.ptr(72203,72242,1),new Q.ptr(72250,72272,22),new Q.ptr(72284,72323,1),new Q.ptr(72326,72329,1),new Q.ptr(72384,72440,1),new Q.ptr(72704,72712,1),new Q.ptr(72714,72750,1),new Q.ptr(72768,72818,50),new Q.ptr(72819,72847,1),new Q.ptr(72960,72966,1),new Q.ptr(72968,72969,1),new Q.ptr(72971,73008,1),new Q.ptr(73030,73728,698),new Q.ptr(73729,74649,1),new Q.ptr(74880,75075,1),new Q.ptr(77824,78894,1),new Q.ptr(82944,83526,1),new Q.ptr(92160,92728,1),new Q.ptr(92736,92766,1),new Q.ptr(92880,92909,1),new Q.ptr(92928,92975,1),new Q.ptr(92992,92995,1),new Q.ptr(93027,93047,1),new Q.ptr(93053,93071,1),new Q.ptr(93952,94020,1),new Q.ptr(94032,94099,67),new Q.ptr(94100,94111,1),new Q.ptr(94176,94177,1),new Q.ptr(94208,100332,1),new Q.ptr(100352,101106,1),new Q.ptr(110592,110878,1),new Q.ptr(110960,111355,1),new Q.ptr(113664,113770,1),new Q.ptr(113776,113788,1),new Q.ptr(113792,113800,1),new Q.ptr(113808,113817,1),new Q.ptr(119808,119892,1),new Q.ptr(119894,119964,1),new Q.ptr(119966,119967,1),new Q.ptr(119970,119973,3),new Q.ptr(119974,119977,3),new Q.ptr(119978,119980,1),new Q.ptr(119982,119993,1),new Q.ptr(119995,119997,2),new Q.ptr(119998,120003,1),new Q.ptr(120005,120069,1),new Q.ptr(120071,120074,1),new Q.ptr(120077,120084,1),new Q.ptr(120086,120092,1),new Q.ptr(120094,120121,1),new Q.ptr(120123,120126,1),new Q.ptr(120128,120132,1),new Q.ptr(120134,120138,4),new Q.ptr(120139,120144,1),new Q.ptr(120146,120485,1),new Q.ptr(120488,120512,1),new Q.ptr(120514,120538,1),new Q.ptr(120540,120570,1),new Q.ptr(120572,120596,1),new Q.ptr(120598,120628,1),new Q.ptr(120630,120654,1),new Q.ptr(120656,120686,1),new Q.ptr(120688,120712,1),new Q.ptr(120714,120744,1),new Q.ptr(120746,120770,1),new Q.ptr(120772,120779,1),new Q.ptr(124928,125124,1),new Q.ptr(125184,125251,1),new Q.ptr(126464,126467,1),new Q.ptr(126469,126495,1),new Q.ptr(126497,126498,1),new Q.ptr(126500,126503,3),new Q.ptr(126505,126514,1),new Q.ptr(126516,126519,1),new Q.ptr(126521,126523,2),new Q.ptr(126530,126535,5),new Q.ptr(126537,126541,2),new Q.ptr(126542,126543,1),new Q.ptr(126545,126546,1),new Q.ptr(126548,126551,3),new Q.ptr(126553,126561,2),new Q.ptr(126562,126564,2),new Q.ptr(126567,126570,1),new Q.ptr(126572,126578,1),new Q.ptr(126580,126583,1),new Q.ptr(126585,126588,1),new Q.ptr(126590,126592,2),new Q.ptr(126593,126601,1),new Q.ptr(126603,126619,1),new Q.ptr(126625,126627,1),new Q.ptr(126629,126633,1),new Q.ptr(126635,126651,1),new Q.ptr(131072,173782,1),new Q.ptr(173824,177972,1),new Q.ptr(177984,178205,1),new Q.ptr(178208,183969,1),new Q.ptr(183984,191456,1),new Q.ptr(194560,195101,1)]),6);AN=new O.ptr(new IY([new P.ptr(97,122,1),new P.ptr(181,223,42),new P.ptr(224,246,1),new P.ptr(248,255,1),new P.ptr(257,311,2),new P.ptr(312,328,2),new P.ptr(329,375,2),new P.ptr(378,382,2),new P.ptr(383,384,1),new P.ptr(387,389,2),new P.ptr(392,396,4),new P.ptr(397,402,5),new P.ptr(405,409,4),new P.ptr(410,411,1),new P.ptr(414,417,3),new P.ptr(419,421,2),new P.ptr(424,426,2),new P.ptr(427,429,2),new P.ptr(432,436,4),new P.ptr(438,441,3),new P.ptr(442,445,3),new P.ptr(446,447,1),new P.ptr(454,460,3),new P.ptr(462,476,2),new P.ptr(477,495,2),new P.ptr(496,499,3),new P.ptr(501,505,4),new P.ptr(507,563,2),new P.ptr(564,569,1),new P.ptr(572,575,3),new P.ptr(576,578,2),new P.ptr(583,591,2),new P.ptr(592,659,1),new P.ptr(661,687,1),new P.ptr(881,883,2),new P.ptr(887,891,4),new P.ptr(892,893,1),new P.ptr(912,940,28),new P.ptr(941,974,1),new P.ptr(976,977,1),new P.ptr(981,983,1),new P.ptr(985,1007,2),new P.ptr(1008,1011,1),new P.ptr(1013,1019,3),new P.ptr(1020,1072,52),new P.ptr(1073,1119,1),new P.ptr(1121,1153,2),new P.ptr(1163,1215,2),new P.ptr(1218,1230,2),new P.ptr(1231,1327,2),new P.ptr(1377,1415,1),new P.ptr(5112,5117,1),new P.ptr(7296,7304,1),new P.ptr(7424,7467,1),new P.ptr(7531,7543,1),new P.ptr(7545,7578,1),new P.ptr(7681,7829,2),new P.ptr(7830,7837,1),new P.ptr(7839,7935,2),new P.ptr(7936,7943,1),new P.ptr(7952,7957,1),new P.ptr(7968,7975,1),new P.ptr(7984,7991,1),new P.ptr(8000,8005,1),new P.ptr(8016,8023,1),new P.ptr(8032,8039,1),new P.ptr(8048,8061,1),new P.ptr(8064,8071,1),new P.ptr(8080,8087,1),new P.ptr(8096,8103,1),new P.ptr(8112,8116,1),new P.ptr(8118,8119,1),new P.ptr(8126,8130,4),new P.ptr(8131,8132,1),new P.ptr(8134,8135,1),new P.ptr(8144,8147,1),new P.ptr(8150,8151,1),new P.ptr(8160,8167,1),new P.ptr(8178,8180,1),new P.ptr(8182,8183,1),new P.ptr(8458,8462,4),new P.ptr(8463,8467,4),new P.ptr(8495,8505,5),new P.ptr(8508,8509,1),new P.ptr(8518,8521,1),new P.ptr(8526,8580,54),new P.ptr(11312,11358,1),new P.ptr(11361,11365,4),new P.ptr(11366,11372,2),new P.ptr(11377,11379,2),new P.ptr(11380,11382,2),new P.ptr(11383,11387,1),new P.ptr(11393,11491,2),new P.ptr(11492,11500,8),new P.ptr(11502,11507,5),new P.ptr(11520,11557,1),new P.ptr(11559,11565,6),new P.ptr(42561,42605,2),new P.ptr(42625,42651,2),new P.ptr(42787,42799,2),new P.ptr(42800,42801,1),new P.ptr(42803,42865,2),new P.ptr(42866,42872,1),new P.ptr(42874,42876,2),new P.ptr(42879,42887,2),new P.ptr(42892,42894,2),new P.ptr(42897,42899,2),new P.ptr(42900,42901,1),new P.ptr(42903,42921,2),new P.ptr(42933,42935,2),new P.ptr(43002,43824,822),new P.ptr(43825,43866,1),new P.ptr(43872,43877,1),new P.ptr(43888,43967,1),new P.ptr(64256,64262,1),new P.ptr(64275,64279,1),new P.ptr(65345,65370,1)]),new IZ([new Q.ptr(66600,66639,1),new Q.ptr(66776,66811,1),new Q.ptr(68800,68850,1),new Q.ptr(71872,71903,1),new Q.ptr(119834,119859,1),new Q.ptr(119886,119892,1),new Q.ptr(119894,119911,1),new Q.ptr(119938,119963,1),new Q.ptr(119990,119993,1),new Q.ptr(119995,119997,2),new Q.ptr(119998,120003,1),new Q.ptr(120005,120015,1),new Q.ptr(120042,120067,1),new Q.ptr(120094,120119,1),new Q.ptr(120146,120171,1),new Q.ptr(120198,120223,1),new Q.ptr(120250,120275,1),new Q.ptr(120302,120327,1),new Q.ptr(120354,120379,1),new Q.ptr(120406,120431,1),new Q.ptr(120458,120485,1),new Q.ptr(120514,120538,1),new Q.ptr(120540,120545,1),new Q.ptr(120572,120596,1),new Q.ptr(120598,120603,1),new Q.ptr(120630,120654,1),new Q.ptr(120656,120661,1),new Q.ptr(120688,120712,1),new Q.ptr(120714,120719,1),new Q.ptr(120746,120770,1),new Q.ptr(120772,120777,1),new Q.ptr(120779,125218,4439),new Q.ptr(125219,125251,1)]),4);AO=new O.ptr(new IY([new P.ptr(688,705,1),new P.ptr(710,721,1),new P.ptr(736,740,1),new P.ptr(748,750,2),new P.ptr(884,890,6),new P.ptr(1369,1600,231),new P.ptr(1765,1766,1),new P.ptr(2036,2037,1),new P.ptr(2042,2074,32),new P.ptr(2084,2088,4),new P.ptr(2417,3654,1237),new P.ptr(3782,4348,566),new P.ptr(6103,6211,108),new P.ptr(6823,7288,465),new P.ptr(7289,7293,1),new P.ptr(7468,7530,1),new P.ptr(7544,7579,35),new P.ptr(7580,7615,1),new P.ptr(8305,8319,14),new P.ptr(8336,8348,1),new P.ptr(11388,11389,1),new P.ptr(11631,11823,192),new P.ptr(12293,12337,44),new P.ptr(12338,12341,1),new P.ptr(12347,12445,98),new P.ptr(12446,12540,94),new P.ptr(12541,12542,1),new P.ptr(40981,42232,1251),new P.ptr(42233,42237,1),new P.ptr(42508,42623,115),new P.ptr(42652,42653,1),new P.ptr(42775,42783,1),new P.ptr(42864,42888,24),new P.ptr(43000,43001,1),new P.ptr(43471,43494,23),new P.ptr(43632,43741,109),new P.ptr(43763,43764,1),new P.ptr(43868,43871,1),new P.ptr(65392,65438,46),new P.ptr(65439,65439,1)]),new IZ([new Q.ptr(92992,92992,1),new Q.ptr(92993,92995,1),new Q.ptr(94099,94111,1),new Q.ptr(94176,94177,1)]),0);AP=new O.ptr(new IY([new P.ptr(170,186,16),new P.ptr(443,448,5),new P.ptr(449,451,1),new P.ptr(660,1488,828),new P.ptr(1489,1514,1),new P.ptr(1520,1522,1),new P.ptr(1568,1599,1),new P.ptr(1601,1610,1),new P.ptr(1646,1647,1),new P.ptr(1649,1747,1),new P.ptr(1749,1774,25),new P.ptr(1775,1786,11),new P.ptr(1787,1788,1),new P.ptr(1791,1808,17),new P.ptr(1810,1839,1),new P.ptr(1869,1957,1),new P.ptr(1969,1994,25),new P.ptr(1995,2026,1),new P.ptr(2048,2069,1),new P.ptr(2112,2136,1),new P.ptr(2144,2154,1),new P.ptr(2208,2228,1),new P.ptr(2230,2237,1),new P.ptr(2308,2361,1),new P.ptr(2365,2384,19),new P.ptr(2392,2401,1),new P.ptr(2418,2432,1),new P.ptr(2437,2444,1),new P.ptr(2447,2448,1),new P.ptr(2451,2472,1),new P.ptr(2474,2480,1),new P.ptr(2482,2486,4),new P.ptr(2487,2489,1),new P.ptr(2493,2510,17),new P.ptr(2524,2525,1),new P.ptr(2527,2529,1),new P.ptr(2544,2545,1),new P.ptr(2556,2565,9),new P.ptr(2566,2570,1),new P.ptr(2575,2576,1),new P.ptr(2579,2600,1),new P.ptr(2602,2608,1),new P.ptr(2610,2611,1),new P.ptr(2613,2614,1),new P.ptr(2616,2617,1),new P.ptr(2649,2652,1),new P.ptr(2654,2674,20),new P.ptr(2675,2676,1),new P.ptr(2693,2701,1),new P.ptr(2703,2705,1),new P.ptr(2707,2728,1),new P.ptr(2730,2736,1),new P.ptr(2738,2739,1),new P.ptr(2741,2745,1),new P.ptr(2749,2768,19),new P.ptr(2784,2785,1),new P.ptr(2809,2821,12),new P.ptr(2822,2828,1),new P.ptr(2831,2832,1),new P.ptr(2835,2856,1),new P.ptr(2858,2864,1),new P.ptr(2866,2867,1),new P.ptr(2869,2873,1),new P.ptr(2877,2908,31),new P.ptr(2909,2911,2),new P.ptr(2912,2913,1),new P.ptr(2929,2947,18),new P.ptr(2949,2954,1),new P.ptr(2958,2960,1),new P.ptr(2962,2965,1),new P.ptr(2969,2970,1),new P.ptr(2972,2974,2),new P.ptr(2975,2979,4),new P.ptr(2980,2984,4),new P.ptr(2985,2986,1),new P.ptr(2990,3001,1),new P.ptr(3024,3077,53),new P.ptr(3078,3084,1),new P.ptr(3086,3088,1),new P.ptr(3090,3112,1),new P.ptr(3114,3129,1),new P.ptr(3133,3160,27),new P.ptr(3161,3162,1),new P.ptr(3168,3169,1),new P.ptr(3200,3205,5),new P.ptr(3206,3212,1),new P.ptr(3214,3216,1),new P.ptr(3218,3240,1),new P.ptr(3242,3251,1),new P.ptr(3253,3257,1),new P.ptr(3261,3294,33),new P.ptr(3296,3297,1),new P.ptr(3313,3314,1),new P.ptr(3333,3340,1),new P.ptr(3342,3344,1),new P.ptr(3346,3386,1),new P.ptr(3389,3406,17),new P.ptr(3412,3414,1),new P.ptr(3423,3425,1),new P.ptr(3450,3455,1),new P.ptr(3461,3478,1),new P.ptr(3482,3505,1),new P.ptr(3507,3515,1),new P.ptr(3517,3520,3),new P.ptr(3521,3526,1),new P.ptr(3585,3632,1),new P.ptr(3634,3635,1),new P.ptr(3648,3653,1),new P.ptr(3713,3714,1),new P.ptr(3716,3719,3),new P.ptr(3720,3722,2),new P.ptr(3725,3732,7),new P.ptr(3733,3735,1),new P.ptr(3737,3743,1),new P.ptr(3745,3747,1),new P.ptr(3749,3751,2),new P.ptr(3754,3755,1),new P.ptr(3757,3760,1),new P.ptr(3762,3763,1),new P.ptr(3773,3776,3),new P.ptr(3777,3780,1),new P.ptr(3804,3807,1),new P.ptr(3840,3904,64),new P.ptr(3905,3911,1),new P.ptr(3913,3948,1),new P.ptr(3976,3980,1),new P.ptr(4096,4138,1),new P.ptr(4159,4176,17),new P.ptr(4177,4181,1),new P.ptr(4186,4189,1),new P.ptr(4193,4197,4),new P.ptr(4198,4206,8),new P.ptr(4207,4208,1),new P.ptr(4213,4225,1),new P.ptr(4238,4304,66),new P.ptr(4305,4346,1),new P.ptr(4349,4680,1),new P.ptr(4682,4685,1),new P.ptr(4688,4694,1),new P.ptr(4696,4698,2),new P.ptr(4699,4701,1),new P.ptr(4704,4744,1),new P.ptr(4746,4749,1),new P.ptr(4752,4784,1),new P.ptr(4786,4789,1),new P.ptr(4792,4798,1),new P.ptr(4800,4802,2),new P.ptr(4803,4805,1),new P.ptr(4808,4822,1),new P.ptr(4824,4880,1),new P.ptr(4882,4885,1),new P.ptr(4888,4954,1),new P.ptr(4992,5007,1),new P.ptr(5121,5740,1),new P.ptr(5743,5759,1),new P.ptr(5761,5786,1),new P.ptr(5792,5866,1),new P.ptr(5873,5880,1),new P.ptr(5888,5900,1),new P.ptr(5902,5905,1),new P.ptr(5920,5937,1),new P.ptr(5952,5969,1),new P.ptr(5984,5996,1),new P.ptr(5998,6000,1),new P.ptr(6016,6067,1),new P.ptr(6108,6176,68),new P.ptr(6177,6210,1),new P.ptr(6212,6263,1),new P.ptr(6272,6276,1),new P.ptr(6279,6312,1),new P.ptr(6314,6320,6),new P.ptr(6321,6389,1),new P.ptr(6400,6430,1),new P.ptr(6480,6509,1),new P.ptr(6512,6516,1),new P.ptr(6528,6571,1),new P.ptr(6576,6601,1),new P.ptr(6656,6678,1),new P.ptr(6688,6740,1),new P.ptr(6917,6963,1),new P.ptr(6981,6987,1),new P.ptr(7043,7072,1),new P.ptr(7086,7087,1),new P.ptr(7098,7141,1),new P.ptr(7168,7203,1),new P.ptr(7245,7247,1),new P.ptr(7258,7287,1),new P.ptr(7401,7404,1),new P.ptr(7406,7409,1),new P.ptr(7413,7414,1),new P.ptr(8501,8504,1),new P.ptr(11568,11623,1),new P.ptr(11648,11670,1),new P.ptr(11680,11686,1),new P.ptr(11688,11694,1),new P.ptr(11696,11702,1),new P.ptr(11704,11710,1),new P.ptr(11712,11718,1),new P.ptr(11720,11726,1),new P.ptr(11728,11734,1),new P.ptr(11736,11742,1),new P.ptr(12294,12348,54),new P.ptr(12353,12438,1),new P.ptr(12447,12449,2),new P.ptr(12450,12538,1),new P.ptr(12543,12549,6),new P.ptr(12550,12590,1),new P.ptr(12593,12686,1),new P.ptr(12704,12730,1),new P.ptr(12784,12799,1),new P.ptr(13312,19893,1),new P.ptr(19968,40938,1),new P.ptr(40960,40980,1),new P.ptr(40982,42124,1),new P.ptr(42192,42231,1),new P.ptr(42240,42507,1),new P.ptr(42512,42527,1),new P.ptr(42538,42539,1),new P.ptr(42606,42656,50),new P.ptr(42657,42725,1),new P.ptr(42895,42999,104),new P.ptr(43003,43009,1),new P.ptr(43011,43013,1),new P.ptr(43015,43018,1),new P.ptr(43020,43042,1),new P.ptr(43072,43123,1),new P.ptr(43138,43187,1),new P.ptr(43250,43255,1),new P.ptr(43259,43261,2),new P.ptr(43274,43301,1),new P.ptr(43312,43334,1),new P.ptr(43360,43388,1),new P.ptr(43396,43442,1),new P.ptr(43488,43492,1),new P.ptr(43495,43503,1),new P.ptr(43514,43518,1),new P.ptr(43520,43560,1),new P.ptr(43584,43586,1),new P.ptr(43588,43595,1),new P.ptr(43616,43631,1),new P.ptr(43633,43638,1),new P.ptr(43642,43646,4),new P.ptr(43647,43695,1),new P.ptr(43697,43701,4),new P.ptr(43702,43705,3),new P.ptr(43706,43709,1),new P.ptr(43712,43714,2),new P.ptr(43739,43740,1),new P.ptr(43744,43754,1),new P.ptr(43762,43777,15),new P.ptr(43778,43782,1),new P.ptr(43785,43790,1),new P.ptr(43793,43798,1),new P.ptr(43808,43814,1),new P.ptr(43816,43822,1),new P.ptr(43968,44002,1),new P.ptr(44032,55203,1),new P.ptr(55216,55238,1),new P.ptr(55243,55291,1),new P.ptr(63744,64109,1),new P.ptr(64112,64217,1),new P.ptr(64285,64287,2),new P.ptr(64288,64296,1),new P.ptr(64298,64310,1),new P.ptr(64312,64316,1),new P.ptr(64318,64320,2),new P.ptr(64321,64323,2),new P.ptr(64324,64326,2),new P.ptr(64327,64433,1),new P.ptr(64467,64829,1),new P.ptr(64848,64911,1),new P.ptr(64914,64967,1),new P.ptr(65008,65019,1),new P.ptr(65136,65140,1),new P.ptr(65142,65276,1),new P.ptr(65382,65391,1),new P.ptr(65393,65437,1),new P.ptr(65440,65470,1),new P.ptr(65474,65479,1),new P.ptr(65482,65487,1),new P.ptr(65490,65495,1),new P.ptr(65498,65500,1)]),new IZ([new Q.ptr(65536,65547,1),new Q.ptr(65549,65574,1),new Q.ptr(65576,65594,1),new Q.ptr(65596,65597,1),new Q.ptr(65599,65613,1),new Q.ptr(65616,65629,1),new Q.ptr(65664,65786,1),new Q.ptr(66176,66204,1),new Q.ptr(66208,66256,1),new Q.ptr(66304,66335,1),new Q.ptr(66349,66368,1),new Q.ptr(66370,66377,1),new Q.ptr(66384,66421,1),new Q.ptr(66432,66461,1),new Q.ptr(66464,66499,1),new Q.ptr(66504,66511,1),new Q.ptr(66640,66717,1),new Q.ptr(66816,66855,1),new Q.ptr(66864,66915,1),new Q.ptr(67072,67382,1),new Q.ptr(67392,67413,1),new Q.ptr(67424,67431,1),new Q.ptr(67584,67589,1),new Q.ptr(67592,67594,2),new Q.ptr(67595,67637,1),new Q.ptr(67639,67640,1),new Q.ptr(67644,67647,3),new Q.ptr(67648,67669,1),new Q.ptr(67680,67702,1),new Q.ptr(67712,67742,1),new Q.ptr(67808,67826,1),new Q.ptr(67828,67829,1),new Q.ptr(67840,67861,1),new Q.ptr(67872,67897,1),new Q.ptr(67968,68023,1),new Q.ptr(68030,68031,1),new Q.ptr(68096,68112,16),new Q.ptr(68113,68115,1),new Q.ptr(68117,68119,1),new Q.ptr(68121,68147,1),new Q.ptr(68192,68220,1),new Q.ptr(68224,68252,1),new Q.ptr(68288,68295,1),new Q.ptr(68297,68324,1),new Q.ptr(68352,68405,1),new Q.ptr(68416,68437,1),new Q.ptr(68448,68466,1),new Q.ptr(68480,68497,1),new Q.ptr(68608,68680,1),new Q.ptr(69635,69687,1),new Q.ptr(69763,69807,1),new Q.ptr(69840,69864,1),new Q.ptr(69891,69926,1),new Q.ptr(69968,70002,1),new Q.ptr(70006,70019,13),new Q.ptr(70020,70066,1),new Q.ptr(70081,70084,1),new Q.ptr(70106,70108,2),new Q.ptr(70144,70161,1),new Q.ptr(70163,70187,1),new Q.ptr(70272,70278,1),new Q.ptr(70280,70282,2),new Q.ptr(70283,70285,1),new Q.ptr(70287,70301,1),new Q.ptr(70303,70312,1),new Q.ptr(70320,70366,1),new Q.ptr(70405,70412,1),new Q.ptr(70415,70416,1),new Q.ptr(70419,70440,1),new Q.ptr(70442,70448,1),new Q.ptr(70450,70451,1),new Q.ptr(70453,70457,1),new Q.ptr(70461,70480,19),new Q.ptr(70493,70497,1),new Q.ptr(70656,70708,1),new Q.ptr(70727,70730,1),new Q.ptr(70784,70831,1),new Q.ptr(70852,70853,1),new Q.ptr(70855,71040,185),new Q.ptr(71041,71086,1),new Q.ptr(71128,71131,1),new Q.ptr(71168,71215,1),new Q.ptr(71236,71296,60),new Q.ptr(71297,71338,1),new Q.ptr(71424,71449,1),new Q.ptr(71935,72192,257),new Q.ptr(72203,72242,1),new Q.ptr(72250,72272,22),new Q.ptr(72284,72323,1),new Q.ptr(72326,72329,1),new Q.ptr(72384,72440,1),new Q.ptr(72704,72712,1),new Q.ptr(72714,72750,1),new Q.ptr(72768,72818,50),new Q.ptr(72819,72847,1),new Q.ptr(72960,72966,1),new Q.ptr(72968,72969,1),new Q.ptr(72971,73008,1),new Q.ptr(73030,73728,698),new Q.ptr(73729,74649,1),new Q.ptr(74880,75075,1),new Q.ptr(77824,78894,1),new Q.ptr(82944,83526,1),new Q.ptr(92160,92728,1),new Q.ptr(92736,92766,1),new Q.ptr(92880,92909,1),new Q.ptr(92928,92975,1),new Q.ptr(93027,93047,1),new Q.ptr(93053,93071,1),new Q.ptr(93952,94020,1),new Q.ptr(94032,94208,176),new Q.ptr(94209,100332,1),new Q.ptr(100352,101106,1),new Q.ptr(110592,110878,1),new Q.ptr(110960,111355,1),new Q.ptr(113664,113770,1),new Q.ptr(113776,113788,1),new Q.ptr(113792,113800,1),new Q.ptr(113808,113817,1),new Q.ptr(124928,125124,1),new Q.ptr(126464,126467,1),new Q.ptr(126469,126495,1),new Q.ptr(126497,126498,1),new Q.ptr(126500,126503,3),new Q.ptr(126505,126514,1),new Q.ptr(126516,126519,1),new Q.ptr(126521,126523,2),new Q.ptr(126530,126535,5),new Q.ptr(126537,126541,2),new Q.ptr(126542,126543,1),new Q.ptr(126545,126546,1),new Q.ptr(126548,126551,3),new Q.ptr(126553,126561,2),new Q.ptr(126562,126564,2),new Q.ptr(126567,126570,1),new Q.ptr(126572,126578,1),new Q.ptr(126580,126583,1),new Q.ptr(126585,126588,1),new Q.ptr(126590,126592,2),new Q.ptr(126593,126601,1),new Q.ptr(126603,126619,1),new Q.ptr(126625,126627,1),new Q.ptr(126629,126633,1),new Q.ptr(126635,126651,1),new Q.ptr(131072,173782,1),new Q.ptr(173824,177972,1),new Q.ptr(177984,178205,1),new Q.ptr(178208,183969,1),new Q.ptr(183984,191456,1),new Q.ptr(194560,195101,1)]),1);AQ=new O.ptr(new IY([new P.ptr(453,459,3),new P.ptr(498,8072,7574),new P.ptr(8073,8079,1),new P.ptr(8088,8095,1),new P.ptr(8104,8111,1),new P.ptr(8124,8140,16),new P.ptr(8188,8188,1)]),IZ.nil,0);AR=new O.ptr(new IY([new P.ptr(65,90,1),new P.ptr(192,214,1),new P.ptr(216,222,1),new P.ptr(256,310,2),new P.ptr(313,327,2),new P.ptr(330,376,2),new P.ptr(377,381,2),new P.ptr(385,386,1),new P.ptr(388,390,2),new P.ptr(391,393,2),new P.ptr(394,395,1),new P.ptr(398,401,1),new P.ptr(403,404,1),new P.ptr(406,408,1),new P.ptr(412,413,1),new P.ptr(415,416,1),new P.ptr(418,422,2),new P.ptr(423,425,2),new P.ptr(428,430,2),new P.ptr(431,433,2),new P.ptr(434,435,1),new P.ptr(437,439,2),new P.ptr(440,444,4),new P.ptr(452,461,3),new P.ptr(463,475,2),new P.ptr(478,494,2),new P.ptr(497,500,3),new P.ptr(502,504,1),new P.ptr(506,562,2),new P.ptr(570,571,1),new P.ptr(573,574,1),new P.ptr(577,579,2),new P.ptr(580,582,1),new P.ptr(584,590,2),new P.ptr(880,882,2),new P.ptr(886,895,9),new P.ptr(902,904,2),new P.ptr(905,906,1),new P.ptr(908,910,2),new P.ptr(911,913,2),new P.ptr(914,929,1),new P.ptr(931,939,1),new P.ptr(975,978,3),new P.ptr(979,980,1),new P.ptr(984,1006,2),new P.ptr(1012,1015,3),new P.ptr(1017,1018,1),new P.ptr(1021,1071,1),new P.ptr(1120,1152,2),new P.ptr(1162,1216,2),new P.ptr(1217,1229,2),new P.ptr(1232,1326,2),new P.ptr(1329,1366,1),new P.ptr(4256,4293,1),new P.ptr(4295,4301,6),new P.ptr(5024,5109,1),new P.ptr(7680,7828,2),new P.ptr(7838,7934,2),new P.ptr(7944,7951,1),new P.ptr(7960,7965,1),new P.ptr(7976,7983,1),new P.ptr(7992,7999,1),new P.ptr(8008,8013,1),new P.ptr(8025,8031,2),new P.ptr(8040,8047,1),new P.ptr(8120,8123,1),new P.ptr(8136,8139,1),new P.ptr(8152,8155,1),new P.ptr(8168,8172,1),new P.ptr(8184,8187,1),new P.ptr(8450,8455,5),new P.ptr(8459,8461,1),new P.ptr(8464,8466,1),new P.ptr(8469,8473,4),new P.ptr(8474,8477,1),new P.ptr(8484,8490,2),new P.ptr(8491,8493,1),new P.ptr(8496,8499,1),new P.ptr(8510,8511,1),new P.ptr(8517,8579,62),new P.ptr(11264,11310,1),new P.ptr(11360,11362,2),new P.ptr(11363,11364,1),new P.ptr(11367,11373,2),new P.ptr(11374,11376,1),new P.ptr(11378,11381,3),new P.ptr(11390,11392,1),new P.ptr(11394,11490,2),new P.ptr(11499,11501,2),new P.ptr(11506,42560,31054),new P.ptr(42562,42604,2),new P.ptr(42624,42650,2),new P.ptr(42786,42798,2),new P.ptr(42802,42862,2),new P.ptr(42873,42877,2),new P.ptr(42878,42886,2),new P.ptr(42891,42893,2),new P.ptr(42896,42898,2),new P.ptr(42902,42922,2),new P.ptr(42923,42926,1),new P.ptr(42928,42932,1),new P.ptr(42934,65313,22379),new P.ptr(65314,65338,1)]),new IZ([new Q.ptr(66560,66599,1),new Q.ptr(66736,66771,1),new Q.ptr(68736,68786,1),new Q.ptr(71840,71871,1),new Q.ptr(119808,119833,1),new Q.ptr(119860,119885,1),new Q.ptr(119912,119937,1),new Q.ptr(119964,119966,2),new Q.ptr(119967,119973,3),new Q.ptr(119974,119977,3),new Q.ptr(119978,119980,1),new Q.ptr(119982,119989,1),new Q.ptr(120016,120041,1),new Q.ptr(120068,120069,1),new Q.ptr(120071,120074,1),new Q.ptr(120077,120084,1),new Q.ptr(120086,120092,1),new Q.ptr(120120,120121,1),new Q.ptr(120123,120126,1),new Q.ptr(120128,120132,1),new Q.ptr(120134,120138,4),new Q.ptr(120139,120144,1),new Q.ptr(120172,120197,1),new Q.ptr(120224,120249,1),new Q.ptr(120276,120301,1),new Q.ptr(120328,120353,1),new Q.ptr(120380,120405,1),new Q.ptr(120432,120457,1),new Q.ptr(120488,120512,1),new Q.ptr(120546,120570,1),new Q.ptr(120604,120628,1),new Q.ptr(120662,120686,1),new Q.ptr(120720,120744,1),new Q.ptr(120778,125184,4406),new Q.ptr(125185,125217,1)]),3);AS=new O.ptr(new IY([new P.ptr(768,879,1),new P.ptr(1155,1161,1),new P.ptr(1425,1469,1),new P.ptr(1471,1473,2),new P.ptr(1474,1476,2),new P.ptr(1477,1479,2),new P.ptr(1552,1562,1),new P.ptr(1611,1631,1),new P.ptr(1648,1750,102),new P.ptr(1751,1756,1),new P.ptr(1759,1764,1),new P.ptr(1767,1768,1),new P.ptr(1770,1773,1),new P.ptr(1809,1840,31),new P.ptr(1841,1866,1),new P.ptr(1958,1968,1),new P.ptr(2027,2035,1),new P.ptr(2070,2073,1),new P.ptr(2075,2083,1),new P.ptr(2085,2087,1),new P.ptr(2089,2093,1),new P.ptr(2137,2139,1),new P.ptr(2260,2273,1),new P.ptr(2275,2307,1),new P.ptr(2362,2364,1),new P.ptr(2366,2383,1),new P.ptr(2385,2391,1),new P.ptr(2402,2403,1),new P.ptr(2433,2435,1),new P.ptr(2492,2494,2),new P.ptr(2495,2500,1),new P.ptr(2503,2504,1),new P.ptr(2507,2509,1),new P.ptr(2519,2530,11),new P.ptr(2531,2561,30),new P.ptr(2562,2563,1),new P.ptr(2620,2622,2),new P.ptr(2623,2626,1),new P.ptr(2631,2632,1),new P.ptr(2635,2637,1),new P.ptr(2641,2672,31),new P.ptr(2673,2677,4),new P.ptr(2689,2691,1),new P.ptr(2748,2750,2),new P.ptr(2751,2757,1),new P.ptr(2759,2761,1),new P.ptr(2763,2765,1),new P.ptr(2786,2787,1),new P.ptr(2810,2815,1),new P.ptr(2817,2819,1),new P.ptr(2876,2878,2),new P.ptr(2879,2884,1),new P.ptr(2887,2888,1),new P.ptr(2891,2893,1),new P.ptr(2902,2903,1),new P.ptr(2914,2915,1),new P.ptr(2946,3006,60),new P.ptr(3007,3010,1),new P.ptr(3014,3016,1),new P.ptr(3018,3021,1),new P.ptr(3031,3072,41),new P.ptr(3073,3075,1),new P.ptr(3134,3140,1),new P.ptr(3142,3144,1),new P.ptr(3146,3149,1),new P.ptr(3157,3158,1),new P.ptr(3170,3171,1),new P.ptr(3201,3203,1),new P.ptr(3260,3262,2),new P.ptr(3263,3268,1),new P.ptr(3270,3272,1),new P.ptr(3274,3277,1),new P.ptr(3285,3286,1),new P.ptr(3298,3299,1),new P.ptr(3328,3331,1),new P.ptr(3387,3388,1),new P.ptr(3390,3396,1),new P.ptr(3398,3400,1),new P.ptr(3402,3405,1),new P.ptr(3415,3426,11),new P.ptr(3427,3458,31),new P.ptr(3459,3530,71),new P.ptr(3535,3540,1),new P.ptr(3542,3544,2),new P.ptr(3545,3551,1),new P.ptr(3570,3571,1),new P.ptr(3633,3636,3),new P.ptr(3637,3642,1),new P.ptr(3655,3662,1),new P.ptr(3761,3764,3),new P.ptr(3765,3769,1),new P.ptr(3771,3772,1),new P.ptr(3784,3789,1),new P.ptr(3864,3865,1),new P.ptr(3893,3897,2),new P.ptr(3902,3903,1),new P.ptr(3953,3972,1),new P.ptr(3974,3975,1),new P.ptr(3981,3991,1),new P.ptr(3993,4028,1),new P.ptr(4038,4139,101),new P.ptr(4140,4158,1),new P.ptr(4182,4185,1),new P.ptr(4190,4192,1),new P.ptr(4194,4196,1),new P.ptr(4199,4205,1),new P.ptr(4209,4212,1),new P.ptr(4226,4237,1),new P.ptr(4239,4250,11),new P.ptr(4251,4253,1),new P.ptr(4957,4959,1),new P.ptr(5906,5908,1),new P.ptr(5938,5940,1),new P.ptr(5970,5971,1),new P.ptr(6002,6003,1),new P.ptr(6068,6099,1),new P.ptr(6109,6155,46),new P.ptr(6156,6157,1),new P.ptr(6277,6278,1),new P.ptr(6313,6432,119),new P.ptr(6433,6443,1),new P.ptr(6448,6459,1),new P.ptr(6679,6683,1),new P.ptr(6741,6750,1),new P.ptr(6752,6780,1),new P.ptr(6783,6832,49),new P.ptr(6833,6846,1),new P.ptr(6912,6916,1),new P.ptr(6964,6980,1),new P.ptr(7019,7027,1),new P.ptr(7040,7042,1),new P.ptr(7073,7085,1),new P.ptr(7142,7155,1),new P.ptr(7204,7223,1),new P.ptr(7376,7378,1),new P.ptr(7380,7400,1),new P.ptr(7405,7410,5),new P.ptr(7411,7412,1),new P.ptr(7415,7417,1),new P.ptr(7616,7673,1),new P.ptr(7675,7679,1),new P.ptr(8400,8432,1),new P.ptr(11503,11505,1),new P.ptr(11647,11744,97),new P.ptr(11745,11775,1),new P.ptr(12330,12335,1),new P.ptr(12441,12442,1),new P.ptr(42607,42610,1),new P.ptr(42612,42621,1),new P.ptr(42654,42655,1),new P.ptr(42736,42737,1),new P.ptr(43010,43014,4),new P.ptr(43019,43043,24),new P.ptr(43044,43047,1),new P.ptr(43136,43137,1),new P.ptr(43188,43205,1),new P.ptr(43232,43249,1),new P.ptr(43302,43309,1),new P.ptr(43335,43347,1),new P.ptr(43392,43395,1),new P.ptr(43443,43456,1),new P.ptr(43493,43561,68),new P.ptr(43562,43574,1),new P.ptr(43587,43596,9),new P.ptr(43597,43643,46),new P.ptr(43644,43645,1),new P.ptr(43696,43698,2),new P.ptr(43699,43700,1),new P.ptr(43703,43704,1),new P.ptr(43710,43711,1),new P.ptr(43713,43755,42),new P.ptr(43756,43759,1),new P.ptr(43765,43766,1),new P.ptr(44003,44010,1),new P.ptr(44012,44013,1),new P.ptr(64286,65024,738),new P.ptr(65025,65039,1),new P.ptr(65056,65071,1)]),new IZ([new Q.ptr(66045,66272,227),new Q.ptr(66422,66426,1),new Q.ptr(68097,68099,1),new Q.ptr(68101,68102,1),new Q.ptr(68108,68111,1),new Q.ptr(68152,68154,1),new Q.ptr(68159,68325,166),new Q.ptr(68326,69632,1306),new Q.ptr(69633,69634,1),new Q.ptr(69688,69702,1),new Q.ptr(69759,69762,1),new Q.ptr(69808,69818,1),new Q.ptr(69888,69890,1),new Q.ptr(69927,69940,1),new Q.ptr(70003,70016,13),new Q.ptr(70017,70018,1),new Q.ptr(70067,70080,1),new Q.ptr(70090,70092,1),new Q.ptr(70188,70199,1),new Q.ptr(70206,70367,161),new Q.ptr(70368,70378,1),new Q.ptr(70400,70403,1),new Q.ptr(70460,70462,2),new Q.ptr(70463,70468,1),new Q.ptr(70471,70472,1),new Q.ptr(70475,70477,1),new Q.ptr(70487,70498,11),new Q.ptr(70499,70502,3),new Q.ptr(70503,70508,1),new Q.ptr(70512,70516,1),new Q.ptr(70709,70726,1),new Q.ptr(70832,70851,1),new Q.ptr(71087,71093,1),new Q.ptr(71096,71104,1),new Q.ptr(71132,71133,1),new Q.ptr(71216,71232,1),new Q.ptr(71339,71351,1),new Q.ptr(71453,71467,1),new Q.ptr(72193,72202,1),new Q.ptr(72243,72249,1),new Q.ptr(72251,72254,1),new Q.ptr(72263,72273,10),new Q.ptr(72274,72283,1),new Q.ptr(72330,72345,1),new Q.ptr(72751,72758,1),new Q.ptr(72760,72767,1),new Q.ptr(72850,72871,1),new Q.ptr(72873,72886,1),new Q.ptr(73009,73014,1),new Q.ptr(73018,73020,2),new Q.ptr(73021,73023,2),new Q.ptr(73024,73029,1),new Q.ptr(73031,92912,19881),new Q.ptr(92913,92916,1),new Q.ptr(92976,92982,1),new Q.ptr(94033,94078,1),new Q.ptr(94095,94098,1),new Q.ptr(113821,113822,1),new Q.ptr(119141,119145,1),new Q.ptr(119149,119154,1),new Q.ptr(119163,119170,1),new Q.ptr(119173,119179,1),new Q.ptr(119210,119213,1),new Q.ptr(119362,119364,1),new Q.ptr(121344,121398,1),new Q.ptr(121403,121452,1),new Q.ptr(121461,121476,15),new Q.ptr(121499,121503,1),new Q.ptr(121505,121519,1),new Q.ptr(122880,122886,1),new Q.ptr(122888,122904,1),new Q.ptr(122907,122913,1),new Q.ptr(122915,122916,1),new Q.ptr(122918,122922,1),new Q.ptr(125136,125142,1),new Q.ptr(125252,125258,1),new Q.ptr(917760,917999,1)]),0);AT=new O.ptr(new IY([new P.ptr(2307,2363,56),new P.ptr(2366,2368,1),new P.ptr(2377,2380,1),new P.ptr(2382,2383,1),new P.ptr(2434,2435,1),new P.ptr(2494,2496,1),new P.ptr(2503,2504,1),new P.ptr(2507,2508,1),new P.ptr(2519,2563,44),new P.ptr(2622,2624,1),new P.ptr(2691,2750,59),new P.ptr(2751,2752,1),new P.ptr(2761,2763,2),new P.ptr(2764,2818,54),new P.ptr(2819,2878,59),new P.ptr(2880,2887,7),new P.ptr(2888,2891,3),new P.ptr(2892,2903,11),new P.ptr(3006,3007,1),new P.ptr(3009,3010,1),new P.ptr(3014,3016,1),new P.ptr(3018,3020,1),new P.ptr(3031,3073,42),new P.ptr(3074,3075,1),new P.ptr(3137,3140,1),new P.ptr(3202,3203,1),new P.ptr(3262,3264,2),new P.ptr(3265,3268,1),new P.ptr(3271,3272,1),new P.ptr(3274,3275,1),new P.ptr(3285,3286,1),new P.ptr(3330,3331,1),new P.ptr(3390,3392,1),new P.ptr(3398,3400,1),new P.ptr(3402,3404,1),new P.ptr(3415,3458,43),new P.ptr(3459,3535,76),new P.ptr(3536,3537,1),new P.ptr(3544,3551,1),new P.ptr(3570,3571,1),new P.ptr(3902,3903,1),new P.ptr(3967,4139,172),new P.ptr(4140,4145,5),new P.ptr(4152,4155,3),new P.ptr(4156,4182,26),new P.ptr(4183,4194,11),new P.ptr(4195,4196,1),new P.ptr(4199,4205,1),new P.ptr(4227,4228,1),new P.ptr(4231,4236,1),new P.ptr(4239,4250,11),new P.ptr(4251,4252,1),new P.ptr(6070,6078,8),new P.ptr(6079,6085,1),new P.ptr(6087,6088,1),new P.ptr(6435,6438,1),new P.ptr(6441,6443,1),new P.ptr(6448,6449,1),new P.ptr(6451,6456,1),new P.ptr(6681,6682,1),new P.ptr(6741,6743,2),new P.ptr(6753,6755,2),new P.ptr(6756,6765,9),new P.ptr(6766,6770,1),new P.ptr(6916,6965,49),new P.ptr(6971,6973,2),new P.ptr(6974,6977,1),new P.ptr(6979,6980,1),new P.ptr(7042,7073,31),new P.ptr(7078,7079,1),new P.ptr(7082,7143,61),new P.ptr(7146,7148,1),new P.ptr(7150,7154,4),new P.ptr(7155,7204,49),new P.ptr(7205,7211,1),new P.ptr(7220,7221,1),new P.ptr(7393,7410,17),new P.ptr(7411,7415,4),new P.ptr(12334,12335,1),new P.ptr(43043,43044,1),new P.ptr(43047,43136,89),new P.ptr(43137,43188,51),new P.ptr(43189,43203,1),new P.ptr(43346,43347,1),new P.ptr(43395,43444,49),new P.ptr(43445,43450,5),new P.ptr(43451,43453,2),new P.ptr(43454,43456,1),new P.ptr(43567,43568,1),new P.ptr(43571,43572,1),new P.ptr(43597,43643,46),new P.ptr(43645,43755,110),new P.ptr(43758,43759,1),new P.ptr(43765,44003,238),new P.ptr(44004,44006,2),new P.ptr(44007,44009,2),new P.ptr(44010,44012,2)]),new IZ([new Q.ptr(69632,69634,2),new Q.ptr(69762,69808,46),new Q.ptr(69809,69810,1),new Q.ptr(69815,69816,1),new Q.ptr(69932,70018,86),new Q.ptr(70067,70069,1),new Q.ptr(70079,70080,1),new Q.ptr(70188,70190,1),new Q.ptr(70194,70195,1),new Q.ptr(70197,70368,171),new Q.ptr(70369,70370,1),new Q.ptr(70402,70403,1),new Q.ptr(70462,70463,1),new Q.ptr(70465,70468,1),new Q.ptr(70471,70472,1),new Q.ptr(70475,70477,1),new Q.ptr(70487,70498,11),new Q.ptr(70499,70709,210),new Q.ptr(70710,70711,1),new Q.ptr(70720,70721,1),new Q.ptr(70725,70832,107),new Q.ptr(70833,70834,1),new Q.ptr(70841,70843,2),new Q.ptr(70844,70846,1),new Q.ptr(70849,71087,238),new Q.ptr(71088,71089,1),new Q.ptr(71096,71099,1),new Q.ptr(71102,71216,114),new Q.ptr(71217,71218,1),new Q.ptr(71227,71228,1),new Q.ptr(71230,71340,110),new Q.ptr(71342,71343,1),new Q.ptr(71350,71456,106),new Q.ptr(71457,71462,5),new Q.ptr(72199,72200,1),new Q.ptr(72249,72279,30),new Q.ptr(72280,72343,63),new Q.ptr(72751,72766,15),new Q.ptr(72873,72881,8),new Q.ptr(72884,94033,21149),new Q.ptr(94034,94078,1),new Q.ptr(119141,119142,1),new Q.ptr(119149,119154,1)]),0);AU=new O.ptr(new IY([new P.ptr(1160,1161,1),new P.ptr(6846,8413,1567),new P.ptr(8414,8416,1),new P.ptr(8418,8420,1),new P.ptr(42608,42610,1)]),IZ.nil,0);AV=new O.ptr(new IY([new P.ptr(768,879,1),new P.ptr(1155,1159,1),new P.ptr(1425,1469,1),new P.ptr(1471,1473,2),new P.ptr(1474,1476,2),new P.ptr(1477,1479,2),new P.ptr(1552,1562,1),new P.ptr(1611,1631,1),new P.ptr(1648,1750,102),new P.ptr(1751,1756,1),new P.ptr(1759,1764,1),new P.ptr(1767,1768,1),new P.ptr(1770,1773,1),new P.ptr(1809,1840,31),new P.ptr(1841,1866,1),new P.ptr(1958,1968,1),new P.ptr(2027,2035,1),new P.ptr(2070,2073,1),new P.ptr(2075,2083,1),new P.ptr(2085,2087,1),new P.ptr(2089,2093,1),new P.ptr(2137,2139,1),new P.ptr(2260,2273,1),new P.ptr(2275,2306,1),new P.ptr(2362,2364,2),new P.ptr(2369,2376,1),new P.ptr(2381,2385,4),new P.ptr(2386,2391,1),new P.ptr(2402,2403,1),new P.ptr(2433,2492,59),new P.ptr(2497,2500,1),new P.ptr(2509,2530,21),new P.ptr(2531,2561,30),new P.ptr(2562,2620,58),new P.ptr(2625,2626,1),new P.ptr(2631,2632,1),new P.ptr(2635,2637,1),new P.ptr(2641,2672,31),new P.ptr(2673,2677,4),new P.ptr(2689,2690,1),new P.ptr(2748,2753,5),new P.ptr(2754,2757,1),new P.ptr(2759,2760,1),new P.ptr(2765,2786,21),new P.ptr(2787,2810,23),new P.ptr(2811,2815,1),new P.ptr(2817,2876,59),new P.ptr(2879,2881,2),new P.ptr(2882,2884,1),new P.ptr(2893,2902,9),new P.ptr(2914,2915,1),new P.ptr(2946,3008,62),new P.ptr(3021,3072,51),new P.ptr(3134,3136,1),new P.ptr(3142,3144,1),new P.ptr(3146,3149,1),new P.ptr(3157,3158,1),new P.ptr(3170,3171,1),new P.ptr(3201,3260,59),new P.ptr(3263,3270,7),new P.ptr(3276,3277,1),new P.ptr(3298,3299,1),new P.ptr(3328,3329,1),new P.ptr(3387,3388,1),new P.ptr(3393,3396,1),new P.ptr(3405,3426,21),new P.ptr(3427,3530,103),new P.ptr(3538,3540,1),new P.ptr(3542,3633,91),new P.ptr(3636,3642,1),new P.ptr(3655,3662,1),new P.ptr(3761,3764,3),new P.ptr(3765,3769,1),new P.ptr(3771,3772,1),new P.ptr(3784,3789,1),new P.ptr(3864,3865,1),new P.ptr(3893,3897,2),new P.ptr(3953,3966,1),new P.ptr(3968,3972,1),new P.ptr(3974,3975,1),new P.ptr(3981,3991,1),new P.ptr(3993,4028,1),new P.ptr(4038,4141,103),new P.ptr(4142,4144,1),new P.ptr(4146,4151,1),new P.ptr(4153,4154,1),new P.ptr(4157,4158,1),new P.ptr(4184,4185,1),new P.ptr(4190,4192,1),new P.ptr(4209,4212,1),new P.ptr(4226,4229,3),new P.ptr(4230,4237,7),new P.ptr(4253,4957,704),new P.ptr(4958,4959,1),new P.ptr(5906,5908,1),new P.ptr(5938,5940,1),new P.ptr(5970,5971,1),new P.ptr(6002,6003,1),new P.ptr(6068,6069,1),new P.ptr(6071,6077,1),new P.ptr(6086,6089,3),new P.ptr(6090,6099,1),new P.ptr(6109,6155,46),new P.ptr(6156,6157,1),new P.ptr(6277,6278,1),new P.ptr(6313,6432,119),new P.ptr(6433,6434,1),new P.ptr(6439,6440,1),new P.ptr(6450,6457,7),new P.ptr(6458,6459,1),new P.ptr(6679,6680,1),new P.ptr(6683,6742,59),new P.ptr(6744,6750,1),new P.ptr(6752,6754,2),new P.ptr(6757,6764,1),new P.ptr(6771,6780,1),new P.ptr(6783,6832,49),new P.ptr(6833,6845,1),new P.ptr(6912,6915,1),new P.ptr(6964,6966,2),new P.ptr(6967,6970,1),new P.ptr(6972,6978,6),new P.ptr(7019,7027,1),new P.ptr(7040,7041,1),new P.ptr(7074,7077,1),new P.ptr(7080,7081,1),new P.ptr(7083,7085,1),new P.ptr(7142,7144,2),new P.ptr(7145,7149,4),new P.ptr(7151,7153,1),new P.ptr(7212,7219,1),new P.ptr(7222,7223,1),new P.ptr(7376,7378,1),new P.ptr(7380,7392,1),new P.ptr(7394,7400,1),new P.ptr(7405,7412,7),new P.ptr(7416,7417,1),new P.ptr(7616,7673,1),new P.ptr(7675,7679,1),new P.ptr(8400,8412,1),new P.ptr(8417,8421,4),new P.ptr(8422,8432,1),new P.ptr(11503,11505,1),new P.ptr(11647,11744,97),new P.ptr(11745,11775,1),new P.ptr(12330,12333,1),new P.ptr(12441,12442,1),new P.ptr(42607,42612,5),new P.ptr(42613,42621,1),new P.ptr(42654,42655,1),new P.ptr(42736,42737,1),new P.ptr(43010,43014,4),new P.ptr(43019,43045,26),new P.ptr(43046,43204,158),new P.ptr(43205,43232,27),new P.ptr(43233,43249,1),new P.ptr(43302,43309,1),new P.ptr(43335,43345,1),new P.ptr(43392,43394,1),new P.ptr(43443,43446,3),new P.ptr(43447,43449,1),new P.ptr(43452,43493,41),new P.ptr(43561,43566,1),new P.ptr(43569,43570,1),new P.ptr(43573,43574,1),new P.ptr(43587,43596,9),new P.ptr(43644,43696,52),new P.ptr(43698,43700,1),new P.ptr(43703,43704,1),new P.ptr(43710,43711,1),new P.ptr(43713,43756,43),new P.ptr(43757,43766,9),new P.ptr(44005,44008,3),new P.ptr(44013,64286,20273),new P.ptr(65024,65039,1),new P.ptr(65056,65071,1)]),new IZ([new Q.ptr(66045,66272,227),new Q.ptr(66422,66426,1),new Q.ptr(68097,68099,1),new Q.ptr(68101,68102,1),new Q.ptr(68108,68111,1),new Q.ptr(68152,68154,1),new Q.ptr(68159,68325,166),new Q.ptr(68326,69633,1307),new Q.ptr(69688,69702,1),new Q.ptr(69759,69761,1),new Q.ptr(69811,69814,1),new Q.ptr(69817,69818,1),new Q.ptr(69888,69890,1),new Q.ptr(69927,69931,1),new Q.ptr(69933,69940,1),new Q.ptr(70003,70016,13),new Q.ptr(70017,70070,53),new Q.ptr(70071,70078,1),new Q.ptr(70090,70092,1),new Q.ptr(70191,70193,1),new Q.ptr(70196,70198,2),new Q.ptr(70199,70206,7),new Q.ptr(70367,70371,4),new Q.ptr(70372,70378,1),new Q.ptr(70400,70401,1),new Q.ptr(70460,70464,4),new Q.ptr(70502,70508,1),new Q.ptr(70512,70516,1),new Q.ptr(70712,70719,1),new Q.ptr(70722,70724,1),new Q.ptr(70726,70835,109),new Q.ptr(70836,70840,1),new Q.ptr(70842,70847,5),new Q.ptr(70848,70850,2),new Q.ptr(70851,71090,239),new Q.ptr(71091,71093,1),new Q.ptr(71100,71101,1),new Q.ptr(71103,71104,1),new Q.ptr(71132,71133,1),new Q.ptr(71219,71226,1),new Q.ptr(71229,71231,2),new Q.ptr(71232,71339,107),new Q.ptr(71341,71344,3),new Q.ptr(71345,71349,1),new Q.ptr(71351,71453,102),new Q.ptr(71454,71455,1),new Q.ptr(71458,71461,1),new Q.ptr(71463,71467,1),new Q.ptr(72193,72198,1),new Q.ptr(72201,72202,1),new Q.ptr(72243,72248,1),new Q.ptr(72251,72254,1),new Q.ptr(72263,72273,10),new Q.ptr(72274,72278,1),new Q.ptr(72281,72283,1),new Q.ptr(72330,72342,1),new Q.ptr(72344,72345,1),new Q.ptr(72752,72758,1),new Q.ptr(72760,72765,1),new Q.ptr(72767,72850,83),new Q.ptr(72851,72871,1),new Q.ptr(72874,72880,1),new Q.ptr(72882,72883,1),new Q.ptr(72885,72886,1),new Q.ptr(73009,73014,1),new Q.ptr(73018,73020,2),new Q.ptr(73021,73023,2),new Q.ptr(73024,73029,1),new Q.ptr(73031,92912,19881),new Q.ptr(92913,92916,1),new Q.ptr(92976,92982,1),new Q.ptr(94095,94098,1),new Q.ptr(113821,113822,1),new Q.ptr(119143,119145,1),new Q.ptr(119163,119170,1),new Q.ptr(119173,119179,1),new Q.ptr(119210,119213,1),new Q.ptr(119362,119364,1),new Q.ptr(121344,121398,1),new Q.ptr(121403,121452,1),new Q.ptr(121461,121476,15),new Q.ptr(121499,121503,1),new Q.ptr(121505,121519,1),new Q.ptr(122880,122886,1),new Q.ptr(122888,122904,1),new Q.ptr(122907,122913,1),new Q.ptr(122915,122916,1),new Q.ptr(122918,122922,1),new Q.ptr(125136,125142,1),new Q.ptr(125252,125258,1),new Q.ptr(917760,917999,1)]),0);AW=new O.ptr(new IY([new P.ptr(48,57,1),new P.ptr(178,179,1),new P.ptr(185,188,3),new P.ptr(189,190,1),new P.ptr(1632,1641,1),new P.ptr(1776,1785,1),new P.ptr(1984,1993,1),new P.ptr(2406,2415,1),new P.ptr(2534,2543,1),new P.ptr(2548,2553,1),new P.ptr(2662,2671,1),new P.ptr(2790,2799,1),new P.ptr(2918,2927,1),new P.ptr(2930,2935,1),new P.ptr(3046,3058,1),new P.ptr(3174,3183,1),new P.ptr(3192,3198,1),new P.ptr(3302,3311,1),new P.ptr(3416,3422,1),new P.ptr(3430,3448,1),new P.ptr(3558,3567,1),new P.ptr(3664,3673,1),new P.ptr(3792,3801,1),new P.ptr(3872,3891,1),new P.ptr(4160,4169,1),new P.ptr(4240,4249,1),new P.ptr(4969,4988,1),new P.ptr(5870,5872,1),new P.ptr(6112,6121,1),new P.ptr(6128,6137,1),new P.ptr(6160,6169,1),new P.ptr(6470,6479,1),new P.ptr(6608,6618,1),new P.ptr(6784,6793,1),new P.ptr(6800,6809,1),new P.ptr(6992,7001,1),new P.ptr(7088,7097,1),new P.ptr(7232,7241,1),new P.ptr(7248,7257,1),new P.ptr(8304,8308,4),new P.ptr(8309,8313,1),new P.ptr(8320,8329,1),new P.ptr(8528,8578,1),new P.ptr(8581,8585,1),new P.ptr(9312,9371,1),new P.ptr(9450,9471,1),new P.ptr(10102,10131,1),new P.ptr(11517,12295,778),new P.ptr(12321,12329,1),new P.ptr(12344,12346,1),new P.ptr(12690,12693,1),new P.ptr(12832,12841,1),new P.ptr(12872,12879,1),new P.ptr(12881,12895,1),new P.ptr(12928,12937,1),new P.ptr(12977,12991,1),new P.ptr(42528,42537,1),new P.ptr(42726,42735,1),new P.ptr(43056,43061,1),new P.ptr(43216,43225,1),new P.ptr(43264,43273,1),new P.ptr(43472,43481,1),new P.ptr(43504,43513,1),new P.ptr(43600,43609,1),new P.ptr(44016,44025,1),new P.ptr(65296,65305,1)]),new IZ([new Q.ptr(65799,65843,1),new Q.ptr(65856,65912,1),new Q.ptr(65930,65931,1),new Q.ptr(66273,66299,1),new Q.ptr(66336,66339,1),new Q.ptr(66369,66378,9),new Q.ptr(66513,66517,1),new Q.ptr(66720,66729,1),new Q.ptr(67672,67679,1),new Q.ptr(67705,67711,1),new Q.ptr(67751,67759,1),new Q.ptr(67835,67839,1),new Q.ptr(67862,67867,1),new Q.ptr(68028,68029,1),new Q.ptr(68032,68047,1),new Q.ptr(68050,68095,1),new Q.ptr(68160,68167,1),new Q.ptr(68221,68222,1),new Q.ptr(68253,68255,1),new Q.ptr(68331,68335,1),new Q.ptr(68440,68447,1),new Q.ptr(68472,68479,1),new Q.ptr(68521,68527,1),new Q.ptr(68858,68863,1),new Q.ptr(69216,69246,1),new Q.ptr(69714,69743,1),new Q.ptr(69872,69881,1),new Q.ptr(69942,69951,1),new Q.ptr(70096,70105,1),new Q.ptr(70113,70132,1),new Q.ptr(70384,70393,1),new Q.ptr(70736,70745,1),new Q.ptr(70864,70873,1),new Q.ptr(71248,71257,1),new Q.ptr(71360,71369,1),new Q.ptr(71472,71483,1),new Q.ptr(71904,71922,1),new Q.ptr(72784,72812,1),new Q.ptr(73040,73049,1),new Q.ptr(74752,74862,1),new Q.ptr(92768,92777,1),new Q.ptr(93008,93017,1),new Q.ptr(93019,93025,1),new Q.ptr(119648,119665,1),new Q.ptr(120782,120831,1),new Q.ptr(125127,125135,1),new Q.ptr(125264,125273,1),new Q.ptr(127232,127244,1)]),4);AX=new O.ptr(new IY([new P.ptr(48,57,1),new P.ptr(1632,1641,1),new P.ptr(1776,1785,1),new P.ptr(1984,1993,1),new P.ptr(2406,2415,1),new P.ptr(2534,2543,1),new P.ptr(2662,2671,1),new P.ptr(2790,2799,1),new P.ptr(2918,2927,1),new P.ptr(3046,3055,1),new P.ptr(3174,3183,1),new P.ptr(3302,3311,1),new P.ptr(3430,3439,1),new P.ptr(3558,3567,1),new P.ptr(3664,3673,1),new P.ptr(3792,3801,1),new P.ptr(3872,3881,1),new P.ptr(4160,4169,1),new P.ptr(4240,4249,1),new P.ptr(6112,6121,1),new P.ptr(6160,6169,1),new P.ptr(6470,6479,1),new P.ptr(6608,6617,1),new P.ptr(6784,6793,1),new P.ptr(6800,6809,1),new P.ptr(6992,7001,1),new P.ptr(7088,7097,1),new P.ptr(7232,7241,1),new P.ptr(7248,7257,1),new P.ptr(42528,42537,1),new P.ptr(43216,43225,1),new P.ptr(43264,43273,1),new P.ptr(43472,43481,1),new P.ptr(43504,43513,1),new P.ptr(43600,43609,1),new P.ptr(44016,44025,1),new P.ptr(65296,65305,1)]),new IZ([new Q.ptr(66720,66729,1),new Q.ptr(69734,69743,1),new Q.ptr(69872,69881,1),new Q.ptr(69942,69951,1),new Q.ptr(70096,70105,1),new Q.ptr(70384,70393,1),new Q.ptr(70736,70745,1),new Q.ptr(70864,70873,1),new Q.ptr(71248,71257,1),new Q.ptr(71360,71369,1),new Q.ptr(71472,71481,1),new Q.ptr(71904,71913,1),new Q.ptr(72784,72793,1),new Q.ptr(73040,73049,1),new Q.ptr(92768,92777,1),new Q.ptr(93008,93017,1),new Q.ptr(120782,120831,1),new Q.ptr(125264,125273,1)]),1);AY=new O.ptr(new IY([new P.ptr(5870,5872,1),new P.ptr(8544,8578,1),new P.ptr(8581,8584,1),new P.ptr(12295,12321,26),new P.ptr(12322,12329,1),new P.ptr(12344,12346,1),new P.ptr(42726,42735,1)]),new IZ([new Q.ptr(65856,65908,1),new Q.ptr(66369,66378,9),new Q.ptr(66513,66517,1),new Q.ptr(74752,74862,1)]),0);AZ=new O.ptr(new IY([new P.ptr(178,179,1),new P.ptr(185,188,3),new P.ptr(189,190,1),new P.ptr(2548,2553,1),new P.ptr(2930,2935,1),new P.ptr(3056,3058,1),new P.ptr(3192,3198,1),new P.ptr(3416,3422,1),new P.ptr(3440,3448,1),new P.ptr(3882,3891,1),new P.ptr(4969,4988,1),new P.ptr(6128,6137,1),new P.ptr(6618,8304,1686),new P.ptr(8308,8313,1),new P.ptr(8320,8329,1),new P.ptr(8528,8543,1),new P.ptr(8585,9312,727),new P.ptr(9313,9371,1),new P.ptr(9450,9471,1),new P.ptr(10102,10131,1),new P.ptr(11517,12690,1173),new P.ptr(12691,12693,1),new P.ptr(12832,12841,1),new P.ptr(12872,12879,1),new P.ptr(12881,12895,1),new P.ptr(12928,12937,1),new P.ptr(12977,12991,1),new P.ptr(43056,43061,1)]),new IZ([new Q.ptr(65799,65843,1),new Q.ptr(65909,65912,1),new Q.ptr(65930,65931,1),new Q.ptr(66273,66299,1),new Q.ptr(66336,66339,1),new Q.ptr(67672,67679,1),new Q.ptr(67705,67711,1),new Q.ptr(67751,67759,1),new Q.ptr(67835,67839,1),new Q.ptr(67862,67867,1),new Q.ptr(68028,68029,1),new Q.ptr(68032,68047,1),new Q.ptr(68050,68095,1),new Q.ptr(68160,68167,1),new Q.ptr(68221,68222,1),new Q.ptr(68253,68255,1),new Q.ptr(68331,68335,1),new Q.ptr(68440,68447,1),new Q.ptr(68472,68479,1),new Q.ptr(68521,68527,1),new Q.ptr(68858,68863,1),new Q.ptr(69216,69246,1),new Q.ptr(69714,69733,1),new Q.ptr(70113,70132,1),new Q.ptr(71482,71483,1),new Q.ptr(71914,71922,1),new Q.ptr(72794,72812,1),new Q.ptr(93019,93025,1),new Q.ptr(119648,119665,1),new Q.ptr(125127,125135,1),new Q.ptr(127232,127244,1)]),3);BA=new O.ptr(new IY([new P.ptr(33,35,1),new P.ptr(37,42,1),new P.ptr(44,47,1),new P.ptr(58,59,1),new P.ptr(63,64,1),new P.ptr(91,93,1),new P.ptr(95,123,28),new P.ptr(125,161,36),new P.ptr(167,171,4),new P.ptr(182,183,1),new P.ptr(187,191,4),new P.ptr(894,903,9),new P.ptr(1370,1375,1),new P.ptr(1417,1418,1),new P.ptr(1470,1472,2),new P.ptr(1475,1478,3),new P.ptr(1523,1524,1),new P.ptr(1545,1546,1),new P.ptr(1548,1549,1),new P.ptr(1563,1566,3),new P.ptr(1567,1642,75),new P.ptr(1643,1645,1),new P.ptr(1748,1792,44),new P.ptr(1793,1805,1),new P.ptr(2039,2041,1),new P.ptr(2096,2110,1),new P.ptr(2142,2404,262),new P.ptr(2405,2416,11),new P.ptr(2557,2800,243),new P.ptr(3572,3663,91),new P.ptr(3674,3675,1),new P.ptr(3844,3858,1),new P.ptr(3860,3898,38),new P.ptr(3899,3901,1),new P.ptr(3973,4048,75),new P.ptr(4049,4052,1),new P.ptr(4057,4058,1),new P.ptr(4170,4175,1),new P.ptr(4347,4960,613),new P.ptr(4961,4968,1),new P.ptr(5120,5741,621),new P.ptr(5742,5787,45),new P.ptr(5788,5867,79),new P.ptr(5868,5869,1),new P.ptr(5941,5942,1),new P.ptr(6100,6102,1),new P.ptr(6104,6106,1),new P.ptr(6144,6154,1),new P.ptr(6468,6469,1),new P.ptr(6686,6687,1),new P.ptr(6816,6822,1),new P.ptr(6824,6829,1),new P.ptr(7002,7008,1),new P.ptr(7164,7167,1),new P.ptr(7227,7231,1),new P.ptr(7294,7295,1),new P.ptr(7360,7367,1),new P.ptr(7379,8208,829),new P.ptr(8209,8231,1),new P.ptr(8240,8259,1),new P.ptr(8261,8273,1),new P.ptr(8275,8286,1),new P.ptr(8317,8318,1),new P.ptr(8333,8334,1),new P.ptr(8968,8971,1),new P.ptr(9001,9002,1),new P.ptr(10088,10101,1),new P.ptr(10181,10182,1),new P.ptr(10214,10223,1),new P.ptr(10627,10648,1),new P.ptr(10712,10715,1),new P.ptr(10748,10749,1),new P.ptr(11513,11516,1),new P.ptr(11518,11519,1),new P.ptr(11632,11776,144),new P.ptr(11777,11822,1),new P.ptr(11824,11849,1),new P.ptr(12289,12291,1),new P.ptr(12296,12305,1),new P.ptr(12308,12319,1),new P.ptr(12336,12349,13),new P.ptr(12448,12539,91),new P.ptr(42238,42239,1),new P.ptr(42509,42511,1),new P.ptr(42611,42622,11),new P.ptr(42738,42743,1),new P.ptr(43124,43127,1),new P.ptr(43214,43215,1),new P.ptr(43256,43258,1),new P.ptr(43260,43310,50),new P.ptr(43311,43359,48),new P.ptr(43457,43469,1),new P.ptr(43486,43487,1),new P.ptr(43612,43615,1),new P.ptr(43742,43743,1),new P.ptr(43760,43761,1),new P.ptr(44011,64830,20819),new P.ptr(64831,65040,209),new P.ptr(65041,65049,1),new P.ptr(65072,65106,1),new P.ptr(65108,65121,1),new P.ptr(65123,65128,5),new P.ptr(65130,65131,1),new P.ptr(65281,65283,1),new P.ptr(65285,65290,1),new P.ptr(65292,65295,1),new P.ptr(65306,65307,1),new P.ptr(65311,65312,1),new P.ptr(65339,65341,1),new P.ptr(65343,65371,28),new P.ptr(65373,65375,2),new P.ptr(65376,65381,1)]),new IZ([new Q.ptr(65792,65794,1),new Q.ptr(66463,66512,49),new Q.ptr(66927,67671,744),new Q.ptr(67871,67903,32),new Q.ptr(68176,68184,1),new Q.ptr(68223,68336,113),new Q.ptr(68337,68342,1),new Q.ptr(68409,68415,1),new Q.ptr(68505,68508,1),new Q.ptr(69703,69709,1),new Q.ptr(69819,69820,1),new Q.ptr(69822,69825,1),new Q.ptr(69952,69955,1),new Q.ptr(70004,70005,1),new Q.ptr(70085,70089,1),new Q.ptr(70093,70107,14),new Q.ptr(70109,70111,1),new Q.ptr(70200,70205,1),new Q.ptr(70313,70731,418),new Q.ptr(70732,70735,1),new Q.ptr(70747,70749,2),new Q.ptr(70854,71105,251),new Q.ptr(71106,71127,1),new Q.ptr(71233,71235,1),new Q.ptr(71264,71276,1),new Q.ptr(71484,71486,1),new Q.ptr(72255,72262,1),new Q.ptr(72346,72348,1),new Q.ptr(72350,72354,1),new Q.ptr(72769,72773,1),new Q.ptr(72816,72817,1),new Q.ptr(74864,74868,1),new Q.ptr(92782,92783,1),new Q.ptr(92917,92983,66),new Q.ptr(92984,92987,1),new Q.ptr(92996,113823,20827),new Q.ptr(121479,121483,1),new Q.ptr(125278,125279,1)]),11);BB=new O.ptr(new IY([new P.ptr(95,8255,8160),new P.ptr(8256,8276,20),new P.ptr(65075,65076,1),new P.ptr(65101,65103,1),new P.ptr(65343,65343,1)]),IZ.nil,0);BC=new O.ptr(new IY([new P.ptr(45,1418,1373),new P.ptr(1470,5120,3650),new P.ptr(6150,8208,2058),new P.ptr(8209,8213,1),new P.ptr(11799,11802,3),new P.ptr(11834,11835,1),new P.ptr(11840,12316,476),new P.ptr(12336,12448,112),new P.ptr(65073,65074,1),new P.ptr(65112,65123,11),new P.ptr(65293,65293,1)]),IZ.nil,0);BD=new O.ptr(new IY([new P.ptr(41,93,52),new P.ptr(125,3899,3774),new P.ptr(3901,5788,1887),new P.ptr(8262,8318,56),new P.ptr(8334,8969,635),new P.ptr(8971,9002,31),new P.ptr(10089,10101,2),new P.ptr(10182,10215,33),new P.ptr(10217,10223,2),new P.ptr(10628,10648,2),new P.ptr(10713,10715,2),new P.ptr(10749,11811,1062),new P.ptr(11813,11817,2),new P.ptr(12297,12305,2),new P.ptr(12309,12315,2),new P.ptr(12318,12319,1),new P.ptr(64830,65048,218),new P.ptr(65078,65092,2),new P.ptr(65096,65114,18),new P.ptr(65116,65118,2),new P.ptr(65289,65341,52),new P.ptr(65373,65379,3)]),IZ.nil,1);BE=new O.ptr(new IY([new P.ptr(187,8217,8030),new P.ptr(8221,8250,29),new P.ptr(11779,11781,2),new P.ptr(11786,11789,3),new P.ptr(11805,11809,4)]),IZ.nil,0);BF=new O.ptr(new IY([new P.ptr(171,8216,8045),new P.ptr(8219,8220,1),new P.ptr(8223,8249,26),new P.ptr(11778,11780,2),new P.ptr(11785,11788,3),new P.ptr(11804,11808,4)]),IZ.nil,0);BG=new O.ptr(new IY([new P.ptr(33,35,1),new P.ptr(37,39,1),new P.ptr(42,46,2),new P.ptr(47,58,11),new P.ptr(59,63,4),new P.ptr(64,92,28),new P.ptr(161,167,6),new P.ptr(182,183,1),new P.ptr(191,894,703),new P.ptr(903,1370,467),new P.ptr(1371,1375,1),new P.ptr(1417,1472,55),new P.ptr(1475,1478,3),new P.ptr(1523,1524,1),new P.ptr(1545,1546,1),new P.ptr(1548,1549,1),new P.ptr(1563,1566,3),new P.ptr(1567,1642,75),new P.ptr(1643,1645,1),new P.ptr(1748,1792,44),new P.ptr(1793,1805,1),new P.ptr(2039,2041,1),new P.ptr(2096,2110,1),new P.ptr(2142,2404,262),new P.ptr(2405,2416,11),new P.ptr(2557,2800,243),new P.ptr(3572,3663,91),new P.ptr(3674,3675,1),new P.ptr(3844,3858,1),new P.ptr(3860,3973,113),new P.ptr(4048,4052,1),new P.ptr(4057,4058,1),new P.ptr(4170,4175,1),new P.ptr(4347,4960,613),new P.ptr(4961,4968,1),new P.ptr(5741,5742,1),new P.ptr(5867,5869,1),new P.ptr(5941,5942,1),new P.ptr(6100,6102,1),new P.ptr(6104,6106,1),new P.ptr(6144,6149,1),new P.ptr(6151,6154,1),new P.ptr(6468,6469,1),new P.ptr(6686,6687,1),new P.ptr(6816,6822,1),new P.ptr(6824,6829,1),new P.ptr(7002,7008,1),new P.ptr(7164,7167,1),new P.ptr(7227,7231,1),new P.ptr(7294,7295,1),new P.ptr(7360,7367,1),new P.ptr(7379,8214,835),new P.ptr(8215,8224,9),new P.ptr(8225,8231,1),new P.ptr(8240,8248,1),new P.ptr(8251,8254,1),new P.ptr(8257,8259,1),new P.ptr(8263,8273,1),new P.ptr(8275,8277,2),new P.ptr(8278,8286,1),new P.ptr(11513,11516,1),new P.ptr(11518,11519,1),new P.ptr(11632,11776,144),new P.ptr(11777,11782,5),new P.ptr(11783,11784,1),new P.ptr(11787,11790,3),new P.ptr(11791,11798,1),new P.ptr(11800,11801,1),new P.ptr(11803,11806,3),new P.ptr(11807,11818,11),new P.ptr(11819,11822,1),new P.ptr(11824,11833,1),new P.ptr(11836,11839,1),new P.ptr(11841,11843,2),new P.ptr(11844,11849,1),new P.ptr(12289,12291,1),new P.ptr(12349,12539,190),new P.ptr(42238,42239,1),new P.ptr(42509,42511,1),new P.ptr(42611,42622,11),new P.ptr(42738,42743,1),new P.ptr(43124,43127,1),new P.ptr(43214,43215,1),new P.ptr(43256,43258,1),new P.ptr(43260,43310,50),new P.ptr(43311,43359,48),new P.ptr(43457,43469,1),new P.ptr(43486,43487,1),new P.ptr(43612,43615,1),new P.ptr(43742,43743,1),new P.ptr(43760,43761,1),new P.ptr(44011,65040,21029),new P.ptr(65041,65046,1),new P.ptr(65049,65072,23),new P.ptr(65093,65094,1),new P.ptr(65097,65100,1),new P.ptr(65104,65106,1),new P.ptr(65108,65111,1),new P.ptr(65119,65121,1),new P.ptr(65128,65130,2),new P.ptr(65131,65281,150),new P.ptr(65282,65283,1),new P.ptr(65285,65287,1),new P.ptr(65290,65294,2),new P.ptr(65295,65306,11),new P.ptr(65307,65311,4),new P.ptr(65312,65340,28),new P.ptr(65377,65380,3),new P.ptr(65381,65381,1)]),new IZ([new Q.ptr(65792,65792,1),new Q.ptr(65793,65794,1),new Q.ptr(66463,66512,49),new Q.ptr(66927,67671,744),new Q.ptr(67871,67903,32),new Q.ptr(68176,68184,1),new Q.ptr(68223,68336,113),new Q.ptr(68337,68342,1),new Q.ptr(68409,68415,1),new Q.ptr(68505,68508,1),new Q.ptr(69703,69709,1),new Q.ptr(69819,69820,1),new Q.ptr(69822,69825,1),new Q.ptr(69952,69955,1),new Q.ptr(70004,70005,1),new Q.ptr(70085,70089,1),new Q.ptr(70093,70107,14),new Q.ptr(70109,70111,1),new Q.ptr(70200,70205,1),new Q.ptr(70313,70731,418),new Q.ptr(70732,70735,1),new Q.ptr(70747,70749,2),new Q.ptr(70854,71105,251),new Q.ptr(71106,71127,1),new Q.ptr(71233,71235,1),new Q.ptr(71264,71276,1),new Q.ptr(71484,71486,1),new Q.ptr(72255,72262,1),new Q.ptr(72346,72348,1),new Q.ptr(72350,72354,1),new Q.ptr(72769,72773,1),new Q.ptr(72816,72817,1),new Q.ptr(74864,74868,1),new Q.ptr(92782,92783,1),new Q.ptr(92917,92983,66),new Q.ptr(92984,92987,1),new Q.ptr(92996,113823,20827),new Q.ptr(121479,121483,1),new Q.ptr(125278,125279,1)]),8);BH=new O.ptr(new IY([new P.ptr(40,91,51),new P.ptr(123,3898,3775),new P.ptr(3900,5787,1887),new P.ptr(8218,8222,4),new P.ptr(8261,8317,56),new P.ptr(8333,8968,635),new P.ptr(8970,9001,31),new P.ptr(10088,10100,2),new P.ptr(10181,10214,33),new P.ptr(10216,10222,2),new P.ptr(10627,10647,2),new P.ptr(10712,10714,2),new P.ptr(10748,11810,1062),new P.ptr(11812,11816,2),new P.ptr(11842,12296,454),new P.ptr(12298,12304,2),new P.ptr(12308,12314,2),new P.ptr(12317,64831,52514),new P.ptr(65047,65077,30),new P.ptr(65079,65091,2),new P.ptr(65095,65113,18),new P.ptr(65115,65117,2),new P.ptr(65288,65339,51),new P.ptr(65371,65375,4),new P.ptr(65378,65378,1)]),IZ.nil,1);BI=new O.ptr(new IY([new P.ptr(36,43,7),new P.ptr(60,62,1),new P.ptr(94,96,2),new P.ptr(124,126,2),new P.ptr(162,166,1),new P.ptr(168,169,1),new P.ptr(172,174,2),new P.ptr(175,177,1),new P.ptr(180,184,4),new P.ptr(215,247,32),new P.ptr(706,709,1),new P.ptr(722,735,1),new P.ptr(741,747,1),new P.ptr(749,751,2),new P.ptr(752,767,1),new P.ptr(885,900,15),new P.ptr(901,1014,113),new P.ptr(1154,1421,267),new P.ptr(1422,1423,1),new P.ptr(1542,1544,1),new P.ptr(1547,1550,3),new P.ptr(1551,1758,207),new P.ptr(1769,1789,20),new P.ptr(1790,2038,248),new P.ptr(2546,2547,1),new P.ptr(2554,2555,1),new P.ptr(2801,2928,127),new P.ptr(3059,3066,1),new P.ptr(3199,3407,208),new P.ptr(3449,3647,198),new P.ptr(3841,3843,1),new P.ptr(3859,3861,2),new P.ptr(3862,3863,1),new P.ptr(3866,3871,1),new P.ptr(3892,3896,2),new P.ptr(4030,4037,1),new P.ptr(4039,4044,1),new P.ptr(4046,4047,1),new P.ptr(4053,4056,1),new P.ptr(4254,4255,1),new P.ptr(5008,5017,1),new P.ptr(6107,6464,357),new P.ptr(6622,6655,1),new P.ptr(7009,7018,1),new P.ptr(7028,7036,1),new P.ptr(8125,8127,2),new P.ptr(8128,8129,1),new P.ptr(8141,8143,1),new P.ptr(8157,8159,1),new P.ptr(8173,8175,1),new P.ptr(8189,8190,1),new P.ptr(8260,8274,14),new P.ptr(8314,8316,1),new P.ptr(8330,8332,1),new P.ptr(8352,8383,1),new P.ptr(8448,8449,1),new P.ptr(8451,8454,1),new P.ptr(8456,8457,1),new P.ptr(8468,8470,2),new P.ptr(8471,8472,1),new P.ptr(8478,8483,1),new P.ptr(8485,8489,2),new P.ptr(8494,8506,12),new P.ptr(8507,8512,5),new P.ptr(8513,8516,1),new P.ptr(8522,8525,1),new P.ptr(8527,8586,59),new P.ptr(8587,8592,5),new P.ptr(8593,8967,1),new P.ptr(8972,9000,1),new P.ptr(9003,9254,1),new P.ptr(9280,9290,1),new P.ptr(9372,9449,1),new P.ptr(9472,10087,1),new P.ptr(10132,10180,1),new P.ptr(10183,10213,1),new P.ptr(10224,10626,1),new P.ptr(10649,10711,1),new P.ptr(10716,10747,1),new P.ptr(10750,11123,1),new P.ptr(11126,11157,1),new P.ptr(11160,11193,1),new P.ptr(11197,11208,1),new P.ptr(11210,11218,1),new P.ptr(11244,11247,1),new P.ptr(11493,11498,1),new P.ptr(11904,11929,1),new P.ptr(11931,12019,1),new P.ptr(12032,12245,1),new P.ptr(12272,12283,1),new P.ptr(12292,12306,14),new P.ptr(12307,12320,13),new P.ptr(12342,12343,1),new P.ptr(12350,12351,1),new P.ptr(12443,12444,1),new P.ptr(12688,12689,1),new P.ptr(12694,12703,1),new P.ptr(12736,12771,1),new P.ptr(12800,12830,1),new P.ptr(12842,12871,1),new P.ptr(12880,12896,16),new P.ptr(12897,12927,1),new P.ptr(12938,12976,1),new P.ptr(12992,13054,1),new P.ptr(13056,13311,1),new P.ptr(19904,19967,1),new P.ptr(42128,42182,1),new P.ptr(42752,42774,1),new P.ptr(42784,42785,1),new P.ptr(42889,42890,1),new P.ptr(43048,43051,1),new P.ptr(43062,43065,1),new P.ptr(43639,43641,1),new P.ptr(43867,64297,20430),new P.ptr(64434,64449,1),new P.ptr(65020,65021,1),new P.ptr(65122,65124,2),new P.ptr(65125,65126,1),new P.ptr(65129,65284,155),new P.ptr(65291,65308,17),new P.ptr(65309,65310,1),new P.ptr(65342,65344,2),new P.ptr(65372,65374,2),new P.ptr(65504,65510,1),new P.ptr(65512,65518,1),new P.ptr(65532,65533,1)]),new IZ([new Q.ptr(65847,65855,1),new Q.ptr(65913,65929,1),new Q.ptr(65932,65934,1),new Q.ptr(65936,65947,1),new Q.ptr(65952,66000,48),new Q.ptr(66001,66044,1),new Q.ptr(67703,67704,1),new Q.ptr(68296,71487,3191),new Q.ptr(92988,92991,1),new Q.ptr(92997,113820,20823),new Q.ptr(118784,119029,1),new Q.ptr(119040,119078,1),new Q.ptr(119081,119140,1),new Q.ptr(119146,119148,1),new Q.ptr(119171,119172,1),new Q.ptr(119180,119209,1),new Q.ptr(119214,119272,1),new Q.ptr(119296,119361,1),new Q.ptr(119365,119552,187),new Q.ptr(119553,119638,1),new Q.ptr(120513,120539,26),new Q.ptr(120571,120597,26),new Q.ptr(120629,120655,26),new Q.ptr(120687,120713,26),new Q.ptr(120745,120771,26),new Q.ptr(120832,121343,1),new Q.ptr(121399,121402,1),new Q.ptr(121453,121460,1),new Q.ptr(121462,121475,1),new Q.ptr(121477,121478,1),new Q.ptr(126704,126705,1),new Q.ptr(126976,127019,1),new Q.ptr(127024,127123,1),new Q.ptr(127136,127150,1),new Q.ptr(127153,127167,1),new Q.ptr(127169,127183,1),new Q.ptr(127185,127221,1),new Q.ptr(127248,127278,1),new Q.ptr(127280,127339,1),new Q.ptr(127344,127404,1),new Q.ptr(127462,127490,1),new Q.ptr(127504,127547,1),new Q.ptr(127552,127560,1),new Q.ptr(127568,127569,1),new Q.ptr(127584,127589,1),new Q.ptr(127744,128724,1),new Q.ptr(128736,128748,1),new Q.ptr(128752,128760,1),new Q.ptr(128768,128883,1),new Q.ptr(128896,128980,1),new Q.ptr(129024,129035,1),new Q.ptr(129040,129095,1),new Q.ptr(129104,129113,1),new Q.ptr(129120,129159,1),new Q.ptr(129168,129197,1),new Q.ptr(129280,129291,1),new Q.ptr(129296,129342,1),new Q.ptr(129344,129356,1),new Q.ptr(129360,129387,1),new Q.ptr(129408,129431,1),new Q.ptr(129472,129488,16),new Q.ptr(129489,129510,1)]),10);BJ=new O.ptr(new IY([new P.ptr(36,162,126),new P.ptr(163,165,1),new P.ptr(1423,1547,124),new P.ptr(2546,2547,1),new P.ptr(2555,2801,246),new P.ptr(3065,3647,582),new P.ptr(6107,8352,2245),new P.ptr(8353,8383,1),new P.ptr(43064,65020,21956),new P.ptr(65129,65284,155),new P.ptr(65504,65505,1),new P.ptr(65509,65510,1)]),IZ.nil,2);BK=new O.ptr(new IY([new P.ptr(94,96,2),new P.ptr(168,175,7),new P.ptr(180,184,4),new P.ptr(706,709,1),new P.ptr(722,735,1),new P.ptr(741,747,1),new P.ptr(749,751,2),new P.ptr(752,767,1),new P.ptr(885,900,15),new P.ptr(901,8125,7224),new P.ptr(8127,8129,1),new P.ptr(8141,8143,1),new P.ptr(8157,8159,1),new P.ptr(8173,8175,1),new P.ptr(8189,8190,1),new P.ptr(12443,12444,1),new P.ptr(42752,42774,1),new P.ptr(42784,42785,1),new P.ptr(42889,42890,1),new P.ptr(43867,64434,20567),new P.ptr(64435,64449,1),new P.ptr(65342,65344,2),new P.ptr(65507,65507,1)]),new IZ([new Q.ptr(127995,127995,1),new Q.ptr(127996,127999,1)]),3);BL=new O.ptr(new IY([new P.ptr(43,60,17),new P.ptr(61,62,1),new P.ptr(124,126,2),new P.ptr(172,177,5),new P.ptr(215,247,32),new P.ptr(1014,1542,528),new P.ptr(1543,1544,1),new P.ptr(8260,8274,14),new P.ptr(8314,8316,1),new P.ptr(8330,8332,1),new P.ptr(8472,8512,40),new P.ptr(8513,8516,1),new P.ptr(8523,8592,69),new P.ptr(8593,8596,1),new P.ptr(8602,8603,1),new P.ptr(8608,8614,3),new P.ptr(8622,8654,32),new P.ptr(8655,8658,3),new P.ptr(8660,8692,32),new P.ptr(8693,8959,1),new P.ptr(8992,8993,1),new P.ptr(9084,9115,31),new P.ptr(9116,9139,1),new P.ptr(9180,9185,1),new P.ptr(9655,9665,10),new P.ptr(9720,9727,1),new P.ptr(9839,10176,337),new P.ptr(10177,10180,1),new P.ptr(10183,10213,1),new P.ptr(10224,10239,1),new P.ptr(10496,10626,1),new P.ptr(10649,10711,1),new P.ptr(10716,10747,1),new P.ptr(10750,11007,1),new P.ptr(11056,11076,1),new P.ptr(11079,11084,1),new P.ptr(64297,65122,825),new P.ptr(65124,65126,1),new P.ptr(65291,65308,17),new P.ptr(65309,65310,1),new P.ptr(65372,65374,2),new P.ptr(65506,65513,7),new P.ptr(65514,65516,1)]),new IZ([new Q.ptr(120513,120539,26),new Q.ptr(120571,120597,26),new Q.ptr(120629,120655,26),new Q.ptr(120687,120713,26),new Q.ptr(120745,120771,26),new Q.ptr(126704,126705,1)]),5);BM=new O.ptr(new IY([new P.ptr(166,169,3),new P.ptr(174,176,2),new P.ptr(1154,1421,267),new P.ptr(1422,1550,128),new P.ptr(1551,1758,207),new P.ptr(1769,1789,20),new P.ptr(1790,2038,248),new P.ptr(2554,2928,374),new P.ptr(3059,3064,1),new P.ptr(3066,3199,133),new P.ptr(3407,3449,42),new P.ptr(3841,3843,1),new P.ptr(3859,3861,2),new P.ptr(3862,3863,1),new P.ptr(3866,3871,1),new P.ptr(3892,3896,2),new P.ptr(4030,4037,1),new P.ptr(4039,4044,1),new P.ptr(4046,4047,1),new P.ptr(4053,4056,1),new P.ptr(4254,4255,1),new P.ptr(5008,5017,1),new P.ptr(6464,6622,158),new P.ptr(6623,6655,1),new P.ptr(7009,7018,1),new P.ptr(7028,7036,1),new P.ptr(8448,8449,1),new P.ptr(8451,8454,1),new P.ptr(8456,8457,1),new P.ptr(8468,8470,2),new P.ptr(8471,8478,7),new P.ptr(8479,8483,1),new P.ptr(8485,8489,2),new P.ptr(8494,8506,12),new P.ptr(8507,8522,15),new P.ptr(8524,8525,1),new P.ptr(8527,8586,59),new P.ptr(8587,8597,10),new P.ptr(8598,8601,1),new P.ptr(8604,8607,1),new P.ptr(8609,8610,1),new P.ptr(8612,8613,1),new P.ptr(8615,8621,1),new P.ptr(8623,8653,1),new P.ptr(8656,8657,1),new P.ptr(8659,8661,2),new P.ptr(8662,8691,1),new P.ptr(8960,8967,1),new P.ptr(8972,8991,1),new P.ptr(8994,9000,1),new P.ptr(9003,9083,1),new P.ptr(9085,9114,1),new P.ptr(9140,9179,1),new P.ptr(9186,9254,1),new P.ptr(9280,9290,1),new P.ptr(9372,9449,1),new P.ptr(9472,9654,1),new P.ptr(9656,9664,1),new P.ptr(9666,9719,1),new P.ptr(9728,9838,1),new P.ptr(9840,10087,1),new P.ptr(10132,10175,1),new P.ptr(10240,10495,1),new P.ptr(11008,11055,1),new P.ptr(11077,11078,1),new P.ptr(11085,11123,1),new P.ptr(11126,11157,1),new P.ptr(11160,11193,1),new P.ptr(11197,11208,1),new P.ptr(11210,11218,1),new P.ptr(11244,11247,1),new P.ptr(11493,11498,1),new P.ptr(11904,11929,1),new P.ptr(11931,12019,1),new P.ptr(12032,12245,1),new P.ptr(12272,12283,1),new P.ptr(12292,12306,14),new P.ptr(12307,12320,13),new P.ptr(12342,12343,1),new P.ptr(12350,12351,1),new P.ptr(12688,12689,1),new P.ptr(12694,12703,1),new P.ptr(12736,12771,1),new P.ptr(12800,12830,1),new P.ptr(12842,12871,1),new P.ptr(12880,12896,16),new P.ptr(12897,12927,1),new P.ptr(12938,12976,1),new P.ptr(12992,13054,1),new P.ptr(13056,13311,1),new P.ptr(19904,19967,1),new P.ptr(42128,42182,1),new P.ptr(43048,43051,1),new P.ptr(43062,43063,1),new P.ptr(43065,43639,574),new P.ptr(43640,43641,1),new P.ptr(65021,65508,487),new P.ptr(65512,65517,5),new P.ptr(65518,65532,14),new P.ptr(65533,65533,1)]),new IZ([new Q.ptr(65847,65847,1),new Q.ptr(65848,65855,1),new Q.ptr(65913,65929,1),new Q.ptr(65932,65934,1),new Q.ptr(65936,65947,1),new Q.ptr(65952,66000,48),new Q.ptr(66001,66044,1),new Q.ptr(67703,67704,1),new Q.ptr(68296,71487,3191),new Q.ptr(92988,92991,1),new Q.ptr(92997,113820,20823),new Q.ptr(118784,119029,1),new Q.ptr(119040,119078,1),new Q.ptr(119081,119140,1),new Q.ptr(119146,119148,1),new Q.ptr(119171,119172,1),new Q.ptr(119180,119209,1),new Q.ptr(119214,119272,1),new Q.ptr(119296,119361,1),new Q.ptr(119365,119552,187),new Q.ptr(119553,119638,1),new Q.ptr(120832,121343,1),new Q.ptr(121399,121402,1),new Q.ptr(121453,121460,1),new Q.ptr(121462,121475,1),new Q.ptr(121477,121478,1),new Q.ptr(126976,127019,1),new Q.ptr(127024,127123,1),new Q.ptr(127136,127150,1),new Q.ptr(127153,127167,1),new Q.ptr(127169,127183,1),new Q.ptr(127185,127221,1),new Q.ptr(127248,127278,1),new Q.ptr(127280,127339,1),new Q.ptr(127344,127404,1),new Q.ptr(127462,127490,1),new Q.ptr(127504,127547,1),new Q.ptr(127552,127560,1),new Q.ptr(127568,127569,1),new Q.ptr(127584,127589,1),new Q.ptr(127744,127994,1),new Q.ptr(128000,128724,1),new Q.ptr(128736,128748,1),new Q.ptr(128752,128760,1),new Q.ptr(128768,128883,1),new Q.ptr(128896,128980,1),new Q.ptr(129024,129035,1),new Q.ptr(129040,129095,1),new Q.ptr(129104,129113,1),new Q.ptr(129120,129159,1),new Q.ptr(129168,129197,1),new Q.ptr(129280,129291,1),new Q.ptr(129296,129342,1),new Q.ptr(129344,129356,1),new Q.ptr(129360,129387,1),new Q.ptr(129408,129431,1),new Q.ptr(129472,129488,16),new Q.ptr(129489,129510,1)]),2);BN=new O.ptr(new IY([new P.ptr(32,160,128),new P.ptr(5760,8192,2432),new P.ptr(8193,8202,1),new P.ptr(8232,8233,1),new P.ptr(8239,8287,48),new P.ptr(12288,12288,1)]),IZ.nil,1);BO=new O.ptr(new IY([new P.ptr(8232,8232,1)]),IZ.nil,0);BP=new O.ptr(new IY([new P.ptr(8233,8233,1)]),IZ.nil,0);BQ=new O.ptr(new IY([new P.ptr(32,160,128),new P.ptr(5760,8192,2432),new P.ptr(8193,8202,1),new P.ptr(8239,8287,48),new P.ptr(12288,12288,1)]),IZ.nil,1);$pkg.Cc=AI;$pkg.Cf=AJ;$pkg.Co=AK;$pkg.Cs=AL;$pkg.Digit=AX;$pkg.Nd=AX;$pkg.Letter=AM;$pkg.L=AM;$pkg.Lm=AO;$pkg.Lo=AP;$pkg.Ll=AN;$pkg.M=AS;$pkg.Mc=AT;$pkg.Me=AU;$pkg.Mn=AV;$pkg.Nl=AY;$pkg.No=AZ;$pkg.N=AW;$pkg.C=AH;$pkg.Pc=BB;$pkg.Pd=BC;$pkg.Pe=BD;$pkg.Pf=BE;$pkg.Pi=BF;$pkg.Po=BG;$pkg.Ps=BH;$pkg.P=BA;$pkg.Sc=BJ;$pkg.Sk=BK;$pkg.Sm=BL;$pkg.So=BM;$pkg.Z=BN;$pkg.S=BI;$pkg.PrintRanges=new JB([$pkg.L,$pkg.M,$pkg.N,$pkg.P,$pkg.S]);$pkg.Lt=AQ;$pkg.Lu=AR;$pkg.Zl=BO;$pkg.Zp=BP;$pkg.Zs=BQ;$pkg.Categories=$makeMap($String.keyFor,[{k:"C",v:$pkg.C},{k:"Cc",v:$pkg.Cc},{k:"Cf",v:$pkg.Cf},{k:"Co",v:$pkg.Co},{k:"Cs",v:$pkg.Cs},{k:"L",v:$pkg.L},{k:"Ll",v:$pkg.Ll},{k:"Lm",v:$pkg.Lm},{k:"Lo",v:$pkg.Lo},{k:"Lt",v:$pkg.Lt},{k:"Lu",v:$pkg.Lu},{k:"M",v:$pkg.M},{k:"Mc",v:$pkg.Mc},{k:"Me",v:$pkg.Me},{k:"Mn",v:$pkg.Mn},{k:"N",v:$pkg.N},{k:"Nd",v:$pkg.Nd},{k:"Nl",v:$pkg.Nl},{k:"No",v:$pkg.No},{k:"P",v:$pkg.P},{k:"Pc",v:$pkg.Pc},{k:"Pd",v:$pkg.Pd},{k:"Pe",v:$pkg.Pe},{k:"Pf",v:$pkg.Pf},{k:"Pi",v:$pkg.Pi},{k:"Po",v:$pkg.Po},{k:"Ps",v:$pkg.Ps},{k:"S",v:$pkg.S},{k:"Sc",v:$pkg.Sc},{k:"Sk",v:$pkg.Sk},{k:"Sm",v:$pkg.Sm},{k:"So",v:$pkg.So},{k:"Z",v:$pkg.Z},{k:"Zl",v:$pkg.Zl},{k:"Zp",v:$pkg.Zp},{k:"Zs",v:$pkg.Zs}]);BR=new O.ptr(new IY([]),new IZ([new Q.ptr(125184,125258,1),new Q.ptr(125264,125273,1),new Q.ptr(125278,125279,1)]),0);BS=new O.ptr(new IY([]),new IZ([new Q.ptr(71424,71449,1),new Q.ptr(71453,71467,1),new Q.ptr(71472,71487,1)]),0);BT=new O.ptr(new IY([]),new IZ([new Q.ptr(82944,83526,1)]),0);BU=new O.ptr(new IY([new P.ptr(1536,1540,1),new P.ptr(1542,1547,1),new P.ptr(1549,1562,1),new P.ptr(1564,1564,1),new P.ptr(1566,1566,1),new P.ptr(1568,1599,1),new P.ptr(1601,1610,1),new P.ptr(1622,1647,1),new P.ptr(1649,1756,1),new P.ptr(1758,1791,1),new P.ptr(1872,1919,1),new P.ptr(2208,2228,1),new P.ptr(2230,2237,1),new P.ptr(2260,2273,1),new P.ptr(2275,2303,1),new P.ptr(64336,64449,1),new P.ptr(64467,64829,1),new P.ptr(64848,64911,1),new P.ptr(64914,64967,1),new P.ptr(65008,65021,1),new P.ptr(65136,65140,1),new P.ptr(65142,65276,1)]),new IZ([new Q.ptr(69216,69246,1),new Q.ptr(126464,126467,1),new Q.ptr(126469,126495,1),new Q.ptr(126497,126498,1),new Q.ptr(126500,126500,1),new Q.ptr(126503,126503,1),new Q.ptr(126505,126514,1),new Q.ptr(126516,126519,1),new Q.ptr(126521,126521,1),new Q.ptr(126523,126523,1),new Q.ptr(126530,126530,1),new Q.ptr(126535,126535,1),new Q.ptr(126537,126537,1),new Q.ptr(126539,126539,1),new Q.ptr(126541,126543,1),new Q.ptr(126545,126546,1),new Q.ptr(126548,126548,1),new Q.ptr(126551,126551,1),new Q.ptr(126553,126553,1),new Q.ptr(126555,126555,1),new Q.ptr(126557,126557,1),new Q.ptr(126559,126559,1),new Q.ptr(126561,126562,1),new Q.ptr(126564,126564,1),new Q.ptr(126567,126570,1),new Q.ptr(126572,126578,1),new Q.ptr(126580,126583,1),new Q.ptr(126585,126588,1),new Q.ptr(126590,126590,1),new Q.ptr(126592,126601,1),new Q.ptr(126603,126619,1),new Q.ptr(126625,126627,1),new Q.ptr(126629,126633,1),new Q.ptr(126635,126651,1),new Q.ptr(126704,126705,1)]),0);BV=new O.ptr(new IY([new P.ptr(1329,1366,1),new P.ptr(1369,1375,1),new P.ptr(1377,1415,1),new P.ptr(1418,1418,1),new P.ptr(1421,1423,1),new P.ptr(64275,64279,1)]),IZ.nil,0);BW=new O.ptr(new IY([]),new IZ([new Q.ptr(68352,68405,1),new Q.ptr(68409,68415,1)]),0);BX=new O.ptr(new IY([new P.ptr(6912,6987,1),new P.ptr(6992,7036,1)]),IZ.nil,0);BY=new O.ptr(new IY([new P.ptr(42656,42743,1)]),new IZ([new Q.ptr(92160,92728,1)]),0);BZ=new O.ptr(new IY([]),new IZ([new Q.ptr(92880,92909,1),new Q.ptr(92912,92917,1)]),0);CA=new O.ptr(new IY([new P.ptr(7104,7155,1),new P.ptr(7164,7167,1)]),IZ.nil,0);CB=new O.ptr(new IY([new P.ptr(2432,2435,1),new P.ptr(2437,2444,1),new P.ptr(2447,2448,1),new P.ptr(2451,2472,1),new P.ptr(2474,2480,1),new P.ptr(2482,2482,1),new P.ptr(2486,2489,1),new P.ptr(2492,2500,1),new P.ptr(2503,2504,1),new P.ptr(2507,2510,1),new P.ptr(2519,2519,1),new P.ptr(2524,2525,1),new P.ptr(2527,2531,1),new P.ptr(2534,2557,1)]),IZ.nil,0);CC=new O.ptr(new IY([]),new IZ([new Q.ptr(72704,72712,1),new Q.ptr(72714,72758,1),new Q.ptr(72760,72773,1),new Q.ptr(72784,72812,1)]),0);CD=new O.ptr(new IY([new P.ptr(746,747,1),new P.ptr(12549,12590,1),new P.ptr(12704,12730,1)]),IZ.nil,0);CE=new O.ptr(new IY([]),new IZ([new Q.ptr(69632,69709,1),new Q.ptr(69714,69743,1),new Q.ptr(69759,69759,1)]),0);CF=new O.ptr(new IY([new P.ptr(10240,10495,1)]),IZ.nil,0);CG=new O.ptr(new IY([new P.ptr(6656,6683,1),new P.ptr(6686,6687,1)]),IZ.nil,0);CH=new O.ptr(new IY([new P.ptr(5952,5971,1)]),IZ.nil,0);CI=new O.ptr(new IY([new P.ptr(5120,5759,1),new P.ptr(6320,6389,1)]),IZ.nil,0);CJ=new O.ptr(new IY([]),new IZ([new Q.ptr(66208,66256,1)]),0);CK=new O.ptr(new IY([]),new IZ([new Q.ptr(66864,66915,1),new Q.ptr(66927,66927,1)]),0);CL=new O.ptr(new IY([]),new IZ([new Q.ptr(69888,69940,1),new Q.ptr(69942,69955,1)]),0);CM=new O.ptr(new IY([new P.ptr(43520,43574,1),new P.ptr(43584,43597,1),new P.ptr(43600,43609,1),new P.ptr(43612,43615,1)]),IZ.nil,0);CN=new O.ptr(new IY([new P.ptr(5024,5109,1),new P.ptr(5112,5117,1),new P.ptr(43888,43967,1)]),IZ.nil,0);CO=new O.ptr(new IY([new P.ptr(0,64,1),new P.ptr(91,96,1),new P.ptr(123,169,1),new P.ptr(171,185,1),new P.ptr(187,191,1),new P.ptr(215,215,1),new P.ptr(247,247,1),new P.ptr(697,735,1),new P.ptr(741,745,1),new P.ptr(748,767,1),new P.ptr(884,884,1),new P.ptr(894,894,1),new P.ptr(901,901,1),new P.ptr(903,903,1),new P.ptr(1417,1417,1),new P.ptr(1541,1541,1),new P.ptr(1548,1548,1),new P.ptr(1563,1563,1),new P.ptr(1567,1567,1),new P.ptr(1600,1600,1),new P.ptr(1757,1757,1),new P.ptr(2274,2274,1),new P.ptr(2404,2405,1),new P.ptr(3647,3647,1),new P.ptr(4053,4056,1),new P.ptr(4347,4347,1),new P.ptr(5867,5869,1),new P.ptr(5941,5942,1),new P.ptr(6146,6147,1),new P.ptr(6149,6149,1),new P.ptr(7379,7379,1),new P.ptr(7393,7393,1),new P.ptr(7401,7404,1),new P.ptr(7406,7411,1),new P.ptr(7413,7415,1),new P.ptr(8192,8203,1),new P.ptr(8206,8292,1),new P.ptr(8294,8304,1),new P.ptr(8308,8318,1),new P.ptr(8320,8334,1),new P.ptr(8352,8383,1),new P.ptr(8448,8485,1),new P.ptr(8487,8489,1),new P.ptr(8492,8497,1),new P.ptr(8499,8525,1),new P.ptr(8527,8543,1),new P.ptr(8585,8587,1),new P.ptr(8592,9254,1),new P.ptr(9280,9290,1),new P.ptr(9312,10239,1),new P.ptr(10496,11123,1),new P.ptr(11126,11157,1),new P.ptr(11160,11193,1),new P.ptr(11197,11208,1),new P.ptr(11210,11218,1),new P.ptr(11244,11247,1),new P.ptr(11776,11849,1),new P.ptr(12272,12283,1),new P.ptr(12288,12292,1),new P.ptr(12294,12294,1),new P.ptr(12296,12320,1),new P.ptr(12336,12343,1),new P.ptr(12348,12351,1),new P.ptr(12443,12444,1),new P.ptr(12448,12448,1),new P.ptr(12539,12540,1),new P.ptr(12688,12703,1),new P.ptr(12736,12771,1),new P.ptr(12832,12895,1),new P.ptr(12927,13007,1),new P.ptr(13144,13311,1),new P.ptr(19904,19967,1),new P.ptr(42752,42785,1),new P.ptr(42888,42890,1),new P.ptr(43056,43065,1),new P.ptr(43310,43310,1),new P.ptr(43471,43471,1),new P.ptr(43867,43867,1),new P.ptr(64830,64831,1),new P.ptr(65040,65049,1),new P.ptr(65072,65106,1),new P.ptr(65108,65126,1),new P.ptr(65128,65131,1),new P.ptr(65279,65279,1),new P.ptr(65281,65312,1),new P.ptr(65339,65344,1),new P.ptr(65371,65381,1),new P.ptr(65392,65392,1),new P.ptr(65438,65439,1),new P.ptr(65504,65510,1),new P.ptr(65512,65518,1),new P.ptr(65529,65533,1)]),new IZ([new Q.ptr(65792,65794,1),new Q.ptr(65799,65843,1),new Q.ptr(65847,65855,1),new Q.ptr(65936,65947,1),new Q.ptr(66000,66044,1),new Q.ptr(66273,66299,1),new Q.ptr(113824,113827,1),new Q.ptr(118784,119029,1),new Q.ptr(119040,119078,1),new Q.ptr(119081,119142,1),new Q.ptr(119146,119162,1),new Q.ptr(119171,119172,1),new Q.ptr(119180,119209,1),new Q.ptr(119214,119272,1),new Q.ptr(119552,119638,1),new Q.ptr(119648,119665,1),new Q.ptr(119808,119892,1),new Q.ptr(119894,119964,1),new Q.ptr(119966,119967,1),new Q.ptr(119970,119970,1),new Q.ptr(119973,119974,1),new Q.ptr(119977,119980,1),new Q.ptr(119982,119993,1),new Q.ptr(119995,119995,1),new Q.ptr(119997,120003,1),new Q.ptr(120005,120069,1),new Q.ptr(120071,120074,1),new Q.ptr(120077,120084,1),new Q.ptr(120086,120092,1),new Q.ptr(120094,120121,1),new Q.ptr(120123,120126,1),new Q.ptr(120128,120132,1),new Q.ptr(120134,120134,1),new Q.ptr(120138,120144,1),new Q.ptr(120146,120485,1),new Q.ptr(120488,120779,1),new Q.ptr(120782,120831,1),new Q.ptr(126976,127019,1),new Q.ptr(127024,127123,1),new Q.ptr(127136,127150,1),new Q.ptr(127153,127167,1),new Q.ptr(127169,127183,1),new Q.ptr(127185,127221,1),new Q.ptr(127232,127244,1),new Q.ptr(127248,127278,1),new Q.ptr(127280,127339,1),new Q.ptr(127344,127404,1),new Q.ptr(127462,127487,1),new Q.ptr(127489,127490,1),new Q.ptr(127504,127547,1),new Q.ptr(127552,127560,1),new Q.ptr(127568,127569,1),new Q.ptr(127584,127589,1),new Q.ptr(127744,128724,1),new Q.ptr(128736,128748,1),new Q.ptr(128752,128760,1),new Q.ptr(128768,128883,1),new Q.ptr(128896,128980,1),new Q.ptr(129024,129035,1),new Q.ptr(129040,129095,1),new Q.ptr(129104,129113,1),new Q.ptr(129120,129159,1),new Q.ptr(129168,129197,1),new Q.ptr(129280,129291,1),new Q.ptr(129296,129342,1),new Q.ptr(129344,129356,1),new Q.ptr(129360,129387,1),new Q.ptr(129408,129431,1),new Q.ptr(129472,129472,1),new Q.ptr(129488,129510,1),new Q.ptr(917505,917505,1),new Q.ptr(917536,917631,1)]),7);CP=new O.ptr(new IY([new P.ptr(994,1007,1),new P.ptr(11392,11507,1),new P.ptr(11513,11519,1)]),IZ.nil,0);CQ=new O.ptr(new IY([]),new IZ([new Q.ptr(73728,74649,1),new Q.ptr(74752,74862,1),new Q.ptr(74864,74868,1),new Q.ptr(74880,75075,1)]),0);CR=new O.ptr(new IY([]),new IZ([new Q.ptr(67584,67589,1),new Q.ptr(67592,67592,1),new Q.ptr(67594,67637,1),new Q.ptr(67639,67640,1),new Q.ptr(67644,67644,1),new Q.ptr(67647,67647,1)]),0);CS=new O.ptr(new IY([new P.ptr(1024,1156,1),new P.ptr(1159,1327,1),new P.ptr(7296,7304,1),new P.ptr(7467,7467,1),new P.ptr(7544,7544,1),new P.ptr(11744,11775,1),new P.ptr(42560,42655,1),new P.ptr(65070,65071,1)]),IZ.nil,0);CT=new O.ptr(new IY([]),new IZ([new Q.ptr(66560,66639,1)]),0);CU=new O.ptr(new IY([new P.ptr(2304,2384,1),new P.ptr(2387,2403,1),new P.ptr(2406,2431,1),new P.ptr(43232,43261,1)]),IZ.nil,0);CV=new O.ptr(new IY([]),new IZ([new Q.ptr(113664,113770,1),new Q.ptr(113776,113788,1),new Q.ptr(113792,113800,1),new Q.ptr(113808,113817,1),new Q.ptr(113820,113823,1)]),0);CW=new O.ptr(new IY([]),new IZ([new Q.ptr(77824,78894,1)]),0);CX=new O.ptr(new IY([]),new IZ([new Q.ptr(66816,66855,1)]),0);CY=new O.ptr(new IY([new P.ptr(4608,4680,1),new P.ptr(4682,4685,1),new P.ptr(4688,4694,1),new P.ptr(4696,4696,1),new P.ptr(4698,4701,1),new P.ptr(4704,4744,1),new P.ptr(4746,4749,1),new P.ptr(4752,4784,1),new P.ptr(4786,4789,1),new P.ptr(4792,4798,1),new P.ptr(4800,4800,1),new P.ptr(4802,4805,1),new P.ptr(4808,4822,1),new P.ptr(4824,4880,1),new P.ptr(4882,4885,1),new P.ptr(4888,4954,1),new P.ptr(4957,4988,1),new P.ptr(4992,5017,1),new P.ptr(11648,11670,1),new P.ptr(11680,11686,1),new P.ptr(11688,11694,1),new P.ptr(11696,11702,1),new P.ptr(11704,11710,1),new P.ptr(11712,11718,1),new P.ptr(11720,11726,1),new P.ptr(11728,11734,1),new P.ptr(11736,11742,1),new P.ptr(43777,43782,1),new P.ptr(43785,43790,1),new P.ptr(43793,43798,1),new P.ptr(43808,43814,1),new P.ptr(43816,43822,1)]),IZ.nil,0);CZ=new O.ptr(new IY([new P.ptr(4256,4293,1),new P.ptr(4295,4295,1),new P.ptr(4301,4301,1),new P.ptr(4304,4346,1),new P.ptr(4348,4351,1),new P.ptr(11520,11557,1),new P.ptr(11559,11559,1),new P.ptr(11565,11565,1)]),IZ.nil,0);DA=new O.ptr(new IY([new P.ptr(11264,11310,1),new P.ptr(11312,11358,1)]),new IZ([new Q.ptr(122880,122886,1),new Q.ptr(122888,122904,1),new Q.ptr(122907,122913,1),new Q.ptr(122915,122916,1),new Q.ptr(122918,122922,1)]),0);DB=new O.ptr(new IY([]),new IZ([new Q.ptr(66352,66378,1)]),0);DC=new O.ptr(new IY([]),new IZ([new Q.ptr(70400,70403,1),new Q.ptr(70405,70412,1),new Q.ptr(70415,70416,1),new Q.ptr(70419,70440,1),new Q.ptr(70442,70448,1),new Q.ptr(70450,70451,1),new Q.ptr(70453,70457,1),new Q.ptr(70460,70468,1),new Q.ptr(70471,70472,1),new Q.ptr(70475,70477,1),new Q.ptr(70480,70480,1),new Q.ptr(70487,70487,1),new Q.ptr(70493,70499,1),new Q.ptr(70502,70508,1),new Q.ptr(70512,70516,1)]),0);DD=new O.ptr(new IY([new P.ptr(880,883,1),new P.ptr(885,887,1),new P.ptr(890,893,1),new P.ptr(895,895,1),new P.ptr(900,900,1),new P.ptr(902,902,1),new P.ptr(904,906,1),new P.ptr(908,908,1),new P.ptr(910,929,1),new P.ptr(931,993,1),new P.ptr(1008,1023,1),new P.ptr(7462,7466,1),new P.ptr(7517,7521,1),new P.ptr(7526,7530,1),new P.ptr(7615,7615,1),new P.ptr(7936,7957,1),new P.ptr(7960,7965,1),new P.ptr(7968,8005,1),new P.ptr(8008,8013,1),new P.ptr(8016,8023,1),new P.ptr(8025,8025,1),new P.ptr(8027,8027,1),new P.ptr(8029,8029,1),new P.ptr(8031,8061,1),new P.ptr(8064,8116,1),new P.ptr(8118,8132,1),new P.ptr(8134,8147,1),new P.ptr(8150,8155,1),new P.ptr(8157,8175,1),new P.ptr(8178,8180,1),new P.ptr(8182,8190,1),new P.ptr(8486,8486,1),new P.ptr(43877,43877,1)]),new IZ([new Q.ptr(65856,65934,1),new Q.ptr(65952,65952,1),new Q.ptr(119296,119365,1)]),0);DE=new O.ptr(new IY([new P.ptr(2689,2691,1),new P.ptr(2693,2701,1),new P.ptr(2703,2705,1),new P.ptr(2707,2728,1),new P.ptr(2730,2736,1),new P.ptr(2738,2739,1),new P.ptr(2741,2745,1),new P.ptr(2748,2757,1),new P.ptr(2759,2761,1),new P.ptr(2763,2765,1),new P.ptr(2768,2768,1),new P.ptr(2784,2787,1),new P.ptr(2790,2801,1),new P.ptr(2809,2815,1)]),IZ.nil,0);DF=new O.ptr(new IY([new P.ptr(2561,2563,1),new P.ptr(2565,2570,1),new P.ptr(2575,2576,1),new P.ptr(2579,2600,1),new P.ptr(2602,2608,1),new P.ptr(2610,2611,1),new P.ptr(2613,2614,1),new P.ptr(2616,2617,1),new P.ptr(2620,2620,1),new P.ptr(2622,2626,1),new P.ptr(2631,2632,1),new P.ptr(2635,2637,1),new P.ptr(2641,2641,1),new P.ptr(2649,2652,1),new P.ptr(2654,2654,1),new P.ptr(2662,2677,1)]),IZ.nil,0);DG=new O.ptr(new IY([new P.ptr(11904,11929,1),new P.ptr(11931,12019,1),new P.ptr(12032,12245,1),new P.ptr(12293,12293,1),new P.ptr(12295,12295,1),new P.ptr(12321,12329,1),new P.ptr(12344,12347,1),new P.ptr(13312,19893,1),new P.ptr(19968,40938,1),new P.ptr(63744,64109,1),new P.ptr(64112,64217,1)]),new IZ([new Q.ptr(131072,173782,1),new Q.ptr(173824,177972,1),new Q.ptr(177984,178205,1),new Q.ptr(178208,183969,1),new Q.ptr(183984,191456,1),new Q.ptr(194560,195101,1)]),0);DH=new O.ptr(new IY([new P.ptr(4352,4607,1),new P.ptr(12334,12335,1),new P.ptr(12593,12686,1),new P.ptr(12800,12830,1),new P.ptr(12896,12926,1),new P.ptr(43360,43388,1),new P.ptr(44032,55203,1),new P.ptr(55216,55238,1),new P.ptr(55243,55291,1),new P.ptr(65440,65470,1),new P.ptr(65474,65479,1),new P.ptr(65482,65487,1),new P.ptr(65490,65495,1),new P.ptr(65498,65500,1)]),IZ.nil,0);DI=new O.ptr(new IY([new P.ptr(5920,5940,1)]),IZ.nil,0);DJ=new O.ptr(new IY([]),new IZ([new Q.ptr(67808,67826,1),new Q.ptr(67828,67829,1),new Q.ptr(67835,67839,1)]),0);DK=new O.ptr(new IY([new P.ptr(1425,1479,1),new P.ptr(1488,1514,1),new P.ptr(1520,1524,1),new P.ptr(64285,64310,1),new P.ptr(64312,64316,1),new P.ptr(64318,64318,1),new P.ptr(64320,64321,1),new P.ptr(64323,64324,1),new P.ptr(64326,64335,1)]),IZ.nil,0);DL=new O.ptr(new IY([new P.ptr(12353,12438,1),new P.ptr(12445,12447,1)]),new IZ([new Q.ptr(110593,110878,1),new Q.ptr(127488,127488,1)]),0);DM=new O.ptr(new IY([]),new IZ([new Q.ptr(67648,67669,1),new Q.ptr(67671,67679,1)]),0);DN=new O.ptr(new IY([new P.ptr(768,879,1),new P.ptr(1157,1158,1),new P.ptr(1611,1621,1),new P.ptr(1648,1648,1),new P.ptr(2385,2386,1),new P.ptr(6832,6846,1),new P.ptr(7376,7378,1),new P.ptr(7380,7392,1),new P.ptr(7394,7400,1),new P.ptr(7405,7405,1),new P.ptr(7412,7412,1),new P.ptr(7416,7417,1),new P.ptr(7616,7673,1),new P.ptr(7675,7679,1),new P.ptr(8204,8205,1),new P.ptr(8400,8432,1),new P.ptr(12330,12333,1),new P.ptr(12441,12442,1),new P.ptr(65024,65039,1),new P.ptr(65056,65069,1)]),new IZ([new Q.ptr(66045,66045,1),new Q.ptr(66272,66272,1),new Q.ptr(119143,119145,1),new Q.ptr(119163,119170,1),new Q.ptr(119173,119179,1),new Q.ptr(119210,119213,1),new Q.ptr(917760,917999,1)]),0);DO=new O.ptr(new IY([]),new IZ([new Q.ptr(68448,68466,1),new Q.ptr(68472,68479,1)]),0);DP=new O.ptr(new IY([]),new IZ([new Q.ptr(68416,68437,1),new Q.ptr(68440,68447,1)]),0);DQ=new O.ptr(new IY([new P.ptr(43392,43469,1),new P.ptr(43472,43481,1),new P.ptr(43486,43487,1)]),IZ.nil,0);DR=new O.ptr(new IY([]),new IZ([new Q.ptr(69760,69825,1)]),0);DS=new O.ptr(new IY([new P.ptr(3200,3203,1),new P.ptr(3205,3212,1),new P.ptr(3214,3216,1),new P.ptr(3218,3240,1),new P.ptr(3242,3251,1),new P.ptr(3253,3257,1),new P.ptr(3260,3268,1),new P.ptr(3270,3272,1),new P.ptr(3274,3277,1),new P.ptr(3285,3286,1),new P.ptr(3294,3294,1),new P.ptr(3296,3299,1),new P.ptr(3302,3311,1),new P.ptr(3313,3314,1)]),IZ.nil,0);DT=new O.ptr(new IY([new P.ptr(12449,12538,1),new P.ptr(12541,12543,1),new P.ptr(12784,12799,1),new P.ptr(13008,13054,1),new P.ptr(13056,13143,1),new P.ptr(65382,65391,1),new P.ptr(65393,65437,1)]),new IZ([new Q.ptr(110592,110592,1)]),0);DU=new O.ptr(new IY([new P.ptr(43264,43309,1),new P.ptr(43311,43311,1)]),IZ.nil,0);DV=new O.ptr(new IY([]),new IZ([new Q.ptr(68096,68099,1),new Q.ptr(68101,68102,1),new Q.ptr(68108,68115,1),new Q.ptr(68117,68119,1),new Q.ptr(68121,68147,1),new Q.ptr(68152,68154,1),new Q.ptr(68159,68167,1),new Q.ptr(68176,68184,1)]),0);DW=new O.ptr(new IY([new P.ptr(6016,6109,1),new P.ptr(6112,6121,1),new P.ptr(6128,6137,1),new P.ptr(6624,6655,1)]),IZ.nil,0);DX=new O.ptr(new IY([]),new IZ([new Q.ptr(70144,70161,1),new Q.ptr(70163,70206,1)]),0);DY=new O.ptr(new IY([]),new IZ([new Q.ptr(70320,70378,1),new Q.ptr(70384,70393,1)]),0);DZ=new O.ptr(new IY([new P.ptr(3713,3714,1),new P.ptr(3716,3716,1),new P.ptr(3719,3720,1),new P.ptr(3722,3722,1),new P.ptr(3725,3725,1),new P.ptr(3732,3735,1),new P.ptr(3737,3743,1),new P.ptr(3745,3747,1),new P.ptr(3749,3749,1),new P.ptr(3751,3751,1),new P.ptr(3754,3755,1),new P.ptr(3757,3769,1),new P.ptr(3771,3773,1),new P.ptr(3776,3780,1),new P.ptr(3782,3782,1),new P.ptr(3784,3789,1),new P.ptr(3792,3801,1),new P.ptr(3804,3807,1)]),IZ.nil,0);EA=new O.ptr(new IY([new P.ptr(65,90,1),new P.ptr(97,122,1),new P.ptr(170,170,1),new P.ptr(186,186,1),new P.ptr(192,214,1),new P.ptr(216,246,1),new P.ptr(248,696,1),new P.ptr(736,740,1),new P.ptr(7424,7461,1),new P.ptr(7468,7516,1),new P.ptr(7522,7525,1),new P.ptr(7531,7543,1),new P.ptr(7545,7614,1),new P.ptr(7680,7935,1),new P.ptr(8305,8305,1),new P.ptr(8319,8319,1),new P.ptr(8336,8348,1),new P.ptr(8490,8491,1),new P.ptr(8498,8498,1),new P.ptr(8526,8526,1),new P.ptr(8544,8584,1),new P.ptr(11360,11391,1),new P.ptr(42786,42887,1),new P.ptr(42891,42926,1),new P.ptr(42928,42935,1),new P.ptr(42999,43007,1),new P.ptr(43824,43866,1),new P.ptr(43868,43876,1),new P.ptr(64256,64262,1),new P.ptr(65313,65338,1),new P.ptr(65345,65370,1)]),IZ.nil,6);EB=new O.ptr(new IY([new P.ptr(7168,7223,1),new P.ptr(7227,7241,1),new P.ptr(7245,7247,1)]),IZ.nil,0);EC=new O.ptr(new IY([new P.ptr(6400,6430,1),new P.ptr(6432,6443,1),new P.ptr(6448,6459,1),new P.ptr(6464,6464,1),new P.ptr(6468,6479,1)]),IZ.nil,0);ED=new O.ptr(new IY([]),new IZ([new Q.ptr(67072,67382,1),new Q.ptr(67392,67413,1),new Q.ptr(67424,67431,1)]),0);EE=new O.ptr(new IY([]),new IZ([new Q.ptr(65536,65547,1),new Q.ptr(65549,65574,1),new Q.ptr(65576,65594,1),new Q.ptr(65596,65597,1),new Q.ptr(65599,65613,1),new Q.ptr(65616,65629,1),new Q.ptr(65664,65786,1)]),0);EF=new O.ptr(new IY([new P.ptr(42192,42239,1)]),IZ.nil,0);EG=new O.ptr(new IY([]),new IZ([new Q.ptr(66176,66204,1)]),0);EH=new O.ptr(new IY([]),new IZ([new Q.ptr(67872,67897,1),new Q.ptr(67903,67903,1)]),0);EI=new O.ptr(new IY([]),new IZ([new Q.ptr(69968,70006,1)]),0);EJ=new O.ptr(new IY([new P.ptr(3328,3331,1),new P.ptr(3333,3340,1),new P.ptr(3342,3344,1),new P.ptr(3346,3396,1),new P.ptr(3398,3400,1),new P.ptr(3402,3407,1),new P.ptr(3412,3427,1),new P.ptr(3430,3455,1)]),IZ.nil,0);EK=new O.ptr(new IY([new P.ptr(2112,2139,1),new P.ptr(2142,2142,1)]),IZ.nil,0);EL=new O.ptr(new IY([]),new IZ([new Q.ptr(68288,68326,1),new Q.ptr(68331,68342,1)]),0);EM=new O.ptr(new IY([]),new IZ([new Q.ptr(72816,72847,1),new Q.ptr(72850,72871,1),new Q.ptr(72873,72886,1)]),0);EN=new O.ptr(new IY([]),new IZ([new Q.ptr(72960,72966,1),new Q.ptr(72968,72969,1),new Q.ptr(72971,73014,1),new Q.ptr(73018,73018,1),new Q.ptr(73020,73021,1),new Q.ptr(73023,73031,1),new Q.ptr(73040,73049,1)]),0);EO=new O.ptr(new IY([new P.ptr(43744,43766,1),new P.ptr(43968,44013,1),new P.ptr(44016,44025,1)]),IZ.nil,0);EP=new O.ptr(new IY([]),new IZ([new Q.ptr(124928,125124,1),new Q.ptr(125127,125142,1)]),0);EQ=new O.ptr(new IY([]),new IZ([new Q.ptr(68000,68023,1),new Q.ptr(68028,68047,1),new Q.ptr(68050,68095,1)]),0);ER=new O.ptr(new IY([]),new IZ([new Q.ptr(67968,67999,1)]),0);ES=new O.ptr(new IY([]),new IZ([new Q.ptr(93952,94020,1),new Q.ptr(94032,94078,1),new Q.ptr(94095,94111,1)]),0);ET=new O.ptr(new IY([]),new IZ([new Q.ptr(71168,71236,1),new Q.ptr(71248,71257,1)]),0);EU=new O.ptr(new IY([new P.ptr(6144,6145,1),new P.ptr(6148,6148,1),new P.ptr(6150,6158,1),new P.ptr(6160,6169,1),new P.ptr(6176,6263,1),new P.ptr(6272,6314,1)]),new IZ([new Q.ptr(71264,71276,1)]),0);EV=new O.ptr(new IY([]),new IZ([new Q.ptr(92736,92766,1),new Q.ptr(92768,92777,1),new Q.ptr(92782,92783,1)]),0);EW=new O.ptr(new IY([]),new IZ([new Q.ptr(70272,70278,1),new Q.ptr(70280,70280,1),new Q.ptr(70282,70285,1),new Q.ptr(70287,70301,1),new Q.ptr(70303,70313,1)]),0);EX=new O.ptr(new IY([new P.ptr(4096,4255,1),new P.ptr(43488,43518,1),new P.ptr(43616,43647,1)]),IZ.nil,0);EY=new O.ptr(new IY([]),new IZ([new Q.ptr(67712,67742,1),new Q.ptr(67751,67759,1)]),0);EZ=new O.ptr(new IY([new P.ptr(6528,6571,1),new P.ptr(6576,6601,1),new P.ptr(6608,6618,1),new P.ptr(6622,6623,1)]),IZ.nil,0);FA=new O.ptr(new IY([]),new IZ([new Q.ptr(70656,70745,1),new Q.ptr(70747,70747,1),new Q.ptr(70749,70749,1)]),0);FB=new O.ptr(new IY([new P.ptr(1984,2042,1)]),IZ.nil,0);FC=new O.ptr(new IY([]),new IZ([new Q.ptr(94177,94177,1),new Q.ptr(110960,111355,1)]),0);FD=new O.ptr(new IY([new P.ptr(5760,5788,1)]),IZ.nil,0);FE=new O.ptr(new IY([new P.ptr(7248,7295,1)]),IZ.nil,0);FF=new O.ptr(new IY([]),new IZ([new Q.ptr(68736,68786,1),new Q.ptr(68800,68850,1),new Q.ptr(68858,68863,1)]),0);FG=new O.ptr(new IY([]),new IZ([new Q.ptr(66304,66339,1),new Q.ptr(66349,66351,1)]),0);FH=new O.ptr(new IY([]),new IZ([new Q.ptr(68224,68255,1)]),0);FI=new O.ptr(new IY([]),new IZ([new Q.ptr(66384,66426,1)]),0);FJ=new O.ptr(new IY([]),new IZ([new Q.ptr(66464,66499,1),new Q.ptr(66504,66517,1)]),0);FK=new O.ptr(new IY([]),new IZ([new Q.ptr(68192,68223,1)]),0);FL=new O.ptr(new IY([]),new IZ([new Q.ptr(68608,68680,1)]),0);FM=new O.ptr(new IY([new P.ptr(2817,2819,1),new P.ptr(2821,2828,1),new P.ptr(2831,2832,1),new P.ptr(2835,2856,1),new P.ptr(2858,2864,1),new P.ptr(2866,2867,1),new P.ptr(2869,2873,1),new P.ptr(2876,2884,1),new P.ptr(2887,2888,1),new P.ptr(2891,2893,1),new P.ptr(2902,2903,1),new P.ptr(2908,2909,1),new P.ptr(2911,2915,1),new P.ptr(2918,2935,1)]),IZ.nil,0);FN=new O.ptr(new IY([]),new IZ([new Q.ptr(66736,66771,1),new Q.ptr(66776,66811,1)]),0);FO=new O.ptr(new IY([]),new IZ([new Q.ptr(66688,66717,1),new Q.ptr(66720,66729,1)]),0);FP=new O.ptr(new IY([]),new IZ([new Q.ptr(92928,92997,1),new Q.ptr(93008,93017,1),new Q.ptr(93019,93025,1),new Q.ptr(93027,93047,1),new Q.ptr(93053,93071,1)]),0);FQ=new O.ptr(new IY([]),new IZ([new Q.ptr(67680,67711,1)]),0);FR=new O.ptr(new IY([]),new IZ([new Q.ptr(72384,72440,1)]),0);FS=new O.ptr(new IY([new P.ptr(43072,43127,1)]),IZ.nil,0);FT=new O.ptr(new IY([]),new IZ([new Q.ptr(67840,67867,1),new Q.ptr(67871,67871,1)]),0);FU=new O.ptr(new IY([]),new IZ([new Q.ptr(68480,68497,1),new Q.ptr(68505,68508,1),new Q.ptr(68521,68527,1)]),0);FV=new O.ptr(new IY([new P.ptr(43312,43347,1),new P.ptr(43359,43359,1)]),IZ.nil,0);FW=new O.ptr(new IY([new P.ptr(5792,5866,1),new P.ptr(5870,5880,1)]),IZ.nil,0);FX=new O.ptr(new IY([new P.ptr(2048,2093,1),new P.ptr(2096,2110,1)]),IZ.nil,0);FY=new O.ptr(new IY([new P.ptr(43136,43205,1),new P.ptr(43214,43225,1)]),IZ.nil,0);FZ=new O.ptr(new IY([]),new IZ([new Q.ptr(70016,70093,1),new Q.ptr(70096,70111,1)]),0);GA=new O.ptr(new IY([]),new IZ([new Q.ptr(66640,66687,1)]),0);GB=new O.ptr(new IY([]),new IZ([new Q.ptr(71040,71093,1),new Q.ptr(71096,71133,1)]),0);GC=new O.ptr(new IY([]),new IZ([new Q.ptr(120832,121483,1),new Q.ptr(121499,121503,1),new Q.ptr(121505,121519,1)]),0);GD=new O.ptr(new IY([new P.ptr(3458,3459,1),new P.ptr(3461,3478,1),new P.ptr(3482,3505,1),new P.ptr(3507,3515,1),new P.ptr(3517,3517,1),new P.ptr(3520,3526,1),new P.ptr(3530,3530,1),new P.ptr(3535,3540,1),new P.ptr(3542,3542,1),new P.ptr(3544,3551,1),new P.ptr(3558,3567,1),new P.ptr(3570,3572,1)]),new IZ([new Q.ptr(70113,70132,1)]),0);GE=new O.ptr(new IY([]),new IZ([new Q.ptr(69840,69864,1),new Q.ptr(69872,69881,1)]),0);GF=new O.ptr(new IY([]),new IZ([new Q.ptr(72272,72323,1),new Q.ptr(72326,72348,1),new Q.ptr(72350,72354,1)]),0);GG=new O.ptr(new IY([new P.ptr(7040,7103,1),new P.ptr(7360,7367,1)]),IZ.nil,0);GH=new O.ptr(new IY([new P.ptr(43008,43051,1)]),IZ.nil,0);GI=new O.ptr(new IY([new P.ptr(1792,1805,1),new P.ptr(1807,1866,1),new P.ptr(1869,1871,1),new P.ptr(2144,2154,1)]),IZ.nil,0);GJ=new O.ptr(new IY([new P.ptr(5888,5900,1),new P.ptr(5902,5908,1)]),IZ.nil,0);GK=new O.ptr(new IY([new P.ptr(5984,5996,1),new P.ptr(5998,6000,1),new P.ptr(6002,6003,1)]),IZ.nil,0);GL=new O.ptr(new IY([new P.ptr(6480,6509,1),new P.ptr(6512,6516,1)]),IZ.nil,0);GM=new O.ptr(new IY([new P.ptr(6688,6750,1),new P.ptr(6752,6780,1),new P.ptr(6783,6793,1),new P.ptr(6800,6809,1),new P.ptr(6816,6829,1)]),IZ.nil,0);GN=new O.ptr(new IY([new P.ptr(43648,43714,1),new P.ptr(43739,43743,1)]),IZ.nil,0);GO=new O.ptr(new IY([]),new IZ([new Q.ptr(71296,71351,1),new Q.ptr(71360,71369,1)]),0);GP=new O.ptr(new IY([new P.ptr(2946,2947,1),new P.ptr(2949,2954,1),new P.ptr(2958,2960,1),new P.ptr(2962,2965,1),new P.ptr(2969,2970,1),new P.ptr(2972,2972,1),new P.ptr(2974,2975,1),new P.ptr(2979,2980,1),new P.ptr(2984,2986,1),new P.ptr(2990,3001,1),new P.ptr(3006,3010,1),new P.ptr(3014,3016,1),new P.ptr(3018,3021,1),new P.ptr(3024,3024,1),new P.ptr(3031,3031,1),new P.ptr(3046,3066,1)]),IZ.nil,0);GQ=new O.ptr(new IY([]),new IZ([new Q.ptr(94176,94176,1),new Q.ptr(94208,100332,1),new Q.ptr(100352,101106,1)]),0);GR=new O.ptr(new IY([new P.ptr(3072,3075,1),new P.ptr(3077,3084,1),new P.ptr(3086,3088,1),new P.ptr(3090,3112,1),new P.ptr(3114,3129,1),new P.ptr(3133,3140,1),new P.ptr(3142,3144,1),new P.ptr(3146,3149,1),new P.ptr(3157,3158,1),new P.ptr(3160,3162,1),new P.ptr(3168,3171,1),new P.ptr(3174,3183,1),new P.ptr(3192,3199,1)]),IZ.nil,0);GS=new O.ptr(new IY([new P.ptr(1920,1969,1)]),IZ.nil,0);GT=new O.ptr(new IY([new P.ptr(3585,3642,1),new P.ptr(3648,3675,1)]),IZ.nil,0);GU=new O.ptr(new IY([new P.ptr(3840,3911,1),new P.ptr(3913,3948,1),new P.ptr(3953,3991,1),new P.ptr(3993,4028,1),new P.ptr(4030,4044,1),new P.ptr(4046,4052,1),new P.ptr(4057,4058,1)]),IZ.nil,0);GV=new O.ptr(new IY([new P.ptr(11568,11623,1),new P.ptr(11631,11632,1),new P.ptr(11647,11647,1)]),IZ.nil,0);GW=new O.ptr(new IY([]),new IZ([new Q.ptr(70784,70855,1),new Q.ptr(70864,70873,1)]),0);GX=new O.ptr(new IY([]),new IZ([new Q.ptr(66432,66461,1),new Q.ptr(66463,66463,1)]),0);GY=new O.ptr(new IY([new P.ptr(42240,42539,1)]),IZ.nil,0);GZ=new O.ptr(new IY([]),new IZ([new Q.ptr(71840,71922,1),new Q.ptr(71935,71935,1)]),0);HA=new O.ptr(new IY([new P.ptr(40960,42124,1),new P.ptr(42128,42182,1)]),IZ.nil,0);HB=new O.ptr(new IY([]),new IZ([new Q.ptr(72192,72263,1)]),0);$pkg.Adlam=BR;$pkg.Ahom=BS;$pkg.Anatolian_Hieroglyphs=BT;$pkg.Arabic=BU;$pkg.Armenian=BV;$pkg.Avestan=BW;$pkg.Balinese=BX;$pkg.Bamum=BY;$pkg.Bassa_Vah=BZ;$pkg.Batak=CA;$pkg.Bengali=CB;$pkg.Bhaiksuki=CC;$pkg.Bopomofo=CD;$pkg.Brahmi=CE;$pkg.Braille=CF;$pkg.Buginese=CG;$pkg.Buhid=CH;$pkg.Canadian_Aboriginal=CI;$pkg.Carian=CJ;$pkg.Caucasian_Albanian=CK;$pkg.Chakma=CL;$pkg.Cham=CM;$pkg.Cherokee=CN;$pkg.Common=CO;$pkg.Coptic=CP;$pkg.Cuneiform=CQ;$pkg.Cypriot=CR;$pkg.Cyrillic=CS;$pkg.Deseret=CT;$pkg.Devanagari=CU;$pkg.Duployan=CV;$pkg.Egyptian_Hieroglyphs=CW;$pkg.Elbasan=CX;$pkg.Ethiopic=CY;$pkg.Georgian=CZ;$pkg.Glagolitic=DA;$pkg.Gothic=DB;$pkg.Grantha=DC;$pkg.Greek=DD;$pkg.Gujarati=DE;$pkg.Gurmukhi=DF;$pkg.Han=DG;$pkg.Hangul=DH;$pkg.Hanunoo=DI;$pkg.Hatran=DJ;$pkg.Hebrew=DK;$pkg.Hiragana=DL;$pkg.Imperial_Aramaic=DM;$pkg.Inherited=DN;$pkg.Inscriptional_Pahlavi=DO;$pkg.Inscriptional_Parthian=DP;$pkg.Javanese=DQ;$pkg.Kaithi=DR;$pkg.Kannada=DS;$pkg.Katakana=DT;$pkg.Kayah_Li=DU;$pkg.Kharoshthi=DV;$pkg.Khmer=DW;$pkg.Khojki=DX;$pkg.Khudawadi=DY;$pkg.Lao=DZ;$pkg.Latin=EA;$pkg.Lepcha=EB;$pkg.Limbu=EC;$pkg.Linear_A=ED;$pkg.Linear_B=EE;$pkg.Lisu=EF;$pkg.Lycian=EG;$pkg.Lydian=EH;$pkg.Mahajani=EI;$pkg.Malayalam=EJ;$pkg.Mandaic=EK;$pkg.Manichaean=EL;$pkg.Marchen=EM;$pkg.Masaram_Gondi=EN;$pkg.Meetei_Mayek=EO;$pkg.Mende_Kikakui=EP;$pkg.Meroitic_Cursive=EQ;$pkg.Meroitic_Hieroglyphs=ER;$pkg.Miao=ES;$pkg.Modi=ET;$pkg.Mongolian=EU;$pkg.Mro=EV;$pkg.Multani=EW;$pkg.Myanmar=EX;$pkg.Nabataean=EY;$pkg.New_Tai_Lue=EZ;$pkg.Newa=FA;$pkg.Nko=FB;$pkg.Nushu=FC;$pkg.Ogham=FD;$pkg.Ol_Chiki=FE;$pkg.Old_Hungarian=FF;$pkg.Old_Italic=FG;$pkg.Old_North_Arabian=FH;$pkg.Old_Permic=FI;$pkg.Old_Persian=FJ;$pkg.Old_South_Arabian=FK;$pkg.Old_Turkic=FL;$pkg.Oriya=FM;$pkg.Osage=FN;$pkg.Osmanya=FO;$pkg.Pahawh_Hmong=FP;$pkg.Palmyrene=FQ;$pkg.Pau_Cin_Hau=FR;$pkg.Phags_Pa=FS;$pkg.Phoenician=FT;$pkg.Psalter_Pahlavi=FU;$pkg.Rejang=FV;$pkg.Runic=FW;$pkg.Samaritan=FX;$pkg.Saurashtra=FY;$pkg.Sharada=FZ;$pkg.Shavian=GA;$pkg.Siddham=GB;$pkg.SignWriting=GC;$pkg.Sinhala=GD;$pkg.Sora_Sompeng=GE;$pkg.Soyombo=GF;$pkg.Sundanese=GG;$pkg.Syloti_Nagri=GH;$pkg.Syriac=GI;$pkg.Tagalog=GJ;$pkg.Tagbanwa=GK;$pkg.Tai_Le=GL;$pkg.Tai_Tham=GM;$pkg.Tai_Viet=GN;$pkg.Takri=GO;$pkg.Tamil=GP;$pkg.Tangut=GQ;$pkg.Telugu=GR;$pkg.Thaana=GS;$pkg.Thai=GT;$pkg.Tibetan=GU;$pkg.Tifinagh=GV;$pkg.Tirhuta=GW;$pkg.Ugaritic=GX;$pkg.Vai=GY;$pkg.Warang_Citi=GZ;$pkg.Yi=HA;$pkg.Zanabazar_Square=HB;$pkg.Scripts=$makeMap($String.keyFor,[{k:"Adlam",v:$pkg.Adlam},{k:"Ahom",v:$pkg.Ahom},{k:"Anatolian_Hieroglyphs",v:$pkg.Anatolian_Hieroglyphs},{k:"Arabic",v:$pkg.Arabic},{k:"Armenian",v:$pkg.Armenian},{k:"Avestan",v:$pkg.Avestan},{k:"Balinese",v:$pkg.Balinese},{k:"Bamum",v:$pkg.Bamum},{k:"Bassa_Vah",v:$pkg.Bassa_Vah},{k:"Batak",v:$pkg.Batak},{k:"Bengali",v:$pkg.Bengali},{k:"Bhaiksuki",v:$pkg.Bhaiksuki},{k:"Bopomofo",v:$pkg.Bopomofo},{k:"Brahmi",v:$pkg.Brahmi},{k:"Braille",v:$pkg.Braille},{k:"Buginese",v:$pkg.Buginese},{k:"Buhid",v:$pkg.Buhid},{k:"Canadian_Aboriginal",v:$pkg.Canadian_Aboriginal},{k:"Carian",v:$pkg.Carian},{k:"Caucasian_Albanian",v:$pkg.Caucasian_Albanian},{k:"Chakma",v:$pkg.Chakma},{k:"Cham",v:$pkg.Cham},{k:"Cherokee",v:$pkg.Cherokee},{k:"Common",v:$pkg.Common},{k:"Coptic",v:$pkg.Coptic},{k:"Cuneiform",v:$pkg.Cuneiform},{k:"Cypriot",v:$pkg.Cypriot},{k:"Cyrillic",v:$pkg.Cyrillic},{k:"Deseret",v:$pkg.Deseret},{k:"Devanagari",v:$pkg.Devanagari},{k:"Duployan",v:$pkg.Duployan},{k:"Egyptian_Hieroglyphs",v:$pkg.Egyptian_Hieroglyphs},{k:"Elbasan",v:$pkg.Elbasan},{k:"Ethiopic",v:$pkg.Ethiopic},{k:"Georgian",v:$pkg.Georgian},{k:"Glagolitic",v:$pkg.Glagolitic},{k:"Gothic",v:$pkg.Gothic},{k:"Grantha",v:$pkg.Grantha},{k:"Greek",v:$pkg.Greek},{k:"Gujarati",v:$pkg.Gujarati},{k:"Gurmukhi",v:$pkg.Gurmukhi},{k:"Han",v:$pkg.Han},{k:"Hangul",v:$pkg.Hangul},{k:"Hanunoo",v:$pkg.Hanunoo},{k:"Hatran",v:$pkg.Hatran},{k:"Hebrew",v:$pkg.Hebrew},{k:"Hiragana",v:$pkg.Hiragana},{k:"Imperial_Aramaic",v:$pkg.Imperial_Aramaic},{k:"Inherited",v:$pkg.Inherited},{k:"Inscriptional_Pahlavi",v:$pkg.Inscriptional_Pahlavi},{k:"Inscriptional_Parthian",v:$pkg.Inscriptional_Parthian},{k:"Javanese",v:$pkg.Javanese},{k:"Kaithi",v:$pkg.Kaithi},{k:"Kannada",v:$pkg.Kannada},{k:"Katakana",v:$pkg.Katakana},{k:"Kayah_Li",v:$pkg.Kayah_Li},{k:"Kharoshthi",v:$pkg.Kharoshthi},{k:"Khmer",v:$pkg.Khmer},{k:"Khojki",v:$pkg.Khojki},{k:"Khudawadi",v:$pkg.Khudawadi},{k:"Lao",v:$pkg.Lao},{k:"Latin",v:$pkg.Latin},{k:"Lepcha",v:$pkg.Lepcha},{k:"Limbu",v:$pkg.Limbu},{k:"Linear_A",v:$pkg.Linear_A},{k:"Linear_B",v:$pkg.Linear_B},{k:"Lisu",v:$pkg.Lisu},{k:"Lycian",v:$pkg.Lycian},{k:"Lydian",v:$pkg.Lydian},{k:"Mahajani",v:$pkg.Mahajani},{k:"Malayalam",v:$pkg.Malayalam},{k:"Mandaic",v:$pkg.Mandaic},{k:"Manichaean",v:$pkg.Manichaean},{k:"Marchen",v:$pkg.Marchen},{k:"Masaram_Gondi",v:$pkg.Masaram_Gondi},{k:"Meetei_Mayek",v:$pkg.Meetei_Mayek},{k:"Mende_Kikakui",v:$pkg.Mende_Kikakui},{k:"Meroitic_Cursive",v:$pkg.Meroitic_Cursive},{k:"Meroitic_Hieroglyphs",v:$pkg.Meroitic_Hieroglyphs},{k:"Miao",v:$pkg.Miao},{k:"Modi",v:$pkg.Modi},{k:"Mongolian",v:$pkg.Mongolian},{k:"Mro",v:$pkg.Mro},{k:"Multani",v:$pkg.Multani},{k:"Myanmar",v:$pkg.Myanmar},{k:"Nabataean",v:$pkg.Nabataean},{k:"New_Tai_Lue",v:$pkg.New_Tai_Lue},{k:"Newa",v:$pkg.Newa},{k:"Nko",v:$pkg.Nko},{k:"Nushu",v:$pkg.Nushu},{k:"Ogham",v:$pkg.Ogham},{k:"Ol_Chiki",v:$pkg.Ol_Chiki},{k:"Old_Hungarian",v:$pkg.Old_Hungarian},{k:"Old_Italic",v:$pkg.Old_Italic},{k:"Old_North_Arabian",v:$pkg.Old_North_Arabian},{k:"Old_Permic",v:$pkg.Old_Permic},{k:"Old_Persian",v:$pkg.Old_Persian},{k:"Old_South_Arabian",v:$pkg.Old_South_Arabian},{k:"Old_Turkic",v:$pkg.Old_Turkic},{k:"Oriya",v:$pkg.Oriya},{k:"Osage",v:$pkg.Osage},{k:"Osmanya",v:$pkg.Osmanya},{k:"Pahawh_Hmong",v:$pkg.Pahawh_Hmong},{k:"Palmyrene",v:$pkg.Palmyrene},{k:"Pau_Cin_Hau",v:$pkg.Pau_Cin_Hau},{k:"Phags_Pa",v:$pkg.Phags_Pa},{k:"Phoenician",v:$pkg.Phoenician},{k:"Psalter_Pahlavi",v:$pkg.Psalter_Pahlavi},{k:"Rejang",v:$pkg.Rejang},{k:"Runic",v:$pkg.Runic},{k:"Samaritan",v:$pkg.Samaritan},{k:"Saurashtra",v:$pkg.Saurashtra},{k:"Sharada",v:$pkg.Sharada},{k:"Shavian",v:$pkg.Shavian},{k:"Siddham",v:$pkg.Siddham},{k:"SignWriting",v:$pkg.SignWriting},{k:"Sinhala",v:$pkg.Sinhala},{k:"Sora_Sompeng",v:$pkg.Sora_Sompeng},{k:"Soyombo",v:$pkg.Soyombo},{k:"Sundanese",v:$pkg.Sundanese},{k:"Syloti_Nagri",v:$pkg.Syloti_Nagri},{k:"Syriac",v:$pkg.Syriac},{k:"Tagalog",v:$pkg.Tagalog},{k:"Tagbanwa",v:$pkg.Tagbanwa},{k:"Tai_Le",v:$pkg.Tai_Le},{k:"Tai_Tham",v:$pkg.Tai_Tham},{k:"Tai_Viet",v:$pkg.Tai_Viet},{k:"Takri",v:$pkg.Takri},{k:"Tamil",v:$pkg.Tamil},{k:"Tangut",v:$pkg.Tangut},{k:"Telugu",v:$pkg.Telugu},{k:"Thaana",v:$pkg.Thaana},{k:"Thai",v:$pkg.Thai},{k:"Tibetan",v:$pkg.Tibetan},{k:"Tifinagh",v:$pkg.Tifinagh},{k:"Tirhuta",v:$pkg.Tirhuta},{k:"Ugaritic",v:$pkg.Ugaritic},{k:"Vai",v:$pkg.Vai},{k:"Warang_Citi",v:$pkg.Warang_Citi},{k:"Yi",v:$pkg.Yi},{k:"Zanabazar_Square",v:$pkg.Zanabazar_Square}]);IK=new JC([new R.ptr(65,90,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(97,122,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(181,181,$toNativeArray($kindInt32,[743,0,743])),new R.ptr(192,214,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(216,222,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(224,246,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(248,254,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(255,255,$toNativeArray($kindInt32,[121,0,121])),new R.ptr(256,303,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(304,304,$toNativeArray($kindInt32,[0,-199,0])),new R.ptr(305,305,$toNativeArray($kindInt32,[-232,0,-232])),new R.ptr(306,311,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(313,328,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(330,375,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(376,376,$toNativeArray($kindInt32,[0,-121,0])),new R.ptr(377,382,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(383,383,$toNativeArray($kindInt32,[-300,0,-300])),new R.ptr(384,384,$toNativeArray($kindInt32,[195,0,195])),new R.ptr(385,385,$toNativeArray($kindInt32,[0,210,0])),new R.ptr(386,389,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(390,390,$toNativeArray($kindInt32,[0,206,0])),new R.ptr(391,392,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(393,394,$toNativeArray($kindInt32,[0,205,0])),new R.ptr(395,396,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(398,398,$toNativeArray($kindInt32,[0,79,0])),new R.ptr(399,399,$toNativeArray($kindInt32,[0,202,0])),new R.ptr(400,400,$toNativeArray($kindInt32,[0,203,0])),new R.ptr(401,402,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(403,403,$toNativeArray($kindInt32,[0,205,0])),new R.ptr(404,404,$toNativeArray($kindInt32,[0,207,0])),new R.ptr(405,405,$toNativeArray($kindInt32,[97,0,97])),new R.ptr(406,406,$toNativeArray($kindInt32,[0,211,0])),new R.ptr(407,407,$toNativeArray($kindInt32,[0,209,0])),new R.ptr(408,409,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(410,410,$toNativeArray($kindInt32,[163,0,163])),new R.ptr(412,412,$toNativeArray($kindInt32,[0,211,0])),new R.ptr(413,413,$toNativeArray($kindInt32,[0,213,0])),new R.ptr(414,414,$toNativeArray($kindInt32,[130,0,130])),new R.ptr(415,415,$toNativeArray($kindInt32,[0,214,0])),new R.ptr(416,421,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(422,422,$toNativeArray($kindInt32,[0,218,0])),new R.ptr(423,424,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(425,425,$toNativeArray($kindInt32,[0,218,0])),new R.ptr(428,429,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(430,430,$toNativeArray($kindInt32,[0,218,0])),new R.ptr(431,432,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(433,434,$toNativeArray($kindInt32,[0,217,0])),new R.ptr(435,438,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(439,439,$toNativeArray($kindInt32,[0,219,0])),new R.ptr(440,441,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(444,445,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(447,447,$toNativeArray($kindInt32,[56,0,56])),new R.ptr(452,452,$toNativeArray($kindInt32,[0,2,1])),new R.ptr(453,453,$toNativeArray($kindInt32,[-1,1,0])),new R.ptr(454,454,$toNativeArray($kindInt32,[-2,0,-1])),new R.ptr(455,455,$toNativeArray($kindInt32,[0,2,1])),new R.ptr(456,456,$toNativeArray($kindInt32,[-1,1,0])),new R.ptr(457,457,$toNativeArray($kindInt32,[-2,0,-1])),new R.ptr(458,458,$toNativeArray($kindInt32,[0,2,1])),new R.ptr(459,459,$toNativeArray($kindInt32,[-1,1,0])),new R.ptr(460,460,$toNativeArray($kindInt32,[-2,0,-1])),new R.ptr(461,476,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(477,477,$toNativeArray($kindInt32,[-79,0,-79])),new R.ptr(478,495,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(497,497,$toNativeArray($kindInt32,[0,2,1])),new R.ptr(498,498,$toNativeArray($kindInt32,[-1,1,0])),new R.ptr(499,499,$toNativeArray($kindInt32,[-2,0,-1])),new R.ptr(500,501,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(502,502,$toNativeArray($kindInt32,[0,-97,0])),new R.ptr(503,503,$toNativeArray($kindInt32,[0,-56,0])),new R.ptr(504,543,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(544,544,$toNativeArray($kindInt32,[0,-130,0])),new R.ptr(546,563,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(570,570,$toNativeArray($kindInt32,[0,10795,0])),new R.ptr(571,572,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(573,573,$toNativeArray($kindInt32,[0,-163,0])),new R.ptr(574,574,$toNativeArray($kindInt32,[0,10792,0])),new R.ptr(575,576,$toNativeArray($kindInt32,[10815,0,10815])),new R.ptr(577,578,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(579,579,$toNativeArray($kindInt32,[0,-195,0])),new R.ptr(580,580,$toNativeArray($kindInt32,[0,69,0])),new R.ptr(581,581,$toNativeArray($kindInt32,[0,71,0])),new R.ptr(582,591,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(592,592,$toNativeArray($kindInt32,[10783,0,10783])),new R.ptr(593,593,$toNativeArray($kindInt32,[10780,0,10780])),new R.ptr(594,594,$toNativeArray($kindInt32,[10782,0,10782])),new R.ptr(595,595,$toNativeArray($kindInt32,[-210,0,-210])),new R.ptr(596,596,$toNativeArray($kindInt32,[-206,0,-206])),new R.ptr(598,599,$toNativeArray($kindInt32,[-205,0,-205])),new R.ptr(601,601,$toNativeArray($kindInt32,[-202,0,-202])),new R.ptr(603,603,$toNativeArray($kindInt32,[-203,0,-203])),new R.ptr(604,604,$toNativeArray($kindInt32,[42319,0,42319])),new R.ptr(608,608,$toNativeArray($kindInt32,[-205,0,-205])),new R.ptr(609,609,$toNativeArray($kindInt32,[42315,0,42315])),new R.ptr(611,611,$toNativeArray($kindInt32,[-207,0,-207])),new R.ptr(613,613,$toNativeArray($kindInt32,[42280,0,42280])),new R.ptr(614,614,$toNativeArray($kindInt32,[42308,0,42308])),new R.ptr(616,616,$toNativeArray($kindInt32,[-209,0,-209])),new R.ptr(617,617,$toNativeArray($kindInt32,[-211,0,-211])),new R.ptr(618,618,$toNativeArray($kindInt32,[42308,0,42308])),new R.ptr(619,619,$toNativeArray($kindInt32,[10743,0,10743])),new R.ptr(620,620,$toNativeArray($kindInt32,[42305,0,42305])),new R.ptr(623,623,$toNativeArray($kindInt32,[-211,0,-211])),new R.ptr(625,625,$toNativeArray($kindInt32,[10749,0,10749])),new R.ptr(626,626,$toNativeArray($kindInt32,[-213,0,-213])),new R.ptr(629,629,$toNativeArray($kindInt32,[-214,0,-214])),new R.ptr(637,637,$toNativeArray($kindInt32,[10727,0,10727])),new R.ptr(640,640,$toNativeArray($kindInt32,[-218,0,-218])),new R.ptr(643,643,$toNativeArray($kindInt32,[-218,0,-218])),new R.ptr(647,647,$toNativeArray($kindInt32,[42282,0,42282])),new R.ptr(648,648,$toNativeArray($kindInt32,[-218,0,-218])),new R.ptr(649,649,$toNativeArray($kindInt32,[-69,0,-69])),new R.ptr(650,651,$toNativeArray($kindInt32,[-217,0,-217])),new R.ptr(652,652,$toNativeArray($kindInt32,[-71,0,-71])),new R.ptr(658,658,$toNativeArray($kindInt32,[-219,0,-219])),new R.ptr(669,669,$toNativeArray($kindInt32,[42261,0,42261])),new R.ptr(670,670,$toNativeArray($kindInt32,[42258,0,42258])),new R.ptr(837,837,$toNativeArray($kindInt32,[84,0,84])),new R.ptr(880,883,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(886,887,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(891,893,$toNativeArray($kindInt32,[130,0,130])),new R.ptr(895,895,$toNativeArray($kindInt32,[0,116,0])),new R.ptr(902,902,$toNativeArray($kindInt32,[0,38,0])),new R.ptr(904,906,$toNativeArray($kindInt32,[0,37,0])),new R.ptr(908,908,$toNativeArray($kindInt32,[0,64,0])),new R.ptr(910,911,$toNativeArray($kindInt32,[0,63,0])),new R.ptr(913,929,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(931,939,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(940,940,$toNativeArray($kindInt32,[-38,0,-38])),new R.ptr(941,943,$toNativeArray($kindInt32,[-37,0,-37])),new R.ptr(945,961,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(962,962,$toNativeArray($kindInt32,[-31,0,-31])),new R.ptr(963,971,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(972,972,$toNativeArray($kindInt32,[-64,0,-64])),new R.ptr(973,974,$toNativeArray($kindInt32,[-63,0,-63])),new R.ptr(975,975,$toNativeArray($kindInt32,[0,8,0])),new R.ptr(976,976,$toNativeArray($kindInt32,[-62,0,-62])),new R.ptr(977,977,$toNativeArray($kindInt32,[-57,0,-57])),new R.ptr(981,981,$toNativeArray($kindInt32,[-47,0,-47])),new R.ptr(982,982,$toNativeArray($kindInt32,[-54,0,-54])),new R.ptr(983,983,$toNativeArray($kindInt32,[-8,0,-8])),new R.ptr(984,1007,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1008,1008,$toNativeArray($kindInt32,[-86,0,-86])),new R.ptr(1009,1009,$toNativeArray($kindInt32,[-80,0,-80])),new R.ptr(1010,1010,$toNativeArray($kindInt32,[7,0,7])),new R.ptr(1011,1011,$toNativeArray($kindInt32,[-116,0,-116])),new R.ptr(1012,1012,$toNativeArray($kindInt32,[0,-60,0])),new R.ptr(1013,1013,$toNativeArray($kindInt32,[-96,0,-96])),new R.ptr(1015,1016,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1017,1017,$toNativeArray($kindInt32,[0,-7,0])),new R.ptr(1018,1019,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1021,1023,$toNativeArray($kindInt32,[0,-130,0])),new R.ptr(1024,1039,$toNativeArray($kindInt32,[0,80,0])),new R.ptr(1040,1071,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(1072,1103,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(1104,1119,$toNativeArray($kindInt32,[-80,0,-80])),new R.ptr(1120,1153,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1162,1215,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1216,1216,$toNativeArray($kindInt32,[0,15,0])),new R.ptr(1217,1230,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1231,1231,$toNativeArray($kindInt32,[-15,0,-15])),new R.ptr(1232,1327,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(1329,1366,$toNativeArray($kindInt32,[0,48,0])),new R.ptr(1377,1414,$toNativeArray($kindInt32,[-48,0,-48])),new R.ptr(4256,4293,$toNativeArray($kindInt32,[0,7264,0])),new R.ptr(4295,4295,$toNativeArray($kindInt32,[0,7264,0])),new R.ptr(4301,4301,$toNativeArray($kindInt32,[0,7264,0])),new R.ptr(5024,5103,$toNativeArray($kindInt32,[0,38864,0])),new R.ptr(5104,5109,$toNativeArray($kindInt32,[0,8,0])),new R.ptr(5112,5117,$toNativeArray($kindInt32,[-8,0,-8])),new R.ptr(7296,7296,$toNativeArray($kindInt32,[-6254,0,-6254])),new R.ptr(7297,7297,$toNativeArray($kindInt32,[-6253,0,-6253])),new R.ptr(7298,7298,$toNativeArray($kindInt32,[-6244,0,-6244])),new R.ptr(7299,7300,$toNativeArray($kindInt32,[-6242,0,-6242])),new R.ptr(7301,7301,$toNativeArray($kindInt32,[-6243,0,-6243])),new R.ptr(7302,7302,$toNativeArray($kindInt32,[-6236,0,-6236])),new R.ptr(7303,7303,$toNativeArray($kindInt32,[-6181,0,-6181])),new R.ptr(7304,7304,$toNativeArray($kindInt32,[35266,0,35266])),new R.ptr(7545,7545,$toNativeArray($kindInt32,[35332,0,35332])),new R.ptr(7549,7549,$toNativeArray($kindInt32,[3814,0,3814])),new R.ptr(7680,7829,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(7835,7835,$toNativeArray($kindInt32,[-59,0,-59])),new R.ptr(7838,7838,$toNativeArray($kindInt32,[0,-7615,0])),new R.ptr(7840,7935,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(7936,7943,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(7944,7951,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(7952,7957,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(7960,7965,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(7968,7975,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(7976,7983,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(7984,7991,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(7992,7999,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8000,8005,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8008,8013,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8017,8017,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8019,8019,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8021,8021,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8023,8023,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8025,8025,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8027,8027,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8029,8029,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8031,8031,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8032,8039,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8040,8047,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8048,8049,$toNativeArray($kindInt32,[74,0,74])),new R.ptr(8050,8053,$toNativeArray($kindInt32,[86,0,86])),new R.ptr(8054,8055,$toNativeArray($kindInt32,[100,0,100])),new R.ptr(8056,8057,$toNativeArray($kindInt32,[128,0,128])),new R.ptr(8058,8059,$toNativeArray($kindInt32,[112,0,112])),new R.ptr(8060,8061,$toNativeArray($kindInt32,[126,0,126])),new R.ptr(8064,8071,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8072,8079,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8080,8087,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8088,8095,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8096,8103,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8104,8111,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8112,8113,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8115,8115,$toNativeArray($kindInt32,[9,0,9])),new R.ptr(8120,8121,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8122,8123,$toNativeArray($kindInt32,[0,-74,0])),new R.ptr(8124,8124,$toNativeArray($kindInt32,[0,-9,0])),new R.ptr(8126,8126,$toNativeArray($kindInt32,[-7205,0,-7205])),new R.ptr(8131,8131,$toNativeArray($kindInt32,[9,0,9])),new R.ptr(8136,8139,$toNativeArray($kindInt32,[0,-86,0])),new R.ptr(8140,8140,$toNativeArray($kindInt32,[0,-9,0])),new R.ptr(8144,8145,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8152,8153,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8154,8155,$toNativeArray($kindInt32,[0,-100,0])),new R.ptr(8160,8161,$toNativeArray($kindInt32,[8,0,8])),new R.ptr(8165,8165,$toNativeArray($kindInt32,[7,0,7])),new R.ptr(8168,8169,$toNativeArray($kindInt32,[0,-8,0])),new R.ptr(8170,8171,$toNativeArray($kindInt32,[0,-112,0])),new R.ptr(8172,8172,$toNativeArray($kindInt32,[0,-7,0])),new R.ptr(8179,8179,$toNativeArray($kindInt32,[9,0,9])),new R.ptr(8184,8185,$toNativeArray($kindInt32,[0,-128,0])),new R.ptr(8186,8187,$toNativeArray($kindInt32,[0,-126,0])),new R.ptr(8188,8188,$toNativeArray($kindInt32,[0,-9,0])),new R.ptr(8486,8486,$toNativeArray($kindInt32,[0,-7517,0])),new R.ptr(8490,8490,$toNativeArray($kindInt32,[0,-8383,0])),new R.ptr(8491,8491,$toNativeArray($kindInt32,[0,-8262,0])),new R.ptr(8498,8498,$toNativeArray($kindInt32,[0,28,0])),new R.ptr(8526,8526,$toNativeArray($kindInt32,[-28,0,-28])),new R.ptr(8544,8559,$toNativeArray($kindInt32,[0,16,0])),new R.ptr(8560,8575,$toNativeArray($kindInt32,[-16,0,-16])),new R.ptr(8579,8580,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(9398,9423,$toNativeArray($kindInt32,[0,26,0])),new R.ptr(9424,9449,$toNativeArray($kindInt32,[-26,0,-26])),new R.ptr(11264,11310,$toNativeArray($kindInt32,[0,48,0])),new R.ptr(11312,11358,$toNativeArray($kindInt32,[-48,0,-48])),new R.ptr(11360,11361,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11362,11362,$toNativeArray($kindInt32,[0,-10743,0])),new R.ptr(11363,11363,$toNativeArray($kindInt32,[0,-3814,0])),new R.ptr(11364,11364,$toNativeArray($kindInt32,[0,-10727,0])),new R.ptr(11365,11365,$toNativeArray($kindInt32,[-10795,0,-10795])),new R.ptr(11366,11366,$toNativeArray($kindInt32,[-10792,0,-10792])),new R.ptr(11367,11372,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11373,11373,$toNativeArray($kindInt32,[0,-10780,0])),new R.ptr(11374,11374,$toNativeArray($kindInt32,[0,-10749,0])),new R.ptr(11375,11375,$toNativeArray($kindInt32,[0,-10783,0])),new R.ptr(11376,11376,$toNativeArray($kindInt32,[0,-10782,0])),new R.ptr(11378,11379,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11381,11382,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11390,11391,$toNativeArray($kindInt32,[0,-10815,0])),new R.ptr(11392,11491,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11499,11502,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11506,11507,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(11520,11557,$toNativeArray($kindInt32,[-7264,0,-7264])),new R.ptr(11559,11559,$toNativeArray($kindInt32,[-7264,0,-7264])),new R.ptr(11565,11565,$toNativeArray($kindInt32,[-7264,0,-7264])),new R.ptr(42560,42605,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42624,42651,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42786,42799,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42802,42863,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42873,42876,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42877,42877,$toNativeArray($kindInt32,[0,-35332,0])),new R.ptr(42878,42887,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42891,42892,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42893,42893,$toNativeArray($kindInt32,[0,-42280,0])),new R.ptr(42896,42899,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42902,42921,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(42922,42922,$toNativeArray($kindInt32,[0,-42308,0])),new R.ptr(42923,42923,$toNativeArray($kindInt32,[0,-42319,0])),new R.ptr(42924,42924,$toNativeArray($kindInt32,[0,-42315,0])),new R.ptr(42925,42925,$toNativeArray($kindInt32,[0,-42305,0])),new R.ptr(42926,42926,$toNativeArray($kindInt32,[0,-42308,0])),new R.ptr(42928,42928,$toNativeArray($kindInt32,[0,-42258,0])),new R.ptr(42929,42929,$toNativeArray($kindInt32,[0,-42282,0])),new R.ptr(42930,42930,$toNativeArray($kindInt32,[0,-42261,0])),new R.ptr(42931,42931,$toNativeArray($kindInt32,[0,928,0])),new R.ptr(42932,42935,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new R.ptr(43859,43859,$toNativeArray($kindInt32,[-928,0,-928])),new R.ptr(43888,43967,$toNativeArray($kindInt32,[-38864,0,-38864])),new R.ptr(65313,65338,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(65345,65370,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(66560,66599,$toNativeArray($kindInt32,[0,40,0])),new R.ptr(66600,66639,$toNativeArray($kindInt32,[-40,0,-40])),new R.ptr(66736,66771,$toNativeArray($kindInt32,[0,40,0])),new R.ptr(66776,66811,$toNativeArray($kindInt32,[-40,0,-40])),new R.ptr(68736,68786,$toNativeArray($kindInt32,[0,64,0])),new R.ptr(68800,68850,$toNativeArray($kindInt32,[-64,0,-64])),new R.ptr(71840,71871,$toNativeArray($kindInt32,[0,32,0])),new R.ptr(71872,71903,$toNativeArray($kindInt32,[-32,0,-32])),new R.ptr(125184,125217,$toNativeArray($kindInt32,[0,34,0])),new R.ptr(125218,125251,$toNativeArray($kindInt32,[-34,0,-34]))]);$pkg.CaseRanges=IK;IL=$toNativeArray($kindUint8,[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,144,130,130,130,136,130,130,130,130,130,130,136,130,130,130,130,132,132,132,132,132,132,132,132,132,132,130,130,136,136,136,130,130,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,130,130,130,136,130,136,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,130,136,130,136,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,16,130,136,136,136,136,136,130,136,136,224,130,136,0,136,136,136,136,132,132,136,192,130,130,136,132,224,130,132,132,132,130,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,136,160,160,160,160,160,160,160,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,136,192,192,192,192,192,192,192,192]);IM=$toNativeArray($kindUint16,[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,95,96,65,66,67,68,69,70,71,72,73,74,8490,76,77,78,79,80,81,82,383,84,85,86,87,88,89,90,123,124,125,126,127]);IN=new JD([new AF.ptr(75,107),new AF.ptr(83,115),new AF.ptr(107,8490),new AF.ptr(115,383),new AF.ptr(181,924),new AF.ptr(197,229),new AF.ptr(223,7838),new AF.ptr(229,8491),new AF.ptr(304,304),new AF.ptr(305,305),new AF.ptr(383,83),new AF.ptr(452,453),new AF.ptr(453,454),new AF.ptr(454,452),new AF.ptr(455,456),new AF.ptr(456,457),new AF.ptr(457,455),new AF.ptr(458,459),new AF.ptr(459,460),new AF.ptr(460,458),new AF.ptr(497,498),new AF.ptr(498,499),new AF.ptr(499,497),new AF.ptr(837,921),new AF.ptr(914,946),new AF.ptr(917,949),new AF.ptr(920,952),new AF.ptr(921,953),new AF.ptr(922,954),new AF.ptr(924,956),new AF.ptr(928,960),new AF.ptr(929,961),new AF.ptr(931,962),new AF.ptr(934,966),new AF.ptr(937,969),new AF.ptr(946,976),new AF.ptr(949,1013),new AF.ptr(952,977),new AF.ptr(953,8126),new AF.ptr(954,1008),new AF.ptr(956,181),new AF.ptr(960,982),new AF.ptr(961,1009),new AF.ptr(962,963),new AF.ptr(963,931),new AF.ptr(966,981),new AF.ptr(969,8486),new AF.ptr(976,914),new AF.ptr(977,1012),new AF.ptr(981,934),new AF.ptr(982,928),new AF.ptr(1008,922),new AF.ptr(1009,929),new AF.ptr(1012,920),new AF.ptr(1013,917),new AF.ptr(1042,1074),new AF.ptr(1044,1076),new AF.ptr(1054,1086),new AF.ptr(1057,1089),new AF.ptr(1058,1090),new AF.ptr(1066,1098),new AF.ptr(1074,7296),new AF.ptr(1076,7297),new AF.ptr(1086,7298),new AF.ptr(1089,7299),new AF.ptr(1090,7300),new AF.ptr(1098,7302),new AF.ptr(1122,1123),new AF.ptr(1123,7303),new AF.ptr(7296,1042),new AF.ptr(7297,1044),new AF.ptr(7298,1054),new AF.ptr(7299,1057),new AF.ptr(7300,7301),new AF.ptr(7301,1058),new AF.ptr(7302,1066),new AF.ptr(7303,1122),new AF.ptr(7304,42570),new AF.ptr(7776,7777),new AF.ptr(7777,7835),new AF.ptr(7835,7776),new AF.ptr(7838,223),new AF.ptr(8126,837),new AF.ptr(8486,937),new AF.ptr(8490,75),new AF.ptr(8491,197),new AF.ptr(42570,42571),new AF.ptr(42571,7304)]);IO=new O.ptr(new IY([new P.ptr(837,837,1)]),IZ.nil,0);IP=new O.ptr(new IY([new P.ptr(65,90,1),new P.ptr(192,214,1),new P.ptr(216,222,1),new P.ptr(256,302,2),new P.ptr(306,310,2),new P.ptr(313,327,2),new P.ptr(330,376,2),new P.ptr(377,381,2),new P.ptr(385,386,1),new P.ptr(388,390,2),new P.ptr(391,393,2),new P.ptr(394,395,1),new P.ptr(398,401,1),new P.ptr(403,404,1),new P.ptr(406,408,1),new P.ptr(412,413,1),new P.ptr(415,416,1),new P.ptr(418,422,2),new P.ptr(423,425,2),new P.ptr(428,430,2),new P.ptr(431,433,2),new P.ptr(434,435,1),new P.ptr(437,439,2),new P.ptr(440,444,4),new P.ptr(452,453,1),new P.ptr(455,456,1),new P.ptr(458,459,1),new P.ptr(461,475,2),new P.ptr(478,494,2),new P.ptr(497,498,1),new P.ptr(500,502,2),new P.ptr(503,504,1),new P.ptr(506,562,2),new P.ptr(570,571,1),new P.ptr(573,574,1),new P.ptr(577,579,2),new P.ptr(580,582,1),new P.ptr(584,590,2),new P.ptr(837,880,43),new P.ptr(882,886,4),new P.ptr(895,902,7),new P.ptr(904,906,1),new P.ptr(908,910,2),new P.ptr(911,913,2),new P.ptr(914,929,1),new P.ptr(931,939,1),new P.ptr(975,984,9),new P.ptr(986,1006,2),new P.ptr(1012,1015,3),new P.ptr(1017,1018,1),new P.ptr(1021,1071,1),new P.ptr(1120,1152,2),new P.ptr(1162,1216,2),new P.ptr(1217,1229,2),new P.ptr(1232,1326,2),new P.ptr(1329,1366,1),new P.ptr(4256,4293,1),new P.ptr(4295,4301,6),new P.ptr(5024,5109,1),new P.ptr(7680,7828,2),new P.ptr(7838,7934,2),new P.ptr(7944,7951,1),new P.ptr(7960,7965,1),new P.ptr(7976,7983,1),new P.ptr(7992,7999,1),new P.ptr(8008,8013,1),new P.ptr(8025,8031,2),new P.ptr(8040,8047,1),new P.ptr(8072,8079,1),new P.ptr(8088,8095,1),new P.ptr(8104,8111,1),new P.ptr(8120,8124,1),new P.ptr(8136,8140,1),new P.ptr(8152,8155,1),new P.ptr(8168,8172,1),new P.ptr(8184,8188,1),new P.ptr(8486,8490,4),new P.ptr(8491,8498,7),new P.ptr(8579,11264,2685),new P.ptr(11265,11310,1),new P.ptr(11360,11362,2),new P.ptr(11363,11364,1),new P.ptr(11367,11373,2),new P.ptr(11374,11376,1),new P.ptr(11378,11381,3),new P.ptr(11390,11392,1),new P.ptr(11394,11490,2),new P.ptr(11499,11501,2),new P.ptr(11506,42560,31054),new P.ptr(42562,42604,2),new P.ptr(42624,42650,2),new P.ptr(42786,42798,2),new P.ptr(42802,42862,2),new P.ptr(42873,42877,2),new P.ptr(42878,42886,2),new P.ptr(42891,42893,2),new P.ptr(42896,42898,2),new P.ptr(42902,42922,2),new P.ptr(42923,42926,1),new P.ptr(42928,42932,1),new P.ptr(42934,65313,22379),new P.ptr(65314,65338,1)]),new IZ([new Q.ptr(66560,66599,1),new Q.ptr(66736,66771,1),new Q.ptr(68736,68786,1),new Q.ptr(71840,71871,1),new Q.ptr(125184,125217,1)]),3);IQ=new O.ptr(new IY([new P.ptr(452,454,2),new P.ptr(455,457,2),new P.ptr(458,460,2),new P.ptr(497,499,2),new P.ptr(8064,8071,1),new P.ptr(8080,8087,1),new P.ptr(8096,8103,1),new P.ptr(8115,8131,16),new P.ptr(8179,8179,1)]),IZ.nil,0);IR=new O.ptr(new IY([new P.ptr(97,122,1),new P.ptr(181,223,42),new P.ptr(224,246,1),new P.ptr(248,255,1),new P.ptr(257,303,2),new P.ptr(307,311,2),new P.ptr(314,328,2),new P.ptr(331,375,2),new P.ptr(378,382,2),new P.ptr(383,384,1),new P.ptr(387,389,2),new P.ptr(392,396,4),new P.ptr(402,405,3),new P.ptr(409,410,1),new P.ptr(414,417,3),new P.ptr(419,421,2),new P.ptr(424,429,5),new P.ptr(432,436,4),new P.ptr(438,441,3),new P.ptr(445,447,2),new P.ptr(453,454,1),new P.ptr(456,457,1),new P.ptr(459,460,1),new P.ptr(462,476,2),new P.ptr(477,495,2),new P.ptr(498,499,1),new P.ptr(501,505,4),new P.ptr(507,543,2),new P.ptr(547,563,2),new P.ptr(572,575,3),new P.ptr(576,578,2),new P.ptr(583,591,2),new P.ptr(592,596,1),new P.ptr(598,599,1),new P.ptr(601,603,2),new P.ptr(604,608,4),new P.ptr(609,613,2),new P.ptr(614,616,2),new P.ptr(617,620,1),new P.ptr(623,625,2),new P.ptr(626,629,3),new P.ptr(637,643,3),new P.ptr(647,652,1),new P.ptr(658,669,11),new P.ptr(670,837,167),new P.ptr(881,883,2),new P.ptr(887,891,4),new P.ptr(892,893,1),new P.ptr(940,943,1),new P.ptr(945,974,1),new P.ptr(976,977,1),new P.ptr(981,983,1),new P.ptr(985,1007,2),new P.ptr(1008,1011,1),new P.ptr(1013,1019,3),new P.ptr(1072,1119,1),new P.ptr(1121,1153,2),new P.ptr(1163,1215,2),new P.ptr(1218,1230,2),new P.ptr(1231,1327,2),new P.ptr(1377,1414,1),new P.ptr(5112,5117,1),new P.ptr(7296,7304,1),new P.ptr(7545,7549,4),new P.ptr(7681,7829,2),new P.ptr(7835,7841,6),new P.ptr(7843,7935,2),new P.ptr(7936,7943,1),new P.ptr(7952,7957,1),new P.ptr(7968,7975,1),new P.ptr(7984,7991,1),new P.ptr(8000,8005,1),new P.ptr(8017,8023,2),new P.ptr(8032,8039,1),new P.ptr(8048,8061,1),new P.ptr(8112,8113,1),new P.ptr(8126,8144,18),new P.ptr(8145,8160,15),new P.ptr(8161,8165,4),new P.ptr(8526,8580,54),new P.ptr(11312,11358,1),new P.ptr(11361,11365,4),new P.ptr(11366,11372,2),new P.ptr(11379,11382,3),new P.ptr(11393,11491,2),new P.ptr(11500,11502,2),new P.ptr(11507,11520,13),new P.ptr(11521,11557,1),new P.ptr(11559,11565,6),new P.ptr(42561,42605,2),new P.ptr(42625,42651,2),new P.ptr(42787,42799,2),new P.ptr(42803,42863,2),new P.ptr(42874,42876,2),new P.ptr(42879,42887,2),new P.ptr(42892,42897,5),new P.ptr(42899,42903,4),new P.ptr(42905,42921,2),new P.ptr(42933,42935,2),new P.ptr(43859,43888,29),new P.ptr(43889,43967,1),new P.ptr(65345,65370,1)]),new IZ([new Q.ptr(66600,66639,1),new Q.ptr(66776,66811,1),new Q.ptr(68800,68850,1),new Q.ptr(71872,71903,1),new Q.ptr(125218,125251,1)]),4);IS=new O.ptr(new IY([new P.ptr(921,953,32),new P.ptr(8126,8126,1)]),IZ.nil,0);IT=new O.ptr(new IY([new P.ptr(921,953,32),new P.ptr(8126,8126,1)]),IZ.nil,0);$pkg.FoldCategory=$makeMap($String.keyFor,[{k:"L",v:IO},{k:"Ll",v:IP},{k:"Lt",v:IQ},{k:"Lu",v:IR},{k:"M",v:IS},{k:"Mn",v:IT}]);IU=new O.ptr(new IY([new P.ptr(924,956,32)]),IZ.nil,0);IV=new O.ptr(new IY([new P.ptr(181,837,656)]),IZ.nil,0);IW=new O.ptr(new IY([new P.ptr(921,953,32),new P.ptr(8126,8126,1)]),IZ.nil,0);$pkg.FoldScript=$makeMap($String.keyFor,[{k:"Common",v:IU},{k:"Greek",v:IV},{k:"Inherited",v:IW}]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["reflect"]=(function(){var $pkg={},$init,A,C,H,D,B,E,F,G,N,P,Q,R,AW,CB,CC,CD,CE,CF,CG,CH,CI,CJ,CK,CL,CM,CN,CO,CP,CQ,CS,DB,DC,DD,DG,DH,DI,EY,EZ,FC,FM,HQ,HR,HS,HV,HW,HX,HY,HZ,IA,IB,IC,ID,IE,IF,IG,IH,II,IJ,IK,IL,IM,IP,IQ,IR,IS,IT,IU,JC,JE,JG,JH,JI,JJ,JQ,JR,JS,I,O,S,U,W,BJ,BK,BO,CT,FL,J,K,L,M,T,V,X,Y,Z,AA,AB,AC,AD,AE,AH,AJ,AK,AL,AM,AO,AS,AT,AU,AV,AX,AY,AZ,BA,BB,BC,BE,BF,BG,BH,BI,BL,BM,BN,BP,BQ,BU,DK,DM,DN,DO,DP,EQ,EV,FN,FO,GH,GJ,GK,GL,GM,GN,GO,GP,GQ,GR,GS,GT,GU,GV,GW,GX,GY,GZ,HA,HB,HC,HD,HE;A=$packages["errors"];C=$packages["github.com/gopherjs/gopherjs/js"];H=$packages["math"];D=$packages["runtime"];B=$packages["strconv"];E=$packages["sync"];F=$packages["unicode"];G=$packages["unicode/utf8"];N=$pkg.uncommonType=$newType(0,$kindStruct,"reflect.uncommonType",true,"reflect",false,function(pkgPath_,mcount_,xcount_,moff_,_methods_){this.$val=this;if(arguments.length===0){this.pkgPath=0;this.mcount=0;this.xcount=0;this.moff=0;this._methods=IB.nil;return;}this.pkgPath=pkgPath_;this.mcount=mcount_;this.xcount=xcount_;this.moff=moff_;this._methods=_methods_;});P=$pkg.funcType=$newType(0,$kindStruct,"reflect.funcType",true,"reflect",false,function(rtype_,inCount_,outCount_,_in_,_out_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.inCount=0;this.outCount=0;this._in=HS.nil;this._out=HS.nil;return;}this.rtype=rtype_;this.inCount=inCount_;this.outCount=outCount_;this._in=_in_;this._out=_out_;});Q=$pkg.name=$newType(0,$kindStruct,"reflect.name",true,"reflect",false,function(bytes_){this.$val=this;if(arguments.length===0){this.bytes=IA.nil;return;}this.bytes=bytes_;});R=$pkg.nameData=$newType(0,$kindStruct,"reflect.nameData",true,"reflect",false,function(name_,tag_,exported_){this.$val=this;if(arguments.length===0){this.name="";this.tag="";this.exported=false;return;}this.name=name_;this.tag=tag_;this.exported=exported_;});AW=$pkg.mapIter=$newType(0,$kindStruct,"reflect.mapIter",true,"reflect",false,function(t_,m_,keys_,i_,last_){this.$val=this;if(arguments.length===0){this.t=$ifaceNil;this.m=null;this.keys=null;this.i=0;this.last=null;return;}this.t=t_;this.m=m_;this.keys=keys_;this.i=i_;this.last=last_;});CB=$pkg.Type=$newType(8,$kindInterface,"reflect.Type",true,"reflect",true,null);CC=$pkg.Kind=$newType(4,$kindUint,"reflect.Kind",true,"reflect",true,null);CD=$pkg.tflag=$newType(1,$kindUint8,"reflect.tflag",true,"reflect",false,null);CE=$pkg.rtype=$newType(0,$kindStruct,"reflect.rtype",true,"reflect",false,function(size_,ptrdata_,hash_,tflag_,align_,fieldAlign_,kind_,alg_,gcdata_,str_,ptrToThis_){this.$val=this;if(arguments.length===0){this.size=0;this.ptrdata=0;this.hash=0;this.tflag=0;this.align=0;this.fieldAlign=0;this.kind=0;this.alg=HZ.nil;this.gcdata=IA.nil;this.str=0;this.ptrToThis=0;return;}this.size=size_;this.ptrdata=ptrdata_;this.hash=hash_;this.tflag=tflag_;this.align=align_;this.fieldAlign=fieldAlign_;this.kind=kind_;this.alg=alg_;this.gcdata=gcdata_;this.str=str_;this.ptrToThis=ptrToThis_;});CF=$pkg.typeAlg=$newType(0,$kindStruct,"reflect.typeAlg",true,"reflect",false,function(hash_,equal_){this.$val=this;if(arguments.length===0){this.hash=$throwNilPointerError;this.equal=$throwNilPointerError;return;}this.hash=hash_;this.equal=equal_;});CG=$pkg.method=$newType(0,$kindStruct,"reflect.method",true,"reflect",false,function(name_,mtyp_,ifn_,tfn_){this.$val=this;if(arguments.length===0){this.name=0;this.mtyp=0;this.ifn=0;this.tfn=0;return;}this.name=name_;this.mtyp=mtyp_;this.ifn=ifn_;this.tfn=tfn_;});CH=$pkg.ChanDir=$newType(4,$kindInt,"reflect.ChanDir",true,"reflect",true,null);CI=$pkg.arrayType=$newType(0,$kindStruct,"reflect.arrayType",true,"reflect",false,function(rtype_,elem_,slice_,len_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.elem=HR.nil;this.slice=HR.nil;this.len=0;return;}this.rtype=rtype_;this.elem=elem_;this.slice=slice_;this.len=len_;});CJ=$pkg.chanType=$newType(0,$kindStruct,"reflect.chanType",true,"reflect",false,function(rtype_,elem_,dir_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.elem=HR.nil;this.dir=0;return;}this.rtype=rtype_;this.elem=elem_;this.dir=dir_;});CK=$pkg.imethod=$newType(0,$kindStruct,"reflect.imethod",true,"reflect",false,function(name_,typ_){this.$val=this;if(arguments.length===0){this.name=0;this.typ=0;return;}this.name=name_;this.typ=typ_;});CL=$pkg.interfaceType=$newType(0,$kindStruct,"reflect.interfaceType",true,"reflect",false,function(rtype_,pkgPath_,methods_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.pkgPath=new Q.ptr(IA.nil);this.methods=IC.nil;return;}this.rtype=rtype_;this.pkgPath=pkgPath_;this.methods=methods_;});CM=$pkg.mapType=$newType(0,$kindStruct,"reflect.mapType",true,"reflect",false,function(rtype_,key_,elem_,bucket_,keysize_,valuesize_,bucketsize_,flags_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.key=HR.nil;this.elem=HR.nil;this.bucket=HR.nil;this.keysize=0;this.valuesize=0;this.bucketsize=0;this.flags=0;return;}this.rtype=rtype_;this.key=key_;this.elem=elem_;this.bucket=bucket_;this.keysize=keysize_;this.valuesize=valuesize_;this.bucketsize=bucketsize_;this.flags=flags_;});CN=$pkg.ptrType=$newType(0,$kindStruct,"reflect.ptrType",true,"reflect",false,function(rtype_,elem_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.elem=HR.nil;return;}this.rtype=rtype_;this.elem=elem_;});CO=$pkg.sliceType=$newType(0,$kindStruct,"reflect.sliceType",true,"reflect",false,function(rtype_,elem_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.elem=HR.nil;return;}this.rtype=rtype_;this.elem=elem_;});CP=$pkg.structField=$newType(0,$kindStruct,"reflect.structField",true,"reflect",false,function(name_,typ_,offsetEmbed_){this.$val=this;if(arguments.length===0){this.name=new Q.ptr(IA.nil);this.typ=HR.nil;this.offsetEmbed=0;return;}this.name=name_;this.typ=typ_;this.offsetEmbed=offsetEmbed_;});CQ=$pkg.structType=$newType(0,$kindStruct,"reflect.structType",true,"reflect",false,function(rtype_,pkgPath_,fields_){this.$val=this;if(arguments.length===0){this.rtype=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);this.pkgPath=new Q.ptr(IA.nil);this.fields=ID.nil;return;}this.rtype=rtype_;this.pkgPath=pkgPath_;this.fields=fields_;});CS=$pkg.Method=$newType(0,$kindStruct,"reflect.Method",true,"reflect",true,function(Name_,PkgPath_,Type_,Func_,Index_){this.$val=this;if(arguments.length===0){this.Name="";this.PkgPath="";this.Type=$ifaceNil;this.Func=new EY.ptr(HR.nil,0,0);this.Index=0;return;}this.Name=Name_;this.PkgPath=PkgPath_;this.Type=Type_;this.Func=Func_;this.Index=Index_;});DB=$pkg.nameOff=$newType(4,$kindInt32,"reflect.nameOff",true,"reflect",false,null);DC=$pkg.typeOff=$newType(4,$kindInt32,"reflect.typeOff",true,"reflect",false,null);DD=$pkg.textOff=$newType(4,$kindInt32,"reflect.textOff",true,"reflect",false,null);DG=$pkg.StructField=$newType(0,$kindStruct,"reflect.StructField",true,"reflect",true,function(Name_,PkgPath_,Type_,Tag_,Offset_,Index_,Anonymous_){this.$val=this;if(arguments.length===0){this.Name="";this.PkgPath="";this.Type=$ifaceNil;this.Tag="";this.Offset=0;this.Index=IR.nil;this.Anonymous=false;return;}this.Name=Name_;this.PkgPath=PkgPath_;this.Type=Type_;this.Tag=Tag_;this.Offset=Offset_;this.Index=Index_;this.Anonymous=Anonymous_;});DH=$pkg.StructTag=$newType(8,$kindString,"reflect.StructTag",true,"reflect",true,null);DI=$pkg.fieldScan=$newType(0,$kindStruct,"reflect.fieldScan",true,"reflect",false,function(typ_,index_){this.$val=this;if(arguments.length===0){this.typ=IT.nil;this.index=IR.nil;return;}this.typ=typ_;this.index=index_;});EY=$pkg.Value=$newType(0,$kindStruct,"reflect.Value",true,"reflect",true,function(typ_,ptr_,flag_){this.$val=this;if(arguments.length===0){this.typ=HR.nil;this.ptr=0;this.flag=0;return;}this.typ=typ_;this.ptr=ptr_;this.flag=flag_;});EZ=$pkg.flag=$newType(4,$kindUintptr,"reflect.flag",true,"reflect",false,null);FC=$pkg.ValueError=$newType(0,$kindStruct,"reflect.ValueError",true,"reflect",true,function(Method_,Kind_){this.$val=this;if(arguments.length===0){this.Method="";this.Kind=0;return;}this.Method=Method_;this.Kind=Kind_;});FM=$pkg.MapIter=$newType(0,$kindStruct,"reflect.MapIter",true,"reflect",true,function(m_,it_){this.$val=this;if(arguments.length===0){this.m=new EY.ptr(HR.nil,0,0);this.it=0;return;}this.m=m_;this.it=it_;});HQ=$sliceType(Q);HR=$ptrType(CE);HS=$sliceType(HR);HV=$sliceType($emptyInterface);HW=$ptrType(C.Object);HX=$funcType([HV],[HW],true);HY=$sliceType($String);HZ=$ptrType(CF);IA=$ptrType($Uint8);IB=$sliceType(CG);IC=$sliceType(CK);ID=$sliceType(CP);IE=$ptrType(N);IF=$ptrType(R);IG=$structType("reflect",[{prop:"str",name:"str",embedded:false,exported:false,typ:$String,tag:""}]);IH=$sliceType(HW);II=$sliceType(EY);IJ=$ptrType(AW);IK=$ptrType(P);IL=$sliceType(CB);IM=$sliceType(IH);IP=$ptrType(CL);IQ=$ptrType(CK);IR=$sliceType($Int);IS=$sliceType(DI);IT=$ptrType(CQ);IU=$sliceType($Uint8);JC=$ptrType($UnsafePointer);JE=$sliceType($Int32);JG=$funcType([$String],[$Bool],false);JH=$funcType([$UnsafePointer,$Uintptr],[$Uintptr],false);JI=$funcType([$UnsafePointer,$UnsafePointer],[$Bool],false);JJ=$ptrType(CP);JQ=$arrayType($Uintptr,2);JR=$ptrType(FM);JS=$ptrType(FC);J=function(){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=(function(an){var an;});$r=an((ao=new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),new ao.constructor.elem(ao)));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((ap=new N.ptr(0,0,0,0,IB.nil),new ap.constructor.elem(ap)));$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((aq=new CG.ptr(0,0,0,0),new aq.constructor.elem(aq)));$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((ar=new CI.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),HR.nil,HR.nil,0),new ar.constructor.elem(ar)));$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((as=new CJ.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),HR.nil,0),new as.constructor.elem(as)));$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((at=new P.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),0,0,HS.nil,HS.nil),new at.constructor.elem(at)));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((au=new CL.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),new Q.ptr(IA.nil),IC.nil),new au.constructor.elem(au)));$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((av=new CM.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),HR.nil,HR.nil,HR.nil,0,0,0,0),new av.constructor.elem(av)));$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((aw=new CN.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),HR.nil),new aw.constructor.elem(aw)));$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((ax=new CO.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),HR.nil),new ax.constructor.elem(ax)));$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((ay=new CQ.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),new Q.ptr(IA.nil),ID.nil),new ay.constructor.elem(ay)));$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((az=new CK.ptr(0,0),new az.constructor.elem(az)));$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=an((ba=new CP.ptr(new Q.ptr(IA.nil),HR.nil,0),new ba.constructor.elem(ba)));$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}I=true;FL=$assertType(AD(new $Uint8(0)),HR);$s=-1;return;}return;}if($f===undefined){$f={$blk:J};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.$s=$s;$f.$r=$r;return $f;};K=function(an){var an;return an.jsType;};L=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,bw,bx,by,bz;if(an.reflectType===undefined){ao=new CE.ptr(((($parseInt(an.size)>>0)>>>0)),0,0,0,0,0,((($parseInt(an.kind)>>0)<<24>>>24)),HZ.nil,IA.nil,V($clone(T(Y(an.string),"",!!(an.exported)),Q)),0);ao.jsType=an;an.reflectType=ao;ap=$methodSet(an);if(!(($parseInt(ap.length)===0))||!!(an.named)){ao.tflag=(ao.tflag|(1))>>>0;if(!!(an.named)){ao.tflag=(ao.tflag|(4))>>>0;}aq=IB.nil;ar=0;while(true){if(!(ar<$parseInt(ap.length))){break;}as=ap[ar];at=Y(as.pkg)==="";if(!at){ar=ar+(1)>>0;continue;}aq=$append(aq,new CG.ptr(V($clone(T(Y(as.name),"",at),Q)),X(L(as.typ)),0,0));ar=ar+(1)>>0;}au=((aq.$length<<16>>>16));av=0;while(true){if(!(av<$parseInt(ap.length))){break;}aw=ap[av];ax=Y(aw.pkg)==="";if(ax){av=av+(1)>>0;continue;}aq=$append(aq,new CG.ptr(V($clone(T(Y(aw.name),"",ax),Q)),X(L(aw.typ)),0,0));av=av+(1)>>0;}ay=new N.ptr(V($clone(T(Y(an.pkg),"",false),Q)),(($parseInt(ap.length)<<16>>>16)),au,0,aq);az=ao;(O||$throwRuntimeError("assignment to entry in nil map"))[HR.keyFor(az)]={k:az,v:ay};ay.jsType=an;}ba=ao.Kind();if(ba===(17)){M(ao,new CI.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),L(an.elem),HR.nil,((($parseInt(an.len)>>0)>>>0))));}else if(ba===(18)){bb=3;if(!!(an.sendOnly)){bb=2;}if(!!(an.recvOnly)){bb=1;}M(ao,new CJ.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),L(an.elem),((bb>>>0))));}else if(ba===(19)){bc=an.params;bd=$makeSlice(HS,$parseInt(bc.length));be=bd;bf=0;while(true){if(!(bf=bd.$length)?($throwRuntimeError("index out of range"),undefined):bd.$array[bd.$offset+bg]=L(bc[bg]));bf++;}bh=an.results;bi=$makeSlice(HS,$parseInt(bh.length));bj=bi;bk=0;while(true){if(!(bk=bi.$length)?($throwRuntimeError("index out of range"),undefined):bi.$array[bi.$offset+bl]=L(bh[bl]));bk++;}bm=(($parseInt(bh.length)<<16>>>16));if(!!(an.variadic)){bm=(bm|(32768))>>>0;}M(ao,new P.ptr($clone(ao,CE),(($parseInt(bc.length)<<16>>>16)),bm,bd,bi));}else if(ba===(20)){bn=an.methods;bo=$makeSlice(IC,$parseInt(bn.length));bp=bo;bq=0;while(true){if(!(bq=bo.$length)?($throwRuntimeError("index out of range"),undefined):bo.$array[bo.$offset+br]),new CK.ptr(V($clone(T(Y(bs.name),"",Y(bs.pkg)===""),Q)),X(L(bs.typ))));bq++;}M(ao,new CL.ptr($clone(ao,CE),$clone(T(Y(an.pkg),"",false),Q),bo));}else if(ba===(21)){M(ao,new CM.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),L(an.key),L(an.elem),HR.nil,0,0,0,0));}else if(ba===(22)){M(ao,new CN.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),L(an.elem)));}else if(ba===(23)){M(ao,new CO.ptr(new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0),L(an.elem)));}else if(ba===(25)){bt=an.fields;bu=$makeSlice(ID,$parseInt(bt.length));bv=bu;bw=0;while(true){if(!(bw>>0))<<1>>>0;if(!!(by.embedded)){bz=(bz|(1))>>>0;}CP.copy(((bx<0||bx>=bu.$length)?($throwRuntimeError("index out of range"),undefined):bu.$array[bu.$offset+bx]),new CP.ptr($clone(T(Y(by.name),Y(by.tag),!!(by.exported)),Q),L(by.typ),bz));bw++;}M(ao,new CQ.ptr($clone(ao,CE),$clone(T(Y(an.pkgPath),"",false),Q),bu));}}return((an.reflectType));};M=function(an,ao){var an,ao;an.kindType=ao;ao.rtype=an;};N.ptr.prototype.methods=function(){var an;an=this;return an._methods;};N.prototype.methods=function(){return this.$val.methods();};N.ptr.prototype.exportedMethods=function(){var an;an=this;return $subslice(an._methods,0,an.xcount,an.xcount);};N.prototype.exportedMethods=function(){return this.$val.exportedMethods();};CE.ptr.prototype.uncommon=function(){var an,ao;an=this;return(ao=O[HR.keyFor(an)],ao!==undefined?ao.v:IE.nil);};CE.prototype.uncommon=function(){return this.$val.uncommon();};P.ptr.prototype.in$=function(){var an;an=this;return an._in;};P.prototype.in$=function(){return this.$val.in$();};P.ptr.prototype.out=function(){var an;an=this;return an._out;};P.prototype.out=function(){return this.$val.out();};Q.ptr.prototype.name=function(){var an,ao,ap;an="";ao=this;an=(ap=S[IA.keyFor(ao.bytes)],ap!==undefined?ap.v:IF.nil).name;return an;};Q.prototype.name=function(){return this.$val.name();};Q.ptr.prototype.tag=function(){var an,ao,ap;an="";ao=this;an=(ap=S[IA.keyFor(ao.bytes)],ap!==undefined?ap.v:IF.nil).tag;return an;};Q.prototype.tag=function(){return this.$val.tag();};Q.ptr.prototype.pkgPath=function(){var an;an=this;return"";};Q.prototype.pkgPath=function(){return this.$val.pkgPath();};Q.ptr.prototype.isExported=function(){var an,ao;an=this;return(ao=S[IA.keyFor(an.bytes)],ao!==undefined?ao.v:IF.nil).exported;};Q.prototype.isExported=function(){return this.$val.isExported();};T=function(an,ao,ap){var an,ao,ap,aq,ar;aq=$newDataPointer(0,IA);ar=aq;(S||$throwRuntimeError("assignment to entry in nil map"))[IA.keyFor(ar)]={k:ar,v:new R.ptr(an,ao,ap)};return new Q.ptr(aq);};CE.ptr.prototype.nameOff=function(an){var an,ao,ap;ao=this;return(ap=((an>>0)),((ap<0||ap>=U.$length)?($throwRuntimeError("index out of range"),undefined):U.$array[U.$offset+ap]));};CE.prototype.nameOff=function(an){return this.$val.nameOff(an);};V=function(an){var an,ao;ao=U.$length;U=$append(U,an);return((ao>>0));};CE.ptr.prototype.typeOff=function(an){var an,ao,ap;ao=this;return(ap=((an>>0)),((ap<0||ap>=W.$length)?($throwRuntimeError("index out of range"),undefined):W.$array[W.$offset+ap]));};CE.prototype.typeOff=function(an){return this.$val.typeOff(an);};X=function(an){var an,ao;ao=W.$length;W=$append(W,an);return((ao>>0));};Y=function(an){var an,ao;ao=new IG.ptr("");ao.str=an;return ao.str;};Z=function(an){var an;return!!(K(an).wrapped);};AA=function(an,ao,ap){var an,ao,ap,aq,ar,as;aq=K(ap).fields;ar=0;while(true){if(!(ar<$parseInt(aq.length))){break;}as=$internalize(aq[ar].prop,$String);an[$externalize(as,$String)]=ao[$externalize(as,$String)];ar=ar+(1)>>0;}};AB=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=an.common();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;au=an.Kind();$s=6;case 6:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}if(au===17){at=true;$s=5;continue s;}av=an.Kind();$s=7;case 7:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}at=av===25;case 5:if(at){as=true;$s=4;continue s;}aw=an.Kind();$s=8;case 8:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}as=aw===22;case 4:if(as){$s=2;continue;}$s=3;continue;case 2:ax=an.Kind();$s=9;case 9:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}$s=-1;return new EY.ptr(ar,(ao),(ap|((ax>>>0)))>>>0);case 3:ay=an.Kind();$s=10;case 10:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}$s=-1;return new EY.ptr(ar,($newDataPointer(ao,K(ar.ptrTo()))),(((ap|((ay>>>0)))>>>0)|128)>>>0);}return;}if($f===undefined){$f={$blk:AB};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.$s=$s;$f.$r=$r;return $f;};AC=function(an,ao,ap){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=[an];aq=an[0].Kind();$s=3;case 3:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}if(!((aq===23))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.MakeSlice of non-slice type"));case 2:if(ao<0){$panic(new $String("reflect.MakeSlice: negative len"));}if(ap<0){$panic(new $String("reflect.MakeSlice: negative cap"));}if(ao>ap){$panic(new $String("reflect.MakeSlice: len > cap"));}ar=AB(an[0],$makeSlice(K(an[0]),ao,ap,(function(an){return function $b(){var ar,as,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;ar=$f.ar;as=$f.as;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ar=an[0].Elem();$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=K(ar);$s=2;case 2:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}$s=-1;return as.zero();}return;}if($f===undefined){$f={$blk:$b};}$f.ar=ar;$f.as=as;$f.$s=$s;$f.$r=$r;return $f;};})(an)),0);$s=4;case 4:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}$s=-1;return ar;}return;}if($f===undefined){$f={$blk:AC};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};$pkg.MakeSlice=AC;AD=function(an){var an;if(!I){return new CE.ptr(0,0,0,0,0,0,0,HZ.nil,IA.nil,0,0);}if($interfaceIsEqual(an,$ifaceNil)){return $ifaceNil;}return L(an.constructor);};$pkg.TypeOf=AD;AE=function(an){var an,ao,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if($interfaceIsEqual(an,$ifaceNil)){$s=-1;return new EY.ptr(HR.nil,0,0);}ao=AB(L(an.constructor),an.$val,0);$s=1;case 1:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}$s=-1;return ao;}return;}if($f===undefined){$f={$blk:AE};}$f.an=an;$f.ao=ao;$f.$s=$s;$f.$r=$r;return $f;};$pkg.ValueOf=AE;AH=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(!(ap)){aq=false;$s=3;continue s;}if(an.$length===0){ar=true;$s=4;continue s;}at=(as=an.$length-1>>0,((as<0||as>=an.$length)?($throwRuntimeError("index out of range"),undefined):an.$array[an.$offset+as])).Kind();$s=5;case 5:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}ar=!((at===23));case 4:aq=ar;case 3:if(aq){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.FuncOf: last arg of variadic func must be slice"));case 2:au=$makeSlice(IH,an.$length);av=an;aw=0;while(true){if(!(aw=av.$length)?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+aw]);((ax<0||ax>=au.$length)?($throwRuntimeError("index out of range"),undefined):au.$array[au.$offset+ax]=K(ay));aw++;}az=$makeSlice(IH,ao.$length);ba=ao;bb=0;while(true){if(!(bb=ba.$length)?($throwRuntimeError("index out of range"),undefined):ba.$array[ba.$offset+bb]);((bc<0||bc>=az.$length)?($throwRuntimeError("index out of range"),undefined):az.$array[az.$offset+bc]=K(bd));bb++;}$s=-1;return L($funcType($externalize(au,IH),$externalize(az,IH),$externalize(ap,$Bool)));}return;}if($f===undefined){$f={$blk:AH};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.$s=$s;$f.$r=$r;return $f;};$pkg.FuncOf=AH;CE.ptr.prototype.ptrTo=function(){var an;an=this;return L($ptrType(K(an)));};CE.prototype.ptrTo=function(){return this.$val.ptrTo();};AJ=function(an){var an;return L($sliceType(K(an)));};$pkg.SliceOf=AJ;AK=function(an){var an,ao,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=AB(an,K(an).zero(),0);$s=1;case 1:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}$s=-1;return ao;}return;}if($f===undefined){$f={$blk:AK};}$f.an=an;$f.ao=ao;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Zero=AK;AL=function(an){var an,ao;ao=an.Kind();if(ao===(25)){return(new(K(an).ptr)());}else if(ao===(17)){return(K(an).zero());}else{return($newDataPointer(K(an).zero(),K(an.ptrTo())));}};AM=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=ap.common();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;as=AL(ar);at=ar.Kind();if(at===(3)){(as).$set(((ao.$low<<24>>24)));}else if(at===(4)){(as).$set(((ao.$low<<16>>16)));}else if((at===(2))||(at===(5))){(as).$set(((ao.$low>>0)));}else if(at===(6)){(as).$set((new $Int64(ao.$high,ao.$low)));}else if(at===(8)){(as).$set(((ao.$low<<24>>>24)));}else if(at===(9)){(as).$set(((ao.$low<<16>>>16)));}else if((at===(7))||(at===(10))||(at===(12))){(as).$set(((ao.$low>>>0)));}else if(at===(11)){(as).$set((ao));}$s=-1;return new EY.ptr(ar,as,(((an|128)>>>0)|((ar.Kind()>>>0)))>>>0);}return;}if($f===undefined){$f={$blk:AM};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};AO=function(an,ao,ap){var an,ao,ap;ao.$set(ap.$get());};AS=function(an,ao){var an,ao,ap,aq;ap=ao;if(!(ap.$get===undefined)){ap=ap.$get();}aq=$internalize(K(an.Key()).keyFor(ap),$String);return[ap,aq];};AT=function(an,ao,ap){var an,ao,ap,aq,ar,as;aq=AS(an,ap);ar=aq[1];as=ao[$externalize(ar,$String)];if(as===undefined){return 0;}return($newDataPointer(as.v,K(DK(an.Elem()))));};AU=function(an,ao,ap,aq){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ar=AS(an,ap);as=ar[0];at=ar[1];au=aq.$get();av=an.Elem();aw=av.Kind();$s=3;case 3:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}if(aw===25){$s=1;continue;}$s=2;continue;case 1:ax=K(av).zero();AA(ax,au,av);au=ax;case 2:ay=new($global.Object)();ay.k=as;ay.v=au;ao[$externalize(at,$String)]=ay;$s=-1;return;}return;}if($f===undefined){$f={$blk:AU};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.$s=$s;$f.$r=$r;return $f;};AV=function(an,ao,ap){var an,ao,ap,aq,ar;aq=AS(an,ap);ar=aq[1];delete ao[$externalize(ar,$String)];};AW.ptr.prototype.skipUntilValidKey=function(){var an,ao;an=this;while(true){if(!(an.i<$parseInt(an.keys.length))){break;}ao=an.keys[an.i];if(!(an.m[$externalize($internalize(ao,$String),$String)]===undefined)){break;}an.i=an.i+(1)>>0;}};AW.prototype.skipUntilValidKey=function(){return this.$val.skipUntilValidKey();};AX=function(an,ao){var an,ao;return(new AW.ptr(an,ao,$keys(ao),0,null));};AY=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=($pointerOfStructConversion(an,IJ));ap=null;if(!(ao.last===null)){ap=ao.last;}else{ao.skipUntilValidKey();if(ao.i===$parseInt(ao.keys.length)){$s=-1;return 0;}aq=ao.keys[ao.i];ap=ao.m[$externalize($internalize(aq,$String),$String)];ao.last=ap;}ar=ao.t.Key();$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=DK(ar);$s=2;case 2:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}at=K(as);$s=3;case 3:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return($newDataPointer(ap.k,at));}return;}if($f===undefined){$f={$blk:AY};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};AZ=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=($pointerOfStructConversion(an,IJ));ap=null;if(!(ao.last===null)){ap=ao.last;}else{ao.skipUntilValidKey();if(ao.i===$parseInt(ao.keys.length)){$s=-1;return 0;}aq=ao.keys[ao.i];ap=ao.m[$externalize($internalize(aq,$String),$String)];ao.last=ap;}ar=ao.t.Elem();$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=DK(ar);$s=2;case 2:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}at=K(as);$s=3;case 3:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return($newDataPointer(ap.v,at));}return;}if($f===undefined){$f={$blk:AZ};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};BA=function(an){var an,ao;ao=($pointerOfStructConversion(an,IJ));ao.last=null;ao.i=ao.i+(1)>>0;};BB=function(an){var an;return $parseInt($keys(an).length);};BC=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=$clone(an,EY).object();if(ap===K(an.typ).nil){$s=1;continue;}$s=2;continue;case 1:aq=AB(ao,K(ao).nil,an.flag);$s=3;case 3:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;case 2:ar=null;as=ao.Kind();$s=5;case 5:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}at=as;au=at;if(au===(23)){$s=6;continue;}if(au===(22)){$s=7;continue;}if(au===(25)){$s=8;continue;}if((au===(17))||(au===(1))||(au===(18))||(au===(19))||(au===(20))||(au===(21))||(au===(24))){$s=9;continue;}$s=10;continue;case 6:av=new(K(ao))(ap.$array);av.$offset=ap.$offset;av.$length=ap.$length;av.$capacity=ap.$capacity;ar=$newDataPointer(av,K(DK(ao)));$s=11;continue;case 7:aw=ao.Elem();$s=14;case 14:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}ax=aw.Kind();$s=15;case 15:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}if(ax===25){$s=12;continue;}$s=13;continue;case 12:ay=ao.Elem();$s=18;case 18:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}if($interfaceIsEqual(ay,an.typ.Elem())){$s=16;continue;}$s=17;continue;case 16:ar=ap;$s=4;continue;case 17:ar=new(K(ao))();az=ar;ba=ap;bb=ao.Elem();$s=19;case 19:if($c){$c=false;bb=bb.$blk();}if(bb&&bb.$blk!==undefined){break s;}bc=bb;$r=AA(az,ba,bc);$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=4;continue;case 13:ar=new(K(ao))(ap.$get,ap.$set);$s=11;continue;case 8:ar=new(K(ao).ptr)();AA(ar,ap,ao);$s=11;continue;case 9:ar=an.ptr;$s=11;continue;case 10:$panic(new FC.ptr("reflect.Convert",at));case 11:case 4:bd=ao.common();$s=21;case 21:if($c){$c=false;bd=bd.$blk();}if(bd&&bd.$blk!==undefined){break s;}be=ao.Kind();$s=22;case 22:if($c){$c=false;be=be.$blk();}if(be&&be.$blk!==undefined){break s;}$s=-1;return new EY.ptr(bd,(ar),(((new EZ(an.flag).ro()|((an.flag&128)>>>0))>>>0)|((be>>>0)))>>>0);}return;}if($f===undefined){$f={$blk:BC};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.$s=$s;$f.$r=$r;return $f;};BE=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az;aq=HR.nil;ar=IK.nil;as=0;at="";if(ao.typ.Kind()===20){au=(ao.typ.kindType);if(ap<0||ap>=au.methods.$length){$panic(new $String("reflect: internal error: invalid method index"));}aw=(av=au.methods,((ap<0||ap>=av.$length)?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+ap]));if(!$clone(au.rtype.nameOff(aw.name),Q).isExported()){$panic(new $String("reflect: "+an+" of unexported method"));}ar=(au.rtype.typeOff(aw.typ).kindType);at=$clone(au.rtype.nameOff(aw.name),Q).name();}else{ax=ao.typ.exportedMethods();if(((ap>>>0))>=((ax.$length>>>0))){$panic(new $String("reflect: internal error: invalid method index"));}ay=$clone(((ap<0||ap>=ax.$length)?($throwRuntimeError("index out of range"),undefined):ax.$array[ax.$offset+ap]),CG);if(!$clone(ao.typ.nameOff(ay.name),Q).isExported()){$panic(new $String("reflect: "+an+" of unexported method"));}ar=(ao.typ.typeOff(ay.mtyp).kindType);at=$internalize($methodSet(K(ao.typ))[ap].prop,$String);}az=$clone(ao,EY).object();if(Z(ao.typ)){az=new(K(ao.typ))(az);}as=(az[$externalize(at,$String)]);return[aq,ar,as];};BF=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(an.flag===0){$panic(new FC.ptr("reflect.Value.Interface",0));}if(ao&&!((((an.flag&96)>>>0)===0))){$panic(new $String("reflect.Value.Interface: cannot return value obtained from unexported field or method"));}if(!((((an.flag&512)>>>0)===0))){$s=1;continue;}$s=2;continue;case 1:ap=BI("Interface",$clone(an,EY));$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}an=ap;case 2:if(Z(an.typ)){$s=-1;return((new(K(an.typ))($clone(an,EY).object())));}$s=-1;return(($clone(an,EY).object()));}return;}if($f===undefined){$f={$blk:BF};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};BG=function(an,ao,ap){var an,ao,ap;ap.$set(ao);};BH=function(){return"?FIXME?";};BI=function(an,ao){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=[ap];aq=[aq];if(((ao.flag&512)>>>0)===0){$panic(new $String("reflect: internal error: invalid use of makePartialFunc"));}ar=BE(an,$clone(ao,EY),((ao.flag>>0))>>10>>0);ap[0]=ar[2];aq[0]=$clone(ao,EY).object();if(Z(ao.typ)){aq[0]=new(K(ao.typ))(aq[0]);}as=C.MakeFunc((function(ap,aq){return function(as,at){var as,at;return new $jsObjectPtr(ap[0].apply(aq[0],$externalize(at,IH)));};})(ap,aq));at=$clone(ao,EY).Type().common();$s=1;case 1:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return new EY.ptr(at,(as),(new EZ(ao.flag).ro()|19)>>>0);}return;}if($f===undefined){$f={$blk:BI};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};CE.ptr.prototype.pointers=function(){var an,ao;an=this;ao=an.Kind();if((ao===(22))||(ao===(21))||(ao===(18))||(ao===(19))||(ao===(25))||(ao===(17))){return true;}else{return false;}};CE.prototype.pointers=function(){return this.$val.pointers();};CE.ptr.prototype.Comparable=function(){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;ao=an.Kind();if((ao===(19))||(ao===(23))||(ao===(21))){$s=2;continue;}if(ao===(17)){$s=3;continue;}if(ao===(25)){$s=4;continue;}$s=5;continue;case 2:$s=-1;return false;case 3:ap=an.Elem().Comparable();$s=6;case 6:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;case 4:aq=0;case 7:if(!(aq>0;$s=7;continue;case 8:case 5:case 1:$s=-1;return true;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.Comparable};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.Comparable=function(){return this.$val.Comparable();};CE.ptr.prototype.Method=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=[ao];ap=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);aq=this;if(aq.Kind()===20){ar=(aq.kindType);CS.copy(ap,ar.Method(an));$s=-1;return ap;}as=aq.exportedMethods();if(an<0||an>=as.$length){$panic(new $String("reflect: Method index out of range"));}at=$clone(((an<0||an>=as.$length)?($throwRuntimeError("index out of range"),undefined):as.$array[as.$offset+an]),CG);au=$clone(aq.nameOff(at.name),Q);ap.Name=$clone(au,Q).name();av=19;aw=aq.typeOff(at.mtyp);ax=(aw.kindType);ay=$makeSlice(IL,0,(1+ax.in$().$length>>0));ay=$append(ay,aq);az=ax.in$();ba=0;while(true){if(!(ba=az.$length)?($throwRuntimeError("index out of range"),undefined):az.$array[az.$offset+ba]);ay=$append(ay,bb);ba++;}bc=$makeSlice(IL,0,ax.out().$length);bd=ax.out();be=0;while(true){if(!(be=bd.$length)?($throwRuntimeError("index out of range"),undefined):bd.$array[bd.$offset+be]);bc=$append(bc,bf);be++;}bg=AH(ay,bc,ax.rtype.IsVariadic());$s=1;case 1:if($c){$c=false;bg=bg.$blk();}if(bg&&bg.$blk!==undefined){break s;}bh=bg;ap.Type=bh;ao[0]=$internalize($methodSet(aq.jsType)[an].prop,$String);bi=C.MakeFunc((function(ao){return function(bi,bj){var bi,bj,bk;bk=(0>=bj.$length?($throwRuntimeError("index out of range"),undefined):bj.$array[bj.$offset+0]);return new $jsObjectPtr(bk[$externalize(ao[0],$String)].apply(bk,$externalize($subslice(bj,1),IH)));};})(ao));ap.Func=new EY.ptr($assertType(bh,HR),(bi),av);ap.Index=an;CS.copy(ap,ap);$s=-1;return ap;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.Method};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.Method=function(an){return this.$val.Method(an);};EY.ptr.prototype.object=function(){var an,ao,ap,aq;an=this;if((an.typ.Kind()===17)||(an.typ.Kind()===25)){return an.ptr;}if(!((((an.flag&128)>>>0)===0))){ao=an.ptr.$get();if(!(ao===$ifaceNil)&&!(ao.constructor===K(an.typ))){switch(0){default:ap=an.typ.Kind();if((ap===(11))||(ap===(6))){ao=new(K(an.typ))(ao.$high,ao.$low);}else if((ap===(15))||(ap===(16))){ao=new(K(an.typ))(ao.$real,ao.$imag);}else if(ap===(23)){if(ao===ao.constructor.nil){ao=K(an.typ).nil;break;}aq=new(K(an.typ))(ao.$array);aq.$offset=ao.$offset;aq.$length=ao.$length;aq.$capacity=ao.$capacity;ao=aq;}}}return ao;}return an.ptr;};EY.prototype.object=function(){return this.$val.object();};EY.ptr.prototype.assignTo=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=this;if(!((((aq.flag&512)>>>0)===0))){$s=1;continue;}$s=2;continue;case 1:ar=BI(an,$clone(aq,EY));$s=3;case 3:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}aq=ar;case 2:as=DN(ao,aq.typ);$s=8;case 8:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}if(as){$s=5;continue;}if(DM(ao,aq.typ)){$s=6;continue;}$s=7;continue;case 5:at=(((aq.flag&384)>>>0)|new EZ(aq.flag).ro())>>>0;at=(at|(((ao.Kind()>>>0))))>>>0;$s=-1;return new EY.ptr(ao,aq.ptr,at);case 6:if(ap===0){ap=AL(ao);}au=BF($clone(aq,EY),false);$s=9;case 9:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}av=au;if(ao.NumMethod()===0){(ap).$set(av);}else{BG(ao,av,ap);}$s=-1;return new EY.ptr(ao,ap,148);case 7:case 4:$panic(new $String(an+": value of type "+aq.typ.String()+" is not assignable to type "+ao.String()));$s=-1;return new EY.ptr(HR.nil,0,0);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.assignTo};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.assignTo=function(an,ao,ap){return this.$val.assignTo(an,ao,ap);};EY.ptr.prototype.call=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,bw,bx,by,bz,ca,cb,cc,cd,ce,cf,cg,ch,ci,cj,ck,cl,cm,cn,co,cp,cq,cr,cs,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;bu=$f.bu;bv=$f.bv;bw=$f.bw;bx=$f.bx;by=$f.by;bz=$f.bz;ca=$f.ca;cb=$f.cb;cc=$f.cc;cd=$f.cd;ce=$f.ce;cf=$f.cf;cg=$f.cg;ch=$f.ch;ci=$f.ci;cj=$f.cj;ck=$f.ck;cl=$f.cl;cm=$f.cm;cn=$f.cn;co=$f.co;cp=$f.cp;cq=$f.cq;cr=$f.cr;cs=$f.cs;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=this;aq=IK.nil;ar=0;as=null;if(!((((ap.flag&512)>>>0)===0))){at=BE(an,$clone(ap,EY),((ap.flag>>0))>>10>>0);aq=at[1];ar=at[2];as=$clone(ap,EY).object();if(Z(ap.typ)){as=new(K(ap.typ))(as);}}else{aq=(ap.typ.kindType);ar=($clone(ap,EY).object());as=undefined;}if(ar===0){$panic(new $String("reflect.Value.Call: call of nil function"));}au=an==="CallSlice";av=aq.rtype.NumIn();if(au){if(!aq.rtype.IsVariadic()){$panic(new $String("reflect: CallSlice of non-variadic function"));}if(ao.$lengthav){$panic(new $String("reflect: CallSlice with too many input arguments"));}}else{if(aq.rtype.IsVariadic()){av=av-(1)>>0;}if(ao.$lengthav){$panic(new $String("reflect: Call with too many input arguments"));}}aw=ao;ax=0;while(true){if(!(ax=aw.$length)?($throwRuntimeError("index out of range"),undefined):aw.$array[aw.$offset+ax]);if($clone(ay,EY).Kind()===0){$panic(new $String("reflect: "+an+" using zero Value argument"));}ax++;}az=0;case 1:if(!(az=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+az]),EY).Type();bb=aq.rtype.In(az);bc=ba;bd=bb;be=bc.AssignableTo(bd);$s=5;case 5:if($c){$c=false;be=be.$blk();}if(be&&be.$blk!==undefined){break s;}if(!be){$s=3;continue;}$s=4;continue;case 3:bf=bc.String();$s=6;case 6:if($c){$c=false;bf=bf.$blk();}if(bf&&bf.$blk!==undefined){break s;}bg=bd.String();$s=7;case 7:if($c){$c=false;bg=bg.$blk();}if(bg&&bg.$blk!==undefined){break s;}$panic(new $String("reflect: "+an+" using "+bf+" as type "+bg));case 4:az=az+(1)>>0;$s=1;continue;case 2:if(!au&&aq.rtype.IsVariadic()){$s=8;continue;}$s=9;continue;case 8:bh=ao.$length-av>>0;bi=AC(aq.rtype.In(av),bh,bh);$s=10;case 10:if($c){$c=false;bi=bi.$blk();}if(bi&&bi.$blk!==undefined){break s;}bj=bi;bk=aq.rtype.In(av).Elem();$s=11;case 11:if($c){$c=false;bk=bk.$blk();}if(bk&&bk.$blk!==undefined){break s;}bl=bk;bm=0;case 12:if(!(bm>0,((bn<0||bn>=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+bn]));bp=$clone(bo,EY).Type();bq=bp.AssignableTo(bl);$s=16;case 16:if($c){$c=false;bq=bq.$blk();}if(bq&&bq.$blk!==undefined){break s;}if(!bq){$s=14;continue;}$s=15;continue;case 14:br=bp.String();$s=17;case 17:if($c){$c=false;br=br.$blk();}if(br&&br.$blk!==undefined){break s;}bs=bl.String();$s=18;case 18:if($c){$c=false;bs=bs.$blk();}if(bs&&bs.$blk!==undefined){break s;}$panic(new $String("reflect: cannot use "+br+" as type "+bs+" in "+an));case 15:bt=$clone(bj,EY).Index(bm);$s=19;case 19:if($c){$c=false;bt=bt.$blk();}if(bt&&bt.$blk!==undefined){break s;}$r=$clone(bt,EY).Set($clone(bo,EY));$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}bm=bm+(1)>>0;$s=12;continue;case 13:bu=ao;ao=$makeSlice(II,(av+1>>0));$copySlice($subslice(ao,0,av),bu);((av<0||av>=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+av]=bj);case 9:bv=ao.$length;if(!((bv===aq.rtype.NumIn()))){$panic(new $String("reflect.Value.Call: wrong argument count"));}bw=aq.rtype.NumOut();bx=new($global.Array)(aq.rtype.NumIn());by=ao;bz=0;case 21:if(!(bz=by.$length)?($throwRuntimeError("index out of range"),undefined):by.$array[by.$offset+bz]);cc=aq.rtype.In(ca);cd=aq.rtype.In(ca).common();$s=23;case 23:if($c){$c=false;cd=cd.$blk();}if(cd&&cd.$blk!==undefined){break s;}ce=cd;cf=0;cg=$clone(cb,EY).assignTo("reflect.Value.Call",ce,cf);$s=24;case 24:if($c){$c=false;cg=cg.$blk();}if(cg&&cg.$blk!==undefined){break s;}ch=$clone(cg,EY).object();$s=25;case 25:if($c){$c=false;ch=ch.$blk();}if(ch&&ch.$blk!==undefined){break s;}ci=ch;cj=BM(cc,ci);$s=26;case 26:if($c){$c=false;cj=cj.$blk();}if(cj&&cj.$blk!==undefined){break s;}bx[ca]=cj;bz++;$s=21;continue;case 22:ck=BJ(new HV([new $jsObjectPtr(ar),new $jsObjectPtr(as),new $jsObjectPtr(bx)]));$s=27;case 27:if($c){$c=false;ck=ck.$blk();}if(ck&&ck.$blk!==undefined){break s;}cl=ck;cm=bw;if(cm===(0)){$s=29;continue;}if(cm===(1)){$s=30;continue;}$s=31;continue;case 29:$s=-1;return II.nil;case 30:cn=AB(aq.rtype.Out(0),BL(aq.rtype.Out(0),cl),0);$s=33;case 33:if($c){$c=false;cn=cn.$blk();}if(cn&&cn.$blk!==undefined){break s;}$s=-1;return new II([$clone(cn,EY)]);case 31:co=$makeSlice(II,bw);cp=co;cq=0;case 34:if(!(cq=co.$length)?($throwRuntimeError("index out of range"),undefined):co.$array[co.$offset+cr]=cs);cq++;$s=34;continue;case 35:$s=-1;return co;case 32:case 28:$s=-1;return II.nil;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.call};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.bu=bu;$f.bv=bv;$f.bw=bw;$f.bx=bx;$f.by=by;$f.bz=bz;$f.ca=ca;$f.cb=cb;$f.cc=cc;$f.cd=cd;$f.ce=ce;$f.cf=cf;$f.cg=cg;$f.ch=ch;$f.ci=ci;$f.cj=cj;$f.ck=ck;$f.cl=cl;$f.cm=cm;$f.cn=cn;$f.co=co;$f.cp=cp;$f.cq=cq;$f.cr=cr;$f.cs=cs;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.call=function(an,ao){return this.$val.call(an,ao);};EY.ptr.prototype.Cap=function(){var an,ao,ap;an=this;ao=new EZ(an.flag).kind();ap=ao;if(ap===(17)){return an.typ.Len();}else if((ap===(18))||(ap===(23))){return $parseInt($clone(an,EY).object().$capacity)>>0;}$panic(new FC.ptr("reflect.Value.Cap",ao));};EY.prototype.Cap=function(){return this.$val.Cap();};BL=function(an,ao){var an,ao;if($interfaceIsEqual(an,BK)){return new(K(BK))(ao);}return ao;};BM=function(an,ao){var an,ao;if($interfaceIsEqual(an,BK)){return ao.object;}return ao;};EY.ptr.prototype.Elem=function(){var an,ao,ap,aq,ar,as,at,au,av,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;ao=new EZ(an.flag).kind();ap=ao;if(ap===(20)){$s=2;continue;}if(ap===(22)){$s=3;continue;}$s=4;continue;case 2:aq=$clone(an,EY).object();if(aq===$ifaceNil){$s=-1;return new EY.ptr(HR.nil,0,0);}ar=L(aq.constructor);as=AB(ar,aq.$val,new EZ(an.flag).ro());$s=6;case 6:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}$s=-1;return as;case 3:if($clone(an,EY).IsNil()){$s=-1;return new EY.ptr(HR.nil,0,0);}at=$clone(an,EY).object();au=(an.typ.kindType);av=(((((an.flag&96)>>>0)|128)>>>0)|256)>>>0;av=(av|(((au.elem.Kind()>>>0))))>>>0;$s=-1;return new EY.ptr(au.elem,(BL(au.elem,at)),av);case 4:$panic(new FC.ptr("reflect.Value.Elem",ao));case 5:case 1:$s=-1;return new EY.ptr(HR.nil,0,0);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Elem};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Elem=function(){return this.$val.Elem();};EY.ptr.prototype.Field=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=[ao];ap=[ap];aq=[aq];ar=[ar];as=this;if(!((new EZ(as.flag).kind()===25))){$panic(new FC.ptr("reflect.Value.Field",new EZ(as.flag).kind()));}at=(as.typ.kindType);if(((an>>>0))>=((at.fields.$length>>>0))){$panic(new $String("reflect: Field index out of range"));}ap[0]=$internalize(K(as.typ).fields[an].prop,$String);av=(au=at.fields,((an<0||an>=au.$length)?($throwRuntimeError("index out of range"),undefined):au.$array[au.$offset+an]));ar[0]=av.typ;aw=(((as.flag&416)>>>0)|((ar[0].Kind()>>>0)))>>>0;if(!$clone(av.name,Q).isExported()){if(av.embedded()){aw=(aw|(64))>>>0;}else{aw=(aw|(32))>>>0;}}ay=$clone((ax=at.fields,((an<0||an>=ax.$length)?($throwRuntimeError("index out of range"),undefined):ax.$array[ax.$offset+an])).name,Q).tag();if(!(ay==="")&&!((an===0))){$s=1;continue;}$s=2;continue;case 1:ao[0]=BN(ay);if(!(ao[0]==="")){$s=3;continue;}$s=4;continue;case 3:case 5:az=[az];ba=$clone(as,EY).Field(0);$s=7;case 7:if($c){$c=false;ba=ba.$blk();}if(ba&&ba.$blk!==undefined){break s;}as=ba;if(as.typ===BK){$s=8;continue;}$s=9;continue;case 8:az[0]=$clone(as,EY).object().object;$s=-1;return new EY.ptr(ar[0],(new(K(DK(ar[0])))((function(ao,ap,aq,ar,az){return function(){return $internalize(az[0][$externalize(ao[0],$String)],K(ar[0]));};})(ao,ap,aq,ar,az),(function(ao,ap,aq,ar,az){return function(bb){var bb;az[0][$externalize(ao[0],$String)]=$externalize(bb,K(ar[0]));};})(ao,ap,aq,ar,az))),aw);case 9:if(as.typ.Kind()===22){$s=10;continue;}$s=11;continue;case 10:bb=$clone(as,EY).Elem();$s=12;case 12:if($c){$c=false;bb=bb.$blk();}if(bb&&bb.$blk!==undefined){break s;}as=bb;case 11:$s=5;continue;case 6:case 4:case 2:aq[0]=as.ptr;if(!((((aw&128)>>>0)===0))&&!((ar[0].Kind()===17))&&!((ar[0].Kind()===25))){$s=13;continue;}$s=14;continue;case 13:$s=-1;return new EY.ptr(ar[0],(new(K(DK(ar[0])))((function(ao,ap,aq,ar){return function(){return BL(ar[0],aq[0][$externalize(ap[0],$String)]);};})(ao,ap,aq,ar),(function(ao,ap,aq,ar){return function(bc){var bc;aq[0][$externalize(ap[0],$String)]=BM(ar[0],bc);};})(ao,ap,aq,ar))),aw);case 14:bc=AB(ar[0],BL(ar[0],aq[0][$externalize(ap[0],$String)]),aw);$s=15;case 15:if($c){$c=false;bc=bc.$blk();}if(bc&&bc.$blk!==undefined){break s;}$s=-1;return bc;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Field};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Field=function(an){return this.$val.Field(an);};BN=function(an){var an,ao,ap,aq,ar,as;while(true){if(!(!(an===""))){break;}ao=0;while(true){if(!(ao>0;}an=$substring(an,ao);if(an===""){break;}ao=0;while(true){if(!(ao>0;}if((ao+1>>0)>=an.length||!((an.charCodeAt(ao)===58))||!((an.charCodeAt((ao+1>>0))===34))){break;}ap=($substring(an,0,ao));an=$substring(an,(ao+1>>0));ao=1;while(true){if(!(ao>0;}ao=ao+(1)>>0;}if(ao>=an.length){break;}aq=($substring(an,0,(ao+1>>0)));an=$substring(an,(ao+1>>0));if(ap==="js"){ar=B.Unquote(aq);as=ar[0];return as;}}return"";};EY.ptr.prototype.Index=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=[an];ao=[ao];ap=[ap];aq=[aq];ar=[ar];as=[as];at=this;au=new EZ(at.flag).kind();av=au;if(av===(17)){$s=2;continue;}if(av===(23)){$s=3;continue;}if(av===(24)){$s=4;continue;}$s=5;continue;case 2:aw=(at.typ.kindType);if(an[0]<0||an[0]>((aw.len>>0))){$panic(new $String("reflect: array index out of range"));}ar[0]=aw.elem;ax=(((((at.flag&384)>>>0)|new EZ(at.flag).ro())>>>0)|((ar[0].Kind()>>>0)))>>>0;ao[0]=at.ptr;if(!((((ax&128)>>>0)===0))&&!((ar[0].Kind()===17))&&!((ar[0].Kind()===25))){$s=7;continue;}$s=8;continue;case 7:$s=-1;return new EY.ptr(ar[0],(new(K(DK(ar[0])))((function(an,ao,ap,aq,ar,as){return function(){return BL(ar[0],ao[0][an[0]]);};})(an,ao,ap,aq,ar,as),(function(an,ao,ap,aq,ar,as){return function(ay){var ay;ao[0][an[0]]=BM(ar[0],ay);};})(an,ao,ap,aq,ar,as))),ax);case 8:ay=AB(ar[0],BL(ar[0],ao[0][an[0]]),ax);$s=9;case 9:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}$s=-1;return ay;case 3:az=$clone(at,EY).object();if(an[0]<0||an[0]>=($parseInt(az.$length)>>0)){$panic(new $String("reflect: slice index out of range"));}ba=(at.typ.kindType);as[0]=ba.elem;bb=(((384|new EZ(at.flag).ro())>>>0)|((as[0].Kind()>>>0)))>>>0;an[0]=an[0]+(($parseInt(az.$offset)>>0))>>0;ap[0]=az.$array;if(!((((bb&128)>>>0)===0))&&!((as[0].Kind()===17))&&!((as[0].Kind()===25))){$s=10;continue;}$s=11;continue;case 10:$s=-1;return new EY.ptr(as[0],(new(K(DK(as[0])))((function(an,ao,ap,aq,ar,as){return function(){return BL(as[0],ap[0][an[0]]);};})(an,ao,ap,aq,ar,as),(function(an,ao,ap,aq,ar,as){return function(bc){var bc;ap[0][an[0]]=BM(as[0],bc);};})(an,ao,ap,aq,ar,as))),bb);case 11:bc=AB(as[0],BL(as[0],ap[0][an[0]]),bb);$s=12;case 12:if($c){$c=false;bc=bc.$blk();}if(bc&&bc.$blk!==undefined){break s;}$s=-1;return bc;case 4:bd=(at.ptr).$get();if(an[0]<0||an[0]>=bd.length){$panic(new $String("reflect: string index out of range"));}be=(((new EZ(at.flag).ro()|8)>>>0)|128)>>>0;aq[0]=bd.charCodeAt(an[0]);$s=-1;return new EY.ptr(FL,((aq.$ptr||(aq.$ptr=new IA(function(){return this.$target[0];},function($v){this.$target[0]=$v;},aq)))),be);case 5:$panic(new FC.ptr("reflect.Value.Index",au));case 6:case 1:$s=-1;return new EY.ptr(HR.nil,0,0);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Index};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Index=function(an){return this.$val.Index(an);};EY.ptr.prototype.InterfaceData=function(){var an;an=this;$panic(A.New("InterfaceData is not supported by GopherJS"));};EY.prototype.InterfaceData=function(){return this.$val.InterfaceData();};EY.ptr.prototype.IsNil=function(){var an,ao,ap;an=this;ao=new EZ(an.flag).kind();ap=ao;if((ap===(22))||(ap===(23))){return $clone(an,EY).object()===K(an.typ).nil;}else if(ap===(18)){return $clone(an,EY).object()===$chanNil;}else if(ap===(19)){return $clone(an,EY).object()===$throwNilPointerError;}else if(ap===(21)){return $clone(an,EY).object()===false;}else if(ap===(20)){return $clone(an,EY).object()===$ifaceNil;}else if(ap===(26)){return $clone(an,EY).object()===0;}else{$panic(new FC.ptr("reflect.Value.IsNil",ao));}};EY.prototype.IsNil=function(){return this.$val.IsNil();};EY.ptr.prototype.Len=function(){var an,ao,ap;an=this;ao=new EZ(an.flag).kind();ap=ao;if((ap===(17))||(ap===(24))){return $parseInt($clone(an,EY).object().length);}else if(ap===(23)){return $parseInt($clone(an,EY).object().$length)>>0;}else if(ap===(18)){return $parseInt($clone(an,EY).object().$buffer.length)>>0;}else if(ap===(21)){return $parseInt($keys($clone(an,EY).object()).length);}else{$panic(new FC.ptr("reflect.Value.Len",ao));}};EY.prototype.Len=function(){return this.$val.Len();};EY.ptr.prototype.Pointer=function(){var an,ao,ap;an=this;ao=new EZ(an.flag).kind();ap=ao;if((ap===(18))||(ap===(21))||(ap===(22))||(ap===(26))){if($clone(an,EY).IsNil()){return 0;}return $clone(an,EY).object();}else if(ap===(19)){if($clone(an,EY).IsNil()){return 0;}return 1;}else if(ap===(23)){if($clone(an,EY).IsNil()){return 0;}return $clone(an,EY).object().$array;}else{$panic(new FC.ptr("reflect.Value.Pointer",ao));}};EY.prototype.Pointer=function(){return this.$val.Pointer();};EY.ptr.prototype.Set=function(an){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(an.flag).mustBeExported();ap=$clone(an,EY).assignTo("reflect.Set",ao.typ,0);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}an=ap;if(!((((ao.flag&128)>>>0)===0))){$s=2;continue;}$s=3;continue;case 2:aq=ao.typ.Kind();if(aq===(17)){$s=5;continue;}if(aq===(20)){$s=6;continue;}if(aq===(25)){$s=7;continue;}$s=8;continue;case 5:K(ao.typ).copy(ao.ptr,an.ptr);$s=9;continue;case 6:ar=BF($clone(an,EY),false);$s=10;case 10:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}ao.ptr.$set(ar);$s=9;continue;case 7:AA(ao.ptr,an.ptr,ao.typ);$s=9;continue;case 8:ao.ptr.$set($clone(an,EY).object());case 9:case 4:$s=-1;return;case 3:ao.ptr=an.ptr;$s=-1;return;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Set};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Set=function(an){return this.$val.Set(an);};EY.ptr.prototype.SetBytes=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(23);ap=ao.typ.Elem().Kind();$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}if(!((ap===8))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.Value.SetBytes of non-byte slice"));case 2:aq=an;if(!(ao.typ.Name()==="")){ar=true;$s=6;continue s;}as=ao.typ.Elem().Name();$s=7;case 7:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}ar=!(as==="");case 6:if(ar){$s=4;continue;}$s=5;continue;case 4:at=new(K(ao.typ))(aq.$array);at.$offset=aq.$offset;at.$length=aq.$length;at.$capacity=aq.$capacity;aq=at;case 5:ao.ptr.$set(aq);$s=-1;return;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.SetBytes};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.SetBytes=function(an){return this.$val.SetBytes(an);};EY.ptr.prototype.SetCap=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(23);ap=ao.ptr.$get();if(an<($parseInt(ap.$length)>>0)||an>($parseInt(ap.$capacity)>>0)){$panic(new $String("reflect: slice capacity out of range in SetCap"));}aq=new(K(ao.typ))(ap.$array);aq.$offset=ap.$offset;aq.$length=ap.$length;aq.$capacity=an;ao.ptr.$set(aq);};EY.prototype.SetCap=function(an){return this.$val.SetCap(an);};EY.ptr.prototype.SetLen=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(23);ap=ao.ptr.$get();if(an<0||an>($parseInt(ap.$capacity)>>0)){$panic(new $String("reflect: slice length out of range in SetLen"));}aq=new(K(ao.typ))(ap.$array);aq.$offset=ap.$offset;aq.$length=an;aq.$capacity=ap.$capacity;ao.ptr.$set(aq);};EY.prototype.SetLen=function(an){return this.$val.SetLen(an);};EY.ptr.prototype.Slice=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=this;aq=0;ar=$ifaceNil;as=null;at=new EZ(ap.flag).kind();au=at;if(au===(17)){$s=2;continue;}if(au===(23)){$s=3;continue;}if(au===(24)){$s=4;continue;}$s=5;continue;case 2:if(((ap.flag&256)>>>0)===0){$panic(new $String("reflect.Value.Slice: slice of unaddressable array"));}av=(ap.typ.kindType);aq=((av.len>>0));ar=AJ(av.elem);as=new(K(ar))($clone(ap,EY).object());$s=6;continue;case 3:ar=ap.typ;as=$clone(ap,EY).object();aq=$parseInt(as.$capacity)>>0;$s=6;continue;case 4:aw=(ap.ptr).$get();if(an<0||aoaw.length){$panic(new $String("reflect.Value.Slice: string slice index out of bounds"));}ax=AE(new $String($substring(aw,an,ao)));$s=7;case 7:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}$s=-1;return ax;case 5:$panic(new FC.ptr("reflect.Value.Slice",at));case 6:case 1:if(an<0||aoaq){$panic(new $String("reflect.Value.Slice: slice index out of bounds"));}ay=AB(ar,$subslice(as,an,ao),new EZ(ap.flag).ro());$s=8;case 8:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}$s=-1;return ay;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Slice};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Slice=function(an,ao){return this.$val.Slice(an,ao);};EY.ptr.prototype.Slice3=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=this;ar=0;as=$ifaceNil;at=null;au=new EZ(aq.flag).kind();av=au;if(av===(17)){if(((aq.flag&256)>>>0)===0){$panic(new $String("reflect.Value.Slice: slice of unaddressable array"));}aw=(aq.typ.kindType);ar=((aw.len>>0));as=AJ(aw.elem);at=new(K(as))($clone(aq,EY).object());}else if(av===(23)){as=aq.typ;at=$clone(aq,EY).object();ar=$parseInt(at.$capacity)>>0;}else{$panic(new FC.ptr("reflect.Value.Slice3",au));}if(an<0||aoar){$panic(new $String("reflect.Value.Slice3: slice index out of bounds"));}ax=AB(as,$subslice(at,an,ao,ap),new EZ(aq.flag).ro());$s=1;case 1:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}$s=-1;return ax;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Slice3};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Slice3=function(an,ao,ap){return this.$val.Slice3(an,ao,ap);};EY.ptr.prototype.Close=function(){var an;an=this;new EZ(an.flag).mustBe(18);new EZ(an.flag).mustBeExported();$close($clone(an,EY).object());};EY.prototype.Close=function(){return this.$val.Close();};BP=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=false;ar=false;as=new IM([new IH([an])]);if(ao){as=$append(as,new IH([]));}at=BO(new HV([as]));$s=1;case 1:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}au=at;if(ao&&(($parseInt(au[0])>>0)===1)){av=false;aw=false;aq=av;ar=aw;$s=-1;return[aq,ar];}ax=au[1];ap.$set(ax[0]);ay=true;az=!!(ax[1]);aq=ay;ar=az;$s=-1;return[aq,ar];}return;}if($f===undefined){$f={$blk:BP};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.$s=$s;$f.$r=$r;return $f;};BQ=function(an,ao,ap){var an,ao,ap,aq,ar,as,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=new IM([new IH([an,ao.$get()])]);if(ap){aq=$append(aq,new IH([]));}ar=BO(new HV([aq]));$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=ar;if(ap&&(($parseInt(as[0])>>0)===1)){$s=-1;return false;}$s=-1;return true;}return;}if($f===undefined){$f={$blk:BQ};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.$s=$s;$f.$r=$r;return $f;};BU=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=[ao];ap=[ap];aq=[aq];ar=AE(an);$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=ar;if(!(($clone(as,EY).Kind()===23))){$panic(new FC.ptr("Swapper",$clone(as,EY).Kind()));}aq[0]=(($clone(as,EY).Len()>>>0));at=aq[0];if(at===(0)){$s=-1;return(function(ao,ap,aq){return function(au,av){var au,av;$panic(new $String("reflect: slice index out of range"));};})(ao,ap,aq);}else if(at===(1)){$s=-1;return(function(ao,ap,aq){return function(au,av){var au,av;if(!((au===0))||!((av===0))){$panic(new $String("reflect: slice index out of range"));}};})(ao,ap,aq);}ao[0]=an.$array;ap[0]=$parseInt(an.$offset)>>0;$s=-1;return(function(ao,ap,aq){return function(au,av){var au,av,aw;if(((au>>>0))>=aq[0]||((av>>>0))>=aq[0]){$panic(new $String("reflect: slice index out of range"));}au=au+(ap[0])>>0;av=av+(ap[0])>>0;aw=ao[0][au];ao[0][au]=ao[0][av];ao[0][av]=aw;};})(ao,ap,aq);}return;}if($f===undefined){$f={$blk:BU};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Swapper=BU;CP.ptr.prototype.offset=function(){var an;an=this;return an.offsetEmbed>>>1>>>0;};CP.prototype.offset=function(){return this.$val.offset();};CP.ptr.prototype.embedded=function(){var an;an=this;return!((((an.offsetEmbed&1)>>>0)===0));};CP.prototype.embedded=function(){return this.$val.embedded();};CC.prototype.String=function(){var an;an=this.$val;if(((an>>0))=CT.$length)?($throwRuntimeError("index out of range"),undefined):CT.$array[CT.$offset+an]);}return"kind"+B.Itoa(((an>>0)));};$ptrType(CC).prototype.String=function(){return new CC(this.$get()).String();};CE.ptr.prototype.String=function(){var an,ao;an=this;ao=$clone(an.nameOff(an.str),Q).name();if(!((((an.tflag&2)>>>0)===0))){return $substring(ao,1);}return ao;};CE.prototype.String=function(){return this.$val.String();};CE.ptr.prototype.Size=function(){var an;an=this;return an.size;};CE.prototype.Size=function(){return this.$val.Size();};CE.ptr.prototype.Bits=function(){var an,ao;an=this;if(an===HR.nil){$panic(new $String("reflect: Bits of nil Type"));}ao=an.Kind();if(ao<2||ao>16){$panic(new $String("reflect: Bits of non-arithmetic Type "+an.String()));}return $imul(((an.size>>0)),8);};CE.prototype.Bits=function(){return this.$val.Bits();};CE.ptr.prototype.Align=function(){var an;an=this;return((an.align>>0));};CE.prototype.Align=function(){return this.$val.Align();};CE.ptr.prototype.FieldAlign=function(){var an;an=this;return((an.fieldAlign>>0));};CE.prototype.FieldAlign=function(){return this.$val.FieldAlign();};CE.ptr.prototype.Kind=function(){var an;an=this;return((((an.kind&31)>>>0)>>>0));};CE.prototype.Kind=function(){return this.$val.Kind();};CE.ptr.prototype.common=function(){var an;an=this;return an;};CE.prototype.common=function(){return this.$val.common();};CE.ptr.prototype.exportedMethods=function(){var an,ao;an=this;ao=an.uncommon();if(ao===IE.nil){return IB.nil;}return ao.exportedMethods();};CE.prototype.exportedMethods=function(){return this.$val.exportedMethods();};CE.ptr.prototype.NumMethod=function(){var an,ao;an=this;if(an.Kind()===20){ao=(an.kindType);return ao.NumMethod();}return an.exportedMethods().$length;};CE.prototype.NumMethod=function(){return this.$val.NumMethod();};CE.ptr.prototype.MethodByName=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);ap=false;aq=this;if(aq.Kind()===20){ar=(aq.kindType);as=ar.MethodByName(an);CS.copy(ao,as[0]);ap=as[1];$s=-1;return[ao,ap];}at=aq.uncommon();if(at===IE.nil){au=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);av=false;CS.copy(ao,au);ap=av;$s=-1;return[ao,ap];}aw=at.exportedMethods();ax=0;case 1:if(!(ax=aw.$length)?($throwRuntimeError("index out of range"),undefined):aw.$array[aw.$offset+ax]),CG);if($clone(aq.nameOff(az.name),Q).name()===an){$s=3;continue;}$s=4;continue;case 3:bb=aq.Method(ay);$s=5;case 5:if($c){$c=false;bb=bb.$blk();}if(bb&&bb.$blk!==undefined){break s;}ba=$clone(bb,CS);bc=true;CS.copy(ao,ba);ap=bc;$s=-1;return[ao,ap];case 4:ax++;$s=1;continue;case 2:bd=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);be=false;CS.copy(ao,bd);ap=be;$s=-1;return[ao,ap];}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.MethodByName};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.MethodByName=function(an){return this.$val.MethodByName(an);};CE.ptr.prototype.PkgPath=function(){var an,ao;an=this;if(((an.tflag&4)>>>0)===0){return"";}ao=an.uncommon();if(ao===IE.nil){return"";}return $clone(an.nameOff(ao.pkgPath),Q).name();};CE.prototype.PkgPath=function(){return this.$val.PkgPath();};CE.ptr.prototype.Name=function(){var an,ao,ap;an=this;if(((an.tflag&4)>>>0)===0){return"";}ao=an.String();ap=ao.length-1>>0;while(true){if(!(ap>=0)){break;}if(ao.charCodeAt(ap)===46){break;}ap=ap-(1)>>0;}return $substring(ao,(ap+1>>0));};CE.prototype.Name=function(){return this.$val.Name();};CE.ptr.prototype.ChanDir=function(){var an,ao;an=this;if(!((an.Kind()===18))){$panic(new $String("reflect: ChanDir of non-chan type"));}ao=(an.kindType);return((ao.dir>>0));};CE.prototype.ChanDir=function(){return this.$val.ChanDir();};CE.ptr.prototype.IsVariadic=function(){var an,ao;an=this;if(!((an.Kind()===19))){$panic(new $String("reflect: IsVariadic of non-func type"));}ao=(an.kindType);return!((((ao.outCount&32768)>>>0)===0));};CE.prototype.IsVariadic=function(){return this.$val.IsVariadic();};CE.ptr.prototype.Elem=function(){var an,ao,ap,aq,ar,as,at;an=this;ao=an.Kind();if(ao===(17)){ap=(an.kindType);return EQ(ap.elem);}else if(ao===(18)){aq=(an.kindType);return EQ(aq.elem);}else if(ao===(21)){ar=(an.kindType);return EQ(ar.elem);}else if(ao===(22)){as=(an.kindType);return EQ(as.elem);}else if(ao===(23)){at=(an.kindType);return EQ(at.elem);}$panic(new $String("reflect: Elem of invalid type"));};CE.prototype.Elem=function(){return this.$val.Elem();};CE.ptr.prototype.Field=function(an){var an,ao,ap;ao=this;if(!((ao.Kind()===25))){$panic(new $String("reflect: Field of non-struct type"));}ap=(ao.kindType);return ap.Field(an);};CE.prototype.Field=function(an){return this.$val.Field(an);};CE.ptr.prototype.FieldByIndex=function(an){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(!((ao.Kind()===25))){$panic(new $String("reflect: FieldByIndex of non-struct type"));}ap=(ao.kindType);aq=ap.FieldByIndex(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.FieldByIndex};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.FieldByIndex=function(an){return this.$val.FieldByIndex(an);};CE.ptr.prototype.FieldByName=function(an){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(!((ao.Kind()===25))){$panic(new $String("reflect: FieldByName of non-struct type"));}ap=(ao.kindType);aq=ap.FieldByName(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.FieldByName};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.FieldByName=function(an){return this.$val.FieldByName(an);};CE.ptr.prototype.FieldByNameFunc=function(an){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(!((ao.Kind()===25))){$panic(new $String("reflect: FieldByNameFunc of non-struct type"));}ap=(ao.kindType);aq=ap.FieldByNameFunc(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.FieldByNameFunc};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.FieldByNameFunc=function(an){return this.$val.FieldByNameFunc(an);};CE.ptr.prototype.In=function(an){var an,ao,ap,aq;ao=this;if(!((ao.Kind()===19))){$panic(new $String("reflect: In of non-func type"));}ap=(ao.kindType);return EQ((aq=ap.in$(),((an<0||an>=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+an])));};CE.prototype.In=function(an){return this.$val.In(an);};CE.ptr.prototype.Key=function(){var an,ao;an=this;if(!((an.Kind()===21))){$panic(new $String("reflect: Key of non-map type"));}ao=(an.kindType);return EQ(ao.key);};CE.prototype.Key=function(){return this.$val.Key();};CE.ptr.prototype.Len=function(){var an,ao;an=this;if(!((an.Kind()===17))){$panic(new $String("reflect: Len of non-array type"));}ao=(an.kindType);return((ao.len>>0));};CE.prototype.Len=function(){return this.$val.Len();};CE.ptr.prototype.NumField=function(){var an,ao;an=this;if(!((an.Kind()===25))){$panic(new $String("reflect: NumField of non-struct type"));}ao=(an.kindType);return ao.fields.$length;};CE.prototype.NumField=function(){return this.$val.NumField();};CE.ptr.prototype.NumIn=function(){var an,ao;an=this;if(!((an.Kind()===19))){$panic(new $String("reflect: NumIn of non-func type"));}ao=(an.kindType);return((ao.inCount>>0));};CE.prototype.NumIn=function(){return this.$val.NumIn();};CE.ptr.prototype.NumOut=function(){var an,ao;an=this;if(!((an.Kind()===19))){$panic(new $String("reflect: NumOut of non-func type"));}ao=(an.kindType);return ao.out().$length;};CE.prototype.NumOut=function(){return this.$val.NumOut();};CE.ptr.prototype.Out=function(an){var an,ao,ap,aq;ao=this;if(!((ao.Kind()===19))){$panic(new $String("reflect: Out of non-func type"));}ap=(ao.kindType);return EQ((aq=ap.out(),((an<0||an>=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+an])));};CE.prototype.Out=function(an){return this.$val.Out(an);};CH.prototype.String=function(){var an,ao;an=this.$val;ao=an;if(ao===(2)){return"chan<-";}else if(ao===(1)){return"<-chan";}else if(ao===(3)){return"chan";}return"ChanDir"+B.Itoa(((an>>0)));};$ptrType(CH).prototype.String=function(){return new CH(this.$get()).String();};CL.ptr.prototype.Method=function(an){var an,ao,ap,aq,ar,as;ao=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);ap=this;if(an<0||an>=ap.methods.$length){return ao;}ar=(aq=ap.methods,((an<0||an>=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+an]));as=$clone(ap.rtype.nameOff(ar.name),Q);ao.Name=$clone(as,Q).name();if(!$clone(as,Q).isExported()){ao.PkgPath=$clone(as,Q).pkgPath();if(ao.PkgPath===""){ao.PkgPath=$clone(ap.pkgPath,Q).name();}}ao.Type=EQ(ap.rtype.typeOff(ar.typ));ao.Index=an;return ao;};CL.prototype.Method=function(an){return this.$val.Method(an);};CL.ptr.prototype.NumMethod=function(){var an;an=this;return an.methods.$length;};CL.prototype.NumMethod=function(){return this.$val.NumMethod();};CL.ptr.prototype.MethodByName=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax;ao=new CS.ptr("","",$ifaceNil,new EY.ptr(HR.nil,0,0),0);ap=false;aq=this;if(aq===IP.nil){return[ao,ap];}ar=IQ.nil;as=aq.methods;at=0;while(true){if(!(at=av.$length)?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+au]));if($clone(aq.rtype.nameOff(ar.name),Q).name()===an){aw=$clone(aq.Method(au),CS);ax=true;CS.copy(ao,aw);ap=ax;return[ao,ap];}at++;}return[ao,ap];};CL.prototype.MethodByName=function(an){return this.$val.MethodByName(an);};DH.prototype.Get=function(an){var an,ao,ap,aq;ao=this.$val;ap=new DH(ao).Lookup(an);aq=ap[0];return aq;};$ptrType(DH).prototype.Get=function(an){return new DH(this.$get()).Get(an);};DH.prototype.Lookup=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba;ao="";ap=false;aq=this.$val;while(true){if(!(!(aq===""))){break;}ar=0;while(true){if(!(ar>0;}aq=$substring(aq,ar);if(aq===""){break;}ar=0;while(true){if(!(ar32&&!((aq.charCodeAt(ar)===58))&&!((aq.charCodeAt(ar)===34))&&!((aq.charCodeAt(ar)===127)))){break;}ar=ar+(1)>>0;}if((ar===0)||(ar+1>>0)>=aq.length||!((aq.charCodeAt(ar)===58))||!((aq.charCodeAt((ar+1>>0))===34))){break;}as=($substring(aq,0,ar));aq=$substring(aq,(ar+1>>0));ar=1;while(true){if(!(ar>0;}ar=ar+(1)>>0;}if(ar>=aq.length){break;}at=($substring(aq,0,(ar+1>>0)));aq=$substring(aq,(ar+1>>0));if(an===as){au=B.Unquote(at);av=au[0];aw=au[1];if(!($interfaceIsEqual(aw,$ifaceNil))){break;}ax=av;ay=true;ao=ax;ap=ay;return[ao,ap];}}az="";ba=false;ao=az;ap=ba;return[ao,ap];};$ptrType(DH).prototype.Lookup=function(an){return new DH(this.$get()).Lookup(an);};CQ.ptr.prototype.Field=function(an){var an,ao,ap,aq,ar,as;ao=new DG.ptr("","",$ifaceNil,"",0,IR.nil,false);ap=this;if(an<0||an>=ap.fields.$length){$panic(new $String("reflect: Field index out of bounds"));}ar=(aq=ap.fields,((an<0||an>=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+an]));ao.Type=EQ(ar.typ);ao.Name=$clone(ar.name,Q).name();ao.Anonymous=ar.embedded();if(!$clone(ar.name,Q).isExported()){ao.PkgPath=$clone(ap.pkgPath,Q).name();}as=$clone(ar.name,Q).tag();if(!(as==="")){ao.Tag=(as);}ao.Offset=ar.offset();ao.Index=new IR([an]);return ao;};CQ.prototype.Field=function(an){return this.$val.Field(an);};CQ.ptr.prototype.FieldByIndex=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=new DG.ptr("","",$ifaceNil,"",0,IR.nil,false);ap=this;ao.Type=EQ(ap.rtype);aq=an;ar=0;case 1:if(!(ar=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+ar]);if(as>0){$s=3;continue;}$s=4;continue;case 3:au=ao.Type;aw=au.Kind();$s=8;case 8:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}if(!(aw===22)){av=false;$s=7;continue s;}ax=au.Elem();$s=9;case 9:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ay=ax.Kind();$s=10;case 10:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}av=ay===25;case 7:if(av){$s=5;continue;}$s=6;continue;case 5:az=au.Elem();$s=11;case 11:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}au=az;case 6:ao.Type=au;case 4:ba=ao.Type.Field(at);$s=12;case 12:if($c){$c=false;ba=ba.$blk();}if(ba&&ba.$blk!==undefined){break s;}DG.copy(ao,ba);ar++;$s=1;continue;case 2:$s=-1;return ao;}return;}if($f===undefined){$f={$blk:CQ.ptr.prototype.FieldByIndex};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.$s=$s;$f.$r=$r;return $f;};CQ.prototype.FieldByIndex=function(an){return this.$val.FieldByIndex(an);};CQ.ptr.prototype.FieldByNameFunc=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,bw,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;bu=$f.bu;bv=$f.bv;bw=$f.bw;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=new DG.ptr("","",$ifaceNil,"",0,IR.nil,false);ap=false;aq=this;ar=new IS([]);as=new IS([new DI.ptr(aq,IR.nil)]);at=false;au=$makeMap(IT.keyFor,[]);case 1:if(!(as.$length>0)){$s=2;continue;}av=as;aw=$subslice(ar,0,0);ar=av;as=aw;ax=at;at=false;ay=ar;az=0;case 3:if(!(az=ay.$length)?($throwRuntimeError("index out of range"),undefined):ay.$array[ay.$offset+az]),DI);bb=ba.typ;if((bc=au[IT.keyFor(bb)],bc!==undefined?bc.v:false)){$s=5;continue;}$s=6;continue;case 5:az++;$s=3;continue;case 6:bd=bb;(au||$throwRuntimeError("assignment to entry in nil map"))[IT.keyFor(bd)]={k:bd,v:true};be=bb.fields;bf=0;case 7:if(!(bf=bh.$length)?($throwRuntimeError("index out of range"),undefined):bh.$array[bh.$offset+bg]));bj=$clone(bi.name,Q).name();bk=HR.nil;if(bi.embedded()){$s=9;continue;}$s=10;continue;case 9:bk=bi.typ;if(bk.Kind()===22){$s=11;continue;}$s=12;continue;case 11:bl=bk.Elem().common();$s=13;case 13:if($c){$c=false;bl=bl.$blk();}if(bl&&bl.$blk!==undefined){break s;}bk=bl;case 12:case 10:bm=an(bj);$s=16;case 16:if($c){$c=false;bm=bm.$blk();}if(bm&&bm.$blk!==undefined){break s;}if(bm){$s=14;continue;}$s=15;continue;case 14:if((bn=ax[IT.keyFor(bb)],bn!==undefined?bn.v:0)>1||ap){bo=new DG.ptr("","",$ifaceNil,"",0,IR.nil,false);bp=false;DG.copy(ao,bo);ap=bp;$s=-1;return[ao,ap];}DG.copy(ao,bb.Field(bg));ao.Index=IR.nil;ao.Index=$appendSlice(ao.Index,ba.index);ao.Index=$append(ao.Index,bg);ap=true;bf++;$s=7;continue;case 15:if(ap||bk===HR.nil||!((bk.Kind()===25))){bf++;$s=7;continue;}bq=(bk.kindType);if((br=at[IT.keyFor(bq)],br!==undefined?br.v:0)>0){bs=bq;(at||$throwRuntimeError("assignment to entry in nil map"))[IT.keyFor(bs)]={k:bs,v:2};bf++;$s=7;continue;}if(at===false){at=$makeMap(IT.keyFor,[]);}bt=bq;(at||$throwRuntimeError("assignment to entry in nil map"))[IT.keyFor(bt)]={k:bt,v:1};if((bu=ax[IT.keyFor(bb)],bu!==undefined?bu.v:0)>1){bv=bq;(at||$throwRuntimeError("assignment to entry in nil map"))[IT.keyFor(bv)]={k:bv,v:2};}bw=IR.nil;bw=$appendSlice(bw,ba.index);bw=$append(bw,bg);as=$append(as,new DI.ptr(bq,bw));bf++;$s=7;continue;case 8:az++;$s=3;continue;case 4:if(ap){$s=2;continue;}$s=1;continue;case 2:$s=-1;return[ao,ap];}return;}if($f===undefined){$f={$blk:CQ.ptr.prototype.FieldByNameFunc};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.bu=bu;$f.bv=bv;$f.bw=bw;$f.$s=$s;$f.$r=$r;return $f;};CQ.prototype.FieldByNameFunc=function(an){return this.$val.FieldByNameFunc(an);};CQ.ptr.prototype.FieldByName=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=[an];ao=new DG.ptr("","",$ifaceNil,"",0,IR.nil,false);ap=false;aq=this;ar=false;if(!(an[0]==="")){as=aq.fields;at=0;while(true){if(!(at=av.$length)?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+au]));if($clone(aw.name,Q).name()===an[0]){ax=$clone(aq.Field(au),DG);ay=true;DG.copy(ao,ax);ap=ay;$s=-1;return[ao,ap];}if(aw.embedded()){ar=true;}at++;}}if(!ar){$s=-1;return[ao,ap];}ba=aq.FieldByNameFunc((function(an){return function(ba){var ba;return ba===an[0];};})(an));$s=1;case 1:if($c){$c=false;ba=ba.$blk();}if(ba&&ba.$blk!==undefined){break s;}az=ba;DG.copy(ao,az[0]);ap=az[1];$s=-1;return[ao,ap];}return;}if($f===undefined){$f={$blk:CQ.ptr.prototype.FieldByName};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.$s=$s;$f.$r=$r;return $f;};CQ.prototype.FieldByName=function(an){return this.$val.FieldByName(an);};DK=function(an){var an;return $assertType(an,HR).ptrTo();};$pkg.PtrTo=DK;CE.ptr.prototype.Implements=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if($interfaceIsEqual(an,$ifaceNil)){$panic(new $String("reflect: nil type passed to Type.Implements"));}ap=an.Kind();$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}if(!((ap===20))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect: non-interface type passed to Type.Implements"));case 2:$s=-1;return DM($assertType(an,HR),ao);}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.Implements};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.Implements=function(an){return this.$val.Implements(an);};CE.ptr.prototype.AssignableTo=function(an){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if($interfaceIsEqual(an,$ifaceNil)){$panic(new $String("reflect: nil type passed to Type.AssignableTo"));}ap=$assertType(an,HR);aq=DN(ap,ao);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq||DM(ap,ao);}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.AssignableTo};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.AssignableTo=function(an){return this.$val.AssignableTo(an);};CE.ptr.prototype.ConvertibleTo=function(an){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if($interfaceIsEqual(an,$ifaceNil)){$panic(new $String("reflect: nil type passed to Type.ConvertibleTo"));}ap=$assertType(an,HR);aq=GJ(ap,ao);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return!(aq===$throwNilPointerError);}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.ConvertibleTo};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.ConvertibleTo=function(an){return this.$val.ConvertibleTo(an);};DM=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl;if(!((an.Kind()===20))){return false;}ap=(an.kindType);if(ap.methods.$length===0){return true;}if(ao.Kind()===20){aq=(ao.kindType);ar=0;as=0;while(true){if(!(as=at.$length)?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+ar]));av=$clone(ap.rtype.nameOff(au.name),Q);ax=(aw=aq.methods,((as<0||as>=aw.$length)?($throwRuntimeError("index out of range"),undefined):aw.$array[aw.$offset+as]));ay=$clone(ao.nameOff(ax.name),Q);if($clone(ay,Q).name()===$clone(av,Q).name()&&ao.typeOff(ax.typ)===ap.rtype.typeOff(au.typ)){if(!$clone(av,Q).isExported()){az=$clone(av,Q).pkgPath();if(az===""){az=$clone(ap.pkgPath,Q).name();}ba=$clone(ay,Q).pkgPath();if(ba===""){ba=$clone(aq.pkgPath,Q).name();}if(!(az===ba)){as=as+(1)>>0;continue;}}ar=ar+(1)>>0;if(ar>=ap.methods.$length){return true;}}as=as+(1)>>0;}return false;}bb=ao.uncommon();if(bb===IE.nil){return false;}bc=0;bd=bb.methods();be=0;while(true){if(!(be<((bb.mcount>>0)))){break;}bg=(bf=ap.methods,((bc<0||bc>=bf.$length)?($throwRuntimeError("index out of range"),undefined):bf.$array[bf.$offset+bc]));bh=$clone(ap.rtype.nameOff(bg.name),Q);bi=$clone(((be<0||be>=bd.$length)?($throwRuntimeError("index out of range"),undefined):bd.$array[bd.$offset+be]),CG);bj=$clone(ao.nameOff(bi.name),Q);if($clone(bj,Q).name()===$clone(bh,Q).name()&&ao.typeOff(bi.mtyp)===ap.rtype.typeOff(bg.typ)){if(!$clone(bh,Q).isExported()){bk=$clone(bh,Q).pkgPath();if(bk===""){bk=$clone(ap.pkgPath,Q).name();}bl=$clone(bj,Q).pkgPath();if(bl===""){bl=$clone(ao.nameOff(bb.pkgPath),Q).name();}if(!(bk===bl)){be=be+(1)>>0;continue;}}bc=bc+(1)>>0;if(bc>=ap.methods.$length){return true;}}be=be+(1)>>0;}return false;};DN=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(an===ao){$s=-1;return true;}if(!(an.Name()==="")&&!(ao.Name()==="")||!((an.Kind()===ao.Kind()))){$s=-1;return false;}ap=DP(an,ao,true);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:DN};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};DO=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(ap){$s=-1;return $interfaceIsEqual(an,ao);}ar=an.Name();$s=4;case 4:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=ao.Name();$s=5;case 5:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}if(!(ar===as)){aq=true;$s=3;continue s;}at=an.Kind();$s=6;case 6:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}au=ao.Kind();$s=7;case 7:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}aq=!((at===au));case 3:if(aq){$s=1;continue;}$s=2;continue;case 1:$s=-1;return false;case 2:av=an.common();$s=8;case 8:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}aw=av;ax=ao.common();$s=9;case 9:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ay=ax;az=DP(aw,ay,false);$s=10;case 10:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}$s=-1;return az;}return;}if($f===undefined){$f={$blk:DO};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.$s=$s;$f.$r=$r;return $f;};DP=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(an===ao){$s=-1;return true;}aq=an.Kind();if(!((aq===ao.Kind()))){$s=-1;return false;}if(1<=aq&&aq<=16||(aq===24)||(aq===26)){$s=-1;return true;}ar=aq;if(ar===(17)){$s=2;continue;}if(ar===(18)){$s=3;continue;}if(ar===(19)){$s=4;continue;}if(ar===(20)){$s=5;continue;}if(ar===(21)){$s=6;continue;}if((ar===(22))||(ar===(23))){$s=7;continue;}if(ar===(25)){$s=8;continue;}$s=9;continue;case 2:if(!(an.Len()===ao.Len())){as=false;$s=10;continue s;}at=DO(an.Elem(),ao.Elem(),ap);$s=11;case 11:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}as=at;case 10:$s=-1;return as;case 3:if(!(ao.ChanDir()===3)){au=false;$s=14;continue s;}av=DO(an.Elem(),ao.Elem(),ap);$s=15;case 15:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}au=av;case 14:if(au){$s=12;continue;}$s=13;continue;case 12:$s=-1;return true;case 13:if(!(ao.ChanDir()===an.ChanDir())){aw=false;$s=16;continue s;}ax=DO(an.Elem(),ao.Elem(),ap);$s=17;case 17:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}aw=ax;case 16:$s=-1;return aw;case 4:ay=(an.kindType);az=(ao.kindType);if(!((ay.outCount===az.outCount))||!((ay.inCount===az.inCount))){$s=-1;return false;}ba=0;case 18:if(!(ba>0;$s=18;continue;case 19:bc=0;case 23:if(!(bc>0;$s=23;continue;case 24:$s=-1;return true;case 5:be=(an.kindType);bf=(ao.kindType);if((be.methods.$length===0)&&(bf.methods.$length===0)){$s=-1;return true;}$s=-1;return false;case 6:bh=DO(an.Key(),ao.Key(),ap);$s=29;case 29:if($c){$c=false;bh=bh.$blk();}if(bh&&bh.$blk!==undefined){break s;}if(!(bh)){bg=false;$s=28;continue s;}bi=DO(an.Elem(),ao.Elem(),ap);$s=30;case 30:if($c){$c=false;bi=bi.$blk();}if(bi&&bi.$blk!==undefined){break s;}bg=bi;case 28:$s=-1;return bg;case 7:bj=DO(an.Elem(),ao.Elem(),ap);$s=31;case 31:if($c){$c=false;bj=bj.$blk();}if(bj&&bj.$blk!==undefined){break s;}$s=-1;return bj;case 8:bk=(an.kindType);bl=(ao.kindType);if(!((bk.fields.$length===bl.fields.$length))){$s=-1;return false;}if(!($clone(bk.pkgPath,Q).name()===$clone(bl.pkgPath,Q).name())){$s=-1;return false;}bm=bk.fields;bn=0;case 32:if(!(bn=bp.$length)?($throwRuntimeError("index out of range"),undefined):bp.$array[bp.$offset+bo]));bs=(br=bl.fields,((bo<0||bo>=br.$length)?($throwRuntimeError("index out of range"),undefined):br.$array[br.$offset+bo]));if(!($clone(bq.name,Q).name()===$clone(bs.name,Q).name())){$s=-1;return false;}bt=DO(bq.typ,bs.typ,ap);$s=36;case 36:if($c){$c=false;bt=bt.$blk();}if(bt&&bt.$blk!==undefined){break s;}if(!bt){$s=34;continue;}$s=35;continue;case 34:$s=-1;return false;case 35:if(ap&&!($clone(bq.name,Q).tag()===$clone(bs.name,Q).tag())){$s=-1;return false;}if(!((bq.offsetEmbed===bs.offsetEmbed))){$s=-1;return false;}bn++;$s=32;continue;case 33:$s=-1;return true;case 9:case 1:$s=-1;return false;}return;}if($f===undefined){$f={$blk:DP};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.$s=$s;$f.$r=$r;return $f;};EQ=function(an){var an;if(an===HR.nil){return $ifaceNil;}return an;};EV=function(an){var an;return((an.kind&32)>>>0)===0;};EZ.prototype.kind=function(){var an;an=this.$val;return((((an&31)>>>0)>>>0));};$ptrType(EZ).prototype.kind=function(){return new EZ(this.$get()).kind();};EZ.prototype.ro=function(){var an;an=this.$val;if(!((((an&96)>>>0)===0))){return 32;}return 0;};$ptrType(EZ).prototype.ro=function(){return new EZ(this.$get()).ro();};EY.ptr.prototype.pointer=function(){var an;an=this;if(!((an.typ.size===4))||!an.typ.pointers()){$panic(new $String("can't call pointer on a non-pointer Value"));}if(!((((an.flag&128)>>>0)===0))){return(an.ptr).$get();}return an.ptr;};EY.prototype.pointer=function(){return this.$val.pointer();};FC.ptr.prototype.Error=function(){var an;an=this;if(an.Kind===0){return"reflect: call of "+an.Method+" on zero Value";}return"reflect: call of "+an.Method+" on "+new CC(an.Kind).String()+" Value";};FC.prototype.Error=function(){return this.$val.Error();};EZ.prototype.mustBe=function(an){var an,ao;ao=this.$val;if(!((new EZ(ao).kind()===an))){$panic(new FC.ptr(BH(),new EZ(ao).kind()));}};$ptrType(EZ).prototype.mustBe=function(an){return new EZ(this.$get()).mustBe(an);};EZ.prototype.mustBeExported=function(){var an;an=this.$val;if(an===0){$panic(new FC.ptr(BH(),0));}if(!((((an&96)>>>0)===0))){$panic(new $String("reflect: "+BH()+" using value obtained using unexported field"));}};$ptrType(EZ).prototype.mustBeExported=function(){return new EZ(this.$get()).mustBeExported();};EZ.prototype.mustBeAssignable=function(){var an;an=this.$val;if(an===0){$panic(new FC.ptr(BH(),0));}if(!((((an&96)>>>0)===0))){$panic(new $String("reflect: "+BH()+" using value obtained using unexported field"));}if(((an&256)>>>0)===0){$panic(new $String("reflect: "+BH()+" using unaddressable value"));}};$ptrType(EZ).prototype.mustBeAssignable=function(){return new EZ(this.$get()).mustBeAssignable();};EY.ptr.prototype.Addr=function(){var an;an=this;if(((an.flag&256)>>>0)===0){$panic(new $String("reflect.Value.Addr of unaddressable value"));}return new EY.ptr(an.typ.ptrTo(),an.ptr,(new EZ(an.flag).ro()|22)>>>0);};EY.prototype.Addr=function(){return this.$val.Addr();};EY.ptr.prototype.Bool=function(){var an;an=this;new EZ(an.flag).mustBe(1);return(an.ptr).$get();};EY.prototype.Bool=function(){return this.$val.Bool();};EY.ptr.prototype.Bytes=function(){var an,ao,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;new EZ(an.flag).mustBe(23);ao=an.typ.Elem().Kind();$s=3;case 3:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}if(!((ao===8))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.Value.Bytes of non-byte slice"));case 2:$s=-1;return(an.ptr).$get();}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Bytes};}$f.an=an;$f.ao=ao;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Bytes=function(){return this.$val.Bytes();};EY.ptr.prototype.runes=function(){var an,ao,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;new EZ(an.flag).mustBe(23);ao=an.typ.Elem().Kind();$s=3;case 3:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}if(!((ao===5))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.Value.Bytes of non-rune slice"));case 2:$s=-1;return(an.ptr).$get();}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.runes};}$f.an=an;$f.ao=ao;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.runes=function(){return this.$val.runes();};EY.ptr.prototype.CanAddr=function(){var an;an=this;return!((((an.flag&256)>>>0)===0));};EY.prototype.CanAddr=function(){return this.$val.CanAddr();};EY.ptr.prototype.CanSet=function(){var an;an=this;return((an.flag&352)>>>0)===256;};EY.prototype.CanSet=function(){return this.$val.CanSet();};EY.ptr.prototype.Call=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(19);new EZ(ao.flag).mustBeExported();ap=$clone(ao,EY).call("Call",an);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Call};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Call=function(an){return this.$val.Call(an);};EY.ptr.prototype.CallSlice=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(19);new EZ(ao.flag).mustBeExported();ap=$clone(ao,EY).call("CallSlice",an);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.CallSlice};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.CallSlice=function(an){return this.$val.CallSlice(an);};EY.ptr.prototype.Complex=function(){var an,ao,ap,aq;an=this;ao=new EZ(an.flag).kind();ap=ao;if(ap===(15)){return((aq=(an.ptr).$get(),new $Complex128(aq.$real,aq.$imag)));}else if(ap===(16)){return(an.ptr).$get();}$panic(new FC.ptr("reflect.Value.Complex",new EZ(an.flag).kind()));};EY.prototype.Complex=function(){return this.$val.Complex();};EY.ptr.prototype.FieldByIndex=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(an.$length===1){$s=1;continue;}$s=2;continue;case 1:ap=$clone(ao,EY).Field((0>=an.$length?($throwRuntimeError("index out of range"),undefined):an.$array[an.$offset+0]));$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;case 2:new EZ(ao.flag).mustBe(25);aq=an;ar=0;case 4:if(!(ar=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+ar]);if(as>0){$s=6;continue;}$s=7;continue;case 6:if(!($clone(ao,EY).Kind()===22)){au=false;$s=10;continue s;}av=ao.typ.Elem().Kind();$s=11;case 11:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}au=av===25;case 10:if(au){$s=8;continue;}$s=9;continue;case 8:if($clone(ao,EY).IsNil()){$panic(new $String("reflect: indirection through nil pointer to embedded struct"));}aw=$clone(ao,EY).Elem();$s=12;case 12:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}ao=aw;case 9:case 7:ax=$clone(ao,EY).Field(at);$s=13;case 13:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ao=ax;ar++;$s=4;continue;case 5:$s=-1;return ao;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.FieldByIndex};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.FieldByIndex=function(an){return this.$val.FieldByIndex(an);};EY.ptr.prototype.FieldByName=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(25);aq=ao.typ.FieldByName(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ap=aq;ar=$clone(ap[0],DG);as=ap[1];if(as){$s=2;continue;}$s=3;continue;case 2:at=$clone(ao,EY).FieldByIndex(ar.Index);$s=4;case 4:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;case 3:$s=-1;return new EY.ptr(HR.nil,0,0);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.FieldByName};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.FieldByName=function(an){return this.$val.FieldByName(an);};EY.ptr.prototype.FieldByNameFunc=function(an){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;aq=ao.typ.FieldByNameFunc(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ap=aq;ar=$clone(ap[0],DG);as=ap[1];if(as){$s=2;continue;}$s=3;continue;case 2:at=$clone(ao,EY).FieldByIndex(ar.Index);$s=4;case 4:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;case 3:$s=-1;return new EY.ptr(HR.nil,0,0);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.FieldByNameFunc};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.FieldByNameFunc=function(an){return this.$val.FieldByNameFunc(an);};EY.ptr.prototype.Float=function(){var an,ao,ap;an=this;ao=new EZ(an.flag).kind();ap=ao;if(ap===(13)){return((an.ptr).$get());}else if(ap===(14)){return(an.ptr).$get();}$panic(new FC.ptr("reflect.Value.Float",new EZ(an.flag).kind()));};EY.prototype.Float=function(){return this.$val.Float();};EY.ptr.prototype.Int=function(){var an,ao,ap,aq;an=this;ao=new EZ(an.flag).kind();ap=an.ptr;aq=ao;if(aq===(2)){return(new $Int64(0,(ap).$get()));}else if(aq===(3)){return(new $Int64(0,(ap).$get()));}else if(aq===(4)){return(new $Int64(0,(ap).$get()));}else if(aq===(5)){return(new $Int64(0,(ap).$get()));}else if(aq===(6)){return(ap).$get();}$panic(new FC.ptr("reflect.Value.Int",new EZ(an.flag).kind()));};EY.prototype.Int=function(){return this.$val.Int();};EY.ptr.prototype.CanInterface=function(){var an;an=this;if(an.flag===0){$panic(new FC.ptr("reflect.Value.CanInterface",0));}return((an.flag&96)>>>0)===0;};EY.prototype.CanInterface=function(){return this.$val.CanInterface();};EY.ptr.prototype.Interface=function(){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=$ifaceNil;ao=this;ap=BF($clone(ao,EY),true);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}an=ap;$s=-1;return an;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Interface};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Interface=function(){return this.$val.Interface();};EY.ptr.prototype.IsValid=function(){var an;an=this;return!((an.flag===0));};EY.prototype.IsValid=function(){return this.$val.IsValid();};EY.ptr.prototype.Kind=function(){var an;an=this;return new EZ(an.flag).kind();};EY.prototype.Kind=function(){return this.$val.Kind();};EY.ptr.prototype.MapIndex=function(an){var an,ao,ap,aq,ar,as,at,au,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(21);ap=(ao.typ.kindType);aq=$clone(an,EY).assignTo("reflect.Value.MapIndex",ap.key,0);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}an=aq;ar=0;if(!((((an.flag&128)>>>0)===0))){ar=an.ptr;}else{ar=((an.$ptr_ptr||(an.$ptr_ptr=new JC(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},an))));}as=AT(ao.typ,$clone(ao,EY).pointer(),ar);if(as===0){$s=-1;return new EY.ptr(HR.nil,0,0);}at=ap.elem;au=new EZ((((ao.flag|an.flag)>>>0))).ro();au=(au|(((at.Kind()>>>0))))>>>0;$s=-1;return FN(at,au,as);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.MapIndex};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.MapIndex=function(an){return this.$val.MapIndex(an);};EY.ptr.prototype.MapKeys=function(){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;new EZ(an.flag).mustBe(21);ao=(an.typ.kindType);ap=ao.key;aq=(new EZ(an.flag).ro()|((ap.Kind()>>>0)))>>>0;ar=$clone(an,EY).pointer();as=0;if(!(ar===0)){as=BB(ar);}at=AX(an.typ,ar);au=$makeSlice(II,as);av=0;av=0;case 1:if(!(av=au.$length)?($throwRuntimeError("index out of range"),undefined):au.$array[au.$offset+av]=FN(ap,aq,ax));BA(at);av=av+(1)>>0;$s=1;continue;case 2:$s=-1;return $subslice(au,0,av);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.MapKeys};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.MapKeys=function(){return this.$val.MapKeys();};FM.ptr.prototype.Key=function(){var an,ao,ap,aq,ar,as,at,au,av,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;if(an.it===0){$panic(new $String("MapIter.Key called before Next"));}ao=AY(an.it);$s=3;case 3:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}if(ao===0){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("MapIter.Key called on exhausted iterator"));case 2:ap=(an.m.typ.kindType);aq=ap.key;ar=aq;as=(new EZ(an.m.flag).ro()|((aq.Kind()>>>0)))>>>0;at=AY(an.it);$s=4;case 4:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}au=at;av=FN(ar,as,au);$s=5;case 5:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}$s=-1;return av;}return;}if($f===undefined){$f={$blk:FM.ptr.prototype.Key};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.$s=$s;$f.$r=$r;return $f;};FM.prototype.Key=function(){return this.$val.Key();};FM.ptr.prototype.Value=function(){var an,ao,ap,aq,ar,as,at,au,av,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;if(an.it===0){$panic(new $String("MapIter.Value called before Next"));}ao=AY(an.it);$s=3;case 3:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}if(ao===0){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("MapIter.Value called on exhausted iterator"));case 2:ap=(an.m.typ.kindType);aq=ap.elem;ar=aq;as=(new EZ(an.m.flag).ro()|((aq.Kind()>>>0)))>>>0;at=AZ(an.it);$s=4;case 4:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}au=at;av=FN(ar,as,au);$s=5;case 5:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}$s=-1;return av;}return;}if($f===undefined){$f={$blk:FM.ptr.prototype.Value};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.$s=$s;$f.$r=$r;return $f;};FM.prototype.Value=function(){return this.$val.Value();};FM.ptr.prototype.Next=function(){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;if(an.it===0){$s=1;continue;}$s=2;continue;case 1:an.it=AX(an.m.typ,$clone(an.m,EY).pointer());$s=3;continue;case 2:ao=AY(an.it);$s=6;case 6:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}if(ao===0){$s=4;continue;}$s=5;continue;case 4:$panic(new $String("MapIter.Next called on exhausted iterator"));case 5:BA(an.it);case 3:ap=AY(an.it);$s=7;case 7:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return!(ap===0);}return;}if($f===undefined){$f={$blk:FM.ptr.prototype.Next};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};FM.prototype.Next=function(){return this.$val.Next();};EY.ptr.prototype.MapRange=function(){var an;an=this;new EZ(an.flag).mustBe(21);return new FM.ptr($clone(an,EY),0);};EY.prototype.MapRange=function(){return this.$val.MapRange();};FN=function(an,ao,ap){var an,ao,ap,aq;if(EV(an)){aq=AL(an);AO(an,aq,ap);return new EY.ptr(an,aq,(ao|128)>>>0);}return new EY.ptr(an,(ap).$get(),ao);};EY.ptr.prototype.Method=function(an){var an,ao,ap;ao=this;if(ao.typ===HR.nil){$panic(new FC.ptr("reflect.Value.Method",0));}if(!((((ao.flag&512)>>>0)===0))||((an>>>0))>=((ao.typ.NumMethod()>>>0))){$panic(new $String("reflect: Method index out of range"));}if((ao.typ.Kind()===20)&&$clone(ao,EY).IsNil()){$panic(new $String("reflect: Method on nil interface value"));}ap=(ao.flag&160)>>>0;ap=(ap|(19))>>>0;ap=(ap|((((((an>>>0))<<10>>>0)|512)>>>0)))>>>0;return new EY.ptr(ao.typ,ao.ptr,ap);};EY.prototype.Method=function(an){return this.$val.Method(an);};EY.ptr.prototype.NumMethod=function(){var an;an=this;if(an.typ===HR.nil){$panic(new FC.ptr("reflect.Value.NumMethod",0));}if(!((((an.flag&512)>>>0)===0))){return 0;}return an.typ.NumMethod();};EY.prototype.NumMethod=function(){return this.$val.NumMethod();};EY.ptr.prototype.MethodByName=function(an){var an,ao,ap,aq,ar,as,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(ao.typ===HR.nil){$panic(new FC.ptr("reflect.Value.MethodByName",0));}if(!((((ao.flag&512)>>>0)===0))){$s=-1;return new EY.ptr(HR.nil,0,0);}aq=ao.typ.MethodByName(an);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ap=aq;ar=$clone(ap[0],CS);as=ap[1];if(!as){$s=-1;return new EY.ptr(HR.nil,0,0);}$s=-1;return $clone(ao,EY).Method(ar.Index);}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.MethodByName};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.MethodByName=function(an){return this.$val.MethodByName(an);};EY.ptr.prototype.NumField=function(){var an,ao;an=this;new EZ(an.flag).mustBe(25);ao=(an.typ.kindType);return ao.fields.$length;};EY.prototype.NumField=function(){return this.$val.NumField();};EY.ptr.prototype.OverflowComplex=function(an){var an,ao,ap,aq;ao=this;ap=new EZ(ao.flag).kind();aq=ap;if(aq===(15)){return FO(an.$real)||FO(an.$imag);}else if(aq===(16)){return false;}$panic(new FC.ptr("reflect.Value.OverflowComplex",new EZ(ao.flag).kind()));};EY.prototype.OverflowComplex=function(an){return this.$val.OverflowComplex(an);};EY.ptr.prototype.OverflowFloat=function(an){var an,ao,ap,aq;ao=this;ap=new EZ(ao.flag).kind();aq=ap;if(aq===(13)){return FO(an);}else if(aq===(14)){return false;}$panic(new FC.ptr("reflect.Value.OverflowFloat",new EZ(ao.flag).kind()));};EY.prototype.OverflowFloat=function(an){return this.$val.OverflowFloat(an);};FO=function(an){var an;if(an<0){an=-an;}return 3.4028234663852886e+38>>0;as=$shiftRightInt64(($shiftLeft64(an,((64-ar>>>0)))),((64-ar>>>0)));return!((an.$high===as.$high&&an.$low===as.$low));}$panic(new FC.ptr("reflect.Value.OverflowInt",new EZ(ao.flag).kind()));};EY.prototype.OverflowInt=function(an){return this.$val.OverflowInt(an);};EY.ptr.prototype.OverflowUint=function(an){var an,ao,ap,aq,ar,as;ao=this;ap=new EZ(ao.flag).kind();aq=ap;if((aq===(7))||(aq===(12))||(aq===(8))||(aq===(9))||(aq===(10))||(aq===(11))){ar=$imul(ao.typ.size,8)>>>0;as=$shiftRightUint64(($shiftLeft64(an,((64-ar>>>0)))),((64-ar>>>0)));return!((an.$high===as.$high&&an.$low===as.$low));}$panic(new FC.ptr("reflect.Value.OverflowUint",new EZ(ao.flag).kind()));};EY.prototype.OverflowUint=function(an){return this.$val.OverflowUint(an);};EY.ptr.prototype.Recv=function(){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=new EY.ptr(HR.nil,0,0);ao=false;ap=this;new EZ(ap.flag).mustBe(18);new EZ(ap.flag).mustBeExported();ar=$clone(ap,EY).recv(false);$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}aq=ar;an=aq[0];ao=aq[1];$s=-1;return[an,ao];}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Recv};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Recv=function(){return this.$val.Recv();};EY.ptr.prototype.recv=function(an){var an,ao,ap,aq,ar,as,at,au,av,aw,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=new EY.ptr(HR.nil,0,0);ap=false;aq=this;ar=(aq.typ.kindType);if((((ar.dir>>0))&1)===0){$panic(new $String("reflect: recv on send-only channel"));}as=ar.elem;ao=new EY.ptr(as,0,((as.Kind()>>>0)));at=0;if(EV(as)){at=AL(as);ao.ptr=at;ao.flag=(ao.flag|(128))>>>0;}else{at=((ao.$ptr_ptr||(ao.$ptr_ptr=new JC(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},ao))));}av=BP($clone(aq,EY).pointer(),an,at);$s=1;case 1:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}au=av;aw=au[0];ap=au[1];if(!aw){ao=new EY.ptr(HR.nil,0,0);}$s=-1;return[ao,ap];}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.recv};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.recv=function(an){return this.$val.recv(an);};EY.ptr.prototype.Send=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(18);new EZ(ao.flag).mustBeExported();ap=$clone(ao,EY).send($clone(an,EY),false);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}ap;$s=-1;return;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Send};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Send=function(an){return this.$val.Send(an);};EY.ptr.prototype.send=function(an,ao){var an,ao,ap,aq,ar,as,at,au,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=false;aq=this;ar=(aq.typ.kindType);if((((ar.dir>>0))&2)===0){$panic(new $String("reflect: send on recv-only channel"));}new EZ(an.flag).mustBeExported();as=$clone(an,EY).assignTo("reflect.Value.Send",ar.elem,0);$s=1;case 1:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}an=as;at=0;if(!((((an.flag&128)>>>0)===0))){at=an.ptr;}else{at=((an.$ptr_ptr||(an.$ptr_ptr=new JC(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},an))));}au=BQ($clone(aq,EY).pointer(),at,ao);$s=2;case 2:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}ap=au;$s=-1;return ap;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.send};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.send=function(an,ao){return this.$val.send(an,ao);};EY.ptr.prototype.SetBool=function(an){var an,ao;ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(1);(ao.ptr).$set(an);};EY.prototype.SetBool=function(an){return this.$val.SetBool(an);};EY.ptr.prototype.setRunes=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(23);ap=ao.typ.Elem().Kind();$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}if(!((ap===5))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.Value.setRunes of non-rune slice"));case 2:(ao.ptr).$set(an);$s=-1;return;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.setRunes};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.setRunes=function(an){return this.$val.setRunes(an);};EY.ptr.prototype.SetComplex=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();ap=new EZ(ao.flag).kind();aq=ap;if(aq===(15)){(ao.ptr).$set((new $Complex64(an.$real,an.$imag)));}else if(aq===(16)){(ao.ptr).$set(an);}else{$panic(new FC.ptr("reflect.Value.SetComplex",new EZ(ao.flag).kind()));}};EY.prototype.SetComplex=function(an){return this.$val.SetComplex(an);};EY.ptr.prototype.SetFloat=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();ap=new EZ(ao.flag).kind();aq=ap;if(aq===(13)){(ao.ptr).$set(($fround(an)));}else if(aq===(14)){(ao.ptr).$set(an);}else{$panic(new FC.ptr("reflect.Value.SetFloat",new EZ(ao.flag).kind()));}};EY.prototype.SetFloat=function(an){return this.$val.SetFloat(an);};EY.ptr.prototype.SetInt=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();ap=new EZ(ao.flag).kind();aq=ap;if(aq===(2)){(ao.ptr).$set((((an.$low+((an.$high>>31)*4294967296))>>0)));}else if(aq===(3)){(ao.ptr).$set((((an.$low+((an.$high>>31)*4294967296))<<24>>24)));}else if(aq===(4)){(ao.ptr).$set((((an.$low+((an.$high>>31)*4294967296))<<16>>16)));}else if(aq===(5)){(ao.ptr).$set((((an.$low+((an.$high>>31)*4294967296))>>0)));}else if(aq===(6)){(ao.ptr).$set(an);}else{$panic(new FC.ptr("reflect.Value.SetInt",new EZ(ao.flag).kind()));}};EY.prototype.SetInt=function(an){return this.$val.SetInt(an);};EY.ptr.prototype.SetMapIndex=function(an,ao){var an,ao,ap,aq,ar,as,at,au,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=this;new EZ(ap.flag).mustBe(21);new EZ(ap.flag).mustBeExported();new EZ(an.flag).mustBeExported();aq=(ap.typ.kindType);ar=$clone(an,EY).assignTo("reflect.Value.SetMapIndex",aq.key,0);$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}an=ar;as=0;if(!((((an.flag&128)>>>0)===0))){as=an.ptr;}else{as=((an.$ptr_ptr||(an.$ptr_ptr=new JC(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},an))));}if(ao.typ===HR.nil){AV(ap.typ,$clone(ap,EY).pointer(),as);$s=-1;return;}new EZ(ao.flag).mustBeExported();at=$clone(ao,EY).assignTo("reflect.Value.SetMapIndex",aq.elem,0);$s=2;case 2:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}ao=at;au=0;if(!((((ao.flag&128)>>>0)===0))){au=ao.ptr;}else{au=((ao.$ptr_ptr||(ao.$ptr_ptr=new JC(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},ao))));}$r=AU(ap.typ,$clone(ap,EY).pointer(),as,au);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.SetMapIndex};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.SetMapIndex=function(an,ao){return this.$val.SetMapIndex(an,ao);};EY.ptr.prototype.SetUint=function(an){var an,ao,ap,aq;ao=this;new EZ(ao.flag).mustBeAssignable();ap=new EZ(ao.flag).kind();aq=ap;if(aq===(7)){(ao.ptr).$set(((an.$low>>>0)));}else if(aq===(8)){(ao.ptr).$set(((an.$low<<24>>>24)));}else if(aq===(9)){(ao.ptr).$set(((an.$low<<16>>>16)));}else if(aq===(10)){(ao.ptr).$set(((an.$low>>>0)));}else if(aq===(11)){(ao.ptr).$set(an);}else if(aq===(12)){(ao.ptr).$set(((an.$low>>>0)));}else{$panic(new FC.ptr("reflect.Value.SetUint",new EZ(ao.flag).kind()));}};EY.prototype.SetUint=function(an){return this.$val.SetUint(an);};EY.ptr.prototype.SetPointer=function(an){var an,ao;ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(26);(ao.ptr).$set(an);};EY.prototype.SetPointer=function(an){return this.$val.SetPointer(an);};EY.ptr.prototype.SetString=function(an){var an,ao;ao=this;new EZ(ao.flag).mustBeAssignable();new EZ(ao.flag).mustBe(24);(ao.ptr).$set(an);};EY.prototype.SetString=function(an){return this.$val.SetString(an);};EY.ptr.prototype.String=function(){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=this;ao=new EZ(an.flag).kind();ap=ao;if(ap===(0)){$s=-1;return"";}else if(ap===(24)){$s=-1;return(an.ptr).$get();}aq=$clone(an,EY).Type().String();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return"<"+aq+" Value>";}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.String};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.String=function(){return this.$val.String();};EY.ptr.prototype.TryRecv=function(){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:an=new EY.ptr(HR.nil,0,0);ao=false;ap=this;new EZ(ap.flag).mustBe(18);new EZ(ap.flag).mustBeExported();ar=$clone(ap,EY).recv(true);$s=1;case 1:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}aq=ar;an=aq[0];ao=aq[1];$s=-1;return[an,ao];}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.TryRecv};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.TryRecv=function(){return this.$val.TryRecv();};EY.ptr.prototype.TrySend=function(an){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;new EZ(ao.flag).mustBe(18);new EZ(ao.flag).mustBeExported();ap=$clone(ao,EY).send($clone(an,EY),true);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.TrySend};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.TrySend=function(an){return this.$val.TrySend(an);};EY.ptr.prototype.Type=function(){var an,ao,ap,aq,ar,as,at,au;an=this;ao=an.flag;if(ao===0){$panic(new FC.ptr("reflect.Value.Type",0));}if(((ao&512)>>>0)===0){return an.typ;}ap=((an.flag>>0))>>10>>0;if(an.typ.Kind()===20){aq=(an.typ.kindType);if(((ap>>>0))>=((aq.methods.$length>>>0))){$panic(new $String("reflect: internal error: invalid method index"));}as=(ar=aq.methods,((ap<0||ap>=ar.$length)?($throwRuntimeError("index out of range"),undefined):ar.$array[ar.$offset+ap]));return an.typ.typeOff(as.typ);}at=an.typ.exportedMethods();if(((ap>>>0))>=((at.$length>>>0))){$panic(new $String("reflect: internal error: invalid method index"));}au=$clone(((ap<0||ap>=at.$length)?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+ap]),CG);return an.typ.typeOff(au.mtyp);};EY.prototype.Type=function(){return this.$val.Type();};EY.ptr.prototype.Uint=function(){var an,ao,ap,aq,ar;an=this;ao=new EZ(an.flag).kind();ap=an.ptr;aq=ao;if(aq===(7)){return(new $Uint64(0,(ap).$get()));}else if(aq===(8)){return(new $Uint64(0,(ap).$get()));}else if(aq===(9)){return(new $Uint64(0,(ap).$get()));}else if(aq===(10)){return(new $Uint64(0,(ap).$get()));}else if(aq===(11)){return(ap).$get();}else if(aq===(12)){return((ar=(ap).$get(),new $Uint64(0,ar.constructor===Number?ar:1)));}$panic(new FC.ptr("reflect.Value.Uint",new EZ(an.flag).kind()));};EY.prototype.Uint=function(){return this.$val.Uint();};EY.ptr.prototype.UnsafeAddr=function(){var an;an=this;if(an.typ===HR.nil){$panic(new FC.ptr("reflect.Value.UnsafeAddr",0));}if(((an.flag&256)>>>0)===0){$panic(new $String("reflect.Value.UnsafeAddr of unaddressable value"));}return(an.ptr);};EY.prototype.UnsafeAddr=function(){return this.$val.UnsafeAddr();};GH=function(an){var an,ao,ap,aq;if($interfaceIsEqual(an,$ifaceNil)){$panic(new $String("reflect: New(nil)"));}ao=$assertType(an,HR);ap=AL(ao);aq=22;return new EY.ptr(ao.ptrTo(),ap,aq);};$pkg.New=GH;EY.ptr.prototype.Convert=function(an){var an,ao,ap,aq,ar,as,at,au,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ao=this;if(!((((ao.flag&512)>>>0)===0))){$s=1;continue;}$s=2;continue;case 1:ap=BI("Convert",$clone(ao,EY));$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}ao=ap;case 2:aq=an.common();$s=4;case 4:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=GJ(aq,ao.typ);$s=5;case 5:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=ar;if(as===$throwNilPointerError){$s=6;continue;}$s=7;continue;case 6:at=an.String();$s=8;case 8:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$panic(new $String("reflect.Value.Convert: value of type "+ao.typ.String()+" cannot be converted to type "+at));case 7:au=as($clone(ao,EY),an);$s=9;case 9:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}$s=-1;return au;}return;}if($f===undefined){$f={$blk:EY.ptr.prototype.Convert};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.$s=$s;$f.$r=$r;return $f;};EY.prototype.Convert=function(an){return this.$val.Convert(an);};GJ=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=ao.Kind();if((ap===(2))||(ap===(3))||(ap===(4))||(ap===(5))||(ap===(6))){$s=2;continue;}if((ap===(7))||(ap===(8))||(ap===(9))||(ap===(10))||(ap===(11))||(ap===(12))){$s=3;continue;}if((ap===(13))||(ap===(14))){$s=4;continue;}if((ap===(15))||(ap===(16))){$s=5;continue;}if(ap===(24)){$s=6;continue;}if(ap===(23)){$s=7;continue;}$s=8;continue;case 2:aq=an.Kind();if((aq===(2))||(aq===(3))||(aq===(4))||(aq===(5))||(aq===(6))||(aq===(7))||(aq===(8))||(aq===(9))||(aq===(10))||(aq===(11))||(aq===(12))){$s=-1;return GP;}else if((aq===(13))||(aq===(14))){$s=-1;return GT;}else if(aq===(24)){$s=-1;return GX;}$s=8;continue;case 3:ar=an.Kind();if((ar===(2))||(ar===(3))||(ar===(4))||(ar===(5))||(ar===(6))||(ar===(7))||(ar===(8))||(ar===(9))||(ar===(10))||(ar===(11))||(ar===(12))){$s=-1;return GQ;}else if((ar===(13))||(ar===(14))){$s=-1;return GU;}else if(ar===(24)){$s=-1;return GY;}$s=8;continue;case 4:as=an.Kind();if((as===(2))||(as===(3))||(as===(4))||(as===(5))||(as===(6))){$s=-1;return GR;}else if((as===(7))||(as===(8))||(as===(9))||(as===(10))||(as===(11))||(as===(12))){$s=-1;return GS;}else if((as===(13))||(as===(14))){$s=-1;return GV;}$s=8;continue;case 5:at=an.Kind();if((at===(15))||(at===(16))){$s=-1;return GW;}$s=8;continue;case 6:if(!(an.Kind()===23)){au=false;$s=11;continue s;}av=an.Elem().PkgPath();$s=12;case 12:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}au=av==="";case 11:if(au){$s=9;continue;}$s=10;continue;case 9:aw=an.Elem().Kind();$s=14;case 14:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}ax=aw;if(ax===(8)){$s=-1;return HA;}else if(ax===(5)){$s=-1;return HC;}case 13:case 10:$s=8;continue;case 7:if(!(an.Kind()===24)){ay=false;$s=17;continue s;}az=ao.Elem().PkgPath();$s=18;case 18:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}ay=az==="";case 17:if(ay){$s=15;continue;}$s=16;continue;case 15:ba=ao.Elem().Kind();$s=20;case 20:if($c){$c=false;ba=ba.$blk();}if(ba&&ba.$blk!==undefined){break s;}bb=ba;if(bb===(8)){$s=-1;return GZ;}else if(bb===(5)){$s=-1;return HB;}case 19:case 16:case 8:case 1:bc=DP(an,ao,false);$s=23;case 23:if($c){$c=false;bc=bc.$blk();}if(bc&&bc.$blk!==undefined){break s;}if(bc){$s=21;continue;}$s=22;continue;case 21:$s=-1;return BC;case 22:if(!((an.Kind()===22)&&an.Name()===""&&(ao.Kind()===22)&&ao.Name()==="")){bd=false;$s=26;continue s;}be=an.Elem().common();$s=27;case 27:if($c){$c=false;be=be.$blk();}if(be&&be.$blk!==undefined){break s;}bf=be;bg=ao.Elem().common();$s=28;case 28:if($c){$c=false;bg=bg.$blk();}if(bg&&bg.$blk!==undefined){break s;}bh=bg;bi=DP(bf,bh,false);$s=29;case 29:if($c){$c=false;bi=bi.$blk();}if(bi&&bi.$blk!==undefined){break s;}bd=bi;case 26:if(bd){$s=24;continue;}$s=25;continue;case 24:$s=-1;return BC;case 25:if(DM(an,ao)){if(ao.Kind()===20){$s=-1;return HE;}$s=-1;return HD;}$s=-1;return $throwNilPointerError;}return;}if($f===undefined){$f={$blk:GJ};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.$s=$s;$f.$r=$r;return $f;};GK=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=ap.common();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;as=AL(ar);at=ar.size;if(at===(4)){(as).$set(($fround(ao)));}else if(at===(8)){(as).$set(ao);}$s=-1;return new EY.ptr(ar,as,(((an|128)>>>0)|((ar.Kind()>>>0)))>>>0);}return;}if($f===undefined){$f={$blk:GK};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};GL=function(an,ao,ap){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=ap.common();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;as=AL(ar);at=ar.size;if(at===(8)){(as).$set((new $Complex64(ao.$real,ao.$imag)));}else if(at===(16)){(as).$set(ao);}$s=-1;return new EY.ptr(ar,as,(((an|128)>>>0)|((ar.Kind()>>>0)))>>>0);}return;}if($f===undefined){$f={$blk:GL};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};GM=function(an,ao,ap){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=$clone(GH(ap),EY).Elem();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;$clone(ar,EY).SetString(ao);ar.flag=(((ar.flag&~256)>>>0)|an)>>>0;$s=-1;return ar;}return;}if($f===undefined){$f={$blk:GM};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};GN=function(an,ao,ap){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=$clone(GH(ap),EY).Elem();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;$r=$clone(ar,EY).SetBytes(ao);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ar.flag=(((ar.flag&~256)>>>0)|an)>>>0;$s=-1;return ar;}return;}if($f===undefined){$f={$blk:GN};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};GO=function(an,ao,ap){var an,ao,ap,aq,ar,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=$clone(GH(ap),EY).Elem();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;$r=$clone(ar,EY).setRunes(ao);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ar.flag=(((ar.flag&~256)>>>0)|an)>>>0;$s=-1;return ar;}return;}if($f===undefined){$f={$blk:GO};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.$s=$s;$f.$r=$r;return $f;};GP=function(an,ao){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=AM(new EZ(an.flag).ro(),((ap=$clone(an,EY).Int(),new $Uint64(ap.$high,ap.$low))),ao);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:GP};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};GQ=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=AM(new EZ(an.flag).ro(),$clone(an,EY).Uint(),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GQ};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GR=function(an,ao){var an,ao,ap,aq,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:aq=AM(new EZ(an.flag).ro(),((ap=(new $Int64(0,$clone(an,EY).Float())),new $Uint64(ap.$high,ap.$low))),ao);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:GR};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.$s=$s;$f.$r=$r;return $f;};GS=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=AM(new EZ(an.flag).ro(),(new $Uint64(0,$clone(an,EY).Float())),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GS};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GT=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GK(new EZ(an.flag).ro(),($flatten64($clone(an,EY).Int())),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GT};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GU=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GK(new EZ(an.flag).ro(),($flatten64($clone(an,EY).Uint())),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GU};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GV=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GK(new EZ(an.flag).ro(),$clone(an,EY).Float(),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GV};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GW=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GL(new EZ(an.flag).ro(),$clone(an,EY).Complex(),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GW};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GX=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GM(new EZ(an.flag).ro(),($encodeRune($clone(an,EY).Int().$low)),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GX};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GY=function(an,ao){var an,ao,ap,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=GM(new EZ(an.flag).ro(),($encodeRune($clone(an,EY).Uint().$low)),ao);$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}$s=-1;return ap;}return;}if($f===undefined){$f={$blk:GY};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.$s=$s;$f.$r=$r;return $f;};GZ=function(an,ao){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=new EZ(an.flag).ro();aq=$clone(an,EY).Bytes();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=($bytesToString(aq));as=ao;at=GM(ap,ar,as);$s=2;case 2:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;}return;}if($f===undefined){$f={$blk:GZ};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};HA=function(an,ao){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=new EZ(an.flag).ro();aq=$clone(an,EY).String();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=(new IU($stringToBytes(aq)));as=ao;at=GN(ap,ar,as);$s=2;case 2:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;}return;}if($f===undefined){$f={$blk:HA};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};HB=function(an,ao){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=new EZ(an.flag).ro();aq=$clone(an,EY).runes();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=($runesToString(aq));as=ao;at=GM(ap,ar,as);$s=2;case 2:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;}return;}if($f===undefined){$f={$blk:HB};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};HC=function(an,ao){var an,ao,ap,aq,ar,as,at,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=new EZ(an.flag).ro();aq=$clone(an,EY).String();$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=(new JE($stringToRunes(aq)));as=ao;at=GO(ap,ar,as);$s=2;case 2:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}$s=-1;return at;}return;}if($f===undefined){$f={$blk:HC};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.$s=$s;$f.$r=$r;return $f;};HD=function(an,ao){var an,ao,ap,aq,ar,as,at,au,av,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:ap=ao.common();$s=1;case 1:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}aq=AL(ap);$s=2;case 2:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;as=BF($clone(an,EY),false);$s=3;case 3:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}at=as;au=ao.NumMethod();$s=7;case 7:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}if(au===0){$s=4;continue;}$s=5;continue;case 4:(ar).$set(at);$s=6;continue;case 5:BG($assertType(ao,HR),at,ar);case 6:av=ao.common();$s=8;case 8:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}$s=-1;return new EY.ptr(av,ar,(((new EZ(an.flag).ro()|128)>>>0)|20)>>>0);}return;}if($f===undefined){$f={$blk:HD};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.$s=$s;$f.$r=$r;return $f;};HE=function(an,ao){var an,ao,ap,aq,ar,as,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if($clone(an,EY).IsNil()){$s=1;continue;}$s=2;continue;case 1:ap=AK(ao);$s=3;case 3:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}aq=ap;aq.flag=(aq.flag|(new EZ(an.flag).ro()))>>>0;$s=-1;return aq;case 2:ar=$clone(an,EY).Elem();$s=4;case 4:if($c){$c=false;ar=ar.$blk();}if(ar&&ar.$blk!==undefined){break s;}as=HD($clone(ar,EY),ao);$s=5;case 5:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}$s=-1;return as;}return;}if($f===undefined){$f={$blk:HE};}$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.$s=$s;$f.$r=$r;return $f;};IE.methods=[{prop:"methods",name:"methods",pkg:"reflect",typ:$funcType([],[IB],false)},{prop:"exportedMethods",name:"exportedMethods",pkg:"reflect",typ:$funcType([],[IB],false)}];IK.methods=[{prop:"in$",name:"in",pkg:"reflect",typ:$funcType([],[HS],false)},{prop:"out",name:"out",pkg:"reflect",typ:$funcType([],[HS],false)}];Q.methods=[{prop:"name",name:"name",pkg:"reflect",typ:$funcType([],[$String],false)},{prop:"tag",name:"tag",pkg:"reflect",typ:$funcType([],[$String],false)},{prop:"pkgPath",name:"pkgPath",pkg:"reflect",typ:$funcType([],[$String],false)},{prop:"isExported",name:"isExported",pkg:"reflect",typ:$funcType([],[$Bool],false)},{prop:"data",name:"data",pkg:"reflect",typ:$funcType([$Int,$String],[IA],false)},{prop:"nameLen",name:"nameLen",pkg:"reflect",typ:$funcType([],[$Int],false)},{prop:"tagLen",name:"tagLen",pkg:"reflect",typ:$funcType([],[$Int],false)}];IJ.methods=[{prop:"skipUntilValidKey",name:"skipUntilValidKey",pkg:"reflect",typ:$funcType([],[],false)}];CC.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];HR.methods=[{prop:"uncommon",name:"uncommon",pkg:"reflect",typ:$funcType([],[IE],false)},{prop:"nameOff",name:"nameOff",pkg:"reflect",typ:$funcType([DB],[Q],false)},{prop:"typeOff",name:"typeOff",pkg:"reflect",typ:$funcType([DC],[HR],false)},{prop:"ptrTo",name:"ptrTo",pkg:"reflect",typ:$funcType([],[HR],false)},{prop:"pointers",name:"pointers",pkg:"reflect",typ:$funcType([],[$Bool],false)},{prop:"Comparable",name:"Comparable",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Method",name:"Method",pkg:"",typ:$funcType([$Int],[CS],false)},{prop:"textOff",name:"textOff",pkg:"reflect",typ:$funcType([DD],[$UnsafePointer],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Bits",name:"Bits",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Align",name:"Align",pkg:"",typ:$funcType([],[$Int],false)},{prop:"FieldAlign",name:"FieldAlign",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[CC],false)},{prop:"common",name:"common",pkg:"reflect",typ:$funcType([],[HR],false)},{prop:"exportedMethods",name:"exportedMethods",pkg:"reflect",typ:$funcType([],[IB],false)},{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)},{prop:"MethodByName",name:"MethodByName",pkg:"",typ:$funcType([$String],[CS,$Bool],false)},{prop:"PkgPath",name:"PkgPath",pkg:"",typ:$funcType([],[$String],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"ChanDir",name:"ChanDir",pkg:"",typ:$funcType([],[CH],false)},{prop:"IsVariadic",name:"IsVariadic",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[CB],false)},{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[DG],false)},{prop:"FieldByIndex",name:"FieldByIndex",pkg:"",typ:$funcType([IR],[DG],false)},{prop:"FieldByName",name:"FieldByName",pkg:"",typ:$funcType([$String],[DG,$Bool],false)},{prop:"FieldByNameFunc",name:"FieldByNameFunc",pkg:"",typ:$funcType([JG],[DG,$Bool],false)},{prop:"In",name:"In",pkg:"",typ:$funcType([$Int],[CB],false)},{prop:"Key",name:"Key",pkg:"",typ:$funcType([],[CB],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumField",name:"NumField",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumIn",name:"NumIn",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumOut",name:"NumOut",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Out",name:"Out",pkg:"",typ:$funcType([$Int],[CB],false)},{prop:"Implements",name:"Implements",pkg:"",typ:$funcType([CB],[$Bool],false)},{prop:"AssignableTo",name:"AssignableTo",pkg:"",typ:$funcType([CB],[$Bool],false)},{prop:"ConvertibleTo",name:"ConvertibleTo",pkg:"",typ:$funcType([CB],[$Bool],false)}];CH.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];IP.methods=[{prop:"Method",name:"Method",pkg:"",typ:$funcType([$Int],[CS],false)},{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)},{prop:"MethodByName",name:"MethodByName",pkg:"",typ:$funcType([$String],[CS,$Bool],false)}];JJ.methods=[{prop:"offset",name:"offset",pkg:"reflect",typ:$funcType([],[$Uintptr],false)},{prop:"embedded",name:"embedded",pkg:"reflect",typ:$funcType([],[$Bool],false)}];IT.methods=[{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[DG],false)},{prop:"FieldByIndex",name:"FieldByIndex",pkg:"",typ:$funcType([IR],[DG],false)},{prop:"FieldByNameFunc",name:"FieldByNameFunc",pkg:"",typ:$funcType([JG],[DG,$Bool],false)},{prop:"FieldByName",name:"FieldByName",pkg:"",typ:$funcType([$String],[DG,$Bool],false)}];DH.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"Lookup",name:"Lookup",pkg:"",typ:$funcType([$String],[$String,$Bool],false)}];EY.methods=[{prop:"object",name:"object",pkg:"reflect",typ:$funcType([],[HW],false)},{prop:"assignTo",name:"assignTo",pkg:"reflect",typ:$funcType([$String,HR,$UnsafePointer],[EY],false)},{prop:"call",name:"call",pkg:"reflect",typ:$funcType([$String,II],[II],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[EY],false)},{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[EY],false)},{prop:"Index",name:"Index",pkg:"",typ:$funcType([$Int],[EY],false)},{prop:"InterfaceData",name:"InterfaceData",pkg:"",typ:$funcType([],[JQ],false)},{prop:"IsNil",name:"IsNil",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Pointer",name:"Pointer",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([EY],[],false)},{prop:"SetBytes",name:"SetBytes",pkg:"",typ:$funcType([IU],[],false)},{prop:"SetCap",name:"SetCap",pkg:"",typ:$funcType([$Int],[],false)},{prop:"SetLen",name:"SetLen",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Slice",name:"Slice",pkg:"",typ:$funcType([$Int,$Int],[EY],false)},{prop:"Slice3",name:"Slice3",pkg:"",typ:$funcType([$Int,$Int,$Int],[EY],false)},{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[],false)},{prop:"pointer",name:"pointer",pkg:"reflect",typ:$funcType([],[$UnsafePointer],false)},{prop:"Addr",name:"Addr",pkg:"",typ:$funcType([],[EY],false)},{prop:"Bool",name:"Bool",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[IU],false)},{prop:"runes",name:"runes",pkg:"reflect",typ:$funcType([],[JE],false)},{prop:"CanAddr",name:"CanAddr",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"CanSet",name:"CanSet",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Call",name:"Call",pkg:"",typ:$funcType([II],[II],false)},{prop:"CallSlice",name:"CallSlice",pkg:"",typ:$funcType([II],[II],false)},{prop:"Complex",name:"Complex",pkg:"",typ:$funcType([],[$Complex128],false)},{prop:"FieldByIndex",name:"FieldByIndex",pkg:"",typ:$funcType([IR],[EY],false)},{prop:"FieldByName",name:"FieldByName",pkg:"",typ:$funcType([$String],[EY],false)},{prop:"FieldByNameFunc",name:"FieldByNameFunc",pkg:"",typ:$funcType([JG],[EY],false)},{prop:"Float",name:"Float",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Int",name:"Int",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"CanInterface",name:"CanInterface",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Interface",name:"Interface",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"IsValid",name:"IsValid",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[CC],false)},{prop:"MapIndex",name:"MapIndex",pkg:"",typ:$funcType([EY],[EY],false)},{prop:"MapKeys",name:"MapKeys",pkg:"",typ:$funcType([],[II],false)},{prop:"MapRange",name:"MapRange",pkg:"",typ:$funcType([],[JR],false)},{prop:"Method",name:"Method",pkg:"",typ:$funcType([$Int],[EY],false)},{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)},{prop:"MethodByName",name:"MethodByName",pkg:"",typ:$funcType([$String],[EY],false)},{prop:"NumField",name:"NumField",pkg:"",typ:$funcType([],[$Int],false)},{prop:"OverflowComplex",name:"OverflowComplex",pkg:"",typ:$funcType([$Complex128],[$Bool],false)},{prop:"OverflowFloat",name:"OverflowFloat",pkg:"",typ:$funcType([$Float64],[$Bool],false)},{prop:"OverflowInt",name:"OverflowInt",pkg:"",typ:$funcType([$Int64],[$Bool],false)},{prop:"OverflowUint",name:"OverflowUint",pkg:"",typ:$funcType([$Uint64],[$Bool],false)},{prop:"Recv",name:"Recv",pkg:"",typ:$funcType([],[EY,$Bool],false)},{prop:"recv",name:"recv",pkg:"reflect",typ:$funcType([$Bool],[EY,$Bool],false)},{prop:"Send",name:"Send",pkg:"",typ:$funcType([EY],[],false)},{prop:"send",name:"send",pkg:"reflect",typ:$funcType([EY,$Bool],[$Bool],false)},{prop:"SetBool",name:"SetBool",pkg:"",typ:$funcType([$Bool],[],false)},{prop:"setRunes",name:"setRunes",pkg:"reflect",typ:$funcType([JE],[],false)},{prop:"SetComplex",name:"SetComplex",pkg:"",typ:$funcType([$Complex128],[],false)},{prop:"SetFloat",name:"SetFloat",pkg:"",typ:$funcType([$Float64],[],false)},{prop:"SetInt",name:"SetInt",pkg:"",typ:$funcType([$Int64],[],false)},{prop:"SetMapIndex",name:"SetMapIndex",pkg:"",typ:$funcType([EY,EY],[],false)},{prop:"SetUint",name:"SetUint",pkg:"",typ:$funcType([$Uint64],[],false)},{prop:"SetPointer",name:"SetPointer",pkg:"",typ:$funcType([$UnsafePointer],[],false)},{prop:"SetString",name:"SetString",pkg:"",typ:$funcType([$String],[],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"TryRecv",name:"TryRecv",pkg:"",typ:$funcType([],[EY,$Bool],false)},{prop:"TrySend",name:"TrySend",pkg:"",typ:$funcType([EY],[$Bool],false)},{prop:"Type",name:"Type",pkg:"",typ:$funcType([],[CB],false)},{prop:"Uint",name:"Uint",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"UnsafeAddr",name:"UnsafeAddr",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Convert",name:"Convert",pkg:"",typ:$funcType([CB],[EY],false)}];EZ.methods=[{prop:"kind",name:"kind",pkg:"reflect",typ:$funcType([],[CC],false)},{prop:"ro",name:"ro",pkg:"reflect",typ:$funcType([],[EZ],false)},{prop:"mustBe",name:"mustBe",pkg:"reflect",typ:$funcType([CC],[],false)},{prop:"mustBeExported",name:"mustBeExported",pkg:"reflect",typ:$funcType([],[],false)},{prop:"mustBeAssignable",name:"mustBeAssignable",pkg:"reflect",typ:$funcType([],[],false)}];JS.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];JR.methods=[{prop:"Key",name:"Key",pkg:"",typ:$funcType([],[EY],false)},{prop:"Value",name:"Value",pkg:"",typ:$funcType([],[EY],false)},{prop:"Next",name:"Next",pkg:"",typ:$funcType([],[$Bool],false)}];N.init("reflect",[{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:DB,tag:""},{prop:"mcount",name:"mcount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"xcount",name:"xcount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"moff",name:"moff",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"_methods",name:"_methods",embedded:false,exported:false,typ:IB,tag:""}]);P.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:"reflect:\"func\""},{prop:"inCount",name:"inCount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"outCount",name:"outCount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"_in",name:"_in",embedded:false,exported:false,typ:HS,tag:""},{prop:"_out",name:"_out",embedded:false,exported:false,typ:HS,tag:""}]);Q.init("reflect",[{prop:"bytes",name:"bytes",embedded:false,exported:false,typ:IA,tag:""}]);R.init("reflect",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"tag",name:"tag",embedded:false,exported:false,typ:$String,tag:""},{prop:"exported",name:"exported",embedded:false,exported:false,typ:$Bool,tag:""}]);AW.init("reflect",[{prop:"t",name:"t",embedded:false,exported:false,typ:CB,tag:""},{prop:"m",name:"m",embedded:false,exported:false,typ:HW,tag:""},{prop:"keys",name:"keys",embedded:false,exported:false,typ:HW,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int,tag:""},{prop:"last",name:"last",embedded:false,exported:false,typ:HW,tag:""}]);CB.init([{prop:"Align",name:"Align",pkg:"",typ:$funcType([],[$Int],false)},{prop:"AssignableTo",name:"AssignableTo",pkg:"",typ:$funcType([CB],[$Bool],false)},{prop:"Bits",name:"Bits",pkg:"",typ:$funcType([],[$Int],false)},{prop:"ChanDir",name:"ChanDir",pkg:"",typ:$funcType([],[CH],false)},{prop:"Comparable",name:"Comparable",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"ConvertibleTo",name:"ConvertibleTo",pkg:"",typ:$funcType([CB],[$Bool],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[CB],false)},{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[DG],false)},{prop:"FieldAlign",name:"FieldAlign",pkg:"",typ:$funcType([],[$Int],false)},{prop:"FieldByIndex",name:"FieldByIndex",pkg:"",typ:$funcType([IR],[DG],false)},{prop:"FieldByName",name:"FieldByName",pkg:"",typ:$funcType([$String],[DG,$Bool],false)},{prop:"FieldByNameFunc",name:"FieldByNameFunc",pkg:"",typ:$funcType([JG],[DG,$Bool],false)},{prop:"Implements",name:"Implements",pkg:"",typ:$funcType([CB],[$Bool],false)},{prop:"In",name:"In",pkg:"",typ:$funcType([$Int],[CB],false)},{prop:"IsVariadic",name:"IsVariadic",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Key",name:"Key",pkg:"",typ:$funcType([],[CB],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[CC],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Method",name:"Method",pkg:"",typ:$funcType([$Int],[CS],false)},{prop:"MethodByName",name:"MethodByName",pkg:"",typ:$funcType([$String],[CS,$Bool],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"NumField",name:"NumField",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumIn",name:"NumIn",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumOut",name:"NumOut",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Out",name:"Out",pkg:"",typ:$funcType([$Int],[CB],false)},{prop:"PkgPath",name:"PkgPath",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"common",name:"common",pkg:"reflect",typ:$funcType([],[HR],false)},{prop:"uncommon",name:"uncommon",pkg:"reflect",typ:$funcType([],[IE],false)}]);CE.init("reflect",[{prop:"size",name:"size",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"ptrdata",name:"ptrdata",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"hash",name:"hash",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"tflag",name:"tflag",embedded:false,exported:false,typ:CD,tag:""},{prop:"align",name:"align",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"fieldAlign",name:"fieldAlign",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"kind",name:"kind",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"alg",name:"alg",embedded:false,exported:false,typ:HZ,tag:""},{prop:"gcdata",name:"gcdata",embedded:false,exported:false,typ:IA,tag:""},{prop:"str",name:"str",embedded:false,exported:false,typ:DB,tag:""},{prop:"ptrToThis",name:"ptrToThis",embedded:false,exported:false,typ:DC,tag:""}]);CF.init("reflect",[{prop:"hash",name:"hash",embedded:false,exported:false,typ:JH,tag:""},{prop:"equal",name:"equal",embedded:false,exported:false,typ:JI,tag:""}]);CG.init("reflect",[{prop:"name",name:"name",embedded:false,exported:false,typ:DB,tag:""},{prop:"mtyp",name:"mtyp",embedded:false,exported:false,typ:DC,tag:""},{prop:"ifn",name:"ifn",embedded:false,exported:false,typ:DD,tag:""},{prop:"tfn",name:"tfn",embedded:false,exported:false,typ:DD,tag:""}]);CI.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:HR,tag:""},{prop:"slice",name:"slice",embedded:false,exported:false,typ:HR,tag:""},{prop:"len",name:"len",embedded:false,exported:false,typ:$Uintptr,tag:""}]);CJ.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:HR,tag:""},{prop:"dir",name:"dir",embedded:false,exported:false,typ:$Uintptr,tag:""}]);CK.init("reflect",[{prop:"name",name:"name",embedded:false,exported:false,typ:DB,tag:""},{prop:"typ",name:"typ",embedded:false,exported:false,typ:DC,tag:""}]);CL.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:Q,tag:""},{prop:"methods",name:"methods",embedded:false,exported:false,typ:IC,tag:""}]);CM.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"key",name:"key",embedded:false,exported:false,typ:HR,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:HR,tag:""},{prop:"bucket",name:"bucket",embedded:false,exported:false,typ:HR,tag:""},{prop:"keysize",name:"keysize",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"valuesize",name:"valuesize",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"bucketsize",name:"bucketsize",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"flags",name:"flags",embedded:false,exported:false,typ:$Uint32,tag:""}]);CN.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:HR,tag:""}]);CO.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:HR,tag:""}]);CP.init("reflect",[{prop:"name",name:"name",embedded:false,exported:false,typ:Q,tag:""},{prop:"typ",name:"typ",embedded:false,exported:false,typ:HR,tag:""},{prop:"offsetEmbed",name:"offsetEmbed",embedded:false,exported:false,typ:$Uintptr,tag:""}]);CQ.init("reflect",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:CE,tag:""},{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:Q,tag:""},{prop:"fields",name:"fields",embedded:false,exported:false,typ:ID,tag:""}]);CS.init("",[{prop:"Name",name:"Name",embedded:false,exported:true,typ:$String,tag:""},{prop:"PkgPath",name:"PkgPath",embedded:false,exported:true,typ:$String,tag:""},{prop:"Type",name:"Type",embedded:false,exported:true,typ:CB,tag:""},{prop:"Func",name:"Func",embedded:false,exported:true,typ:EY,tag:""},{prop:"Index",name:"Index",embedded:false,exported:true,typ:$Int,tag:""}]);DG.init("",[{prop:"Name",name:"Name",embedded:false,exported:true,typ:$String,tag:""},{prop:"PkgPath",name:"PkgPath",embedded:false,exported:true,typ:$String,tag:""},{prop:"Type",name:"Type",embedded:false,exported:true,typ:CB,tag:""},{prop:"Tag",name:"Tag",embedded:false,exported:true,typ:DH,tag:""},{prop:"Offset",name:"Offset",embedded:false,exported:true,typ:$Uintptr,tag:""},{prop:"Index",name:"Index",embedded:false,exported:true,typ:IR,tag:""},{prop:"Anonymous",name:"Anonymous",embedded:false,exported:true,typ:$Bool,tag:""}]);DI.init("reflect",[{prop:"typ",name:"typ",embedded:false,exported:false,typ:IT,tag:""},{prop:"index",name:"index",embedded:false,exported:false,typ:IR,tag:""}]);EY.init("reflect",[{prop:"typ",name:"typ",embedded:false,exported:false,typ:HR,tag:""},{prop:"ptr",name:"ptr",embedded:false,exported:false,typ:$UnsafePointer,tag:""},{prop:"flag",name:"flag",embedded:true,exported:false,typ:EZ,tag:""}]);FC.init("",[{prop:"Method",name:"Method",embedded:false,exported:true,typ:$String,tag:""},{prop:"Kind",name:"Kind",embedded:false,exported:true,typ:CC,tag:""}]);FM.init("reflect",[{prop:"m",name:"m",embedded:false,exported:false,typ:EY,tag:""},{prop:"it",name:"it",embedded:false,exported:false,typ:$UnsafePointer,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}U=HQ.nil;W=HS.nil;I=false;O={};S={};BJ=$assertType($internalize($call,$emptyInterface),HX);BO=$assertType($internalize($select,$emptyInterface),HX);BK=L($jsObjectPtr);CT=new HY(["invalid","bool","int","int8","int16","int32","int64","uint","uint8","uint16","uint32","uint64","uintptr","float32","float64","complex64","complex128","array","chan","func","interface","map","ptr","slice","string","struct","unsafe.Pointer"]);FL=$assertType(AD(new $Uint8(0)),HR);$r=J();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["sort"]=(function(){var $pkg={},$init,A,S,W,AU,AX,AY,B,C,F,J,K,L,M,N,O,P,Q,R,AA,AG,AH,AI,AJ,AK,AL,AM,AN,AP,AQ;A=$packages["reflect"];S=$pkg.lessSwap=$newType(0,$kindStruct,"sort.lessSwap",true,"sort",false,function(Less_,Swap_){this.$val=this;if(arguments.length===0){this.Less=$throwNilPointerError;this.Swap=$throwNilPointerError;return;}this.Less=Less_;this.Swap=Swap_;});W=$pkg.IntSlice=$newType(12,$kindSlice,"sort.IntSlice",true,"sort",true,null);AU=$sliceType($Int);AX=$funcType([$Int,$Int],[$Bool],false);AY=$funcType([$Int,$Int],[],false);B=function(a,b){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=a;e=c;f=d;case 1:if(!(e>0)>>>0))>>>1>>>0)>>0));h=b(g);$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if(!h){$s=3;continue;}$s=4;continue;case 3:e=g+1>>0;$s=5;continue;case 4:f=g;case 5:$s=1;continue;case 2:$s=-1;return e;}return;}if($f===undefined){$f={$blk:B};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Search=B;C=function(a,b){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=B(a[0].$length,(function(a,b){return function(c){var c;return((c<0||c>=a[0].$length)?($throwRuntimeError("index out of range"),undefined):a[0].$array[a[0].$offset+c])>=b[0];};})(a,b));$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:C};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};$pkg.SearchInts=C;W.prototype.Search=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=C($subslice(new AU(b.$array),b.$offset,b.$offset+b.$length),a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:W.prototype.Search};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(W).prototype.Search=function(a){return this.$get().Search(a);};F=function(a,b){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=A.ValueOf(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=A.Swapper(a);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=$clone(d,A.Value).Len();$r=AQ(new S.ptr(b,f),0,g,R(g));$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:F};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Slice=F;J=function(a,b,c){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=b+1>>0;case 1:if(!(db)){f=false;$s=5;continue s;}g=a.Less(e,e-1>>0);$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;case 5:if(!(f)){$s=4;continue;}$r=a.Swap(e,e-1>>0);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e-(1)>>0;$s=3;continue;case 4:d=d+(1)>>0;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:J};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};K=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=b;case 1:f=($imul(2,e))+1>>0;if(f>=c){$s=2;continue;}if(!((f+1>>0)>0,(d+f>>0)+1>>0);$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;case 5:if(g){$s=3;continue;}$s=4;continue;case 3:f=f+(1)>>0;case 4:i=a.Less(d+e>>0,d+f>>0);$s=9;case 9:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}if(!i){$s=7;continue;}$s=8;continue;case 7:$s=-1;return;case 8:$r=a.Swap(d+e>>0,d+f>>0);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=f;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:K};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};L=function(a,b,c){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=b;e=0;f=c-b>>0;h=(g=((f-1>>0))/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"));case 1:if(!(h>=0)){$s=2;continue;}$r=K(a,h,f,d);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}h=h-(1)>>0;$s=1;continue;case 2:i=f-1>>0;case 4:if(!(i>=0)){$s=5;continue;}$r=a.Swap(d,d+i>>0);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K(a,e,i,d);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=i-(1)>>0;$s=4;continue;case 5:$s=-1;return;}return;}if($f===undefined){$f={$blk:L};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};M=function(a,b,c,d){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=a.Less(b,c);$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}if(e){$s=1;continue;}$s=2;continue;case 1:$r=a.Swap(b,c);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:f=a.Less(d,b);$s=7;case 7:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}if(f){$s=5;continue;}$s=6;continue;case 5:$r=a.Swap(d,b);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}g=a.Less(b,c);$s=11;case 11:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}if(g){$s=9;continue;}$s=10;continue;case 9:$r=a.Swap(b,c);$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 10:case 6:$s=-1;return;}return;}if($f===undefined){$f={$blk:M};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};N=function(a,b,c,d){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;case 1:if(!(e>0,c+e>>0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e+(1)>>0;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:N};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};O=function(a,b,c){var a,aa,ab,ac,ad,ae,af,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=0;f=((((((b+c>>0)>>>0))>>>1>>>0)>>0));if((c-b>>0)>40){$s=1;continue;}$s=2;continue;case 1:h=(g=((c-b>>0))/8,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"));$r=M(a,b,b+h>>0,b+($imul(2,h))>>0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=M(a,f,f-h>>0,f+h>>0);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=M(a,c-1>>0,(c-1>>0)-h>>0,(c-1>>0)-($imul(2,h))>>0);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$r=M(a,b,f,c-1>>0);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=b;j=b+1>>0;k=c-1>>0;l=j;m=k;case 7:if(!(l>0;$s=7;continue;case 8:p=l;case 11:case 13:if(!(p>0;$s=13;continue;case 14:case 17:if(!(p>0);$s=20;case 20:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;case 19:if(!(s)){$s=18;continue;}m=m-(1)>>0;$s=17;continue;case 18:if(p>=m){$s=12;continue;}$r=a.Swap(p,m-1>>0);$s=21;case 21:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}p=p+(1)>>0;m=m-(1)>>0;$s=11;continue;case 12:u=(c-m>>0)<5;if(!u&&(c-m>>0)<(v=((c-b>>0))/4,(v===v&&v!==1/0&&v!==-1/0)?v>>0:$throwRuntimeError("integer divide by zero"))){$s=22;continue;}$s=23;continue;case 22:w=0;x=a.Less(i,c-1>>0);$s=26;case 26:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}if(!x){$s=24;continue;}$s=25;continue;case 24:$r=a.Swap(m,c-1>>0);$s=27;case 27:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}m=m+(1)>>0;w=w+(1)>>0;case 25:y=a.Less(p-1>>0,i);$s=30;case 30:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}if(!y){$s=28;continue;}$s=29;continue;case 28:p=p-(1)>>0;w=w+(1)>>0;case 29:z=a.Less(f,i);$s=33;case 33:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}if(!z){$s=31;continue;}$s=32;continue;case 31:$r=a.Swap(f,p-1>>0);$s=34;case 34:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}p=p-(1)>>0;w=w+(1)>>0;case 32:u=w>1;case 23:if(u){$s=35;continue;}$s=36;continue;case 35:case 37:case 39:if(!(l>0,i);$s=42;case 42:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=!ab;case 41:if(!(aa)){$s=40;continue;}p=p-(1)>>0;$s=39;continue;case 40:case 43:if(!(l>0;$s=43;continue;case 44:if(l>=p){$s=38;continue;}$r=a.Swap(l,p-1>>0);$s=47;case 47:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=l+(1)>>0;p=p-(1)>>0;$s=37;continue;case 38:case 36:$r=a.Swap(i,p-1>>0);$s=48;case 48:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ae=p-1>>0;af=m;d=ae;e=af;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:O};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};P=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:case 1:if(!((c-b>>0)>12)){$s=2;continue;}if(d===0){$s=3;continue;}$s=4;continue;case 3:$r=L(a,b,c);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 4:d=d-(1)>>0;f=O(a,b,c);$s=6;case 6:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[0];h=e[1];if((g-b>>0)<(c-h>>0)){$s=7;continue;}$s=8;continue;case 7:$r=P(a,b,g,d);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}b=h;$s=9;continue;case 8:$r=P(a,h,c,d);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=g;case 9:$s=1;continue;case 2:if((c-b>>0)>1){$s=12;continue;}$s=13;continue;case 12:i=b+6>>0;case 14:if(!(i>0);$s=18;case 18:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}if(j){$s=16;continue;}$s=17;continue;case 16:$r=a.Swap(i,i-6>>0);$s=19;case 19:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 17:i=i+(1)>>0;$s=14;continue;case 15:$r=J(a,b,c);$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 13:$s=-1;return;}return;}if($f===undefined){$f={$blk:P};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};Q=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=a.Len();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;$r=P(a,0,c,R(c));$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:Q};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sort=Q;R=function(a){var a,b,c;b=0;c=a;while(true){if(!(c>0)){break;}b=b+(1)>>0;c=(c>>$min((1),31))>>0;}return $imul(b,2);};W.prototype.Len=function(){var a;a=this;return a.$length;};$ptrType(W).prototype.Len=function(){return this.$get().Len();};W.prototype.Less=function(a,b){var a,b,c;c=this;return((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a])<((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]);};$ptrType(W).prototype.Less=function(a,b){return this.$get().Less(a,b);};W.prototype.Swap=function(a,b){var a,b,c,d,e;c=this;d=((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]);e=((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]);((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]=d);((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]=e);};$ptrType(W).prototype.Swap=function(a,b){return this.$get().Swap(a,b);};W.prototype.Sort=function(){var a,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;$r=Q(a);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:W.prototype.Sort};}$f.a=a;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(W).prototype.Sort=function(){return this.$get().Sort();};AA=function(a){var a,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=Q(($subslice(new W(a.$array),a.$offset,a.$offset+a.$length)));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AA};}$f.a=a;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Ints=AA;AG=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=a;c=a.Len();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;$r=AH(b,d);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AG};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Stable=AG;AH=function(a,b){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=20;d=0;e=c;f=d;g=e;case 1:if(!(g<=b)){$s=2;continue;}$r=J(a,f,g);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=g;g=g+(c)>>0;$s=1;continue;case 2:$r=J(a,f,b);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 5:if(!(c>0,g);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=g;g=g+(($imul(2,c)))>>0;$s=7;continue;case 8:j=f+c>>0;if(j>0)===1){$s=1;continue;}$s=2;continue;case 1:e=c;f=d;case 3:if(!(e>0)>>>0))>>>1>>>0)>>0));h=a.Less(g,b);$s=8;case 8:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if(h){$s=5;continue;}$s=6;continue;case 5:e=g+1>>0;$s=7;continue;case 6:f=g;case 7:$s=3;continue;case 4:i=b;case 9:if(!(i<(e-1>>0))){$s=10;continue;}$r=a.Swap(i,i+1>>0);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=i+(1)>>0;$s=9;continue;case 10:$s=-1;return;case 2:if((d-c>>0)===1){$s=12;continue;}$s=13;continue;case 12:j=b;k=c;case 14:if(!(j>0)>>>0))>>>1>>>0)>>0));m=a.Less(c,l);$s=19;case 19:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}if(!m){$s=16;continue;}$s=17;continue;case 16:j=l+1>>0;$s=18;continue;case 17:k=l;case 18:$s=14;continue;case 15:n=c;case 20:if(!(n>j)){$s=21;continue;}$r=a.Swap(n,n-1>>0);$s=22;case 22:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}n=n-(1)>>0;$s=20;continue;case 21:$s=-1;return;case 13:o=((((((b+d>>0)>>>0))>>>1>>>0)>>0));p=o+c>>0;q=0;r=0;s=q;t=r;if(c>o){s=p-d>>0;t=o;}else{s=b;t=c;}u=p-1>>0;case 23:if(!(s>0)>>>0))>>>1>>>0)>>0));w=a.Less(u-v>>0,v);$s=28;case 28:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}if(!w){$s=25;continue;}$s=26;continue;case 25:s=v+1>>0;$s=27;continue;case 26:t=v;case 27:$s=23;continue;case 24:x=p-s>>0;if(s>0;f=d-c>>0;case 1:if(!(!((e===f)))){$s=2;continue;}if(e>f){$s=3;continue;}$s=4;continue;case 3:$r=N(a,c-e>>0,c,f);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e-(f)>>0;$s=5;continue;case 4:$r=N(a,c-e>>0,(c+f>>0)-e>>0,e);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=f-(e)>>0;case 5:$s=1;continue;case 2:$r=N(a,c-e>>0,c,e);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AJ};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AK=function(a,b,c){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=b+1>>0;case 1:if(!(db)){f=false;$s=5;continue s;}g=a.Less(e,e-1>>0);$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;case 5:if(!(f)){$s=4;continue;}$r=a.Swap(e,e-1>>0);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e-(1)>>0;$s=3;continue;case 4:d=d+(1)>>0;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:AK};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AL=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=b;case 1:f=($imul(2,e))+1>>0;if(f>=c){$s=2;continue;}if(!((f+1>>0)>0,(d+f>>0)+1>>0);$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;case 5:if(g){$s=3;continue;}$s=4;continue;case 3:f=f+(1)>>0;case 4:i=a.Less(d+e>>0,d+f>>0);$s=9;case 9:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}if(!i){$s=7;continue;}$s=8;continue;case 7:$s=-1;return;case 8:$r=a.Swap(d+e>>0,d+f>>0);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=f;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:AL};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AM=function(a,b,c){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=b;e=0;f=c-b>>0;h=(g=((f-1>>0))/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"));case 1:if(!(h>=0)){$s=2;continue;}$r=AL($clone(a,S),h,f,d);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}h=h-(1)>>0;$s=1;continue;case 2:i=f-1>>0;case 4:if(!(i>=0)){$s=5;continue;}$r=a.Swap(d,d+i>>0);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=AL($clone(a,S),e,i,d);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=i-(1)>>0;$s=4;continue;case 5:$s=-1;return;}return;}if($f===undefined){$f={$blk:AM};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AN=function(a,b,c,d){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=a.Less(b,c);$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}if(e){$s=1;continue;}$s=2;continue;case 1:$r=a.Swap(b,c);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:f=a.Less(d,b);$s=7;case 7:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}if(f){$s=5;continue;}$s=6;continue;case 5:$r=a.Swap(d,b);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}g=a.Less(b,c);$s=11;case 11:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}if(g){$s=9;continue;}$s=10;continue;case 9:$r=a.Swap(b,c);$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 10:case 6:$s=-1;return;}return;}if($f===undefined){$f={$blk:AN};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AP=function(a,b,c){var a,aa,ab,ac,ad,ae,af,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=0;f=((((((b+c>>0)>>>0))>>>1>>>0)>>0));if((c-b>>0)>40){$s=1;continue;}$s=2;continue;case 1:h=(g=((c-b>>0))/8,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"));$r=AN($clone(a,S),b,b+h>>0,b+($imul(2,h))>>0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=AN($clone(a,S),f,f-h>>0,f+h>>0);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=AN($clone(a,S),c-1>>0,(c-1>>0)-h>>0,(c-1>>0)-($imul(2,h))>>0);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$r=AN($clone(a,S),b,f,c-1>>0);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=b;j=b+1>>0;k=c-1>>0;l=j;m=k;case 7:if(!(l>0;$s=7;continue;case 8:p=l;case 11:case 13:if(!(p>0;$s=13;continue;case 14:case 17:if(!(p>0);$s=20;case 20:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;case 19:if(!(s)){$s=18;continue;}m=m-(1)>>0;$s=17;continue;case 18:if(p>=m){$s=12;continue;}$r=a.Swap(p,m-1>>0);$s=21;case 21:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}p=p+(1)>>0;m=m-(1)>>0;$s=11;continue;case 12:u=(c-m>>0)<5;if(!u&&(c-m>>0)<(v=((c-b>>0))/4,(v===v&&v!==1/0&&v!==-1/0)?v>>0:$throwRuntimeError("integer divide by zero"))){$s=22;continue;}$s=23;continue;case 22:w=0;x=a.Less(i,c-1>>0);$s=26;case 26:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}if(!x){$s=24;continue;}$s=25;continue;case 24:$r=a.Swap(m,c-1>>0);$s=27;case 27:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}m=m+(1)>>0;w=w+(1)>>0;case 25:y=a.Less(p-1>>0,i);$s=30;case 30:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}if(!y){$s=28;continue;}$s=29;continue;case 28:p=p-(1)>>0;w=w+(1)>>0;case 29:z=a.Less(f,i);$s=33;case 33:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}if(!z){$s=31;continue;}$s=32;continue;case 31:$r=a.Swap(f,p-1>>0);$s=34;case 34:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}p=p-(1)>>0;w=w+(1)>>0;case 32:u=w>1;case 23:if(u){$s=35;continue;}$s=36;continue;case 35:case 37:case 39:if(!(l>0,i);$s=42;case 42:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=!ab;case 41:if(!(aa)){$s=40;continue;}p=p-(1)>>0;$s=39;continue;case 40:case 43:if(!(l>0;$s=43;continue;case 44:if(l>=p){$s=38;continue;}$r=a.Swap(l,p-1>>0);$s=47;case 47:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=l+(1)>>0;p=p-(1)>>0;$s=37;continue;case 38:case 36:$r=a.Swap(i,p-1>>0);$s=48;case 48:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ae=p-1>>0;af=m;d=ae;e=af;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:AP};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AQ=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:case 1:if(!((c-b>>0)>12)){$s=2;continue;}if(d===0){$s=3;continue;}$s=4;continue;case 3:$r=AM($clone(a,S),b,c);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 4:d=d-(1)>>0;f=AP($clone(a,S),b,c);$s=6;case 6:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[0];h=e[1];if((g-b>>0)<(c-h>>0)){$s=7;continue;}$s=8;continue;case 7:$r=AQ($clone(a,S),b,g,d);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}b=h;$s=9;continue;case 8:$r=AQ($clone(a,S),h,c,d);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=g;case 9:$s=1;continue;case 2:if((c-b>>0)>1){$s=12;continue;}$s=13;continue;case 12:i=b+6>>0;case 14:if(!(i>0);$s=18;case 18:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}if(j){$s=16;continue;}$s=17;continue;case 16:$r=a.Swap(i,i-6>>0);$s=19;case 19:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 17:i=i+(1)>>0;$s=14;continue;case 15:$r=AK($clone(a,S),b,c);$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 13:$s=-1;return;}return;}if($f===undefined){$f={$blk:AQ};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};W.methods=[{prop:"Search",name:"Search",pkg:"",typ:$funcType([$Int],[$Int],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Less",name:"Less",pkg:"",typ:$funcType([$Int,$Int],[$Bool],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$Int,$Int],[],false)},{prop:"Sort",name:"Sort",pkg:"",typ:$funcType([],[],false)}];S.init("",[{prop:"Less",name:"Less",embedded:false,exported:true,typ:AX,tag:""},{prop:"Swap",name:"Swap",embedded:false,exported:true,typ:AY,tag:""}]);W.init($Int);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/fmtsort"]=(function(){var $pkg={},$init,A,B,C,I,J,D,E,F,G,H;A=$packages["reflect"];B=$packages["sort"];C=$pkg.SortedMap=$newType(0,$kindStruct,"fmtsort.SortedMap",true,"internal/fmtsort",true,function(Key_,Value_){this.$val=this;if(arguments.length===0){this.Key=J.nil;this.Value=J.nil;return;}this.Key=Key_;this.Value=Value_;});I=$ptrType(C);J=$sliceType(A.Value);C.ptr.prototype.Len=function(){var a;a=this;return a.Key.$length;};C.prototype.Len=function(){return this.$val.Len();};C.ptr.prototype.Less=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;f=E($clone((d=c.Key,((a<0||a>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+a])),A.Value),$clone((e=c.Key,((b<0||b>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+b])),A.Value));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f<0;}return;}if($f===undefined){$f={$blk:C.ptr.prototype.Less};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};C.prototype.Less=function(a,b){return this.$val.Less(a,b);};C.ptr.prototype.Swap=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;c=this;d=(e=c.Key,((b<0||b>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+b]));f=(g=c.Key,((a<0||a>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+a]));(h=c.Key,((a<0||a>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+a]=d));(i=c.Key,((b<0||b>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+b]=f));j=(k=c.Value,((b<0||b>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+b]));l=(m=c.Value,((a<0||a>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+a]));(n=c.Value,((a<0||a>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+a]=j));(o=c.Value,((b<0||b>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+b]=l));};C.prototype.Swap=function(a,b){return this.$val.Swap(a,b);};D=function(a){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=$clone(a,A.Value).Type().Kind();$s=3;case 3:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}if(!((b===21))){$s=1;continue;}$s=2;continue;case 1:$s=-1;return I.nil;case 2:c=$makeSlice(J,$clone(a,A.Value).Len());d=$makeSlice(J,c.$length);e=$clone(a,A.Value).MapRange();f=0;case 4:g=e.Next();$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}if(!(g)){$s=5;continue;}h=e.Key();$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=h);i=e.Value();$s=8;case 8:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f]=i);f=f+(1)>>0;$s=4;continue;case 5:j=new C.ptr(c,d);$r=B.Stable(j);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return j;}return;}if($f===undefined){$f={$blk:D};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sort=D;E=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;b=$f.b;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;bu=$f.bu;bv=$f.bv;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=$clone(a,A.Value).Type();d=$clone(b,A.Value).Type();e=c;f=d;if(!($interfaceIsEqual(e,f))){$s=-1;return-1;}g=$clone(a,A.Value).Kind();if((g===(2))||(g===(3))||(g===(4))||(g===(5))||(g===(6))){$s=2;continue;}if((g===(7))||(g===(8))||(g===(9))||(g===(10))||(g===(11))||(g===(12))){$s=3;continue;}if(g===(24)){$s=4;continue;}if((g===(13))||(g===(14))){$s=5;continue;}if((g===(15))||(g===(16))){$s=6;continue;}if(g===(1)){$s=7;continue;}if(g===(22)){$s=8;continue;}if(g===(18)){$s=9;continue;}if(g===(25)){$s=10;continue;}if(g===(17)){$s=11;continue;}if(g===(20)){$s=12;continue;}$s=13;continue;case 2:h=$clone(a,A.Value).Int();i=$clone(b,A.Value).Int();j=h;k=i;if((j.$highk.$high||(j.$high===k.$high&&j.$low>k.$low))){$s=-1;return 1;}else{$s=-1;return 0;}$s=14;continue;case 3:l=$clone(a,A.Value).Uint();m=$clone(b,A.Value).Uint();n=l;o=m;if((n.$higho.$high||(n.$high===o.$high&&n.$low>o.$low))){$s=-1;return 1;}else{$s=-1;return 0;}$s=14;continue;case 4:q=$clone(a,A.Value).String();$s=15;case 15:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;s=$clone(b,A.Value).String();$s=16;case 16:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}r=s;t=p;u=r;if(tu){$s=-1;return 1;}else{$s=-1;return 0;}$s=14;continue;case 5:$s=-1;return G($clone(a,A.Value).Float(),$clone(b,A.Value).Float());case 6:v=$clone(a,A.Value).Complex();w=$clone(b,A.Value).Complex();x=v;y=w;z=G(x.$real,y.$real);if(!((z===0))){$s=-1;return z;}$s=-1;return G(x.$imag,y.$imag);case 7:aa=$clone(a,A.Value).Bool();ab=$clone(b,A.Value).Bool();ac=aa;ad=ab;if(ac===ad){$s=-1;return 0;}else if(ac){$s=-1;return 1;}else{$s=-1;return-1;}$s=14;continue;case 8:ae=$clone(a,A.Value).Pointer();af=$clone(b,A.Value).Pointer();ag=ae;ah=af;if(agah){$s=-1;return 1;}else{$s=-1;return 0;}$s=14;continue;case 9:ai=F($clone(a,A.Value),$clone(b,A.Value));aj=ai[0];ak=ai[1];if(ak){$s=-1;return aj;}al=$clone(a,A.Value).Pointer();am=$clone(b,A.Value).Pointer();an=al;ao=am;if(anao){$s=-1;return 1;}else{$s=-1;return 0;}$s=14;continue;case 10:ap=0;case 17:if(!(ap<$clone(a,A.Value).NumField())){$s=18;continue;}aq=$clone(a,A.Value).Field(ap);$s=19;case 19:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=$clone(aq,A.Value);as=$clone(b,A.Value).Field(ap);$s=20;case 20:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}at=$clone(as,A.Value);au=E(ar,at);$s=21;case 21:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}av=au;if(!((av===0))){$s=-1;return av;}ap=ap+(1)>>0;$s=17;continue;case 18:$s=-1;return 0;case 11:aw=0;case 22:if(!(aw<$clone(a,A.Value).Len())){$s=23;continue;}ax=$clone(a,A.Value).Index(aw);$s=24;case 24:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ay=$clone(ax,A.Value);az=$clone(b,A.Value).Index(aw);$s=25;case 25:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}ba=$clone(az,A.Value);bb=E(ay,ba);$s=26;case 26:if($c){$c=false;bb=bb.$blk();}if(bb&&bb.$blk!==undefined){break s;}bc=bb;if(!((bc===0))){$s=-1;return bc;}aw=aw+(1)>>0;$s=22;continue;case 23:$s=-1;return 0;case 12:bd=F($clone(a,A.Value),$clone(b,A.Value));be=bd[0];bf=bd[1];if(bf){$s=-1;return be;}bg=$clone(a,A.Value).Elem();$s=27;case 27:if($c){$c=false;bg=bg.$blk();}if(bg&&bg.$blk!==undefined){break s;}bh=$clone(bg,A.Value).Type();$s=28;case 28:if($c){$c=false;bh=bh.$blk();}if(bh&&bh.$blk!==undefined){break s;}bi=A.ValueOf(bh);$s=29;case 29:if($c){$c=false;bi=bi.$blk();}if(bi&&bi.$blk!==undefined){break s;}bj=$clone(bi,A.Value);bk=$clone(b,A.Value).Elem();$s=30;case 30:if($c){$c=false;bk=bk.$blk();}if(bk&&bk.$blk!==undefined){break s;}bl=$clone(bk,A.Value).Type();$s=31;case 31:if($c){$c=false;bl=bl.$blk();}if(bl&&bl.$blk!==undefined){break s;}bm=A.ValueOf(bl);$s=32;case 32:if($c){$c=false;bm=bm.$blk();}if(bm&&bm.$blk!==undefined){break s;}bn=$clone(bm,A.Value);bo=E(bj,bn);$s=33;case 33:if($c){$c=false;bo=bo.$blk();}if(bo&&bo.$blk!==undefined){break s;}bp=bo;if(!((bp===0))){$s=-1;return bp;}bq=$clone(a,A.Value).Elem();$s=34;case 34:if($c){$c=false;bq=bq.$blk();}if(bq&&bq.$blk!==undefined){break s;}br=$clone(bq,A.Value);bs=$clone(b,A.Value).Elem();$s=35;case 35:if($c){$c=false;bs=bs.$blk();}if(bs&&bs.$blk!==undefined){break s;}bt=$clone(bs,A.Value);bu=E(br,bt);$s=36;case 36:if($c){$c=false;bu=bu.$blk();}if(bu&&bu.$blk!==undefined){break s;}$s=-1;return bu;case 13:bv=e.String();$s=37;case 37:if($c){$c=false;bv=bv.$blk();}if(bv&&bv.$blk!==undefined){break s;}$panic(new $String("bad type in compare: "+bv));case 14:case 1:$s=-1;return 0;}return;}if($f===undefined){$f={$blk:E};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.b=b;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.bu=bu;$f.bv=bv;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};F=function(a,b){var a,b;if($clone(a,A.Value).IsNil()){if($clone(b,A.Value).IsNil()){return[0,true];}return[-1,true];}if($clone(b,A.Value).IsNil()){return[1,true];}return[0,false];};G=function(a,b){var a,b;if(H(a)){return-1;}else if(H(b)){return 1;}else if(ab){return 1;}return 0;};H=function(a){var a;return!((a===a));};I.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Less",name:"Less",pkg:"",typ:$funcType([$Int,$Int],[$Bool],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$Int,$Int],[],false)}];C.init("",[{prop:"Key",name:"Key",embedded:false,exported:true,typ:J,tag:""},{prop:"Value",name:"Value",embedded:false,exported:true,typ:J,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["syscall"]=(function(){var $pkg={},$init,A,D,B,C,CB,EH,EI,GM,GN,GV,GW,GX,GY,NJ,NS,NX,NY,NZ,OA,OB,OC,OD,OE,OF,OG,OH,OI,OJ,OK,PL,PN,PV,PZ,QF,QG,QH,QL,QT,QU,RA,RB,RC,RD,RE,RG,RK,RL,RO,RP,RR,RS,RT,RU,RV,RW,RX,RY,RZ,SF,E,F,P,Q,R,AG,FX,GO,GP,GQ,HR,PU,HW,G,H,I,K,L,M,S,T,U,Y,Z,AA,AB,AC,BC,BD,BZ,CA,CZ,DA,EJ,EK,EL,EU,EV,EX,FP,FQ,FR,FS,GC,GR,GT,GU,HC,HD,HE,HF,HG,HH,HI,HJ,HL,IR,IS,IY,IZ,JB,JE,JF,JZ,KU,KY,LG,LH,LJ,LT,LU,LV,MF,MK,ML,MO,MR,MS,MX,MY,MZ,NA,NB;A=$packages["github.com/gopherjs/gopherjs/js"];D=$packages["internal/race"];B=$packages["runtime"];C=$packages["sync"];CB=$pkg.RawConn=$newType(8,$kindInterface,"syscall.RawConn",true,"syscall",true,null);EH=$pkg.SockaddrLinklayer=$newType(0,$kindStruct,"syscall.SockaddrLinklayer",true,"syscall",true,function(Protocol_,Ifindex_,Hatype_,Pkttype_,Halen_,Addr_,raw_){this.$val=this;if(arguments.length===0){this.Protocol=0;this.Ifindex=0;this.Hatype=0;this.Pkttype=0;this.Halen=0;this.Addr=QF.zero();this.raw=new OA.ptr(0,0,0,0,0,0,QF.zero());return;}this.Protocol=Protocol_;this.Ifindex=Ifindex_;this.Hatype=Hatype_;this.Pkttype=Pkttype_;this.Halen=Halen_;this.Addr=Addr_;this.raw=raw_;});EI=$pkg.SockaddrNetlink=$newType(0,$kindStruct,"syscall.SockaddrNetlink",true,"syscall",true,function(Family_,Pad_,Pid_,Groups_,raw_){this.$val=this;if(arguments.length===0){this.Family=0;this.Pad=0;this.Pid=0;this.Groups=0;this.raw=new OB.ptr(0,0,0,0);return;}this.Family=Family_;this.Pad=Pad_;this.Pid=Pid_;this.Groups=Groups_;this.raw=raw_;});GM=$pkg.mmapper=$newType(0,$kindStruct,"syscall.mmapper",true,"syscall",false,function(Mutex_,active_,mmap_,munmap_){this.$val=this;if(arguments.length===0){this.Mutex=new C.Mutex.ptr(0,0);this.active=false;this.mmap=$throwNilPointerError;this.munmap=$throwNilPointerError;return;}this.Mutex=Mutex_;this.active=active_;this.mmap=mmap_;this.munmap=munmap_;});GN=$pkg.Errno=$newType(4,$kindUintptr,"syscall.Errno",true,"syscall",true,null);GV=$pkg.Sockaddr=$newType(8,$kindInterface,"syscall.Sockaddr",true,"syscall",true,null);GW=$pkg.SockaddrInet4=$newType(0,$kindStruct,"syscall.SockaddrInet4",true,"syscall",true,function(Port_,Addr_,raw_){this.$val=this;if(arguments.length===0){this.Port=0;this.Addr=RB.zero();this.raw=new NX.ptr(0,0,RB.zero(),QF.zero());return;}this.Port=Port_;this.Addr=Addr_;this.raw=raw_;});GX=$pkg.SockaddrInet6=$newType(0,$kindStruct,"syscall.SockaddrInet6",true,"syscall",true,function(Port_,ZoneId_,Addr_,raw_){this.$val=this;if(arguments.length===0){this.Port=0;this.ZoneId=0;this.Addr=QH.zero();this.raw=new NY.ptr(0,0,0,QH.zero(),0);return;}this.Port=Port_;this.ZoneId=ZoneId_;this.Addr=Addr_;this.raw=raw_;});GY=$pkg.SockaddrUnix=$newType(0,$kindStruct,"syscall.SockaddrUnix",true,"syscall",true,function(Name_,raw_){this.$val=this;if(arguments.length===0){this.Name="";this.raw=new NZ.ptr(0,RA.zero());return;}this.Name=Name_;this.raw=raw_;});NJ=$pkg.Timespec=$newType(0,$kindStruct,"syscall.Timespec",true,"syscall",true,function(Sec_,Nsec_){this.$val=this;if(arguments.length===0){this.Sec=new $Int64(0,0);this.Nsec=new $Int64(0,0);return;}this.Sec=Sec_;this.Nsec=Nsec_;});NS=$pkg.Stat_t=$newType(0,$kindStruct,"syscall.Stat_t",true,"syscall",true,function(Dev_,Ino_,Nlink_,Mode_,Uid_,Gid_,X__pad0_,Rdev_,Size_,Blksize_,Blocks_,Atim_,Mtim_,Ctim_,X__unused_){this.$val=this;if(arguments.length===0){this.Dev=new $Uint64(0,0);this.Ino=new $Uint64(0,0);this.Nlink=new $Uint64(0,0);this.Mode=0;this.Uid=0;this.Gid=0;this.X__pad0=0;this.Rdev=new $Uint64(0,0);this.Size=new $Int64(0,0);this.Blksize=new $Int64(0,0);this.Blocks=new $Int64(0,0);this.Atim=new NJ.ptr(new $Int64(0,0),new $Int64(0,0));this.Mtim=new NJ.ptr(new $Int64(0,0),new $Int64(0,0));this.Ctim=new NJ.ptr(new $Int64(0,0),new $Int64(0,0));this.X__unused=QU.zero();return;}this.Dev=Dev_;this.Ino=Ino_;this.Nlink=Nlink_;this.Mode=Mode_;this.Uid=Uid_;this.Gid=Gid_;this.X__pad0=X__pad0_;this.Rdev=Rdev_;this.Size=Size_;this.Blksize=Blksize_;this.Blocks=Blocks_;this.Atim=Atim_;this.Mtim=Mtim_;this.Ctim=Ctim_;this.X__unused=X__unused_;});NX=$pkg.RawSockaddrInet4=$newType(0,$kindStruct,"syscall.RawSockaddrInet4",true,"syscall",true,function(Family_,Port_,Addr_,Zero_){this.$val=this;if(arguments.length===0){this.Family=0;this.Port=0;this.Addr=RB.zero();this.Zero=QF.zero();return;}this.Family=Family_;this.Port=Port_;this.Addr=Addr_;this.Zero=Zero_;});NY=$pkg.RawSockaddrInet6=$newType(0,$kindStruct,"syscall.RawSockaddrInet6",true,"syscall",true,function(Family_,Port_,Flowinfo_,Addr_,Scope_id_){this.$val=this;if(arguments.length===0){this.Family=0;this.Port=0;this.Flowinfo=0;this.Addr=QH.zero();this.Scope_id=0;return;}this.Family=Family_;this.Port=Port_;this.Flowinfo=Flowinfo_;this.Addr=Addr_;this.Scope_id=Scope_id_;});NZ=$pkg.RawSockaddrUnix=$newType(0,$kindStruct,"syscall.RawSockaddrUnix",true,"syscall",true,function(Family_,Path_){this.$val=this;if(arguments.length===0){this.Family=0;this.Path=RA.zero();return;}this.Family=Family_;this.Path=Path_;});OA=$pkg.RawSockaddrLinklayer=$newType(0,$kindStruct,"syscall.RawSockaddrLinklayer",true,"syscall",true,function(Family_,Protocol_,Ifindex_,Hatype_,Pkttype_,Halen_,Addr_){this.$val=this;if(arguments.length===0){this.Family=0;this.Protocol=0;this.Ifindex=0;this.Hatype=0;this.Pkttype=0;this.Halen=0;this.Addr=QF.zero();return;}this.Family=Family_;this.Protocol=Protocol_;this.Ifindex=Ifindex_;this.Hatype=Hatype_;this.Pkttype=Pkttype_;this.Halen=Halen_;this.Addr=Addr_;});OB=$pkg.RawSockaddrNetlink=$newType(0,$kindStruct,"syscall.RawSockaddrNetlink",true,"syscall",true,function(Family_,Pad_,Pid_,Groups_){this.$val=this;if(arguments.length===0){this.Family=0;this.Pad=0;this.Pid=0;this.Groups=0;return;}this.Family=Family_;this.Pad=Pad_;this.Pid=Pid_;this.Groups=Groups_;});OC=$pkg.RawSockaddr=$newType(0,$kindStruct,"syscall.RawSockaddr",true,"syscall",true,function(Family_,Data_){this.$val=this;if(arguments.length===0){this.Family=0;this.Data=RC.zero();return;}this.Family=Family_;this.Data=Data_;});OD=$pkg.RawSockaddrAny=$newType(0,$kindStruct,"syscall.RawSockaddrAny",true,"syscall",true,function(Addr_,Pad_){this.$val=this;if(arguments.length===0){this.Addr=new OC.ptr(0,RC.zero());this.Pad=RD.zero();return;}this.Addr=Addr_;this.Pad=Pad_;});OE=$pkg._Socklen=$newType(4,$kindUint32,"syscall._Socklen",true,"syscall",false,null);OF=$pkg.Linger=$newType(0,$kindStruct,"syscall.Linger",true,"syscall",true,function(Onoff_,Linger_){this.$val=this;if(arguments.length===0){this.Onoff=0;this.Linger=0;return;}this.Onoff=Onoff_;this.Linger=Linger_;});OG=$pkg.Iovec=$newType(0,$kindStruct,"syscall.Iovec",true,"syscall",true,function(Base_,Len_){this.$val=this;if(arguments.length===0){this.Base=PV.nil;this.Len=new $Uint64(0,0);return;}this.Base=Base_;this.Len=Len_;});OH=$pkg.IPMreq=$newType(0,$kindStruct,"syscall.IPMreq",true,"syscall",true,function(Multiaddr_,Interface_){this.$val=this;if(arguments.length===0){this.Multiaddr=RB.zero();this.Interface=RB.zero();return;}this.Multiaddr=Multiaddr_;this.Interface=Interface_;});OI=$pkg.IPMreqn=$newType(0,$kindStruct,"syscall.IPMreqn",true,"syscall",true,function(Multiaddr_,Address_,Ifindex_){this.$val=this;if(arguments.length===0){this.Multiaddr=RB.zero();this.Address=RB.zero();this.Ifindex=0;return;}this.Multiaddr=Multiaddr_;this.Address=Address_;this.Ifindex=Ifindex_;});OJ=$pkg.IPv6Mreq=$newType(0,$kindStruct,"syscall.IPv6Mreq",true,"syscall",true,function(Multiaddr_,Interface_){this.$val=this;if(arguments.length===0){this.Multiaddr=QH.zero();this.Interface=0;return;}this.Multiaddr=Multiaddr_;this.Interface=Interface_;});OK=$pkg.Msghdr=$newType(0,$kindStruct,"syscall.Msghdr",true,"syscall",true,function(Name_,Namelen_,Pad_cgo_0_,Iov_,Iovlen_,Control_,Controllen_,Flags_,Pad_cgo_1_){this.$val=this;if(arguments.length===0){this.Name=PV.nil;this.Namelen=0;this.Pad_cgo_0=RB.zero();this.Iov=RG.nil;this.Iovlen=new $Uint64(0,0);this.Control=PV.nil;this.Controllen=new $Uint64(0,0);this.Flags=0;this.Pad_cgo_1=RB.zero();return;}this.Name=Name_;this.Namelen=Namelen_;this.Pad_cgo_0=Pad_cgo_0_;this.Iov=Iov_;this.Iovlen=Iovlen_;this.Control=Control_;this.Controllen=Controllen_;this.Flags=Flags_;this.Pad_cgo_1=Pad_cgo_1_;});PL=$sliceType($Uint8);PN=$sliceType($String);PV=$ptrType($Uint8);PZ=$ptrType($Int32);QF=$arrayType($Uint8,8);QG=$ptrType($Uint16);QH=$arrayType($Uint8,16);QL=$ptrType(EI);QT=$arrayType($Uint8,32);QU=$arrayType($Int64,3);RA=$arrayType($Int8,108);RB=$arrayType($Uint8,4);RC=$arrayType($Int8,14);RD=$arrayType($Int8,96);RE=$ptrType(OE);RG=$ptrType(OG);RK=$structType("syscall",[{prop:"addr",name:"addr",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"len",name:"len",embedded:false,exported:false,typ:$Int,tag:""},{prop:"cap",name:"cap",embedded:false,exported:false,typ:$Int,tag:""}]);RL=$ptrType($Int64);RO=$funcType([$Uintptr],[],false);RP=$funcType([$Uintptr],[$Bool],false);RR=$ptrType(EH);RS=$ptrType(GM);RT=$mapType(PV,PL);RU=$funcType([$Uintptr,$Uintptr,$Int,$Int,$Int,$Int64],[$Uintptr,$error],false);RV=$funcType([$Uintptr,$Uintptr],[$error],false);RW=$ptrType(GW);RX=$ptrType(GX);RY=$ptrType(GY);RZ=$ptrType(NJ);SF=$ptrType(OK);G=function(){$flushConsole=(function(){if(!((F.$length===0))){$global.console.log($externalize(($bytesToString(F)),$String));F=PL.nil;}});};H=function(){if(!E){$global.console.error($externalize("warning: system calls not available, see https://github.com/gopherjs/gopherjs/blob/master/doc/syscalls.md",$String));}E=true;};I=function(k){var k,l,m;l=$global.goPrintToConsole;if(!(l===undefined)){l(k);return;}F=$appendSlice(F,k);while(true){m=L(F,10);if(m===-1){break;}$global.console.log($externalize(($bytesToString($subslice(F,0,m))),$String));F=$subslice(F,(m+1>>0));}};K=function(k){var k;T(231,((k>>>0)),0,0);};$pkg.Exit=K;L=function(k,l){var k,l,m,n,o,p;m=k;n=0;while(true){if(!(n=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]);if(p===l){return o;}n++;}return-1;};M=function(){var k,l,m,n,o,p;k=$global.process;if(k===undefined){return PN.nil;}l=k.env;m=$global.Object.keys(l);n=$makeSlice(PN,$parseInt(m.length));o=0;while(true){if(!(o<$parseInt(m.length))){break;}p=$internalize(m[o],$String);((o<0||o>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]=p+"="+$internalize(l[$externalize(p,$String)],$String));o=o+(1)>>0;}return n;};S=function(k){var k,l,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);$deferred.push([(function(){$recover();}),[]]);if(P===null){if(Q){return null;}Q=true;l=$global.require;if(l===undefined){$panic(new $String(""));}P=l($externalize("syscall",$String));}return P[$externalize(k,$String)];}catch(err){$err=err;return null;}finally{$callDeferred($deferred,$err);}};T=function(k,l,m,n){var aa,ab,ac,ad,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;o=0;p=0;q=0;r=S("Syscall");if(!(r===null)){s=r(k,l,m,n);t=((($parseInt(s[0])>>0)>>>0));u=((($parseInt(s[1])>>0)>>>0));v=((($parseInt(s[2])>>0)>>>0));o=t;p=u;q=v;return[o,p,q];}if((k===1)&&((l===1)||(l===2))){w=m;x=$makeSlice(PL,$parseInt(w.length));x.$array=w;I(x);y=(($parseInt(w.length)>>>0));z=0;aa=0;o=y;p=z;q=aa;return[o,p,q];}if(k===231){B.Goexit();}H();ab=((R>>>0));ac=0;ad=13;o=ab;p=ac;q=ad;return[o,p,q];};$pkg.Syscall=T;U=function(k,l,m,n,o,p,q){var aa,ab,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;r=0;s=0;t=0;u=S("Syscall6");if(!(u===null)){v=u(k,l,m,n,o,p,q);w=((($parseInt(v[0])>>0)>>>0));x=((($parseInt(v[1])>>0)>>>0));y=((($parseInt(v[2])>>0)>>>0));r=w;s=x;t=y;return[r,s,t];}if(!((k===202))){H();}z=((R>>>0));aa=0;ab=13;r=z;s=aa;t=ab;return[r,s,t];};$pkg.Syscall6=U;Y=function(k){var k,l,m,n,o,p;l=new($global.Uint8Array)(k.length+1>>0);m=(new PL($stringToBytes(k)));n=0;while(true){if(!(n=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]);if(p===0){return[PV.nil,new GN(22)];}l[o]=p;n++;}l[k.length]=0;return[((l)),$ifaceNil];};$pkg.BytePtrFromString=Y;Z=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=new $Uint64(0,0);o=false;if(k.$length<(((l+m>>>0)>>0))){p=new $Uint64(0,0);q=false;n=p;o=q;return[n,o];}if(false){r=AA($subslice(k,l),m);s=true;n=r;o=s;return[n,o];}t=AB($subslice(k,l),m);u=true;n=t;o=u;return[n,o];};AA=function(k,l){var aa,ab,ac,ad,ae,af,ag,ah,ai,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;m=l;if(m===(1)){return(new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])));}else if(m===(2)){$unused((1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]));return(n=(new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),o=$shiftLeft64((new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),8),new $Uint64(n.$high|o.$high,(n.$low|o.$low)>>>0));}else if(m===(4)){$unused((3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]));return(p=(q=(r=(new $Uint64(0,(3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]))),s=$shiftLeft64((new $Uint64(0,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2]))),8),new $Uint64(r.$high|s.$high,(r.$low|s.$low)>>>0)),t=$shiftLeft64((new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),16),new $Uint64(q.$high|t.$high,(q.$low|t.$low)>>>0)),u=$shiftLeft64((new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),24),new $Uint64(p.$high|u.$high,(p.$low|u.$low)>>>0));}else if(m===(8)){$unused((7>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+7]));return(v=(w=(x=(y=(z=(aa=(ab=(new $Uint64(0,(7>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+7]))),ac=$shiftLeft64((new $Uint64(0,(6>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+6]))),8),new $Uint64(ab.$high|ac.$high,(ab.$low|ac.$low)>>>0)),ad=$shiftLeft64((new $Uint64(0,(5>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+5]))),16),new $Uint64(aa.$high|ad.$high,(aa.$low|ad.$low)>>>0)),ae=$shiftLeft64((new $Uint64(0,(4>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+4]))),24),new $Uint64(z.$high|ae.$high,(z.$low|ae.$low)>>>0)),af=$shiftLeft64((new $Uint64(0,(3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]))),32),new $Uint64(y.$high|af.$high,(y.$low|af.$low)>>>0)),ag=$shiftLeft64((new $Uint64(0,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2]))),40),new $Uint64(x.$high|ag.$high,(x.$low|ag.$low)>>>0)),ah=$shiftLeft64((new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),48),new $Uint64(w.$high|ah.$high,(w.$low|ah.$low)>>>0)),ai=$shiftLeft64((new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),56),new $Uint64(v.$high|ai.$high,(v.$low|ai.$low)>>>0));}else{$panic(new $String("syscall: readInt with unsupported size"));}};AB=function(k,l){var aa,ab,ac,ad,ae,af,ag,ah,ai,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;m=l;if(m===(1)){return(new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])));}else if(m===(2)){$unused((1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]));return(n=(new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),o=$shiftLeft64((new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),8),new $Uint64(n.$high|o.$high,(n.$low|o.$low)>>>0));}else if(m===(4)){$unused((3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]));return(p=(q=(r=(new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),s=$shiftLeft64((new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),8),new $Uint64(r.$high|s.$high,(r.$low|s.$low)>>>0)),t=$shiftLeft64((new $Uint64(0,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2]))),16),new $Uint64(q.$high|t.$high,(q.$low|t.$low)>>>0)),u=$shiftLeft64((new $Uint64(0,(3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]))),24),new $Uint64(p.$high|u.$high,(p.$low|u.$low)>>>0));}else if(m===(8)){$unused((7>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+7]));return(v=(w=(x=(y=(z=(aa=(ab=(new $Uint64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),ac=$shiftLeft64((new $Uint64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),8),new $Uint64(ab.$high|ac.$high,(ab.$low|ac.$low)>>>0)),ad=$shiftLeft64((new $Uint64(0,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2]))),16),new $Uint64(aa.$high|ad.$high,(aa.$low|ad.$low)>>>0)),ae=$shiftLeft64((new $Uint64(0,(3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]))),24),new $Uint64(z.$high|ae.$high,(z.$low|ae.$low)>>>0)),af=$shiftLeft64((new $Uint64(0,(4>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+4]))),32),new $Uint64(y.$high|af.$high,(y.$low|af.$low)>>>0)),ag=$shiftLeft64((new $Uint64(0,(5>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+5]))),40),new $Uint64(x.$high|ag.$high,(x.$low|ag.$low)>>>0)),ah=$shiftLeft64((new $Uint64(0,(6>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+6]))),48),new $Uint64(w.$high|ah.$high,(w.$low|ah.$low)>>>0)),ai=$shiftLeft64((new $Uint64(0,(7>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+7]))),56),new $Uint64(v.$high|ai.$high,(v.$low|ai.$low)>>>0));}else{$panic(new $String("syscall: readInt with unsupported size"));}};AC=function(k,l,m){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;n=0;o=0;p=PN.nil;q=k.$length;o=0;while(true){if(!(!((l===0))&&k.$length>0)){break;}r=FR(k);s=r[0];t=r[1];if(!t||(u=(new $Uint64(0,k.$length)),(s.$high>u.$high||(s.$high===u.$high&&s.$low>u.$low)))){v=q;w=o;x=m;n=v;o=w;p=x;return[n,o,p];}y=$subslice(k,0,$flatten64(s));k=$subslice(k,$flatten64(s));z=FQ(y);aa=z[0];t=z[1];if(!t){break;}if((aa.$high===0&&aa.$low===0)){continue;}ab=FS(y);ac=ab[0];t=ab[1];if(!t||(ad=new $Uint64(0+ac.$high,19+ac.$low),ae=(new $Uint64(0,y.$length)),(ad.$high>ae.$high||(ad.$high===ae.$high&&ad.$low>ae.$low)))){break;}af=$subslice(y,19,$flatten64(new $Uint64(0+ac.$high,19+ac.$low)));ag=af;ah=0;while(true){if(!(ah=ag.$length)?($throwRuntimeError("index out of range"),undefined):ag.$array[ag.$offset+ah]);if(aj===0){af=$subslice(af,0,ai);break;}ah++;}if(($bytesToString(af))==="."||($bytesToString(af))===".."){continue;}l=l-(1)>>0;o=o+(1)>>0;m=$append(m,($bytesToString(af)));}ak=q-k.$length>>0;al=o;am=m;n=ak;o=al;p=am;return[n,o,p];};$pkg.ParseDirent=AC;BC=function(k){var k;JB(k,2,1);};$pkg.CloseOnExec=BC;BD=function(k,l){var k,l,m,n,o,p;m=$ifaceNil;n=JB(k,3,0);o=n[0];m=n[1];if(!($interfaceIsEqual(m,$ifaceNil))){m=m;return m;}if(l){o=o|(2048);}else{o=(o&~(2048))>>0;}p=JB(k,4,o);m=p[1];m=m;return m;};$pkg.SetNonblock=BD;BZ=function(k,l){var k,l;};CA=function(k,l){var k,l;};CZ=function(k){var k;if(k<0){return"-"+DA(((-k>>>0)));}return DA(((k>>>0)));};DA=function(k){var k,l,m,n,o;l=QT.zero();m=31;while(true){if(!(k>=10)){break;}((m<0||m>=l.length)?($throwRuntimeError("index out of range"),undefined):l[m]=((((n=k%10,n===n?n:$throwRuntimeError("integer divide by zero"))+48>>>0)<<24>>>24)));m=m-(1)>>0;k=(o=k/(10),(o===o&&o!==1/0&&o!==-1/0)?o>>>0:$throwRuntimeError("integer divide by zero"));}((m<0||m>=l.length)?($throwRuntimeError("index out of range"),undefined):l[m]=(((k+48>>>0)<<24>>>24)));return($bytesToString($subslice(new PL(l),m)));};NJ.ptr.prototype.Unix=function(){var k,l,m,n,o;k=new $Int64(0,0);l=new $Int64(0,0);m=this;n=(m.Sec);o=(m.Nsec);k=n;l=o;return[k,l];};NJ.prototype.Unix=function(){return this.$val.Unix();};NJ.ptr.prototype.Nano=function(){var k,l,m;k=this;return(l=$mul64((k.Sec),new $Int64(0,1000000000)),m=(k.Nsec),new $Int64(l.$high+m.$high,l.$low+m.$low));};NJ.prototype.Nano=function(){return this.$val.Nano();};GW.ptr.prototype.sockaddr=function(){var k,l,m,n,o,p,q,r,s;k=this;if(k.Port<0||k.Port>65535){return[0,0,new GN(22)];}k.raw.Family=2;m=(((l=k.raw,(l.$ptr_Port||(l.$ptr_Port=new QG(function(){return this.$target.Port;},function($v){this.$target.Port=$v;},l))))));m.nilCheck,m[0]=(((k.Port>>8>>0)<<24>>>24));m.nilCheck,m[1]=((k.Port<<24>>>24));n=0;while(true){if(!(n<4)){break;}(p=k.raw.Addr,((n<0||n>=p.length)?($throwRuntimeError("index out of range"),undefined):p[n]=(o=k.Addr,((n<0||n>=o.length)?($throwRuntimeError("index out of range"),undefined):o[n]))));n=n+(1)>>0;}q=new Uint8Array(16);return[(q),16,$ifaceNil];};GW.prototype.sockaddr=function(){return this.$val.sockaddr();};GX.ptr.prototype.sockaddr=function(){var k,l,m,n,o,p,q,r,s;k=this;if(k.Port<0||k.Port>65535){return[0,0,new GN(22)];}k.raw.Family=10;m=(((l=k.raw,(l.$ptr_Port||(l.$ptr_Port=new QG(function(){return this.$target.Port;},function($v){this.$target.Port=$v;},l))))));m.nilCheck,m[0]=(((k.Port>>8>>0)<<24>>>24));m.nilCheck,m[1]=((k.Port<<24>>>24));k.raw.Scope_id=k.ZoneId;n=0;while(true){if(!(n<16)){break;}(p=k.raw.Addr,((n<0||n>=p.length)?($throwRuntimeError("index out of range"),undefined):p[n]=(o=k.Addr,((n<0||n>=o.length)?($throwRuntimeError("index out of range"),undefined):o[n]))));n=n+(1)>>0;}q=new Uint8Array(28);return[(q),28,$ifaceNil];};GX.prototype.sockaddr=function(){return this.$val.sockaddr();};GY.ptr.prototype.sockaddr=function(){var k,l,m,n,o,p,q,r,s;k=this;l=k.Name;m=l.length;if(m>108){return[0,0,new GN(22)];}if((m===108)&&!((l.charCodeAt(0)===64))){return[0,0,new GN(22)];}k.raw.Family=1;n=0;while(true){if(!(n=o.length)?($throwRuntimeError("index out of range"),undefined):o[n]=((l.charCodeAt(n)<<24>>24))));n=n+(1)>>0;}p=2;if(m>0){p=p+((((m>>>0))+1>>>0))>>>0;}if(k.raw.Path[0]===64){k.raw.Path[0]=0;p=p-(1)>>>0;}q=new Uint8Array(110);return[(q),p,$ifaceNil];};GY.prototype.sockaddr=function(){return this.$val.sockaddr();};EH.ptr.prototype.sockaddr=function(){var k,l,m,n,o,p,q;k=this;if(k.Ifindex<0||k.Ifindex>2147483647){return[0,0,new GN(22)];}k.raw.Family=17;k.raw.Protocol=k.Protocol;k.raw.Ifindex=((k.Ifindex>>0));k.raw.Hatype=k.Hatype;k.raw.Pkttype=k.Pkttype;k.raw.Halen=k.Halen;l=0;while(true){if(!(l<8)){break;}(n=k.raw.Addr,((l<0||l>=n.length)?($throwRuntimeError("index out of range"),undefined):n[l]=(m=k.Addr,((l<0||l>=m.length)?($throwRuntimeError("index out of range"),undefined):m[l]))));l=l+(1)>>0;}o=new Uint8Array(20);return[(o),20,$ifaceNil];};EH.prototype.sockaddr=function(){return this.$val.sockaddr();};EI.ptr.prototype.sockaddr=function(){var k,l,m,n;k=this;k.raw.Family=16;k.raw.Pad=k.Pad;k.raw.Pid=k.Pid;k.raw.Groups=k.Groups;l=new Uint8Array(12);return[(l),12,$ifaceNil];};EI.prototype.sockaddr=function(){return this.$val.sockaddr();};EJ=function(k){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;l=k.Addr.Family;if(l===(16)){p=new Uint8Array(112);s=((m=(p),n=new OB.ptr(0,0,0,0),o=new DataView(m.buffer,m.byteOffset),n.Family=o.getUint16(0,true),n.Pad=o.getUint16(2,true),n.Pid=o.getUint32(4,true),n.Groups=o.getUint32(8,true),n));q=k,r=new DataView(p.buffer,p.byteOffset),q.Addr.Family=r.getUint16(0,true),q.Addr.Data=new($nativeArray($kindInt8))(p.buffer,$min(p.byteOffset+2,p.buffer.byteLength)),q.Pad=new($nativeArray($kindInt8))(p.buffer,$min(p.byteOffset+16,p.buffer.byteLength));t=new EI.ptr(0,0,0,0,new OB.ptr(0,0,0,0));t.Family=s.Family;t.Pad=s.Pad;t.Pid=s.Pid;t.Groups=s.Groups;return[t,$ifaceNil];}else if(l===(17)){x=new Uint8Array(112);aa=((u=(x),v=new OA.ptr(0,0,0,0,0,0,QF.zero()),w=new DataView(u.buffer,u.byteOffset),v.Family=w.getUint16(0,true),v.Protocol=w.getUint16(2,true),v.Ifindex=w.getInt32(4,true),v.Hatype=w.getUint16(8,true),v.Pkttype=w.getUint8(10,true),v.Halen=w.getUint8(11,true),v.Addr=new($nativeArray($kindUint8))(u.buffer,$min(u.byteOffset+12,u.buffer.byteLength)),v));y=k,z=new DataView(x.buffer,x.byteOffset),y.Addr.Family=z.getUint16(0,true),y.Addr.Data=new($nativeArray($kindInt8))(x.buffer,$min(x.byteOffset+2,x.buffer.byteLength)),y.Pad=new($nativeArray($kindInt8))(x.buffer,$min(x.byteOffset+16,x.buffer.byteLength));ab=new EH.ptr(0,0,0,0,0,QF.zero(),new OA.ptr(0,0,0,0,0,0,QF.zero()));ab.Protocol=aa.Protocol;ab.Ifindex=((aa.Ifindex>>0));ab.Hatype=aa.Hatype;ab.Pkttype=aa.Pkttype;ab.Halen=aa.Halen;ac=0;while(true){if(!(ac<8)){break;}(ae=ab.Addr,((ac<0||ac>=ae.length)?($throwRuntimeError("index out of range"),undefined):ae[ac]=(ad=aa.Addr,((ac<0||ac>=ad.length)?($throwRuntimeError("index out of range"),undefined):ad[ac]))));ac=ac+(1)>>0;}return[ab,$ifaceNil];}else if(l===(1)){ai=new Uint8Array(112);al=((af=(ai),ag=new NZ.ptr(0,RA.zero()),ah=new DataView(af.buffer,af.byteOffset),ag.Family=ah.getUint16(0,true),ag.Path=new($nativeArray($kindInt8))(af.buffer,$min(af.byteOffset+2,af.buffer.byteLength)),ag));aj=k,ak=new DataView(ai.buffer,ai.byteOffset),aj.Addr.Family=ak.getUint16(0,true),aj.Addr.Data=new($nativeArray($kindInt8))(ai.buffer,$min(ai.byteOffset+2,ai.buffer.byteLength)),aj.Pad=new($nativeArray($kindInt8))(ai.buffer,$min(ai.byteOffset+16,ai.buffer.byteLength));am=new GY.ptr("",new NZ.ptr(0,RA.zero()));if(al.Path[0]===0){al.Path[0]=64;}an=0;while(true){if(!(an<108&&!(((ao=al.Path,((an<0||an>=ao.length)?($throwRuntimeError("index out of range"),undefined):ao[an]))===0)))){break;}an=an+(1)>>0;}ap=$subslice(new PL((($sliceToArray(new PL(al.Path))))),0,an);am.Name=($bytesToString(ap));return[am,$ifaceNil];}else if(l===(2)){at=new Uint8Array(112);aw=((aq=(at),ar=new NX.ptr(0,0,RB.zero(),QF.zero()),as=new DataView(aq.buffer,aq.byteOffset),ar.Family=as.getUint16(0,true),ar.Port=as.getUint16(2,true),ar.Addr=new($nativeArray($kindUint8))(aq.buffer,$min(aq.byteOffset+4,aq.buffer.byteLength)),ar.Zero=new($nativeArray($kindUint8))(aq.buffer,$min(aq.byteOffset+8,aq.buffer.byteLength)),ar));au=k,av=new DataView(at.buffer,at.byteOffset),au.Addr.Family=av.getUint16(0,true),au.Addr.Data=new($nativeArray($kindInt8))(at.buffer,$min(at.byteOffset+2,at.buffer.byteLength)),au.Pad=new($nativeArray($kindInt8))(at.buffer,$min(at.byteOffset+16,at.buffer.byteLength));ax=new GW.ptr(0,RB.zero(),new NX.ptr(0,0,RB.zero(),QF.zero()));ay=(((aw.$ptr_Port||(aw.$ptr_Port=new QG(function(){return this.$target.Port;},function($v){this.$target.Port=$v;},aw)))));ax.Port=((((ay.nilCheck,ay[0])>>0))<<8>>0)+(((ay.nilCheck,ay[1])>>0))>>0;az=0;while(true){if(!(az<4)){break;}(bb=ax.Addr,((az<0||az>=bb.length)?($throwRuntimeError("index out of range"),undefined):bb[az]=(ba=aw.Addr,((az<0||az>=ba.length)?($throwRuntimeError("index out of range"),undefined):ba[az]))));az=az+(1)>>0;}return[ax,$ifaceNil];}else if(l===(10)){bf=new Uint8Array(112);bi=((bc=(bf),bd=new NY.ptr(0,0,0,QH.zero(),0),be=new DataView(bc.buffer,bc.byteOffset),bd.Family=be.getUint16(0,true),bd.Port=be.getUint16(2,true),bd.Flowinfo=be.getUint32(4,true),bd.Addr=new($nativeArray($kindUint8))(bc.buffer,$min(bc.byteOffset+8,bc.buffer.byteLength)),bd.Scope_id=be.getUint32(24,true),bd));bg=k,bh=new DataView(bf.buffer,bf.byteOffset),bg.Addr.Family=bh.getUint16(0,true),bg.Addr.Data=new($nativeArray($kindInt8))(bf.buffer,$min(bf.byteOffset+2,bf.buffer.byteLength)),bg.Pad=new($nativeArray($kindInt8))(bf.buffer,$min(bf.byteOffset+16,bf.buffer.byteLength));bj=new GX.ptr(0,0,QH.zero(),new NY.ptr(0,0,0,QH.zero(),0));bk=(((bi.$ptr_Port||(bi.$ptr_Port=new QG(function(){return this.$target.Port;},function($v){this.$target.Port=$v;},bi)))));bj.Port=((((bk.nilCheck,bk[0])>>0))<<8>>0)+(((bk.nilCheck,bk[1])>>0))>>0;bj.ZoneId=bi.Scope_id;bl=0;while(true){if(!(bl<16)){break;}(bn=bj.Addr,((bl<0||bl>=bn.length)?($throwRuntimeError("index out of range"),undefined):bn[bl]=(bm=bi.Addr,((bl<0||bl>=bm.length)?($throwRuntimeError("index out of range"),undefined):bm[bl]))));bl=bl+(1)>>0;}return[bj,$ifaceNil];}return[$ifaceNil,new GN(97)];};EK=function(k){var k,l,m,n,o,p,q,r,s;l=0;m=$ifaceNil;n=$ifaceNil;o=new OD.ptr(new OC.ptr(0,RC.zero()),RD.zero());p=112;q=MK(k,o,(r||(r=new RE(function(){return p;},function($v){p=$v;}))));l=q[0];n=q[1];if(!($interfaceIsEqual(n,$ifaceNil))){return[l,m,n];}s=EJ(o);m=s[0];n=s[1];if(!($interfaceIsEqual(n,$ifaceNil))){IR(l);l=0;}return[l,m,n];};$pkg.Accept=EK;EL=function(k,l){var k,l,m,n,o,p,q,r,s,t;m=0;n=$ifaceNil;o=$ifaceNil;p=new OD.ptr(new OC.ptr(0,RC.zero()),RD.zero());q=112;r=ML(k,p,(s||(s=new RE(function(){return q;},function($v){q=$v;}))),l);m=r[0];o=r[1];if(!($interfaceIsEqual(o,$ifaceNil))){return[m,n,o];}if(q>112){$panic(new $String("RawSockaddrAny too small"));}t=EJ(p);n=t[0];o=t[1];if(!($interfaceIsEqual(o,$ifaceNil))){IR(m);m=0;}return[m,n,o];};$pkg.Accept4=EL;EU=function(k,l,m,n){var k,l,m,n,o,p,q,r;o=$ifaceNil;p=new Uint8Array(12);o=MS(k,l,m,(p),12);q=n,r=new DataView(p.buffer,p.byteOffset),q.Multiaddr=new($nativeArray($kindUint8))(p.buffer,$min(p.byteOffset+0,p.buffer.byteLength)),q.Address=new($nativeArray($kindUint8))(p.buffer,$min(p.byteOffset+4,p.buffer.byteLength)),q.Ifindex=r.getInt32(8,true);return o;};$pkg.SetsockoptIPMreqn=EU;EV=function(k,l,m,n){var aa,ab,ac,ad,ae,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;o=0;p=0;q=0;r=$ifaceNil;s=$ifaceNil;t=new OK.ptr(PV.nil,0,RB.zero(),RG.nil,new $Uint64(0,0),PV.nil,new $Uint64(0,0),0,RB.zero());u=new OD.ptr(new OC.ptr(0,RC.zero()),RD.zero());v=new Uint8Array(112);t.Name=((v));w=u,x=new DataView(v.buffer,v.byteOffset),w.Addr.Family=x.getUint16(0,true),w.Addr.Data=new($nativeArray($kindInt8))(v.buffer,$min(v.byteOffset+2,v.buffer.byteLength)),w.Pad=new($nativeArray($kindInt8))(v.buffer,$min(v.byteOffset+16,v.buffer.byteLength));t.Namelen=112;y=new OG.ptr(PV.nil,new $Uint64(0,0));if(l.$length>0){y.Base=$indexPtr(l.$array,l.$offset+0,PV);y.SetLen(l.$length);}z=0;if(m.$length>0){if(l.$length===0){aa=0;ab=HC(k,1,3);aa=ab[0];s=ab[1];if(!($interfaceIsEqual(s,$ifaceNil))){return[o,p,q,r,s];}if(!((aa===2))){y.Base=(ac||(ac=new PV(function(){return z;},function($v){z=$v;})));y.SetLen(1);}}t.Control=$indexPtr(m.$array,m.$offset+0,PV);t.SetControllen(m.$length);}t.Iov=y;t.Iovlen=new $Uint64(0,1);ad=MZ(k,t,n);o=ad[0];s=ad[1];if(!($interfaceIsEqual(s,$ifaceNil))){return[o,p,q,r,s];}p=((t.Controllen.$low>>0));q=((t.Flags>>0));if(!((u.Addr.Family===0))){ae=EJ(u);r=ae[0];s=ae[1];}return[o,p,q,r,s];};$pkg.Recvmsg=EV;EX=function(k,l,m,n,o){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:p=[p];q=[q];r=[r];s=0;t=$ifaceNil;u=0;v=0;if(!($interfaceIsEqual(n,$ifaceNil))){$s=1;continue;}$s=2;continue;case 1:w=$ifaceNil;y=n.sockaddr();$s=3;case 3:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}x=y;u=x[0];v=x[1];w=x[2];if(!($interfaceIsEqual(w,$ifaceNil))){z=0;aa=w;s=z;t=aa;$s=-1;return[s,t];}case 2:r[0]=new OK.ptr(PV.nil,0,RB.zero(),RG.nil,new $Uint64(0,0),PV.nil,new $Uint64(0,0),0,RB.zero());r[0].Name=(u);r[0].Namelen=((v>>>0));q[0]=new OG.ptr(PV.nil,new $Uint64(0,0));if(l.$length>0){q[0].Base=$indexPtr(l.$array,l.$offset+0,PV);q[0].SetLen(l.$length);}p[0]=0;if(m.$length>0){if(l.$length===0){ab=0;ac=HC(k,1,3);ab=ac[0];t=ac[1];if(!($interfaceIsEqual(t,$ifaceNil))){ad=0;ae=t;s=ad;t=ae;$s=-1;return[s,t];}if(!((ab===2))){q[0].Base=(p.$ptr||(p.$ptr=new PV(function(){return this.$target[0];},function($v){this.$target[0]=$v;},p)));q[0].SetLen(1);}}r[0].Control=$indexPtr(m.$array,m.$offset+0,PV);r[0].SetControllen(m.$length);}r[0].Iov=q[0];r[0].Iovlen=new $Uint64(0,1);af=NA(k,r[0],o);s=af[0];t=af[1];if(!($interfaceIsEqual(t,$ifaceNil))){ag=0;ah=t;s=ag;t=ah;$s=-1;return[s,t];}if(m.$length>0&&(l.$length===0)){s=0;}ai=s;aj=$ifaceNil;s=ai;t=aj;$s=-1;return[s,t];}return;}if($f===undefined){$f={$blk:EX};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$pkg.SendmsgN=EX;FP=function(k,l){var k,l,m,n,o;m=0;n=$ifaceNil;o=JF(k,l);m=o[0];n=o[1];return[m,n];};$pkg.ReadDirent=FP;FQ=function(k){var k;return Z(k,0,8);};FR=function(k){var k;return Z(k,16,2);};FS=function(k){var k,l,m,n;l=FR(k);m=l[0];n=l[1];if(!n){return[new $Uint64(0,0),false];}return[new $Uint64(m.$high-0,m.$low-19),true];};GC=function(k,l){var k,l,m;m=$ifaceNil;m=MO(-100,k,l,256);return m;};$pkg.Lstat=GC;OG.ptr.prototype.SetLen=function(k){var k,l;l=this;l.Len=(new $Uint64(0,k));};OG.prototype.SetLen=function(k){return this.$val.SetLen(k);};OK.ptr.prototype.SetControllen=function(k){var k,l;l=this;l.Controllen=(new $Uint64(0,k));};OK.prototype.SetControllen=function(k){return this.$val.SetControllen(k);};GM.ptr.prototype.Mmap=function(k,l,m,n,o){var aa,ab,ac,ad,ae,af,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);p=[p];q=PL.nil;r=$ifaceNil;s=this;if(m<=0){t=PL.nil;u=new GN(22);q=t;r=u;$s=-1;return[q,r];}w=s.mmap(0,((m>>>0)),n,o,k,l);$s=1;case 1:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}v=w;x=v[0];y=v[1];if(!($interfaceIsEqual(y,$ifaceNil))){z=PL.nil;aa=y;q=z;r=aa;$s=-1;return[q,r];}p[0]=new RK.ptr(x,m,m);ab=p[0];ac=$indexPtr(ab.$array,ab.$offset+(ab.$capacity-1>>0),PV);$r=s.Mutex.Lock();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$deferred.push([$methodVal(s.Mutex,"Unlock"),[]]);ad=ac;(s.active||$throwRuntimeError("assignment to entry in nil map"))[PV.keyFor(ad)]={k:ad,v:ab};ae=ab;af=$ifaceNil;q=ae;r=af;$s=-1;return[q,r];}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if(!$curGoroutine.asleep){return[q,r];}if($curGoroutine.asleep){if($f===undefined){$f={$blk:GM.ptr.prototype.Mmap};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};GM.prototype.Mmap=function(k,l,m,n,o){return this.$val.Mmap(k,l,m,n,o);};GM.ptr.prototype.Munmap=function(k){var k,l,m,n,o,p,q,r,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);l=$ifaceNil;m=this;if((k.$length===0)||!((k.$length===k.$capacity))){l=new GN(22);$s=-1;return l;}n=$indexPtr(k.$array,k.$offset+(k.$capacity-1>>0),PV);$r=m.Mutex.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$deferred.push([$methodVal(m.Mutex,"Unlock"),[]]);p=(o=m.active[PV.keyFor(n)],o!==undefined?o.v:PL.nil);if(p===PL.nil||!($indexPtr(p.$array,p.$offset+0,PV)===$indexPtr(k.$array,k.$offset+0,PV))){l=new GN(22);$s=-1;return l;}q=m.munmap((($sliceToArray(p))),((p.$length>>>0)));$s=2;case 2:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=q;if(!($interfaceIsEqual(r,$ifaceNil))){l=r;$s=-1;return l;}delete m.active[PV.keyFor(n)];l=$ifaceNil;$s=-1;return l;}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if(!$curGoroutine.asleep){return l;}if($curGoroutine.asleep){if($f===undefined){$f={$blk:GM.ptr.prototype.Munmap};}$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};GM.prototype.Munmap=function(k){return this.$val.Munmap(k);};GN.prototype.Error=function(){var k,l;k=this.$val;if(0<=((k>>0))&&((k>>0))<133){l=((k<0||k>=HW.length)?($throwRuntimeError("index out of range"),undefined):HW[k]);if(!(l==="")){return l;}}return"errno "+CZ(((k>>0)));};$ptrType(GN).prototype.Error=function(){return new GN(this.$get()).Error();};GN.prototype.Temporary=function(){var k;k=this.$val;return(k===4)||(k===24)||new GN(k).Timeout();};$ptrType(GN).prototype.Temporary=function(){return new GN(this.$get()).Temporary();};GN.prototype.Timeout=function(){var k;k=this.$val;return(k===11)||(k===11)||(k===110);};$ptrType(GN).prototype.Timeout=function(){return new GN(this.$get()).Timeout();};GR=function(k){var k,l;l=k;if(l===(0)){return $ifaceNil;}else if(l===(11)){return GO;}else if(l===(22)){return GP;}else if(l===(2)){return GQ;}return new GN(k);};GT=function(k,l){var k,l,m,n,o;m=0;n=$ifaceNil;o=JZ(k,l);m=o[0];n=o[1];if(false){if(m>0){D.WriteRange(($sliceToArray(l)),m);}if($interfaceIsEqual(n,$ifaceNil)){D.Acquire(((PU||(PU=new RL(function(){return HR;},function($v){HR=$v;})))));}}if(false&&m>0){CA(($sliceToArray(l)),m);}return[m,n];};$pkg.Read=GT;GU=function(k,l){var k,l,m,n,o;m=0;n=$ifaceNil;if(false){D.ReleaseMerge(((PU||(PU=new RL(function(){return HR;},function($v){HR=$v;})))));}o=KU(k,l);m=o[0];n=o[1];if(false&&m>0){D.ReadRange(($sliceToArray(l)),m);}if(false&&m>0){BZ(($sliceToArray(l)),m);}return[m,n];};$pkg.Write=GU;HC=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=0;o=$ifaceNil;p=0;q=4;o=MR(k,l,m,((r||(r=new PZ(function(){return p;},function($v){p=$v;})))),(s||(s=new RE(function(){return q;},function($v){q=$v;}))));t=((p>>0));u=o;n=t;o=u;return[n,o];};$pkg.GetsockoptInt=HC;HD=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=0;o=$ifaceNil;p=$ifaceNil;q=new OD.ptr(new OC.ptr(0,RC.zero()),RD.zero());r=112;s=MX(k,l,m,q,(t||(t=new RE(function(){return r;},function($v){r=$v;}))));n=s[0];p=s[1];if(!($interfaceIsEqual(p,$ifaceNil))){return[n,o,p];}if(!((q.Addr.Family===0))){u=EJ(q);o=u[0];p=u[1];}return[n,o,p];};$pkg.Recvfrom=HD;HE=function(k,l,m,n){var k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:o=$ifaceNil;q=n.sockaddr();$s=1;case 1:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;r=p[0];s=p[1];o=p[2];if(!($interfaceIsEqual(o,$ifaceNil))){o=o;$s=-1;return o;}o=MY(k,l,m,r,s);$s=-1;return o;}return;}if($f===undefined){$f={$blk:HE};}$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sendto=HE;HF=function(k,l,m,n){var k,l,m,n,o,p;o=$ifaceNil;o=MS(k,l,m,((p||(p=new PV(function(){return n;},function($v){n=$v;})))),1);return o;};$pkg.SetsockoptByte=HF;HG=function(k,l,m,n){var k,l,m,n,o,p,q;o=$ifaceNil;p=((n>>0));o=MS(k,l,m,((q||(q=new PZ(function(){return p;},function($v){p=$v;})))),4);return o;};$pkg.SetsockoptInt=HG;HH=function(k,l,m,n){var k,l,m,n,o;o=$ifaceNil;o=MS(k,l,m,($sliceToArray(new PL(n))),4);return o;};$pkg.SetsockoptInet4Addr=HH;HI=function(k,l,m,n){var k,l,m,n,o,p,q,r;o=$ifaceNil;p=new Uint8Array(8);o=MS(k,l,m,(p),8);q=n,r=new DataView(p.buffer,p.byteOffset),q.Multiaddr=new($nativeArray($kindUint8))(p.buffer,$min(p.byteOffset+0,p.buffer.byteLength)),q.Interface=new($nativeArray($kindUint8))(p.buffer,$min(p.byteOffset+4,p.buffer.byteLength));return o;};$pkg.SetsockoptIPMreq=HI;HJ=function(k,l,m,n){var k,l,m,n,o,p,q,r;o=$ifaceNil;p=new Uint8Array(20);o=MS(k,l,m,(p),20);q=n,r=new DataView(p.buffer,p.byteOffset),q.Multiaddr=new($nativeArray($kindUint8))(p.buffer,$min(p.byteOffset+0,p.buffer.byteLength)),q.Interface=r.getUint32(16,true);return o;};$pkg.SetsockoptIPv6Mreq=HJ;HL=function(k,l,m,n){var k,l,m,n,o,p,q,r;o=$ifaceNil;p=new Uint8Array(8);o=MS(k,l,m,(p),8);q=n,r=new DataView(p.buffer,p.byteOffset),q.Onoff=r.getInt32(0,true),q.Linger=r.getInt32(4,true);return o;};$pkg.SetsockoptLinger=HL;IR=function(k){var k,l,m,n;l=$ifaceNil;m=T(3,((k>>>0)),0,0);n=m[2];if(!((n===0))){l=GR(n);}return l;};$pkg.Close=IR;IS=function(k){var k,l,m,n,o,p;l=0;m=$ifaceNil;n=T(32,((k>>>0)),0,0);o=n[0];p=n[2];l=((o>>0));if(!((p===0))){m=GR(p);}return[l,m];};$pkg.Dup=IS;IY=function(k){var k,l,m,n;l=$ifaceNil;m=T(81,((k>>>0)),0,0);n=m[2];if(!((n===0))){l=GR(n);}return l;};$pkg.Fchdir=IY;IZ=function(k,l){var k,l,m,n,o;m=$ifaceNil;n=T(91,((k>>>0)),((l>>>0)),0);o=n[2];if(!((o===0))){m=GR(o);}return m;};$pkg.Fchmod=IZ;JB=function(k,l,m){var k,l,m,n,o,p,q,r;n=0;o=$ifaceNil;p=T(72,((k>>>0)),((l>>>0)),((m>>>0)));q=p[0];r=p[2];n=((q>>0));if(!((r===0))){o=GR(r);}return[n,o];};JE=function(k){var k,l,m,n;l=$ifaceNil;m=T(74,((k>>>0)),0,0);n=m[2];if(!((n===0))){l=GR(n);}return l;};$pkg.Fsync=JE;JF=function(k,l){var k,l,m,n,o,p,q,r;m=0;n=$ifaceNil;o=0;if(l.$length>0){o=($sliceToArray(l));}else{o=(new Uint8Array(0));}p=T(217,((k>>>0)),(o),((l.$length>>>0)));q=p[0];r=p[2];m=((q>>0));if(!((r===0))){n=GR(r);}return[m,n];};$pkg.Getdents=JF;JZ=function(k,l){var k,l,m,n,o,p,q,r;m=0;n=$ifaceNil;o=0;if(l.$length>0){o=($sliceToArray(l));}else{o=(new Uint8Array(0));}p=T(0,((k>>>0)),(o),((l.$length>>>0)));q=p[0];r=p[2];m=((q>>0));if(!((r===0))){n=GR(r);}return[m,n];};KU=function(k,l){var k,l,m,n,o,p,q,r;m=0;n=$ifaceNil;o=0;if(l.$length>0){o=($sliceToArray(l));}else{o=(new Uint8Array(0));}p=T(1,((k>>>0)),(o),((l.$length>>>0)));q=p[0];r=p[2];m=((q>>0));if(!((r===0))){n=GR(r);}return[m,n];};KY=function(k,l){var k,l,m,n,o;m=$ifaceNil;n=T(11,(k),(l),0);o=n[2];if(!((o===0))){m=GR(o);}return m;};LG=function(k,l,m){var k,l,m,n,o,p;n=$ifaceNil;o=T(93,((k>>>0)),((l>>>0)),((m>>>0)));p=o[2];if(!((p===0))){n=GR(p);}return n;};$pkg.Fchown=LG;LH=function(k,l){var k,l,m,n,o,p,q,r;m=$ifaceNil;o=new Uint8Array(144);n=T(5,((k>>>0)),((o)),0);p=l,q=new DataView(o.buffer,o.byteOffset),p.Dev=new $Uint64(q.getUint32(4,true),q.getUint32(0,true)),p.Ino=new $Uint64(q.getUint32(12,true),q.getUint32(8,true)),p.Nlink=new $Uint64(q.getUint32(20,true),q.getUint32(16,true)),p.Mode=q.getUint32(24,true),p.Uid=q.getUint32(28,true),p.Gid=q.getUint32(32,true),p.X__pad0=q.getInt32(36,true),p.Rdev=new $Uint64(q.getUint32(44,true),q.getUint32(40,true)),p.Size=new $Int64(q.getUint32(52,true),q.getUint32(48,true)),p.Blksize=new $Int64(q.getUint32(60,true),q.getUint32(56,true)),p.Blocks=new $Int64(q.getUint32(68,true),q.getUint32(64,true)),p.Atim.Sec=new $Int64(q.getUint32(76,true),q.getUint32(72,true)),p.Atim.Nsec=new $Int64(q.getUint32(84,true),q.getUint32(80,true)),p.Mtim.Sec=new $Int64(q.getUint32(92,true),q.getUint32(88,true)),p.Mtim.Nsec=new $Int64(q.getUint32(100,true),q.getUint32(96,true)),p.Ctim.Sec=new $Int64(q.getUint32(108,true),q.getUint32(104,true)),p.Ctim.Nsec=new $Int64(q.getUint32(116,true),q.getUint32(112,true)),p.X__unused=new($nativeArray($kindInt64))(o.buffer,$min(o.byteOffset+120,o.buffer.byteLength));r=n[2];if(!((r===0))){m=GR(r);}return m;};$pkg.Fstat=LH;LJ=function(k,l){var k,l,m,n,o;m=$ifaceNil;n=T(77,((k>>>0)),((l.$low>>>0)),0);o=n[2];if(!((o===0))){m=GR(o);}return m;};$pkg.Ftruncate=LJ;LT=function(k,l,m){var k,l,m,n,o,p,q,r,s;n=0;o=$ifaceNil;p=0;if(l.$length>0){p=($sliceToArray(l));}else{p=(new Uint8Array(0));}q=U(17,((k>>>0)),(p),((l.$length>>>0)),((m.$low>>>0)),0,0);r=q[0];s=q[2];n=((r>>0));if(!((s===0))){o=GR(s);}return[n,o];};$pkg.Pread=LT;LU=function(k,l,m){var k,l,m,n,o,p,q,r,s;n=0;o=$ifaceNil;p=0;if(l.$length>0){p=($sliceToArray(l));}else{p=(new Uint8Array(0));}q=U(18,((k>>>0)),(p),((l.$length>>>0)),((m.$low>>>0)),0,0);r=q[0];s=q[2];n=((r>>0));if(!((s===0))){o=GR(s);}return[n,o];};$pkg.Pwrite=LU;LV=function(k,l,m){var k,l,m,n,o,p,q,r;n=new $Int64(0,0);o=$ifaceNil;p=T(8,((k>>>0)),((l.$low>>>0)),((m>>>0)));q=p[0];r=p[2];n=(new $Int64(0,q.constructor===Number?q:1));if(!((r===0))){o=GR(r);}return[n,o];};$pkg.Seek=LV;MF=function(k,l){var k,l,m,n,o;m=$ifaceNil;n=T(48,((k>>>0)),((l>>>0)),0);o=n[2];if(!((o===0))){m=GR(o);}return m;};$pkg.Shutdown=MF;MK=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=0;o=$ifaceNil;q=new Uint8Array(112);p=T(43,((k>>>0)),((q)),((m)));r=l,s=new DataView(q.buffer,q.byteOffset),r.Addr.Family=s.getUint16(0,true),r.Addr.Data=new($nativeArray($kindInt8))(q.buffer,$min(q.byteOffset+2,q.buffer.byteLength)),r.Pad=new($nativeArray($kindInt8))(q.buffer,$min(q.byteOffset+16,q.buffer.byteLength));t=p[0];u=p[2];n=((t>>0));if(!((u===0))){o=GR(u);}return[n,o];};ML=function(k,l,m,n){var k,l,m,n,o,p,q,r,s,t,u,v;o=0;p=$ifaceNil;r=new Uint8Array(112);q=U(288,((k>>>0)),((r)),((m)),((n>>>0)),0,0);s=l,t=new DataView(r.buffer,r.byteOffset),s.Addr.Family=t.getUint16(0,true),s.Addr.Data=new($nativeArray($kindInt8))(r.buffer,$min(r.byteOffset+2,r.buffer.byteLength)),s.Pad=new($nativeArray($kindInt8))(r.buffer,$min(r.byteOffset+16,r.buffer.byteLength));u=q[0];v=q[2];o=((u>>0));if(!((v===0))){p=GR(v);}return[o,p];};MO=function(k,l,m,n){var k,l,m,n,o,p,q,r,s,t,u,v;o=$ifaceNil;p=PV.nil;q=Y(l);p=q[0];o=q[1];if(!($interfaceIsEqual(o,$ifaceNil))){return o;}s=new Uint8Array(144);r=U(262,((k>>>0)),((p)),((s)),((n>>>0)),0,0);t=m,u=new DataView(s.buffer,s.byteOffset),t.Dev=new $Uint64(u.getUint32(4,true),u.getUint32(0,true)),t.Ino=new $Uint64(u.getUint32(12,true),u.getUint32(8,true)),t.Nlink=new $Uint64(u.getUint32(20,true),u.getUint32(16,true)),t.Mode=u.getUint32(24,true),t.Uid=u.getUint32(28,true),t.Gid=u.getUint32(32,true),t.X__pad0=u.getInt32(36,true),t.Rdev=new $Uint64(u.getUint32(44,true),u.getUint32(40,true)),t.Size=new $Int64(u.getUint32(52,true),u.getUint32(48,true)),t.Blksize=new $Int64(u.getUint32(60,true),u.getUint32(56,true)),t.Blocks=new $Int64(u.getUint32(68,true),u.getUint32(64,true)),t.Atim.Sec=new $Int64(u.getUint32(76,true),u.getUint32(72,true)),t.Atim.Nsec=new $Int64(u.getUint32(84,true),u.getUint32(80,true)),t.Mtim.Sec=new $Int64(u.getUint32(92,true),u.getUint32(88,true)),t.Mtim.Nsec=new $Int64(u.getUint32(100,true),u.getUint32(96,true)),t.Ctim.Sec=new $Int64(u.getUint32(108,true),u.getUint32(104,true)),t.Ctim.Nsec=new $Int64(u.getUint32(116,true),u.getUint32(112,true)),t.X__unused=new($nativeArray($kindInt64))(s.buffer,$min(s.byteOffset+120,s.buffer.byteLength));v=r[2];if(!((v===0))){o=GR(v);}return o;};MR=function(k,l,m,n,o){var k,l,m,n,o,p,q,r;p=$ifaceNil;q=U(55,((k>>>0)),((l>>>0)),((m>>>0)),(n),((o)),0);r=q[2];if(!((r===0))){p=GR(r);}return p;};MS=function(k,l,m,n,o){var k,l,m,n,o,p,q,r;p=$ifaceNil;q=U(54,((k>>>0)),((l>>>0)),((m>>>0)),(n),(o),0);r=q[2];if(!((r===0))){p=GR(r);}return p;};MX=function(k,l,m,n,o){var k,l,m,n,o,p,q,r,s,t,u,v,w,x;p=0;q=$ifaceNil;r=0;if(l.$length>0){r=($sliceToArray(l));}else{r=(new Uint8Array(0));}t=new Uint8Array(112);s=U(45,((k>>>0)),(r),((l.$length>>>0)),((m>>>0)),((t)),((o)));u=n,v=new DataView(t.buffer,t.byteOffset),u.Addr.Family=v.getUint16(0,true),u.Addr.Data=new($nativeArray($kindInt8))(t.buffer,$min(t.byteOffset+2,t.buffer.byteLength)),u.Pad=new($nativeArray($kindInt8))(t.buffer,$min(t.byteOffset+16,t.buffer.byteLength));w=s[0];x=s[2];p=((w>>0));if(!((x===0))){q=GR(x);}return[p,q];};MY=function(k,l,m,n,o){var k,l,m,n,o,p,q,r,s;p=$ifaceNil;q=0;if(l.$length>0){q=($sliceToArray(l));}else{q=(new Uint8Array(0));}r=U(44,((k>>>0)),(q),((l.$length>>>0)),((m>>>0)),(n),((o>>>0)));s=r[2];if(!((s===0))){p=GR(s);}return p;};MZ=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=0;o=$ifaceNil;q=new Uint8Array(48);p=T(47,((k>>>0)),((q)),((m>>>0)));r=l,s=new DataView(q.buffer,q.byteOffset),r.Namelen=s.getUint32(4,true),r.Pad_cgo_0=new($nativeArray($kindUint8))(q.buffer,$min(q.byteOffset+8,q.buffer.byteLength)),r.Iovlen=new $Uint64(s.getUint32(20,true),s.getUint32(16,true)),r.Controllen=new $Uint64(s.getUint32(36,true),s.getUint32(32,true)),r.Flags=s.getInt32(40,true),r.Pad_cgo_1=new($nativeArray($kindUint8))(q.buffer,$min(q.byteOffset+44,q.buffer.byteLength));t=p[0];u=p[2];n=((t>>0));if(!((u===0))){o=GR(u);}return[n,o];};NA=function(k,l,m){var k,l,m,n,o,p,q,r,s,t,u;n=0;o=$ifaceNil;q=new Uint8Array(48);p=T(46,((k>>>0)),((q)),((m>>>0)));r=l,s=new DataView(q.buffer,q.byteOffset),r.Namelen=s.getUint32(4,true),r.Pad_cgo_0=new($nativeArray($kindUint8))(q.buffer,$min(q.byteOffset+8,q.buffer.byteLength)),r.Iovlen=new $Uint64(s.getUint32(20,true),s.getUint32(16,true)),r.Controllen=new $Uint64(s.getUint32(36,true),s.getUint32(32,true)),r.Flags=s.getInt32(40,true),r.Pad_cgo_1=new($nativeArray($kindUint8))(q.buffer,$min(q.byteOffset+44,q.buffer.byteLength));t=p[0];u=p[2];n=((t>>0));if(!((u===0))){o=GR(u);}return[n,o];};NB=function(k,l,m,n,o,p){var k,l,m,n,o,p,q,r,s,t,u;q=0;r=$ifaceNil;s=U(9,(k),(l),((m>>>0)),((n>>>0)),((o>>>0)),((p.$low>>>0)));t=s[0];u=s[2];q=(t);if(!((u===0))){r=GR(u);}return[q,r];};RR.methods=[{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}];QL.methods=[{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}];RS.methods=[{prop:"Mmap",name:"Mmap",pkg:"",typ:$funcType([$Int,$Int64,$Int,$Int,$Int],[PL,$error],false)},{prop:"Munmap",name:"Munmap",pkg:"",typ:$funcType([PL],[$error],false)}];GN.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Temporary",name:"Temporary",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Timeout",name:"Timeout",pkg:"",typ:$funcType([],[$Bool],false)}];RW.methods=[{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}];RX.methods=[{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}];RY.methods=[{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}];RZ.methods=[{prop:"Unix",name:"Unix",pkg:"",typ:$funcType([],[$Int64,$Int64],false)},{prop:"Nano",name:"Nano",pkg:"",typ:$funcType([],[$Int64],false)}];RG.methods=[{prop:"SetLen",name:"SetLen",pkg:"",typ:$funcType([$Int],[],false)}];SF.methods=[{prop:"SetControllen",name:"SetControllen",pkg:"",typ:$funcType([$Int],[],false)}];CB.init([{prop:"Control",name:"Control",pkg:"",typ:$funcType([RO],[$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([RP],[$error],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([RP],[$error],false)}]);EH.init("syscall",[{prop:"Protocol",name:"Protocol",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Ifindex",name:"Ifindex",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Hatype",name:"Hatype",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pkttype",name:"Pkttype",embedded:false,exported:true,typ:$Uint8,tag:""},{prop:"Halen",name:"Halen",embedded:false,exported:true,typ:$Uint8,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:QF,tag:""},{prop:"raw",name:"raw",embedded:false,exported:false,typ:OA,tag:""}]);EI.init("syscall",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pad",name:"Pad",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pid",name:"Pid",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Groups",name:"Groups",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"raw",name:"raw",embedded:false,exported:false,typ:OB,tag:""}]);GM.init("syscall",[{prop:"Mutex",name:"Mutex",embedded:true,exported:true,typ:C.Mutex,tag:""},{prop:"active",name:"active",embedded:false,exported:false,typ:RT,tag:""},{prop:"mmap",name:"mmap",embedded:false,exported:false,typ:RU,tag:""},{prop:"munmap",name:"munmap",embedded:false,exported:false,typ:RV,tag:""}]);GV.init([{prop:"sockaddr",name:"sockaddr",pkg:"syscall",typ:$funcType([],[$UnsafePointer,OE,$error],false)}]);GW.init("syscall",[{prop:"Port",name:"Port",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:RB,tag:""},{prop:"raw",name:"raw",embedded:false,exported:false,typ:NX,tag:""}]);GX.init("syscall",[{prop:"Port",name:"Port",embedded:false,exported:true,typ:$Int,tag:""},{prop:"ZoneId",name:"ZoneId",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:QH,tag:""},{prop:"raw",name:"raw",embedded:false,exported:false,typ:NY,tag:""}]);GY.init("syscall",[{prop:"Name",name:"Name",embedded:false,exported:true,typ:$String,tag:""},{prop:"raw",name:"raw",embedded:false,exported:false,typ:NZ,tag:""}]);NJ.init("",[{prop:"Sec",name:"Sec",embedded:false,exported:true,typ:$Int64,tag:""},{prop:"Nsec",name:"Nsec",embedded:false,exported:true,typ:$Int64,tag:""}]);NS.init("",[{prop:"Dev",name:"Dev",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Ino",name:"Ino",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Nlink",name:"Nlink",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Mode",name:"Mode",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Uid",name:"Uid",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Gid",name:"Gid",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"X__pad0",name:"X__pad0",embedded:false,exported:true,typ:$Int32,tag:""},{prop:"Rdev",name:"Rdev",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Size",name:"Size",embedded:false,exported:true,typ:$Int64,tag:""},{prop:"Blksize",name:"Blksize",embedded:false,exported:true,typ:$Int64,tag:""},{prop:"Blocks",name:"Blocks",embedded:false,exported:true,typ:$Int64,tag:""},{prop:"Atim",name:"Atim",embedded:false,exported:true,typ:NJ,tag:""},{prop:"Mtim",name:"Mtim",embedded:false,exported:true,typ:NJ,tag:""},{prop:"Ctim",name:"Ctim",embedded:false,exported:true,typ:NJ,tag:""},{prop:"X__unused",name:"X__unused",embedded:false,exported:true,typ:QU,tag:""}]);NX.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Port",name:"Port",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:RB,tag:""},{prop:"Zero",name:"Zero",embedded:false,exported:true,typ:QF,tag:""}]);NY.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Port",name:"Port",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Flowinfo",name:"Flowinfo",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:QH,tag:""},{prop:"Scope_id",name:"Scope_id",embedded:false,exported:true,typ:$Uint32,tag:""}]);NZ.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Path",name:"Path",embedded:false,exported:true,typ:RA,tag:""}]);OA.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Protocol",name:"Protocol",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Ifindex",name:"Ifindex",embedded:false,exported:true,typ:$Int32,tag:""},{prop:"Hatype",name:"Hatype",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pkttype",name:"Pkttype",embedded:false,exported:true,typ:$Uint8,tag:""},{prop:"Halen",name:"Halen",embedded:false,exported:true,typ:$Uint8,tag:""},{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:QF,tag:""}]);OB.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pad",name:"Pad",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Pid",name:"Pid",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Groups",name:"Groups",embedded:false,exported:true,typ:$Uint32,tag:""}]);OC.init("",[{prop:"Family",name:"Family",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Data",name:"Data",embedded:false,exported:true,typ:RC,tag:""}]);OD.init("",[{prop:"Addr",name:"Addr",embedded:false,exported:true,typ:OC,tag:""},{prop:"Pad",name:"Pad",embedded:false,exported:true,typ:RD,tag:""}]);OF.init("",[{prop:"Onoff",name:"Onoff",embedded:false,exported:true,typ:$Int32,tag:""},{prop:"Linger",name:"Linger",embedded:false,exported:true,typ:$Int32,tag:""}]);OG.init("",[{prop:"Base",name:"Base",embedded:false,exported:true,typ:PV,tag:""},{prop:"Len",name:"Len",embedded:false,exported:true,typ:$Uint64,tag:""}]);OH.init("",[{prop:"Multiaddr",name:"Multiaddr",embedded:false,exported:true,typ:RB,tag:""},{prop:"Interface",name:"Interface",embedded:false,exported:true,typ:RB,tag:""}]);OI.init("",[{prop:"Multiaddr",name:"Multiaddr",embedded:false,exported:true,typ:RB,tag:""},{prop:"Address",name:"Address",embedded:false,exported:true,typ:RB,tag:""},{prop:"Ifindex",name:"Ifindex",embedded:false,exported:true,typ:$Int32,tag:""}]);OJ.init("",[{prop:"Multiaddr",name:"Multiaddr",embedded:false,exported:true,typ:QH,tag:""},{prop:"Interface",name:"Interface",embedded:false,exported:true,typ:$Uint32,tag:""}]);OK.init("",[{prop:"Name",name:"Name",embedded:false,exported:true,typ:PV,tag:""},{prop:"Namelen",name:"Namelen",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Pad_cgo_0",name:"Pad_cgo_0",embedded:false,exported:true,typ:RB,tag:""},{prop:"Iov",name:"Iov",embedded:false,exported:true,typ:RG,tag:""},{prop:"Iovlen",name:"Iovlen",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Control",name:"Control",embedded:false,exported:true,typ:PV,tag:""},{prop:"Controllen",name:"Controllen",embedded:false,exported:true,typ:$Uint64,tag:""},{prop:"Flags",name:"Flags",embedded:false,exported:true,typ:$Int32,tag:""},{prop:"Pad_cgo_1",name:"Pad_cgo_1",embedded:false,exported:true,typ:RB,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}F=PL.nil;P=null;$pkg.ForkLock=new C.RWMutex.ptr(new C.Mutex.ptr(0,0),0,0,0,0);HR=new $Int64(0,0);E=false;Q=false;R=-1;AG=M();$pkg.Stdin=0;$pkg.Stdout=1;$pkg.Stderr=2;GO=new GN(11);GP=new GN(22);GQ=new GN(2);HW=$toNativeArray($kindString,["","operation not permitted","no such file or directory","no such process","interrupted system call","input/output error","no such device or address","argument list too long","exec format error","bad file descriptor","no child processes","resource temporarily unavailable","cannot allocate memory","permission denied","bad address","block device required","device or resource busy","file exists","invalid cross-device link","no such device","not a directory","is a directory","invalid argument","too many open files in system","too many open files","inappropriate ioctl for device","text file busy","file too large","no space left on device","illegal seek","read-only file system","too many links","broken pipe","numerical argument out of domain","numerical result out of range","resource deadlock avoided","file name too long","no locks available","function not implemented","directory not empty","too many levels of symbolic links","","no message of desired type","identifier removed","channel number out of range","level 2 not synchronized","level 3 halted","level 3 reset","link number out of range","protocol driver not attached","no CSI structure available","level 2 halted","invalid exchange","invalid request descriptor","exchange full","no anode","invalid request code","invalid slot","","bad font file format","device not a stream","no data available","timer expired","out of streams resources","machine is not on the network","package not installed","object is remote","link has been severed","advertise error","srmount error","communication error on send","protocol error","multihop attempted","RFS specific error","bad message","value too large for defined data type","name not unique on network","file descriptor in bad state","remote address changed","can not access a needed shared library","accessing a corrupted shared library",".lib section in a.out corrupted","attempting to link in too many shared libraries","cannot exec a shared library directly","invalid or incomplete multibyte or wide character","interrupted system call should be restarted","streams pipe error","too many users","socket operation on non-socket","destination address required","message too long","protocol wrong type for socket","protocol not available","protocol not supported","socket type not supported","operation not supported","protocol family not supported","address family not supported by protocol","address already in use","cannot assign requested address","network is down","network is unreachable","network dropped connection on reset","software caused connection abort","connection reset by peer","no buffer space available","transport endpoint is already connected","transport endpoint is not connected","cannot send after transport endpoint shutdown","too many references: cannot splice","connection timed out","connection refused","host is down","no route to host","operation already in progress","operation now in progress","stale NFS file handle","structure needs cleaning","not a XENIX named type file","no XENIX semaphores available","is a named type file","remote I/O error","disk quota exceeded","no medium found","wrong medium type","operation canceled","required key not available","key has expired","key has been revoked","key was rejected by service","owner died","state not recoverable","operation not possible due to RF-kill"]);FX=new GM.ptr(new C.Mutex.ptr(0,0),{},NB,KY);G();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["github.com/gopherjs/gopherjs/nosync"]=(function(){var $pkg={},$init,A,B,D,E,F,G,H,I,J,L,M,N,O,P,Q;A=$pkg.Map=$newType(0,$kindStruct,"nosync.Map",true,"github.com/gopherjs/gopherjs/nosync",true,function(m_){this.$val=this;if(arguments.length===0){this.m=false;return;}this.m=m_;});B=$pkg.Mutex=$newType(0,$kindStruct,"nosync.Mutex",true,"github.com/gopherjs/gopherjs/nosync",true,function(locked_){this.$val=this;if(arguments.length===0){this.locked=false;return;}this.locked=locked_;});D=$pkg.WaitGroup=$newType(0,$kindStruct,"nosync.WaitGroup",true,"github.com/gopherjs/gopherjs/nosync",true,function(counter_){this.$val=this;if(arguments.length===0){this.counter=0;return;}this.counter=counter_;});E=$pkg.Once=$newType(0,$kindStruct,"nosync.Once",true,"github.com/gopherjs/gopherjs/nosync",true,function(doing_,done_){this.$val=this;if(arguments.length===0){this.doing=false;this.done=false;return;}this.doing=doing_;this.done=done_;});F=$pkg.Pool=$newType(0,$kindStruct,"nosync.Pool",true,"github.com/gopherjs/gopherjs/nosync",true,function(store_,New_){this.$val=this;if(arguments.length===0){this.store=O.nil;this.New=$throwNilPointerError;return;}this.store=store_;this.New=New_;});G=$funcType([$emptyInterface,$emptyInterface],[$Bool],false);H=$ptrType(A);I=$mapType($emptyInterface,$emptyInterface);J=$ptrType(B);L=$ptrType(D);M=$funcType([],[],false);N=$ptrType(E);O=$sliceType($emptyInterface);P=$ptrType(F);Q=$funcType([],[$emptyInterface],false);A.ptr.prototype.Load=function(a){var a,b,c,d,e,f,g,h;b=$ifaceNil;c=false;d=this;e=(f=d.m[$emptyInterface.keyFor(a)],f!==undefined?[f.v,true]:[$ifaceNil,false]);b=e[0];c=e[1];g=b;h=c;b=g;c=h;return[b,c];};A.prototype.Load=function(a){return this.$val.Load(a);};A.ptr.prototype.Store=function(a,b){var a,b,c,d;c=this;if(c.m===false){c.m={};}d=a;(c.m||$throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(d)]={k:d,v:b};};A.prototype.Store=function(a,b){return this.$val.Store(a,b);};A.ptr.prototype.LoadOrStore=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n;c=$ifaceNil;d=false;e=this;f=(g=e.m[$emptyInterface.keyFor(a)],g!==undefined?[g.v,true]:[$ifaceNil,false]);h=f[0];i=f[1];if(i){j=h;k=true;c=j;d=k;return[c,d];}if(e.m===false){e.m={};}l=a;(e.m||$throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(l)]={k:l,v:b};m=b;n=false;c=m;d=n;return[c,d];};A.prototype.LoadOrStore=function(a,b){return this.$val.LoadOrStore(a,b);};A.ptr.prototype.Delete=function(a){var a,b;b=this;if(b.m===false){return;}delete b.m[$emptyInterface.keyFor(a)];};A.prototype.Delete=function(a){return this.$val.Delete(a);};A.ptr.prototype.Range=function(a){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.m;d=0;e=$keys(c);case 1:if(!(d>0;if(b.counter<0){$panic(new $String("sync: negative WaitGroup counter"));}};D.prototype.Add=function(a){return this.$val.Add(a);};D.ptr.prototype.Done=function(){var a;a=this;a.Add(-1);};D.prototype.Done=function(){return this.$val.Done();};D.ptr.prototype.Wait=function(){var a;a=this;if(!((a.counter===0))){$panic(new $String("sync: WaitGroup counter not zero"));}};D.prototype.Wait=function(){return this.$val.Wait();};E.ptr.prototype.Do=function(a){var a,b,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);b=[b];b[0]=this;if(b[0].done){$s=-1;return;}if(b[0].doing){$panic(new $String("nosync: Do called within f"));}b[0].doing=true;$deferred.push([(function(b){return function(){b[0].doing=false;b[0].done=true;};})(b),[]]);$r=a();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:E.ptr.prototype.Do};}$f.a=a;$f.b=b;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};E.prototype.Do=function(a){return this.$val.Do(a);};F.ptr.prototype.Get=function(){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;if(a.store.$length===0){$s=1;continue;}$s=2;continue;case 1:if(!(a.New===$throwNilPointerError)){$s=3;continue;}$s=4;continue;case 3:b=a.New();$s=5;case 5:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;case 4:$s=-1;return $ifaceNil;case 2:e=(c=a.store,d=a.store.$length-1>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]));a.store=$subslice(a.store,0,(a.store.$length-1>>0));$s=-1;return e;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Get};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Get=function(){return this.$val.Get();};F.ptr.prototype.Put=function(a){var a,b;b=this;if($interfaceIsEqual(a,$ifaceNil)){return;}b.store=$append(b.store,a);};F.prototype.Put=function(a){return this.$val.Put(a);};H.methods=[{prop:"Load",name:"Load",pkg:"",typ:$funcType([$emptyInterface],[$emptyInterface,$Bool],false)},{prop:"Store",name:"Store",pkg:"",typ:$funcType([$emptyInterface,$emptyInterface],[],false)},{prop:"LoadOrStore",name:"LoadOrStore",pkg:"",typ:$funcType([$emptyInterface,$emptyInterface],[$emptyInterface,$Bool],false)},{prop:"Delete",name:"Delete",pkg:"",typ:$funcType([$emptyInterface],[],false)},{prop:"Range",name:"Range",pkg:"",typ:$funcType([G],[],false)}];J.methods=[{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}];L.methods=[{prop:"Add",name:"Add",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Done",name:"Done",pkg:"",typ:$funcType([],[],false)},{prop:"Wait",name:"Wait",pkg:"",typ:$funcType([],[],false)}];N.methods=[{prop:"Do",name:"Do",pkg:"",typ:$funcType([M],[],false)}];P.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Put",name:"Put",pkg:"",typ:$funcType([$emptyInterface],[],false)}];A.init("github.com/gopherjs/gopherjs/nosync",[{prop:"m",name:"m",embedded:false,exported:false,typ:I,tag:""}]);B.init("github.com/gopherjs/gopherjs/nosync",[{prop:"locked",name:"locked",embedded:false,exported:false,typ:$Bool,tag:""}]);D.init("github.com/gopherjs/gopherjs/nosync",[{prop:"counter",name:"counter",embedded:false,exported:false,typ:$Int,tag:""}]);E.init("github.com/gopherjs/gopherjs/nosync",[{prop:"doing",name:"doing",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"done",name:"done",embedded:false,exported:false,typ:$Bool,tag:""}]);F.init("github.com/gopherjs/gopherjs/nosync",[{prop:"store",name:"store",embedded:false,exported:false,typ:O,tag:""},{prop:"New",name:"New",embedded:false,exported:true,typ:Q,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["time"]=(function(){var $pkg={},$init,C,B,E,A,D,AE,BL,BM,BO,BS,CJ,CK,CL,DK,DL,DM,DO,DQ,DR,DS,DT,DU,DX,EC,EG,O,Q,T,U,V,W,AA,AD,AR,BN,BP,BZ,CB,CM,DI,CN,DJ,CO,CQ,CY,h,F,H,I,J,P,R,S,X,Y,Z,AB,AC,AF,AG,AH,AI,AJ,AK,AM,AN,AO,AP,AQ,AS,BQ,BR,BT,BU,BV,BW,BY,CA,CC,CD,CE,CF,CG,CH,CI,CP;C=$packages["errors"];B=$packages["github.com/gopherjs/gopherjs/js"];E=$packages["github.com/gopherjs/gopherjs/nosync"];A=$packages["runtime"];D=$packages["syscall"];AE=$pkg.ParseError=$newType(0,$kindStruct,"time.ParseError",true,"time",true,function(Layout_,Value_,LayoutElem_,ValueElem_,Message_){this.$val=this;if(arguments.length===0){this.Layout="";this.Value="";this.LayoutElem="";this.ValueElem="";this.Message="";return;}this.Layout=Layout_;this.Value=Value_;this.LayoutElem=LayoutElem_;this.ValueElem=ValueElem_;this.Message=Message_;});BL=$pkg.Time=$newType(0,$kindStruct,"time.Time",true,"time",true,function(wall_,ext_,loc_){this.$val=this;if(arguments.length===0){this.wall=new $Uint64(0,0);this.ext=new $Int64(0,0);this.loc=DU.nil;return;}this.wall=wall_;this.ext=ext_;this.loc=loc_;});BM=$pkg.Month=$newType(4,$kindInt,"time.Month",true,"time",true,null);BO=$pkg.Weekday=$newType(4,$kindInt,"time.Weekday",true,"time",true,null);BS=$pkg.Duration=$newType(8,$kindInt64,"time.Duration",true,"time",true,null);CJ=$pkg.Location=$newType(0,$kindStruct,"time.Location",true,"time",true,function(name_,zone_,tx_,cacheStart_,cacheEnd_,cacheZone_){this.$val=this;if(arguments.length===0){this.name="";this.zone=DK.nil;this.tx=DL.nil;this.cacheStart=new $Int64(0,0);this.cacheEnd=new $Int64(0,0);this.cacheZone=DM.nil;return;}this.name=name_;this.zone=zone_;this.tx=tx_;this.cacheStart=cacheStart_;this.cacheEnd=cacheEnd_;this.cacheZone=cacheZone_;});CK=$pkg.zone=$newType(0,$kindStruct,"time.zone",true,"time",false,function(name_,offset_,isDST_){this.$val=this;if(arguments.length===0){this.name="";this.offset=0;this.isDST=false;return;}this.name=name_;this.offset=offset_;this.isDST=isDST_;});CL=$pkg.zoneTrans=$newType(0,$kindStruct,"time.zoneTrans",true,"time",false,function(when_,index_,isstd_,isutc_){this.$val=this;if(arguments.length===0){this.when=new $Int64(0,0);this.index=0;this.isstd=false;this.isutc=false;return;}this.when=when_;this.index=index_;this.isstd=isstd_;this.isutc=isutc_;});DK=$sliceType(CK);DL=$sliceType(CL);DM=$ptrType(CK);DO=$sliceType($String);DQ=$arrayType($Uint8,20);DR=$sliceType($Uint8);DS=$arrayType($Uint8,9);DT=$arrayType($Uint8,64);DU=$ptrType(CJ);DX=$arrayType($Uint8,32);EC=$ptrType(AE);EG=$ptrType(BL);F=function(){$unused(CE(new $Int64(0,0),new $Int64(0,0)));};H=function(){var i,j,k,l;i=new($global.Date)();j=$internalize(i,$String);k=P(j,40);l=P(j,41);if((k===-1)||(l===-1)){CN.name="UTC";return;}CN.name=$substring(j,(k+1>>0),l);CN.zone=new DK([new CK.ptr(CN.name,$imul(($parseInt(i.getTimezoneOffset())>>0),-60),false)]);};I=function(){return $mul64($internalize(new($global.Date)().getTime(),$Int64),new $Int64(0,1000000));};J=function(){var i,j,k,l,m,n,o,p;i=new $Int64(0,0);j=0;k=new $Int64(0,0);l=I();m=$div64(l,new $Int64(0,1000000000),false);n=(((o=$div64(l,new $Int64(0,1000000000),true),o.$low+((o.$high>>31)*4294967296))>>0));p=l;i=m;j=n;k=p;return[i,j,k];};P=function(i,j){var i,j;return $parseInt(i.indexOf($global.String.fromCharCode(j)))>>0;};R=function(i){var i,j;if(i.length===0){return false;}j=i.charCodeAt(0);return 97<=j&&j<=122;};S=function(i){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,bw,bx,by,bz,ca,cb,cc,cd,ce,cf,cg,ch,ci,cj,ck,cl,cm,cn,co,cp,cq,cr,cs,ct,cu,cv,cw,cx,cy,cz,da,db,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;j="";k=0;l="";m=0;while(true){if(!(m>0));o=n;if(o===(74)){if(i.length>=(m+3>>0)&&$substring(i,m,(m+3>>0))==="Jan"){if(i.length>=(m+7>>0)&&$substring(i,m,(m+7>>0))==="January"){p=$substring(i,0,m);q=257;r=$substring(i,(m+7>>0));j=p;k=q;l=r;return[j,k,l];}if(!R($substring(i,(m+3>>0)))){s=$substring(i,0,m);t=258;u=$substring(i,(m+3>>0));j=s;k=t;l=u;return[j,k,l];}}}else if(o===(77)){if(i.length>=(m+3>>0)){if($substring(i,m,(m+3>>0))==="Mon"){if(i.length>=(m+6>>0)&&$substring(i,m,(m+6>>0))==="Monday"){v=$substring(i,0,m);w=261;x=$substring(i,(m+6>>0));j=v;k=w;l=x;return[j,k,l];}if(!R($substring(i,(m+3>>0)))){y=$substring(i,0,m);z=262;aa=$substring(i,(m+3>>0));j=y;k=z;l=aa;return[j,k,l];}}if($substring(i,m,(m+3>>0))==="MST"){ab=$substring(i,0,m);ac=21;ad=$substring(i,(m+3>>0));j=ab;k=ac;l=ad;return[j,k,l];}}}else if(o===(48)){if(i.length>=(m+2>>0)&&49<=i.charCodeAt((m+1>>0))&&i.charCodeAt((m+1>>0))<=54){ae=$substring(i,0,m);af=(ag=i.charCodeAt((m+1>>0))-49<<24>>>24,((ag<0||ag>=Q.length)?($throwRuntimeError("index out of range"),undefined):Q[ag]));ah=$substring(i,(m+2>>0));j=ae;k=af;l=ah;return[j,k,l];}}else if(o===(49)){if(i.length>=(m+2>>0)&&(i.charCodeAt((m+1>>0))===53)){ai=$substring(i,0,m);aj=522;ak=$substring(i,(m+2>>0));j=ai;k=aj;l=ak;return[j,k,l];}al=$substring(i,0,m);am=259;an=$substring(i,(m+1>>0));j=al;k=am;l=an;return[j,k,l];}else if(o===(50)){if(i.length>=(m+4>>0)&&$substring(i,m,(m+4>>0))==="2006"){ao=$substring(i,0,m);ap=273;aq=$substring(i,(m+4>>0));j=ao;k=ap;l=aq;return[j,k,l];}ar=$substring(i,0,m);as=263;at=$substring(i,(m+1>>0));j=ar;k=as;l=at;return[j,k,l];}else if(o===(95)){if(i.length>=(m+2>>0)&&(i.charCodeAt((m+1>>0))===50)){if(i.length>=(m+5>>0)&&$substring(i,(m+1>>0),(m+5>>0))==="2006"){au=$substring(i,0,(m+1>>0));av=273;aw=$substring(i,(m+5>>0));j=au;k=av;l=aw;return[j,k,l];}ax=$substring(i,0,m);ay=264;az=$substring(i,(m+2>>0));j=ax;k=ay;l=az;return[j,k,l];}}else if(o===(51)){ba=$substring(i,0,m);bb=523;bc=$substring(i,(m+1>>0));j=ba;k=bb;l=bc;return[j,k,l];}else if(o===(52)){bd=$substring(i,0,m);be=525;bf=$substring(i,(m+1>>0));j=bd;k=be;l=bf;return[j,k,l];}else if(o===(53)){bg=$substring(i,0,m);bh=527;bi=$substring(i,(m+1>>0));j=bg;k=bh;l=bi;return[j,k,l];}else if(o===(80)){if(i.length>=(m+2>>0)&&(i.charCodeAt((m+1>>0))===77)){bj=$substring(i,0,m);bk=531;bl=$substring(i,(m+2>>0));j=bj;k=bk;l=bl;return[j,k,l];}}else if(o===(112)){if(i.length>=(m+2>>0)&&(i.charCodeAt((m+1>>0))===109)){bm=$substring(i,0,m);bn=532;bo=$substring(i,(m+2>>0));j=bm;k=bn;l=bo;return[j,k,l];}}else if(o===(45)){if(i.length>=(m+7>>0)&&$substring(i,m,(m+7>>0))==="-070000"){bp=$substring(i,0,m);bq=28;br=$substring(i,(m+7>>0));j=bp;k=bq;l=br;return[j,k,l];}if(i.length>=(m+9>>0)&&$substring(i,m,(m+9>>0))==="-07:00:00"){bs=$substring(i,0,m);bt=31;bu=$substring(i,(m+9>>0));j=bs;k=bt;l=bu;return[j,k,l];}if(i.length>=(m+5>>0)&&$substring(i,m,(m+5>>0))==="-0700"){bv=$substring(i,0,m);bw=27;bx=$substring(i,(m+5>>0));j=bv;k=bw;l=bx;return[j,k,l];}if(i.length>=(m+6>>0)&&$substring(i,m,(m+6>>0))==="-07:00"){by=$substring(i,0,m);bz=30;ca=$substring(i,(m+6>>0));j=by;k=bz;l=ca;return[j,k,l];}if(i.length>=(m+3>>0)&&$substring(i,m,(m+3>>0))==="-07"){cb=$substring(i,0,m);cc=29;cd=$substring(i,(m+3>>0));j=cb;k=cc;l=cd;return[j,k,l];}}else if(o===(90)){if(i.length>=(m+7>>0)&&$substring(i,m,(m+7>>0))==="Z070000"){ce=$substring(i,0,m);cf=23;cg=$substring(i,(m+7>>0));j=ce;k=cf;l=cg;return[j,k,l];}if(i.length>=(m+9>>0)&&$substring(i,m,(m+9>>0))==="Z07:00:00"){ch=$substring(i,0,m);ci=26;cj=$substring(i,(m+9>>0));j=ch;k=ci;l=cj;return[j,k,l];}if(i.length>=(m+5>>0)&&$substring(i,m,(m+5>>0))==="Z0700"){ck=$substring(i,0,m);cl=22;cm=$substring(i,(m+5>>0));j=ck;k=cl;l=cm;return[j,k,l];}if(i.length>=(m+6>>0)&&$substring(i,m,(m+6>>0))==="Z07:00"){cn=$substring(i,0,m);co=25;cp=$substring(i,(m+6>>0));j=cn;k=co;l=cp;return[j,k,l];}if(i.length>=(m+3>>0)&&$substring(i,m,(m+3>>0))==="Z07"){cq=$substring(i,0,m);cr=24;cs=$substring(i,(m+3>>0));j=cq;k=cr;l=cs;return[j,k,l];}}else if(o===(46)){if((m+1>>0)>0))===48)||(i.charCodeAt((m+1>>0))===57))){ct=i.charCodeAt((m+1>>0));cu=m+1>>0;while(true){if(!(cu>0;}if(!AG(i,cu)){cv=32;if(i.charCodeAt((m+1>>0))===57){cv=33;}cv=cv|((((cu-((m+1>>0))>>0))<<16>>0));cw=$substring(i,0,m);cx=cv;cy=$substring(i,cu);j=cw;k=cx;l=cy;return[j,k,l];}}}m=m+(1)>>0;}cz=i;da=0;db="";j=cz;k=da;l=db;return[j,k,l];};X=function(i,j){var i,j,k,l,m;k=0;while(true){if(!(k>>0;m=(m|(32))>>>0;if(!((l===m))||l<97||l>122){return false;}}k=k+(1)>>0;}return true;};Y=function(i,j){var i,j,k,l,m,n;k=i;l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);if(j.length>=n.length&&X($substring(j,0,n.length),n)){return[m,$substring(j,n.length),$ifaceNil];}l++;}return[-1,j,AD];};Z=function(i,j,k){var i,j,k,l,m,n,o,p,q;l=((j>>>0));if(j<0){i=$append(i,45);l=((-j>>>0));}m=DQ.zero();n=20;while(true){if(!(l>=10)){break;}n=n-(1)>>0;p=(o=l/10,(o===o&&o!==1/0&&o!==-1/0)?o>>>0:$throwRuntimeError("integer divide by zero"));((n<0||n>=m.length)?($throwRuntimeError("index out of range"),undefined):m[n]=((((48+l>>>0)-(p*10>>>0)>>>0)<<24>>>24)));l=p;}n=n-(1)>>0;((n<0||n>=m.length)?($throwRuntimeError("index out of range"),undefined):m[n]=(((48+l>>>0)<<24>>>24)));q=20-n>>0;while(true){if(!(q>0;}return $appendSlice(i,$subslice(new DR(m),n));};AB=function(i){var i,j,k,l,m,n,o,p,q,r,s;j=0;k=$ifaceNil;l=false;if(!(i==="")&&((i.charCodeAt(0)===45)||(i.charCodeAt(0)===43))){l=i.charCodeAt(0)===45;i=$substring(i,1);}m=AS(i);n=m[0];o=m[1];k=m[2];j=(((n.$low+((n.$high>>31)*4294967296))>>0));if(!($interfaceIsEqual(k,$ifaceNil))||!(o==="")){p=0;q=AA;j=p;k=q;return[j,k];}if(l){j=-j;}r=j;s=$ifaceNil;j=r;k=s;return[j,k];};AC=function(i,j,k,l){var i,j,k,l,m,n,o,p,q,r;m=j;n=DS.zero();o=9;while(true){if(!(o>0)){break;}o=o-(1)>>0;((o<0||o>=n.length)?($throwRuntimeError("index out of range"),undefined):n[o]=((((p=m%10,p===p?p:$throwRuntimeError("integer divide by zero"))+48>>>0)<<24>>>24)));m=(q=m/(10),(q===q&&q!==1/0&&q!==-1/0)?q>>>0:$throwRuntimeError("integer divide by zero"));}if(k>9){k=9;}if(l){while(true){if(!(k>0&&((r=k-1>>0,((r<0||r>=n.length)?($throwRuntimeError("index out of range"),undefined):n[r]))===48))){break;}k=k-(1)>>0;}if(k===0){return i;}}i=$append(i,46);return $appendSlice(i,$subslice(new DR(n),0,k));};BL.ptr.prototype.String=function(){var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=$clone(i,BL).Format("2006-01-02 15:04:05.999999999 -0700 MST");$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(!((l=(m=i.wall,new $Uint64(m.$high&2147483648,(m.$low&0)>>>0)),(l.$high===0&&l.$low===0)))){o=((n=i.ext,new $Uint64(n.$high,n.$low)));p=43;if((q=i.ext,(q.$high<0||(q.$high===0&&q.$low<0)))){p=45;o=new $Uint64(-o.$high,-o.$low);}r=$div64(o,new $Uint64(0,1000000000),false);s=$div64(o,new $Uint64(0,1000000000),true);t=r;o=s;u=$div64(t,new $Uint64(0,1000000000),false);v=$div64(t,new $Uint64(0,1000000000),true);w=u;t=v;x=DR.nil;x=$appendSlice(x," m=");x=$append(x,p);y=0;if(!((w.$high===0&&w.$low===0))){x=Z(x,((w.$low>>0)),0);y=9;}x=Z(x,((t.$low>>0)),y);x=$append(x,46);x=Z(x,((o.$low>>0)),9);k=k+(($bytesToString(x)));}$s=-1;return k;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.String};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.String=function(){return this.$val.String();};BL.ptr.prototype.Format=function(i){var i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=this;k=DR.nil;l=i.length+10>>0;if(l<64){m=DT.zero();k=$subslice(new DR(m),0,0);}else{k=$makeSlice(DR,0,l);}n=$clone(j,BL).AppendFormat(k,i);$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}k=n;$s=-1;return($bytesToString(k));}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Format};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Format=function(i){return this.$val.Format(i);};BL.ptr.prototype.AppendFormat=function(i,j){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:k=this;m=$clone(k,BL).locabs();$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;n=l[0];o=l[1];p=l[2];q=-1;r=0;s=0;t=-1;u=0;v=0;while(true){if(!(!(j===""))){break;}w=S(j);x=w[0];y=w[1];z=w[2];if(!(x==="")){i=$appendSlice(i,x);}if(y===0){break;}j=z;if(q<0&&!(((y&256)===0))){aa=BY(p,true);q=aa[0];r=aa[1];s=aa[2];}if(t<0&&!(((y&512)===0))){ab=BR(p);t=ab[0];u=ab[1];v=ab[2];}switch(0){default:ac=y&65535;if(ac===(274)){ad=q;if(ad<0){ad=-ad;}i=Z(i,(ae=ad%100,ae===ae?ae:$throwRuntimeError("integer divide by zero")),2);}else if(ac===(273)){i=Z(i,q,4);}else if(ac===(258)){i=$appendSlice(i,$substring(new BM(r).String(),0,3));}else if(ac===(257)){af=new BM(r).String();i=$appendSlice(i,af);}else if(ac===(259)){i=Z(i,((r>>0)),0);}else if(ac===(260)){i=Z(i,((r>>0)),2);}else if(ac===(262)){i=$appendSlice(i,$substring(new BO(BQ(p)).String(),0,3));}else if(ac===(261)){ag=new BO(BQ(p)).String();i=$appendSlice(i,ag);}else if(ac===(263)){i=Z(i,s,0);}else if(ac===(264)){if(s<10){i=$append(i,32);}i=Z(i,s,0);}else if(ac===(265)){i=Z(i,s,2);}else if(ac===(522)){i=Z(i,t,2);}else if(ac===(523)){ai=(ah=t%12,ah===ah?ah:$throwRuntimeError("integer divide by zero"));if(ai===0){ai=12;}i=Z(i,ai,0);}else if(ac===(524)){ak=(aj=t%12,aj===aj?aj:$throwRuntimeError("integer divide by zero"));if(ak===0){ak=12;}i=Z(i,ak,2);}else if(ac===(525)){i=Z(i,u,0);}else if(ac===(526)){i=Z(i,u,2);}else if(ac===(527)){i=Z(i,v,0);}else if(ac===(528)){i=Z(i,v,2);}else if(ac===(531)){if(t>=12){i=$appendSlice(i,"PM");}else{i=$appendSlice(i,"AM");}}else if(ac===(532)){if(t>=12){i=$appendSlice(i,"pm");}else{i=$appendSlice(i,"am");}}else if((ac===(22))||(ac===(25))||(ac===(23))||(ac===(24))||(ac===(26))||(ac===(27))||(ac===(30))||(ac===(28))||(ac===(29))||(ac===(31))){if((o===0)&&((y===22)||(y===25)||(y===23)||(y===24)||(y===26))){i=$append(i,90);break;}am=(al=o/60,(al===al&&al!==1/0&&al!==-1/0)?al>>0:$throwRuntimeError("integer divide by zero"));an=o;if(am<0){i=$append(i,45);am=-am;an=-an;}else{i=$append(i,43);}i=Z(i,(ao=am/60,(ao===ao&&ao!==1/0&&ao!==-1/0)?ao>>0:$throwRuntimeError("integer divide by zero")),2);if((y===25)||(y===30)||(y===26)||(y===31)){i=$append(i,58);}if(!((y===29))&&!((y===24))){i=Z(i,(ap=am%60,ap===ap?ap:$throwRuntimeError("integer divide by zero")),2);}if((y===23)||(y===28)||(y===31)||(y===26)){if((y===31)||(y===26)){i=$append(i,58);}i=Z(i,(aq=an%60,aq===aq?aq:$throwRuntimeError("integer divide by zero")),2);}}else if(ac===(21)){if(!(n==="")){i=$appendSlice(i,n);break;}as=(ar=o/60,(ar===ar&&ar!==1/0&&ar!==-1/0)?ar>>0:$throwRuntimeError("integer divide by zero"));if(as<0){i=$append(i,45);as=-as;}else{i=$append(i,43);}i=Z(i,(at=as/60,(at===at&&at!==1/0&&at!==-1/0)?at>>0:$throwRuntimeError("integer divide by zero")),2);i=Z(i,(au=as%60,au===au?au:$throwRuntimeError("integer divide by zero")),2);}else if((ac===(32))||(ac===(33))){i=AC(i,(($clone(k,BL).Nanosecond()>>>0)),y>>16>>0,(y&65535)===33);}}}$s=-1;return i;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.AppendFormat};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.AppendFormat=function(i,j){return this.$val.AppendFormat(i,j);};AF=function(i){var i;return"\""+i+"\"";};AE.ptr.prototype.Error=function(){var i;i=this;if(i.Message===""){return"parsing time "+AF(i.Value)+" as "+AF(i.Layout)+": cannot parse "+AF(i.ValueElem)+" as "+AF(i.LayoutElem);}return"parsing time "+AF(i.Value)+i.Message;};AE.prototype.Error=function(){return this.$val.Error();};AG=function(i,j){var i,j,k;if(i.length<=j){return false;}k=i.charCodeAt(j);return 48<=k&&k<=57;};AH=function(i,j){var i,j;if(!AG(i,0)){return[0,i,AD];}if(!AG(i,1)){if(j){return[0,i,AD];}return[(((i.charCodeAt(0)-48<<24>>>24)>>0)),$substring(i,1),$ifaceNil];}return[($imul((((i.charCodeAt(0)-48<<24>>>24)>>0)),10))+(((i.charCodeAt(1)-48<<24>>>24)>>0))>>0,$substring(i,2),$ifaceNil];};AI=function(i){var i;while(true){if(!(i.length>0&&(i.charCodeAt(0)===32))){break;}i=$substring(i,1);}return i;};AJ=function(i,j){var i,j;while(true){if(!(j.length>0)){break;}if(j.charCodeAt(0)===32){if(i.length>0&&!((i.charCodeAt(0)===32))){return[i,AD];}j=AI(j);i=AI(i);continue;}if((i.length===0)||!((i.charCodeAt(0)===j.charCodeAt(0)))){return[i,AD];}j=$substring(j,1);i=$substring(i,1);}return[i,$ifaceNil];};AK=function(i,j){var i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:k=AM(i,j,$pkg.UTC,$pkg.Local);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}$s=-1;return k;}return;}if($f===undefined){$f={$blk:AK};}$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Parse=AK;AM=function(i,j,k,l){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,bu,bv,bw,bx,by,bz,ca,cb,cc,cd,ce,cf,cg,ch,ci,cj,ck,cl,cm,cn,co,cp,cq,cr,cs,ct,cu,cv,cw,cx,cy,cz,da,db,dc,dd,de,df,dg,dh,di,dj,dk,dl,dm,dn,dp,dq,dr,ds,dt,du,dv,dw,dx,dy,dz,ea,eb,ec,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;bu=$f.bu;bv=$f.bv;bw=$f.bw;bx=$f.bx;by=$f.by;bz=$f.bz;ca=$f.ca;cb=$f.cb;cc=$f.cc;cd=$f.cd;ce=$f.ce;cf=$f.cf;cg=$f.cg;ch=$f.ch;ci=$f.ci;cj=$f.cj;ck=$f.ck;cl=$f.cl;cm=$f.cm;cn=$f.cn;co=$f.co;cp=$f.cp;cq=$f.cq;cr=$f.cr;cs=$f.cs;ct=$f.ct;cu=$f.cu;cv=$f.cv;cw=$f.cw;cx=$f.cx;cy=$f.cy;cz=$f.cz;da=$f.da;db=$f.db;dc=$f.dc;dd=$f.dd;de=$f.de;df=$f.df;dg=$f.dg;dh=$f.dh;di=$f.di;dj=$f.dj;dk=$f.dk;dl=$f.dl;dm=$f.dm;dn=$f.dn;dp=$f.dp;dq=$f.dq;dr=$f.dr;ds=$f.ds;dt=$f.dt;du=$f.du;dv=$f.dv;dw=$f.dw;dx=$f.dx;dy=$f.dy;dz=$f.dz;ea=$f.ea;eb=$f.eb;ec=$f.ec;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:m=i;n=j;o=m;p=n;q="";r=false;s=false;t=0;u=1;v=1;w=0;x=0;y=0;z=0;aa=DU.nil;ab=-1;ac="";while(true){ad=$ifaceNil;ae=S(i);af=ae[0];ag=ae[1];ah=ae[2];ai=$substring(i,af.length,(i.length-ah.length>>0));aj=AJ(j,af);j=aj[0];ad=aj[1];if(!($interfaceIsEqual(ad,$ifaceNil))){$s=-1;return[new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil),new AE.ptr(o,p,af,j,"")];}if(ag===0){if(!((j.length===0))){$s=-1;return[new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil),new AE.ptr(o,p,"",j,": extra text: "+j)];}break;}i=ah;ak="";switch(0){default:al=ag&65535;if(al===(274)){if(j.length<2){ad=AD;break;}am=$substring(j,0,2);an=$substring(j,2);ak=am;j=an;ao=AB(ak);t=ao[0];ad=ao[1];if(t>=69){t=t+(1900)>>0;}else{t=t+(2000)>>0;}}else if(al===(273)){if(j.length<4||!AG(j,0)){ad=AD;break;}ap=$substring(j,0,4);aq=$substring(j,4);ak=ap;j=aq;ar=AB(ak);t=ar[0];ad=ar[1];}else if(al===(258)){as=Y(V,j);u=as[0];j=as[1];ad=as[2];u=u+(1)>>0;}else if(al===(257)){at=Y(W,j);u=at[0];j=at[1];ad=at[2];u=u+(1)>>0;}else if((al===(259))||(al===(260))){au=AH(j,ag===260);u=au[0];j=au[1];ad=au[2];if(u<=0||120&&(j.charCodeAt(0)===32)){j=$substring(j,1);}ax=AH(j,ag===265);v=ax[0];j=ax[1];ad=ax[2];if(v<0){q="day";}}else if(al===(522)){ay=AH(j,false);w=ay[0];j=ay[1];ad=ay[2];if(w<0||24<=w){q="hour";}}else if((al===(523))||(al===(524))){az=AH(j,ag===524);w=az[0];j=az[1];ad=az[2];if(w<0||12=2&&(j.charCodeAt(0)===46)&&AG(j,1)){bc=S(i);ag=bc[1];ag=ag&(65535);if((ag===32)||(ag===33)){break;}bd=2;while(true){if(!(bd>0;}be=AQ(j,bd);z=be[0];q=be[1];ad=be[2];j=$substring(j,bd);}}else if(al===(531)){if(j.length<2){ad=AD;break;}bf=$substring(j,0,2);bg=$substring(j,2);ak=bf;j=bg;bh=ak;if(bh===("PM")){s=true;}else if(bh===("AM")){r=true;}else{ad=AD;}}else if(al===(532)){if(j.length<2){ad=AD;break;}bi=$substring(j,0,2);bj=$substring(j,2);ak=bi;j=bj;bk=ak;if(bk===("pm")){s=true;}else if(bk===("am")){r=true;}else{ad=AD;}}else if((al===(22))||(al===(25))||(al===(23))||(al===(24))||(al===(26))||(al===(27))||(al===(29))||(al===(30))||(al===(28))||(al===(31))){if(((ag===22)||(ag===24)||(ag===25))&&j.length>=1&&(j.charCodeAt(0)===90)){j=$substring(j,1);aa=$pkg.UTC;break;}bl="";bm="";bn="";bo="";bp=bl;bq=bm;br=bn;bs=bo;if((ag===25)||(ag===30)){if(j.length<6){ad=AD;break;}if(!((j.charCodeAt(3)===58))){ad=AD;break;}bt=$substring(j,0,1);bu=$substring(j,1,3);bv=$substring(j,4,6);bw="00";bx=$substring(j,6);bp=bt;bq=bu;br=bv;bs=bw;j=bx;}else if((ag===29)||(ag===24)){if(j.length<3){ad=AD;break;}by=$substring(j,0,1);bz=$substring(j,1,3);ca="00";cb="00";cc=$substring(j,3);bp=by;bq=bz;br=ca;bs=cb;j=cc;}else if((ag===26)||(ag===31)){if(j.length<9){ad=AD;break;}if(!((j.charCodeAt(3)===58))||!((j.charCodeAt(6)===58))){ad=AD;break;}cd=$substring(j,0,1);ce=$substring(j,1,3);cf=$substring(j,4,6);cg=$substring(j,7,9);ch=$substring(j,9);bp=cd;bq=ce;br=cf;bs=cg;j=ch;}else if((ag===23)||(ag===28)){if(j.length<7){ad=AD;break;}ci=$substring(j,0,1);cj=$substring(j,1,3);ck=$substring(j,3,5);cl=$substring(j,5,7);cm=$substring(j,7);bp=ci;bq=cj;br=ck;bs=cl;j=cm;}else{if(j.length<5){ad=AD;break;}cn=$substring(j,0,1);co=$substring(j,1,3);cp=$substring(j,3,5);cq="00";cr=$substring(j,5);bp=cn;bq=co;br=cp;bs=cq;j=cr;}cs=0;ct=0;cu=0;cv=cs;cw=ct;cx=cu;cy=AB(bq);cv=cy[0];ad=cy[1];if($interfaceIsEqual(ad,$ifaceNil)){cz=AB(br);cw=cz[0];ad=cz[1];}if($interfaceIsEqual(ad,$ifaceNil)){da=AB(bs);cx=da[0];ad=da[1];}ab=($imul(((($imul(cv,60))+cw>>0)),60))+cx>>0;db=bp.charCodeAt(0);if(db===(43)){}else if(db===(45)){ab=-ab;}else{ad=AD;}}else if(al===(21)){if(j.length>=3&&$substring(j,0,3)==="UTC"){aa=$pkg.UTC;j=$substring(j,3);break;}dc=AN(j);dd=dc[0];de=dc[1];if(!de){ad=AD;break;}df=$substring(j,0,dd);dg=$substring(j,dd);ac=df;j=dg;}else if(al===(32)){dh=1+((ag>>16>>0))>>0;if(j.length>0)>0))&&j.charCodeAt((dj+1>>0))<=57)){break;}dj=dj+(1)>>0;}dk=AQ(j,1+dj>>0);z=dk[0];q=dk[1];ad=dk[2];j=$substring(j,(1+dj>>0));}}if(!(q==="")){$s=-1;return[new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil),new AE.ptr(o,p,ai,j,": "+q+" out of range")];}if(!($interfaceIsEqual(ad,$ifaceNil))){$s=-1;return[new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil),new AE.ptr(o,p,ai,j,"")];}}if(s&&w<12){w=w+(12)>>0;}else if(r&&(w===12)){w=0;}if(v<1||v>CA(((u>>0)),t)){$s=-1;return[new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil),new AE.ptr(o,p,"",j,": day out of range")];}if(!(aa===DU.nil)){$s=1;continue;}$s=2;continue;case 1:dl=CH(t,((u>>0)),v,w,x,y,z,aa);$s=3;case 3:if($c){$c=false;dl=dl.$blk();}if(dl&&dl.$blk!==undefined){break s;}$s=-1;return[dl,$ifaceNil];case 2:if(!((ab===-1))){$s=4;continue;}$s=5;continue;case 4:dm=CH(t,((u>>0)),v,w,x,y,z,$pkg.UTC);$s=6;case 6:if($c){$c=false;dm=dm.$blk();}if(dm&&dm.$blk!==undefined){break s;}dn=$clone(dm,BL);dn.addSec((dp=(new $Int64(0,ab)),new $Int64(-dp.$high,-dp.$low)));dr=l.lookup(dn.unixSec());$s=7;case 7:if($c){$c=false;dr=dr.$blk();}if(dr&&dr.$blk!==undefined){break s;}dq=dr;ds=dq[0];dt=dq[1];if((dt===ab)&&(ac===""||ds===ac)){dn.setLoc(l);$s=-1;return[dn,$ifaceNil];}dn.setLoc(CP(ac,ab));$s=-1;return[dn,$ifaceNil];case 5:if(!(ac==="")){$s=8;continue;}$s=9;continue;case 8:du=CH(t,((u>>0)),v,w,x,y,z,$pkg.UTC);$s=10;case 10:if($c){$c=false;du=du.$blk();}if(du&&du.$blk!==undefined){break s;}dv=$clone(du,BL);dx=l.lookupName(ac,dv.unixSec());$s=11;case 11:if($c){$c=false;dx=dx.$blk();}if(dx&&dx.$blk!==undefined){break s;}dw=dx;dy=dw[0];dz=dw[1];if(dz){dv.addSec((ea=(new $Int64(0,dy)),new $Int64(-ea.$high,-ea.$low)));dv.setLoc(l);$s=-1;return[dv,$ifaceNil];}if(ac.length>3&&$substring(ac,0,3)==="GMT"){eb=AB($substring(ac,3));dy=eb[0];dy=$imul(dy,(3600));}dv.setLoc(CP(ac,dy));$s=-1;return[dv,$ifaceNil];case 9:ec=CH(t,((u>>0)),v,w,x,y,z,k);$s=12;case 12:if($c){$c=false;ec=ec.$blk();}if(ec&&ec.$blk!==undefined){break s;}$s=-1;return[ec,$ifaceNil];}return;}if($f===undefined){$f={$blk:AM};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.bu=bu;$f.bv=bv;$f.bw=bw;$f.bx=bx;$f.by=by;$f.bz=bz;$f.ca=ca;$f.cb=cb;$f.cc=cc;$f.cd=cd;$f.ce=ce;$f.cf=cf;$f.cg=cg;$f.ch=ch;$f.ci=ci;$f.cj=cj;$f.ck=ck;$f.cl=cl;$f.cm=cm;$f.cn=cn;$f.co=co;$f.cp=cp;$f.cq=cq;$f.cr=cr;$f.cs=cs;$f.ct=ct;$f.cu=cu;$f.cv=cv;$f.cw=cw;$f.cx=cx;$f.cy=cy;$f.cz=cz;$f.da=da;$f.db=db;$f.dc=dc;$f.dd=dd;$f.de=de;$f.df=df;$f.dg=dg;$f.dh=dh;$f.di=di;$f.dj=dj;$f.dk=dk;$f.dl=dl;$f.dm=dm;$f.dn=dn;$f.dp=dp;$f.dq=dq;$f.dr=dr;$f.ds=ds;$f.dt=dt;$f.du=du;$f.dv=dv;$f.dw=dw;$f.dx=dx;$f.dy=dy;$f.dz=dz;$f.ea=ea;$f.eb=eb;$f.ec=ec;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AN=function(i){var aa,ab,ac,ad,ae,af,ag,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;j=0;k=false;if(i.length<3){l=0;m=false;j=l;k=m;return[j,k];}if(i.length>=4&&($substring(i,0,4)==="ChST"||$substring(i,0,4)==="MeST")){n=4;o=true;j=n;k=o;return[j,k];}if($substring(i,0,3)==="GMT"){j=AO(i);p=j;q=true;j=p;k=q;return[j,k];}if((i.charCodeAt(0)===43)||(i.charCodeAt(0)===45)){j=AP(i);r=j>0;s=j;t=r;j=s;k=t;return[j,k];}u=0;u=0;while(true){if(!(u<6)){break;}if(u>=i.length){break;}v=i.charCodeAt(u);if(v<65||90>0;}w=u;if((w===(0))||(w===(1))||(w===(2))||(w===(6))){x=0;y=false;j=x;k=y;return[j,k];}else if(w===(5)){if(i.charCodeAt(4)===84){z=5;aa=true;j=z;k=aa;return[j,k];}}else if(w===(4)){if((i.charCodeAt(3)===84)||$substring(i,0,4)==="WITA"){ab=4;ac=true;j=ab;k=ac;return[j,k];}}else if(w===(3)){ad=3;ae=true;j=ad;k=ae;return[j,k];}af=0;ag=false;j=af;k=ag;return[j,k];};AO=function(i){var i;i=$substring(i,3);if(i.length===0){return 3;}return 3+AP(i)>>0;};AP=function(i){var i,j,k,l,m,n;j=i.charCodeAt(0);if(!((j===45))&&!((j===43))){return 0;}k=AS($substring(i,1));l=k[0];m=k[1];n=k[2];if(!($interfaceIsEqual(n,$ifaceNil))||$substring(i,1)===m){return 0;}if(j===45){l=new $Int64(-l.$high,-l.$low);}if((l.$high<-1||(l.$high===-1&&l.$low<4294967273))||(0>0;};AQ=function(i,j){var i,j,k,l,m,n,o,p;k=0;l="";m=$ifaceNil;if(!((i.charCodeAt(0)===46))){m=AD;return[k,l,m];}n=AB($substring(i,1,j));k=n[0];m=n[1];if(!($interfaceIsEqual(m,$ifaceNil))){return[k,l,m];}if(k<0||1000000000<=k){l="fractional second";return[k,l,m];}o=10-j>>0;p=0;while(true){if(!(p>0;}return[k,l,m];};AS=function(i){var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;j=new $Int64(0,0);k="";l=$ifaceNil;m=0;while(true){if(!(m57){break;}if((j.$high>214748364||(j.$high===214748364&&j.$low>3435973836))){o=new $Int64(0,0);p="";q=AR;j=o;k=p;l=q;return[j,k,l];}j=(r=(s=$mul64(j,new $Int64(0,10)),t=(new $Int64(0,n)),new $Int64(s.$high+t.$high,s.$low+t.$low)),new $Int64(r.$high-0,r.$low-48));if((j.$high<0||(j.$high===0&&j.$low<0))){u=new $Int64(0,0);v="";w=AR;j=u;k=v;l=w;return[j,k,l];}m=m+(1)>>0;}x=j;y=$substring(i,m);z=$ifaceNil;j=x;k=y;l=z;return[j,k,l];};BL.ptr.prototype.nsec=function(){var i,j;i=this;return(((j=i.wall,new $Uint64(j.$high&0,(j.$low&1073741823)>>>0)).$low>>0));};BL.prototype.nsec=function(){return this.$val.nsec();};BL.ptr.prototype.sec=function(){var i,j,k,l,m;i=this;if(!((j=(k=i.wall,new $Uint64(k.$high&2147483648,(k.$low&0)>>>0)),(j.$high===0&&j.$low===0)))){return(l=((m=$shiftRightUint64($shiftLeft64(i.wall,1),31),new $Int64(m.$high,m.$low))),new $Int64(13+l.$high,3618733952+l.$low));}return i.ext;};BL.prototype.sec=function(){return this.$val.sec();};BL.ptr.prototype.unixSec=function(){var i,j;i=this;return(j=i.sec(),new $Int64(j.$high+-15,j.$low+2288912640));};BL.prototype.unixSec=function(){return this.$val.unixSec();};BL.ptr.prototype.addSec=function(i){var i,j,k,l,m,n,o,p,q,r,s,t,u;j=this;if(!((k=(l=j.wall,new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){n=((m=$shiftRightUint64($shiftLeft64(j.wall,1),31),new $Int64(m.$high,m.$low)));o=new $Int64(n.$high+i.$high,n.$low+i.$low);if((0>>0)),s=$shiftLeft64((new $Uint64(o.$high,o.$low)),30),new $Uint64(q.$high|s.$high,(q.$low|s.$low)>>>0)),new $Uint64(p.$high|2147483648,(p.$low|0)>>>0));return;}j.stripMono();}j.ext=(t=j.ext,u=i,new $Int64(t.$high+u.$high,t.$low+u.$low));};BL.prototype.addSec=function(i){return this.$val.addSec(i);};BL.ptr.prototype.setLoc=function(i){var i,j;j=this;if(i===CM){i=DU.nil;}j.stripMono();j.loc=i;};BL.prototype.setLoc=function(i){return this.$val.setLoc(i);};BL.ptr.prototype.stripMono=function(){var i,j,k,l,m;i=this;if(!((j=(k=i.wall,new $Uint64(k.$high&2147483648,(k.$low&0)>>>0)),(j.$high===0&&j.$low===0)))){i.ext=i.sec();i.wall=(l=i.wall,m=new $Uint64(0,1073741823),new $Uint64(l.$high&m.$high,(l.$low&m.$low)>>>0));}};BL.prototype.stripMono=function(){return this.$val.stripMono();};BL.ptr.prototype.After=function(i){var i,j,k,l,m,n,o,p,q,r;j=this;if(!((k=(l=(m=j.wall,n=i.wall,new $Uint64(m.$high&n.$high,(m.$low&n.$low)>>>0)),new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){return(o=j.ext,p=i.ext,(o.$high>p.$high||(o.$high===p.$high&&o.$low>p.$low)));}q=j.sec();r=i.sec();return(q.$high>r.$high||(q.$high===r.$high&&q.$low>r.$low))||(q.$high===r.$high&&q.$low===r.$low)&&j.nsec()>i.nsec();};BL.prototype.After=function(i){return this.$val.After(i);};BL.ptr.prototype.Before=function(i){var i,j,k,l,m,n,o,p,q,r,s,t;j=this;if(!((k=(l=(m=j.wall,n=i.wall,new $Uint64(m.$high&n.$high,(m.$low&n.$low)>>>0)),new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){return(o=j.ext,p=i.ext,(o.$high>>0)),new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){return(o=j.ext,p=i.ext,(o.$high===p.$high&&o.$low===p.$low));}return(q=j.sec(),r=i.sec(),(q.$high===r.$high&&q.$low===r.$low))&&(j.nsec()===i.nsec());};BL.prototype.Equal=function(i){return this.$val.Equal(i);};BM.prototype.String=function(){var i,j,k,l;i=this.$val;if(1<=i&&i<=12){return(j=i-1>>0,((j<0||j>=BN.length)?($throwRuntimeError("index out of range"),undefined):BN[j]));}k=$makeSlice(DR,20);l=BU(k,(new $Uint64(0,i)));return"%!Month("+($bytesToString($subslice(k,l)))+")";};$ptrType(BM).prototype.String=function(){return new BM(this.$get()).String();};BO.prototype.String=function(){var i,j,k;i=this.$val;if(0<=i&&i<=6){return((i<0||i>=BP.length)?($throwRuntimeError("index out of range"),undefined):BP[i]);}j=$makeSlice(DR,20);k=BU(j,(new $Uint64(0,i)));return"%!Weekday("+($bytesToString($subslice(j,k)))+")";};$ptrType(BO).prototype.String=function(){return new BO(this.$get()).String();};BL.ptr.prototype.IsZero=function(){var i,j;i=this;return(j=i.sec(),(j.$high===0&&j.$low===0))&&(i.nsec()===0);};BL.prototype.IsZero=function(){return this.$val.IsZero();};BL.ptr.prototype.abs=function(){var i,j,k,l,m,n,o,p,q,r,s,t,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=i.loc;if(j===DU.nil||j===CN){$s=1;continue;}$s=2;continue;case 1:k=j.get();$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;case 2:l=i.unixSec();if(!(j===CM)){$s=4;continue;}$s=5;continue;case 4:if(!(j.cacheZone===DM.nil)&&(m=j.cacheStart,(m.$high>0))/86400,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0));};BL.ptr.prototype.ISOWeek=function(){var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=0;j=0;k=this;m=$clone(k,BL).date(true);$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;i=l[0];n=l[1];o=l[2];p=l[3];r=$clone(k,BL).Weekday();$s=2;case 2:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}s=(q=(((r+6>>0)>>0))%7,q===q?q:$throwRuntimeError("integer divide by zero"));j=(t=(((p-s>>0)+7>>0))/7,(t===t&&t!==1/0&&t!==-1/0)?t>>0:$throwRuntimeError("integer divide by zero"));v=(u=(((s-p>>0)+371>>0))%7,u===u?u:$throwRuntimeError("integer divide by zero"));if(1<=v&&v<=3){j=j+(1)>>0;}if(j===0){i=i-(1)>>0;j=52;if((v===4)||((v===5)&&CF(i))){j=j+(1)>>0;}}if((n===12)&&o>=29&&s<3){x=(w=(((s+31>>0)-o>>0))%7,w===w?w:$throwRuntimeError("integer divide by zero"));if(0<=x&&x<=2){i=i+(1)>>0;j=1;}}$s=-1;return[i,j];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.ISOWeek};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.ISOWeek=function(){return this.$val.ISOWeek();};BL.ptr.prototype.Clock=function(){var i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=0;j=0;k=0;l=this;n=$clone(l,BL).abs();$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}o=BR(n);$s=2;case 2:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}m=o;i=m[0];j=m[1];k=m[2];$s=-1;return[i,j,k];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Clock};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Clock=function(){return this.$val.Clock();};BR=function(i){var i,j,k,l,m,n;j=0;k=0;l=0;l=(($div64(i,new $Uint64(0,86400),true).$low>>0));j=(m=l/3600,(m===m&&m!==1/0&&m!==-1/0)?m>>0:$throwRuntimeError("integer divide by zero"));l=l-(($imul(j,3600)))>>0;k=(n=l/60,(n===n&&n!==1/0&&n!==-1/0)?n>>0:$throwRuntimeError("integer divide by zero"));l=l-(($imul(k,60)))>>0;return[j,k,l];};BL.ptr.prototype.Hour=function(){var i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;k=$clone(i,BL).abs();$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}$s=-1;return(j=(($div64(k,new $Uint64(0,86400),true).$low>>0))/3600,(j===j&&j!==1/0&&j!==-1/0)?j>>0:$throwRuntimeError("integer divide by zero"));}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Hour};}$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Hour=function(){return this.$val.Hour();};BL.ptr.prototype.Minute=function(){var i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;k=$clone(i,BL).abs();$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}$s=-1;return(j=(($div64(k,new $Uint64(0,3600),true).$low>>0))/60,(j===j&&j!==1/0&&j!==-1/0)?j>>0:$throwRuntimeError("integer divide by zero"));}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Minute};}$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Minute=function(){return this.$val.Minute();};BL.ptr.prototype.Second=function(){var i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=$clone(i,BL).abs();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$s=-1;return(($div64(j,new $Uint64(0,60),true).$low>>0));}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Second};}$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Second=function(){return this.$val.Second();};BL.ptr.prototype.Nanosecond=function(){var i;i=this;return((i.nsec()>>0));};BL.prototype.Nanosecond=function(){return this.$val.Nanosecond();};BL.ptr.prototype.YearDay=function(){var i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;k=$clone(i,BL).date(false);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[3];$s=-1;return l+1>>0;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.YearDay};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.YearDay=function(){return this.$val.YearDay();};BS.prototype.String=function(){var i,j,k,l,m,n,o,p;i=this;j=DX.zero();k=32;l=(new $Uint64(i.$high,i.$low));m=(i.$high<0||(i.$high===0&&i.$low<0));if(m){l=new $Uint64(-l.$high,-l.$low);}if((l.$high<0||(l.$high===0&&l.$low<1000000000))){n=0;k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=115);k=k-(1)>>0;if((l.$high===0&&l.$low===0)){return"0s";}else if((l.$high<0||(l.$high===0&&l.$low<1000))){n=0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=110);}else if((l.$high<0||(l.$high===0&&l.$low<1000000))){n=3;k=k-(1)>>0;$copyString($subslice(new DR(j),k),"\xC2\xB5");}else{n=6;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=109);}o=BT($subslice(new DR(j),0,k),l,n);k=o[0];l=o[1];k=BU($subslice(new DR(j),0,k),l);}else{k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=115);p=BT($subslice(new DR(j),0,k),l,9);k=p[0];l=p[1];k=BU($subslice(new DR(j),0,k),$div64(l,new $Uint64(0,60),true));l=$div64(l,(new $Uint64(0,60)),false);if((l.$high>0||(l.$high===0&&l.$low>0))){k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=109);k=BU($subslice(new DR(j),0,k),$div64(l,new $Uint64(0,60),true));l=$div64(l,(new $Uint64(0,60)),false);if((l.$high>0||(l.$high===0&&l.$low>0))){k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=104);k=BU($subslice(new DR(j),0,k),l);}}}if(m){k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=45);}return($bytesToString($subslice(new DR(j),k)));};$ptrType(BS).prototype.String=function(){return this.$get().String();};BT=function(i,j,k){var i,j,k,l,m,n,o,p,q,r,s;l=0;m=new $Uint64(0,0);n=i.$length;o=false;p=0;while(true){if(!(p>0;((n<0||n>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+n]=(((q.$low<<24>>>24))+48<<24>>>24));}j=$div64(j,(new $Uint64(0,10)),false);p=p+(1)>>0;}if(o){n=n-(1)>>0;((n<0||n>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+n]=46);}r=n;s=j;l=r;m=s;return[l,m];};BU=function(i,j){var i,j,k;k=i.$length;if((j.$high===0&&j.$low===0)){k=k-(1)>>0;((k<0||k>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+k]=48);}else{while(true){if(!((j.$high>0||(j.$high===0&&j.$low>0)))){break;}k=k-(1)>>0;((k<0||k>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+k]=((($div64(j,new $Uint64(0,10),true).$low<<24>>>24))+48<<24>>>24));j=$div64(j,(new $Uint64(0,10)),false);}}return k;};BS.prototype.Nanoseconds=function(){var i;i=this;return(new $Int64(i.$high,i.$low));};$ptrType(BS).prototype.Nanoseconds=function(){return this.$get().Nanoseconds();};BS.prototype.Seconds=function(){var i,j,k;i=this;j=$div64(i,new BS(0,1000000000),false);k=$div64(i,new BS(0,1000000000),true);return($flatten64(j))+($flatten64(k))/1e+09;};$ptrType(BS).prototype.Seconds=function(){return this.$get().Seconds();};BS.prototype.Minutes=function(){var i,j,k;i=this;j=$div64(i,new BS(13,4165425152),false);k=$div64(i,new BS(13,4165425152),true);return($flatten64(j))+($flatten64(k))/6e+10;};$ptrType(BS).prototype.Minutes=function(){return this.$get().Minutes();};BS.prototype.Hours=function(){var i,j,k;i=this;j=$div64(i,new BS(838,817405952),false);k=$div64(i,new BS(838,817405952),true);return($flatten64(j))+($flatten64(k))/3.6e+12;};$ptrType(BS).prototype.Hours=function(){return this.$get().Hours();};BS.prototype.Truncate=function(i){var i,j,k;j=this;if((i.$high<0||(i.$high===0&&i.$low<=0))){return j;}return(k=$div64(j,i,true),new BS(j.$high-k.$high,j.$low-k.$low));};$ptrType(BS).prototype.Truncate=function(i){return this.$get().Truncate(i);};BV=function(i,j){var i,j,k,l,m,n;return(k=(l=(new $Uint64(i.$high,i.$low)),m=(new $Uint64(i.$high,i.$low)),new $Uint64(l.$high+m.$high,l.$low+m.$low)),n=(new $Uint64(j.$high,j.$low)),(k.$highj.$high||(o.$high===j.$high&&o.$low>j.$low))){return o;}return new BS(2147483647,4294967295);};$ptrType(BS).prototype.Round=function(i){return this.$get().Round(i);};BL.ptr.prototype.Add=function(i){var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;j=this;l=((k=$div64(i,new BS(0,1000000000),false),new $Int64(k.$high,k.$low)));n=j.nsec()+(((m=$div64(i,new BS(0,1000000000),true),m.$low+((m.$high>>31)*4294967296))>>0))>>0;if(n>=1000000000){l=(o=new $Int64(0,1),new $Int64(l.$high+o.$high,l.$low+o.$low));n=n-(1000000000)>>0;}else if(n<0){l=(p=new $Int64(0,1),new $Int64(l.$high-p.$high,l.$low-p.$low));n=n+(1000000000)>>0;}j.wall=(q=(r=j.wall,new $Uint64(r.$high&~0,(r.$low&~1073741823)>>>0)),s=(new $Uint64(0,n)),new $Uint64(q.$high|s.$high,(q.$low|s.$low)>>>0));j.addSec(l);if(!((t=(u=j.wall,new $Uint64(u.$high&2147483648,(u.$low&0)>>>0)),(t.$high===0&&t.$low===0)))){x=(v=j.ext,w=(new $Int64(i.$high,i.$low)),new $Int64(v.$high+w.$high,v.$low+w.$low));if((i.$high<0||(i.$high===0&&i.$low<0))&&(y=j.ext,(x.$high>y.$high||(x.$high===y.$high&&x.$low>y.$low)))||(i.$high>0||(i.$high===0&&i.$low>0))&&(z=j.ext,(x.$high>>0)),new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){o=j.ext;p=i.ext;r=((q=new $Int64(o.$high-p.$high,o.$low-p.$low),new BS(q.$high,q.$low)));if((r.$high<0||(r.$high===0&&r.$low<0))&&(o.$high>p.$high||(o.$high===p.$high&&o.$low>p.$low))){return new BS(2147483647,4294967295);}if((r.$high>0||(r.$high===0&&r.$low>0))&&(o.$high>0))),new BS(s.$high+w.$high,s.$low+w.$low));if($clone($clone(i,BL).Add(x),BL).Equal($clone(j,BL))){return x;}else if($clone(j,BL).Before($clone(i,BL))){return new BS(-2147483648,0);}else{return new BS(2147483647,4294967295);}};BL.prototype.Sub=function(i){return this.$val.Sub(i);};BW=function(i){var i,j,k,l,m;j=new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil);if(!((k=(l=i.wall,new $Uint64(l.$high&2147483648,(l.$low&0)>>>0)),(k.$high===0&&k.$low===0)))){BL.copy(j,new BL.ptr(new $Uint64(2147483648,0),(m=I(),new $Int64(m.$high-CB.$high,m.$low-CB.$low)),DU.nil));}else{BL.copy(j,CC());}return $clone(j,BL).Sub($clone(i,BL));};$pkg.Since=BW;BL.ptr.prototype.AddDate=function(i,j,k){var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:l=this;n=$clone(l,BL).Date();$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];p=m[1];q=m[2];s=$clone(l,BL).Clock();$s=2;case 2:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}r=s;t=r[0];u=r[1];v=r[2];w=CH(o+i>>0,p+((j>>0))>>0,q+k>>0,t,u,v,((l.nsec()>>0)),$clone(l,BL).Location());$s=3;case 3:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}$s=-1;return w;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.AddDate};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.AddDate=function(i,j,k){return this.$val.AddDate(i,j,k);};BL.ptr.prototype.date=function(i){var i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=0;k=0;l=0;m=0;n=this;p=$clone(n,BL).abs();$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=BY(p,i);$s=2;case 2:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}o=q;j=o[0];k=o[1];l=o[2];m=o[3];$s=-1;return[j,k,l,m];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.date};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.date=function(i){return this.$val.date(i);};BY=function(i,j){var aa,ab,ac,ad,ae,af,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;k=0;l=0;m=0;n=0;o=$div64(i,new $Uint64(0,86400),false);p=$div64(o,new $Uint64(0,146097),false);q=$mul64(new $Uint64(0,400),p);o=(r=$mul64(new $Uint64(0,146097),p),new $Uint64(o.$high-r.$high,o.$low-r.$low));p=$div64(o,new $Uint64(0,36524),false);p=(s=$shiftRightUint64(p,2),new $Uint64(p.$high-s.$high,p.$low-s.$low));q=(t=$mul64(new $Uint64(0,100),p),new $Uint64(q.$high+t.$high,q.$low+t.$low));o=(u=$mul64(new $Uint64(0,36524),p),new $Uint64(o.$high-u.$high,o.$low-u.$low));p=$div64(o,new $Uint64(0,1461),false);q=(v=$mul64(new $Uint64(0,4),p),new $Uint64(q.$high+v.$high,q.$low+v.$low));o=(w=$mul64(new $Uint64(0,1461),p),new $Uint64(o.$high-w.$high,o.$low-w.$low));p=$div64(o,new $Uint64(0,365),false);p=(x=$shiftRightUint64(p,2),new $Uint64(p.$high-x.$high,p.$low-x.$low));q=(y=p,new $Uint64(q.$high+y.$high,q.$low+y.$low));o=(z=$mul64(new $Uint64(0,365),p),new $Uint64(o.$high-z.$high,o.$low-z.$low));k=(((aa=(ab=(new $Int64(q.$high,q.$low)),new $Int64(ab.$high+-69,ab.$low+4075721025)),aa.$low+((aa.$high>>31)*4294967296))>>0));n=((o.$low>>0));if(!j){return[k,l,m,n];}m=n;if(CF(k)){if(m>59){m=m-(1)>>0;}else if((m===59)){l=2;m=29;return[k,l,m,n];}}l=(((ac=m/31,(ac===ac&&ac!==1/0&&ac!==-1/0)?ac>>0:$throwRuntimeError("integer divide by zero"))>>0));ae=(((ad=l+1>>0,((ad<0||ad>=BZ.length)?($throwRuntimeError("index out of range"),undefined):BZ[ad]))>>0));af=0;if(m>=ae){l=l+(1)>>0;af=ae;}else{af=((((l<0||l>=BZ.length)?($throwRuntimeError("index out of range"),undefined):BZ[l])>>0));}l=l+(1)>>0;m=(m-af>>0)+1>>0;return[k,l,m,n];};CA=function(i,j){var i,j,k;if((i===2)&&CF(j)){return 29;}return(((((i<0||i>=BZ.length)?($throwRuntimeError("index out of range"),undefined):BZ[i])-(k=i-1>>0,((k<0||k>=BZ.length)?($throwRuntimeError("index out of range"),undefined):BZ[k]))>>0)>>0));};CC=function(){var i,j,k,l,m,n,o,p,q,r;i=J();j=i[0];k=i[1];l=i[2];l=(m=CB,new $Int64(l.$high-m.$high,l.$low-m.$low));j=(n=new $Int64(0,2682288000),new $Int64(j.$high+n.$high,j.$low+n.$low));if(!((o=$shiftRightUint64((new $Uint64(j.$high,j.$low)),33),(o.$high===0&&o.$low===0)))){return new BL.ptr((new $Uint64(0,k)),new $Int64(j.$high+13,j.$low+3618733952),$pkg.Local);}return new BL.ptr((p=(q=$shiftLeft64((new $Uint64(j.$high,j.$low)),30),new $Uint64(2147483648|q.$high,(0|q.$low)>>>0)),r=(new $Uint64(0,k)),new $Uint64(p.$high|r.$high,(p.$low|r.$low)>>>0)),l,$pkg.Local);};$pkg.Now=CC;CD=function(i,j){var i,j;return new BL.ptr((new $Uint64(0,j)),new $Int64(i.$high+14,i.$low+2006054656),$pkg.Local);};BL.ptr.prototype.UTC=function(){var i;i=this;i.setLoc(CM);return i;};BL.prototype.UTC=function(){return this.$val.UTC();};BL.ptr.prototype.Local=function(){var i;i=this;i.setLoc($pkg.Local);return i;};BL.prototype.Local=function(){return this.$val.Local();};BL.ptr.prototype.In=function(i){var i,j;j=this;if(i===DU.nil){$panic(new $String("time: missing Location in call to Time.In"));}j.setLoc(i);return j;};BL.prototype.In=function(i){return this.$val.In(i);};BL.ptr.prototype.Location=function(){var i,j;i=this;j=i.loc;if(j===DU.nil){j=$pkg.UTC;}return j;};BL.prototype.Location=function(){return this.$val.Location();};BL.ptr.prototype.Zone=function(){var i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i="";j=0;k=this;m=k.loc.lookup(k.unixSec());$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;i=l[0];j=l[1];$s=-1;return[i,j];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Zone};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Zone=function(){return this.$val.Zone();};BL.ptr.prototype.Unix=function(){var i;i=this;return i.unixSec();};BL.prototype.Unix=function(){return this.$val.Unix();};BL.ptr.prototype.UnixNano=function(){var i,j,k;i=this;return(j=$mul64((i.unixSec()),new $Int64(0,1000000000)),k=(new $Int64(0,i.nsec())),new $Int64(j.$high+k.$high,j.$low+k.$low));};BL.prototype.UnixNano=function(){return this.$val.UnixNano();};BL.ptr.prototype.MarshalBinary=function(){var i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=0;if($clone(i,BL).Location()===$pkg.UTC){$s=1;continue;}$s=2;continue;case 1:j=-1;$s=3;continue;case 2:l=$clone(i,BL).Zone();$s=4;case 4:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;m=k[1];if(!(((n=m%60,n===n?n:$throwRuntimeError("integer divide by zero"))===0))){$s=-1;return[DR.nil,C.New("Time.MarshalBinary: zone offset has fractional minute")];}m=(o=m/(60),(o===o&&o!==1/0&&o!==-1/0)?o>>0:$throwRuntimeError("integer divide by zero"));if(m<-32768||(m===-1)||m>32767){$s=-1;return[DR.nil,C.New("Time.MarshalBinary: unexpected zone offset")];}j=((m<<16>>16));case 3:p=i.sec();q=i.nsec();r=new DR([1,(($shiftRightInt64(p,56).$low<<24>>>24)),(($shiftRightInt64(p,48).$low<<24>>>24)),(($shiftRightInt64(p,40).$low<<24>>>24)),(($shiftRightInt64(p,32).$low<<24>>>24)),(($shiftRightInt64(p,24).$low<<24>>>24)),(($shiftRightInt64(p,16).$low<<24>>>24)),(($shiftRightInt64(p,8).$low<<24>>>24)),((p.$low<<24>>>24)),(((q>>24>>0)<<24>>>24)),(((q>>16>>0)<<24>>>24)),(((q>>8>>0)<<24>>>24)),((q<<24>>>24)),(((j>>8<<16>>16)<<24>>>24)),((j<<24>>>24))]);$s=-1;return[r,$ifaceNil];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.MarshalBinary};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.MarshalBinary=function(){return this.$val.MarshalBinary();};BL.ptr.prototype.UnmarshalBinary=function(i){var aa,ab,ac,ad,ae,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=this;k=i;if(k.$length===0){$s=-1;return C.New("Time.UnmarshalBinary: no data");}if(!(((0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])===1))){$s=-1;return C.New("Time.UnmarshalBinary: unsupported version");}if(!((k.$length===15))){$s=-1;return C.New("Time.UnmarshalBinary: invalid length");}k=$subslice(k,1);z=(l=(m=(n=(o=(p=(q=(r=(new $Int64(0,(7>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+7]))),s=$shiftLeft64((new $Int64(0,(6>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+6]))),8),new $Int64(r.$high|s.$high,(r.$low|s.$low)>>>0)),t=$shiftLeft64((new $Int64(0,(5>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+5]))),16),new $Int64(q.$high|t.$high,(q.$low|t.$low)>>>0)),u=$shiftLeft64((new $Int64(0,(4>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+4]))),24),new $Int64(p.$high|u.$high,(p.$low|u.$low)>>>0)),v=$shiftLeft64((new $Int64(0,(3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3]))),32),new $Int64(o.$high|v.$high,(o.$low|v.$low)>>>0)),w=$shiftLeft64((new $Int64(0,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2]))),40),new $Int64(n.$high|w.$high,(n.$low|w.$low)>>>0)),x=$shiftLeft64((new $Int64(0,(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]))),48),new $Int64(m.$high|x.$high,(m.$low|x.$low)>>>0)),y=$shiftLeft64((new $Int64(0,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]))),56),new $Int64(l.$high|y.$high,(l.$low|y.$low)>>>0));k=$subslice(k,8);aa=(((((3>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+3])>>0))|((((2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2])>>0))<<8>>0))|((((1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1])>>0))<<16>>0))|((((0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])>>0))<<24>>0);k=$subslice(k,4);ab=$imul(((((((1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1])<<16>>16))|((((0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])<<16>>16))<<8<<16>>16))>>0)),60);BL.copy(j,new BL.ptr(new $Uint64(0,0),new $Int64(0,0),DU.nil));j.wall=(new $Uint64(0,aa));j.ext=z;if(ab===-60){$s=1;continue;}$s=2;continue;case 1:j.setLoc(CM);$s=3;continue;case 2:ad=$pkg.Local.lookup(j.unixSec());$s=4;case 4:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ac=ad;ae=ac[1];if(ab===ae){j.setLoc($pkg.Local);}else{j.setLoc(CP("",ab));}case 3:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.UnmarshalBinary};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.UnmarshalBinary=function(i){return this.$val.UnmarshalBinary(i);};BL.ptr.prototype.GobEncode=function(){var i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=$clone(i,BL).MarshalBinary();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$s=-1;return j;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.GobEncode};}$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.GobEncode=function(){return this.$val.GobEncode();};BL.ptr.prototype.GobDecode=function(i){var i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=this;k=j.UnmarshalBinary(i);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}$s=-1;return k;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.GobDecode};}$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.GobDecode=function(i){return this.$val.GobDecode(i);};BL.ptr.prototype.MarshalJSON=function(){var i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=$clone(i,BL).Year();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(k<0||k>=10000){$s=-1;return[DR.nil,C.New("Time.MarshalJSON: year outside of range [0,9999]")];}l=$makeSlice(DR,0,37);l=$append(l,34);m=$clone(i,BL).AppendFormat(l,"2006-01-02T15:04:05.999999999Z07:00");$s=2;case 2:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;l=$append(l,34);$s=-1;return[l,$ifaceNil];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.MarshalJSON};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.MarshalJSON=function(){return this.$val.MarshalJSON();};BL.ptr.prototype.UnmarshalJSON=function(i){var i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=this;if(($bytesToString(i))==="null"){$s=-1;return $ifaceNil;}k=$ifaceNil;m=AK("\"2006-01-02T15:04:05Z07:00\"",($bytesToString(i)));$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;BL.copy(j,l[0]);k=l[1];$s=-1;return k;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.UnmarshalJSON};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.UnmarshalJSON=function(i){return this.$val.UnmarshalJSON(i);};BL.ptr.prototype.MarshalText=function(){var i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=$clone(i,BL).Year();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(k<0||k>=10000){$s=-1;return[DR.nil,C.New("Time.MarshalText: year outside of range [0,9999]")];}l=$makeSlice(DR,0,35);m=$clone(i,BL).AppendFormat(l,"2006-01-02T15:04:05.999999999Z07:00");$s=2;case 2:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return[m,$ifaceNil];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.MarshalText};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.MarshalText=function(){return this.$val.MarshalText();};BL.ptr.prototype.UnmarshalText=function(i){var i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j=this;k=$ifaceNil;m=AK("2006-01-02T15:04:05Z07:00",($bytesToString(i)));$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;BL.copy(j,l[0]);k=l[1];$s=-1;return k;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.UnmarshalText};}$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.UnmarshalText=function(i){return this.$val.UnmarshalText(i);};CE=function(i,j){var i,j,k,l,m,n,o;if((j.$high<0||(j.$high===0&&j.$low<0))||(j.$high>0||(j.$high===0&&j.$low>=1000000000))){k=$div64(j,new $Int64(0,1000000000),false);i=(l=k,new $Int64(i.$high+l.$high,i.$low+l.$low));j=(m=$mul64(k,new $Int64(0,1000000000)),new $Int64(j.$high-m.$high,j.$low-m.$low));if((j.$high<0||(j.$high===0&&j.$low<0))){j=(n=new $Int64(0,1000000000),new $Int64(j.$high+n.$high,j.$low+n.$low));i=(o=new $Int64(0,1),new $Int64(i.$high-o.$high,i.$low-o.$low));}}return CD(i,(((j.$low+((j.$high>>31)*4294967296))>>0)));};$pkg.Unix=CE;CF=function(i){var i,j,k,l;return((j=i%4,j===j?j:$throwRuntimeError("integer divide by zero"))===0)&&(!(((k=i%100,k===k?k:$throwRuntimeError("integer divide by zero"))===0))||((l=i%400,l===l?l:$throwRuntimeError("integer divide by zero"))===0));};CG=function(i,j,k){var i,j,k,l,m,n,o,p,q,r,s;l=0;m=0;if(j<0){o=(n=((-j-1>>0))/k,(n===n&&n!==1/0&&n!==-1/0)?n>>0:$throwRuntimeError("integer divide by zero"))+1>>0;i=i-(o)>>0;j=j+(($imul(o,k)))>>0;}if(j>=k){q=(p=j/k,(p===p&&p!==1/0&&p!==-1/0)?p>>0:$throwRuntimeError("integer divide by zero"));i=i+(q)>>0;j=j-(($imul(q,k)))>>0;}r=i;s=j;l=r;m=s;return[l,m];};CH=function(i,j,k,l,m,n,o,p){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(p===DU.nil){$panic(new $String("time: missing Location in call to Date"));}q=((j>>0))-1>>0;r=CG(i,q,12);i=r[0];q=r[1];j=((q>>0))+1>>0;s=CG(n,o,1000000000);n=s[0];o=s[1];t=CG(m,n,60);m=t[0];n=t[1];u=CG(l,m,60);l=u[0];m=u[1];v=CG(k,l,24);k=v[0];l=v[1];y=((w=(x=(new $Int64(0,i)),new $Int64(x.$high- -69,x.$low-4075721025)),new $Uint64(w.$high,w.$low)));z=$div64(y,new $Uint64(0,400),false);y=(aa=$mul64(new $Uint64(0,400),z),new $Uint64(y.$high-aa.$high,y.$low-aa.$low));ab=$mul64(new $Uint64(0,146097),z);z=$div64(y,new $Uint64(0,100),false);y=(ac=$mul64(new $Uint64(0,100),z),new $Uint64(y.$high-ac.$high,y.$low-ac.$low));ab=(ad=$mul64(new $Uint64(0,36524),z),new $Uint64(ab.$high+ad.$high,ab.$low+ad.$low));z=$div64(y,new $Uint64(0,4),false);y=(ae=$mul64(new $Uint64(0,4),z),new $Uint64(y.$high-ae.$high,y.$low-ae.$low));ab=(af=$mul64(new $Uint64(0,1461),z),new $Uint64(ab.$high+af.$high,ab.$low+af.$low));z=y;ab=(ag=$mul64(new $Uint64(0,365),z),new $Uint64(ab.$high+ag.$high,ab.$low+ag.$low));ab=(ah=(new $Uint64(0,(ai=j-1>>0,((ai<0||ai>=BZ.length)?($throwRuntimeError("index out of range"),undefined):BZ[ai])))),new $Uint64(ab.$high+ah.$high,ab.$low+ah.$low));if(CF(i)&&j>=3){ab=(aj=new $Uint64(0,1),new $Uint64(ab.$high+aj.$high,ab.$low+aj.$low));}ab=(ak=(new $Uint64(0,(k-1>>0))),new $Uint64(ab.$high+ak.$high,ab.$low+ak.$low));al=$mul64(ab,new $Uint64(0,86400));al=(am=(new $Uint64(0,((($imul(l,3600))+($imul(m,60))>>0)+n>>0))),new $Uint64(al.$high+am.$high,al.$low+am.$low));ao=(an=(new $Int64(al.$high,al.$low)),new $Int64(an.$high+-2147483647,an.$low+3844486912));aq=p.lookup(ao);$s=1;case 1:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ap=aq;ar=ap[1];as=ap[2];at=ap[3];if(!((ar===0))){$s=2;continue;}$s=3;continue;case 2:av=(au=(new $Int64(0,ar)),new $Int64(ao.$high-au.$high,ao.$low-au.$low));if((av.$highat.$high||(av.$high===at.$high&&av.$low>=at.$low))){$s=6;continue;}$s=7;continue;case 5:ax=p.lookup(new $Int64(as.$high-0,as.$low-1));$s=8;case 8:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}aw=ax;ar=aw[1];$s=7;continue;case 6:az=p.lookup(at);$s=9;case 9:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}ay=az;ar=ay[1];case 7:case 4:ao=(ba=(new $Int64(0,ar)),new $Int64(ao.$high-ba.$high,ao.$low-ba.$low));case 3:bb=$clone(CD(ao,((o>>0))),BL);bb.setLoc(p);$s=-1;return bb;}return;}if($f===undefined){$f={$blk:CH};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Date=CH;BL.ptr.prototype.Truncate=function(i){var i,j,k,l;j=this;j.stripMono();if((i.$high<0||(i.$high===0&&i.$low<=0))){return j;}k=CI($clone(j,BL),i);l=k[1];return $clone(j,BL).Add(new BS(-l.$high,-l.$low));};BL.prototype.Truncate=function(i){return this.$val.Truncate(i);};BL.ptr.prototype.Round=function(i){var i,j,k,l;j=this;j.stripMono();if((i.$high<0||(i.$high===0&&i.$low<=0))){return j;}k=CI($clone(j,BL),i);l=k[1];if(BV(l,i)){return $clone(j,BL).Add(new BS(-l.$high,-l.$low));}return $clone(j,BL).Add(new BS(i.$high-l.$high,i.$low-l.$low));};BL.prototype.Round=function(i){return this.$val.Round(i);};CI=function(i,j){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;k=0;l=new BS(0,0);m=false;n=i.nsec();o=i.sec();if((o.$high<0||(o.$high===0&&o.$low<0))){m=true;o=new $Int64(-o.$high,-o.$low);n=-n;if(n<0){n=n+(1000000000)>>0;o=(p=new $Int64(0,1),new $Int64(o.$high-p.$high,o.$low-p.$low));}}if((j.$high<0||(j.$high===0&&j.$low<1000000000))&&(q=$div64(new BS(0,1000000000),(new BS(j.$high+j.$high,j.$low+j.$low)),true),(q.$high===0&&q.$low===0))){k=(((s=n/(((j.$low+((j.$high>>31)*4294967296))>>0)),(s===s&&s!==1/0&&s!==-1/0)?s>>0:$throwRuntimeError("integer divide by zero"))>>0))&1;l=(new BS(0,(t=n%(((j.$low+((j.$high>>31)*4294967296))>>0)),t===t?t:$throwRuntimeError("integer divide by zero"))));}else if((r=$div64(j,new BS(0,1000000000),true),(r.$high===0&&r.$low===0))){v=((u=$div64(j,new BS(0,1000000000),false),new $Int64(u.$high,u.$low)));k=(((w=$div64(o,v,false),w.$low+((w.$high>>31)*4294967296))>>0))&1;l=(x=$mul64(((y=$div64(o,v,true),new BS(y.$high,y.$low))),new BS(0,1000000000)),z=(new BS(0,n)),new BS(x.$high+z.$high,x.$low+z.$low));}else{aa=(new $Uint64(o.$high,o.$low));ab=$mul64(($shiftRightUint64(aa,32)),new $Uint64(0,1000000000));ac=$shiftRightUint64(ab,32);ad=$shiftLeft64(ab,32);ab=$mul64((new $Uint64(aa.$high&0,(aa.$low&4294967295)>>>0)),new $Uint64(0,1000000000));ae=ad;af=new $Uint64(ad.$high+ab.$high,ad.$low+ab.$low);ag=ae;ad=af;if((ad.$higham.$high||(ac.$high===am.$high&&ac.$low>am.$low))||(ac.$high===am.$high&&ac.$low===am.$low)&&(ad.$high>ao.$high||(ad.$high===ao.$high&&ad.$low>=ao.$low))){k=1;ap=ad;aq=new $Uint64(ad.$high-ao.$high,ad.$low-ao.$low);ag=ap;ad=aq;if((ad.$high>ag.$high||(ad.$high===ag.$high&&ad.$low>ag.$low))){ac=(ar=new $Uint64(0,1),new $Uint64(ac.$high-ar.$high,ac.$low-ar.$low));}ac=(as=am,new $Uint64(ac.$high-as.$high,ac.$low-as.$low));}if((am.$high===0&&am.$low===0)&&(at=(new $Uint64(j.$high,j.$low)),(ao.$high===at.$high&&ao.$low===at.$low))){break;}ao=$shiftRightUint64(ao,(1));ao=(au=$shiftLeft64((new $Uint64(am.$high&0,(am.$low&1)>>>0)),63),new $Uint64(ao.$high|au.$high,(ao.$low|au.$low)>>>0));am=$shiftRightUint64(am,(1));}l=(new BS(ad.$high,ad.$low));}if(m&&!((l.$high===0&&l.$low===0))){k=(k^(1))>>0;l=new BS(j.$high-l.$high,j.$low-l.$low);}return[k,l];};CJ.ptr.prototype.get=function(){var i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;if(i===DU.nil){$s=-1;return CM;}if(i===CN){$s=1;continue;}$s=2;continue;case 1:$r=CO.Do(H);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return i;}return;}if($f===undefined){$f={$blk:CJ.ptr.prototype.get};}$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};CJ.prototype.get=function(){return this.$val.get();};CJ.ptr.prototype.String=function(){var i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=this;j=i.get();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$s=-1;return j.name;}return;}if($f===undefined){$f={$blk:CJ.ptr.prototype.String};}$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};CJ.prototype.String=function(){return this.$val.String();};CP=function(i,j){var i,j,k,l;k=new CJ.ptr(i,new DK([new CK.ptr(i,j,false)]),new DL([new CL.ptr(new $Int64(-2147483648,0),0,false,false)]),new $Int64(-2147483648,0),new $Int64(2147483647,4294967295),DM.nil);k.cacheZone=(l=k.zone,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0]));return k;};$pkg.FixedZone=CP;CJ.ptr.prototype.lookup=function(i){var aa,ab,ac,ad,ae,af,ag,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:j="";k=0;l=new $Int64(0,0);m=new $Int64(0,0);n=this;o=n.get();$s=1;case 1:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;if(n.zone.$length===0){j="UTC";k=0;l=new $Int64(-2147483648,0);m=new $Int64(2147483647,4294967295);$s=-1;return[j,k,l,m];}p=n.cacheZone;if(!(p===DM.nil)&&(q=n.cacheStart,(q.$high=t.$length?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+0])).when,(i.$high=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+v]));j=w.name;k=w.offset;l=new $Int64(-2147483648,0);if(n.tx.$length>0){m=(x=n.tx,(0>=x.$length?($throwRuntimeError("index out of range"),undefined):x.$array[x.$offset+0])).when;}else{m=new $Int64(2147483647,4294967295);}$s=-1;return[j,k,l,m];}y=n.tx;m=new $Int64(2147483647,4294967295);z=0;aa=y.$length;while(true){if(!((aa-z>>0)>1)){break;}ac=z+(ab=((aa-z>>0))/2,(ab===ab&&ab!==1/0&&ab!==-1/0)?ab>>0:$throwRuntimeError("integer divide by zero"))>>0;ad=((ac<0||ac>=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+ac]).when;if((i.$high=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+z]).index,((af<0||af>=ae.$length)?($throwRuntimeError("index out of range"),undefined):ae.$array[ae.$offset+af]));j=ag.name;k=ag.offset;l=((z<0||z>=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+z]).when;$s=-1;return[j,k,l,m];}return;}if($f===undefined){$f={$blk:CJ.ptr.prototype.lookup};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};CJ.prototype.lookup=function(i){return this.$val.lookup(i);};CJ.ptr.prototype.lookupFirstZone=function(){var i,j,k,l,m,n,o,p,q,r,s;i=this;if(!i.firstZoneUsed()){return 0;}if(i.tx.$length>0&&(j=i.zone,k=(l=i.tx,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0])).index,((k<0||k>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k])).isDST){n=(((m=i.tx,(0>=m.$length?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+0])).index>>0))-1>>0;while(true){if(!(n>=0)){break;}if(!(o=i.zone,((n<0||n>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+n])).isDST){return n;}n=n-(1)>>0;}}p=i.zone;q=0;while(true){if(!(q=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+r])).isDST){return r;}q++;}return 0;};CJ.prototype.lookupFirstZone=function(){return this.$val.lookupFirstZone();};CJ.ptr.prototype.firstZoneUsed=function(){var i,j,k,l;i=this;j=i.tx;k=0;while(true){if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]),CL);if(l.index===0){return true;}k++;}return false;};CJ.prototype.firstZoneUsed=function(){return this.$val.firstZoneUsed();};CJ.ptr.prototype.lookupName=function(i,j){var aa,ab,ac,ad,ae,af,ag,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:k=0;l=false;m=this;n=m.get();$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m.zone;p=0;case 2:if(!(p=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+q]));if(s.name===i){$s=4;continue;}$s=5;continue;case 4:v=m.lookup((u=(new $Int64(0,s.offset)),new $Int64(j.$high-u.$high,j.$low-u.$low)));$s=6;case 6:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}t=v;w=t[0];x=t[1];if(w===s.name){y=x;z=true;k=y;l=z;$s=-1;return[k,l];}case 5:p++;$s=2;continue;case 3:aa=m.zone;ab=0;while(true){if(!(ab=ad.$length)?($throwRuntimeError("index out of range"),undefined):ad.$array[ad.$offset+ac]));if(ae.name===i){af=ae.offset;ag=true;k=af;l=ag;$s=-1;return[k,l];}ab++;}$s=-1;return[k,l];}return;}if($f===undefined){$f={$blk:CJ.ptr.prototype.lookupName};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};CJ.prototype.lookupName=function(i,j){return this.$val.lookupName(i,j);};EC.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];BL.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Format",name:"Format",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"AppendFormat",name:"AppendFormat",pkg:"",typ:$funcType([DR,$String],[DR],false)},{prop:"After",name:"After",pkg:"",typ:$funcType([BL],[$Bool],false)},{prop:"Before",name:"Before",pkg:"",typ:$funcType([BL],[$Bool],false)},{prop:"Equal",name:"Equal",pkg:"",typ:$funcType([BL],[$Bool],false)},{prop:"IsZero",name:"IsZero",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"abs",name:"abs",pkg:"time",typ:$funcType([],[$Uint64],false)},{prop:"locabs",name:"locabs",pkg:"time",typ:$funcType([],[$String,$Int,$Uint64],false)},{prop:"Date",name:"Date",pkg:"",typ:$funcType([],[$Int,BM,$Int],false)},{prop:"Year",name:"Year",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Month",name:"Month",pkg:"",typ:$funcType([],[BM],false)},{prop:"Day",name:"Day",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Weekday",name:"Weekday",pkg:"",typ:$funcType([],[BO],false)},{prop:"ISOWeek",name:"ISOWeek",pkg:"",typ:$funcType([],[$Int,$Int],false)},{prop:"Clock",name:"Clock",pkg:"",typ:$funcType([],[$Int,$Int,$Int],false)},{prop:"Hour",name:"Hour",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Minute",name:"Minute",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Second",name:"Second",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Nanosecond",name:"Nanosecond",pkg:"",typ:$funcType([],[$Int],false)},{prop:"YearDay",name:"YearDay",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Add",name:"Add",pkg:"",typ:$funcType([BS],[BL],false)},{prop:"Sub",name:"Sub",pkg:"",typ:$funcType([BL],[BS],false)},{prop:"AddDate",name:"AddDate",pkg:"",typ:$funcType([$Int,$Int,$Int],[BL],false)},{prop:"date",name:"date",pkg:"time",typ:$funcType([$Bool],[$Int,BM,$Int,$Int],false)},{prop:"UTC",name:"UTC",pkg:"",typ:$funcType([],[BL],false)},{prop:"Local",name:"Local",pkg:"",typ:$funcType([],[BL],false)},{prop:"In",name:"In",pkg:"",typ:$funcType([DU],[BL],false)},{prop:"Location",name:"Location",pkg:"",typ:$funcType([],[DU],false)},{prop:"Zone",name:"Zone",pkg:"",typ:$funcType([],[$String,$Int],false)},{prop:"Unix",name:"Unix",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"UnixNano",name:"UnixNano",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"MarshalBinary",name:"MarshalBinary",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"GobEncode",name:"GobEncode",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"MarshalJSON",name:"MarshalJSON",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"Truncate",name:"Truncate",pkg:"",typ:$funcType([BS],[BL],false)},{prop:"Round",name:"Round",pkg:"",typ:$funcType([BS],[BL],false)}];EG.methods=[{prop:"nsec",name:"nsec",pkg:"time",typ:$funcType([],[$Int32],false)},{prop:"sec",name:"sec",pkg:"time",typ:$funcType([],[$Int64],false)},{prop:"unixSec",name:"unixSec",pkg:"time",typ:$funcType([],[$Int64],false)},{prop:"addSec",name:"addSec",pkg:"time",typ:$funcType([$Int64],[],false)},{prop:"setLoc",name:"setLoc",pkg:"time",typ:$funcType([DU],[],false)},{prop:"stripMono",name:"stripMono",pkg:"time",typ:$funcType([],[],false)},{prop:"setMono",name:"setMono",pkg:"time",typ:$funcType([$Int64],[],false)},{prop:"mono",name:"mono",pkg:"time",typ:$funcType([],[$Int64],false)},{prop:"UnmarshalBinary",name:"UnmarshalBinary",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"GobDecode",name:"GobDecode",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"UnmarshalJSON",name:"UnmarshalJSON",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([DR],[$error],false)}];BM.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];BO.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];BS.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Nanoseconds",name:"Nanoseconds",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Seconds",name:"Seconds",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Minutes",name:"Minutes",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Hours",name:"Hours",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Truncate",name:"Truncate",pkg:"",typ:$funcType([BS],[BS],false)},{prop:"Round",name:"Round",pkg:"",typ:$funcType([BS],[BS],false)}];DU.methods=[{prop:"get",name:"get",pkg:"time",typ:$funcType([],[DU],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"lookup",name:"lookup",pkg:"time",typ:$funcType([$Int64],[$String,$Int,$Int64,$Int64],false)},{prop:"lookupFirstZone",name:"lookupFirstZone",pkg:"time",typ:$funcType([],[$Int],false)},{prop:"firstZoneUsed",name:"firstZoneUsed",pkg:"time",typ:$funcType([],[$Bool],false)},{prop:"lookupName",name:"lookupName",pkg:"time",typ:$funcType([$String,$Int64],[$Int,$Bool],false)}];AE.init("",[{prop:"Layout",name:"Layout",embedded:false,exported:true,typ:$String,tag:""},{prop:"Value",name:"Value",embedded:false,exported:true,typ:$String,tag:""},{prop:"LayoutElem",name:"LayoutElem",embedded:false,exported:true,typ:$String,tag:""},{prop:"ValueElem",name:"ValueElem",embedded:false,exported:true,typ:$String,tag:""},{prop:"Message",name:"Message",embedded:false,exported:true,typ:$String,tag:""}]);BL.init("time",[{prop:"wall",name:"wall",embedded:false,exported:false,typ:$Uint64,tag:""},{prop:"ext",name:"ext",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"loc",name:"loc",embedded:false,exported:false,typ:DU,tag:""}]);CJ.init("time",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"zone",name:"zone",embedded:false,exported:false,typ:DK,tag:""},{prop:"tx",name:"tx",embedded:false,exported:false,typ:DL,tag:""},{prop:"cacheStart",name:"cacheStart",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"cacheEnd",name:"cacheEnd",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"cacheZone",name:"cacheZone",embedded:false,exported:false,typ:DM,tag:""}]);CK.init("time",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"offset",name:"offset",embedded:false,exported:false,typ:$Int,tag:""},{prop:"isDST",name:"isDST",embedded:false,exported:false,typ:$Bool,tag:""}]);CL.init("time",[{prop:"when",name:"when",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"index",name:"index",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"isstd",name:"isstd",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"isutc",name:"isutc",embedded:false,exported:false,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}CN=new CJ.ptr("",DK.nil,DL.nil,new $Int64(0,0),new $Int64(0,0),DM.nil);CO=new E.Once.ptr(false,false);O=new DO([A.GOROOT()+"/lib/time/zoneinfo.zip"]);Q=$toNativeArray($kindInt,[260,265,524,526,528,274]);T=new DO(["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]);U=new DO(["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]);V=new DO(["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]);W=new DO(["January","February","March","April","May","June","July","August","September","October","November","December"]);AA=C.New("time: invalid number");AD=C.New("bad value for field");AR=C.New("time: bad [0-9]*");BN=$toNativeArray($kindString,["January","February","March","April","May","June","July","August","September","October","November","December"]);BP=$toNativeArray($kindString,["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]);BZ=$toNativeArray($kindInt32,[0,31,59,90,120,151,181,212,243,273,304,334,365]);CB=(h=I(),new $Int64(h.$high-0,h.$low-1));CM=new CJ.ptr("UTC",DK.nil,DL.nil,new $Int64(0,0),new $Int64(0,0),DM.nil);$pkg.UTC=CM;$pkg.Local=CN;CQ=C.New("time: invalid location name");CY=C.New("malformed time zone information");$unused(new DO(["/usr/share/zoneinfo/","/usr/share/lib/zoneinfo/","/usr/lib/locale/TZ/",A.GOROOT()+"/lib/time/zoneinfo.zip"]));F();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/poll"]=(function(){var $pkg={},$init,B,E,F,D,C,A,G,M,P,Q,AG,AH,AI,AJ,AK,AM,AR,AS,AT,AU,AV,AW,AX,AY,AZ,BA,BB,BC,BD,BE,BF,BG,BH,K,R,AE,I,J,L,N,O,S,T,U,W;B=$packages["errors"];E=$packages["io"];F=$packages["runtime"];D=$packages["sync/atomic"];C=$packages["syscall"];A=$packages["time"];G=$pkg.pollDesc=$newType(0,$kindStruct,"poll.pollDesc",true,"internal/poll",false,function(closing_){this.$val=this;if(arguments.length===0){this.closing=false;return;}this.closing=closing_;});M=$pkg.TimeoutError=$newType(0,$kindStruct,"poll.TimeoutError",true,"internal/poll",true,function(){this.$val=this;if(arguments.length===0){return;}});P=$pkg.fdMutex=$newType(0,$kindStruct,"poll.fdMutex",true,"internal/poll",false,function(state_,rsema_,wsema_){this.$val=this;if(arguments.length===0){this.state=new $Uint64(0,0);this.rsema=0;this.wsema=0;return;}this.state=state_;this.rsema=rsema_;this.wsema=wsema_;});Q=$pkg.FD=$newType(0,$kindStruct,"poll.FD",true,"internal/poll",true,function(fdmu_,Sysfd_,pd_,iovecs_,csema_,isBlocking_,IsStream_,ZeroReadIsEOF_,isFile_){this.$val=this;if(arguments.length===0){this.fdmu=new P.ptr(new $Uint64(0,0),0,0);this.Sysfd=0;this.pd=new G.ptr(false);this.iovecs=AS.nil;this.csema=0;this.isBlocking=0;this.IsStream=false;this.ZeroReadIsEOF=false;this.isFile=false;return;}this.fdmu=fdmu_;this.Sysfd=Sysfd_;this.pd=pd_;this.iovecs=iovecs_;this.csema=csema_;this.isBlocking=isBlocking_;this.IsStream=IsStream_;this.ZeroReadIsEOF=ZeroReadIsEOF_;this.isFile=isFile_;});AG=$ptrType($Uint32);AH=$chanType($Bool,false,false);AI=$sliceType(AH);AJ=$ptrType($Uint64);AK=$ptrType($Int32);AM=$arrayType($Uint8,4);AR=$sliceType(C.Iovec);AS=$ptrType(AR);AT=$ptrType($Uint8);AU=$ptrType(Q);AV=$ptrType(G);AW=$ptrType(M);AX=$ptrType(P);AY=$sliceType($Uint8);AZ=$ptrType(C.Stat_t);BA=$funcType([$Uintptr],[],false);BB=$funcType([$Uintptr],[$Bool],false);BC=$ptrType(C.Linger);BD=$ptrType(C.IPMreqn);BE=$ptrType(C.IPMreq);BF=$ptrType(C.IPv6Mreq);BG=$sliceType(AY);BH=$ptrType(BG);G.ptr.prototype.init=function(c){var c,d;d=this;return $ifaceNil;};G.prototype.init=function(c){return this.$val.init(c);};G.ptr.prototype.close=function(){var c;c=this;};G.prototype.close=function(){return this.$val.close();};G.ptr.prototype.evict=function(){var c;c=this;c.closing=true;};G.prototype.evict=function(){return this.$val.evict();};G.ptr.prototype.prepare=function(c,d){var c,d,e;e=this;if(e.closing){return L(d);}return $ifaceNil;};G.prototype.prepare=function(c,d){return this.$val.prepare(c,d);};G.ptr.prototype.prepareRead=function(c){var c,d;d=this;return d.prepare(114,c);};G.prototype.prepareRead=function(c){return this.$val.prepareRead(c);};G.ptr.prototype.prepareWrite=function(c){var c,d;d=this;return d.prepare(119,c);};G.prototype.prepareWrite=function(c){return this.$val.prepareWrite(c);};G.ptr.prototype.wait=function(c,d){var c,d,e;e=this;if(e.closing){return L(d);}return $pkg.ErrTimeout;};G.prototype.wait=function(c,d){return this.$val.wait(c,d);};G.ptr.prototype.waitRead=function(c){var c,d;d=this;return d.wait(114,c);};G.prototype.waitRead=function(c){return this.$val.waitRead(c);};G.ptr.prototype.waitWrite=function(c){var c,d;d=this;return d.wait(119,c);};G.prototype.waitWrite=function(c){return this.$val.waitWrite(c);};G.ptr.prototype.pollable=function(){return true;};G.prototype.pollable=function(){return this.$val.pollable();};Q.ptr.prototype.SetDeadline=function(c){var c;return $ifaceNil;};Q.prototype.SetDeadline=function(c){return this.$val.SetDeadline(c);};Q.ptr.prototype.SetReadDeadline=function(c){var c;return $ifaceNil;};Q.prototype.SetReadDeadline=function(c){return this.$val.SetReadDeadline(c);};Q.ptr.prototype.SetWriteDeadline=function(c){var c;return $ifaceNil;};Q.prototype.SetWriteDeadline=function(c){return this.$val.SetWriteDeadline(c);};I=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(c.$get()===0){$s=1;continue;}$s=2;continue;case 1:d=new $Chan($Bool,0);e=c;(K||$throwRuntimeError("assignment to entry in nil map"))[AG.keyFor(e)]={k:e,v:$append((f=K[AG.keyFor(c)],f!==undefined?f.v:AI.nil),d)};g=$recv(d);$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}g[0];case 2:c.$set(c.$get()-(1)>>>0);$s=-1;return;}return;}if($f===undefined){$f={$blk:I};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};J=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c.$set(c.$get()+(1)>>>0);e=(d=K[AG.keyFor(c)],d!==undefined?d.v:AI.nil);if(e.$length===0){$s=-1;return;}f=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);e=$subslice(e,1);g=c;(K||$throwRuntimeError("assignment to entry in nil map"))[AG.keyFor(g)]={k:g,v:e};if(e.$length===0){delete K[AG.keyFor(c)];}$r=$send(f,true);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:J};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};L=function(c){var c;if(c){return $pkg.ErrFileClosing;}return $pkg.ErrNetClosing;};M.ptr.prototype.Error=function(){var c;c=this;return"i/o timeout";};M.prototype.Error=function(){return this.$val.Error();};M.ptr.prototype.Timeout=function(){var c;c=this;return true;};M.prototype.Timeout=function(){return this.$val.Timeout();};M.ptr.prototype.Temporary=function(){var c;c=this;return true;};M.prototype.Temporary=function(){return this.$val.Temporary();};N=function(c,d){var c,d,e,f,g,h,i;while(true){if(!(c.$get().$length>0)){break;}f=(new $Int64(0,(e=c.$get(),(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])).$length));if((f.$high>d.$high||(f.$high===d.$high&&f.$low>d.$low))){(h=c.$get(),(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0]=$subslice((g=c.$get(),(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0])),$flatten64(d))));return;}d=(i=f,new $Int64(d.$high-i.$high,d.$low-i.$low));c.$set($subslice((c.$get()),1));}};Q.ptr.prototype.Fsync=function(){var c,d,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=c.incref();if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return d;}$deferred.push([$methodVal(c,"decref"),[]]);$s=-1;return C.Fsync(c.Sysfd);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Fsync};}$f.c=c;$f.d=d;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Fsync=function(){return this.$val.Fsync();};O=function(c,d,e){var c,d,e,f,g,h;f=C.Syscall(72,((c>>>0)),((d>>>0)),((e>>>0)));g=f[0];h=f[2];if(!((h===0))){return[((g>>0)),new C.Errno((h))];}return[((g>>0)),$ifaceNil];};P.ptr.prototype.incref=function(){var c,d,e,f,g;c=this;while(true){d=D.LoadUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))));if(!((e=new $Uint64(d.$high&0,(d.$low&1)>>>0),(e.$high===0&&e.$low===0)))){return false;}f=new $Uint64(d.$high+0,d.$low+8);if((g=new $Uint64(f.$high&0,(f.$low&8388600)>>>0),(g.$high===0&&g.$low===0))){$panic(new $String("too many concurrent operations on a single file or socket (max 1048575)"));}if(D.CompareAndSwapUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))),d,f)){return true;}}};P.prototype.incref=function(){return this.$val.incref();};P.ptr.prototype.increfAndClose=function(){var c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;case 1:d=D.LoadUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))));if(!((e=new $Uint64(d.$high&0,(d.$low&1)>>>0),(e.$high===0&&e.$low===0)))){$s=-1;return false;}g=(f=new $Uint64(d.$high|0,(d.$low|1)>>>0),new $Uint64(f.$high+0,f.$low+8));if((h=new $Uint64(g.$high&0,(g.$low&8388600)>>>0),(h.$high===0&&h.$low===0))){$panic(new $String("too many concurrent operations on a single file or socket (max 1048575)"));}g=(i=new $Uint64(2147483647,4286578688),new $Uint64(g.$high&~i.$high,(g.$low&~i.$low)>>>0));if(D.CompareAndSwapUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))),d,g)){$s=3;continue;}$s=4;continue;case 3:case 5:if(!(!((j=new $Uint64(d.$high&2047,(d.$low&4286578688)>>>0),(j.$high===0&&j.$low===0))))){$s=6;continue;}d=(k=new $Uint64(0,8388608),new $Uint64(d.$high-k.$high,d.$low-k.$low));$r=J((c.$ptr_rsema||(c.$ptr_rsema=new AG(function(){return this.$target.rsema;},function($v){this.$target.rsema=$v;},c))));$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=5;continue;case 6:case 8:if(!(!((l=new $Uint64(d.$high&2147481600,(d.$low&0)>>>0),(l.$high===0&&l.$low===0))))){$s=9;continue;}d=(m=new $Uint64(2048,0),new $Uint64(d.$high-m.$high,d.$low-m.$low));$r=J((c.$ptr_wsema||(c.$ptr_wsema=new AG(function(){return this.$target.wsema;},function($v){this.$target.wsema=$v;},c))));$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=8;continue;case 9:$s=-1;return true;case 4:$s=1;continue;case 2:$s=-1;return false;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.increfAndClose};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.increfAndClose=function(){return this.$val.increfAndClose();};P.ptr.prototype.decref=function(){var c,d,e,f,g;c=this;while(true){d=D.LoadUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))));if((e=new $Uint64(d.$high&0,(d.$low&8388600)>>>0),(e.$high===0&&e.$low===0))){$panic(new $String("inconsistent poll.fdMutex"));}f=new $Uint64(d.$high-0,d.$low-8);if(D.CompareAndSwapUint64((c.$ptr_state||(c.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},c))),d,f)){return(g=new $Uint64(f.$high&0,(f.$low&8388601)>>>0),(g.$high===0&&g.$low===1));}}};P.prototype.decref=function(){return this.$val.decref();};P.ptr.prototype.rwlock=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=new $Uint64(0,0);f=new $Uint64(0,0);g=new $Uint64(0,0);h=e;i=f;j=g;k=AG.nil;if(c){h=new $Uint64(0,2);i=new $Uint64(0,8388608);j=new $Uint64(2047,4286578688);k=(d.$ptr_rsema||(d.$ptr_rsema=new AG(function(){return this.$target.rsema;},function($v){this.$target.rsema=$v;},d)));}else{h=new $Uint64(0,4);i=new $Uint64(2048,0);j=new $Uint64(2147481600,0);k=(d.$ptr_wsema||(d.$ptr_wsema=new AG(function(){return this.$target.wsema;},function($v){this.$target.wsema=$v;},d)));}case 1:l=D.LoadUint64((d.$ptr_state||(d.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},d))));if(!((m=new $Uint64(l.$high&0,(l.$low&1)>>>0),(m.$high===0&&m.$low===0)))){$s=-1;return false;}n=new $Uint64(0,0);if((o=new $Uint64(l.$high&h.$high,(l.$low&h.$low)>>>0),(o.$high===0&&o.$low===0))){n=(p=new $Uint64(l.$high|h.$high,(l.$low|h.$low)>>>0),new $Uint64(p.$high+0,p.$low+8));if((q=new $Uint64(n.$high&0,(n.$low&8388600)>>>0),(q.$high===0&&q.$low===0))){$panic(new $String("too many concurrent operations on a single file or socket (max 1048575)"));}}else{n=new $Uint64(l.$high+i.$high,l.$low+i.$low);if((r=new $Uint64(n.$high&j.$high,(n.$low&j.$low)>>>0),(r.$high===0&&r.$low===0))){$panic(new $String("too many concurrent operations on a single file or socket (max 1048575)"));}}if(D.CompareAndSwapUint64((d.$ptr_state||(d.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},d))),l,n)){$s=3;continue;}$s=4;continue;case 3:if((s=new $Uint64(l.$high&h.$high,(l.$low&h.$low)>>>0),(s.$high===0&&s.$low===0))){$s=-1;return true;}$r=I(k);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 4:$s=1;continue;case 2:$s=-1;return false;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.rwlock};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.rwlock=function(c){return this.$val.rwlock(c);};P.ptr.prototype.rwunlock=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=new $Uint64(0,0);f=new $Uint64(0,0);g=new $Uint64(0,0);h=e;i=f;j=g;k=AG.nil;if(c){h=new $Uint64(0,2);i=new $Uint64(0,8388608);j=new $Uint64(2047,4286578688);k=(d.$ptr_rsema||(d.$ptr_rsema=new AG(function(){return this.$target.rsema;},function($v){this.$target.rsema=$v;},d)));}else{h=new $Uint64(0,4);i=new $Uint64(2048,0);j=new $Uint64(2147481600,0);k=(d.$ptr_wsema||(d.$ptr_wsema=new AG(function(){return this.$target.wsema;},function($v){this.$target.wsema=$v;},d)));}case 1:l=D.LoadUint64((d.$ptr_state||(d.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},d))));if((m=new $Uint64(l.$high&h.$high,(l.$low&h.$low)>>>0),(m.$high===0&&m.$low===0))||(n=new $Uint64(l.$high&0,(l.$low&8388600)>>>0),(n.$high===0&&n.$low===0))){$panic(new $String("inconsistent poll.fdMutex"));}p=(o=new $Uint64(l.$high&~h.$high,(l.$low&~h.$low)>>>0),new $Uint64(o.$high-0,o.$low-8));if(!((q=new $Uint64(l.$high&j.$high,(l.$low&j.$low)>>>0),(q.$high===0&&q.$low===0)))){p=(r=i,new $Uint64(p.$high-r.$high,p.$low-r.$low));}if(D.CompareAndSwapUint64((d.$ptr_state||(d.$ptr_state=new AJ(function(){return this.$target.state;},function($v){this.$target.state=$v;},d))),l,p)){$s=3;continue;}$s=4;continue;case 3:if(!((s=new $Uint64(l.$high&j.$high,(l.$low&j.$low)>>>0),(s.$high===0&&s.$low===0)))){$s=5;continue;}$s=6;continue;case 5:$r=J(k);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 6:$s=-1;return(t=new $Uint64(p.$high&0,(p.$low&8388601)>>>0),(t.$high===0&&t.$low===1));case 4:$s=1;continue;case 2:$s=-1;return false;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.rwunlock};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.rwunlock=function(c){return this.$val.rwunlock(c);};Q.ptr.prototype.incref=function(){var c;c=this;if(!c.fdmu.incref()){return L(c.isFile);}return $ifaceNil;};Q.prototype.incref=function(){return this.$val.incref();};Q.ptr.prototype.decref=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(c.fdmu.decref()){$s=1;continue;}$s=2;continue;case 1:d=c.destroy();$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;case 2:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.decref};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.decref=function(){return this.$val.decref();};Q.ptr.prototype.readLock=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.fdmu.rwlock(true);$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}if(!d){$s=1;continue;}$s=2;continue;case 1:$s=-1;return L(c.isFile);case 2:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.readLock};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.readLock=function(){return this.$val.readLock();};Q.ptr.prototype.readUnlock=function(){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.fdmu.rwunlock(true);$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}if(d){$s=1;continue;}$s=2;continue;case 1:e=c.destroy();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.readUnlock};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.readUnlock=function(){return this.$val.readUnlock();};Q.ptr.prototype.writeLock=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.fdmu.rwlock(false);$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}if(!d){$s=1;continue;}$s=2;continue;case 1:$s=-1;return L(c.isFile);case 2:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.writeLock};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.writeLock=function(){return this.$val.writeLock();};Q.ptr.prototype.writeUnlock=function(){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.fdmu.rwunlock(false);$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}if(d){$s=1;continue;}$s=2;continue;case 1:e=c.destroy();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.writeUnlock};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.writeUnlock=function(){return this.$val.writeUnlock();};Q.ptr.prototype.eofError=function(c,d){var c,d,e;e=this;if((c===0)&&$interfaceIsEqual(d,$ifaceNil)&&e.ZeroReadIsEOF){return E.EOF;}return d;};Q.prototype.eofError=function(c,d){return this.$val.eofError(c,d);};Q.ptr.prototype.Fchmod=function(c){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}$deferred.push([$methodVal(d,"decref"),[]]);$s=-1;return C.Fchmod(d.Sysfd,c);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Fchmod};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Fchmod=function(c){return this.$val.Fchmod(c);};Q.ptr.prototype.Fchown=function(c,d){var c,d,e,f,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=this;f=e.incref();if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return f;}$deferred.push([$methodVal(e,"decref"),[]]);$s=-1;return C.Fchown(e.Sysfd,c,d);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Fchown};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Fchown=function(c,d){return this.$val.Fchown(c,d);};Q.ptr.prototype.Ftruncate=function(c){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}$deferred.push([$methodVal(d,"decref"),[]]);$s=-1;return C.Ftruncate(d.Sysfd,c);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Ftruncate};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Ftruncate=function(c){return this.$val.Ftruncate(c);};Q.ptr.prototype.Init=function(c,d){var c,d,e,f;e=this;if(c==="file"){e.isFile=true;}if(!d){e.isBlocking=1;return $ifaceNil;}f=e.pd.init(e);if(!($interfaceIsEqual(f,$ifaceNil))){e.isBlocking=1;}return f;};Q.prototype.Init=function(c,d){return this.$val.Init(c,d);};Q.ptr.prototype.destroy=function(){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;c.pd.close();d=$pkg.CloseFunc(c.Sysfd);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;c.Sysfd=-1;$r=J((c.$ptr_csema||(c.$ptr_csema=new AG(function(){return this.$target.csema;},function($v){this.$target.csema=$v;},c))));$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.destroy};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.destroy=function(){return this.$val.destroy();};Q.ptr.prototype.Close=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.fdmu.increfAndClose();$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}if(!d){$s=1;continue;}$s=2;continue;case 1:$s=-1;return L(c.isFile);case 2:c.pd.evict();e=c.decref();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(c.isBlocking===0){$s=5;continue;}$s=6;continue;case 5:$r=I((c.$ptr_csema||(c.$ptr_csema=new AG(function(){return this.$target.csema;},function($v){this.$target.csema=$v;},c))));$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 6:$s=-1;return f;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.Close};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.Close=function(){return this.$val.Close();};Q.ptr.prototype.Shutdown=function(c){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}$deferred.push([$methodVal(d,"decref"),[]]);$s=-1;return C.Shutdown(d.Sysfd,c);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Shutdown};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Shutdown=function(c){return this.$val.Shutdown(c);};Q.ptr.prototype.SetBlocking=function(){var c,d,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=c.incref();if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return d;}$deferred.push([$methodVal(c,"decref"),[]]);D.StoreUint32((c.$ptr_isBlocking||(c.$ptr_isBlocking=new AG(function(){return this.$target.isBlocking;},function($v){this.$target.isBlocking=$v;},c))),1);$s=-1;return C.SetNonblock(c.Sysfd,false);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetBlocking};}$f.c=c;$f.d=d;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetBlocking=function(){return this.$val.SetBlocking();};Q.ptr.prototype.Read=function(c){var c,d,e,f,g,h,i,j,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.readLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,f];}$deferred.push([$methodVal(d,"readUnlock"),[]]);if(c.$length===0){$s=-1;return[0,$ifaceNil];}g=d.pd.prepareRead(d.isFile);if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[0,g];}if(d.IsStream&&c.$length>1073741824){c=$subslice(c,0,1073741824);}while(true){h=C.Read(d.Sysfd,c);i=h[0];j=h[1];if(!($interfaceIsEqual(j,$ifaceNil))){i=0;if($interfaceIsEqual(j,new C.Errno(11))&&d.pd.pollable()){j=d.pd.waitRead(d.isFile);if($interfaceIsEqual(j,$ifaceNil)){continue;}}if(false&&$interfaceIsEqual(j,new C.Errno(4))){continue;}}j=d.eofError(i,j);$s=-1;return[i,j];}$s=-1;return[0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Read};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Read=function(c){return this.$val.Read(c);};Q.ptr.prototype.Pread=function(c,d){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=e.incref();if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,f];}if(e.IsStream&&c.$length>1073741824){c=$subslice(c,0,1073741824);}g=C.Pread(e.Sysfd,c,d);h=g[0];i=g[1];if(!($interfaceIsEqual(i,$ifaceNil))){h=0;}j=e.decref();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}j;i=e.eofError(h,i);$s=-1;return[h,i];}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.Pread};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.Pread=function(c,d){return this.$val.Pread(c,d);};Q.ptr.prototype.ReadFrom=function(c){var c,d,e,f,g,h,i,j,k,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.readLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,$ifaceNil,f];}$deferred.push([$methodVal(d,"readUnlock"),[]]);g=d.pd.prepareRead(d.isFile);if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[0,$ifaceNil,g];}while(true){h=C.Recvfrom(d.Sysfd,c,0);i=h[0];j=h[1];k=h[2];if(!($interfaceIsEqual(k,$ifaceNil))){i=0;if($interfaceIsEqual(k,new C.Errno(11))&&d.pd.pollable()){k=d.pd.waitRead(d.isFile);if($interfaceIsEqual(k,$ifaceNil)){continue;}}}k=d.eofError(i,k);$s=-1;return[i,j,k];}$s=-1;return[0,$ifaceNil,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.ReadFrom};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.ReadFrom=function(c){return this.$val.ReadFrom(c);};Q.ptr.prototype.ReadMsg=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=this;f=e.readLock();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[0,0,0,$ifaceNil,g];}$deferred.push([$methodVal(e,"readUnlock"),[]]);h=e.pd.prepareRead(e.isFile);if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[0,0,0,$ifaceNil,h];}while(true){i=C.Recvmsg(e.Sysfd,c,d,0);j=i[0];k=i[1];l=i[2];m=i[3];n=i[4];if(!($interfaceIsEqual(n,$ifaceNil))){if($interfaceIsEqual(n,new C.Errno(11))&&e.pd.pollable()){n=e.pd.waitRead(e.isFile);if($interfaceIsEqual(n,$ifaceNil)){continue;}}}n=e.eofError(j,n);$s=-1;return[j,k,l,m,n];}$s=-1;return[0,0,0,$ifaceNil,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,0,0,$ifaceNil,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.ReadMsg};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.ReadMsg=function(c,d){return this.$val.ReadMsg(c,d);};Q.ptr.prototype.Write=function(c){var c,d,e,f,g,h,i,j,k,l,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.writeLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,f];}$deferred.push([$methodVal(d,"writeUnlock"),[]]);g=d.pd.prepareWrite(d.isFile);if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[0,g];}h=0;while(true){i=c.$length;if(d.IsStream&&(i-h>>0)>1073741824){i=h+1073741824>>0;}j=C.Write(d.Sysfd,$subslice(c,h,i));k=j[0];l=j[1];if(k>0){h=h+(k)>>0;}if(h===c.$length){$s=-1;return[h,l];}if($interfaceIsEqual(l,new C.Errno(11))&&d.pd.pollable()){l=d.pd.waitWrite(d.isFile);if($interfaceIsEqual(l,$ifaceNil)){continue;}}if(!($interfaceIsEqual(l,$ifaceNil))){$s=-1;return[h,l];}if(k===0){$s=-1;return[h,E.ErrUnexpectedEOF];}}$s=-1;return[0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Write};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Write=function(c){return this.$val.Write(c);};Q.ptr.prototype.Pwrite=function(c,d){var c,d,e,f,g,h,i,j,k,l,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=this;f=e.incref();if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,f];}$deferred.push([$methodVal(e,"decref"),[]]);g=0;while(true){h=c.$length;if(e.IsStream&&(h-g>>0)>1073741824){h=g+1073741824>>0;}i=C.Pwrite(e.Sysfd,$subslice(c,g,h),(j=(new $Int64(0,g)),new $Int64(d.$high+j.$high,d.$low+j.$low)));k=i[0];l=i[1];if(k>0){g=g+(k)>>0;}if(g===c.$length){$s=-1;return[g,l];}if(!($interfaceIsEqual(l,$ifaceNil))){$s=-1;return[g,l];}if(k===0){$s=-1;return[g,E.ErrUnexpectedEOF];}}$s=-1;return[0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Pwrite};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Pwrite=function(c,d){return this.$val.Pwrite(c,d);};Q.ptr.prototype.WriteTo=function(c,d){var c,d,e,f,g,h,i,j,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=this;f=e.writeLock();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[0,g];}$deferred.push([$methodVal(e,"writeUnlock"),[]]);h=e.pd.prepareWrite(e.isFile);if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[0,h];}case 2:i=C.Sendto(e.Sysfd,c,0,d);$s=4;case 4:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;if($interfaceIsEqual(j,new C.Errno(11))&&e.pd.pollable()){j=e.pd.waitWrite(e.isFile);if($interfaceIsEqual(j,$ifaceNil)){$s=2;continue;}}if(!($interfaceIsEqual(j,$ifaceNil))){$s=-1;return[0,j];}$s=-1;return[c.$length,$ifaceNil];$s=2;continue;case 3:$s=-1;return[0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.WriteTo};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.WriteTo=function(c,d){return this.$val.WriteTo(c,d);};Q.ptr.prototype.WriteMsg=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.writeLock();$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[0,0,h];}$deferred.push([$methodVal(f,"writeUnlock"),[]]);i=f.pd.prepareWrite(f.isFile);if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[0,0,i];}case 2:k=C.SendmsgN(f.Sysfd,c,d,e,0);$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[0];m=j[1];if($interfaceIsEqual(m,new C.Errno(11))&&f.pd.pollable()){m=f.pd.waitWrite(f.isFile);if($interfaceIsEqual(m,$ifaceNil)){$s=2;continue;}}if(!($interfaceIsEqual(m,$ifaceNil))){$s=-1;return[l,0,m];}$s=-1;return[l,d.$length,m];$s=2;continue;case 3:$s=-1;return[0,0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.WriteMsg};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.WriteMsg=function(c,d,e){return this.$val.WriteMsg(c,d,e);};Q.ptr.prototype.Accept=function(){var c,d,e,f,g,h,i,j,k,l,m,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=c.readLock();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[-1,$ifaceNil,"",e];}$deferred.push([$methodVal(c,"readUnlock"),[]]);f=c.pd.prepareRead(c.isFile);if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[-1,$ifaceNil,"",f];}case 2:h=W(c.Sysfd);$s=4;case 4:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;i=g[0];j=g[1];k=g[2];l=g[3];if($interfaceIsEqual(l,$ifaceNil)){$s=-1;return[i,j,"",l];}m=l;if($interfaceIsEqual(m,new C.Errno((11)))){if(c.pd.pollable()){l=c.pd.waitRead(c.isFile);if($interfaceIsEqual(l,$ifaceNil)){$s=2;continue;}}}else if($interfaceIsEqual(m,new C.Errno((103)))){$s=2;continue;}$s=-1;return[-1,$ifaceNil,k,l];$s=2;continue;case 3:$s=-1;return[0,$ifaceNil,"",$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil,"",$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Accept};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Accept=function(){return this.$val.Accept();};Q.ptr.prototype.Seek=function(c,d){var c,d,e,f,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=this;f=e.incref();if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[new $Int64(0,0),f];}$deferred.push([$methodVal(e,"decref"),[]]);$s=-1;return C.Seek(e.Sysfd,c,d);}return;}}catch(err){$err=err;$s=-1;return[new $Int64(0,0),$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Seek};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Seek=function(c,d){return this.$val.Seek(c,d);};Q.ptr.prototype.ReadDirent=function(c){var c,d,e,f,g,h,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[0,e];}$deferred.push([$methodVal(d,"decref"),[]]);while(true){f=C.ReadDirent(d.Sysfd,c);g=f[0];h=f[1];if(!($interfaceIsEqual(h,$ifaceNil))){g=0;if($interfaceIsEqual(h,new C.Errno(11))&&d.pd.pollable()){h=d.pd.waitRead(d.isFile);if($interfaceIsEqual(h,$ifaceNil)){continue;}}}$s=-1;return[g,h];}$s=-1;return[0,$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.ReadDirent};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.ReadDirent=function(c){return this.$val.ReadDirent(c);};Q.ptr.prototype.Fchdir=function(){var c,d,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=c.incref();if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return d;}$deferred.push([$methodVal(c,"decref"),[]]);$s=-1;return C.Fchdir(c.Sysfd);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Fchdir};}$f.c=c;$f.d=d;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Fchdir=function(){return this.$val.Fchdir();};Q.ptr.prototype.Fstat=function(c){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}$deferred.push([$methodVal(d,"decref"),[]]);$s=-1;return C.Fstat(d.Sysfd,c);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Fstat};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Fstat=function(c){return this.$val.Fstat(c);};S=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(D.LoadInt32((AE||(AE=new AK(function(){return R;},function($v){R=$v;}))))===1){d=O(c,1030,0);e=d[0];f=d[1];if($interfaceIsEqual(f,$ifaceNil)){$s=-1;return[e,"",$ifaceNil];}g=$assertType(f,C.Errno);if((g===(22))||(g===(38))){D.StoreInt32((AE||(AE=new AK(function(){return R;},function($v){R=$v;}))),0);}else{$s=-1;return[-1,"fcntl",f];}}h=T(c);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:S};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};$pkg.DupCloseOnExec=S;T=function(c){var c,d,e,f,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);$r=C.ForkLock.RLock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$deferred.push([$methodVal(C.ForkLock,"RUnlock"),[]]);d=C.Dup(c);e=d[0];f=d[1];if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[-1,"dup",f];}C.CloseOnExec(e);$s=-1;return[e,"",$ifaceNil];}return;}}catch(err){$err=err;$s=-1;return[0,"",$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:T};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.ptr.prototype.Dup=function(){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=c.incref();if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return[-1,"",d];}$deferred.push([$methodVal(c,"decref"),[]]);e=S(c.Sysfd);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}}catch(err){$err=err;$s=-1;return[0,"",$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Dup};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Dup=function(){return this.$val.Dup();};Q.ptr.prototype.WaitWrite=function(){var c;c=this;return c.pd.waitWrite(c.isFile);};Q.prototype.WaitWrite=function(){return this.$val.WaitWrite();};Q.ptr.prototype.WriteOnce=function(c){var c,d,e,f,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.writeLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[0,f];}$deferred.push([$methodVal(d,"writeUnlock"),[]]);$s=-1;return C.Write(d.Sysfd,c);}return;}}catch(err){$err=err;$s=-1;return[0,$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.WriteOnce};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.WriteOnce=function(c){return this.$val.WriteOnce(c);};Q.ptr.prototype.RawControl=function(c){var c,d,e,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.incref();if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}$deferred.push([$methodVal(d,"decref"),[]]);$r=c(((d.Sysfd>>>0)));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return $ifaceNil;}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.RawControl};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.RawControl=function(c){return this.$val.RawControl(c);};Q.ptr.prototype.RawRead=function(c){var c,d,e,f,g,h,i,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.readLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return f;}$deferred.push([$methodVal(d,"readUnlock"),[]]);g=d.pd.prepareRead(d.isFile);if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}case 2:h=c(((d.Sysfd>>>0)));$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if(h){$s=4;continue;}$s=5;continue;case 4:$s=-1;return $ifaceNil;case 5:i=d.pd.waitRead(d.isFile);if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return i;}$s=2;continue;case 3:$s=-1;return $ifaceNil;}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.RawRead};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.RawRead=function(c){return this.$val.RawRead(c);};Q.ptr.prototype.RawWrite=function(c){var c,d,e,f,g,h,i,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=this;e=d.writeLock();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return f;}$deferred.push([$methodVal(d,"writeUnlock"),[]]);g=d.pd.prepareWrite(d.isFile);if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}case 2:h=c(((d.Sysfd>>>0)));$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if(h){$s=4;continue;}$s=5;continue;case 4:$s=-1;return $ifaceNil;case 5:i=d.pd.waitWrite(d.isFile);if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return i;}$s=2;continue;case 3:$s=-1;return $ifaceNil;}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.RawWrite};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.RawWrite=function(c){return this.$val.RawWrite(c);};U=function(c,d){var c,d,e,f,g;e=C.Syscall(20,((c>>>0)),(($sliceToArray(d))),((d.$length>>>0)));f=e[0];g=e[2];if(!((g===0))){return[f,new C.Errno((g))];}return[f,$ifaceNil];};W=function(c){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=$pkg.Accept4Func(c,526336);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;f=d[0];g=d[1];h=d[2];i=h;if($interfaceIsEqual(i,$ifaceNil)){$s=-1;return[f,g,"",$ifaceNil];}else if($interfaceIsEqual(i,new C.Errno((38)))){}else if($interfaceIsEqual(i,new C.Errno((22)))){}else if($interfaceIsEqual(i,new C.Errno((13)))){}else if($interfaceIsEqual(i,new C.Errno((14)))){}else{$s=-1;return[-1,g,"accept4",h];}k=$pkg.AcceptFunc(c);$s=2;case 2:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;f=j[0];g=j[1];h=j[2];if($interfaceIsEqual(h,$ifaceNil)){C.CloseOnExec(f);}if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[-1,$ifaceNil,"accept",h];}h=C.SetNonblock(f,true);if(!($interfaceIsEqual(h,$ifaceNil))){$s=3;continue;}$s=4;continue;case 3:l=$pkg.CloseFunc(f);$s=5;case 5:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;$s=-1;return[-1,$ifaceNil,"setnonblock",h];case 4:$s=-1;return[f,g,"",$ifaceNil];}return;}if($f===undefined){$f={$blk:W};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};Q.ptr.prototype.SetsockoptInt=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptInt(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptInt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptInt=function(c,d,e){return this.$val.SetsockoptInt(c,d,e);};Q.ptr.prototype.SetsockoptInet4Addr=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptInet4Addr(f.Sysfd,c,d,$clone(e,AM));}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptInet4Addr};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptInet4Addr=function(c,d,e){return this.$val.SetsockoptInet4Addr(c,d,e);};Q.ptr.prototype.SetsockoptLinger=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptLinger(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptLinger};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptLinger=function(c,d,e){return this.$val.SetsockoptLinger(c,d,e);};Q.ptr.prototype.SetsockoptIPMreqn=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptIPMreqn(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptIPMreqn};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptIPMreqn=function(c,d,e){return this.$val.SetsockoptIPMreqn(c,d,e);};Q.ptr.prototype.SetsockoptByte=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptByte(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptByte};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptByte=function(c,d,e){return this.$val.SetsockoptByte(c,d,e);};Q.ptr.prototype.SetsockoptIPMreq=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptIPMreq(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptIPMreq};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptIPMreq=function(c,d,e){return this.$val.SetsockoptIPMreq(c,d,e);};Q.ptr.prototype.SetsockoptIPv6Mreq=function(c,d,e){var c,d,e,f,g,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);f=this;g=f.incref();if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return g;}$deferred.push([$methodVal(f,"decref"),[]]);$s=-1;return C.SetsockoptIPv6Mreq(f.Sysfd,c,d,e);}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.SetsockoptIPv6Mreq};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.SetsockoptIPv6Mreq=function(c,d,e){return this.$val.SetsockoptIPv6Mreq(c,d,e);};Q.ptr.prototype.Writev=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);d=[d];e=this;f=e.writeLock();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[new $Int64(0,0),g];}$deferred.push([$methodVal(e,"writeUnlock"),[]]);h=e.pd.prepareWrite(e.isFile);if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[new $Int64(0,0),h];}d[0]=AR.nil;if(!(e.iovecs===AS.nil)){d[0]=e.iovecs.$get();}i=1024;j=new $Int64(0,0);k=$ifaceNil;case 2:if(!(c.$get().$length>0)){$s=3;continue;}d[0]=$subslice(d[0],0,0);l=c.$get();m=0;case 4:if(!(m=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]);if(n.$length===0){m++;$s=4;continue;}d[0]=$append(d[0],new C.Iovec.ptr($indexPtr(n.$array,n.$offset+0,AT),new $Uint64(0,0)));if(e.IsStream&&n.$length>1073741824){(o=d[0].$length-1>>0,((o<0||o>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+o])).SetLen(1073741824);$s=5;continue;}(p=d[0].$length-1>>0,((p<0||p>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+p])).SetLen(n.$length);if(d[0].$length===i){$s=5;continue;}m++;$s=4;continue;case 5:if(d[0].$length===0){$s=3;continue;}e.iovecs=(d.$ptr||(d.$ptr=new AS(function(){return this.$target[0];},function($v){this.$target[0]=$v;},d)));q=0;r=U(e.Sysfd,d[0]);q=r[0];k=r[1];if(q===4294967295){q=0;}$r=$pkg.TestHookDidWritev(((q>>0)));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}j=(s=(new $Int64(0,q.constructor===Number?q:1)),new $Int64(j.$high+s.$high,j.$low+s.$low));N(c,(new $Int64(0,q.constructor===Number?q:1)));if(!($interfaceIsEqual(k,$ifaceNil))){if($assertType(k,C.Errno)===11){k=e.pd.waitWrite(e.isFile);if($interfaceIsEqual(k,$ifaceNil)){$s=2;continue;}}$s=3;continue;}if((j.$high===0&&j.$low===0)){k=E.ErrUnexpectedEOF;$s=3;continue;}$s=2;continue;case 3:$s=-1;return[j,k];}return;}}catch(err){$err=err;$s=-1;return[new $Int64(0,0),$ifaceNil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.Writev};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.Writev=function(c){return this.$val.Writev(c);};AV.methods=[{prop:"init",name:"init",pkg:"internal/poll",typ:$funcType([AU],[$error],false)},{prop:"close",name:"close",pkg:"internal/poll",typ:$funcType([],[],false)},{prop:"evict",name:"evict",pkg:"internal/poll",typ:$funcType([],[],false)},{prop:"prepare",name:"prepare",pkg:"internal/poll",typ:$funcType([$Int,$Bool],[$error],false)},{prop:"prepareRead",name:"prepareRead",pkg:"internal/poll",typ:$funcType([$Bool],[$error],false)},{prop:"prepareWrite",name:"prepareWrite",pkg:"internal/poll",typ:$funcType([$Bool],[$error],false)},{prop:"wait",name:"wait",pkg:"internal/poll",typ:$funcType([$Int,$Bool],[$error],false)},{prop:"waitRead",name:"waitRead",pkg:"internal/poll",typ:$funcType([$Bool],[$error],false)},{prop:"waitWrite",name:"waitWrite",pkg:"internal/poll",typ:$funcType([$Bool],[$error],false)},{prop:"waitCanceled",name:"waitCanceled",pkg:"internal/poll",typ:$funcType([$Int],[],false)},{prop:"pollable",name:"pollable",pkg:"internal/poll",typ:$funcType([],[$Bool],false)}];AW.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Timeout",name:"Timeout",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Temporary",name:"Temporary",pkg:"",typ:$funcType([],[$Bool],false)}];AX.methods=[{prop:"incref",name:"incref",pkg:"internal/poll",typ:$funcType([],[$Bool],false)},{prop:"increfAndClose",name:"increfAndClose",pkg:"internal/poll",typ:$funcType([],[$Bool],false)},{prop:"decref",name:"decref",pkg:"internal/poll",typ:$funcType([],[$Bool],false)},{prop:"rwlock",name:"rwlock",pkg:"internal/poll",typ:$funcType([$Bool],[$Bool],false)},{prop:"rwunlock",name:"rwunlock",pkg:"internal/poll",typ:$funcType([$Bool],[$Bool],false)}];AU.methods=[{prop:"SetDeadline",name:"SetDeadline",pkg:"",typ:$funcType([A.Time],[$error],false)},{prop:"SetReadDeadline",name:"SetReadDeadline",pkg:"",typ:$funcType([A.Time],[$error],false)},{prop:"SetWriteDeadline",name:"SetWriteDeadline",pkg:"",typ:$funcType([A.Time],[$error],false)},{prop:"Fsync",name:"Fsync",pkg:"",typ:$funcType([],[$error],false)},{prop:"incref",name:"incref",pkg:"internal/poll",typ:$funcType([],[$error],false)},{prop:"decref",name:"decref",pkg:"internal/poll",typ:$funcType([],[$error],false)},{prop:"readLock",name:"readLock",pkg:"internal/poll",typ:$funcType([],[$error],false)},{prop:"readUnlock",name:"readUnlock",pkg:"internal/poll",typ:$funcType([],[],false)},{prop:"writeLock",name:"writeLock",pkg:"internal/poll",typ:$funcType([],[$error],false)},{prop:"writeUnlock",name:"writeUnlock",pkg:"internal/poll",typ:$funcType([],[],false)},{prop:"eofError",name:"eofError",pkg:"internal/poll",typ:$funcType([$Int,$error],[$error],false)},{prop:"Fchmod",name:"Fchmod",pkg:"",typ:$funcType([$Uint32],[$error],false)},{prop:"Fchown",name:"Fchown",pkg:"",typ:$funcType([$Int,$Int],[$error],false)},{prop:"Ftruncate",name:"Ftruncate",pkg:"",typ:$funcType([$Int64],[$error],false)},{prop:"Init",name:"Init",pkg:"",typ:$funcType([$String,$Bool],[$error],false)},{prop:"destroy",name:"destroy",pkg:"internal/poll",typ:$funcType([],[$error],false)},{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)},{prop:"Shutdown",name:"Shutdown",pkg:"",typ:$funcType([$Int],[$error],false)},{prop:"SetBlocking",name:"SetBlocking",pkg:"",typ:$funcType([],[$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([AY],[$Int,$error],false)},{prop:"Pread",name:"Pread",pkg:"",typ:$funcType([AY,$Int64],[$Int,$error],false)},{prop:"ReadFrom",name:"ReadFrom",pkg:"",typ:$funcType([AY],[$Int,C.Sockaddr,$error],false)},{prop:"ReadMsg",name:"ReadMsg",pkg:"",typ:$funcType([AY,AY],[$Int,$Int,$Int,C.Sockaddr,$error],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([AY],[$Int,$error],false)},{prop:"Pwrite",name:"Pwrite",pkg:"",typ:$funcType([AY,$Int64],[$Int,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([AY,C.Sockaddr],[$Int,$error],false)},{prop:"WriteMsg",name:"WriteMsg",pkg:"",typ:$funcType([AY,AY,C.Sockaddr],[$Int,$Int,$error],false)},{prop:"Accept",name:"Accept",pkg:"",typ:$funcType([],[$Int,C.Sockaddr,$String,$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"ReadDirent",name:"ReadDirent",pkg:"",typ:$funcType([AY],[$Int,$error],false)},{prop:"Fchdir",name:"Fchdir",pkg:"",typ:$funcType([],[$error],false)},{prop:"Fstat",name:"Fstat",pkg:"",typ:$funcType([AZ],[$error],false)},{prop:"Dup",name:"Dup",pkg:"",typ:$funcType([],[$Int,$String,$error],false)},{prop:"WaitWrite",name:"WaitWrite",pkg:"",typ:$funcType([],[$error],false)},{prop:"WriteOnce",name:"WriteOnce",pkg:"",typ:$funcType([AY],[$Int,$error],false)},{prop:"RawControl",name:"RawControl",pkg:"",typ:$funcType([BA],[$error],false)},{prop:"RawRead",name:"RawRead",pkg:"",typ:$funcType([BB],[$error],false)},{prop:"RawWrite",name:"RawWrite",pkg:"",typ:$funcType([BB],[$error],false)},{prop:"SetsockoptInt",name:"SetsockoptInt",pkg:"",typ:$funcType([$Int,$Int,$Int],[$error],false)},{prop:"SetsockoptInet4Addr",name:"SetsockoptInet4Addr",pkg:"",typ:$funcType([$Int,$Int,AM],[$error],false)},{prop:"SetsockoptLinger",name:"SetsockoptLinger",pkg:"",typ:$funcType([$Int,$Int,BC],[$error],false)},{prop:"SetsockoptIPMreqn",name:"SetsockoptIPMreqn",pkg:"",typ:$funcType([$Int,$Int,BD],[$error],false)},{prop:"SetsockoptByte",name:"SetsockoptByte",pkg:"",typ:$funcType([$Int,$Int,$Uint8],[$error],false)},{prop:"SetsockoptIPMreq",name:"SetsockoptIPMreq",pkg:"",typ:$funcType([$Int,$Int,BE],[$error],false)},{prop:"SetsockoptIPv6Mreq",name:"SetsockoptIPv6Mreq",pkg:"",typ:$funcType([$Int,$Int,BF],[$error],false)},{prop:"Writev",name:"Writev",pkg:"",typ:$funcType([BH],[$Int64,$error],false)}];G.init("internal/poll",[{prop:"closing",name:"closing",embedded:false,exported:false,typ:$Bool,tag:""}]);M.init("",[]);P.init("internal/poll",[{prop:"state",name:"state",embedded:false,exported:false,typ:$Uint64,tag:""},{prop:"rsema",name:"rsema",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"wsema",name:"wsema",embedded:false,exported:false,typ:$Uint32,tag:""}]);Q.init("internal/poll",[{prop:"fdmu",name:"fdmu",embedded:false,exported:false,typ:P,tag:""},{prop:"Sysfd",name:"Sysfd",embedded:false,exported:true,typ:$Int,tag:""},{prop:"pd",name:"pd",embedded:false,exported:false,typ:G,tag:""},{prop:"iovecs",name:"iovecs",embedded:false,exported:false,typ:AS,tag:""},{prop:"csema",name:"csema",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"isBlocking",name:"isBlocking",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"IsStream",name:"IsStream",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"ZeroReadIsEOF",name:"ZeroReadIsEOF",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"isFile",name:"isFile",embedded:false,exported:false,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}K={};$pkg.ErrNetClosing=B.New("use of closed network connection");$pkg.ErrFileClosing=B.New("use of closed file");$pkg.ErrNoDeadline=B.New("file type does not support deadline");$pkg.ErrTimeout=new M.ptr();$pkg.TestHookDidWritev=(function(c){var c;});R=1;$pkg.Accept4Func=C.Accept4;$pkg.CloseFunc=C.Close;$pkg.AcceptFunc=C.Accept;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/syscall/unix"]=(function(){var $pkg={},$init,B,A,C;B=$packages["sync/atomic"];A=$packages["syscall"];C=function(b){var b,c,d,e,f;c=false;d=$ifaceNil;e=false;f=$ifaceNil;c=e;d=f;return[c,d];};$pkg.IsNonblock=C;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["internal/testlog"]=(function(){var $pkg={},$init,A,B,I,C,E,H;A=$packages["sync/atomic"];B=$pkg.Interface=$newType(8,$kindInterface,"testlog.Interface",true,"internal/testlog",true,null);I=$ptrType(B);E=function(){var a;a=C.Load();if($interfaceIsEqual(a,$ifaceNil)){return $ifaceNil;}return $assertType(a,I).$get();};$pkg.Logger=E;H=function(a){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=E();if(!($interfaceIsEqual(b,$ifaceNil))){$s=1;continue;}$s=2;continue;case 1:$r=b.Stat(a);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:H};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Stat=H;B.init([{prop:"Chdir",name:"Chdir",pkg:"",typ:$funcType([$String],[],false)},{prop:"Getenv",name:"Getenv",pkg:"",typ:$funcType([$String],[],false)},{prop:"Open",name:"Open",pkg:"",typ:$funcType([$String],[],false)},{prop:"Stat",name:"Stat",pkg:"",typ:$funcType([$String],[],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}C=new A.Value.ptr($ifaceNil);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["os"]=(function(){var $pkg={},$init,A,B,G,K,F,C,D,H,I,E,J,P,AC,AD,AE,BC,BZ,DC,DT,DU,DV,DX,EA,EB,EC,ED,EE,EF,EG,EH,ET,EU,EV,EW,EX,FB,FG,FH,FL,FM,FN,AZ,BJ,L,M,N,AF,AH,AK,AL,AN,BQ,BS,CA,CC,CD,CR,CV,DB,DD,DI,DJ,DK,DN;A=$packages["errors"];B=$packages["github.com/gopherjs/gopherjs/js"];G=$packages["internal/poll"];K=$packages["internal/syscall/unix"];F=$packages["internal/testlog"];C=$packages["io"];D=$packages["runtime"];H=$packages["sync"];I=$packages["sync/atomic"];E=$packages["syscall"];J=$packages["time"];P=$pkg.dirInfo=$newType(0,$kindStruct,"os.dirInfo",true,"os",false,function(buf_,nbuf_,bufp_){this.$val=this;if(arguments.length===0){this.buf=EE.nil;this.nbuf=0;this.bufp=0;return;}this.buf=buf_;this.nbuf=nbuf_;this.bufp=bufp_;});AC=$pkg.timeout=$newType(8,$kindInterface,"os.timeout",true,"os",false,null);AD=$pkg.PathError=$newType(0,$kindStruct,"os.PathError",true,"os",true,function(Op_,Path_,Err_){this.$val=this;if(arguments.length===0){this.Op="";this.Path="";this.Err=$ifaceNil;return;}this.Op=Op_;this.Path=Path_;this.Err=Err_;});AE=$pkg.SyscallError=$newType(0,$kindStruct,"os.SyscallError",true,"os",true,function(Syscall_,Err_){this.$val=this;if(arguments.length===0){this.Syscall="";this.Err=$ifaceNil;return;}this.Syscall=Syscall_;this.Err=Err_;});BC=$pkg.LinkError=$newType(0,$kindStruct,"os.LinkError",true,"os",true,function(Op_,Old_,New_,Err_){this.$val=this;if(arguments.length===0){this.Op="";this.Old="";this.New="";this.Err=$ifaceNil;return;}this.Op=Op_;this.Old=Old_;this.New=New_;this.Err=Err_;});BZ=$pkg.file=$newType(0,$kindStruct,"os.file",true,"os",false,function(pfd_,name_,dirinfo_,nonblock_,stdoutOrErr_){this.$val=this;if(arguments.length===0){this.pfd=new G.FD.ptr(new G.fdMutex.ptr(new $Uint64(0,0),0,0),0,new G.pollDesc.ptr(false),EU.nil,0,0,false,false,false);this.name="";this.dirinfo=ED.nil;this.nonblock=false;this.stdoutOrErr=false;return;}this.pfd=pfd_;this.name=name_;this.dirinfo=dirinfo_;this.nonblock=nonblock_;this.stdoutOrErr=stdoutOrErr_;});DC=$pkg.rawConn=$newType(0,$kindStruct,"os.rawConn",true,"os",false,function(file_){this.$val=this;if(arguments.length===0){this.file=EB.nil;return;}this.file=file_;});DT=$pkg.File=$newType(0,$kindStruct,"os.File",true,"os",true,function(file_){this.$val=this;if(arguments.length===0){this.file=EW.nil;return;}this.file=file_;});DU=$pkg.FileInfo=$newType(8,$kindInterface,"os.FileInfo",true,"os",true,null);DV=$pkg.FileMode=$newType(4,$kindUint32,"os.FileMode",true,"os",true,null);DX=$pkg.fileStat=$newType(0,$kindStruct,"os.fileStat",true,"os",false,function(name_,size_,mode_,modTime_,sys_){this.$val=this;if(arguments.length===0){this.name="";this.size=new $Int64(0,0);this.mode=0;this.modTime=new J.Time.ptr(new $Uint64(0,0),new $Int64(0,0),FB.nil);this.sys=new E.Stat_t.ptr(new $Uint64(0,0),new $Uint64(0,0),new $Uint64(0,0),0,0,0,0,new $Uint64(0,0),new $Int64(0,0),new $Int64(0,0),new $Int64(0,0),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),EV.zero());return;}this.name=name_;this.size=size_;this.mode=mode_;this.modTime=modTime_;this.sys=sys_;});EA=$sliceType($String);EB=$ptrType(DT);EC=$sliceType(DU);ED=$ptrType(P);EE=$sliceType($Uint8);EF=$ptrType(AD);EG=$ptrType(BC);EH=$ptrType(AE);ET=$sliceType(E.Iovec);EU=$ptrType(ET);EV=$arrayType($Int64,3);EW=$ptrType(BZ);EX=$funcType([EW],[$error],false);FB=$ptrType(J.Location);FG=$arrayType($Uint8,32);FH=$ptrType(DX);FL=$funcType([$Uintptr],[],false);FM=$funcType([$Uintptr],[$Bool],false);FN=$ptrType(DC);L=function(){return $pkg.Args;};M=function(){var c,d,e;c=$global.process;if(!(c===undefined)){d=c.argv;$pkg.Args=$makeSlice(EA,($parseInt(d.length)-1>>0));e=0;while(true){if(!(e<($parseInt(d.length)-1>>0))){break;}((e<0||e>=$pkg.Args.$length)?($throwRuntimeError("index out of range"),undefined):$pkg.Args.$array[$pkg.Args.$offset+e]=$internalize(d[(e+1>>0)],$String));e=e+(1)>>0;}}if($pkg.Args.$length===0){$pkg.Args=new EA(["?"]);}};N=function(){};DT.ptr.prototype.Readdir=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(d===EB.nil){$s=-1;return[EC.nil,$pkg.ErrInvalid];}e=d.readdir(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Readdir};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Readdir=function(c){return this.$val.Readdir(c);};DT.ptr.prototype.Readdirnames=function(c){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=EA.nil;e=$ifaceNil;f=this;if(f===EB.nil){g=EA.nil;h=$pkg.ErrInvalid;d=g;e=h;$s=-1;return[d,e];}j=f.readdirnames(c);$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;d=i[0];e=i[1];$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Readdirnames};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Readdirnames=function(c){return this.$val.Readdirnames(c);};P.ptr.prototype.close=function(){var c;c=this;};P.prototype.close=function(){return this.$val.close();};DT.ptr.prototype.readdirnames=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=EA.nil;e=$ifaceNil;f=this;if(f.file.dirinfo===ED.nil){f.file.dirinfo=new P.ptr(EE.nil,0,0);f.file.dirinfo.buf=$makeSlice(EE,8192);}g=f.file.dirinfo;h=c;if(h<=0){h=100;c=-1;}d=$makeSlice(EA,0,h);case 1:if(!(!((c===0)))){$s=2;continue;}if(g.bufp>=g.nbuf){$s=3;continue;}$s=4;continue;case 3:g.bufp=0;i=$ifaceNil;k=f.file.pfd.ReadDirent(g.buf);$s=5;case 5:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;g.nbuf=j[0];i=j[1];D.KeepAlive(f);if(!($interfaceIsEqual(i,$ifaceNil))){l=d;m=AL("readdirent",i);d=l;e=m;$s=-1;return[d,e];}if(g.nbuf<=0){$s=2;continue;}case 4:n=0;o=0;p=n;q=o;r=E.ParseDirent($subslice(g.buf,g.bufp,g.nbuf),c,d);p=r[0];q=r[1];d=r[2];g.bufp=g.bufp+(p)>>0;c=c-(q)>>0;$s=1;continue;case 2:if(c>=0&&(d.$length===0)){s=d;t=C.EOF;d=s;e=t;$s=-1;return[d,e];}u=d;v=$ifaceNil;d=u;e=v;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.readdirnames};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.readdirnames=function(c){return this.$val.readdirnames(c);};AD.ptr.prototype.Error=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.Err.Error();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return c.Op+" "+c.Path+": "+d;}return;}if($f===undefined){$f={$blk:AD.ptr.prototype.Error};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AD.prototype.Error=function(){return this.$val.Error();};AD.ptr.prototype.Timeout=function(){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=$assertType(c.Err,AC,true);e=d[0];f=d[1];if(!(f)){g=false;$s=1;continue s;}h=e.Timeout();$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;case 1:$s=-1;return g;}return;}if($f===undefined){$f={$blk:AD.ptr.prototype.Timeout};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AD.prototype.Timeout=function(){return this.$val.Timeout();};AE.ptr.prototype.Error=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.Err.Error();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return c.Syscall+": "+d;}return;}if($f===undefined){$f={$blk:AE.ptr.prototype.Error};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AE.prototype.Error=function(){return this.$val.Error();};AE.ptr.prototype.Timeout=function(){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=$assertType(c.Err,AC,true);e=d[0];f=d[1];if(!(f)){g=false;$s=1;continue s;}h=e.Timeout();$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;case 1:$s=-1;return g;}return;}if($f===undefined){$f={$blk:AE.ptr.prototype.Timeout};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AE.prototype.Timeout=function(){return this.$val.Timeout();};AF=function(c,d){var c,d;if($interfaceIsEqual(d,$ifaceNil)){return $ifaceNil;}return new AE.ptr(c,d);};$pkg.NewSyscallError=AF;AH=function(c){var c;return AN(c);};$pkg.IsNotExist=AH;AK=function(c){var c,d,e,f,g;d=c;if($assertType(d,EF,true)[1]){e=d.$val;return e.Err;}else if($assertType(d,EG,true)[1]){f=d.$val;return f.Err;}else if($assertType(d,EH,true)[1]){g=d.$val;return g.Err;}return c;};AL=function(c,d){var c,d,e,f;e=$assertType(d,E.Errno,true);f=e[1];if(f){d=AF(c,d);}return d;};AN=function(c){var c;c=AK(c);return $interfaceIsEqual(c,new E.Errno(2))||$interfaceIsEqual(c,$pkg.ErrNotExist);};DT.ptr.prototype.Name=function(){var c;c=this;return c.file.name;};DT.prototype.Name=function(){return this.$val.Name();};BC.ptr.prototype.Error=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.Err.Error();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return c.Op+" "+c.Old+" "+c.New+": "+d;}return;}if($f===undefined){$f={$blk:BC.ptr.prototype.Error};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};BC.prototype.Error=function(){return this.$val.Error();};DT.ptr.prototype.Read=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;g=f.checkValid("read");if(!($interfaceIsEqual(g,$ifaceNil))){h=0;i=g;d=h;e=i;$s=-1;return[d,e];}k=f.read(c);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;d=j[0];l=j[1];m=d;n=f.wrapErr("read",l);d=m;e=n;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Read};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Read=function(c){return this.$val.Read(c);};DT.ptr.prototype.ReadAt=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;h=g.checkValid("read");if(!($interfaceIsEqual(h,$ifaceNil))){i=0;j=h;e=i;f=j;$s=-1;return[e,f];}if((d.$high<0||(d.$high===0&&d.$low<0))){k=0;l=new AD.ptr("readat",g.file.name,A.New("negative offset"));e=k;f=l;$s=-1;return[e,f];}case 1:if(!(c.$length>0)){$s=2;continue;}n=g.pread(c,d);$s=3;case 3:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];p=m[1];if(!($interfaceIsEqual(p,$ifaceNil))){f=g.wrapErr("read",p);$s=2;continue;}e=e+(o)>>0;c=$subslice(c,o);d=(q=(new $Int64(0,o)),new $Int64(d.$high+q.$high,d.$low+q.$low));$s=1;continue;case 2:$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.ReadAt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.ReadAt=function(c,d){return this.$val.ReadAt(c,d);};DT.ptr.prototype.Write=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;g=f.checkValid("write");if(!($interfaceIsEqual(g,$ifaceNil))){h=0;i=g;d=h;e=i;$s=-1;return[d,e];}k=f.write(c);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;d=j[0];l=j[1];if(d<0){d=0;}if(!((d===c.$length))){e=C.ErrShortWrite;}CD(f,l);if(!($interfaceIsEqual(l,$ifaceNil))){e=f.wrapErr("write",l);}m=d;n=e;d=m;e=n;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Write};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Write=function(c){return this.$val.Write(c);};DT.ptr.prototype.WriteAt=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;h=g.checkValid("write");if(!($interfaceIsEqual(h,$ifaceNil))){i=0;j=h;e=i;f=j;$s=-1;return[e,f];}if((d.$high<0||(d.$high===0&&d.$low<0))){k=0;l=new AD.ptr("writeat",g.file.name,A.New("negative offset"));e=k;f=l;$s=-1;return[e,f];}case 1:if(!(c.$length>0)){$s=2;continue;}n=g.pwrite(c,d);$s=3;case 3:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];p=m[1];if(!($interfaceIsEqual(p,$ifaceNil))){f=g.wrapErr("write",p);$s=2;continue;}e=e+(o)>>0;c=$subslice(c,o);d=(q=(new $Int64(0,o)),new $Int64(d.$high+q.$high,d.$low+q.$low));$s=1;continue;case 2:$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.WriteAt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.WriteAt=function(c,d){return this.$val.WriteAt(c,d);};DT.ptr.prototype.Seek=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;h=g.checkValid("seek");if(!($interfaceIsEqual(h,$ifaceNil))){i=new $Int64(0,0);j=h;e=i;f=j;$s=-1;return[e,f];}l=g.seek(c,d);$s=1;case 1:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;m=k[0];n=k[1];if($interfaceIsEqual(n,$ifaceNil)&&!(g.file.dirinfo===ED.nil)&&!((m.$high===0&&m.$low===0))){n=new E.Errno(21);}if(!($interfaceIsEqual(n,$ifaceNil))){o=new $Int64(0,0);p=g.wrapErr("seek",n);e=o;f=p;$s=-1;return[e,f];}q=m;r=$ifaceNil;e=q;f=r;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Seek};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Seek=function(c,d){return this.$val.Seek(c,d);};DT.ptr.prototype.WriteString=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;h=f.Write((new EE($stringToBytes(c))));$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;d=g[0];e=g[1];$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.WriteString};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.WriteString=function(c){return this.$val.WriteString(c);};DT.ptr.prototype.wrapErr=function(c,d){var c,d,e;e=this;if($interfaceIsEqual(d,$ifaceNil)||$interfaceIsEqual(d,C.EOF)){return d;}if($interfaceIsEqual(d,G.ErrFileClosing)){d=$pkg.ErrClosed;}return new AD.ptr(c,e.file.name,d);};DT.prototype.wrapErr=function(c,d){return this.$val.wrapErr(c,d);};DT.ptr.prototype.Chmod=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.chmod(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Chmod};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Chmod=function(c){return this.$val.Chmod(c);};DT.ptr.prototype.SetDeadline=function(c){var c,d;d=this;return d.setDeadline($clone(c,J.Time));};DT.prototype.SetDeadline=function(c){return this.$val.SetDeadline(c);};DT.ptr.prototype.SetReadDeadline=function(c){var c,d;d=this;return d.setReadDeadline($clone(c,J.Time));};DT.prototype.SetReadDeadline=function(c){return this.$val.SetReadDeadline(c);};DT.ptr.prototype.SetWriteDeadline=function(c){var c,d;d=this;return d.setWriteDeadline($clone(c,J.Time));};DT.prototype.SetWriteDeadline=function(c){return this.$val.SetWriteDeadline(c);};DT.ptr.prototype.SyscallConn=function(){var c,d,e;c=this;d=c.checkValid("SyscallConn");if(!($interfaceIsEqual(d,$ifaceNil))){return[$ifaceNil,d];}e=DD(c);return[e[0],e[1]];};DT.prototype.SyscallConn=function(){return this.$val.SyscallConn();};BQ=function(){$throwRuntimeError("native function not implemented: os.sigpipe");};BS=function(c){var c,d;d=0;d=(d|(((new DV(c).Perm()>>>0))))>>>0;if(!((((c&8388608)>>>0)===0))){d=(d|(2048))>>>0;}if(!((((c&4194304)>>>0)===0))){d=(d|(1024))>>>0;}if(!((((c&1048576)>>>0)===0))){d=(d|(512))>>>0;}return d;};DT.ptr.prototype.chmod=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.checkValid("chmod");if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}f=d.file.pfd.Fchmod(BS(c));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return d.wrapErr("chmod",g);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.chmod};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.chmod=function(c){return this.$val.chmod(c);};DT.ptr.prototype.Chown=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=e.checkValid("chown");if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return f;}g=e.file.pfd.Fchown(c,d);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return e.wrapErr("chown",h);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Chown};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Chown=function(c,d){return this.$val.Chown(c,d);};DT.ptr.prototype.Truncate=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.checkValid("truncate");if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}f=d.file.pfd.Ftruncate(c);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return d.wrapErr("truncate",g);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Truncate};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Truncate=function(c){return this.$val.Truncate(c);};DT.ptr.prototype.Sync=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.checkValid("sync");if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return d;}e=c.file.pfd.Fsync();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return c.wrapErr("sync",f);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Sync};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Sync=function(){return this.$val.Sync();};DT.ptr.prototype.Chdir=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.checkValid("chdir");if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return d;}e=c.file.pfd.Fchdir();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return c.wrapErr("chdir",f);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Chdir};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Chdir=function(){return this.$val.Chdir();};DT.ptr.prototype.setDeadline=function(c){var c,d,e;d=this;e=d.checkValid("SetDeadline");if(!($interfaceIsEqual(e,$ifaceNil))){return e;}return d.file.pfd.SetDeadline($clone(c,J.Time));};DT.prototype.setDeadline=function(c){return this.$val.setDeadline(c);};DT.ptr.prototype.setReadDeadline=function(c){var c,d,e;d=this;e=d.checkValid("SetReadDeadline");if(!($interfaceIsEqual(e,$ifaceNil))){return e;}return d.file.pfd.SetReadDeadline($clone(c,J.Time));};DT.prototype.setReadDeadline=function(c){return this.$val.setReadDeadline(c);};DT.ptr.prototype.setWriteDeadline=function(c){var c,d,e;d=this;e=d.checkValid("SetWriteDeadline");if(!($interfaceIsEqual(e,$ifaceNil))){return e;}return d.file.pfd.SetWriteDeadline($clone(c,J.Time));};DT.prototype.setWriteDeadline=function(c){return this.$val.setWriteDeadline(c);};DT.ptr.prototype.checkValid=function(c){var c,d;d=this;if(d===EB.nil){return $pkg.ErrInvalid;}return $ifaceNil;};DT.prototype.checkValid=function(c){return this.$val.checkValid(c);};DT.ptr.prototype.Fd=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(c===EB.nil){$s=-1;return 4294967295;}if(c.file.nonblock){$s=1;continue;}$s=2;continue;case 1:d=c.file.pfd.SetBlocking();$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}d;case 2:$s=-1;return((c.file.pfd.Sysfd>>>0));}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Fd};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Fd=function(){return this.$val.Fd();};CA=function(c,d){var c,d,e,f,g,h;e=0;f=K.IsNonblock(((c>>0)));g=f[0];h=f[1];if($interfaceIsEqual(h,$ifaceNil)&&g){e=3;}return CC(c,d,e);};$pkg.NewFile=CA;CC=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n;f=((c>>0));if(f<0){return EB.nil;}g=new DT.ptr(new BZ.ptr(new G.FD.ptr(new G.fdMutex.ptr(new $Uint64(0,0),0,0),f,new G.pollDesc.ptr(false),EU.nil,0,0,true,true,false),d,ED.nil,false,(f===1)||(f===2)));h=(e===1)||(e===2)||(e===3);if(e===1){i=new E.Stat_t.ptr(new $Uint64(0,0),new $Uint64(0,0),new $Uint64(0,0),0,0,0,0,new $Uint64(0,0),new $Int64(0,0),new $Int64(0,0),new $Int64(0,0),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),EV.zero());j="linux";if(j===("freebsd")){h=false;}else if(j===("dragonfly")||j===("netbsd")||j===("openbsd")){k=E.Fstat(f,i);if($interfaceIsEqual(k,$ifaceNil)&&(((i.Mode&61440)>>>0)===32768)){h=false;}}else if(j===("darwin")){l=E.Fstat(f,i);if($interfaceIsEqual(l,$ifaceNil)&&((((i.Mode&61440)>>>0)===4096)||(((i.Mode&61440)>>>0)===32768))){h=false;}}}m=g.file.pfd.Init("file",h);if(!($interfaceIsEqual(m,$ifaceNil))){}else if(h){n=E.SetNonblock(f,true);if($interfaceIsEqual(n,$ifaceNil)){g.file.nonblock=true;}}D.SetFinalizer(g.file,new EX($methodExpr(EW,"close")));return g;};CD=function(c,d){var c,d;if($interfaceIsEqual(d,new E.Errno(32))&&c.file.stdoutOrErr){BQ();}};DT.ptr.prototype.Close=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(c===EB.nil){$s=-1;return $pkg.ErrInvalid;}d=c.file.close();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Close};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Close=function(){return this.$val.Close();};BZ.ptr.prototype.close=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(c===EW.nil){$s=-1;return new E.Errno(22);}if(!(c.dirinfo===ED.nil)){c.dirinfo.close();}d=$ifaceNil;e=c.pfd.Close();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){if($interfaceIsEqual(f,G.ErrFileClosing)){f=$pkg.ErrClosed;}d=new AD.ptr("close",c.name,f);}D.SetFinalizer(c,$ifaceNil);$s=-1;return d;}return;}if($f===undefined){$f={$blk:BZ.ptr.prototype.close};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};BZ.prototype.close=function(){return this.$val.close();};DT.ptr.prototype.read=function(c){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;h=f.file.pfd.Read(c);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;d=g[0];e=g[1];D.KeepAlive(f);i=d;j=e;d=i;e=j;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.read};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.read=function(c){return this.$val.read(c);};DT.ptr.prototype.pread=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;i=g.file.pfd.Pread(c,d);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;e=h[0];f=h[1];D.KeepAlive(g);j=e;k=f;e=j;f=k;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.pread};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.pread=function(c,d){return this.$val.pread(c,d);};DT.ptr.prototype.write=function(c){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;h=f.file.pfd.Write(c);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;d=g[0];e=g[1];D.KeepAlive(f);i=d;j=e;d=i;e=j;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.write};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.write=function(c){return this.$val.write(c);};DT.ptr.prototype.pwrite=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;i=g.file.pfd.Pwrite(c,d);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;e=h[0];f=h[1];D.KeepAlive(g);j=e;k=f;e=j;f=k;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.pwrite};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.pwrite=function(c,d){return this.$val.pwrite(c,d);};DT.ptr.prototype.seek=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;i=g.file.pfd.Seek(c,d);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;e=h[0];f=h[1];D.KeepAlive(g);j=e;k=f;e=j;f=k;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.seek};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.seek=function(c,d){return this.$val.seek(c,d);};DT.ptr.prototype.readdir=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=EC.nil;e=$ifaceNil;f=this;g=f.file.name;if(g===""){g=".";}i=f.Readdirnames(c);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=h[0];e=h[1];d=$makeSlice(EC,0,j.$length);k=j;l=0;case 2:if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);o=BJ(g+"/"+m);$s=4;case 4:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;p=n[0];q=n[1];if(AH(q)){l++;$s=2;continue;}if(!($interfaceIsEqual(q,$ifaceNil))){r=d;s=q;d=r;e=s;$s=-1;return[d,e];}d=$append(d,p);l++;$s=2;continue;case 3:if((d.$length===0)&&$interfaceIsEqual(e,$ifaceNil)&&c>0){e=C.EOF;}t=d;u=e;d=t;e=u;$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.readdir};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.readdir=function(c){return this.$val.readdir(c);};CR=function(c){var c,d;d=c.length-1>>0;while(true){if(!(d>0&&(c.charCodeAt(d)===47))){break;}c=$substring(c,0,d);d=d-(1)>>0;}d=d-(1)>>0;while(true){if(!(d>=0)){break;}if(c.charCodeAt(d)===47){c=$substring(c,(d+1>>0));break;}d=d-(1)>>0;}return c;};CV=function(){if(false){return;}$pkg.Args=L();};DB=function(c){var c;if(c===0){N();}E.Exit(c);};$pkg.Exit=DB;DC.ptr.prototype.Control=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.file.checkValid("SyscallConn.Control");if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}f=d.file.file.pfd.RawControl(c);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;D.KeepAlive(d.file);$s=-1;return g;}return;}if($f===undefined){$f={$blk:DC.ptr.prototype.Control};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DC.prototype.Control=function(c){return this.$val.Control(c);};DC.ptr.prototype.Read=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.file.checkValid("SyscallConn.Read");if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}f=d.file.file.pfd.RawRead(c);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;D.KeepAlive(d.file);$s=-1;return g;}return;}if($f===undefined){$f={$blk:DC.ptr.prototype.Read};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DC.prototype.Read=function(c){return this.$val.Read(c);};DC.ptr.prototype.Write=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.file.checkValid("SyscallConn.Write");if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return e;}f=d.file.file.pfd.RawWrite(c);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;D.KeepAlive(d.file);$s=-1;return g;}return;}if($f===undefined){$f={$blk:DC.ptr.prototype.Write};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DC.prototype.Write=function(c){return this.$val.Write(c);};DD=function(c){var c;return[new DC.ptr(c),$ifaceNil];};DI=function(c){var c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=F.Stat(c);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return DN(c);}return;}if($f===undefined){$f={$blk:DI};}$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Lstat=DI;DJ=function(c,d){var c,d,e;c.name=CR(d);c.size=c.sys.Size;J.Time.copy(c.modTime,DK($clone(c.sys.Mtim,E.Timespec)));c.mode=((((c.sys.Mode&511)>>>0)>>>0));e=(c.sys.Mode&61440)>>>0;if(e===(24576)){c.mode=(c.mode|(67108864))>>>0;}else if(e===(8192)){c.mode=(c.mode|(69206016))>>>0;}else if(e===(16384)){c.mode=(c.mode|(2147483648))>>>0;}else if(e===(4096)){c.mode=(c.mode|(33554432))>>>0;}else if(e===(40960)){c.mode=(c.mode|(134217728))>>>0;}else if(e===(32768)){}else if(e===(49152)){c.mode=(c.mode|(16777216))>>>0;}if(!((((c.sys.Mode&1024)>>>0)===0))){c.mode=(c.mode|(4194304))>>>0;}if(!((((c.sys.Mode&2048)>>>0)===0))){c.mode=(c.mode|(8388608))>>>0;}if(!((((c.sys.Mode&512)>>>0)===0))){c.mode=(c.mode|(1048576))>>>0;}};DK=function(c){var c;return J.Unix((c.Sec),(c.Nsec));};DT.ptr.prototype.Stat=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;if(d===EB.nil){$s=-1;return[$ifaceNil,$pkg.ErrInvalid];}c[0]=new DX.ptr("",new $Int64(0,0),0,new J.Time.ptr(new $Uint64(0,0),new $Int64(0,0),FB.nil),new E.Stat_t.ptr(new $Uint64(0,0),new $Uint64(0,0),new $Uint64(0,0),0,0,0,0,new $Uint64(0,0),new $Int64(0,0),new $Int64(0,0),new $Int64(0,0),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),EV.zero()));e=d.file.pfd.Fstat(c[0].sys);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){$s=-1;return[$ifaceNil,new AD.ptr("stat",d.file.name,f)];}DJ(c[0],d.file.name);$s=-1;return[c[0],$ifaceNil];}return;}if($f===undefined){$f={$blk:DT.ptr.prototype.Stat};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DT.prototype.Stat=function(){return this.$val.Stat();};DN=function(c){var c,d,e;d=new DX.ptr("",new $Int64(0,0),0,new J.Time.ptr(new $Uint64(0,0),new $Int64(0,0),FB.nil),new E.Stat_t.ptr(new $Uint64(0,0),new $Uint64(0,0),new $Uint64(0,0),0,0,0,0,new $Uint64(0,0),new $Int64(0,0),new $Int64(0,0),new $Int64(0,0),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),new E.Timespec.ptr(new $Int64(0,0),new $Int64(0,0)),EV.zero()));e=E.Lstat(c,d.sys);if(!($interfaceIsEqual(e,$ifaceNil))){return[$ifaceNil,new AD.ptr("lstat",c,e)];}DJ(d,c);return[d,$ifaceNil];};DV.prototype.String=function(){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;c=this.$val;d=FG.zero();e=0;f="dalTLDpSugct?";g=0;while(true){if(!(g>0)>>>0)),k<32?(1<>>0)))>>>0)===0))){((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=((j<<24>>>24)));e=e+(1)>>0;}g+=h[1];}if(e===0){((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=45);e=e+(1)>>0;}l="rwxrwxrwx";m=0;while(true){if(!(m>0)>>>0)),q<32?(1<>>0)))>>>0)===0))){((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=((p<<24>>>24)));}else{((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=45);}e=e+(1)>>0;m+=n[1];}return($bytesToString($subslice(new EE(d),0,e)));};$ptrType(DV).prototype.String=function(){return new DV(this.$get()).String();};DV.prototype.IsDir=function(){var c;c=this.$val;return!((((c&2147483648)>>>0)===0));};$ptrType(DV).prototype.IsDir=function(){return new DV(this.$get()).IsDir();};DV.prototype.IsRegular=function(){var c;c=this.$val;return((c&2401763328)>>>0)===0;};$ptrType(DV).prototype.IsRegular=function(){return new DV(this.$get()).IsRegular();};DV.prototype.Perm=function(){var c;c=this.$val;return(c&511)>>>0;};$ptrType(DV).prototype.Perm=function(){return new DV(this.$get()).Perm();};DX.ptr.prototype.Name=function(){var c;c=this;return c.name;};DX.prototype.Name=function(){return this.$val.Name();};DX.ptr.prototype.IsDir=function(){var c;c=this;return new DV(c.Mode()).IsDir();};DX.prototype.IsDir=function(){return this.$val.IsDir();};DX.ptr.prototype.Size=function(){var c;c=this;return c.size;};DX.prototype.Size=function(){return this.$val.Size();};DX.ptr.prototype.Mode=function(){var c;c=this;return c.mode;};DX.prototype.Mode=function(){return this.$val.Mode();};DX.ptr.prototype.ModTime=function(){var c;c=this;return c.modTime;};DX.prototype.ModTime=function(){return this.$val.ModTime();};DX.ptr.prototype.Sys=function(){var c;c=this;return c.sys;};DX.prototype.Sys=function(){return this.$val.Sys();};ED.methods=[{prop:"close",name:"close",pkg:"os",typ:$funcType([],[],false)}];EF.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Timeout",name:"Timeout",pkg:"",typ:$funcType([],[$Bool],false)}];EH.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Timeout",name:"Timeout",pkg:"",typ:$funcType([],[$Bool],false)}];EG.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];EW.methods=[{prop:"close",name:"close",pkg:"os",typ:$funcType([],[$error],false)}];FN.methods=[{prop:"Control",name:"Control",pkg:"",typ:$funcType([FL],[$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([FM],[$error],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([FM],[$error],false)}];EB.methods=[{prop:"Readdir",name:"Readdir",pkg:"",typ:$funcType([$Int],[EC,$error],false)},{prop:"Readdirnames",name:"Readdirnames",pkg:"",typ:$funcType([$Int],[EA,$error],false)},{prop:"readdirnames",name:"readdirnames",pkg:"os",typ:$funcType([$Int],[EA,$error],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([EE],[$Int,$error],false)},{prop:"ReadAt",name:"ReadAt",pkg:"",typ:$funcType([EE,$Int64],[$Int,$error],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([EE],[$Int,$error],false)},{prop:"WriteAt",name:"WriteAt",pkg:"",typ:$funcType([EE,$Int64],[$Int,$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)},{prop:"wrapErr",name:"wrapErr",pkg:"os",typ:$funcType([$String,$error],[$error],false)},{prop:"Chmod",name:"Chmod",pkg:"",typ:$funcType([DV],[$error],false)},{prop:"SetDeadline",name:"SetDeadline",pkg:"",typ:$funcType([J.Time],[$error],false)},{prop:"SetReadDeadline",name:"SetReadDeadline",pkg:"",typ:$funcType([J.Time],[$error],false)},{prop:"SetWriteDeadline",name:"SetWriteDeadline",pkg:"",typ:$funcType([J.Time],[$error],false)},{prop:"SyscallConn",name:"SyscallConn",pkg:"",typ:$funcType([],[E.RawConn,$error],false)},{prop:"chmod",name:"chmod",pkg:"os",typ:$funcType([DV],[$error],false)},{prop:"Chown",name:"Chown",pkg:"",typ:$funcType([$Int,$Int],[$error],false)},{prop:"Truncate",name:"Truncate",pkg:"",typ:$funcType([$Int64],[$error],false)},{prop:"Sync",name:"Sync",pkg:"",typ:$funcType([],[$error],false)},{prop:"Chdir",name:"Chdir",pkg:"",typ:$funcType([],[$error],false)},{prop:"setDeadline",name:"setDeadline",pkg:"os",typ:$funcType([J.Time],[$error],false)},{prop:"setReadDeadline",name:"setReadDeadline",pkg:"os",typ:$funcType([J.Time],[$error],false)},{prop:"setWriteDeadline",name:"setWriteDeadline",pkg:"os",typ:$funcType([J.Time],[$error],false)},{prop:"checkValid",name:"checkValid",pkg:"os",typ:$funcType([$String],[$error],false)},{prop:"Fd",name:"Fd",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)},{prop:"read",name:"read",pkg:"os",typ:$funcType([EE],[$Int,$error],false)},{prop:"pread",name:"pread",pkg:"os",typ:$funcType([EE,$Int64],[$Int,$error],false)},{prop:"write",name:"write",pkg:"os",typ:$funcType([EE],[$Int,$error],false)},{prop:"pwrite",name:"pwrite",pkg:"os",typ:$funcType([EE,$Int64],[$Int,$error],false)},{prop:"seek",name:"seek",pkg:"os",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"readdir",name:"readdir",pkg:"os",typ:$funcType([$Int],[EC,$error],false)},{prop:"Stat",name:"Stat",pkg:"",typ:$funcType([],[DU,$error],false)}];DV.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"IsDir",name:"IsDir",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsRegular",name:"IsRegular",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Perm",name:"Perm",pkg:"",typ:$funcType([],[DV],false)}];FH.methods=[{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"IsDir",name:"IsDir",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Mode",name:"Mode",pkg:"",typ:$funcType([],[DV],false)},{prop:"ModTime",name:"ModTime",pkg:"",typ:$funcType([],[J.Time],false)},{prop:"Sys",name:"Sys",pkg:"",typ:$funcType([],[$emptyInterface],false)}];P.init("os",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:EE,tag:""},{prop:"nbuf",name:"nbuf",embedded:false,exported:false,typ:$Int,tag:""},{prop:"bufp",name:"bufp",embedded:false,exported:false,typ:$Int,tag:""}]);AC.init([{prop:"Timeout",name:"Timeout",pkg:"",typ:$funcType([],[$Bool],false)}]);AD.init("",[{prop:"Op",name:"Op",embedded:false,exported:true,typ:$String,tag:""},{prop:"Path",name:"Path",embedded:false,exported:true,typ:$String,tag:""},{prop:"Err",name:"Err",embedded:false,exported:true,typ:$error,tag:""}]);AE.init("",[{prop:"Syscall",name:"Syscall",embedded:false,exported:true,typ:$String,tag:""},{prop:"Err",name:"Err",embedded:false,exported:true,typ:$error,tag:""}]);BC.init("",[{prop:"Op",name:"Op",embedded:false,exported:true,typ:$String,tag:""},{prop:"Old",name:"Old",embedded:false,exported:true,typ:$String,tag:""},{prop:"New",name:"New",embedded:false,exported:true,typ:$String,tag:""},{prop:"Err",name:"Err",embedded:false,exported:true,typ:$error,tag:""}]);BZ.init("os",[{prop:"pfd",name:"pfd",embedded:false,exported:false,typ:G.FD,tag:""},{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"dirinfo",name:"dirinfo",embedded:false,exported:false,typ:ED,tag:""},{prop:"nonblock",name:"nonblock",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"stdoutOrErr",name:"stdoutOrErr",embedded:false,exported:false,typ:$Bool,tag:""}]);DC.init("os",[{prop:"file",name:"file",embedded:false,exported:false,typ:EB,tag:""}]);DT.init("os",[{prop:"file",name:"file",embedded:true,exported:false,typ:EW,tag:""}]);DU.init([{prop:"IsDir",name:"IsDir",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"ModTime",name:"ModTime",pkg:"",typ:$funcType([],[J.Time],false)},{prop:"Mode",name:"Mode",pkg:"",typ:$funcType([],[DV],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Sys",name:"Sys",pkg:"",typ:$funcType([],[$emptyInterface],false)}]);DX.init("os",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"size",name:"size",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"mode",name:"mode",embedded:false,exported:false,typ:DV,tag:""},{prop:"modTime",name:"modTime",embedded:false,exported:false,typ:J.Time,tag:""},{prop:"sys",name:"sys",embedded:false,exported:false,typ:E.Stat_t,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=J.$init();$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.Args=EA.nil;$pkg.ErrInvalid=A.New("invalid argument");$pkg.ErrPermission=A.New("permission denied");$pkg.ErrExist=A.New("file already exists");$pkg.ErrNotExist=A.New("file does not exist");$pkg.ErrClosed=A.New("file already closed");AZ=A.New("os: process already finished");$pkg.Stdin=CA(((E.Stdin>>>0)),"/dev/stdin");$pkg.Stdout=CA(((E.Stdout>>>0)),"/dev/stdout");$pkg.Stderr=CA(((E.Stderr>>>0)),"/dev/stderr");BJ=DI;M();CV();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["fmt"]=(function(){var $pkg={},$init,C,D,E,I,F,G,A,H,B,J,K,L,M,N,O,P,Q,AI,AU,AV,AW,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BT,CO,CP,R,AX,BB,BD,BE,S,T,V,W,X,Z,AC,AD,AE,AF,AG,AH,AY,AZ,BF;C=$packages["errors"];D=$packages["internal/fmtsort"];E=$packages["io"];I=$packages["math"];F=$packages["os"];G=$packages["reflect"];A=$packages["strconv"];H=$packages["sync"];B=$packages["unicode/utf8"];J=$pkg.fmtFlags=$newType(0,$kindStruct,"fmt.fmtFlags",true,"fmt",false,function(widPresent_,precPresent_,minus_,plus_,sharp_,space_,zero_,plusV_,sharpV_){this.$val=this;if(arguments.length===0){this.widPresent=false;this.precPresent=false;this.minus=false;this.plus=false;this.sharp=false;this.space=false;this.zero=false;this.plusV=false;this.sharpV=false;return;}this.widPresent=widPresent_;this.precPresent=precPresent_;this.minus=minus_;this.plus=plus_;this.sharp=sharp_;this.space=space_;this.zero=zero_;this.plusV=plusV_;this.sharpV=sharpV_;});K=$pkg.fmt=$newType(0,$kindStruct,"fmt.fmt",true,"fmt",false,function(buf_,fmtFlags_,wid_,prec_,intbuf_){this.$val=this;if(arguments.length===0){this.buf=BK.nil;this.fmtFlags=new J.ptr(false,false,false,false,false,false,false,false,false);this.wid=0;this.prec=0;this.intbuf=BL.zero();return;}this.buf=buf_;this.fmtFlags=fmtFlags_;this.wid=wid_;this.prec=prec_;this.intbuf=intbuf_;});L=$pkg.State=$newType(8,$kindInterface,"fmt.State",true,"fmt",true,null);M=$pkg.Formatter=$newType(8,$kindInterface,"fmt.Formatter",true,"fmt",true,null);N=$pkg.Stringer=$newType(8,$kindInterface,"fmt.Stringer",true,"fmt",true,null);O=$pkg.GoStringer=$newType(8,$kindInterface,"fmt.GoStringer",true,"fmt",true,null);P=$pkg.buffer=$newType(12,$kindSlice,"fmt.buffer",true,"fmt",false,null);Q=$pkg.pp=$newType(0,$kindStruct,"fmt.pp",true,"fmt",false,function(buf_,arg_,value_,fmt_,reordered_,goodArgNum_,panicking_,erroring_){this.$val=this;if(arguments.length===0){this.buf=P.nil;this.arg=$ifaceNil;this.value=new G.Value.ptr(BJ.nil,0,0);this.fmt=new K.ptr(BK.nil,new J.ptr(false,false,false,false,false,false,false,false,false),0,0,BL.zero());this.reordered=false;this.goodArgNum=false;this.panicking=false;this.erroring=false;return;}this.buf=buf_;this.arg=arg_;this.value=value_;this.fmt=fmt_;this.reordered=reordered_;this.goodArgNum=goodArgNum_;this.panicking=panicking_;this.erroring=erroring_;});AI=$pkg.ScanState=$newType(8,$kindInterface,"fmt.ScanState",true,"fmt",true,null);AU=$pkg.scanError=$newType(0,$kindStruct,"fmt.scanError",true,"fmt",false,function(err_){this.$val=this;if(arguments.length===0){this.err=$ifaceNil;return;}this.err=err_;});AV=$pkg.ss=$newType(0,$kindStruct,"fmt.ss",true,"fmt",false,function(rs_,buf_,count_,atEOF_,ssave_){this.$val=this;if(arguments.length===0){this.rs=$ifaceNil;this.buf=P.nil;this.count=0;this.atEOF=false;this.ssave=new AW.ptr(false,false,false,0,0,0);return;}this.rs=rs_;this.buf=buf_;this.count=count_;this.atEOF=atEOF_;this.ssave=ssave_;});AW=$pkg.ssave=$newType(0,$kindStruct,"fmt.ssave",true,"fmt",false,function(validSave_,nlIsEnd_,nlIsSpace_,argLimit_,limit_,maxWid_){this.$val=this;if(arguments.length===0){this.validSave=false;this.nlIsEnd=false;this.nlIsSpace=false;this.argLimit=0;this.limit=0;this.maxWid=0;return;}this.validSave=validSave_;this.nlIsEnd=nlIsEnd_;this.nlIsSpace=nlIsSpace_;this.argLimit=argLimit_;this.limit=limit_;this.maxWid=maxWid_;});BI=$sliceType($emptyInterface);BJ=$ptrType(G.rtype);BK=$ptrType(P);BL=$arrayType($Uint8,68);BM=$arrayType($Uint16,2);BN=$sliceType(BM);BO=$sliceType($Uint8);BP=$arrayType($Uint8,5);BQ=$ptrType(Q);BT=$ptrType(AV);CO=$ptrType(K);CP=$funcType([$Int32],[$Bool],false);K.ptr.prototype.clearflags=function(){var a;a=this;J.copy(a.fmtFlags,new J.ptr(false,false,false,false,false,false,false,false,false));};K.prototype.clearflags=function(){return this.$val.clearflags();};K.ptr.prototype.init=function(a){var a,b;b=this;b.buf=a;b.clearflags();};K.prototype.init=function(a){return this.$val.init(a);};K.ptr.prototype.writePadding=function(a){var a,b,c,d,e,f,g,h,i,j;b=this;if(a<=0){return;}c=b.buf.$get();d=c.$length;e=d+a>>0;if(e>c.$capacity){c=$makeSlice(P,(($imul(c.$capacity,2))+a>>0));$copySlice(c,b.buf.$get());}f=32;if(b.fmtFlags.zero){f=48;}g=$subslice(c,d,e);h=g;i=0;while(true){if(!(i=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]=f);i++;}b.buf.$set($subslice(c,0,e));};K.prototype.writePadding=function(a){return this.$val.writePadding(a);};K.ptr.prototype.pad=function(a){var a,b,c;b=this;if(!b.fmtFlags.widPresent||(b.wid===0)){b.buf.Write(a);return;}c=b.wid-B.RuneCount(a)>>0;if(!b.fmtFlags.minus){b.writePadding(c);b.buf.Write(a);}else{b.buf.Write(a);b.writePadding(c);}};K.prototype.pad=function(a){return this.$val.pad(a);};K.ptr.prototype.padString=function(a){var a,b,c;b=this;if(!b.fmtFlags.widPresent||(b.wid===0)){b.buf.WriteString(a);return;}c=b.wid-B.RuneCountInString(a)>>0;if(!b.fmtFlags.minus){b.writePadding(c);b.buf.WriteString(a);}else{b.buf.WriteString(a);b.writePadding(c);}};K.prototype.padString=function(a){return this.$val.padString(a);};K.ptr.prototype.fmtBoolean=function(a){var a,b;b=this;if(a){b.padString("true");}else{b.padString("false");}};K.prototype.fmtBoolean=function(a){return this.$val.fmtBoolean(a);};K.ptr.prototype.fmtUnicode=function(a){var a,b,c,d,e,f,g;b=this;c=$subslice(new BO(b.intbuf),0);d=4;if(b.fmtFlags.precPresent&&b.prec>4){d=b.prec;e=(((2+d>>0)+2>>0)+4>>0)+1>>0;if(e>c.$length){c=$makeSlice(BO,e);}}f=c.$length;if(b.fmtFlags.sharp&&(a.$high<0||(a.$high===0&&a.$low<=1114111))&&A.IsPrint(((a.$low>>0)))){f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=39);f=f-(B.RuneLen(((a.$low>>0))))>>0;B.EncodeRune($subslice(c,f),((a.$low>>0)));f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=39);f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=32);}while(true){if(!((a.$high>0||(a.$high===0&&a.$low>=16)))){break;}f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]="0123456789ABCDEFX".charCodeAt($flatten64(new $Uint64(a.$high&0,(a.$low&15)>>>0))));d=d-(1)>>0;a=$shiftRightUint64(a,(4));}f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]="0123456789ABCDEFX".charCodeAt($flatten64(a)));d=d-(1)>>0;while(true){if(!(d>0)){break;}f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=48);d=d-(1)>>0;}f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=43);f=f-(1)>>0;((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=85);g=b.fmtFlags.zero;b.fmtFlags.zero=false;b.pad($subslice(c,f));b.fmtFlags.zero=g;};K.prototype.fmtUnicode=function(a){return this.$val.fmtUnicode(a);};K.ptr.prototype.fmtInteger=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;e=this;g=c&&(f=(new $Int64(a.$high,a.$low)),(f.$high<0||(f.$high===0&&f.$low<0)));if(g){a=new $Uint64(-a.$high,-a.$low);}h=$subslice(new BO(e.intbuf),0);if(e.fmtFlags.widPresent||e.fmtFlags.precPresent){i=(3+e.wid>>0)+e.prec>>0;if(i>h.$length){h=$makeSlice(BO,i);}}j=0;if(e.fmtFlags.precPresent){j=e.prec;if((j===0)&&(a.$high===0&&a.$low===0)){k=e.fmtFlags.zero;e.fmtFlags.zero=false;e.writePadding(e.wid);e.fmtFlags.zero=k;return;}}else if(e.fmtFlags.zero&&e.fmtFlags.widPresent){j=e.wid;if(g||e.fmtFlags.plus||e.fmtFlags.space){j=j-(1)>>0;}}l=h.$length;m=b;if(m===(10)){while(true){if(!((a.$high>0||(a.$high===0&&a.$low>=10)))){break;}l=l-(1)>>0;n=$div64(a,new $Uint64(0,10),false);((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=(((o=new $Uint64(0+a.$high,48+a.$low),p=$mul64(n,new $Uint64(0,10)),new $Uint64(o.$high-p.$high,o.$low-p.$low)).$low<<24>>>24)));a=n;}}else if(m===(16)){while(true){if(!((a.$high>0||(a.$high===0&&a.$low>=16)))){break;}l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=d.charCodeAt($flatten64(new $Uint64(a.$high&0,(a.$low&15)>>>0))));a=$shiftRightUint64(a,(4));}}else if(m===(8)){while(true){if(!((a.$high>0||(a.$high===0&&a.$low>=8)))){break;}l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=(((q=new $Uint64(a.$high&0,(a.$low&7)>>>0),new $Uint64(0+q.$high,48+q.$low)).$low<<24>>>24)));a=$shiftRightUint64(a,(3));}}else if(m===(2)){while(true){if(!((a.$high>0||(a.$high===0&&a.$low>=2)))){break;}l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=(((r=new $Uint64(a.$high&0,(a.$low&1)>>>0),new $Uint64(0+r.$high,48+r.$low)).$low<<24>>>24)));a=$shiftRightUint64(a,(1));}}else{$panic(new $String("fmt: unknown base; can't happen"));}l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=d.charCodeAt($flatten64(a)));while(true){if(!(l>0&&j>(h.$length-l>>0))){break;}l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=48);}if(e.fmtFlags.sharp){s=b;if(s===(8)){if(!((((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l])===48))){l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=48);}}else if(s===(16)){l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=d.charCodeAt(16));l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=48);}}if(g){l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=45);}else if(e.fmtFlags.plus){l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=43);}else if(e.fmtFlags.space){l=l-(1)>>0;((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]=32);}t=e.fmtFlags.zero;e.fmtFlags.zero=false;e.pad($subslice(h,l));e.fmtFlags.zero=t;};K.prototype.fmtInteger=function(a,b,c,d){return this.$val.fmtInteger(a,b,c,d);};K.ptr.prototype.truncateString=function(a){var a,b,c,d,e,f,g;b=this;if(b.fmtFlags.precPresent){c=b.prec;d=a;e=0;while(true){if(!(e>0;if(c<0){return $substring(a,0,g);}e+=f[1];}}return a;};K.prototype.truncateString=function(a){return this.$val.truncateString(a);};K.ptr.prototype.truncate=function(a){var a,b,c,d,e,f;b=this;if(b.fmtFlags.precPresent){c=b.prec;d=0;while(true){if(!(d>0;if(c<0){return $subslice(a,0,d);}e=1;if(((d<0||d>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+d])>=128){f=B.DecodeRune($subslice(a,d));e=f[1];}d=d+(e)>>0;}}return a;};K.prototype.truncate=function(a){return this.$val.truncate(a);};K.ptr.prototype.fmtS=function(a){var a,b;b=this;a=b.truncateString(a);b.padString(a);};K.prototype.fmtS=function(a){return this.$val.fmtS(a);};K.ptr.prototype.fmtBs=function(a){var a,b;b=this;a=b.truncate(a);b.pad(a);};K.prototype.fmtBs=function(a){return this.$val.fmtBs(a);};K.ptr.prototype.fmtSbx=function(a,b,c){var a,b,c,d,e,f,g,h,i;d=this;e=b.$length;if(b===BO.nil){e=a.length;}if(d.fmtFlags.precPresent&&d.prec0){if(d.fmtFlags.space){if(d.fmtFlags.sharp){f=$imul(f,(2));}f=f+((e-1>>0))>>0;}else if(d.fmtFlags.sharp){f=f+(2)>>0;}}else{if(d.fmtFlags.widPresent){d.writePadding(d.wid);}return;}if(d.fmtFlags.widPresent&&d.wid>f&&!d.fmtFlags.minus){d.writePadding(d.wid-f>>0);}g=d.buf.$get();if(d.fmtFlags.sharp){g=$append(g,48,c.charCodeAt(16));}h=0;i=0;while(true){if(!(i0){g=$append(g,32);if(d.fmtFlags.sharp){g=$append(g,48,c.charCodeAt(16));}}if(!(b===BO.nil)){h=((i<0||i>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+i]);}else{h=a.charCodeAt(i);}g=$append(g,c.charCodeAt((h>>>4<<24>>>24)),c.charCodeAt(((h&15)>>>0)));i=i+(1)>>0;}d.buf.$set(g);if(d.fmtFlags.widPresent&&d.wid>f&&d.fmtFlags.minus){d.writePadding(d.wid-f>>0);}};K.prototype.fmtSbx=function(a,b,c){return this.$val.fmtSbx(a,b,c);};K.ptr.prototype.fmtSx=function(a,b){var a,b,c;c=this;c.fmtSbx(a,BO.nil,b);};K.prototype.fmtSx=function(a,b){return this.$val.fmtSx(a,b);};K.ptr.prototype.fmtBx=function(a,b){var a,b,c;c=this;c.fmtSbx("",a,b);};K.prototype.fmtBx=function(a,b){return this.$val.fmtBx(a,b);};K.ptr.prototype.fmtQ=function(a){var a,b,c;b=this;a=b.truncateString(a);if(b.fmtFlags.sharp&&A.CanBackquote(a)){b.padString("`"+a+"`");return;}c=$subslice(new BO(b.intbuf),0,0);if(b.fmtFlags.plus){b.pad(A.AppendQuoteToASCII(c,a));}else{b.pad(A.AppendQuote(c,a));}};K.prototype.fmtQ=function(a){return this.$val.fmtQ(a);};K.ptr.prototype.fmtC=function(a){var a,b,c,d,e;b=this;c=((a.$low>>0));if((a.$high>0||(a.$high===0&&a.$low>1114111))){c=65533;}d=$subslice(new BO(b.intbuf),0,0);e=B.EncodeRune($subslice(d,0,4),c);b.pad($subslice(d,0,e));};K.prototype.fmtC=function(a){return this.$val.fmtC(a);};K.ptr.prototype.fmtQc=function(a){var a,b,c,d;b=this;c=((a.$low>>0));if((a.$high>0||(a.$high===0&&a.$low>1114111))){c=65533;}d=$subslice(new BO(b.intbuf),0,0);if(b.fmtFlags.plus){b.pad(A.AppendQuoteRuneToASCII(d,c));}else{b.pad(A.AppendQuoteRune(d,c));}};K.prototype.fmtQc=function(a){return this.$val.fmtQc(a);};K.ptr.prototype.fmtFloat=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n;e=this;if(e.fmtFlags.precPresent){d=e.prec;}f=A.AppendFloat($subslice(new BO(e.intbuf),0,1),a,((c<<24>>>24)),d,b);if(((1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])===45)||((1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])===43)){f=$subslice(f,1);}else{(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]=43);}if(e.fmtFlags.space&&((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0])===43)&&!e.fmtFlags.plus){(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]=32);}if(((1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])===73)||((1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])===78)){g=e.fmtFlags.zero;e.fmtFlags.zero=false;if(((1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])===78)&&!e.fmtFlags.space&&!e.fmtFlags.plus){f=$subslice(f,1);}e.pad(f);e.fmtFlags.zero=g;return;}if(e.fmtFlags.sharp&&!((c===98))){h=0;i=c;if((i===(118))||(i===(103))||(i===(71))){h=d;if(h===-1){h=6;}}j=BP.zero();k=$subslice(new BO(j),0,0);l=false;m=1;while(true){if(!(m=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+m]);if(n===(46)){l=true;}else if((n===(101))||(n===(69))){k=$appendSlice(k,$subslice(f,m));f=$subslice(f,0,m);}else{h=h-(1)>>0;}m=m+(1)>>0;}if(!l){f=$append(f,46);}while(true){if(!(h>0)){break;}f=$append(f,48);h=h-(1)>>0;}f=$appendSlice(f,k);}if(e.fmtFlags.plus||!(((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0])===43))){if(e.fmtFlags.zero&&e.fmtFlags.widPresent&&e.wid>f.$length){e.buf.WriteByte((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]));e.writePadding(e.wid-f.$length>>0);e.buf.Write($subslice(f,1));return;}e.pad(f);return;}e.pad($subslice(f,1));};K.prototype.fmtFloat=function(a,b,c,d){return this.$val.fmtFloat(a,b,c,d);};$ptrType(P).prototype.Write=function(a){var a,b;b=this;b.$set($appendSlice(b.$get(),a));};$ptrType(P).prototype.WriteString=function(a){var a,b;b=this;b.$set($appendSlice(b.$get(),a));};$ptrType(P).prototype.WriteByte=function(a){var a,b;b=this;b.$set($append(b.$get(),a));};$ptrType(P).prototype.WriteRune=function(a){var a,b,c,d,e,f;b=this;if(a<128){b.$set($append(b.$get(),((a<<24>>>24))));return;}c=b.$get();d=c.$length;while(true){if(!((d+4>>0)>c.$capacity)){break;}c=$append(c,0);}f=B.EncodeRune((e=$subslice(c,d,(d+4>>0)),$subslice(new BO(e.$array),e.$offset,e.$offset+e.$length)),a);b.$set($subslice(c,0,(d+f>>0)));};S=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=R.Get();$s=1;case 1:if($c){$c=false;a=a.$blk();}if(a&&a.$blk!==undefined){break s;}b=$assertType(a,BQ);b.panicking=false;b.erroring=false;b.fmt.init((b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))));$s=-1;return b;}return;}if($f===undefined){$f={$blk:S};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};Q.ptr.prototype.free=function(){var a;a=this;if(a.buf.$capacity>65536){return;}a.buf=$subslice(a.buf,0,0);a.arg=$ifaceNil;a.value=new G.Value.ptr(BJ.nil,0,0);R.Put(a);};Q.prototype.free=function(){return this.$val.free();};Q.ptr.prototype.Width=function(){var a,b,c,d,e;a=0;b=false;c=this;d=c.fmt.wid;e=c.fmt.fmtFlags.widPresent;a=d;b=e;return[a,b];};Q.prototype.Width=function(){return this.$val.Width();};Q.ptr.prototype.Precision=function(){var a,b,c,d,e;a=0;b=false;c=this;d=c.fmt.prec;e=c.fmt.fmtFlags.precPresent;a=d;b=e;return[a,b];};Q.prototype.Precision=function(){return this.$val.Precision();};Q.ptr.prototype.Flag=function(a){var a,b,c;b=this;c=a;if(c===(45)){return b.fmt.fmtFlags.minus;}else if(c===(43)){return b.fmt.fmtFlags.plus||b.fmt.fmtFlags.plusV;}else if(c===(35)){return b.fmt.fmtFlags.sharp||b.fmt.fmtFlags.sharpV;}else if(c===(32)){return b.fmt.fmtFlags.space;}else if(c===(48)){return b.fmt.fmtFlags.zero;}return false;};Q.prototype.Flag=function(a){return this.$val.Flag(a);};Q.ptr.prototype.Write=function(a){var a,b,c,d,e,f;b=0;c=$ifaceNil;d=this;(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).Write(a);e=a.$length;f=$ifaceNil;b=e;c=f;return[b,c];};Q.prototype.Write=function(a){return this.$val.Write(a);};Q.ptr.prototype.WriteString=function(a){var a,b,c,d,e,f;b=0;c=$ifaceNil;d=this;(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(a);e=a.length;f=$ifaceNil;b=e;c=f;return[b,c];};Q.prototype.WriteString=function(a){return this.$val.WriteString(a);};T=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=S();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;$r=g.doPrintf(b,c);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}j=a.Write((i=g.buf,$subslice(new BO(i.$array),i.$offset,i.$offset+i.$length)));$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}h=j;d=h[0];e=h[1];g.free();$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:T};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Fprintf=T;V=function(a,b){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=S();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;$r=d.doPrintf(a,b);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=($bytesToString(d.buf));d.free();$s=-1;return e;}return;}if($f===undefined){$f={$blk:V};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sprintf=V;W=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=V(a,b);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=C.New(c);$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:W};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Errorf=W;X=function(a,b){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=$ifaceNil;e=S();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;$r=f.doPrint(b);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=a.Write((h=f.buf,$subslice(new BO(h.$array),h.$offset,h.$offset+h.$length)));$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}g=i;c=g[0];d=g[1];f.free();$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:X};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Fprint=X;Z=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=S();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;$r=c.doPrint(a);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d=($bytesToString(c.buf));c.free();$s=-1;return d;}return;}if($f===undefined){$f={$blk:Z};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sprint=Z;AC=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=S();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;$r=c.doPrintln(a);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d=($bytesToString(c.buf));c.free();$s=-1;return d;}return;}if($f===undefined){$f={$blk:AC};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Sprintln=AC;AD=function(a,b){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=$clone(a,G.Value).Field(b);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;if(($clone(d,G.Value).Kind()===20)&&!$clone(d,G.Value).IsNil()){$s=2;continue;}$s=3;continue;case 2:e=$clone(d,G.Value).Elem();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;case 3:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AD};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AE=function(a){var a;return a>1000000||a<-1000000;};AF=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l;d=0;e=false;f=0;if(b>=c){g=0;h=false;i=c;d=g;e=h;f=i;return[d,e,f];}f=b;while(true){if(!(f>>24)>>0))>>0;e=true;f=f+(1)>>0;}return[d,e,f];};Q.ptr.prototype.unknownType=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if(!$clone(a,G.Value).IsValid()){(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("");$s=-1;return;}(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(63);c=$clone(a,G.Value).Type().String();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$r=(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString(c);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(63);$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.unknownType};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.unknownType=function(a){return this.$val.unknownType(a);};Q.ptr.prototype.badVerb=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;b.erroring=true;(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("%!");(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteRune(a);(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(40);if(!($interfaceIsEqual(b.arg,$ifaceNil))){$s=2;continue;}if($clone(b.value,G.Value).IsValid()){$s=3;continue;}$s=4;continue;case 2:c=G.TypeOf(b.arg).String();$s=6;case 6:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$r=(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString(c);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(61);$r=b.printArg(b.arg,118);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=5;continue;case 3:d=$clone(b.value,G.Value).Type().String();$s=9;case 9:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$r=(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString(d);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(61);$r=b.printValue($clone(b.value,G.Value),118,0);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=5;continue;case 4:(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("");case 5:case 1:(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(41);b.erroring=false;$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.badVerb};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.badVerb=function(a){return this.$val.badVerb(a);};Q.ptr.prototype.fmtBool=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=b;if((d===(116))||(d===(118))){$s=2;continue;}$s=3;continue;case 2:c.fmt.fmtBoolean(a);$s=4;continue;case 3:$r=c.badVerb(b);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 4:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtBool};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtBool=function(a,b){return this.$val.fmtBool(a,b);};Q.ptr.prototype.fmt0x64=function(a,b){var a,b,c,d;c=this;d=c.fmt.fmtFlags.sharp;c.fmt.fmtFlags.sharp=b;c.fmt.fmtInteger(a,16,false,"0123456789abcdefx");c.fmt.fmtFlags.sharp=d;};Q.prototype.fmt0x64=function(a,b){return this.$val.fmt0x64(a,b);};Q.ptr.prototype.fmtInteger=function(a,b,c){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=c;if(e===(118)){$s=2;continue;}if(e===(100)){$s=3;continue;}if(e===(98)){$s=4;continue;}if(e===(111)){$s=5;continue;}if(e===(120)){$s=6;continue;}if(e===(88)){$s=7;continue;}if(e===(99)){$s=8;continue;}if(e===(113)){$s=9;continue;}if(e===(85)){$s=10;continue;}$s=11;continue;case 2:if(d.fmt.fmtFlags.sharpV&&!b){d.fmt0x64(a,true);}else{d.fmt.fmtInteger(a,10,b,"0123456789abcdefx");}$s=12;continue;case 3:d.fmt.fmtInteger(a,10,b,"0123456789abcdefx");$s=12;continue;case 4:d.fmt.fmtInteger(a,2,b,"0123456789abcdefx");$s=12;continue;case 5:d.fmt.fmtInteger(a,8,b,"0123456789abcdefx");$s=12;continue;case 6:d.fmt.fmtInteger(a,16,b,"0123456789abcdefx");$s=12;continue;case 7:d.fmt.fmtInteger(a,16,b,"0123456789ABCDEFX");$s=12;continue;case 8:d.fmt.fmtC(a);$s=12;continue;case 9:if((a.$high<0||(a.$high===0&&a.$low<=1114111))){$s=13;continue;}$s=14;continue;case 13:d.fmt.fmtQc(a);$s=15;continue;case 14:$r=d.badVerb(c);$s=16;case 16:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 15:$s=12;continue;case 10:d.fmt.fmtUnicode(a);$s=12;continue;case 11:$r=d.badVerb(c);$s=17;case 17:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 12:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtInteger};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtInteger=function(a,b,c){return this.$val.fmtInteger(a,b,c);};Q.ptr.prototype.fmtFloat=function(a,b,c){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=c;if(e===(118)){$s=2;continue;}if((e===(98))||(e===(103))||(e===(71))){$s=3;continue;}if((e===(102))||(e===(101))||(e===(69))){$s=4;continue;}if(e===(70)){$s=5;continue;}$s=6;continue;case 2:d.fmt.fmtFloat(a,b,103,-1);$s=7;continue;case 3:d.fmt.fmtFloat(a,b,c,-1);$s=7;continue;case 4:d.fmt.fmtFloat(a,b,c,6);$s=7;continue;case 5:d.fmt.fmtFloat(a,b,102,6);$s=7;continue;case 6:$r=d.badVerb(c);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 7:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtFloat};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtFloat=function(a,b,c){return this.$val.fmtFloat(a,b,c);};Q.ptr.prototype.fmtComplex=function(a,b,c){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=c;if((e===(118))||(e===(98))||(e===(103))||(e===(71))||(e===(102))||(e===(70))||(e===(101))||(e===(69))){$s=2;continue;}$s=3;continue;case 2:f=d.fmt.fmtFlags.plus;(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(40);$r=d.fmtFloat(a.$real,(g=b/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero")),c);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d.fmt.fmtFlags.plus=true;$r=d.fmtFloat(a.$imag,(h=b/2,(h===h&&h!==1/0&&h!==-1/0)?h>>0:$throwRuntimeError("integer divide by zero")),c);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("i)");d.fmt.fmtFlags.plus=f;$s=4;continue;case 3:$r=d.badVerb(c);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 4:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtComplex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtComplex=function(a,b,c){return this.$val.fmtComplex(a,b,c);};Q.ptr.prototype.fmtString=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=b;if(d===(118)){$s=2;continue;}if(d===(115)){$s=3;continue;}if(d===(120)){$s=4;continue;}if(d===(88)){$s=5;continue;}if(d===(113)){$s=6;continue;}$s=7;continue;case 2:if(c.fmt.fmtFlags.sharpV){c.fmt.fmtQ(a);}else{c.fmt.fmtS(a);}$s=8;continue;case 3:c.fmt.fmtS(a);$s=8;continue;case 4:c.fmt.fmtSx(a,"0123456789abcdefx");$s=8;continue;case 5:c.fmt.fmtSx(a,"0123456789ABCDEFX");$s=8;continue;case 6:c.fmt.fmtQ(a);$s=8;continue;case 7:$r=c.badVerb(b);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 8:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtString};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtString=function(a,b){return this.$val.fmtString(a,b);};Q.ptr.prototype.fmtBytes=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=b;if((e===(118))||(e===(100))){$s=2;continue;}if(e===(115)){$s=3;continue;}if(e===(120)){$s=4;continue;}if(e===(88)){$s=5;continue;}if(e===(113)){$s=6;continue;}$s=7;continue;case 2:if(d.fmt.fmtFlags.sharpV){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(c);if(a===BO.nil){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("(nil)");$s=-1;return;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(123);f=a;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(h>0){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(", ");}d.fmt0x64((new $Uint64(0,i)),true);g++;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(125);}else{(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(91);j=a;k=0;while(true){if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]);if(l>0){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(32);}d.fmt.fmtInteger((new $Uint64(0,m)),10,false,"0123456789abcdefx");k++;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(93);}$s=8;continue;case 3:d.fmt.fmtBs(a);$s=8;continue;case 4:d.fmt.fmtBx(a,"0123456789abcdefx");$s=8;continue;case 5:d.fmt.fmtBx(a,"0123456789ABCDEFX");$s=8;continue;case 6:d.fmt.fmtQ(($bytesToString(a)));$s=8;continue;case 7:n=G.ValueOf(a);$s=9;case 9:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}$r=d.printValue($clone(n,G.Value),b,0);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 8:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtBytes};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtBytes=function(a,b,c){return this.$val.fmtBytes(a,b,c);};Q.ptr.prototype.fmtPointer=function(a,b){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=0;e=$clone(a,G.Value).Kind();if((e===(18))||(e===(19))||(e===(21))||(e===(22))||(e===(23))||(e===(26))){$s=2;continue;}$s=3;continue;case 2:d=$clone(a,G.Value).Pointer();$s=4;continue;case 3:$r=c.badVerb(b);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 4:case 1:f=b;if(f===(118)){$s=7;continue;}if(f===(112)){$s=8;continue;}if((f===(98))||(f===(111))||(f===(100))||(f===(120))||(f===(88))){$s=9;continue;}$s=10;continue;case 7:if(c.fmt.fmtFlags.sharpV){$s=12;continue;}$s=13;continue;case 12:(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteByte(40);g=$clone(a,G.Value).Type().String();$s=15;case 15:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$r=(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString(g);$s=16;case 16:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString(")(");if(d===0){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString("nil");}else{c.fmt0x64((new $Uint64(0,d.constructor===Number?d:1)),true);}(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteByte(41);$s=14;continue;case 13:if(d===0){c.fmt.padString("");}else{c.fmt0x64((new $Uint64(0,d.constructor===Number?d:1)),!c.fmt.fmtFlags.sharp);}case 14:$s=11;continue;case 8:c.fmt0x64((new $Uint64(0,d.constructor===Number?d:1)),!c.fmt.fmtFlags.sharp);$s=11;continue;case 9:$r=c.fmtInteger((new $Uint64(0,d.constructor===Number?d:1)),false,b);$s=17;case 17:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=11;continue;case 10:$r=c.badVerb(b);$s=18;case 18:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 11:case 6:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.fmtPointer};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.fmtPointer=function(a,b){return this.$val.fmtPointer(a,b);};Q.ptr.prototype.catchPanic=function(a,b,c){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=$recover();if(!($interfaceIsEqual(e,$ifaceNil))){$s=1;continue;}$s=2;continue;case 1:f=G.ValueOf(a);$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(($clone(g,G.Value).Kind()===22)&&$clone(g,G.Value).IsNil()){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("");$s=-1;return;}if(d.panicking){$panic(e);}h=$clone(d.fmt.fmtFlags,J);d.fmt.clearflags();(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("%!");(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteRune(b);(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("(PANIC=");(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(c);(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(" method: ");d.panicking=true;$r=d.printArg(e,118);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d.panicking=false;(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(41);J.copy(d.fmt.fmtFlags,h);case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.catchPanic};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.catchPanic=function(a,b,c){return this.$val.catchPanic(a,b,c);};Q.ptr.prototype.handleMethods=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);b=false;c=this;if(c.erroring){$s=-1;return b;}d=$assertType(c.arg,M,true);e=d[0];f=d[1];if(f){$s=1;continue;}$s=2;continue;case 1:b=true;$deferred.push([$methodVal(c,"catchPanic"),[c.arg,a,"Format"]]);$r=e.Format(c,a);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return b;case 2:if(c.fmt.fmtFlags.sharpV){$s=4;continue;}$s=5;continue;case 4:g=$assertType(c.arg,O,true);h=g[0];i=g[1];if(i){$s=7;continue;}$s=8;continue;case 7:b=true;$deferred.push([$methodVal(c,"catchPanic"),[c.arg,a,"GoString"]]);j=h.GoString();$s=9;case 9:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$r=c.fmt.fmtS(j);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return b;case 8:$s=6;continue;case 5:k=a;if((k===(118))||(k===(115))||(k===(120))||(k===(88))||(k===(113))){$s=12;continue;}$s=13;continue;case 12:l=c.arg;if($assertType(l,$error,true)[1]){$s=14;continue;}if($assertType(l,N,true)[1]){$s=15;continue;}$s=16;continue;case 14:m=l;b=true;$deferred.push([$methodVal(c,"catchPanic"),[c.arg,a,"Error"]]);o=m.Error();$s=17;case 17:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}$r=c.fmtString(o,a);$s=18;case 18:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return b;case 15:n=l;b=true;$deferred.push([$methodVal(c,"catchPanic"),[c.arg,a,"String"]]);p=n.String();$s=19;case 19:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}$r=c.fmtString(p,a);$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return b;case 16:case 13:case 11:case 6:b=false;$s=-1;return b;}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if(!$curGoroutine.asleep){return b;}if($curGoroutine.asleep){if($f===undefined){$f={$blk:Q.ptr.prototype.handleMethods};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};Q.prototype.handleMethods=function(a){return this.$val.handleMethods(a);};Q.ptr.prototype.printArg=function(a,b){var a,aa,ab,ac,ad,ae,af,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;c.arg=a;c.value=new G.Value.ptr(BJ.nil,0,0);if($interfaceIsEqual(a,$ifaceNil)){$s=1;continue;}$s=2;continue;case 1:d=b;if((d===(84))||(d===(118))){$s=4;continue;}$s=5;continue;case 4:c.fmt.padString("");$s=6;continue;case 5:$r=c.badVerb(b);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 6:case 3:$s=-1;return;case 2:e=b;if(e===(84)){$s=9;continue;}if(e===(112)){$s=10;continue;}$s=11;continue;case 9:f=G.TypeOf(a).String();$s=12;case 12:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$r=c.fmt.fmtS(f);$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 10:g=G.ValueOf(a);$s=14;case 14:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$r=c.fmtPointer($clone(g,G.Value),112);$s=15;case 15:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 11:case 8:h=a;if($assertType(h,$Bool,true)[1]){$s=16;continue;}if($assertType(h,$Float32,true)[1]){$s=17;continue;}if($assertType(h,$Float64,true)[1]){$s=18;continue;}if($assertType(h,$Complex64,true)[1]){$s=19;continue;}if($assertType(h,$Complex128,true)[1]){$s=20;continue;}if($assertType(h,$Int,true)[1]){$s=21;continue;}if($assertType(h,$Int8,true)[1]){$s=22;continue;}if($assertType(h,$Int16,true)[1]){$s=23;continue;}if($assertType(h,$Int32,true)[1]){$s=24;continue;}if($assertType(h,$Int64,true)[1]){$s=25;continue;}if($assertType(h,$Uint,true)[1]){$s=26;continue;}if($assertType(h,$Uint8,true)[1]){$s=27;continue;}if($assertType(h,$Uint16,true)[1]){$s=28;continue;}if($assertType(h,$Uint32,true)[1]){$s=29;continue;}if($assertType(h,$Uint64,true)[1]){$s=30;continue;}if($assertType(h,$Uintptr,true)[1]){$s=31;continue;}if($assertType(h,$String,true)[1]){$s=32;continue;}if($assertType(h,BO,true)[1]){$s=33;continue;}if($assertType(h,G.Value,true)[1]){$s=34;continue;}$s=35;continue;case 16:i=h.$val;$r=c.fmtBool(i,b);$s=37;case 37:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 17:j=h.$val;$r=c.fmtFloat((j),32,b);$s=38;case 38:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 18:k=h.$val;$r=c.fmtFloat(k,64,b);$s=39;case 39:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 19:l=h.$val;$r=c.fmtComplex((new $Complex128(l.$real,l.$imag)),64,b);$s=40;case 40:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 20:m=h.$val;$r=c.fmtComplex(m,128,b);$s=41;case 41:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 21:n=h.$val;$r=c.fmtInteger((new $Uint64(0,n)),true,b);$s=42;case 42:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 22:o=h.$val;$r=c.fmtInteger((new $Uint64(0,o)),true,b);$s=43;case 43:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 23:p=h.$val;$r=c.fmtInteger((new $Uint64(0,p)),true,b);$s=44;case 44:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 24:q=h.$val;$r=c.fmtInteger((new $Uint64(0,q)),true,b);$s=45;case 45:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 25:r=h.$val;$r=c.fmtInteger((new $Uint64(r.$high,r.$low)),true,b);$s=46;case 46:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 26:s=h.$val;$r=c.fmtInteger((new $Uint64(0,s)),false,b);$s=47;case 47:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 27:t=h.$val;$r=c.fmtInteger((new $Uint64(0,t)),false,b);$s=48;case 48:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 28:u=h.$val;$r=c.fmtInteger((new $Uint64(0,u)),false,b);$s=49;case 49:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 29:v=h.$val;$r=c.fmtInteger((new $Uint64(0,v)),false,b);$s=50;case 50:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 30:w=h.$val;$r=c.fmtInteger(w,false,b);$s=51;case 51:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 31:x=h.$val;$r=c.fmtInteger((new $Uint64(0,x.constructor===Number?x:1)),false,b);$s=52;case 52:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 32:y=h.$val;$r=c.fmtString(y,b);$s=53;case 53:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 33:z=h.$val;$r=c.fmtBytes(z,b,"[]byte");$s=54;case 54:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 34:aa=h.$val;if($clone(aa,G.Value).IsValid()&&$clone(aa,G.Value).CanInterface()){$s=55;continue;}$s=56;continue;case 55:ac=$clone(aa,G.Value).Interface();$s=57;case 57:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}c.arg=ac;ad=c.handleMethods(b);$s=60;case 60:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}if(ad){$s=58;continue;}$s=59;continue;case 58:$s=-1;return;case 59:case 56:$r=c.printValue($clone(aa,G.Value),b,0);$s=61;case 61:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=36;continue;case 35:ab=h;ae=c.handleMethods(b);$s=64;case 64:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}if(!ae){$s=62;continue;}$s=63;continue;case 62:af=G.ValueOf(ab);$s=65;case 65:if($c){$c=false;af=af.$blk();}if(af&&af.$blk!==undefined){break s;}$r=c.printValue($clone(af,G.Value),b,0);$s=66;case 66:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 63:case 36:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.printArg};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.printArg=function(a,b){return this.$val.printArg(a,b);};Q.ptr.prototype.printValue=function(a,b,c){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c>0&&$clone(a,G.Value).IsValid()&&$clone(a,G.Value).CanInterface()){$s=1;continue;}$s=2;continue;case 1:e=$clone(a,G.Value).Interface();$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d.arg=e;f=d.handleMethods(b);$s=6;case 6:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}if(f){$s=4;continue;}$s=5;continue;case 4:$s=-1;return;case 5:case 2:d.arg=$ifaceNil;d.value=a;g=a;h=$clone(a,G.Value).Kind();if(h===(0)){$s=8;continue;}if(h===(1)){$s=9;continue;}if((h===(2))||(h===(3))||(h===(4))||(h===(5))||(h===(6))){$s=10;continue;}if((h===(7))||(h===(8))||(h===(9))||(h===(10))||(h===(11))||(h===(12))){$s=11;continue;}if(h===(13)){$s=12;continue;}if(h===(14)){$s=13;continue;}if(h===(15)){$s=14;continue;}if(h===(16)){$s=15;continue;}if(h===(24)){$s=16;continue;}if(h===(21)){$s=17;continue;}if(h===(25)){$s=18;continue;}if(h===(20)){$s=19;continue;}if((h===(17))||(h===(23))){$s=20;continue;}if(h===(22)){$s=21;continue;}if((h===(18))||(h===(19))||(h===(26))){$s=22;continue;}$s=23;continue;case 8:if(c===0){$s=25;continue;}$s=26;continue;case 25:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("");$s=27;continue;case 26:i=b;if(i===(118)){$s=29;continue;}$s=30;continue;case 29:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("");$s=31;continue;case 30:$r=d.badVerb(b);$s=32;case 32:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 31:case 28:case 27:$s=24;continue;case 9:$r=d.fmtBool($clone(g,G.Value).Bool(),b);$s=33;case 33:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 10:$r=d.fmtInteger(((j=$clone(g,G.Value).Int(),new $Uint64(j.$high,j.$low))),true,b);$s=34;case 34:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 11:$r=d.fmtInteger($clone(g,G.Value).Uint(),false,b);$s=35;case 35:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 12:$r=d.fmtFloat($clone(g,G.Value).Float(),32,b);$s=36;case 36:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 13:$r=d.fmtFloat($clone(g,G.Value).Float(),64,b);$s=37;case 37:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 14:$r=d.fmtComplex($clone(g,G.Value).Complex(),64,b);$s=38;case 38:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 15:$r=d.fmtComplex($clone(g,G.Value).Complex(),128,b);$s=39;case 39:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 16:k=$clone(g,G.Value).String();$s=40;case 40:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}$r=d.fmtString(k,b);$s=41;case 41:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 17:if(d.fmt.fmtFlags.sharpV){$s=42;continue;}$s=43;continue;case 42:l=$clone(g,G.Value).Type().String();$s=45;case 45:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$r=(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(l);$s=46;case 46:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if($clone(g,G.Value).IsNil()){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("(nil)");$s=-1;return;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(123);$s=44;continue;case 43:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("map[");case 44:m=D.Sort($clone(g,G.Value));$s=47;case 47:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;o=n.Key;p=0;case 48:if(!(p=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]);if(q>0){if(d.fmt.fmtFlags.sharpV){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(", ");}else{(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(32);}}$r=d.printValue($clone(r,G.Value),b,c+1>>0);$s=50;case 50:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(58);$r=d.printValue($clone((s=n.Value,((q<0||q>=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+q])),G.Value),b,c+1>>0);$s=51;case 51:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}p++;$s=48;continue;case 49:if(d.fmt.fmtFlags.sharpV){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(125);}else{(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(93);}$s=24;continue;case 18:if(d.fmt.fmtFlags.sharpV){$s=52;continue;}$s=53;continue;case 52:t=$clone(g,G.Value).Type().String();$s=54;case 54:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}$r=(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(t);$s=55;case 55:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 53:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(123);u=0;case 56:if(!(u<$clone(g,G.Value).NumField())){$s=57;continue;}if(u>0){if(d.fmt.fmtFlags.sharpV){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(", ");}else{(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(32);}}if(d.fmt.fmtFlags.plusV||d.fmt.fmtFlags.sharpV){$s=58;continue;}$s=59;continue;case 58:v=$clone(g,G.Value).Type().Field(u);$s=60;case 60:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}w=v.Name;if(!(w==="")){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(w);(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(58);}case 59:x=AD($clone(g,G.Value),u);$s=61;case 61:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}$r=d.printValue($clone(x,G.Value),b,c+1>>0);$s=62;case 62:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}u=u+(1)>>0;$s=56;continue;case 57:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(125);$s=24;continue;case 19:y=$clone(g,G.Value).Elem();$s=63;case 63:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}z=y;if(!$clone(z,G.Value).IsValid()){$s=64;continue;}$s=65;continue;case 64:if(d.fmt.fmtFlags.sharpV){$s=67;continue;}$s=68;continue;case 67:aa=$clone(g,G.Value).Type().String();$s=70;case 70:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}$r=(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(aa);$s=71;case 71:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("(nil)");$s=69;continue;case 68:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("");case 69:$s=66;continue;case 65:$r=d.printValue($clone(z,G.Value),b,c+1>>0);$s=72;case 72:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 66:$s=24;continue;case 20:ab=b;if((ab===(115))||(ab===(113))||(ab===(120))||(ab===(88))){$s=74;continue;}$s=75;continue;case 74:ac=$clone(g,G.Value).Type();ad=ac.Elem();$s=78;case 78:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ae=ad.Kind();$s=79;case 79:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}if(ae===8){$s=76;continue;}$s=77;continue;case 76:af=BO.nil;if($clone(g,G.Value).Kind()===23){$s=80;continue;}if($clone(g,G.Value).CanAddr()){$s=81;continue;}$s=82;continue;case 80:ag=$clone(g,G.Value).Bytes();$s=84;case 84:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}af=ag;$s=83;continue;case 81:ah=$clone(g,G.Value).Slice(0,$clone(g,G.Value).Len());$s=85;case 85:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ai=$clone(ah,G.Value).Bytes();$s=86;case 86:if($c){$c=false;ai=ai.$blk();}if(ai&&ai.$blk!==undefined){break s;}af=ai;$s=83;continue;case 82:af=$makeSlice(BO,$clone(g,G.Value).Len());aj=af;ak=0;case 87:if(!(ak=af.$length)?($throwRuntimeError("index out of range"),undefined):af.$array[af.$offset+al]=((an.$low<<24>>>24)));ak++;$s=87;continue;case 88:case 83:ao=af;ap=b;aq=ac.String();$s=91;case 91:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;$r=d.fmtBytes(ao,ap,ar);$s=92;case 92:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 77:case 75:case 73:if(d.fmt.fmtFlags.sharpV){$s=93;continue;}$s=94;continue;case 93:as=$clone(g,G.Value).Type().String();$s=96;case 96:if($c){$c=false;as=as.$blk();}if(as&&as.$blk!==undefined){break s;}$r=(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(as);$s=97;case 97:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(($clone(g,G.Value).Kind()===23)&&$clone(g,G.Value).IsNil()){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString("(nil)");$s=-1;return;}(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(123);at=0;case 98:if(!(at<$clone(g,G.Value).Len())){$s=99;continue;}if(at>0){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteString(", ");}au=$clone(g,G.Value).Index(at);$s=100;case 100:if($c){$c=false;au=au.$blk();}if(au&&au.$blk!==undefined){break s;}$r=d.printValue($clone(au,G.Value),b,c+1>>0);$s=101;case 101:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}at=at+(1)>>0;$s=98;continue;case 99:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(125);$s=95;continue;case 94:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(91);av=0;case 102:if(!(av<$clone(g,G.Value).Len())){$s=103;continue;}if(av>0){(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(32);}aw=$clone(g,G.Value).Index(av);$s=104;case 104:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}$r=d.printValue($clone(aw,G.Value),b,c+1>>0);$s=105;case 105:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}av=av+(1)>>0;$s=102;continue;case 103:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(93);case 95:$s=24;continue;case 21:if((c===0)&&!(($clone(g,G.Value).Pointer()===0))){$s=106;continue;}$s=107;continue;case 106:ax=$clone(g,G.Value).Elem();$s=109;case 109:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ay=ax;az=$clone(ay,G.Value).Kind();if((az===(17))||(az===(23))||(az===(25))||(az===(21))){$s=110;continue;}$s=111;continue;case 110:(d.$ptr_buf||(d.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},d))).WriteByte(38);$r=d.printValue($clone(ay,G.Value),b,c+1>>0);$s=112;case 112:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 111:case 108:case 107:$r=d.fmtPointer($clone(g,G.Value),b);$s=113;case 113:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 22:$r=d.fmtPointer($clone(g,G.Value),b);$s=114;case 114:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=24;continue;case 23:$r=d.unknownType($clone(g,G.Value));$s=115;case 115:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 24:case 7:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.printValue};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.printValue=function(a,b,c){return this.$val.printValue(a,b,c);};AG=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=false;e=0;e=b;if(b=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+b]),$Int,true);c=f[0];d=f[1];if(!d){$s=3;continue;}$s=4;continue;case 3:g=G.ValueOf(((b<0||b>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+b]));$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;i=$clone(h,G.Value).Kind();if((i===(2))||(i===(3))||(i===(4))||(i===(5))||(i===(6))){j=$clone(h,G.Value).Int();if((k=(new $Int64(0,(((j.$low+((j.$high>>31)*4294967296))>>0)))),(k.$high===j.$high&&k.$low===j.$low))){c=(((j.$low+((j.$high>>31)*4294967296))>>0));d=true;}}else if((i===(7))||(i===(8))||(i===(9))||(i===(10))||(i===(11))||(i===(12))){l=$clone(h,G.Value).Uint();if((m=(new $Int64(l.$high,l.$low)),(m.$high>0||(m.$high===0&&m.$low>=0)))&&(n=(new $Uint64(0,((l.$low>>0)))),(n.$high===l.$high&&n.$low===l.$low))){c=((l.$low>>0));d=true;}}case 5:case 4:e=b+1>>0;if(AE(c)){c=0;d=false;}case 2:$s=-1;return[c,d,e];}return;}if($f===undefined){$f={$blk:AG};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};AH=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;b=0;c=0;d=false;if(a.length<3){e=0;f=1;g=false;b=e;c=f;d=g;return[b,c,d];}h=1;while(true){if(!(h>0;o=false;b=m;c=n;d=o;return[b,c,d];}p=j-1>>0;q=h+1>>0;r=true;b=p;c=q;d=r;return[b,c,d];}h=h+(1)>>0;}s=0;t=1;u=false;b=s;c=t;d=u;return[b,c,d];};Q.ptr.prototype.argNumber=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;e=0;f=0;g=false;h=this;if(b.length<=c||!((b.charCodeAt(c)===91))){i=a;j=c;k=false;e=i;f=j;g=k;return[e,f,g];}h.reordered=true;l=AH($substring(b,c));m=l[0];n=l[1];o=l[2];if(o&&0<=m&&m>0;r=true;e=p;f=q;g=r;return[e,f,g];}h.goodArgNum=false;s=a;t=c+n>>0;u=o;e=s;f=t;g=u;return[e,f,g];};Q.prototype.argNumber=function(a,b,c,d){return this.$val.argNumber(a,b,c,d);};Q.ptr.prototype.badArgNum=function(a){var a,b;b=this;(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("%!");(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteRune(a);(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("(BADINDEX)");};Q.prototype.badArgNum=function(a){return this.$val.badArgNum(a);};Q.ptr.prototype.missingArg=function(a){var a,b;b=this;(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("%!");(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteRune(a);(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteString("(MISSING)");};Q.prototype.missingArg=function(a){return this.$val.missingArg(a);};Q.ptr.prototype.doPrintf=function(a,b){var a,aa,ab,ac,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=a.length;e=0;f=false;c.reordered=false;g=0;case 1:if(!(g>0;}if(g>h){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString($substring(a,h,g));}if(g>=d){$s=2;continue;}g=g+(1)>>0;c.fmt.clearflags();case 3:if(!(g=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+e]),((i>>0)));$s=15;case 15:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e+(1)>>0;g=g+(1)>>0;$s=1;continue s;case 14:$s=4;continue s;case 12:case 5:g=g+(1)>>0;$s=3;continue;case 4:k=c.argNumber(e,a,g,b.$length);e=k[0];g=k[1];f=k[2];if(g>0;m=AG(b,e);$s=19;case 19:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;c.fmt.wid=l[0];c.fmt.fmtFlags.widPresent=l[1];e=l[2];if(!c.fmt.fmtFlags.widPresent){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString("%!(BADWIDTH)");}if(c.fmt.wid<0){c.fmt.wid=-c.fmt.wid;c.fmt.fmtFlags.minus=true;c.fmt.fmtFlags.zero=false;}f=false;$s=18;continue;case 17:n=AF(a,g,d);c.fmt.wid=n[0];c.fmt.fmtFlags.widPresent=n[1];g=n[2];if(f&&c.fmt.fmtFlags.widPresent){c.goodArgNum=false;}case 18:if((g+1>>0)>0;if(f){c.goodArgNum=false;}o=c.argNumber(e,a,g,b.$length);e=o[0];g=o[1];f=o[2];if(g>0;q=AG(b,e);$s=25;case 25:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;c.fmt.prec=p[0];c.fmt.fmtFlags.precPresent=p[1];e=p[2];if(c.fmt.prec<0){c.fmt.prec=0;c.fmt.fmtFlags.precPresent=false;}if(!c.fmt.fmtFlags.precPresent){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString("%!(BADPREC)");}f=false;$s=24;continue;case 23:r=AF(a,g,d);c.fmt.prec=r[0];c.fmt.fmtFlags.precPresent=r[1];g=r[2];if(!c.fmt.fmtFlags.precPresent){c.fmt.prec=0;c.fmt.fmtFlags.precPresent=true;}case 24:case 21:if(!f){s=c.argNumber(e,a,g,b.$length);e=s[0];g=s[1];f=s[2];}if(g>=d){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString("%!(NOVERB)");$s=2;continue;}t=((a.charCodeAt(g)>>0));u=1;v=t;w=u;if(v>=128){x=B.DecodeRuneInString($substring(a,g));v=x[0];w=x[1];}g=g+(w)>>0;if((v===37)){$s=27;continue;}if(!c.goodArgNum){$s=28;continue;}if(e>=b.$length){$s=29;continue;}if((v===118)){$s=30;continue;}$s=31;continue;case 27:(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteByte(37);$s=32;continue;case 28:c.badArgNum(v);$s=32;continue;case 29:c.missingArg(v);$s=32;continue;case 30:c.fmt.fmtFlags.sharpV=c.fmt.fmtFlags.sharp;c.fmt.fmtFlags.sharp=false;c.fmt.fmtFlags.plusV=c.fmt.fmtFlags.plus;c.fmt.fmtFlags.plus=false;$r=c.printArg(((e<0||e>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+e]),v);$s=33;case 33:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e+(1)>>0;$s=32;continue;case 31:$r=c.printArg(((e<0||e>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+e]),v);$s=34;case 34:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}e=e+(1)>>0;case 32:case 26:$s=1;continue;case 2:if(!c.reordered&&e=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+z]);if(aa>0){(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString(", ");}if($interfaceIsEqual(ab,$ifaceNil)){$s=39;continue;}$s=40;continue;case 39:(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString("");$s=41;continue;case 40:ac=G.TypeOf(ab).String();$s=42;case 42:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}$r=(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteString(ac);$s=43;case 43:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteByte(61);$r=c.printArg(ab,118);$s=44;case 44:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 41:z++;$s=37;continue;case 38:(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteByte(41);case 36:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.doPrintf};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.doPrintf=function(a,b){return this.$val.doPrintf(a,b);};Q.ptr.prototype.doPrint=function(a){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=false;d=a;e=0;case 1:if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);if(!(!($interfaceIsEqual(g,$ifaceNil)))){h=false;$s=3;continue s;}i=G.TypeOf(g).Kind();$s=4;case 4:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i===24;case 3:j=h;if(f>0&&!j&&!c){(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(32);}$r=b.printArg(g,118);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=j;e++;$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.doPrint};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.doPrint=function(a){return this.$val.doPrint(a);};Q.ptr.prototype.doPrintln=function(a){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=a;d=0;case 1:if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);if(e>0){(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(32);}$r=b.printArg(f,118);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d++;$s=1;continue;case 2:(b.$ptr_buf||(b.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},b))).WriteByte(10);$s=-1;return;}return;}if($f===undefined){$f={$blk:Q.ptr.prototype.doPrintln};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};Q.prototype.doPrintln=function(a){return this.$val.doPrintln(a);};AV.ptr.prototype.Read=function(a){var a,b,c,d,e,f;b=0;c=$ifaceNil;d=this;e=0;f=C.New("ScanState's Read should not be called. Use ReadRune");b=e;c=f;return[b,c];};AV.prototype.Read=function(a){return this.$val.Read(a);};AV.ptr.prototype.ReadRune=function(){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=0;b=0;c=$ifaceNil;d=this;if(d.atEOF||d.count>=d.ssave.argLimit){c=E.EOF;$s=-1;return[a,b,c];}f=d.rs.ReadRune();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;a=e[0];b=e[1];c=e[2];if($interfaceIsEqual(c,$ifaceNil)){d.count=d.count+(1)>>0;if(d.ssave.nlIsEnd&&(a===10)){d.atEOF=true;}}else if($interfaceIsEqual(c,E.EOF)){d.atEOF=true;}$s=-1;return[a,b,c];}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.ReadRune};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.ReadRune=function(){return this.$val.ReadRune();};AV.ptr.prototype.Width=function(){var a,b,c,d,e,f,g;a=0;b=false;c=this;if(c.ssave.maxWid===1073741824){d=0;e=false;a=d;b=e;return[a,b];}f=c.ssave.maxWid;g=true;a=f;b=g;return[a,b];};AV.prototype.Width=function(){return this.$val.Width();};AV.ptr.prototype.getRune=function(){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=0;b=this;d=b.ReadRune();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;a=c[0];e=c[2];if(!($interfaceIsEqual(e,$ifaceNil))){if($interfaceIsEqual(e,E.EOF)){a=-1;$s=-1;return a;}b.error(e);}$s=-1;return a;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.getRune};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.getRune=function(){return this.$val.getRune();};AV.ptr.prototype.UnreadRune=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.rs.UnreadRune();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}b;a.atEOF=false;a.count=a.count-(1)>>0;$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.UnreadRune};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.UnreadRune=function(){return this.$val.UnreadRune();};AV.ptr.prototype.error=function(a){var a,b,c;b=this;$panic((c=new AU.ptr(a),new c.constructor.elem(c)));};AV.prototype.error=function(a){return this.$val.error(a);};AV.ptr.prototype.errorString=function(a){var a,b,c;b=this;$panic((c=new AU.ptr(C.New(a)),new c.constructor.elem(c)));};AV.prototype.errorString=function(a){return this.$val.errorString(a);};AV.ptr.prototype.Token=function(a,b){var a,b,c,d,e,f,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=[c];d=BO.nil;c[0]=$ifaceNil;e=this;$deferred.push([(function(c){return function(){var f,g,h,i;f=$recover();if(!($interfaceIsEqual(f,$ifaceNil))){g=$assertType(f,AU,true);h=$clone(g[0],AU);i=g[1];if(i){c[0]=h.err;}else{$panic(f);}}};})(c),[]]);if(b===$throwNilPointerError){b=AZ;}e.buf=$subslice(e.buf,0,0);f=e.token(a,b);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}d=f;$s=-1;return[d,c[0]];}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if(!$curGoroutine.asleep){return[d,c[0]];}if($curGoroutine.asleep){if($f===undefined){$f={$blk:AV.ptr.prototype.Token};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};AV.prototype.Token=function(a,b){return this.$val.Token(a,b);};AY=function(a){var a,b,c,d,e;if(a>=65536){return false;}b=((a<<16>>>16));c=AX;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),BM);if(b1024){return;}b.buf=$subslice(b.buf,0,0);b.rs=$ifaceNil;BB.Put(b);};AV.prototype.free=function(a){return this.$val.free(a);};AV.ptr.prototype.SkipSpace=function(){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;case 1:b=a.getRune();$s=3;case 3:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;if(c===-1){$s=-1;return;}if(!(c===13)){d=false;$s=6;continue s;}e=a.peek("\n");$s=7;case 7:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;case 6:if(d){$s=4;continue;}$s=5;continue;case 4:$s=1;continue;case 5:if(c===10){$s=8;continue;}$s=9;continue;case 8:if(a.ssave.nlIsSpace){$s=1;continue;}a.errorString("unexpected newline");$s=-1;return;case 9:if(!AY(c)){$s=10;continue;}$s=11;continue;case 10:f=a.UnreadRune();$s=12;case 12:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;$s=2;continue;case 11:$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.SkipSpace};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.SkipSpace=function(){return this.$val.SkipSpace();};AV.ptr.prototype.token=function(a,b){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(a){$s=1;continue;}$s=2;continue;case 1:$r=c.SkipSpace();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:case 4:d=c.getRune();$s=6;case 6:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===-1){$s=5;continue;}f=b(e);$s=9;case 9:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}if(!f){$s=7;continue;}$s=8;continue;case 7:g=c.UnreadRune();$s=10;case 10:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}g;$s=5;continue;case 8:(c.$ptr_buf||(c.$ptr_buf=new BK(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))).WriteRune(e);$s=4;continue;case 5:$s=-1;return(h=c.buf,$subslice(new BO(h.$array),h.$offset,h.$offset+h.$length));}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.token};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.token=function(a,b){return this.$val.token(a,b);};BF=function(a,b){var a,b,c,d,e,f,g;c=a;d=0;while(true){if(!(d=0;}return;}if($f===undefined){$f={$blk:AV.ptr.prototype.peek};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AV.prototype.peek=function(a){return this.$val.peek(a);};CO.methods=[{prop:"clearflags",name:"clearflags",pkg:"fmt",typ:$funcType([],[],false)},{prop:"init",name:"init",pkg:"fmt",typ:$funcType([BK],[],false)},{prop:"writePadding",name:"writePadding",pkg:"fmt",typ:$funcType([$Int],[],false)},{prop:"pad",name:"pad",pkg:"fmt",typ:$funcType([BO],[],false)},{prop:"padString",name:"padString",pkg:"fmt",typ:$funcType([$String],[],false)},{prop:"fmtBoolean",name:"fmtBoolean",pkg:"fmt",typ:$funcType([$Bool],[],false)},{prop:"fmtUnicode",name:"fmtUnicode",pkg:"fmt",typ:$funcType([$Uint64],[],false)},{prop:"fmtInteger",name:"fmtInteger",pkg:"fmt",typ:$funcType([$Uint64,$Int,$Bool,$String],[],false)},{prop:"truncateString",name:"truncateString",pkg:"fmt",typ:$funcType([$String],[$String],false)},{prop:"truncate",name:"truncate",pkg:"fmt",typ:$funcType([BO],[BO],false)},{prop:"fmtS",name:"fmtS",pkg:"fmt",typ:$funcType([$String],[],false)},{prop:"fmtBs",name:"fmtBs",pkg:"fmt",typ:$funcType([BO],[],false)},{prop:"fmtSbx",name:"fmtSbx",pkg:"fmt",typ:$funcType([$String,BO,$String],[],false)},{prop:"fmtSx",name:"fmtSx",pkg:"fmt",typ:$funcType([$String,$String],[],false)},{prop:"fmtBx",name:"fmtBx",pkg:"fmt",typ:$funcType([BO,$String],[],false)},{prop:"fmtQ",name:"fmtQ",pkg:"fmt",typ:$funcType([$String],[],false)},{prop:"fmtC",name:"fmtC",pkg:"fmt",typ:$funcType([$Uint64],[],false)},{prop:"fmtQc",name:"fmtQc",pkg:"fmt",typ:$funcType([$Uint64],[],false)},{prop:"fmtFloat",name:"fmtFloat",pkg:"fmt",typ:$funcType([$Float64,$Int,$Int32,$Int],[],false)}];BK.methods=[{prop:"Write",name:"Write",pkg:"",typ:$funcType([BO],[],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[],false)},{prop:"WriteByte",name:"WriteByte",pkg:"",typ:$funcType([$Uint8],[],false)},{prop:"WriteRune",name:"WriteRune",pkg:"",typ:$funcType([$Int32],[],false)}];BQ.methods=[{prop:"free",name:"free",pkg:"fmt",typ:$funcType([],[],false)},{prop:"Width",name:"Width",pkg:"",typ:$funcType([],[$Int,$Bool],false)},{prop:"Precision",name:"Precision",pkg:"",typ:$funcType([],[$Int,$Bool],false)},{prop:"Flag",name:"Flag",pkg:"",typ:$funcType([$Int],[$Bool],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([BO],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)},{prop:"unknownType",name:"unknownType",pkg:"fmt",typ:$funcType([G.Value],[],false)},{prop:"badVerb",name:"badVerb",pkg:"fmt",typ:$funcType([$Int32],[],false)},{prop:"fmtBool",name:"fmtBool",pkg:"fmt",typ:$funcType([$Bool,$Int32],[],false)},{prop:"fmt0x64",name:"fmt0x64",pkg:"fmt",typ:$funcType([$Uint64,$Bool],[],false)},{prop:"fmtInteger",name:"fmtInteger",pkg:"fmt",typ:$funcType([$Uint64,$Bool,$Int32],[],false)},{prop:"fmtFloat",name:"fmtFloat",pkg:"fmt",typ:$funcType([$Float64,$Int,$Int32],[],false)},{prop:"fmtComplex",name:"fmtComplex",pkg:"fmt",typ:$funcType([$Complex128,$Int,$Int32],[],false)},{prop:"fmtString",name:"fmtString",pkg:"fmt",typ:$funcType([$String,$Int32],[],false)},{prop:"fmtBytes",name:"fmtBytes",pkg:"fmt",typ:$funcType([BO,$Int32,$String],[],false)},{prop:"fmtPointer",name:"fmtPointer",pkg:"fmt",typ:$funcType([G.Value,$Int32],[],false)},{prop:"catchPanic",name:"catchPanic",pkg:"fmt",typ:$funcType([$emptyInterface,$Int32,$String],[],false)},{prop:"handleMethods",name:"handleMethods",pkg:"fmt",typ:$funcType([$Int32],[$Bool],false)},{prop:"printArg",name:"printArg",pkg:"fmt",typ:$funcType([$emptyInterface,$Int32],[],false)},{prop:"printValue",name:"printValue",pkg:"fmt",typ:$funcType([G.Value,$Int32,$Int],[],false)},{prop:"argNumber",name:"argNumber",pkg:"fmt",typ:$funcType([$Int,$String,$Int,$Int],[$Int,$Int,$Bool],false)},{prop:"badArgNum",name:"badArgNum",pkg:"fmt",typ:$funcType([$Int32],[],false)},{prop:"missingArg",name:"missingArg",pkg:"fmt",typ:$funcType([$Int32],[],false)},{prop:"doPrintf",name:"doPrintf",pkg:"fmt",typ:$funcType([$String,BI],[],false)},{prop:"doPrint",name:"doPrint",pkg:"fmt",typ:$funcType([BI],[],false)},{prop:"doPrintln",name:"doPrintln",pkg:"fmt",typ:$funcType([BI],[],false)}];BT.methods=[{prop:"Read",name:"Read",pkg:"",typ:$funcType([BO],[$Int,$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"Width",name:"Width",pkg:"",typ:$funcType([],[$Int,$Bool],false)},{prop:"getRune",name:"getRune",pkg:"fmt",typ:$funcType([],[$Int32],false)},{prop:"mustReadRune",name:"mustReadRune",pkg:"fmt",typ:$funcType([],[$Int32],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"error",name:"error",pkg:"fmt",typ:$funcType([$error],[],false)},{prop:"errorString",name:"errorString",pkg:"fmt",typ:$funcType([$String],[],false)},{prop:"Token",name:"Token",pkg:"",typ:$funcType([$Bool,CP],[BO,$error],false)},{prop:"free",name:"free",pkg:"fmt",typ:$funcType([AW],[],false)},{prop:"SkipSpace",name:"SkipSpace",pkg:"",typ:$funcType([],[],false)},{prop:"token",name:"token",pkg:"fmt",typ:$funcType([$Bool,CP],[BO],false)},{prop:"consume",name:"consume",pkg:"fmt",typ:$funcType([$String,$Bool],[$Bool],false)},{prop:"peek",name:"peek",pkg:"fmt",typ:$funcType([$String],[$Bool],false)},{prop:"notEOF",name:"notEOF",pkg:"fmt",typ:$funcType([],[],false)},{prop:"accept",name:"accept",pkg:"fmt",typ:$funcType([$String],[$Bool],false)},{prop:"okVerb",name:"okVerb",pkg:"fmt",typ:$funcType([$Int32,$String,$String],[$Bool],false)},{prop:"scanBool",name:"scanBool",pkg:"fmt",typ:$funcType([$Int32],[$Bool],false)},{prop:"getBase",name:"getBase",pkg:"fmt",typ:$funcType([$Int32],[$Int,$String],false)},{prop:"scanNumber",name:"scanNumber",pkg:"fmt",typ:$funcType([$String,$Bool],[$String],false)},{prop:"scanRune",name:"scanRune",pkg:"fmt",typ:$funcType([$Int],[$Int64],false)},{prop:"scanBasePrefix",name:"scanBasePrefix",pkg:"fmt",typ:$funcType([],[$Int,$String,$Bool],false)},{prop:"scanInt",name:"scanInt",pkg:"fmt",typ:$funcType([$Int32,$Int],[$Int64],false)},{prop:"scanUint",name:"scanUint",pkg:"fmt",typ:$funcType([$Int32,$Int],[$Uint64],false)},{prop:"floatToken",name:"floatToken",pkg:"fmt",typ:$funcType([],[$String],false)},{prop:"complexTokens",name:"complexTokens",pkg:"fmt",typ:$funcType([],[$String,$String],false)},{prop:"convertFloat",name:"convertFloat",pkg:"fmt",typ:$funcType([$String,$Int],[$Float64],false)},{prop:"scanComplex",name:"scanComplex",pkg:"fmt",typ:$funcType([$Int32,$Int],[$Complex128],false)},{prop:"convertString",name:"convertString",pkg:"fmt",typ:$funcType([$Int32],[$String],false)},{prop:"quotedString",name:"quotedString",pkg:"fmt",typ:$funcType([],[$String],false)},{prop:"hexByte",name:"hexByte",pkg:"fmt",typ:$funcType([],[$Uint8,$Bool],false)},{prop:"hexString",name:"hexString",pkg:"fmt",typ:$funcType([],[$String],false)},{prop:"scanOne",name:"scanOne",pkg:"fmt",typ:$funcType([$Int32,$emptyInterface],[],false)},{prop:"doScan",name:"doScan",pkg:"fmt",typ:$funcType([BI],[$Int,$error],false)},{prop:"advance",name:"advance",pkg:"fmt",typ:$funcType([$String],[$Int],false)},{prop:"doScanf",name:"doScanf",pkg:"fmt",typ:$funcType([$String,BI],[$Int,$error],false)}];J.init("fmt",[{prop:"widPresent",name:"widPresent",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"precPresent",name:"precPresent",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"minus",name:"minus",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"plus",name:"plus",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"sharp",name:"sharp",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"space",name:"space",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"zero",name:"zero",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"plusV",name:"plusV",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"sharpV",name:"sharpV",embedded:false,exported:false,typ:$Bool,tag:""}]);K.init("fmt",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:BK,tag:""},{prop:"fmtFlags",name:"fmtFlags",embedded:true,exported:false,typ:J,tag:""},{prop:"wid",name:"wid",embedded:false,exported:false,typ:$Int,tag:""},{prop:"prec",name:"prec",embedded:false,exported:false,typ:$Int,tag:""},{prop:"intbuf",name:"intbuf",embedded:false,exported:false,typ:BL,tag:""}]);L.init([{prop:"Flag",name:"Flag",pkg:"",typ:$funcType([$Int],[$Bool],false)},{prop:"Precision",name:"Precision",pkg:"",typ:$funcType([],[$Int,$Bool],false)},{prop:"Width",name:"Width",pkg:"",typ:$funcType([],[$Int,$Bool],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([BO],[$Int,$error],false)}]);M.init([{prop:"Format",name:"Format",pkg:"",typ:$funcType([L,$Int32],[],false)}]);N.init([{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}]);O.init([{prop:"GoString",name:"GoString",pkg:"",typ:$funcType([],[$String],false)}]);P.init($Uint8);Q.init("fmt",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:P,tag:""},{prop:"arg",name:"arg",embedded:false,exported:false,typ:$emptyInterface,tag:""},{prop:"value",name:"value",embedded:false,exported:false,typ:G.Value,tag:""},{prop:"fmt",name:"fmt",embedded:false,exported:false,typ:K,tag:""},{prop:"reordered",name:"reordered",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"goodArgNum",name:"goodArgNum",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"panicking",name:"panicking",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"erroring",name:"erroring",embedded:false,exported:false,typ:$Bool,tag:""}]);AI.init([{prop:"Read",name:"Read",pkg:"",typ:$funcType([BO],[$Int,$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"SkipSpace",name:"SkipSpace",pkg:"",typ:$funcType([],[],false)},{prop:"Token",name:"Token",pkg:"",typ:$funcType([$Bool,CP],[BO,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Width",name:"Width",pkg:"",typ:$funcType([],[$Int,$Bool],false)}]);AU.init("fmt",[{prop:"err",name:"err",embedded:false,exported:false,typ:$error,tag:""}]);AV.init("fmt",[{prop:"rs",name:"rs",embedded:false,exported:false,typ:E.RuneScanner,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:P,tag:""},{prop:"count",name:"count",embedded:false,exported:false,typ:$Int,tag:""},{prop:"atEOF",name:"atEOF",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"ssave",name:"ssave",embedded:true,exported:false,typ:AW,tag:""}]);AW.init("fmt",[{prop:"validSave",name:"validSave",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"nlIsEnd",name:"nlIsEnd",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"nlIsSpace",name:"nlIsSpace",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"argLimit",name:"argLimit",embedded:false,exported:false,typ:$Int,tag:""},{prop:"limit",name:"limit",embedded:false,exported:false,typ:$Int,tag:""},{prop:"maxWid",name:"maxWid",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}R=new H.Pool.ptr(0,0,BI.nil,(function(){return new Q.ptr(P.nil,$ifaceNil,new G.Value.ptr(BJ.nil,0,0),new K.ptr(BK.nil,new J.ptr(false,false,false,false,false,false,false,false,false),0,0,BL.zero()),false,false,false,false);}));AX=new BN([$toNativeArray($kindUint16,[9,13]),$toNativeArray($kindUint16,[32,32]),$toNativeArray($kindUint16,[133,133]),$toNativeArray($kindUint16,[160,160]),$toNativeArray($kindUint16,[5760,5760]),$toNativeArray($kindUint16,[8192,8202]),$toNativeArray($kindUint16,[8232,8233]),$toNativeArray($kindUint16,[8239,8239]),$toNativeArray($kindUint16,[8287,8287]),$toNativeArray($kindUint16,[12288,12288])]);BB=new H.Pool.ptr(0,0,BI.nil,(function(){return new AV.ptr($ifaceNil,P.nil,0,false,new AW.ptr(false,false,false,0,0,0));}));BD=C.New("syntax error scanning complex number");BE=C.New("syntax error scanning boolean");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["strings"]=(function(){var $pkg={},$init,C,B,F,D,E,G,A,L,O,CG,CH,CW,H,I,P,AK,AM,AN,BA;C=$packages["errors"];B=$packages["github.com/gopherjs/gopherjs/js"];F=$packages["internal/bytealg"];D=$packages["io"];E=$packages["sync"];G=$packages["unicode"];A=$packages["unicode/utf8"];L=$pkg.Builder=$newType(0,$kindStruct,"strings.Builder",true,"strings",true,function(addr_,buf_){this.$val=this;if(arguments.length===0){this.addr=CG.nil;this.buf=CH.nil;return;}this.addr=addr_;this.buf=buf_;});O=$pkg.Reader=$newType(0,$kindStruct,"strings.Reader",true,"strings",true,function(s_,i_,prevRune_){this.$val=this;if(arguments.length===0){this.s="";this.i=new $Int64(0,0);this.prevRune=0;return;}this.s=s_;this.i=i_;this.prevRune=prevRune_;});CG=$ptrType(L);CH=$sliceType($Uint8);CW=$ptrType(O);H=function(e,f){var e,f;return $parseInt(e.indexOf($global.String.fromCharCode(f)))>>0;};$pkg.IndexByte=H;I=function(e,f){var e,f;return $parseInt(e.indexOf(f))>>0;};$pkg.Index=I;L.ptr.prototype.String=function(){var e;e=this;return($bytesToString(e.buf));};L.prototype.String=function(){return this.$val.String();};L.ptr.prototype.copyCheck=function(){var e;e=this;if(e.addr===CG.nil){e.addr=e;}else if(!(e.addr===e)){$panic(new $String("strings: illegal use of non-zero Builder copied by value"));}};L.prototype.copyCheck=function(){return this.$val.copyCheck();};L.ptr.prototype.Len=function(){var e;e=this;return e.buf.$length;};L.prototype.Len=function(){return this.$val.Len();};L.ptr.prototype.Cap=function(){var e;e=this;return e.buf.$capacity;};L.prototype.Cap=function(){return this.$val.Cap();};L.ptr.prototype.Reset=function(){var e;e=this;e.addr=CG.nil;e.buf=CH.nil;};L.prototype.Reset=function(){return this.$val.Reset();};L.ptr.prototype.grow=function(e){var e,f,g;f=this;g=$makeSlice(CH,f.buf.$length,(($imul(2,f.buf.$capacity))+e>>0));$copySlice(g,f.buf);f.buf=g;};L.prototype.grow=function(e){return this.$val.grow(e);};L.ptr.prototype.Grow=function(e){var e,f;f=this;f.copyCheck();if(e<0){$panic(new $String("strings.Builder.Grow: negative count"));}if((f.buf.$capacity-f.buf.$length>>0)>>24)));return[1,$ifaceNil];}g=f.buf.$length;if((f.buf.$capacity-g>>0)<4){f.grow(4);}h=A.EncodeRune($subslice(f.buf,g,(g+4>>0)),e);f.buf=$subslice(f.buf,0,(g+h>>0));return[h,$ifaceNil];};L.prototype.WriteRune=function(e){return this.$val.WriteRune(e);};L.ptr.prototype.WriteString=function(e){var e,f;f=this;f.copyCheck();f.buf=$appendSlice(f.buf,e);return[e.length,$ifaceNil];};L.prototype.WriteString=function(e){return this.$val.WriteString(e);};O.ptr.prototype.Len=function(){var e,f,g,h,i,j;e=this;if((f=e.i,g=(new $Int64(0,e.s.length)),(f.$high>g.$high||(f.$high===g.$high&&f.$low>=g.$low)))){return 0;}return(((h=(i=(new $Int64(0,e.s.length)),j=e.i,new $Int64(i.$high-j.$high,i.$low-j.$low)),h.$low+((h.$high>>31)*4294967296))>>0));};O.prototype.Len=function(){return this.$val.Len();};O.ptr.prototype.Size=function(){var e;e=this;return(new $Int64(0,e.s.length));};O.prototype.Size=function(){return this.$val.Size();};O.ptr.prototype.Read=function(e){var e,f,g,h,i,j,k,l,m,n;f=0;g=$ifaceNil;h=this;if((i=h.i,j=(new $Int64(0,h.s.length)),(i.$high>j.$high||(i.$high===j.$high&&i.$low>=j.$low)))){k=0;l=D.EOF;f=k;g=l;return[f,g];}h.prevRune=-1;f=$copyString(e,$substring(h.s,$flatten64(h.i)));h.i=(m=h.i,n=(new $Int64(0,f)),new $Int64(m.$high+n.$high,m.$low+n.$low));return[f,g];};O.prototype.Read=function(e){return this.$val.Read(e);};O.ptr.prototype.ReadAt=function(e,f){var e,f,g,h,i,j,k,l,m,n;g=0;h=$ifaceNil;i=this;if((f.$high<0||(f.$high===0&&f.$low<0))){j=0;k=C.New("strings.Reader.ReadAt: negative offset");g=j;h=k;return[g,h];}if((l=(new $Int64(0,i.s.length)),(f.$high>l.$high||(f.$high===l.$high&&f.$low>=l.$low)))){m=0;n=D.EOF;g=m;h=n;return[g,h];}g=$copyString(e,$substring(i.s,$flatten64(f)));if(gg.$high||(f.$high===g.$high&&f.$low>=g.$low)))){return[0,D.EOF];}h=e.s.charCodeAt($flatten64(e.i));e.i=(i=e.i,j=new $Int64(0,1),new $Int64(i.$high+j.$high,i.$low+j.$low));return[h,$ifaceNil];};O.prototype.ReadByte=function(){return this.$val.ReadByte();};O.ptr.prototype.UnreadByte=function(){var e,f,g,h;e=this;if((f=e.i,(f.$high<0||(f.$high===0&&f.$low<=0)))){return C.New("strings.Reader.UnreadByte: at beginning of string");}e.prevRune=-1;e.i=(g=e.i,h=new $Int64(0,1),new $Int64(g.$high-h.$high,g.$low-h.$low));return $ifaceNil;};O.prototype.UnreadByte=function(){return this.$val.UnreadByte();};O.ptr.prototype.ReadRune=function(){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;e=0;f=0;g=$ifaceNil;h=this;if((i=h.i,j=(new $Int64(0,h.s.length)),(i.$high>j.$high||(i.$high===j.$high&&i.$low>=j.$low)))){h.prevRune=-1;k=0;l=0;m=D.EOF;e=k;f=l;g=m;return[e,f,g];}h.prevRune=(((n=h.i,n.$low+((n.$high>>31)*4294967296))>>0));o=h.s.charCodeAt($flatten64(h.i));if(o<128){h.i=(p=h.i,q=new $Int64(0,1),new $Int64(p.$high+q.$high,p.$low+q.$low));r=((o>>0));s=1;t=$ifaceNil;e=r;f=s;g=t;return[e,f,g];}u=A.DecodeRuneInString($substring(h.s,$flatten64(h.i)));e=u[0];f=u[1];h.i=(v=h.i,w=(new $Int64(0,f)),new $Int64(v.$high+w.$high,v.$low+w.$low));return[e,f,g];};O.prototype.ReadRune=function(){return this.$val.ReadRune();};O.ptr.prototype.UnreadRune=function(){var e,f;e=this;if((f=e.i,(f.$high<0||(f.$high===0&&f.$low<=0)))){return C.New("strings.Reader.UnreadRune: at beginning of string");}if(e.prevRune<0){return C.New("strings.Reader.UnreadRune: previous operation was not ReadRune");}e.i=(new $Int64(0,e.prevRune));e.prevRune=-1;return $ifaceNil;};O.prototype.UnreadRune=function(){return this.$val.UnreadRune();};O.ptr.prototype.Seek=function(e,f){var e,f,g,h,i,j,k;g=this;g.prevRune=-1;h=new $Int64(0,0);i=f;if(i===(0)){h=e;}else if(i===(1)){h=(j=g.i,new $Int64(j.$high+e.$high,j.$low+e.$low));}else if(i===(2)){h=(k=(new $Int64(0,g.s.length)),new $Int64(k.$high+e.$high,k.$low+e.$low));}else{return[new $Int64(0,0),C.New("strings.Reader.Seek: invalid whence")];}if((h.$high<0||(h.$high===0&&h.$low<0))){return[new $Int64(0,0),C.New("strings.Reader.Seek: negative position")];}g.i=h;return[h,$ifaceNil];};O.prototype.Seek=function(e,f){return this.$val.Seek(e,f);};O.ptr.prototype.WriteTo=function(e){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=new $Int64(0,0);g=$ifaceNil;h=this;h.prevRune=-1;if((i=h.i,j=(new $Int64(0,h.s.length)),(i.$high>j.$high||(i.$high===j.$high&&i.$low>=j.$low)))){k=new $Int64(0,0);l=$ifaceNil;f=k;g=l;$s=-1;return[f,g];}m=$substring(h.s,$flatten64(h.i));o=D.WriteString(e,m);$s=1;case 1:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;p=n[0];g=n[1];if(p>m.length){$panic(new $String("strings.Reader.WriteTo: invalid WriteString count"));}h.i=(q=h.i,r=(new $Int64(0,p)),new $Int64(q.$high+r.$high,q.$low+r.$low));f=(new $Int64(0,p));if(!((p===m.length))&&$interfaceIsEqual(g,$ifaceNil)){g=D.ErrShortWrite;}$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:O.ptr.prototype.WriteTo};}$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};O.prototype.WriteTo=function(e){return this.$val.WriteTo(e);};O.ptr.prototype.Reset=function(e){var e,f;f=this;O.copy(f,new O.ptr(e,new $Int64(0,0),-1));};O.prototype.Reset=function(e){return this.$val.Reset(e);};P=function(e){var e;return new O.ptr(e,new $Int64(0,0),-1);};$pkg.NewReader=P;AK=function(e,f){var e,f;return I(e,f)>=0;};$pkg.Contains=AK;AM=function(e,f){var e,f;return AN(e,f)>=0;};$pkg.ContainsRune=AM;AN=function(e,f){var e,f,g,h,i,j,k;if(0<=f&&f<128){return H(e,((f<<24>>>24)));}else if((f===65533)){g=e;h=0;while(true){if(!(h=f.length&&$substring(e,0,f.length)===f;};$pkg.HasPrefix=BA;CG.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"copyCheck",name:"copyCheck",pkg:"strings",typ:$funcType([],[],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"grow",name:"grow",pkg:"strings",typ:$funcType([$Int],[],false)},{prop:"Grow",name:"Grow",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([CH],[$Int,$error],false)},{prop:"WriteByte",name:"WriteByte",pkg:"",typ:$funcType([$Uint8],[$error],false)},{prop:"WriteRune",name:"WriteRune",pkg:"",typ:$funcType([$Int32],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}];CW.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([CH],[$Int,$error],false)},{prop:"ReadAt",name:"ReadAt",pkg:"",typ:$funcType([CH,$Int64],[$Int,$error],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([D.Writer],[$Int64,$error],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([$String],[],false)}];L.init("strings",[{prop:"addr",name:"addr",embedded:false,exported:false,typ:CG,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:CH,tag:""}]);O.init("strings",[{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"prevRune",name:"prevRune",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["encoding/hex"]=(function(){var $pkg={},$init,A,B,C,D,V,E,F,K;A=$packages["errors"];B=$packages["fmt"];C=$packages["io"];D=$packages["strings"];V=$sliceType($Uint8);E=function(a){var a;return $imul(a,2);};$pkg.EncodedLen=E;F=function(a,b){var a,b,c,d,e,f,g,h;c=b;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);(g=$imul(e,2),((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]="0123456789abcdef".charCodeAt((f>>>4<<24>>>24))));(h=($imul(e,2))+1>>0,((h<0||h>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+h]="0123456789abcdef".charCodeAt(((f&15)>>>0))));d++;}return $imul(b.$length,2);};$pkg.Encode=F;K=function(a){var a,b;b=$makeSlice(V,E(a.$length));F(b,a);return($bytesToString(b));};$pkg.EncodeToString=K;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrLength=A.New("encoding/hex: odd length hex string");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["bytes"]=(function(){var $pkg={},$init,A,D,B,E,C,I,J,BE,BS,BU,BV,BY,CB,CD,K,F,G,L,AJ,AW,BD,BF,BG,BJ,BO,BP,BQ,BR,BT;A=$packages["errors"];D=$packages["internal/bytealg"];B=$packages["io"];E=$packages["unicode"];C=$packages["unicode/utf8"];I=$pkg.Buffer=$newType(0,$kindStruct,"bytes.Buffer",true,"bytes",true,function(buf_,off_,lastRead_){this.$val=this;if(arguments.length===0){this.buf=BV.nil;this.off=0;this.lastRead=0;return;}this.buf=buf_;this.off=off_;this.lastRead=lastRead_;});J=$pkg.readOp=$newType(1,$kindInt8,"bytes.readOp",true,"bytes",false,null);BE=$pkg.asciiSet=$newType(32,$kindArray,"bytes.asciiSet",true,"bytes",false,null);BS=$pkg.Reader=$newType(0,$kindStruct,"bytes.Reader",true,"bytes",true,function(s_,i_,prevRune_){this.$val=this;if(arguments.length===0){this.s=BV.nil;this.i=new $Int64(0,0);this.prevRune=0;return;}this.s=s_;this.i=i_;this.prevRune=prevRune_;});BU=$ptrType(I);BV=$sliceType($Uint8);BY=$ptrType(BE);CB=$arrayType($Uint32,8);CD=$ptrType(BS);F=function(d,e){var d,e,f,g,h,i;f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(i===e){return h;}g++;}return-1;};$pkg.IndexByte=F;G=function(d,e){var d,e,f,g,h,i;if(!((d.$length===e.$length))){return false;}f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(!((i===((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])))){return false;}g++;}return true;};$pkg.Equal=G;I.ptr.prototype.Bytes=function(){var d;d=this;return $subslice(d.buf,d.off);};I.prototype.Bytes=function(){return this.$val.Bytes();};I.ptr.prototype.String=function(){var d;d=this;if(d===BU.nil){return"";}return($bytesToString($subslice(d.buf,d.off)));};I.prototype.String=function(){return this.$val.String();};I.ptr.prototype.empty=function(){var d;d=this;return d.buf.$length<=d.off;};I.prototype.empty=function(){return this.$val.empty();};I.ptr.prototype.Len=function(){var d;d=this;return d.buf.$length-d.off>>0;};I.prototype.Len=function(){return this.$val.Len();};I.ptr.prototype.Cap=function(){var d;d=this;return d.buf.$capacity;};I.prototype.Cap=function(){return this.$val.Cap();};I.ptr.prototype.Truncate=function(d){var d,e;e=this;if(d===0){e.Reset();return;}e.lastRead=0;if(d<0||d>e.Len()){$panic(new $String("bytes.Buffer: truncation out of range"));}e.buf=$subslice(e.buf,0,(e.off+d>>0));};I.prototype.Truncate=function(d){return this.$val.Truncate(d);};I.ptr.prototype.Reset=function(){var d;d=this;d.buf=$subslice(d.buf,0,0);d.off=0;d.lastRead=0;};I.prototype.Reset=function(){return this.$val.Reset();};I.ptr.prototype.tryGrowByReslice=function(d){var d,e,f;e=this;f=e.buf.$length;if(d<=(e.buf.$capacity-f>>0)){e.buf=$subslice(e.buf,0,(f+d>>0));return[f,true];}return[0,false];};I.prototype.tryGrowByReslice=function(d){return this.$val.tryGrowByReslice(d);};I.ptr.prototype.grow=function(d){var d,e,f,g,h,i,j,k,l;e=this;f=e.Len();if((f===0)&&!((e.off===0))){e.Reset();}g=e.tryGrowByReslice(d);h=g[0];i=g[1];if(i){return h;}if(e.buf===BV.nil&&d<=64){e.buf=$makeSlice(BV,d,64);return 0;}j=e.buf.$capacity;if(d<=((k=j/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))-f>>0)){$copySlice(e.buf,$subslice(e.buf,e.off));}else if(j>((2147483647-j>>0)-d>>0)){$panic($pkg.ErrTooLarge);}else{l=L(($imul(2,j))+d>>0);$copySlice(l,$subslice(e.buf,e.off));e.buf=l;}e.off=0;e.buf=$subslice(e.buf,0,(f+d>>0));return f;};I.prototype.grow=function(d){return this.$val.grow(d);};I.ptr.prototype.Grow=function(d){var d,e,f;e=this;if(d<0){$panic(new $String("bytes.Buffer.Grow: negative count"));}f=e.grow(d);e.buf=$subslice(e.buf,0,f);};I.prototype.Grow=function(d){return this.$val.Grow(d);};I.ptr.prototype.Write=function(d){var d,e,f,g,h,i,j,k,l;e=0;f=$ifaceNil;g=this;g.lastRead=0;h=g.tryGrowByReslice(d.$length);i=h[0];j=h[1];if(!j){i=g.grow(d.$length);}k=$copySlice($subslice(g.buf,i),d);l=$ifaceNil;e=k;f=l;return[e,f];};I.prototype.Write=function(d){return this.$val.Write(d);};I.ptr.prototype.WriteString=function(d){var d,e,f,g,h,i,j,k,l;e=0;f=$ifaceNil;g=this;g.lastRead=0;h=g.tryGrowByReslice(d.length);i=h[0];j=h[1];if(!j){i=g.grow(d.length);}k=$copyString($subslice(g.buf,i),d);l=$ifaceNil;e=k;f=l;return[e,f];};I.prototype.WriteString=function(d){return this.$val.WriteString(d);};I.ptr.prototype.ReadFrom=function(d){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.lastRead=0;case 1:h=g.grow(512);g.buf=$subslice(g.buf,0,h);j=d.Read($subslice(g.buf,h,g.buf.$capacity));$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[0];l=i[1];if(k<0){$panic(K);}g.buf=$subslice(g.buf,0,(h+k>>0));e=(m=(new $Int64(0,k)),new $Int64(e.$high+m.$high,e.$low+m.$low));if($interfaceIsEqual(l,B.EOF)){n=e;o=$ifaceNil;e=n;f=o;$s=-1;return[e,f];}if(!($interfaceIsEqual(l,$ifaceNil))){p=e;q=l;e=p;f=q;$s=-1;return[e,f];}$s=1;continue;case 2:$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:I.ptr.prototype.ReadFrom};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};I.prototype.ReadFrom=function(d){return this.$val.ReadFrom(d);};L=function(d){var d,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);$deferred.push([(function(){if(!($interfaceIsEqual($recover(),$ifaceNil))){$panic($pkg.ErrTooLarge);}}),[]]);return $makeSlice(BV,d);}catch(err){$err=err;return BV.nil;}finally{$callDeferred($deferred,$err);}};I.ptr.prototype.WriteTo=function(d){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.lastRead=0;h=g.Len();if(h>0){$s=1;continue;}$s=2;continue;case 1:j=d.Write($subslice(g.buf,g.off));$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[0];l=i[1];if(k>h){$panic(new $String("bytes.Buffer.WriteTo: invalid Write count"));}g.off=g.off+(k)>>0;e=(new $Int64(0,k));if(!($interfaceIsEqual(l,$ifaceNil))){m=e;n=l;e=m;f=n;$s=-1;return[e,f];}if(!((k===h))){o=e;p=B.ErrShortWrite;e=o;f=p;$s=-1;return[e,f];}case 2:g.Reset();q=e;r=$ifaceNil;e=q;f=r;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:I.ptr.prototype.WriteTo};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};I.prototype.WriteTo=function(d){return this.$val.WriteTo(d);};I.ptr.prototype.WriteByte=function(d){var d,e,f,g,h,i;e=this;e.lastRead=0;f=e.tryGrowByReslice(1);g=f[0];h=f[1];if(!h){g=e.grow(1);}(i=e.buf,((g<0||g>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+g]=d));return $ifaceNil;};I.prototype.WriteByte=function(d){return this.$val.WriteByte(d);};I.ptr.prototype.WriteRune=function(d){var d,e,f,g,h,i,j,k,l,m,n;e=0;f=$ifaceNil;g=this;if(d<128){g.WriteByte(((d<<24>>>24)));h=1;i=$ifaceNil;e=h;f=i;return[e,f];}g.lastRead=0;j=g.tryGrowByReslice(4);k=j[0];l=j[1];if(!l){k=g.grow(4);}e=C.EncodeRune($subslice(g.buf,k,(k+4>>0)),d);g.buf=$subslice(g.buf,0,(k+e>>0));m=e;n=$ifaceNil;e=m;f=n;return[e,f];};I.prototype.WriteRune=function(d){return this.$val.WriteRune(d);};I.ptr.prototype.Read=function(d){var d,e,f,g,h,i,j,k,l,m;e=0;f=$ifaceNil;g=this;g.lastRead=0;if(g.empty()){g.Reset();if(d.$length===0){h=0;i=$ifaceNil;e=h;f=i;return[e,f];}j=0;k=B.EOF;e=j;f=k;return[e,f];}e=$copySlice(d,$subslice(g.buf,g.off));g.off=g.off+(e)>>0;if(e>0){g.lastRead=-1;}l=e;m=$ifaceNil;e=l;f=m;return[e,f];};I.prototype.Read=function(d){return this.$val.Read(d);};I.ptr.prototype.Next=function(d){var d,e,f,g;e=this;e.lastRead=0;f=e.Len();if(d>f){d=f;}g=$subslice(e.buf,e.off,(e.off+d>>0));e.off=e.off+(d)>>0;if(d>0){e.lastRead=-1;}return g;};I.prototype.Next=function(d){return this.$val.Next(d);};I.ptr.prototype.ReadByte=function(){var d,e,f,g;d=this;if(d.empty()){d.Reset();return[0,B.EOF];}g=(e=d.buf,f=d.off,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));d.off=d.off+(1)>>0;d.lastRead=-1;return[g,$ifaceNil];};I.prototype.ReadByte=function(){return this.$val.ReadByte();};I.ptr.prototype.ReadRune=function(){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;d=0;e=0;f=$ifaceNil;g=this;if(g.empty()){g.Reset();h=0;i=0;j=B.EOF;d=h;e=i;f=j;return[d,e,f];}m=(k=g.buf,l=g.off,((l<0||l>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]));if(m<128){g.off=g.off+(1)>>0;g.lastRead=1;n=((m>>0));o=1;p=$ifaceNil;d=n;e=o;f=p;return[d,e,f];}q=C.DecodeRune($subslice(g.buf,g.off));d=q[0];r=q[1];g.off=g.off+(r)>>0;g.lastRead=((r<<24>>24));s=d;t=r;u=$ifaceNil;d=s;e=t;f=u;return[d,e,f];};I.prototype.ReadRune=function(){return this.$val.ReadRune();};I.ptr.prototype.UnreadRune=function(){var d;d=this;if(d.lastRead<=0){return A.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune");}if(d.off>=((d.lastRead>>0))){d.off=d.off-(((d.lastRead>>0)))>>0;}d.lastRead=0;return $ifaceNil;};I.prototype.UnreadRune=function(){return this.$val.UnreadRune();};I.ptr.prototype.UnreadByte=function(){var d;d=this;if(d.lastRead===0){return A.New("bytes.Buffer: UnreadByte: previous operation was not a successful read");}d.lastRead=0;if(d.off>0){d.off=d.off-(1)>>0;}return $ifaceNil;};I.prototype.UnreadByte=function(){return this.$val.UnreadByte();};I.ptr.prototype.ReadBytes=function(d){var d,e,f,g,h,i,j,k;e=BV.nil;f=$ifaceNil;g=this;h=g.readSlice(d);i=h[0];f=h[1];e=$appendSlice(e,i);j=e;k=f;e=j;f=k;return[e,f];};I.prototype.ReadBytes=function(d){return this.$val.ReadBytes(d);};I.ptr.prototype.readSlice=function(d){var d,e,f,g,h,i,j,k;e=BV.nil;f=$ifaceNil;g=this;h=F($subslice(g.buf,g.off),d);i=(g.off+h>>0)+1>>0;if(h<0){i=g.buf.$length;f=B.EOF;}e=$subslice(g.buf,g.off,i);g.off=i;g.lastRead=-1;j=e;k=f;e=j;f=k;return[e,f];};I.prototype.readSlice=function(d){return this.$val.readSlice(d);};I.ptr.prototype.ReadString=function(d){var d,e,f,g,h,i,j,k;e="";f=$ifaceNil;g=this;h=g.readSlice(d);i=h[0];f=h[1];j=($bytesToString(i));k=f;e=j;f=k;return[e,f];};I.prototype.ReadString=function(d){return this.$val.ReadString(d);};AJ=function(d,e){var d,e;return d.$length>=e.$length&&G($subslice(d,0,e.$length),e);};$pkg.HasPrefix=AJ;AW=function(d,e){var d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BD(d,e,false);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(g>=0&&((g<0||g>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g])>=128){h=C.DecodeRune($subslice(d,g));i=h[1];g=g+(i)>>0;}else{g=g+(1)>>0;}$s=-1;return $subslice(d,0,g);}return;}if($f===undefined){$f={$blk:AW};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};$pkg.TrimRightFunc=AW;BD=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=d.$length;case 1:if(!(g>0)){$s=2;continue;}h=(((i=g-1>>0,((i<0||i>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]))>>0));j=1;k=h;l=j;if(k>=128){m=C.DecodeLastRune($subslice(d,0,g));k=m[0];l=m[1];}g=g-(l)>>0;n=e(k);$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}if(n===f){$s=3;continue;}$s=4;continue;case 3:$s=-1;return g;case 4:$s=1;continue;case 2:$s=-1;return-1;}return;}if($f===undefined){$f={$blk:BD};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};BF=function(d){var d,e,f,g,h,i,j,k,l,m,n;e=CB.zero();f=false;g=0;while(true){if(!(g=128){i=$clone(e,BE);j=false;BE.copy(e,i);f=j;return[e,f];}k=h>>>5<<24>>>24;((k<0||k>=e.length)?($throwRuntimeError("index out of range"),undefined):e[k]=((((k<0||k>=e.length)?($throwRuntimeError("index out of range"),undefined):e[k])|(((l=((((h&31)>>>0)>>>0)),l<32?(1<>>0)))>>>0));g=g+(1)>>0;}m=$clone(e,BE);n=true;BE.copy(e,m);f=n;return[e,f];};BE.prototype.contains=function(d){var d,e,f,g;e=this.$val;return!((((((f=d>>>5<<24>>>24,(e.nilCheck,((f<0||f>=e.length)?($throwRuntimeError("index out of range"),undefined):e[f])))&(((g=((((d&31)>>>0)>>>0)),g<32?(1<>>0)))>>>0))===0));};$ptrType(BE).prototype.contains=function(d){return(new BE(this.$get())).contains(d);};BG=function(d){var d,e,f,g;if((d.length===1)&&d.charCodeAt(0)<128){return(function(e){var e;return e===((d.charCodeAt(0)>>0));});}e=BF(d);f=$clone(e[0],BE);g=e[1];if(g){return(function(h){var h;return h<128&&new BY(f).contains(((h<<24>>>24)));});}return(function(h){var h,i,j,k,l;i=d;j=0;while(true){if(!(j=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])<128){j=(((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])>>0));k=$subslice(d,1);h=j;d=k;}else{l=C.DecodeRune(d);m=l[0];n=l[1];o=m;p=$subslice(d,n);h=o;d=p;}if((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])<128){q=(((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])>>0));r=$subslice(e,1);i=q;e=r;}else{s=C.DecodeRune(e);t=s[0];u=s[1];v=t;w=$subslice(e,u);i=v;e=w;}if(i===h){continue;}if(i>0)-65>>0))){continue;}return false;}z=E.SimpleFold(h);while(true){if(!(!((z===h))&&z=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));}else if((f===d.$length)){if(G(e,d)){return 0;}return-1;}else if(f>d.$length){return-1;}else if(f<=D.MaxLen){if(d.$length<=0){return D.Index(d,e);}g=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);h=(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]);i=0;j=(d.$length-f>>0)+1>>0;k=0;while(true){if(!(i=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i])===g))){l=F($subslice(d,i,j),g);if(l<0){return-1;}i=i+(l)>>0;}if(((m=i+1>>0,((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m]))===h)&&G($subslice(d,i,(i+f>>0)),e)){return i;}k=k+(1)>>0;i=i+(1)>>0;if(k>D.Cutover(i)){n=D.Index($subslice(d,i),e);if(n>=0){return n+i>>0;}return-1;}}return-1;}o=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);p=(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]);q=0;r=0;s=(d.$length-f>>0)+1>>0;while(true){if(!(q=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+q])===o))){t=F($subslice(d,q,s),o);if(t<0){break;}q=q+(t)>>0;}if(((u=q+1>>0,((u<0||u>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+u]))===p)&&G($subslice(d,q,(q+f>>0)),e)){return q;}q=q+(1)>>0;r=r+(1)>>0;if(r>=(4+(q>>4>>0)>>0)&&q>0;}}return-1;};$pkg.Index=BP;BQ=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=BR(e);g=f[0];h=f[1];i=e.$length;j=0;k=0;while(true){if(!(k>>0)+((((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k])>>>0))>>>0;k=k+(1)>>0;}if((j===g)&&G($subslice(d,0,i),e)){return 0;}l=i;while(true){if(!(l>>0;j=j+(((((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l])>>>0)))>>>0;j=j-(($imul(h,(((m=l-i>>0,((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m]))>>>0)))>>>0))>>>0;l=l+(1)>>0;if((j===g)&&G($subslice(d,(l-i>>0),l),e)){return l-i>>0;}}return-1;};BR=function(d){var d,e,f,g,h,i,j,k;e=0;f=0;while(true){if(!(f>>0)+((((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])>>>0))>>>0;f=f+(1)>>0;}g=1;h=16777619;i=g;j=h;k=d.$length;while(true){if(!(k>0)){break;}if(!(((k&1)===0))){i=$imul(i,(j))>>>0;}j=$imul(j,(j))>>>0;k=(k>>$min((1),31))>>0;}return[e,i];};BS.ptr.prototype.Len=function(){var d,e,f,g,h,i;d=this;if((e=d.i,f=(new $Int64(0,d.s.$length)),(e.$high>f.$high||(e.$high===f.$high&&e.$low>=f.$low)))){return 0;}return(((g=(h=(new $Int64(0,d.s.$length)),i=d.i,new $Int64(h.$high-i.$high,h.$low-i.$low)),g.$low+((g.$high>>31)*4294967296))>>0));};BS.prototype.Len=function(){return this.$val.Len();};BS.ptr.prototype.Size=function(){var d;d=this;return(new $Int64(0,d.s.$length));};BS.prototype.Size=function(){return this.$val.Size();};BS.ptr.prototype.Read=function(d){var d,e,f,g,h,i,j,k,l,m;e=0;f=$ifaceNil;g=this;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){j=0;k=B.EOF;e=j;f=k;return[e,f];}g.prevRune=-1;e=$copySlice(d,$subslice(g.s,$flatten64(g.i)));g.i=(l=g.i,m=(new $Int64(0,e)),new $Int64(l.$high+m.$high,l.$low+m.$low));return[e,f];};BS.prototype.Read=function(d){return this.$val.Read(d);};BS.ptr.prototype.ReadAt=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=0;g=$ifaceNil;h=this;if((e.$high<0||(e.$high===0&&e.$low<0))){i=0;j=A.New("bytes.Reader.ReadAt: negative offset");f=i;g=j;return[f,g];}if((k=(new $Int64(0,h.s.$length)),(e.$high>k.$high||(e.$high===k.$high&&e.$low>=k.$low)))){l=0;m=B.EOF;f=l;g=m;return[f,g];}f=$copySlice(d,$subslice(h.s,$flatten64(e)));if(ff.$high||(e.$high===f.$high&&e.$low>=f.$low)))){return[0,B.EOF];}i=(g=d.s,h=d.i,(($flatten64(h)<0||$flatten64(h)>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+$flatten64(h)]));d.i=(j=d.i,k=new $Int64(0,1),new $Int64(j.$high+k.$high,j.$low+k.$low));return[i,$ifaceNil];};BS.prototype.ReadByte=function(){return this.$val.ReadByte();};BS.ptr.prototype.UnreadByte=function(){var d,e,f,g;d=this;if((e=d.i,(e.$high<0||(e.$high===0&&e.$low<=0)))){return A.New("bytes.Reader.UnreadByte: at beginning of slice");}d.prevRune=-1;d.i=(f=d.i,g=new $Int64(0,1),new $Int64(f.$high-g.$high,f.$low-g.$low));return $ifaceNil;};BS.prototype.UnreadByte=function(){return this.$val.UnreadByte();};BS.ptr.prototype.ReadRune=function(){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;d=0;e=0;f=$ifaceNil;g=this;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){g.prevRune=-1;j=0;k=0;l=B.EOF;d=j;e=k;f=l;return[d,e,f];}g.prevRune=(((m=g.i,m.$low+((m.$high>>31)*4294967296))>>0));p=(n=g.s,o=g.i,(($flatten64(o)<0||$flatten64(o)>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+$flatten64(o)]));if(p<128){g.i=(q=g.i,r=new $Int64(0,1),new $Int64(q.$high+r.$high,q.$low+r.$low));s=((p>>0));t=1;u=$ifaceNil;d=s;e=t;f=u;return[d,e,f];}v=C.DecodeRune($subslice(g.s,$flatten64(g.i)));d=v[0];e=v[1];g.i=(w=g.i,x=(new $Int64(0,e)),new $Int64(w.$high+x.$high,w.$low+x.$low));return[d,e,f];};BS.prototype.ReadRune=function(){return this.$val.ReadRune();};BS.ptr.prototype.UnreadRune=function(){var d,e;d=this;if((e=d.i,(e.$high<0||(e.$high===0&&e.$low<=0)))){return A.New("bytes.Reader.UnreadRune: at beginning of slice");}if(d.prevRune<0){return A.New("bytes.Reader.UnreadRune: previous operation was not ReadRune");}d.i=(new $Int64(0,d.prevRune));d.prevRune=-1;return $ifaceNil;};BS.prototype.UnreadRune=function(){return this.$val.UnreadRune();};BS.ptr.prototype.Seek=function(d,e){var d,e,f,g,h,i,j;f=this;f.prevRune=-1;g=new $Int64(0,0);h=e;if(h===(0)){g=d;}else if(h===(1)){g=(i=f.i,new $Int64(i.$high+d.$high,i.$low+d.$low));}else if(h===(2)){g=(j=(new $Int64(0,f.s.$length)),new $Int64(j.$high+d.$high,j.$low+d.$low));}else{return[new $Int64(0,0),A.New("bytes.Reader.Seek: invalid whence")];}if((g.$high<0||(g.$high===0&&g.$low<0))){return[new $Int64(0,0),A.New("bytes.Reader.Seek: negative position")];}f.i=g;return[g,$ifaceNil];};BS.prototype.Seek=function(d,e){return this.$val.Seek(d,e);};BS.ptr.prototype.WriteTo=function(d){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.prevRune=-1;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){j=new $Int64(0,0);k=$ifaceNil;e=j;f=k;$s=-1;return[e,f];}l=$subslice(g.s,$flatten64(g.i));n=d.Write(l);$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];f=m[1];if(o>l.$length){$panic(new $String("bytes.Reader.WriteTo: invalid Write count"));}g.i=(p=g.i,q=(new $Int64(0,o)),new $Int64(p.$high+q.$high,p.$low+q.$low));e=(new $Int64(0,o));if(!((o===l.$length))&&$interfaceIsEqual(f,$ifaceNil)){f=B.ErrShortWrite;}$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:BS.ptr.prototype.WriteTo};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};BS.prototype.WriteTo=function(d){return this.$val.WriteTo(d);};BS.ptr.prototype.Reset=function(d){var d,e;e=this;BS.copy(e,new BS.ptr(d,new $Int64(0,0),-1));};BS.prototype.Reset=function(d){return this.$val.Reset(d);};BT=function(d){var d;return new BS.ptr(d,new $Int64(0,0),-1);};$pkg.NewReader=BT;BU.methods=[{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[BV],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"empty",name:"empty",pkg:"bytes",typ:$funcType([],[$Bool],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Truncate",name:"Truncate",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"tryGrowByReslice",name:"tryGrowByReslice",pkg:"bytes",typ:$funcType([$Int],[$Int,$Bool],false)},{prop:"grow",name:"grow",pkg:"bytes",typ:$funcType([$Int],[$Int],false)},{prop:"Grow",name:"Grow",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([BV],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)},{prop:"ReadFrom",name:"ReadFrom",pkg:"",typ:$funcType([B.Reader],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([B.Writer],[$Int64,$error],false)},{prop:"WriteByte",name:"WriteByte",pkg:"",typ:$funcType([$Uint8],[$error],false)},{prop:"WriteRune",name:"WriteRune",pkg:"",typ:$funcType([$Int32],[$Int,$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([BV],[$Int,$error],false)},{prop:"Next",name:"Next",pkg:"",typ:$funcType([$Int],[BV],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadBytes",name:"ReadBytes",pkg:"",typ:$funcType([$Uint8],[BV,$error],false)},{prop:"readSlice",name:"readSlice",pkg:"bytes",typ:$funcType([$Uint8],[BV,$error],false)},{prop:"ReadString",name:"ReadString",pkg:"",typ:$funcType([$Uint8],[$String,$error],false)}];BY.methods=[{prop:"contains",name:"contains",pkg:"bytes",typ:$funcType([$Uint8],[$Bool],false)}];CD.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([BV],[$Int,$error],false)},{prop:"ReadAt",name:"ReadAt",pkg:"",typ:$funcType([BV,$Int64],[$Int,$error],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([B.Writer],[$Int64,$error],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([BV],[],false)}];I.init("bytes",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:BV,tag:""},{prop:"off",name:"off",embedded:false,exported:false,typ:$Int,tag:""},{prop:"lastRead",name:"lastRead",embedded:false,exported:false,typ:J,tag:""}]);BE.init($Uint32,8);BS.init("bytes",[{prop:"s",name:"s",embedded:false,exported:false,typ:BV,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"prevRune",name:"prevRune",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrTooLarge=A.New("bytes.Buffer: too large");K=A.New("bytes.Buffer: reader returned negative count from Read");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["encoding"]=(function(){var $pkg={},$init,C,D,E;C=$pkg.TextMarshaler=$newType(8,$kindInterface,"encoding.TextMarshaler",true,"encoding",true,null);D=$pkg.TextUnmarshaler=$newType(8,$kindInterface,"encoding.TextUnmarshaler",true,"encoding",true,null);E=$sliceType($Uint8);C.init([{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[E,$error],false)}]);D.init([{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([E],[$error],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["encoding/binary"]=(function(){var $pkg={},$init,A,B,C,D,F,G,X,U;A=$packages["errors"];B=$packages["io"];C=$packages["math"];D=$packages["reflect"];F=$pkg.littleEndian=$newType(0,$kindStruct,"binary.littleEndian",true,"encoding/binary",false,function(){this.$val=this;if(arguments.length===0){return;}});G=$pkg.bigEndian=$newType(0,$kindStruct,"binary.bigEndian",true,"encoding/binary",false,function(){this.$val=this;if(arguments.length===0){return;}});X=$sliceType($Uint8);F.ptr.prototype.Uint16=function(a){var a;$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));return((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])<<16>>>16))|((((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])<<16>>>16))<<8<<16>>>16))>>>0;};F.prototype.Uint16=function(a){return this.$val.Uint16(a);};F.ptr.prototype.PutUint16=function(a,b){var a,b;$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((b<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(((b>>>8<<16>>>16)<<24>>>24)));};F.prototype.PutUint16=function(a,b){return this.$val.PutUint16(a,b);};F.ptr.prototype.Uint32=function(a){var a;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));return((((((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])>>>0))|((((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])>>>0))<<8>>>0))>>>0)|((((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2])>>>0))<<16>>>0))>>>0)|((((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3])>>>0))<<24>>>0))>>>0;};F.prototype.Uint32=function(a){return this.$val.Uint32(a);};F.ptr.prototype.PutUint32=function(a,b){var a,b;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((b<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(((b>>>8>>>0)<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(((b>>>16>>>0)<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=(((b>>>24>>>0)<<24>>>24)));};F.prototype.PutUint32=function(a,b){return this.$val.PutUint32(a,b);};F.ptr.prototype.Uint64=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));return(b=(c=(d=(e=(f=(g=(h=(new $Uint64(0,(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]))),i=$shiftLeft64((new $Uint64(0,(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]))),8),new $Uint64(h.$high|i.$high,(h.$low|i.$low)>>>0)),j=$shiftLeft64((new $Uint64(0,(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]))),16),new $Uint64(g.$high|j.$high,(g.$low|j.$low)>>>0)),k=$shiftLeft64((new $Uint64(0,(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]))),24),new $Uint64(f.$high|k.$high,(f.$low|k.$low)>>>0)),l=$shiftLeft64((new $Uint64(0,(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]))),32),new $Uint64(e.$high|l.$high,(e.$low|l.$low)>>>0)),m=$shiftLeft64((new $Uint64(0,(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]))),40),new $Uint64(d.$high|m.$high,(d.$low|m.$low)>>>0)),n=$shiftLeft64((new $Uint64(0,(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]))),48),new $Uint64(c.$high|n.$high,(c.$low|n.$low)>>>0)),o=$shiftLeft64((new $Uint64(0,(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]))),56),new $Uint64(b.$high|o.$high,(b.$low|o.$low)>>>0));};F.prototype.Uint64=function(a){return this.$val.Uint64(a);};F.ptr.prototype.PutUint64=function(a,b){var a,b;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((b.$low<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(($shiftRightUint64(b,8).$low<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(($shiftRightUint64(b,16).$low<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=(($shiftRightUint64(b,24).$low<<24>>>24)));(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]=(($shiftRightUint64(b,32).$low<<24>>>24)));(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]=(($shiftRightUint64(b,40).$low<<24>>>24)));(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]=(($shiftRightUint64(b,48).$low<<24>>>24)));(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]=(($shiftRightUint64(b,56).$low<<24>>>24)));};F.prototype.PutUint64=function(a,b){return this.$val.PutUint64(a,b);};F.ptr.prototype.String=function(){return"LittleEndian";};F.prototype.String=function(){return this.$val.String();};F.ptr.prototype.GoString=function(){return"binary.LittleEndian";};F.prototype.GoString=function(){return this.$val.GoString();};G.ptr.prototype.Uint16=function(a){var a;$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));return((((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])<<16>>>16))|((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])<<16>>>16))<<8<<16>>>16))>>>0;};G.prototype.Uint16=function(a){return this.$val.Uint16(a);};G.ptr.prototype.PutUint16=function(a,b){var a,b;$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=(((b>>>8<<16>>>16)<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((b<<24>>>24)));};G.prototype.PutUint16=function(a,b){return this.$val.PutUint16(a,b);};G.ptr.prototype.Uint32=function(a){var a;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));return((((((((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3])>>>0))|((((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2])>>>0))<<8>>>0))>>>0)|((((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])>>>0))<<16>>>0))>>>0)|((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])>>>0))<<24>>>0))>>>0;};G.prototype.Uint32=function(a){return this.$val.Uint32(a);};G.ptr.prototype.PutUint32=function(a,b){var a,b;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=(((b>>>24>>>0)<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(((b>>>16>>>0)<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(((b>>>8>>>0)<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=((b<<24>>>24)));};G.prototype.PutUint32=function(a,b){return this.$val.PutUint32(a,b);};G.ptr.prototype.Uint64=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));return(b=(c=(d=(e=(f=(g=(h=(new $Uint64(0,(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]))),i=$shiftLeft64((new $Uint64(0,(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]))),8),new $Uint64(h.$high|i.$high,(h.$low|i.$low)>>>0)),j=$shiftLeft64((new $Uint64(0,(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]))),16),new $Uint64(g.$high|j.$high,(g.$low|j.$low)>>>0)),k=$shiftLeft64((new $Uint64(0,(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]))),24),new $Uint64(f.$high|k.$high,(f.$low|k.$low)>>>0)),l=$shiftLeft64((new $Uint64(0,(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]))),32),new $Uint64(e.$high|l.$high,(e.$low|l.$low)>>>0)),m=$shiftLeft64((new $Uint64(0,(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]))),40),new $Uint64(d.$high|m.$high,(d.$low|m.$low)>>>0)),n=$shiftLeft64((new $Uint64(0,(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]))),48),new $Uint64(c.$high|n.$high,(c.$low|n.$low)>>>0)),o=$shiftLeft64((new $Uint64(0,(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]))),56),new $Uint64(b.$high|o.$high,(b.$low|o.$low)>>>0));};G.prototype.Uint64=function(a){return this.$val.Uint64(a);};G.ptr.prototype.PutUint64=function(a,b){var a,b;$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=(($shiftRightUint64(b,56).$low<<24>>>24)));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=(($shiftRightUint64(b,48).$low<<24>>>24)));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=(($shiftRightUint64(b,40).$low<<24>>>24)));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=(($shiftRightUint64(b,32).$low<<24>>>24)));(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]=(($shiftRightUint64(b,24).$low<<24>>>24)));(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]=(($shiftRightUint64(b,16).$low<<24>>>24)));(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]=(($shiftRightUint64(b,8).$low<<24>>>24)));(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]=((b.$low<<24>>>24)));};G.prototype.PutUint64=function(a,b){return this.$val.PutUint64(a,b);};G.ptr.prototype.String=function(){return"BigEndian";};G.prototype.String=function(){return this.$val.String();};G.ptr.prototype.GoString=function(){return"binary.BigEndian";};G.prototype.GoString=function(){return this.$val.GoString();};F.methods=[{prop:"Uint16",name:"Uint16",pkg:"",typ:$funcType([X],[$Uint16],false)},{prop:"PutUint16",name:"PutUint16",pkg:"",typ:$funcType([X,$Uint16],[],false)},{prop:"Uint32",name:"Uint32",pkg:"",typ:$funcType([X],[$Uint32],false)},{prop:"PutUint32",name:"PutUint32",pkg:"",typ:$funcType([X,$Uint32],[],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([X],[$Uint64],false)},{prop:"PutUint64",name:"PutUint64",pkg:"",typ:$funcType([X,$Uint64],[],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"GoString",name:"GoString",pkg:"",typ:$funcType([],[$String],false)}];G.methods=[{prop:"Uint16",name:"Uint16",pkg:"",typ:$funcType([X],[$Uint16],false)},{prop:"PutUint16",name:"PutUint16",pkg:"",typ:$funcType([X,$Uint16],[],false)},{prop:"Uint32",name:"Uint32",pkg:"",typ:$funcType([X],[$Uint32],false)},{prop:"PutUint32",name:"PutUint32",pkg:"",typ:$funcType([X,$Uint32],[],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([X],[$Uint64],false)},{prop:"PutUint64",name:"PutUint64",pkg:"",typ:$funcType([X,$Uint64],[],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"GoString",name:"GoString",pkg:"",typ:$funcType([],[$String],false)}];F.init("",[]);G.init("",[]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.LittleEndian=new F.ptr();$pkg.BigEndian=new G.ptr();U=A.New("binary: varint overflows a 64-bit integer");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["encoding/base64"]=(function(){var $pkg={},$init,A,B,C,D,F,H,L,M,N,O,P,Q,R,T,E,G;A=$packages["encoding/binary"];B=$packages["io"];C=$packages["strconv"];D=$pkg.Encoding=$newType(0,$kindStruct,"base64.Encoding",true,"encoding/base64",true,function(encode_,decodeMap_,padChar_,strict_){this.$val=this;if(arguments.length===0){this.encode=L.zero();this.decodeMap=M.zero();this.padChar=0;this.strict=false;return;}this.encode=encode_;this.decodeMap=decodeMap_;this.padChar=padChar_;this.strict=strict_;});F=$pkg.encoder=$newType(0,$kindStruct,"base64.encoder",true,"encoding/base64",false,function(err_,enc_,w_,buf_,nbuf_,out_){this.$val=this;if(arguments.length===0){this.err=$ifaceNil;this.enc=O.nil;this.w=$ifaceNil;this.buf=P.zero();this.nbuf=0;this.out=Q.zero();return;}this.err=err_;this.enc=enc_;this.w=w_;this.buf=buf_;this.nbuf=nbuf_;this.out=out_;});H=$pkg.CorruptInputError=$newType(8,$kindInt64,"base64.CorruptInputError",true,"encoding/base64",true,null);L=$arrayType($Uint8,64);M=$arrayType($Uint8,256);N=$sliceType($Uint8);O=$ptrType(D);P=$arrayType($Uint8,3);Q=$arrayType($Uint8,1024);R=$arrayType($Uint8,4);T=$ptrType(F);E=function(a){var a,b,c,d,e,f,g,h;if(!((a.length===64))){$panic(new $String("encoding alphabet is not 64-bytes long"));}b=0;while(true){if(!(b>0;}c=new D.ptr(L.zero(),M.zero(),0,false);c.padChar=61;$copyString(new N(c.encode),a);d=0;while(true){if(!(d<256)){break;}(e=c.decodeMap,((d<0||d>=e.length)?($throwRuntimeError("index out of range"),undefined):e[d]=255));d=d+(1)>>0;}f=0;while(true){if(!(f=g.length)?($throwRuntimeError("index out of range"),undefined):g[h]=((f<<24>>>24))));f=f+(1)>>0;}return c;};$pkg.NewEncoding=E;D.ptr.prototype.WithPadding=function(a){var a,b,c,d;b=this;if((a===13)||(a===10)||a>255){$panic(new $String("invalid padding"));}c=0;while(true){if(!(c<64)){break;}if((((d=b.encode,((c<0||c>=d.length)?($throwRuntimeError("index out of range"),undefined):d[c]))>>0))===a){$panic(new $String("padding contained in alphabet"));}c=c+(1)>>0;}b.padChar=a;return b;};D.prototype.WithPadding=function(a){return this.$val.WithPadding(a);};D.ptr.prototype.Strict=function(){var a;a=this;a.strict=true;return a;};D.prototype.Strict=function(){return this.$val.Strict();};D.ptr.prototype.Encode=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,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;c=this;if(b.$length===0){return;}d=0;e=0;f=d;g=e;i=$imul(((h=b.$length/3,(h===h&&h!==1/0&&h!==-1/0)?h>>0:$throwRuntimeError("integer divide by zero"))),3);while(true){if(!(g>0,((j<0||j>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+j]))>>>0))<<16>>>0)|((((k=g+1>>0,((k<0||k>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+k]))>>>0))<<8>>>0))>>>0)|(((l=g+2>>0,((l<0||l>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+l]))>>>0)))>>>0;(p=f+0>>0,((p<0||p>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+p]=(n=c.encode,o=((m>>>18>>>0)&63)>>>0,((o<0||o>=n.length)?($throwRuntimeError("index out of range"),undefined):n[o]))));(s=f+1>>0,((s<0||s>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+s]=(q=c.encode,r=((m>>>12>>>0)&63)>>>0,((r<0||r>=q.length)?($throwRuntimeError("index out of range"),undefined):q[r]))));(v=f+2>>0,((v<0||v>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+v]=(t=c.encode,u=((m>>>6>>>0)&63)>>>0,((u<0||u>=t.length)?($throwRuntimeError("index out of range"),undefined):t[u]))));(y=f+3>>0,((y<0||y>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+y]=(w=c.encode,x=(m&63)>>>0,((x<0||x>=w.length)?($throwRuntimeError("index out of range"),undefined):w[x]))));g=g+(3)>>0;f=f+(4)>>0;}z=b.$length-g>>0;if(z===0){return;}ab=(((aa=g+0>>0,((aa<0||aa>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+aa]))>>>0))<<16>>>0;if(z===2){ab=(ab|(((((ac=g+1>>0,((ac<0||ac>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+ac]))>>>0))<<8>>>0)))>>>0;}(af=f+0>>0,((af<0||af>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+af]=(ad=c.encode,ae=((ab>>>18>>>0)&63)>>>0,((ae<0||ae>=ad.length)?($throwRuntimeError("index out of range"),undefined):ad[ae]))));(ai=f+1>>0,((ai<0||ai>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ai]=(ag=c.encode,ah=((ab>>>12>>>0)&63)>>>0,((ah<0||ah>=ag.length)?($throwRuntimeError("index out of range"),undefined):ag[ah]))));aj=z;if(aj===(2)){(am=f+2>>0,((am<0||am>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+am]=(ak=c.encode,al=((ab>>>6>>>0)&63)>>>0,((al<0||al>=ak.length)?($throwRuntimeError("index out of range"),undefined):ak[al]))));if(!((c.padChar===-1))){(an=f+3>>0,((an<0||an>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+an]=((c.padChar<<24>>>24))));}}else if(aj===(1)){if(!((c.padChar===-1))){(ao=f+2>>0,((ao<0||ao>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ao]=((c.padChar<<24>>>24))));(ap=f+3>>0,((ap<0||ap>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ap]=((c.padChar<<24>>>24))));}}};D.prototype.Encode=function(a,b){return this.$val.Encode(a,b);};D.ptr.prototype.EncodeToString=function(a){var a,b,c;b=this;c=$makeSlice(N,b.EncodedLen(a.$length));b.Encode(c,a);return($bytesToString(c));};D.prototype.EncodeToString=function(a){return this.$val.EncodeToString(a);};F.ptr.prototype.Write=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=0;c=$ifaceNil;d=this;if(!($interfaceIsEqual(d.err,$ifaceNil))){e=0;f=d.err;b=e;c=f;$s=-1;return[b,c];}if(d.nbuf>0){$s=1;continue;}$s=2;continue;case 1:g=0;g=0;while(true){if(!(g=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]=((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g])));d.nbuf=d.nbuf+(1)>>0;g=g+(1)>>0;}b=b+(g)>>0;a=$subslice(a,g);if(d.nbuf<3){$s=-1;return[b,c];}d.enc.Encode(new N(d.out),new N(d.buf));k=d.w.Write($subslice(new N(d.out),0,4));$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;d.err=j[1];if(!($interfaceIsEqual(d.err,$ifaceNil))){l=b;m=d.err;b=l;c=m;$s=-1;return[b,c];}d.nbuf=0;case 2:case 4:if(!(a.$length>=3)){$s=5;continue;}n=768;if(n>a.$length){n=a.$length;n=n-((o=n%3,o===o?o:$throwRuntimeError("integer divide by zero")))>>0;}d.enc.Encode(new N(d.out),$subslice(a,0,n));r=d.w.Write($subslice(new N(d.out),0,($imul((q=n/3,(q===q&&q!==1/0&&q!==-1/0)?q>>0:$throwRuntimeError("integer divide by zero")),4))));$s=6;case 6:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}p=r;d.err=p[1];if(!($interfaceIsEqual(d.err,$ifaceNil))){s=b;t=d.err;b=s;c=t;$s=-1;return[b,c];}b=b+(n)>>0;a=$subslice(a,n);$s=4;continue;case 5:u=0;while(true){if(!(u=v.length)?($throwRuntimeError("index out of range"),undefined):v[u]=((u<0||u>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+u])));u=u+(1)>>0;}d.nbuf=a.$length;b=b+(a.$length)>>0;$s=-1;return[b,c];}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Write};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Write=function(a){return this.$val.Write(a);};F.ptr.prototype.Close=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;if($interfaceIsEqual(a.err,$ifaceNil)&&a.nbuf>0){$s=1;continue;}$s=2;continue;case 1:a.enc.Encode(new N(a.out),$subslice(new N(a.buf),0,a.nbuf));c=a.w.Write($subslice(new N(a.out),0,a.enc.EncodedLen(a.nbuf)));$s=3;case 3:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;a.err=b[1];a.nbuf=0;case 2:$s=-1;return a.err;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Close};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Close=function(){return this.$val.Close();};G=function(a,b){var a,b;return new F.ptr($ifaceNil,a,b,P.zero(),0,Q.zero());};$pkg.NewEncoder=G;D.ptr.prototype.EncodedLen=function(a){var a,b,c,d;b=this;if(b.padChar===-1){return(c=((($imul(a,8))+5>>0))/6,(c===c&&c!==1/0&&c!==-1/0)?c>>0:$throwRuntimeError("integer divide by zero"));}return $imul((d=((a+2>>0))/3,(d===d&&d!==1/0&&d!==-1/0)?d>>0:$throwRuntimeError("integer divide by zero")),4);};D.prototype.EncodedLen=function(a){return this.$val.EncodedLen(a);};H.prototype.Error=function(){var a;a=this;return"illegal base64 data at input byte "+C.FormatInt((new $Int64(a.$high,a.$low)),10);};$ptrType(H).prototype.Error=function(){return this.$get().Error();};D.ptr.prototype.decodeQuantum=function(a,b,c){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;d=0;e=0;f=$ifaceNil;g=this;h=R.zero();i=3;j=4;k=i;l=j;m=0;while(true){if(!(m<4)){break;}if(b.$length===c){if((m===0)){n=c;o=0;p=$ifaceNil;d=n;e=o;f=p;return[d,e,f];}else if(((m===1))||(!((g.padChar===-1)))){q=c;r=0;s=(new H(0,(c-m>>0)));d=q;e=r;f=s;return[d,e,f];}t=m-1>>0;u=m;k=t;l=u;break;}v=((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c]);c=c+(1)>>0;x=(w=g.decodeMap,((v<0||v>=w.length)?($throwRuntimeError("index out of range"),undefined):w[v]));if(!((x===255))){((m<0||m>=h.length)?($throwRuntimeError("index out of range"),undefined):h[m]=x);m=m+(1)>>0;continue;}if((v===10)||(v===13)){m=m-(1)>>0;m=m+(1)>>0;continue;}if(!((((v>>0))===g.padChar))){y=c;z=0;aa=(new H(0,(c-1>>0)));d=y;e=z;f=aa;return[d,e,f];}ab=m;if((ab===(0))||(ab===(1))){ac=c;ad=0;ae=(new H(0,(c-1>>0)));d=ac;e=ad;f=ae;return[d,e,f];}else if(ab===(2)){while(true){if(!(c=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])===10)||(((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])===13)))){break;}c=c+(1)>>0;}if(c===b.$length){af=c;ag=0;ah=(new H(0,b.$length));d=af;e=ag;f=ah;return[d,e,f];}if(!((((((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])>>0))===g.padChar))){ai=c;aj=0;ak=(new H(0,(c-1>>0)));d=ai;e=aj;f=ak;return[d,e,f];}c=c+(1)>>0;}while(true){if(!(c=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])===10)||(((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])===13)))){break;}c=c+(1)>>0;}if(c>>0))<<18>>>0)|(((h[1]>>>0))<<12>>>0))>>>0)|(((h[2]>>>0))<<6>>>0))>>>0)|((h[3]>>>0)))>>>0;ao=(((an>>>0>>>0)<<24>>>24));ap=(((an>>>8>>>0)<<24>>>24));aq=(((an>>>16>>>0)<<24>>>24));h[2]=ao;h[1]=ap;h[0]=aq;ar=l;if(ar===(4)){(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=h[2]);h[2]=0;(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=h[1]);if(g.strict&&!((h[2]===0))){as=c;at=0;au=(new H(0,(c-1>>0)));d=as;e=at;f=au;return[d,e,f];}h[1]=0;(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=h[0]);if(g.strict&&(!((h[1]===0))||!((h[2]===0)))){av=c;aw=0;ax=(new H(0,(c-2>>0)));d=av;e=aw;f=ax;return[d,e,f];}}else if(ar===(3)){(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=h[1]);if(g.strict&&!((h[2]===0))){ay=c;az=0;ba=(new H(0,(c-1>>0)));d=ay;e=az;f=ba;return[d,e,f];}h[1]=0;(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=h[0]);if(g.strict&&(!((h[1]===0))||!((h[2]===0)))){bb=c;bc=0;bd=(new H(0,(c-2>>0)));d=bb;e=bc;f=bd;return[d,e,f];}}else if(ar===(2)){(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=h[0]);if(g.strict&&(!((h[1]===0))||!((h[2]===0)))){be=c;bf=0;bg=(new H(0,(c-2>>0)));d=be;e=bf;f=bg;return[d,e,f];}}a=$subslice(a,k);bh=c;bi=l-1>>0;bj=f;d=bh;e=bi;f=bj;return[d,e,f];};D.prototype.decodeQuantum=function(a,b,c){return this.$val.decodeQuantum(a,b,c);};D.ptr.prototype.DecodeString=function(a){var a,b,c,d,e,f;b=this;c=$makeSlice(N,b.DecodedLen(a.length));d=b.Decode(c,(new N($stringToBytes(a))));e=d[0];f=d[1];return[$subslice(c,0,e),f];};D.prototype.DecodeString=function(a){return this.$val.DecodeString(a);};D.ptr.prototype.Decode=function(a,b){var a,aa,ab,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;c=0;d=$ifaceNil;e=this;if(b.$length===0){f=0;g=$ifaceNil;c=f;d=g;return[c,d];}h=0;while(true){if(!(false&&(b.$length-h>>0)>=8&&(a.$length-c>>0)>=8)){break;}i=e.decode64($subslice(b,h));j=i[0];k=i[1];if(k){$clone(A.BigEndian,A.bigEndian).PutUint64($subslice(a,c),j);c=c+(6)>>0;h=h+(8)>>0;}else{l=0;m=e.decodeQuantum($subslice(a,c),b,h);h=m[0];l=m[1];d=m[2];c=c+(l)>>0;if(!($interfaceIsEqual(d,$ifaceNil))){n=c;o=d;c=n;d=o;return[c,d];}}}while(true){if(!((b.$length-h>>0)>=4&&(a.$length-c>>0)>=4)){break;}p=e.decode32($subslice(b,h));q=p[0];r=p[1];if(r){$clone(A.BigEndian,A.bigEndian).PutUint32($subslice(a,c),q);c=c+(3)>>0;h=h+(4)>>0;}else{s=0;t=e.decodeQuantum($subslice(a,c),b,h);h=t[0];s=t[1];d=t[2];c=c+(s)>>0;if(!($interfaceIsEqual(d,$ifaceNil))){u=c;v=d;c=u;d=v;return[c,d];}}}while(true){if(!(h>0;if(!($interfaceIsEqual(d,$ifaceNil))){y=c;z=d;c=y;d=z;return[c,d];}}aa=c;ab=d;c=aa;d=ab;return[c,d];};D.prototype.Decode=function(a,b){return this.$val.Decode(a,b);};D.ptr.prototype.decode32=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;b=0;c=false;d=this;e=0;$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));e=(((f=d.decodeMap,g=(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]),((g<0||g>=f.length)?($throwRuntimeError("index out of range"),undefined):f[g]))>>>0));if(e===255){h=0;i=false;b=h;c=i;return[b,c];}b=(b|((e<<26>>>0)))>>>0;e=(((j=d.decodeMap,k=(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]),((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]))>>>0));if(e===255){l=0;m=false;b=l;c=m;return[b,c];}b=(b|((e<<20>>>0)))>>>0;e=(((n=d.decodeMap,o=(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]),((o<0||o>=n.length)?($throwRuntimeError("index out of range"),undefined):n[o]))>>>0));if(e===255){p=0;q=false;b=p;c=q;return[b,c];}b=(b|((e<<14>>>0)))>>>0;e=(((r=d.decodeMap,s=(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]),((s<0||s>=r.length)?($throwRuntimeError("index out of range"),undefined):r[s]))>>>0));if(e===255){t=0;u=false;b=t;c=u;return[b,c];}b=(b|((e<<8>>>0)))>>>0;v=b;w=true;b=v;c=w;return[b,c];};D.prototype.decode32=function(a){return this.$val.decode32(a);};D.ptr.prototype.decode64=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,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;b=new $Uint64(0,0);c=false;d=this;e=new $Uint64(0,0);$unused((7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]));e=(new $Uint64(0,(f=d.decodeMap,g=(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]),((g<0||g>=f.length)?($throwRuntimeError("index out of range"),undefined):f[g]))));if((e.$high===0&&e.$low===255)){h=new $Uint64(0,0);i=false;b=h;c=i;return[b,c];}b=(j=$shiftLeft64(e,58),new $Uint64(b.$high|j.$high,(b.$low|j.$low)>>>0));e=(new $Uint64(0,(k=d.decodeMap,l=(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]),((l<0||l>=k.length)?($throwRuntimeError("index out of range"),undefined):k[l]))));if((e.$high===0&&e.$low===255)){m=new $Uint64(0,0);n=false;b=m;c=n;return[b,c];}b=(o=$shiftLeft64(e,52),new $Uint64(b.$high|o.$high,(b.$low|o.$low)>>>0));e=(new $Uint64(0,(p=d.decodeMap,q=(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]),((q<0||q>=p.length)?($throwRuntimeError("index out of range"),undefined):p[q]))));if((e.$high===0&&e.$low===255)){r=new $Uint64(0,0);s=false;b=r;c=s;return[b,c];}b=(t=$shiftLeft64(e,46),new $Uint64(b.$high|t.$high,(b.$low|t.$low)>>>0));e=(new $Uint64(0,(u=d.decodeMap,v=(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]),((v<0||v>=u.length)?($throwRuntimeError("index out of range"),undefined):u[v]))));if((e.$high===0&&e.$low===255)){w=new $Uint64(0,0);x=false;b=w;c=x;return[b,c];}b=(y=$shiftLeft64(e,40),new $Uint64(b.$high|y.$high,(b.$low|y.$low)>>>0));e=(new $Uint64(0,(z=d.decodeMap,aa=(4>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+4]),((aa<0||aa>=z.length)?($throwRuntimeError("index out of range"),undefined):z[aa]))));if((e.$high===0&&e.$low===255)){ab=new $Uint64(0,0);ac=false;b=ab;c=ac;return[b,c];}b=(ad=$shiftLeft64(e,34),new $Uint64(b.$high|ad.$high,(b.$low|ad.$low)>>>0));e=(new $Uint64(0,(ae=d.decodeMap,af=(5>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+5]),((af<0||af>=ae.length)?($throwRuntimeError("index out of range"),undefined):ae[af]))));if((e.$high===0&&e.$low===255)){ag=new $Uint64(0,0);ah=false;b=ag;c=ah;return[b,c];}b=(ai=$shiftLeft64(e,28),new $Uint64(b.$high|ai.$high,(b.$low|ai.$low)>>>0));e=(new $Uint64(0,(aj=d.decodeMap,ak=(6>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+6]),((ak<0||ak>=aj.length)?($throwRuntimeError("index out of range"),undefined):aj[ak]))));if((e.$high===0&&e.$low===255)){al=new $Uint64(0,0);am=false;b=al;c=am;return[b,c];}b=(an=$shiftLeft64(e,22),new $Uint64(b.$high|an.$high,(b.$low|an.$low)>>>0));e=(new $Uint64(0,(ao=d.decodeMap,ap=(7>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+7]),((ap<0||ap>=ao.length)?($throwRuntimeError("index out of range"),undefined):ao[ap]))));if((e.$high===0&&e.$low===255)){aq=new $Uint64(0,0);ar=false;b=aq;c=ar;return[b,c];}b=(as=$shiftLeft64(e,16),new $Uint64(b.$high|as.$high,(b.$low|as.$low)>>>0));at=b;au=true;b=at;c=au;return[b,c];};D.prototype.decode64=function(a){return this.$val.decode64(a);};D.ptr.prototype.DecodedLen=function(a){var a,b,c,d;b=this;if(b.padChar===-1){return(c=($imul(a,6))/8,(c===c&&c!==1/0&&c!==-1/0)?c>>0:$throwRuntimeError("integer divide by zero"));}return $imul((d=a/4,(d===d&&d!==1/0&&d!==-1/0)?d>>0:$throwRuntimeError("integer divide by zero")),3);};D.prototype.DecodedLen=function(a){return this.$val.DecodedLen(a);};D.methods=[{prop:"WithPadding",name:"WithPadding",pkg:"",typ:$funcType([$Int32],[O],false)},{prop:"Strict",name:"Strict",pkg:"",typ:$funcType([],[O],false)}];O.methods=[{prop:"Encode",name:"Encode",pkg:"",typ:$funcType([N,N],[],false)},{prop:"EncodeToString",name:"EncodeToString",pkg:"",typ:$funcType([N],[$String],false)},{prop:"EncodedLen",name:"EncodedLen",pkg:"",typ:$funcType([$Int],[$Int],false)},{prop:"decodeQuantum",name:"decodeQuantum",pkg:"encoding/base64",typ:$funcType([N,N,$Int],[$Int,$Int,$error],false)},{prop:"DecodeString",name:"DecodeString",pkg:"",typ:$funcType([$String],[N,$error],false)},{prop:"Decode",name:"Decode",pkg:"",typ:$funcType([N,N],[$Int,$error],false)},{prop:"decode32",name:"decode32",pkg:"encoding/base64",typ:$funcType([N],[$Uint32,$Bool],false)},{prop:"decode64",name:"decode64",pkg:"encoding/base64",typ:$funcType([N],[$Uint64,$Bool],false)},{prop:"DecodedLen",name:"DecodedLen",pkg:"",typ:$funcType([$Int],[$Int],false)}];T.methods=[{prop:"Write",name:"Write",pkg:"",typ:$funcType([N],[$Int,$error],false)},{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)}];H.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];D.init("encoding/base64",[{prop:"encode",name:"encode",embedded:false,exported:false,typ:L,tag:""},{prop:"decodeMap",name:"decodeMap",embedded:false,exported:false,typ:M,tag:""},{prop:"padChar",name:"padChar",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"strict",name:"strict",embedded:false,exported:false,typ:$Bool,tag:""}]);F.init("encoding/base64",[{prop:"err",name:"err",embedded:false,exported:false,typ:$error,tag:""},{prop:"enc",name:"enc",embedded:false,exported:false,typ:O,tag:""},{prop:"w",name:"w",embedded:false,exported:false,typ:B.Writer,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:P,tag:""},{prop:"nbuf",name:"nbuf",embedded:false,exported:false,typ:$Int,tag:""},{prop:"out",name:"out",embedded:false,exported:false,typ:Q,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.StdEncoding=E("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");$pkg.URLEncoding=E("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");$pkg.RawStdEncoding=$clone($pkg.StdEncoding,D).WithPadding(-1);$pkg.RawURLEncoding=$clone($pkg.URLEncoding,D).WithPadding(-1);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["unicode/utf16"]=(function(){var $pkg={},$init;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["encoding/json"]=(function(){var $pkg={},$init,A,B,C,N,D,M,O,J,E,K,F,L,G,H,I,U,AI,AJ,AK,AM,AO,AR,AT,AU,BJ,BP,BR,BU,BW,BY,CA,CE,CF,CG,CV,CW,EO,EQ,ER,ES,ET,EU,EW,EZ,FB,FD,FE,FF,FM,FN,FP,FQ,FR,FS,FT,FU,AA,AB,AN,AP,AV,AY,AZ,BK,BL,CJ,EM,EN,a,b,c,V,AF,AH,AQ,AS,AW,AX,BA,BB,BC,BD,BE,BF,BG,BH,BI,BM,BN,BO,BQ,BS,BT,BV,BX,BZ,CB,CC,CD,CH,CI,CK,CL,CM,CN,CO,CQ,CX,CY,CZ,DA,DB,DC,DD,DE,DF,DG,DH,DI,DJ,DK,DL,DM,DN,DO,DP,DQ,DR,DS,DT,DU,DV,DW,DX,DY,DZ,EA,EB,EC,ED,EP;A=$packages["bytes"];B=$packages["encoding"];C=$packages["encoding/base64"];N=$packages["errors"];D=$packages["fmt"];M=$packages["github.com/gopherjs/gopherjs/nosync"];O=$packages["io"];J=$packages["math"];E=$packages["reflect"];K=$packages["sort"];F=$packages["strconv"];L=$packages["strings"];G=$packages["unicode"];H=$packages["unicode/utf16"];I=$packages["unicode/utf8"];U=$pkg.Number=$newType(8,$kindString,"json.Number",true,"encoding/json",true,null);AI=$pkg.Marshaler=$newType(8,$kindInterface,"json.Marshaler",true,"encoding/json",true,null);AJ=$pkg.UnsupportedTypeError=$newType(0,$kindStruct,"json.UnsupportedTypeError",true,"encoding/json",true,function(Type_){this.$val=this;if(arguments.length===0){this.Type=$ifaceNil;return;}this.Type=Type_;});AK=$pkg.UnsupportedValueError=$newType(0,$kindStruct,"json.UnsupportedValueError",true,"encoding/json",true,function(Value_,Str_){this.$val=this;if(arguments.length===0){this.Value=new E.Value.ptr(EZ.nil,0,0);this.Str="";return;}this.Value=Value_;this.Str=Str_;});AM=$pkg.MarshalerError=$newType(0,$kindStruct,"json.MarshalerError",true,"encoding/json",true,function(Type_,Err_){this.$val=this;if(arguments.length===0){this.Type=$ifaceNil;this.Err=$ifaceNil;return;}this.Type=Type_;this.Err=Err_;});AO=$pkg.encodeState=$newType(0,$kindStruct,"json.encodeState",true,"encoding/json",false,function(Buffer_,scratch_){this.$val=this;if(arguments.length===0){this.Buffer=new A.Buffer.ptr(ER.nil,0,0);this.scratch=FE.zero();return;}this.Buffer=Buffer_;this.scratch=scratch_;});AR=$pkg.jsonError=$newType(0,$kindStruct,"json.jsonError",true,"encoding/json",false,function(error_){this.$val=this;if(arguments.length===0){this.error=$ifaceNil;return;}this.error=error_;});AT=$pkg.encOpts=$newType(0,$kindStruct,"json.encOpts",true,"encoding/json",false,function(quoted_,escapeHTML_){this.$val=this;if(arguments.length===0){this.quoted=false;this.escapeHTML=false;return;}this.quoted=quoted_;this.escapeHTML=escapeHTML_;});AU=$pkg.encoderFunc=$newType(4,$kindFunc,"json.encoderFunc",true,"encoding/json",false,null);BJ=$pkg.floatEncoder=$newType(4,$kindInt,"json.floatEncoder",true,"encoding/json",false,null);BP=$pkg.structEncoder=$newType(0,$kindStruct,"json.structEncoder",true,"encoding/json",false,function(fields_){this.$val=this;if(arguments.length===0){this.fields=FB.nil;return;}this.fields=fields_;});BR=$pkg.mapEncoder=$newType(0,$kindStruct,"json.mapEncoder",true,"encoding/json",false,function(elemEnc_){this.$val=this;if(arguments.length===0){this.elemEnc=$throwNilPointerError;return;}this.elemEnc=elemEnc_;});BU=$pkg.sliceEncoder=$newType(0,$kindStruct,"json.sliceEncoder",true,"encoding/json",false,function(arrayEnc_){this.$val=this;if(arguments.length===0){this.arrayEnc=$throwNilPointerError;return;}this.arrayEnc=arrayEnc_;});BW=$pkg.arrayEncoder=$newType(0,$kindStruct,"json.arrayEncoder",true,"encoding/json",false,function(elemEnc_){this.$val=this;if(arguments.length===0){this.elemEnc=$throwNilPointerError;return;}this.elemEnc=elemEnc_;});BY=$pkg.ptrEncoder=$newType(0,$kindStruct,"json.ptrEncoder",true,"encoding/json",false,function(elemEnc_){this.$val=this;if(arguments.length===0){this.elemEnc=$throwNilPointerError;return;}this.elemEnc=elemEnc_;});CA=$pkg.condAddrEncoder=$newType(0,$kindStruct,"json.condAddrEncoder",true,"encoding/json",false,function(canAddrEnc_,elseEnc_){this.$val=this;if(arguments.length===0){this.canAddrEnc=$throwNilPointerError;this.elseEnc=$throwNilPointerError;return;}this.canAddrEnc=canAddrEnc_;this.elseEnc=elseEnc_;});CE=$pkg.reflectWithString=$newType(0,$kindStruct,"json.reflectWithString",true,"encoding/json",false,function(v_,s_){this.$val=this;if(arguments.length===0){this.v=new E.Value.ptr(EZ.nil,0,0);this.s="";return;}this.v=v_;this.s=s_;});CF=$pkg.field=$newType(0,$kindStruct,"json.field",true,"encoding/json",false,function(name_,nameBytes_,equalFold_,nameNonEsc_,nameEscHTML_,tag_,index_,typ_,omitEmpty_,quoted_,encoder_){this.$val=this;if(arguments.length===0){this.name="";this.nameBytes=ER.nil;this.equalFold=$throwNilPointerError;this.nameNonEsc="";this.nameEscHTML="";this.tag=false;this.index=EW.nil;this.typ=$ifaceNil;this.omitEmpty=false;this.quoted=false;this.encoder=$throwNilPointerError;return;}this.name=name_;this.nameBytes=nameBytes_;this.equalFold=equalFold_;this.nameNonEsc=nameNonEsc_;this.nameEscHTML=nameEscHTML_;this.tag=tag_;this.index=index_;this.typ=typ_;this.omitEmpty=omitEmpty_;this.quoted=quoted_;this.encoder=encoder_;});CG=$pkg.byIndex=$newType(12,$kindSlice,"json.byIndex",true,"encoding/json",false,null);CV=$pkg.SyntaxError=$newType(0,$kindStruct,"json.SyntaxError",true,"encoding/json",true,function(msg_,Offset_){this.$val=this;if(arguments.length===0){this.msg="";this.Offset=new $Int64(0,0);return;}this.msg=msg_;this.Offset=Offset_;});CW=$pkg.scanner=$newType(0,$kindStruct,"json.scanner",true,"encoding/json",false,function(step_,endTop_,parseState_,err_,bytes_){this.$val=this;if(arguments.length===0){this.step=$throwNilPointerError;this.endTop=false;this.parseState=EW.nil;this.err=$ifaceNil;this.bytes=new $Int64(0,0);return;}this.step=step_;this.endTop=endTop_;this.parseState=parseState_;this.err=err_;this.bytes=bytes_;});EO=$pkg.tagOptions=$newType(8,$kindString,"json.tagOptions",true,"encoding/json",false,null);EQ=$sliceType($emptyInterface);ER=$sliceType($Uint8);ES=$ptrType(B.TextUnmarshaler);ET=$ptrType(AI);EU=$ptrType(B.TextMarshaler);EW=$sliceType($Int);EZ=$ptrType(E.rtype);FB=$sliceType(CF);FD=$ptrType(AO);FE=$arrayType($Uint8,64);FF=$sliceType(CE);FM=$ptrType(AJ);FN=$ptrType(AK);FP=$ptrType(AM);FQ=$ptrType(CE);FR=$funcType([ER,ER],[$Bool],false);FS=$ptrType(CV);FT=$ptrType(CW);FU=$funcType([FT,$Uint8],[$Int],false);U.prototype.String=function(){var d;d=this.$val;return(d);};$ptrType(U).prototype.String=function(){return new U(this.$get()).String();};U.prototype.Float64=function(){var d;d=this.$val;return F.ParseFloat((d),64);};$ptrType(U).prototype.Float64=function(){return new U(this.$get()).Float64();};U.prototype.Int64=function(){var d;d=this.$val;return F.ParseInt((d),10,64);};$ptrType(U).prototype.Int64=function(){return new U(this.$get()).Int64();};V=function(d){var d;if(d===""){return false;}if(d.charCodeAt(0)===45){d=$substring(d,1);if(d===""){return false;}}if((d.charCodeAt(0)===48)){d=$substring(d,1);}else if(49<=d.charCodeAt(0)&&d.charCodeAt(0)<=57){d=$substring(d,1);while(true){if(!(d.length>0&&48<=d.charCodeAt(0)&&d.charCodeAt(0)<=57)){break;}d=$substring(d,1);}}else{return false;}if(d.length>=2&&(d.charCodeAt(0)===46)&&48<=d.charCodeAt(1)&&d.charCodeAt(1)<=57){d=$substring(d,2);while(true){if(!(d.length>0&&48<=d.charCodeAt(0)&&d.charCodeAt(0)<=57)){break;}d=$substring(d,1);}}if(d.length>=2&&((d.charCodeAt(0)===101)||(d.charCodeAt(0)===69))){d=$substring(d,1);if((d.charCodeAt(0)===43)||(d.charCodeAt(0)===45)){d=$substring(d,1);if(d===""){return false;}}while(true){if(!(d.length>0&&48<=d.charCodeAt(0)&&d.charCodeAt(0)<=57)){break;}d=$substring(d,1);}}return d==="";};AF=function(d){var d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=AQ();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=f.marshal(d,new AT.ptr(false,true));$s=2;case 2:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[ER.nil,h];}i=$appendSlice((ER.nil),f.Buffer.Bytes());f.Buffer.Reset();AP.Put(f);$s=-1;return[i,$ifaceNil];}return;}if($f===undefined){$f={$blk:AF};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Marshal=AF;AH=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=0;g=e;h=0;while(true){if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);if((j===60)||(j===62)||(j===38)){if(f>>4<<24>>>24)));d.WriteByte(AN.charCodeAt(((j&15)>>>0)));f=i+1>>0;}if((j===226)&&(i+2>>0)>0,((k<0||k>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k]))===128)&&((((l=i+2>>0,((l<0||l>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l]))&~1)<<24>>>24)===168)){if(f>0,((m<0||m>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]))&15)>>>0)));f=i+3>>0;}h++;}if(f>0)))));}i=$subslice(new ER(d.scratch),0,0);j=J.Abs(h);k=102;if(!((j===0))){if((g===64)&&(j<1e-06||j>=1e+21)||(g===32)&&(($fround(j))<9.999999974752427e-07||($fround(j))>=1.0000000200408773e+21)){k=101;}}i=F.AppendFloat(i,h,k,-1,((g>>0)));if(k===101){l=i.$length;if(l>=4&&((m=l-4>>0,((m<0||m>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+m]))===101)&&((n=l-3>>0,((n<0||n>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+n]))===45)&&((o=l-2>>0,((o<0||o>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+o]))===48)){(q=l-2>>0,((q<0||q>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+q]=(p=l-1>>0,((p<0||p>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+p]))));i=$subslice(i,0,(l-1>>0));}}if(f.quoted){d.Buffer.WriteByte(34);}d.Buffer.Write(i);if(f.quoted){d.Buffer.WriteByte(34);}};$ptrType(BJ).prototype.encode=function(d,e,f){return new BJ(this.$get()).encode(d,e,f);};BM=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if($interfaceIsEqual($clone(e,E.Value).Type(),AB)){$s=1;continue;}$s=2;continue;case 1:g=$clone(e,E.Value).String();$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;if(h===""){h="0";}if(!V(h)){$s=4;continue;}$s=5;continue;case 4:i=D.Errorf("json: invalid number literal %q",new EQ([new $String(h)]));$s=6;case 6:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$r=d.error(i);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 5:d.Buffer.WriteString(h);$s=-1;return;case 2:if(f.quoted){$s=8;continue;}$s=9;continue;case 8:k=$clone(e,E.Value).String();$s=11;case 11:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=AF(new $String(k));$s=12;case 12:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}j=l;m=j[0];n=j[1];if(!($interfaceIsEqual(n,$ifaceNil))){d.error(n);}d.string(($bytesToString(m)),f.escapeHTML);$s=10;continue;case 9:o=$clone(e,E.Value).String();$s=13;case 13:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}$r=d.string(o,f.escapeHTML);$s=14;case 14:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 10:$s=-1;return;}return;}if($f===undefined){$f={$blk:BM};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};BN=function(d,e,f){var d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if($clone(e,E.Value).IsNil()){d.Buffer.WriteString("null");$s=-1;return;}g=$clone(e,E.Value).Elem();$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$r=d.reflectValue($clone(g,E.Value),$clone(f,AT));$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:BN};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BO=function(d,e,f){var d,e,f;d.error(new AJ.ptr($clone(e,E.Value).Type()));};BP.ptr.prototype.encode=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;h=123;i=g.fields;j=0;case 1:if(!(j=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+k]));n=e;o=m.index;p=0;case 3:if(!(p=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]);if($clone(n,E.Value).Kind()===22){$s=5;continue;}$s=6;continue;case 5:if($clone(n,E.Value).IsNil()){$s=7;continue;}$s=8;continue;case 7:j++;$s=1;continue s;case 8:r=$clone(n,E.Value).Elem();$s=9;case 9:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}n=r;case 6:s=$clone(n,E.Value).Field(q);$s=10;case 10:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}n=s;p++;$s=3;continue;case 4:if(m.omitEmpty&&AS($clone(n,E.Value))){$s=11;continue;}$s=12;continue;case 11:j++;$s=1;continue;case 12:d.Buffer.WriteByte(h);h=44;if(f.escapeHTML){d.Buffer.WriteString(m.nameEscHTML);}else{d.Buffer.WriteString(m.nameNonEsc);}f.quoted=m.quoted;$r=m.encoder(d,$clone(n,E.Value),$clone(f,AT));$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}j++;$s=1;continue;case 2:if(h===123){d.Buffer.WriteString("{}");}else{d.Buffer.WriteByte(125);}$s=-1;return;}return;}if($f===undefined){$f={$blk:BP.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};BP.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};BQ=function(d){var d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=CK(d);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=new BP.ptr(e);$s=-1;return $methodVal($clone(f,BP),"encode");}return;}if($f===undefined){$f={$blk:BQ};}$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};BR.ptr.prototype.encode=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=[g];h=this;if($clone(e,E.Value).IsNil()){d.Buffer.WriteString("null");$s=-1;return;}d.Buffer.WriteByte(123);i=$clone(e,E.Value).MapKeys();$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;g[0]=$makeSlice(FF,j.$length);k=j;l=0;case 2:if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);((m<0||m>=g[0].$length)?($throwRuntimeError("index out of range"),undefined):g[0].$array[g[0].$offset+m]).v=n;o=((m<0||m>=g[0].$length)?($throwRuntimeError("index out of range"),undefined):g[0].$array[g[0].$offset+m]).resolve();$s=4;case 4:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}p=o;if(!($interfaceIsEqual(p,$ifaceNil))){d.error(new AM.ptr($clone(n,E.Value).Type(),p));}l++;$s=2;continue;case 3:$r=K.Slice(g[0],(function(g){return function(q,r){var q,r;return((q<0||q>=g[0].$length)?($throwRuntimeError("index out of range"),undefined):g[0].$array[g[0].$offset+q]).s<((r<0||r>=g[0].$length)?($throwRuntimeError("index out of range"),undefined):g[0].$array[g[0].$offset+r]).s;};})(g));$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}q=g[0];r=0;case 6:if(!(r=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r]),CE);if(s>0){d.Buffer.WriteByte(44);}d.string(t.s,f.escapeHTML);d.Buffer.WriteByte(58);u=d;v=$clone(e,E.Value).MapIndex($clone(t.v,E.Value));$s=8;case 8:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}w=$clone(v,E.Value);x=$clone(f,AT);$r=h.elemEnc(u,w,x);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}r++;$s=6;continue;case 7:d.Buffer.WriteByte(125);$s=-1;return;}return;}if($f===undefined){$f={$blk:BR.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};BR.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};BS=function(d){var d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=d.Key();$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e.Kind();$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if((g===(24))||(g===(2))||(g===(3))||(g===(4))||(g===(5))||(g===(6))||(g===(7))||(g===(8))||(g===(9))||(g===(10))||(g===(11))||(g===(12))){$s=4;continue;}h=d.Key();$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h.Implements(AZ);$s=8;case 8:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}if(!i){$s=5;continue;}$s=6;continue;case 4:$s=6;continue;case 5:$s=-1;return BO;case 6:case 1:j=d.Elem();$s=9;case 9:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=AX(j);$s=10;case 10:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=new BR.ptr(k);$s=-1;return $methodVal($clone(l,BR),"encode");}return;}if($f===undefined){$f={$blk:BS};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};BT=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if($clone(e,E.Value).IsNil()){d.Buffer.WriteString("null");$s=-1;return;}g=$clone(e,E.Value).Bytes();$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;d.Buffer.WriteByte(34);i=C.StdEncoding.EncodedLen(h.$length);if(i<=64){$s=2;continue;}if(i<=1024){$s=3;continue;}$s=4;continue;case 2:j=$subslice(new ER(d.scratch),0,i);C.StdEncoding.Encode(j,h);d.Buffer.Write(j);$s=5;continue;case 3:k=$makeSlice(ER,i);C.StdEncoding.Encode(k,h);d.Buffer.Write(k);$s=5;continue;case 4:l=C.NewEncoder(C.StdEncoding,d);m=l.Write(h);$s=6;case 6:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;n=l.Close();$s=7;case 7:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}n;case 5:d.Buffer.WriteByte(34);$s=-1;return;}return;}if($f===undefined){$f={$blk:BT};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};BU.ptr.prototype.encode=function(d,e,f){var d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;if($clone(e,E.Value).IsNil()){d.Buffer.WriteString("null");$s=-1;return;}$r=g.arrayEnc(d,$clone(e,E.Value),$clone(f,AT));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:BU.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BU.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};BV=function(d){var d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=d.Elem();$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e.Kind();$s=4;case 4:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}if(f===8){$s=1;continue;}$s=2;continue;case 1:g=d.Elem();$s=5;case 5:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=E.PtrTo(g);$s=6;case 6:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;k=i.Implements(AY);$s=10;case 10:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}if(!(!k)){j=false;$s=9;continue s;}l=i.Implements(AZ);$s=11;case 11:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}j=!l;case 9:if(j){$s=7;continue;}$s=8;continue;case 7:$s=-1;return BT;case 8:case 2:m=BX(d);$s=12;case 12:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=new BU.ptr(m);$s=-1;return $methodVal($clone(n,BU),"encode");}return;}if($f===undefined){$f={$blk:BV};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};BW.ptr.prototype.encode=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;d.Buffer.WriteByte(91);h=$clone(e,E.Value).Len();i=0;case 1:if(!(i0){d.Buffer.WriteByte(44);}j=d;k=$clone(e,E.Value).Index(i);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=$clone(k,E.Value);m=$clone(f,AT);$r=g.elemEnc(j,l,m);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}i=i+(1)>>0;$s=1;continue;case 2:d.Buffer.WriteByte(93);$s=-1;return;}return;}if($f===undefined){$f={$blk:BW.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BW.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};BX=function(d){var d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=d.Elem();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=AX(e);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=new BW.ptr(f);$s=-1;return $methodVal($clone(g,BW),"encode");}return;}if($f===undefined){$f={$blk:BX};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BY.ptr.prototype.encode=function(d,e,f){var d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;if($clone(e,E.Value).IsNil()){d.Buffer.WriteString("null");$s=-1;return;}h=d;i=$clone(e,E.Value).Elem();$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=$clone(i,E.Value);k=$clone(f,AT);$r=g.elemEnc(h,j,k);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:BY.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BY.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};BZ=function(d){var d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=d.Elem();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=AX(e);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=new BY.ptr(f);$s=-1;return $methodVal($clone(g,BY),"encode");}return;}if($f===undefined){$f={$blk:BZ};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};CA.ptr.prototype.encode=function(d,e,f){var d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;if($clone(e,E.Value).CanAddr()){$s=1;continue;}$s=2;continue;case 1:$r=g.canAddrEnc(d,$clone(e,E.Value),$clone(f,AT));$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=3;continue;case 2:$r=g.elseEnc(d,$clone(e,E.Value),$clone(f,AT));$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:$s=-1;return;}return;}if($f===undefined){$f={$blk:CA.ptr.prototype.encode};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};CA.prototype.encode=function(d,e,f){return this.$val.encode(d,e,f);};CB=function(d,e){var d,e,f;f=new CA.ptr(d,e);return $methodVal($clone(f,CA),"encode");};CC=function(d){var d,e,f,g,h;if(d===""){return false;}e=d;f=0;while(true){if(!(f?@[]^_{|}~ ",h)){}else if(!G.IsLetter(h)&&!G.IsDigit(h)){return false;}f+=g[1];}return true;};CD=function(d,e){var d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=e;g=0;case 1:if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);i=d.Kind();$s=5;case 5:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}if(i===22){$s=3;continue;}$s=4;continue;case 3:j=d.Elem();$s=6;case 6:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}d=j;case 4:k=d.Field(h);$s=7;case 7:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}d=k.Type;g++;$s=1;continue;case 2:$s=-1;return d;}return;}if($f===undefined){$f={$blk:CD};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};CE.ptr.prototype.resolve=function(){var d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if($clone(d.v,E.Value).Kind()===24){$s=1;continue;}$s=2;continue;case 1:e=$clone(d.v,E.Value).String();$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d.s=e;$s=-1;return $ifaceNil;case 2:g=$clone(d.v,E.Value).Interface();$s=4;case 4:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=$assertType(g,B.TextMarshaler,true);h=f[0];i=f[1];if(i){$s=5;continue;}$s=6;continue;case 5:k=h.MarshalText();$s=7;case 7:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[0];m=j[1];d.s=($bytesToString(l));$s=-1;return m;case 6:n=$clone(d.v,E.Value).Kind();if((n===(2))||(n===(3))||(n===(4))||(n===(5))||(n===(6))){d.s=F.FormatInt($clone(d.v,E.Value).Int(),10);$s=-1;return $ifaceNil;}else if((n===(7))||(n===(8))||(n===(9))||(n===(10))||(n===(11))||(n===(12))){d.s=F.FormatUint($clone(d.v,E.Value).Uint(),10);$s=-1;return $ifaceNil;}$panic(new $String("unexpected map key type"));$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:CE.ptr.prototype.resolve};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};CE.prototype.resolve=function(){return this.$val.resolve();};AO.ptr.prototype.string=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=this;f.Buffer.WriteByte(34);g=0;h=0;while(true){if(!(h=EN.length)?($throwRuntimeError("index out of range"),undefined):EN[i])||(!e&&((i<0||i>=EM.length)?($throwRuntimeError("index out of range"),undefined):EM[i]))){h=h+(1)>>0;continue;}if(g>>4<<24>>>24)));f.Buffer.WriteByte(AN.charCodeAt(((i&15)>>>0)));}h=h+(1)>>0;g=h;continue;}k=I.DecodeRuneInString($substring(d,h));l=k[0];m=k[1];if((l===65533)&&(m===1)){if(g>0;g=h;continue;}if((l===8232)||(l===8233)){if(g>0;g=h;continue;}h=h+(m)>>0;}if(g=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+h]);if(i<128){if(((i<0||i>=EN.length)?($throwRuntimeError("index out of range"),undefined):EN[i])||(!e&&((i<0||i>=EM.length)?($throwRuntimeError("index out of range"),undefined):EM[i]))){h=h+(1)>>0;continue;}if(g>>4<<24>>>24)));f.Buffer.WriteByte(AN.charCodeAt(((i&15)>>>0)));}h=h+(1)>>0;g=h;continue;}k=I.DecodeRune($subslice(d,h));l=k[0];m=k[1];if((l===65533)&&(m===1)){if(g>0;g=h;continue;}if((l===8232)||(l===8233)){if(g>0;g=h;continue;}h=h+(m)>>0;}if(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]),CF);h=$clone(((d<0||d>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+d]),CF);CF.copy(((d<0||d>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+d]),g);CF.copy(((e<0||e>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]),h);};$ptrType(CG).prototype.Swap=function(d,e){return this.$get().Swap(d,e);};CG.prototype.Less=function(d,e){var d,e,f,g,h,i,j,k,l;f=this;g=((d<0||d>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+d]).index;h=0;while(true){if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);if(i>=((e<0||e>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]).index.$length){return false;}if(!((j===(k=((e<0||e>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]).index,((i<0||i>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+i]))))){return j<(l=((e<0||e>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]).index,((i<0||i>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+i]));}h++;}return((d<0||d>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+d]).index.$length<((e<0||e>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]).index.$length;};$ptrType(CG).prototype.Less=function(d,e){return this.$get().Less(d,e);};CH=function(d){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,bq,br,bs,bt,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;bo=$f.bo;bp=$f.bp;bq=$f.bq;br=$f.br;bs=$f.bs;bt=$f.bt;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=[f];g=new FB([]);h=new FB([new CF.ptr("",ER.nil,$throwNilPointerError,"","",false,EW.nil,d,false,false,$throwNilPointerError)]);i=$makeMap(E.Type.keyFor,[]);j=$makeMap(E.Type.keyFor,[]);k=$makeMap(E.Type.keyFor,[]);e[0]=FB.nil;f[0]=new A.Buffer.ptr(ER.nil,0,0);case 1:if(!(h.$length>0)){$s=2;continue;}l=h;m=$subslice(g,0,0);g=l;h=m;n=j;o=$makeMap(E.Type.keyFor,[]);i=n;j=o;p=g;q=0;case 3:if(!(q=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+q]),CF);if((s=k[E.Type.keyFor(r.typ)],s!==undefined?s.v:false)){$s=5;continue;}$s=6;continue;case 5:q++;$s=3;continue;case 6:t=r.typ;(k||$throwRuntimeError("assignment to entry in nil map"))[E.Type.keyFor(t)]={k:t,v:true};u=0;case 7:v=r.typ.NumField();$s=9;case 9:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}if(!(u>0;$s=7;continue;case 19:$s=13;continue;case 12:u=u+(1)>>0;$s=7;continue;case 13:ae=new E.StructTag(x.Tag).Get("json");if(ae==="-"){$s=22;continue;}$s=23;continue;case 22:u=u+(1)>>0;$s=7;continue;case 23:af=EP(ae);ag=af[0];ah=af[1];if(!CC(ag)){ag="";}ai=$makeSlice(EW,(r.index.$length+1>>0));$copySlice(ai,r.index);(aj=r.index.$length,((aj<0||aj>=ai.$length)?($throwRuntimeError("index out of range"),undefined):ai.$array[ai.$offset+aj]=u));ak=x.Type;am=ak.Name();$s=27;case 27:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}if(!(am==="")){al=false;$s=26;continue s;}an=ak.Kind();$s=28;case 28:if($c){$c=false;an=an.$blk();}if(an&&an.$blk!==undefined){break s;}al=an===22;case 26:if(al){$s=24;continue;}$s=25;continue;case 24:ao=ak.Elem();$s=29;case 29:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}ak=ao;case 25:ap=false;if(new EO(ah).Contains("string")){$s=30;continue;}$s=31;continue;case 30:aq=ak.Kind();$s=33;case 33:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;if((ar===(1))||(ar===(2))||(ar===(3))||(ar===(4))||(ar===(5))||(ar===(6))||(ar===(7))||(ar===(8))||(ar===(9))||(ar===(10))||(ar===(11))||(ar===(12))||(ar===(13))||(ar===(14))||(ar===(24))){ap=true;}case 32:case 31:if(!(ag==="")||!x.Anonymous){as=true;$s=36;continue s;}at=ak.Kind();$s=37;case 37:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}as=!((at===25));case 36:if(as){$s=34;continue;}$s=35;continue;case 34:au=!(ag==="");if(ag===""){ag=x.Name;}av=new CF.ptr(ag,ER.nil,$throwNilPointerError,"","",au,ai,ak,new EO(ah).Contains("omitempty"),ap,$throwNilPointerError);av.nameBytes=(new ER($stringToBytes(av.name)));av.equalFold=CL(av.nameBytes);f[0].Reset();f[0].WriteString("\"");AH(f[0],av.nameBytes);f[0].WriteString("\":");av.nameEscHTML=f[0].String();av.nameNonEsc="\""+av.name+"\":";e[0]=$append(e[0],av);if((aw=i[E.Type.keyFor(r.typ)],aw!==undefined?aw.v:0)>1){e[0]=$append(e[0],(ax=e[0].$length-1>>0,((ax<0||ax>=e[0].$length)?($throwRuntimeError("index out of range"),undefined):e[0].$array[e[0].$offset+ax])));}u=u+(1)>>0;$s=7;continue;case 35:ay=ak;(j||$throwRuntimeError("assignment to entry in nil map"))[E.Type.keyFor(ay)]={k:ay,v:(az=j[E.Type.keyFor(ak)],az!==undefined?az.v:0)+(1)>>0};if((ba=j[E.Type.keyFor(ak)],ba!==undefined?ba.v:0)===1){$s=38;continue;}$s=39;continue;case 38:bb=ak.Name();$s=40;case 40:if($c){$c=false;bb=bb.$blk();}if(bb&&bb.$blk!==undefined){break s;}h=$append(h,new CF.ptr(bb,ER.nil,$throwNilPointerError,"","",false,ai,ak,false,false,$throwNilPointerError));case 39:u=u+(1)>>0;$s=7;continue;case 8:q++;$s=3;continue;case 4:$s=1;continue;case 2:$r=K.Slice(e[0],(function(e,f){return function(bc,bd){var bc,bd,be;be=e[0];if(!(((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).name===((bd<0||bd>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bd]).name)){return((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).name<((bd<0||bd>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bd]).name;}if(!((((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).index.$length===((bd<0||bd>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bd]).index.$length))){return((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).index.$length<((bd<0||bd>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bd]).index.$length;}if(!(((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).tag===((bd<0||bd>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bd]).tag)){return((bc<0||bc>=be.$length)?($throwRuntimeError("index out of range"),undefined):be.$array[be.$offset+bc]).tag;}return($subslice(new CG(be.$array),be.$offset,be.$offset+be.$length)).Less(bc,bd);};})(e,f));$s=41;case 41:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}bc=$subslice(e[0],0,0);bd=0;be=0;bf=bd;bg=be;case 42:if(!(bg=e[0].$length)?($throwRuntimeError("index out of range"),undefined):e[0].$array[e[0].$offset+bg]),CF);bi=bh.name;bf=1;while(true){if(!((bg+bf>>0)>0,((bj<0||bj>=e[0].$length)?($throwRuntimeError("index out of range"),undefined):e[0].$array[e[0].$offset+bj])),CF);if(!(bk.name===bi)){break;}bf=bf+(1)>>0;}if(bf===1){bc=$append(bc,bh);bg=bg+(bf)>>0;$s=42;continue;}bl=CI($subslice(e[0],bg,(bg+bf>>0)));bm=$clone(bl[0],CF);bn=bl[1];if(bn){bc=$append(bc,bm);}bg=bg+(bf)>>0;$s=42;continue;case 43:e[0]=bc;$r=K.Sort(($subslice(new CG(e[0].$array),e[0].$offset,e[0].$offset+e[0].$length)));$s=44;case 44:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}bo=e[0];bp=0;case 45:if(!(bp=e[0].$length)?($throwRuntimeError("index out of range"),undefined):e[0].$array[e[0].$offset+bq]);bs=CD(d,br.index);$s=47;case 47:if($c){$c=false;bs=bs.$blk();}if(bs&&bs.$blk!==undefined){break s;}bt=AX(bs);$s=48;case 48:if($c){$c=false;bt=bt.$blk();}if(bt&&bt.$blk!==undefined){break s;}br.encoder=bt;bp++;$s=45;continue;case 46:$s=-1;return e[0];}return;}if($f===undefined){$f={$blk:CH};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.bo=bo;$f.bp=bp;$f.bq=bq;$f.br=br;$f.bs=bs;$f.bt=bt;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};CI=function(d){var d;if(d.$length>1&&((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]).index.$length===(1>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+1]).index.$length)&&(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]).tag===(1>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+1]).tag){return[new CF.ptr("",ER.nil,$throwNilPointerError,"","",false,EW.nil,$ifaceNil,false,false,$throwNilPointerError),false];}return[(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]),true];};CK=function(d){var d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=CJ.Load(d);f=e[0];g=e[1];if(g){$s=-1;return $assertType(f,FB);}i=d;j=CH(d);$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;l=CJ.LoadOrStore(i,k);$s=2;case 2:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}h=l;m=h[0];$s=-1;return $assertType(m,FB);}return;}if($f===undefined){$f={$blk:CK};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};CL=function(d){var d,e,f,g,h,i,j;e=false;f=false;g=d;h=0;while(true){if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);if(i>=128){return A.EqualFold;}j=(i&223)>>>0;if(j<65||j>90){e=true;}else if((j===75)||(j===83)){f=true;}h++;}if(f){return CM;}if(e){return CN;}return CO;};CM=function(d,e){var d,e,f,g,h,i,j,k,l,m,n;f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(e.$length===0){return false;}i=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);if(i<128){if(!((h===i))){j=(h&223)>>>0;if(65<=j&&j<=90){if(!((j===((i&223)>>>0)))){return false;}}else{return false;}}e=$subslice(e,1);g++;continue;}k=I.DecodeRune(e);l=k[0];m=k[1];n=h;if((n===(115))||(n===(83))){if(!((l===383))){return false;}}else if((n===(107))||(n===(75))){if(!((l===8490))){return false;}}else{return false;}e=$subslice(e,m);g++;}if(e.$length>0){return false;}return true;};CN=function(d,e){var d,e,f,g,h,i,j;if(!((d.$length===e.$length))){return false;}f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);j=((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]);if(i===j){g++;continue;}if((97<=i&&i<=122)||(65<=i&&i<=90)){if(!((((i&223)>>>0)===((j&223)>>>0)))){return false;}}else{return false;}g++;}return true;};CO=function(d,e){var d,e,f,g,h,i;if(!((d.$length===e.$length))){return false;}f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(!((((i&223)>>>0)===((((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])&223)>>>0)))){return false;}g++;}return true;};CQ=function(d,e,f){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=[g];h=d.Len();g[0]=new CW.ptr($throwNilPointerError,false,EW.nil,$ifaceNil,new $Int64(0,0));g[0].reset();i=0;j=e;k=0;case 1:if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]);if(f&&((m===60)||(m===62)||(m===38))){if(i>>4<<24>>>24)));d.WriteByte(AN.charCodeAt(((m&15)>>>0)));i=l+1>>0;}if((m===226)&&(l+2>>0)>0,((n<0||n>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+n]))===128)&&((((o=l+2>>0,((o<0||o>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+o]))&~1)<<24>>>24)===168)){if(i>0,((p<0||p>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+p]))&15)>>>0)));i=l+3>>0;}q=g[0].step(g[0],m);$s=3;case 3:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=q;if(r>=9){if(r===11){$s=2;continue;}if(i>0;}k++;$s=1;continue;case 2:s=g[0].eof();$s=6;case 6:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}if(s===11){$s=4;continue;}$s=5;continue;case 4:d.Truncate(h);$s=-1;return g[0].err;case 5:if(i>0;d.parseState=$subslice(d.parseState,0,e);if(e===0){d.step=DD;d.endTop=true;}else{d.step=DC;}};CW.prototype.popParseState=function(){return this.$val.popParseState();};CX=function(d){var d;return(d===32)||(d===9)||(d===13)||(d===10);};CY=function(d,e){var d,e;if(e<=32&&CX(e)){return 9;}if(e===93){return DC(d,e);}return CZ(d,e);};CZ=function(d,e){var d,e,f;if(e<=32&&CX(e)){return 9;}f=e;if(f===(123)){d.step=DA;d.pushParseState(0);return 2;}else if(f===(91)){d.step=CY;d.pushParseState(2);return 6;}else if(f===(34)){d.step=DE;return 1;}else if(f===(45)){d.step=DK;return 1;}else if(f===(48)){d.step=DM;return 1;}else if(f===(116)){d.step=DS;return 1;}else if(f===(102)){d.step=DV;return 1;}else if(f===(110)){d.step=DZ;return 1;}if(49<=e&&e<=57){d.step=DL;return 1;}return d.error(e,"looking for beginning of value");};DA=function(d,e){var d,e,f,g,h;if(e<=32&&CX(e)){return 9;}if(e===125){f=d.parseState.$length;(g=d.parseState,h=f-1>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]=1));return DC(d,e);}return DB(d,e);};DB=function(d,e){var d,e;if(e<=32&&CX(e)){return 9;}if(e===34){d.step=DE;return 1;}return d.error(e,"looking for beginning of object key string");};DC=function(d,e){var d,e,f,g,h,i,j,k,l,m,n;f=d.parseState.$length;if(f===0){d.step=DD;d.endTop=true;return DD(d,e);}if(e<=32&&CX(e)){d.step=DC;return 9;}i=(g=d.parseState,h=f-1>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]));j=i;if(j===(0)){if(e===58){(k=d.parseState,l=f-1>>0,((l<0||l>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]=1));d.step=CZ;return 3;}return d.error(e,"after object key");}else if(j===(1)){if(e===44){(m=d.parseState,n=f-1>>0,((n<0||n>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]=0));d.step=DB;return 4;}if(e===125){d.popParseState();return 5;}return d.error(e,"after object key:value pair");}else if(j===(2)){if(e===44){d.step=CZ;return 7;}if(e===93){d.popParseState();return 8;}return d.error(e,"after array element");}return d.error(e,"");};DD=function(d,e){var d,e;if(!CX(e)){d.error(e,"after top-level value");}return 10;};DE=function(d,e){var d,e;if(e===34){d.step=DC;return 0;}if(e===92){d.step=DF;return 0;}if(e<32){return d.error(e,"in string literal");}return 0;};DF=function(d,e){var d,e,f;f=e;if((f===(98))||(f===(102))||(f===(110))||(f===(114))||(f===(116))||(f===(92))||(f===(47))||(f===(34))){d.step=DE;return 0;}else if(f===(117)){d.step=DG;return 0;}return d.error(e,"in string escape code");};DG=function(d,e){var d,e;if(48<=e&&e<=57||97<=e&&e<=102||65<=e&&e<=70){d.step=DH;return 0;}return d.error(e,"in \\u hexadecimal character escape");};DH=function(d,e){var d,e;if(48<=e&&e<=57||97<=e&&e<=102||65<=e&&e<=70){d.step=DI;return 0;}return d.error(e,"in \\u hexadecimal character escape");};DI=function(d,e){var d,e;if(48<=e&&e<=57||97<=e&&e<=102||65<=e&&e<=70){d.step=DJ;return 0;}return d.error(e,"in \\u hexadecimal character escape");};DJ=function(d,e){var d,e;if(48<=e&&e<=57||97<=e&&e<=102||65<=e&&e<=70){d.step=DE;return 0;}return d.error(e,"in \\u hexadecimal character escape");};DK=function(d,e){var d,e;if(e===48){d.step=DM;return 0;}if(49<=e&&e<=57){d.step=DL;return 0;}return d.error(e,"in numeric literal");};DL=function(d,e){var d,e;if(48<=e&&e<=57){d.step=DL;return 0;}return DM(d,e);};DM=function(d,e){var d,e;if(e===46){d.step=DN;return 0;}if((e===101)||(e===69)){d.step=DP;return 0;}return DC(d,e);};DN=function(d,e){var d,e;if(48<=e&&e<=57){d.step=DO;return 0;}return d.error(e,"after decimal point in numeric literal");};DO=function(d,e){var d,e;if(48<=e&&e<=57){return 0;}if((e===101)||(e===69)){d.step=DP;return 0;}return DC(d,e);};DP=function(d,e){var d,e;if((e===43)||(e===45)){d.step=DQ;return 0;}return DQ(d,e);};DQ=function(d,e){var d,e;if(48<=e&&e<=57){d.step=DR;return 0;}return d.error(e,"in exponent of numeric literal");};DR=function(d,e){var d,e;if(48<=e&&e<=57){return 0;}return DC(d,e);};DS=function(d,e){var d,e;if(e===114){d.step=DT;return 0;}return d.error(e,"in literal true (expecting 'r')");};DT=function(d,e){var d,e;if(e===117){d.step=DU;return 0;}return d.error(e,"in literal true (expecting 'u')");};DU=function(d,e){var d,e;if(e===101){d.step=DC;return 0;}return d.error(e,"in literal true (expecting 'e')");};DV=function(d,e){var d,e;if(e===97){d.step=DW;return 0;}return d.error(e,"in literal false (expecting 'a')");};DW=function(d,e){var d,e;if(e===108){d.step=DX;return 0;}return d.error(e,"in literal false (expecting 'l')");};DX=function(d,e){var d,e;if(e===115){d.step=DY;return 0;}return d.error(e,"in literal false (expecting 's')");};DY=function(d,e){var d,e;if(e===101){d.step=DC;return 0;}return d.error(e,"in literal false (expecting 'e')");};DZ=function(d,e){var d,e;if(e===117){d.step=EA;return 0;}return d.error(e,"in literal null (expecting 'u')");};EA=function(d,e){var d,e;if(e===108){d.step=EB;return 0;}return d.error(e,"in literal null (expecting 'l')");};EB=function(d,e){var d,e;if(e===108){d.step=DC;return 0;}return d.error(e,"in literal null (expecting 'l')");};EC=function(d,e){var d,e;return 11;};CW.ptr.prototype.error=function(d,e){var d,e,f;f=this;f.step=EC;f.err=new CV.ptr("invalid character "+ED(d)+" "+e,f.bytes);return 11;};CW.prototype.error=function(d,e){return this.$val.error(d,e);};ED=function(d){var d,e;if(d===39){return"'\\''";}if(d===34){return"'\"'";}e=F.Quote(($encodeRune(d)));return"'"+$substring(e,1,(e.length-1>>0))+"'";};EP=function(d){var d,e;e=L.Index(d,",");if(!((e===-1))){return[$substring(d,0,e),($substring(d,(e+1>>0)))];}return[d,""];};EO.prototype.Contains=function(d){var d,e,f,g,h,i,j;e=this.$val;if(e.length===0){return false;}f=(e);while(true){if(!(!(f===""))){break;}g="";h=L.Index(f,",");if(h>=0){i=$substring(f,0,h);j=$substring(f,(h+1>>0));f=i;g=j;}if(f===d){return true;}f=g;}return false;};$ptrType(EO).prototype.Contains=function(d){return new EO(this.$get()).Contains(d);};U.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Float64",name:"Float64",pkg:"",typ:$funcType([],[$Float64,$error],false)},{prop:"Int64",name:"Int64",pkg:"",typ:$funcType([],[$Int64,$error],false)}];FM.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];FN.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];FP.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];FD.methods=[{prop:"marshal",name:"marshal",pkg:"encoding/json",typ:$funcType([$emptyInterface,AT],[$error],false)},{prop:"error",name:"error",pkg:"encoding/json",typ:$funcType([$error],[],false)},{prop:"reflectValue",name:"reflectValue",pkg:"encoding/json",typ:$funcType([E.Value,AT],[],false)},{prop:"string",name:"string",pkg:"encoding/json",typ:$funcType([$String,$Bool],[],false)},{prop:"stringBytes",name:"stringBytes",pkg:"encoding/json",typ:$funcType([ER,$Bool],[],false)}];BJ.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];BP.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];BR.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];BU.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];BW.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];BY.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];CA.methods=[{prop:"encode",name:"encode",pkg:"encoding/json",typ:$funcType([FD,E.Value,AT],[],false)}];FQ.methods=[{prop:"resolve",name:"resolve",pkg:"encoding/json",typ:$funcType([],[$error],false)}];CG.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$Int,$Int],[],false)},{prop:"Less",name:"Less",pkg:"",typ:$funcType([$Int,$Int],[$Bool],false)}];FS.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];FT.methods=[{prop:"reset",name:"reset",pkg:"encoding/json",typ:$funcType([],[],false)},{prop:"eof",name:"eof",pkg:"encoding/json",typ:$funcType([],[$Int],false)},{prop:"pushParseState",name:"pushParseState",pkg:"encoding/json",typ:$funcType([$Int],[],false)},{prop:"popParseState",name:"popParseState",pkg:"encoding/json",typ:$funcType([],[],false)},{prop:"error",name:"error",pkg:"encoding/json",typ:$funcType([$Uint8,$String],[$Int],false)}];EO.methods=[{prop:"Contains",name:"Contains",pkg:"",typ:$funcType([$String],[$Bool],false)}];AI.init([{prop:"MarshalJSON",name:"MarshalJSON",pkg:"",typ:$funcType([],[ER,$error],false)}]);AJ.init("",[{prop:"Type",name:"Type",embedded:false,exported:true,typ:E.Type,tag:""}]);AK.init("",[{prop:"Value",name:"Value",embedded:false,exported:true,typ:E.Value,tag:""},{prop:"Str",name:"Str",embedded:false,exported:true,typ:$String,tag:""}]);AM.init("",[{prop:"Type",name:"Type",embedded:false,exported:true,typ:E.Type,tag:""},{prop:"Err",name:"Err",embedded:false,exported:true,typ:$error,tag:""}]);AO.init("encoding/json",[{prop:"Buffer",name:"Buffer",embedded:true,exported:true,typ:A.Buffer,tag:""},{prop:"scratch",name:"scratch",embedded:false,exported:false,typ:FE,tag:""}]);AR.init("encoding/json",[{prop:"error",name:"error",embedded:true,exported:false,typ:$error,tag:""}]);AT.init("encoding/json",[{prop:"quoted",name:"quoted",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"escapeHTML",name:"escapeHTML",embedded:false,exported:false,typ:$Bool,tag:""}]);AU.init([FD,E.Value,AT],[],false);BP.init("encoding/json",[{prop:"fields",name:"fields",embedded:false,exported:false,typ:FB,tag:""}]);BR.init("encoding/json",[{prop:"elemEnc",name:"elemEnc",embedded:false,exported:false,typ:AU,tag:""}]);BU.init("encoding/json",[{prop:"arrayEnc",name:"arrayEnc",embedded:false,exported:false,typ:AU,tag:""}]);BW.init("encoding/json",[{prop:"elemEnc",name:"elemEnc",embedded:false,exported:false,typ:AU,tag:""}]);BY.init("encoding/json",[{prop:"elemEnc",name:"elemEnc",embedded:false,exported:false,typ:AU,tag:""}]);CA.init("encoding/json",[{prop:"canAddrEnc",name:"canAddrEnc",embedded:false,exported:false,typ:AU,tag:""},{prop:"elseEnc",name:"elseEnc",embedded:false,exported:false,typ:AU,tag:""}]);CE.init("encoding/json",[{prop:"v",name:"v",embedded:false,exported:false,typ:E.Value,tag:""},{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""}]);CF.init("encoding/json",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"nameBytes",name:"nameBytes",embedded:false,exported:false,typ:ER,tag:""},{prop:"equalFold",name:"equalFold",embedded:false,exported:false,typ:FR,tag:""},{prop:"nameNonEsc",name:"nameNonEsc",embedded:false,exported:false,typ:$String,tag:""},{prop:"nameEscHTML",name:"nameEscHTML",embedded:false,exported:false,typ:$String,tag:""},{prop:"tag",name:"tag",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"index",name:"index",embedded:false,exported:false,typ:EW,tag:""},{prop:"typ",name:"typ",embedded:false,exported:false,typ:E.Type,tag:""},{prop:"omitEmpty",name:"omitEmpty",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"quoted",name:"quoted",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"encoder",name:"encoder",embedded:false,exported:false,typ:AU,tag:""}]);CG.init(CF);CV.init("encoding/json",[{prop:"msg",name:"msg",embedded:false,exported:false,typ:$String,tag:""},{prop:"Offset",name:"Offset",embedded:false,exported:true,typ:$Int64,tag:""}]);CW.init("encoding/json",[{prop:"step",name:"step",embedded:false,exported:false,typ:FU,tag:""},{prop:"endTop",name:"endTop",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"parseState",name:"parseState",embedded:false,exported:false,typ:EW,tag:""},{prop:"err",name:"err",embedded:false,exported:false,typ:$error,tag:""},{prop:"bytes",name:"bytes",embedded:false,exported:false,typ:$Int64,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=N.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=M.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=O.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=J.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K.$init();$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=L.$init();$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=14;case 14:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=15;case 15:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}AP=new M.Pool.ptr(EQ.nil,$throwNilPointerError);AV=new M.Map.ptr(false);CJ=new M.Map.ptr(false);a=E.TypeOf((ES.nil)).Elem();$s=16;case 16:if($c){$c=false;a=a.$blk();}if(a&&a.$blk!==undefined){break s;}AA=a;AB=E.TypeOf(new U(""));AN="0123456789abcdef";b=E.TypeOf((ET.nil)).Elem();$s=17;case 17:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}AY=b;c=E.TypeOf((EU.nil)).Elem();$s=18;case 18:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}AZ=c;BK=$methodVal(new BJ(32),"encode");BL=$methodVal(new BJ(64),"encode");EM=$toNativeArray($kindBool,[false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true]);EN=$toNativeArray($kindBool,[false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,true,true,false,true,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,false,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["log"]=(function(){var $pkg={},$init,A,E,B,C,D,F,G,Z,AA,AB,AC,AD,I,H,J,Q,R;A=$packages["fmt"];E=$packages["github.com/gopherjs/gopherjs/nosync"];B=$packages["io"];C=$packages["os"];D=$packages["runtime"];F=$packages["time"];G=$pkg.Logger=$newType(0,$kindStruct,"log.Logger",true,"log",true,function(mu_,prefix_,flag_,out_,buf_){this.$val=this;if(arguments.length===0){this.mu=new E.Mutex.ptr(false);this.prefix="";this.flag=0;this.out=$ifaceNil;this.buf=Z.nil;return;}this.mu=mu_;this.prefix=prefix_;this.flag=flag_;this.out=out_;this.buf=buf_;});Z=$sliceType($Uint8);AA=$arrayType($Uint8,20);AB=$ptrType(Z);AC=$sliceType($emptyInterface);AD=$ptrType(G);H=function(a,b,c){var a,b,c;return new G.ptr(new E.Mutex.ptr(false),b,c,a,Z.nil);};$pkg.New=H;G.ptr.prototype.SetOutput=function(a){var a,b,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);b=this;b.mu.Lock();$deferred.push([$methodVal(b.mu,"Unlock"),[]]);b.out=a;}catch(err){$err=err;}finally{$callDeferred($deferred,$err);}};G.prototype.SetOutput=function(a){return this.$val.SetOutput(a);};J=function(a,b,c){var a,b,c,d,e,f,g;d=AA.zero();e=19;while(true){if(!(b>=10||c>1)){break;}c=c-(1)>>0;g=(f=b/10,(f===f&&f!==1/0&&f!==-1/0)?f>>0:$throwRuntimeError("integer divide by zero"));((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=((((48+b>>0)-($imul(g,10))>>0)<<24>>>24)));e=e-(1)>>0;b=g;}((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]=(((48+b>>0)<<24>>>24)));a.$set($appendSlice(a.$get(),$subslice(new Z(d),e)));};G.ptr.prototype.formatHeader=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;a.$set($appendSlice(a.$get(),e.prefix));if(!(((e.flag&7)===0))){$s=1;continue;}$s=2;continue;case 1:if(!(((e.flag&32)===0))){F.Time.copy(b,$clone(b,F.Time).UTC());}if(!(((e.flag&1)===0))){$s=3;continue;}$s=4;continue;case 3:g=$clone(b,F.Time).Date();$s=5;case 5:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[0];i=f[1];j=f[2];J(a,h,4);a.$set($append(a.$get(),47));J(a,((i>>0)),2);a.$set($append(a.$get(),47));J(a,j,2);a.$set($append(a.$get(),32));case 4:if(!(((e.flag&6)===0))){$s=6;continue;}$s=7;continue;case 6:l=$clone(b,F.Time).Clock();$s=8;case 8:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;m=k[0];n=k[1];o=k[2];J(a,m,2);a.$set($append(a.$get(),58));J(a,n,2);a.$set($append(a.$get(),58));J(a,o,2);if(!(((e.flag&4)===0))){a.$set($append(a.$get(),46));J(a,(p=$clone(b,F.Time).Nanosecond()/1000,(p===p&&p!==1/0&&p!==-1/0)?p>>0:$throwRuntimeError("integer divide by zero")),6);}a.$set($append(a.$get(),32));case 7:case 2:if(!(((e.flag&24)===0))){if(!(((e.flag&16)===0))){q=c;r=c.length-1>>0;while(true){if(!(r>0)){break;}if(c.charCodeAt(r)===47){q=$substring(c,(r+1>>0));break;}r=r-(1)>>0;}c=q;}a.$set($appendSlice(a.$get(),c));a.$set($append(a.$get(),58));J(a,d,-1);a.$set($appendSlice(a.$get(),": "));}$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.formatHeader};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.formatHeader=function(a,b,c,d){return this.$val.formatHeader(a,b,c,d);};G.ptr.prototype.Output=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);c=this;d=$clone(F.Now(),F.Time);e="";f=0;c.mu.Lock();$deferred.push([$methodVal(c.mu,"Unlock"),[]]);if(!(((c.flag&24)===0))){c.mu.Unlock();g=false;h=D.Caller(a);e=h[1];f=h[2];g=h[3];if(!g){e="???";f=0;}c.mu.Lock();}c.buf=$subslice(c.buf,0,0);$r=c.formatHeader((c.$ptr_buf||(c.$ptr_buf=new AB(function(){return this.$target.buf;},function($v){this.$target.buf=$v;},c))),$clone(d,F.Time),e,f);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c.buf=$appendSlice(c.buf,b);if((b.length===0)||!((b.charCodeAt((b.length-1>>0))===10))){c.buf=$append(c.buf,10);}j=c.out.Write(c.buf);$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[1];$s=-1;return k;}return;}}catch(err){$err=err;$s=-1;return $ifaceNil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:G.ptr.prototype.Output};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};G.prototype.Output=function(a,b){return this.$val.Output(a,b);};G.ptr.prototype.Printf=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=A.Sprintf(a,b);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;f=c.Output(2,e);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Printf};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Printf=function(a,b){return this.$val.Printf(a,b);};G.ptr.prototype.Print=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprint(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Print};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Print=function(a){return this.$val.Print(a);};G.ptr.prototype.Println=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprintln(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Println};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Println=function(a){return this.$val.Println(a);};G.ptr.prototype.Fatal=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprint(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;C.Exit(1);$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Fatal};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Fatal=function(a){return this.$val.Fatal(a);};G.ptr.prototype.Fatalf=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=A.Sprintf(a,b);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;f=c.Output(2,e);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;C.Exit(1);$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Fatalf};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Fatalf=function(a,b){return this.$val.Fatalf(a,b);};G.ptr.prototype.Fatalln=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprintln(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;C.Exit(1);$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Fatalln};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Fatalln=function(a){return this.$val.Fatalln(a);};G.ptr.prototype.Panic=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprint(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;$panic(new $String(d));$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Panic};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Panic=function(a){return this.$val.Panic(a);};G.ptr.prototype.Panicf=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=A.Sprintf(a,b);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;f=c.Output(2,e);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;$panic(new $String(e));$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Panicf};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Panicf=function(a,b){return this.$val.Panicf(a,b);};G.ptr.prototype.Panicln=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=A.Sprintln(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=b.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;$panic(new $String(d));$s=-1;return;}return;}if($f===undefined){$f={$blk:G.ptr.prototype.Panicln};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};G.prototype.Panicln=function(a){return this.$val.Panicln(a);};G.ptr.prototype.Flags=function(){var a,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);a=this;a.mu.Lock();$deferred.push([$methodVal(a.mu,"Unlock"),[]]);return a.flag;}catch(err){$err=err;return 0;}finally{$callDeferred($deferred,$err);}};G.prototype.Flags=function(){return this.$val.Flags();};G.ptr.prototype.SetFlags=function(a){var a,b,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);b=this;b.mu.Lock();$deferred.push([$methodVal(b.mu,"Unlock"),[]]);b.flag=a;}catch(err){$err=err;}finally{$callDeferred($deferred,$err);}};G.prototype.SetFlags=function(a){return this.$val.SetFlags(a);};G.ptr.prototype.Prefix=function(){var a,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);a=this;a.mu.Lock();$deferred.push([$methodVal(a.mu,"Unlock"),[]]);return a.prefix;}catch(err){$err=err;return"";}finally{$callDeferred($deferred,$err);}};G.prototype.Prefix=function(){return this.$val.Prefix();};G.ptr.prototype.SetPrefix=function(a){var a,b,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);b=this;b.mu.Lock();$deferred.push([$methodVal(b.mu,"Unlock"),[]]);b.prefix=a;}catch(err){$err=err;}finally{$callDeferred($deferred,$err);}};G.prototype.SetPrefix=function(a){return this.$val.SetPrefix(a);};G.ptr.prototype.Writer=function(){var a,$deferred;var $err=null;try{$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);a=this;a.mu.Lock();$deferred.push([$methodVal(a.mu,"Unlock"),[]]);return a.out;}catch(err){$err=err;return $ifaceNil;}finally{$callDeferred($deferred,$err);}};G.prototype.Writer=function(){return this.$val.Writer();};Q=function(a,b){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=A.Sprintf(a,b);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=I.Output(2,d);$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;$s=-1;return;}return;}if($f===undefined){$f={$blk:Q};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Printf=Q;R=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=A.Sprintln(a);$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;d=I.Output(2,c);$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}d;$s=-1;return;}return;}if($f===undefined){$f={$blk:R};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Println=R;AD.methods=[{prop:"SetOutput",name:"SetOutput",pkg:"",typ:$funcType([B.Writer],[],false)},{prop:"formatHeader",name:"formatHeader",pkg:"log",typ:$funcType([AB,F.Time,$String,$Int],[],false)},{prop:"Output",name:"Output",pkg:"",typ:$funcType([$Int,$String],[$error],false)},{prop:"Printf",name:"Printf",pkg:"",typ:$funcType([$String,AC],[],true)},{prop:"Print",name:"Print",pkg:"",typ:$funcType([AC],[],true)},{prop:"Println",name:"Println",pkg:"",typ:$funcType([AC],[],true)},{prop:"Fatal",name:"Fatal",pkg:"",typ:$funcType([AC],[],true)},{prop:"Fatalf",name:"Fatalf",pkg:"",typ:$funcType([$String,AC],[],true)},{prop:"Fatalln",name:"Fatalln",pkg:"",typ:$funcType([AC],[],true)},{prop:"Panic",name:"Panic",pkg:"",typ:$funcType([AC],[],true)},{prop:"Panicf",name:"Panicf",pkg:"",typ:$funcType([$String,AC],[],true)},{prop:"Panicln",name:"Panicln",pkg:"",typ:$funcType([AC],[],true)},{prop:"Flags",name:"Flags",pkg:"",typ:$funcType([],[$Int],false)},{prop:"SetFlags",name:"SetFlags",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Prefix",name:"Prefix",pkg:"",typ:$funcType([],[$String],false)},{prop:"SetPrefix",name:"SetPrefix",pkg:"",typ:$funcType([$String],[],false)},{prop:"Writer",name:"Writer",pkg:"",typ:$funcType([],[B.Writer],false)}];G.init("log",[{prop:"mu",name:"mu",embedded:false,exported:false,typ:E.Mutex,tag:""},{prop:"prefix",name:"prefix",embedded:false,exported:false,typ:$String,tag:""},{prop:"flag",name:"flag",embedded:false,exported:false,typ:$Int,tag:""},{prop:"out",name:"out",embedded:false,exported:false,typ:B.Writer,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:Z,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}I=H(C.Stderr,"",3);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["math/rand"]=(function(){var $pkg={},$init,B,A,J,K,M,AG,AI,AM,AN,AO,AP,AQ,AR,AT,AU,AV,C,D,E,G,H,I,P,AH,F,L,N,O,AJ;B=$packages["github.com/gopherjs/gopherjs/nosync"];A=$packages["math"];J=$pkg.Source=$newType(8,$kindInterface,"rand.Source",true,"math/rand",true,null);K=$pkg.Source64=$newType(8,$kindInterface,"rand.Source64",true,"math/rand",true,null);M=$pkg.Rand=$newType(0,$kindStruct,"rand.Rand",true,"math/rand",true,function(src_,s64_,readVal_,readPos_){this.$val=this;if(arguments.length===0){this.src=$ifaceNil;this.s64=$ifaceNil;this.readVal=new $Int64(0,0);this.readPos=0;return;}this.src=src_;this.s64=s64_;this.readVal=readVal_;this.readPos=readPos_;});AG=$pkg.lockedSource=$newType(0,$kindStruct,"rand.lockedSource",true,"math/rand",false,function(lk_,src_){this.$val=this;if(arguments.length===0){this.lk=new B.Mutex.ptr(false);this.src=$ifaceNil;return;}this.lk=lk_;this.src=src_;});AI=$pkg.rngSource=$newType(0,$kindStruct,"rand.rngSource",true,"math/rand",false,function(tap_,feed_,vec_){this.$val=this;if(arguments.length===0){this.tap=0;this.feed=0;this.vec=AM.zero();return;}this.tap=tap_;this.feed=feed_;this.vec=vec_;});AM=$arrayType($Int64,607);AN=$ptrType(AG);AO=$ptrType($Int8);AP=$sliceType($Int);AQ=$ptrType($Int64);AR=$ptrType(M);AT=$funcType([$Int,$Int],[],false);AU=$sliceType($Uint8);AV=$ptrType(AI);M.ptr.prototype.ExpFloat64=function(){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;case 1:b=a.Uint32();$s=3;case 3:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;d=(c&255)>>>0;e=(c)*(((d<0||d>=D.length)?($throwRuntimeError("index out of range"),undefined):D[d]));if(c<((d<0||d>=C.length)?($throwRuntimeError("index out of range"),undefined):C[d])){$s=-1;return e;}if(d===0){$s=4;continue;}$s=5;continue;case 4:f=a.Float64();$s=6;case 6:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=A.Log(f);$s=7;case 7:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return 7.69711747013105-g;case 5:h=a.Float64();$s=10;case 10:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if($fround(((d<0||d>=E.length)?($throwRuntimeError("index out of range"),undefined):E[d])+$fround(($fround(h))*($fround((i=d-1>>>0,((i<0||i>=E.length)?($throwRuntimeError("index out of range"),undefined):E[i]))-((d<0||d>=E.length)?($throwRuntimeError("index out of range"),undefined):E[d])))))<($fround(A.Exp(-e)))){$s=8;continue;}$s=9;continue;case 8:$s=-1;return e;case 9:$s=1;continue;case 2:$s=-1;return 0;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.ExpFloat64};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.ExpFloat64=function(){return this.$val.ExpFloat64();};F=function(a){var a;if(a<0){return((-a>>>0));}return((a>>>0));};M.ptr.prototype.NormFloat64=function(){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;case 1:b=a.Uint32();$s=3;case 3:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=((b>>0));d=c&127;e=(c)*(((d<0||d>=H.length)?($throwRuntimeError("index out of range"),undefined):H[d]));if(F(c)<((d<0||d>=G.length)?($throwRuntimeError("index out of range"),undefined):G[d])){$s=-1;return e;}if(d===0){$s=4;continue;}$s=5;continue;case 4:case 6:f=a.Float64();$s=8;case 8:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=A.Log(f);$s=9;case 9:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}e=-g*0.29047645161474317;h=a.Float64();$s=10;case 10:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=A.Log(h);$s=11;case 11:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=-i;if(j+j>=e*e){$s=7;continue;}$s=6;continue;case 7:if(c>0){$s=-1;return 3.442619855899+e;}$s=-1;return-3.442619855899-e;case 5:k=a.Float64();$s=14;case 14:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}if($fround(((d<0||d>=I.length)?($throwRuntimeError("index out of range"),undefined):I[d])+$fround(($fround(k))*($fround((l=d-1>>0,((l<0||l>=I.length)?($throwRuntimeError("index out of range"),undefined):I[l]))-((d<0||d>=I.length)?($throwRuntimeError("index out of range"),undefined):I[d])))))<($fround(A.Exp(-0.5*e*e)))){$s=12;continue;}$s=13;continue;case 12:$s=-1;return e;case 13:$s=1;continue;case 2:$s=-1;return 0;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.NormFloat64};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.NormFloat64=function(){return this.$val.NormFloat64();};L=function(a){var a,b;b=new AI.ptr(0,0,AM.zero());b.Seed(a);return b;};$pkg.NewSource=L;N=function(a){var a,b,c;b=$assertType(a,K,true);c=b[0];return new M.ptr(a,c,new $Int64(0,0),0);};$pkg.New=N;M.ptr.prototype.Seed=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=$assertType(b.src,AN,true);d=c[0];e=c[1];if(e){$s=1;continue;}$s=2;continue;case 1:$r=d.seedPos(a,(b.$ptr_readPos||(b.$ptr_readPos=new AO(function(){return this.$target.readPos;},function($v){this.$target.readPos=$v;},b))));$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 2:$r=b.src.Seed(a);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}b.readPos=0;$s=-1;return;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Seed};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Seed=function(a){return this.$val.Seed(a);};M.ptr.prototype.Int63=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.src.Int63();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Int63};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Int63=function(){return this.$val.Int63();};M.ptr.prototype.Uint32=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Int63();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return(($shiftRightInt64(b,31).$low>>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Uint32};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Uint32=function(){return this.$val.Uint32();};M.ptr.prototype.Uint64=function(){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;if(!($interfaceIsEqual(a.s64,$ifaceNil))){$s=1;continue;}$s=2;continue;case 1:b=a.s64.Uint64();$s=3;case 3:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;case 2:e=a.Int63();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}h=a.Int63();$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return(c=$shiftRightUint64(((d=e,new $Uint64(d.$high,d.$low))),31),f=$shiftLeft64(((g=h,new $Uint64(g.$high,g.$low))),32),new $Uint64(c.$high|f.$high,(c.$low|f.$low)>>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Uint64};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Uint64=function(){return this.$val.Uint64();};M.ptr.prototype.Int31=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;c=a.Int63();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return(((b=$shiftRightInt64(c,32),b.$low+((b.$high>>31)*4294967296))>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Int31};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Int31=function(){return this.$val.Int31();};M.ptr.prototype.Int=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Int63();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=((b.$low>>>0));$s=-1;return((((c<<1>>>0)>>>1>>>0)>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Int};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Int=function(){return this.$val.Int();};M.ptr.prototype.Int63n=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if((a.$high<0||(a.$high===0&&a.$low<=0))){$panic(new $String("invalid argument to Int63n"));}if((c=(d=new $Int64(a.$high-0,a.$low-1),new $Int64(a.$high&d.$high,(a.$low&d.$low)>>>0)),(c.$high===0&&c.$low===0))){$s=1;continue;}$s=2;continue;case 1:f=b.Int63();$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return(e=f,g=new $Int64(a.$high-0,a.$low-1),new $Int64(e.$high&g.$high,(e.$low&g.$low)>>>0));case 2:j=((h=(i=$div64(new $Uint64(2147483648,0),(new $Uint64(a.$high,a.$low)),true),new $Uint64(2147483647-i.$high,4294967295-i.$low)),new $Int64(h.$high,h.$low)));k=b.Int63();$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=k;case 5:if(!((l.$high>j.$high||(l.$high===j.$high&&l.$low>j.$low)))){$s=6;continue;}m=b.Int63();$s=7;case 7:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;$s=5;continue;case 6:$s=-1;return $div64(l,a,true);}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Int63n};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Int63n=function(a){return this.$val.Int63n(a);};M.ptr.prototype.Int31n=function(a){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if(a<=0){$panic(new $String("invalid argument to Int31n"));}if((a&((a-1>>0)))===0){$s=1;continue;}$s=2;continue;case 1:c=b.Int31();$s=3;case 3:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c&((a-1>>0));case 2:e=(((2147483647-(d=2147483648%((a>>>0)),d===d?d:$throwRuntimeError("integer divide by zero"))>>>0)>>0));f=b.Int31();$s=4;case 4:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;case 5:if(!(g>e)){$s=6;continue;}h=b.Int31();$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;$s=5;continue;case 6:$s=-1;return(i=g%a,i===i?i:$throwRuntimeError("integer divide by zero"));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Int31n};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Int31n=function(a){return this.$val.Int31n(a);};M.ptr.prototype.int31n=function(a){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.Uint32();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=$mul64((new $Uint64(0,d)),(new $Uint64(0,a)));f=((e.$low>>>0));if(f<((a>>>0))){$s=2;continue;}$s=3;continue;case 2:h=(g=((-a>>>0))%((a>>>0)),g===g?g:$throwRuntimeError("integer divide by zero"));case 4:if(!(f>>0));$s=4;continue;case 5:case 3:$s=-1;return(($shiftRightUint64(e,32).$low>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.int31n};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.int31n=function(a){return this.$val.int31n(a);};M.ptr.prototype.Intn=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if(a<=0){$panic(new $String("invalid argument to Intn"));}if(a<=2147483647){$s=1;continue;}$s=2;continue;case 1:c=b.Int31n(((a>>0)));$s=3;case 3:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return((c>>0));case 2:e=b.Int63n((new $Int64(0,a)));$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return(((d=e,d.$low+((d.$high>>31)*4294967296))>>0));}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Intn};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Intn=function(a){return this.$val.Intn(a);};M.ptr.prototype.Float64=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;case 1:b=a.Int63();$s=2;case 2:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=($flatten64(b))/9.223372036854776e+18;if(c===1){$s=3;continue;}$s=4;continue;case 3:$s=1;continue;case 4:$s=-1;return c;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Float64};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Float64=function(){return this.$val.Float64();};M.ptr.prototype.Float32=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;case 1:b=a.Float64();$s=2;case 2:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=($fround(b));if(c===1){$s=3;continue;}$s=4;continue;case 3:$s=1;continue;case 4:$s=-1;return c;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Float32};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Float32=function(){return this.$val.Float32();};M.ptr.prototype.Perm=function(a){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=$makeSlice(AP,a);d=0;case 1:if(!(d>0);$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]));((f<0||f>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=d);d=d+(1)>>0;$s=1;continue;case 2:$s=-1;return c;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Perm};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Perm=function(a){return this.$val.Perm(a);};M.ptr.prototype.Shuffle=function(a,b){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(a<0){$panic(new $String("invalid argument to Shuffle"));}d=a-1>>0;case 1:if(!(d>2147483646)){$s=2;continue;}f=c.Int63n((new $Int64(0,(d+1>>0))));$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=(((e=f,e.$low+((e.$high>>31)*4294967296))>>0));$r=b(d,g);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d=d-(1)>>0;$s=1;continue;case 2:case 5:if(!(d>0)){$s=6;continue;}h=c.int31n((((d+1>>0)>>0)));$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=((h>>0));$r=b(d,i);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}d=d-(1)>>0;$s=5;continue;case 6:$s=-1;return;}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Shuffle};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Shuffle=function(a,b){return this.$val.Shuffle(a,b);};M.ptr.prototype.Read=function(a){var a,b,c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=0;c=$ifaceNil;d=this;e=$assertType(d.src,AN,true);f=e[0];g=e[1];if(g){$s=1;continue;}$s=2;continue;case 1:i=f.read(a,(d.$ptr_readVal||(d.$ptr_readVal=new AQ(function(){return this.$target.readVal;},function($v){this.$target.readVal=$v;},d))),(d.$ptr_readPos||(d.$ptr_readPos=new AO(function(){return this.$target.readPos;},function($v){this.$target.readPos=$v;},d))));$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;b=h[0];c=h[1];$s=-1;return[b,c];case 2:k=O(a,$methodVal(d,"Int63"),(d.$ptr_readVal||(d.$ptr_readVal=new AQ(function(){return this.$target.readVal;},function($v){this.$target.readVal=$v;},d))),(d.$ptr_readPos||(d.$ptr_readPos=new AO(function(){return this.$target.readPos;},function($v){this.$target.readPos=$v;},d))));$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;b=j[0];c=j[1];$s=-1;return[b,c];}return;}if($f===undefined){$f={$blk:M.ptr.prototype.Read};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};M.prototype.Read=function(a){return this.$val.Read(a);};O=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=d.$get();h=c.$get();e=0;case 1:if(!(e=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]=((h.$low<<24>>>24)));h=$shiftRightInt64(h,(8));g=g-(1)<<24>>24;e=e+(1)>>0;$s=1;continue;case 2:d.$set(g);c.$set(h);$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:O};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AG.ptr.prototype.Int63=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=new $Int64(0,0);b=this;b.lk.Lock();c=b.src.Int63();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}a=c;b.lk.Unlock();$s=-1;return a;}return;}if($f===undefined){$f={$blk:AG.ptr.prototype.Int63};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AG.prototype.Int63=function(){return this.$val.Int63();};AG.ptr.prototype.Uint64=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=new $Uint64(0,0);b=this;b.lk.Lock();c=b.src.Uint64();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}a=c;b.lk.Unlock();$s=-1;return a;}return;}if($f===undefined){$f={$blk:AG.ptr.prototype.Uint64};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AG.prototype.Uint64=function(){return this.$val.Uint64();};AG.ptr.prototype.Seed=function(a){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;b.lk.Lock();$r=b.src.Seed(a);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}b.lk.Unlock();$s=-1;return;}return;}if($f===undefined){$f={$blk:AG.ptr.prototype.Seed};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};AG.prototype.Seed=function(a){return this.$val.Seed(a);};AG.ptr.prototype.seedPos=function(a,b){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;c.lk.Lock();$r=c.src.Seed(a);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}b.$set(0);c.lk.Unlock();$s=-1;return;}return;}if($f===undefined){$f={$blk:AG.ptr.prototype.seedPos};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AG.prototype.seedPos=function(a,b){return this.$val.seedPos(a,b);};AG.ptr.prototype.read=function(a,b,c){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=$ifaceNil;f=this;f.lk.Lock();h=O(a,$methodVal(f.src,"Int63"),b,c);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;d=g[0];e=g[1];f.lk.Unlock();$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:AG.ptr.prototype.read};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AG.prototype.read=function(a,b,c){return this.$val.read(a,b,c);};AJ=function(a){var a,b,c,d,e;c=(b=a/44488,(b===b&&b!==1/0&&b!==-1/0)?b>>0:$throwRuntimeError("integer divide by zero"));e=(d=a%44488,d===d?d:$throwRuntimeError("integer divide by zero"));a=($imul(48271,e))-($imul(3399,c))>>0;if(a<0){a=a+(2147483647)>>0;}return a;};AI.ptr.prototype.Seed=function(a){var a,b,c,d,e,f,g,h,i,j;b=this;b.tap=0;b.feed=334;a=$div64(a,new $Int64(0,2147483647),true);if((a.$high<0||(a.$high===0&&a.$low<0))){a=(c=new $Int64(0,2147483647),new $Int64(a.$high+c.$high,a.$low+c.$low));}if((a.$high===0&&a.$low===0)){a=new $Int64(0,89482311);}d=(((a.$low+((a.$high>>31)*4294967296))>>0));e=-20;while(true){if(!(e<607)){break;}d=AJ(d);if(e>=0){f=new $Int64(0,0);f=$shiftLeft64((new $Int64(0,d)),40);d=AJ(d);f=(g=$shiftLeft64((new $Int64(0,d)),20),new $Int64(f.$high^g.$high,(f.$low^g.$low)>>>0));d=AJ(d);f=(h=(new $Int64(0,d)),new $Int64(f.$high^h.$high,(f.$low^h.$low)>>>0));f=(i=((e<0||e>=AH.length)?($throwRuntimeError("index out of range"),undefined):AH[e]),new $Int64(f.$high^i.$high,(f.$low^i.$low)>>>0));(j=b.vec,((e<0||e>=j.length)?($throwRuntimeError("index out of range"),undefined):j[e]=f));}e=e+(1)>>0;}};AI.prototype.Seed=function(a){return this.$val.Seed(a);};AI.ptr.prototype.Int63=function(){var a,b,c;a=this;return((b=(c=a.Uint64(),new $Uint64(c.$high&2147483647,(c.$low&4294967295)>>>0)),new $Int64(b.$high,b.$low)));};AI.prototype.Int63=function(){return this.$val.Int63();};AI.ptr.prototype.Uint64=function(){var a,b,c,d,e,f,g,h,i,j;a=this;a.tap=a.tap-(1)>>0;if(a.tap<0){a.tap=a.tap+(607)>>0;}a.feed=a.feed-(1)>>0;if(a.feed<0){a.feed=a.feed+(607)>>0;}h=(b=(c=a.vec,d=a.feed,((d<0||d>=c.length)?($throwRuntimeError("index out of range"),undefined):c[d])),e=(f=a.vec,g=a.tap,((g<0||g>=f.length)?($throwRuntimeError("index out of range"),undefined):f[g])),new $Int64(b.$high+e.$high,b.$low+e.$low));(i=a.vec,j=a.feed,((j<0||j>=i.length)?($throwRuntimeError("index out of range"),undefined):i[j]=h));return(new $Uint64(h.$high,h.$low));};AI.prototype.Uint64=function(){return this.$val.Uint64();};AR.methods=[{prop:"ExpFloat64",name:"ExpFloat64",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"NormFloat64",name:"NormFloat64",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Seed",name:"Seed",pkg:"",typ:$funcType([$Int64],[],false)},{prop:"Int63",name:"Int63",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint32",name:"Uint32",pkg:"",typ:$funcType([],[$Uint32],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"Int31",name:"Int31",pkg:"",typ:$funcType([],[$Int32],false)},{prop:"Int",name:"Int",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Int63n",name:"Int63n",pkg:"",typ:$funcType([$Int64],[$Int64],false)},{prop:"Int31n",name:"Int31n",pkg:"",typ:$funcType([$Int32],[$Int32],false)},{prop:"int31n",name:"int31n",pkg:"math/rand",typ:$funcType([$Int32],[$Int32],false)},{prop:"Intn",name:"Intn",pkg:"",typ:$funcType([$Int],[$Int],false)},{prop:"Float64",name:"Float64",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Float32",name:"Float32",pkg:"",typ:$funcType([],[$Float32],false)},{prop:"Perm",name:"Perm",pkg:"",typ:$funcType([$Int],[AP],false)},{prop:"Shuffle",name:"Shuffle",pkg:"",typ:$funcType([$Int,AT],[],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([AU],[$Int,$error],false)}];AN.methods=[{prop:"Int63",name:"Int63",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"Seed",name:"Seed",pkg:"",typ:$funcType([$Int64],[],false)},{prop:"seedPos",name:"seedPos",pkg:"math/rand",typ:$funcType([$Int64,AO],[],false)},{prop:"read",name:"read",pkg:"math/rand",typ:$funcType([AU,AQ,AO],[$Int,$error],false)}];AV.methods=[{prop:"Seed",name:"Seed",pkg:"",typ:$funcType([$Int64],[],false)},{prop:"Int63",name:"Int63",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)}];J.init([{prop:"Int63",name:"Int63",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Seed",name:"Seed",pkg:"",typ:$funcType([$Int64],[],false)}]);K.init([{prop:"Int63",name:"Int63",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Seed",name:"Seed",pkg:"",typ:$funcType([$Int64],[],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)}]);M.init("math/rand",[{prop:"src",name:"src",embedded:false,exported:false,typ:J,tag:""},{prop:"s64",name:"s64",embedded:false,exported:false,typ:K,tag:""},{prop:"readVal",name:"readVal",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"readPos",name:"readPos",embedded:false,exported:false,typ:$Int8,tag:""}]);AG.init("math/rand",[{prop:"lk",name:"lk",embedded:false,exported:false,typ:B.Mutex,tag:""},{prop:"src",name:"src",embedded:false,exported:false,typ:K,tag:""}]);AI.init("math/rand",[{prop:"tap",name:"tap",embedded:false,exported:false,typ:$Int,tag:""},{prop:"feed",name:"feed",embedded:false,exported:false,typ:$Int,tag:""},{prop:"vec",name:"vec",embedded:false,exported:false,typ:AM,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}C=$toNativeArray($kindUint32,[3801129273,0,2615860924,3279400049,3571300752,3733536696,3836274812,3906990442,3958562475,3997804264,4028649213,4053523342,4074002619,4091154507,4105727352,4118261130,4129155133,4138710916,4147160435,4154685009,4161428406,4167506077,4173011791,4178022498,4182601930,4186803325,4190671498,4194244443,4197554582,4200629752,4203493986,4206168142,4208670408,4211016720,4213221098,4215295924,4217252177,4219099625,4220846988,4222502074,4224071896,4225562770,4226980400,4228329951,4229616109,4230843138,4232014925,4233135020,4234206673,4235232866,4236216336,4237159604,4238064994,4238934652,4239770563,4240574564,4241348362,4242093539,4242811568,4243503822,4244171579,4244816032,4245438297,4246039419,4246620374,4247182079,4247725394,4248251127,4248760037,4249252839,4249730206,4250192773,4250641138,4251075867,4251497493,4251906522,4252303431,4252688672,4253062674,4253425844,4253778565,4254121205,4254454110,4254777611,4255092022,4255397640,4255694750,4255983622,4256264513,4256537670,4256803325,4257061702,4257313014,4257557464,4257795244,4258026541,4258251531,4258470383,4258683258,4258890309,4259091685,4259287526,4259477966,4259663135,4259843154,4260018142,4260188212,4260353470,4260514019,4260669958,4260821380,4260968374,4261111028,4261249421,4261383632,4261513736,4261639802,4261761900,4261880092,4261994441,4262105003,4262211835,4262314988,4262414513,4262510454,4262602857,4262691764,4262777212,4262859239,4262937878,4263013162,4263085118,4263153776,4263219158,4263281289,4263340187,4263395872,4263448358,4263497660,4263543789,4263586755,4263626565,4263663224,4263696735,4263727099,4263754314,4263778377,4263799282,4263817020,4263831582,4263842955,4263851124,4263856071,4263857776,4263856218,4263851370,4263843206,4263831695,4263816804,4263798497,4263776735,4263751476,4263722676,4263690284,4263654251,4263614520,4263571032,4263523724,4263472530,4263417377,4263358192,4263294892,4263227394,4263155608,4263079437,4262998781,4262913534,4262823581,4262728804,4262629075,4262524261,4262414220,4262298801,4262177846,4262051187,4261918645,4261780032,4261635148,4261483780,4261325704,4261160681,4260988457,4260808763,4260621313,4260425802,4260221905,4260009277,4259787550,4259556329,4259315195,4259063697,4258801357,4258527656,4258242044,4257943926,4257632664,4257307571,4256967906,4256612870,4256241598,4255853155,4255446525,4255020608,4254574202,4254106002,4253614578,4253098370,4252555662,4251984571,4251383021,4250748722,4250079132,4249371435,4248622490,4247828790,4246986404,4246090910,4245137315,4244119963,4243032411,4241867296,4240616155,4239269214,4237815118,4236240596,4234530035,4232664930,4230623176,4228378137,4225897409,4223141146,4220059768,4216590757,4212654085,4208145538,4202926710,4196809522,4189531420,4180713890,4169789475,4155865042,4137444620,4111806704,4073393724,4008685917,3873074895]);D=$toNativeArray($kindFloat32,[2.0249555365836613e-09,1.4866739783681027e-11,2.4409616689036184e-11,3.1968806074589295e-11,3.844677007314168e-11,4.42282044321729e-11,4.951644302919611e-11,5.443358958023836e-11,5.905943789574764e-11,6.34494193296753e-11,6.764381416113352e-11,7.167294535648239e-11,7.556032188826833e-11,7.932458162551725e-11,8.298078890689453e-11,8.654132271912474e-11,9.001651507523079e-11,9.341507428706208e-11,9.674443190998971e-11,1.0001099254308699e-10,1.0322031424037093e-10,1.0637725422757427e-10,1.0948611461891744e-10,1.1255067711157807e-10,1.1557434870246297e-10,1.1856014781042035e-10,1.2151082917633005e-10,1.2442885610752796e-10,1.2731647680563896e-10,1.3017574518325858e-10,1.330085347417409e-10,1.3581656632677408e-10,1.386014220061682e-10,1.413645728254309e-10,1.4410737880776736e-10,1.4683107507629245e-10,1.4953686899854546e-10,1.522258291641876e-10,1.5489899640730442e-10,1.575573282952547e-10,1.6020171300645814e-10,1.628330109637588e-10,1.6545202707884954e-10,1.68059510752272e-10,1.7065616975120435e-10,1.73242697965037e-10,1.758197337720091e-10,1.783878739169964e-10,1.8094774290045024e-10,1.834998542005195e-10,1.8604476292871652e-10,1.8858298256319017e-10,1.9111498494872592e-10,1.9364125580789704e-10,1.9616222535212557e-10,1.9867835154840918e-10,2.011900368525943e-10,2.0369768372052732e-10,2.062016807302669e-10,2.0870240258208383e-10,2.1120022397624894e-10,2.136955057352452e-10,2.1618855317040442e-10,2.1867974098199738e-10,2.2116936060356807e-10,2.2365774510202385e-10,2.2614519978869652e-10,2.2863201609713002e-10,2.3111849933865614e-10,2.3360494094681883e-10,2.3609159072179864e-10,2.3857874009713953e-10,2.4106666662859766e-10,2.4355562011635357e-10,2.460458781161634e-10,2.485376904282077e-10,2.5103127909709144e-10,2.5352694943414633e-10,2.560248957284017e-10,2.585253955356137e-10,2.610286709003873e-10,2.6353494386732734e-10,2.6604446423661443e-10,2.6855745405285347e-10,2.71074163116225e-10,2.7359478571575835e-10,2.7611959940720965e-10,2.786487707240326e-10,2.8118254946640775e-10,2.8372118543451563e-10,2.8626484516180994e-10,2.8881380620404684e-10,2.9136826285025563e-10,2.9392840938946563e-10,2.96494523377433e-10,2.990667713476114e-10,3.016454031001814e-10,3.042306406797479e-10,3.068226783753403e-10,3.09421765987139e-10,3.12028125559749e-10,3.1464195138219964e-10,3.17263521010247e-10,3.1989300097734485e-10,3.225306410836737e-10,3.2517669112941405e-10,3.2783134540359526e-10,3.3049485370639786e-10,3.3316743808242677e-10,3.3584937608743815e-10,3.385408342548857e-10,3.4124211789610115e-10,3.4395342130011386e-10,3.4667499426710435e-10,3.494071143528288e-10,3.521500313574677e-10,3.54903967325626e-10,3.576691720574843e-10,3.6044595086437425e-10,3.632345535464765e-10,3.660352021483959e-10,3.688482297370399e-10,3.716738583570134e-10,3.7451239331964814e-10,3.773641121807003e-10,3.802292924959261e-10,3.831082673322328e-10,3.8600128648980103e-10,3.8890865527996255e-10,3.9183070676962473e-10,3.9476774627011935e-10,3.977200790927782e-10,4.006880383045086e-10,4.0367195697221803e-10,4.066721681628138e-10,4.0968900494320337e-10,4.127228558914453e-10,4.15774054074447e-10,4.188429603146915e-10,4.2192993543466173e-10,4.25035395767992e-10,4.2815970213716525e-10,4.313032986313914e-10,4.3446651831757777e-10,4.376498607960855e-10,4.408536868893975e-10,4.4407846844229937e-10,4.4732464954400086e-10,4.5059267428371186e-10,4.538830145062178e-10,4.5719619756745544e-10,4.605326675566346e-10,4.638929240741163e-10,4.672775499869886e-10,4.706869893844612e-10,4.74121908400349e-10,4.775827511238617e-10,4.810701836888143e-10,4.845848167178701e-10,4.881271498113904e-10,4.916979601254923e-10,4.952977472605369e-10,4.989272883726414e-10,5.025872495956207e-10,5.062783525744408e-10,5.100013189540675e-10,5.13756870379467e-10,5.175458395179078e-10,5.21369003525507e-10,5.252272505806843e-10,5.29121357839557e-10,5.330522134805449e-10,5.3702081670437e-10,5.41028055689452e-10,5.450749851476644e-10,5.491624932574268e-10,5.532918012640664e-10,5.574638528571541e-10,5.616799247931681e-10,5.659410717839819e-10,5.702485705860738e-10,5.746036979559221e-10,5.790077306500052e-10,5.83462111958255e-10,5.879682296594524e-10,5.925275825546805e-10,5.971417249561739e-10,6.01812211176167e-10,6.065408175714992e-10,6.113292094767075e-10,6.16179329782085e-10,6.21092954844471e-10,6.260721940876124e-10,6.311191569352559e-10,6.362359528111483e-10,6.414249686947926e-10,6.466885360545405e-10,6.520292639144998e-10,6.574497612987784e-10,6.629528592760892e-10,6.685415554485985e-10,6.742187919073217e-10,6.799880103436351e-10,6.858525969377638e-10,6.918161599145378e-10,6.978825850545434e-10,7.040559801829716e-10,7.103406751696184e-10,7.167412219288849e-10,7.232625609532306e-10,7.2990985477972e-10,7.366885990123251e-10,7.436047333442275e-10,7.506645305355164e-10,7.57874762946642e-10,7.652426470272644e-10,7.727759543385559e-10,7.804830115532013e-10,7.883728114777e-10,7.964550685635174e-10,8.047402189070851e-10,8.132396422944055e-10,8.219657177122031e-10,8.309318788590758e-10,8.401527806789488e-10,8.496445214056791e-10,8.594246980742071e-10,8.695127395874636e-10,8.799300732498239e-10,8.90700457834015e-10,9.01850316648023e-10,9.134091816243028e-10,9.254100818978372e-10,9.37890431984556e-10,9.508922538259412e-10,9.64463842123564e-10,9.78660263939446e-10,9.935448019859905e-10,1.0091912860943353e-09,1.0256859805934937e-09,1.0431305819125214e-09,1.0616465484503124e-09,1.0813799855569073e-09,1.1025096391392708e-09,1.1252564435793033e-09,1.149898620766976e-09,1.176793218427008e-09,1.2064089727203964e-09,1.2393785997488749e-09,1.2765849488616254e-09,1.319313880365769e-09,1.36954347862428e-09,1.4305497897382224e-09,1.5083649884672923e-09,1.6160853766322703e-09,1.7921247819074893e-09]);E=$toNativeArray($kindFloat32,[1,0.9381436705589294,0.900469958782196,0.8717043399810791,0.847785472869873,0.8269932866096497,0.8084216713905334,0.7915276288986206,0.7759568691253662,0.7614634037017822,0.7478685975074768,0.7350381016731262,0.7228676676750183,0.7112747430801392,0.7001926302909851,0.6895664930343628,0.6793505549430847,0.669506311416626,0.6600008606910706,0.6508058309555054,0.6418967247009277,0.633251965045929,0.62485271692276,0.6166821718215942,0.608725368976593,0.6009689569473267,0.5934008955955505,0.5860103368759155,0.5787873864173889,0.5717230439186096,0.5648092031478882,0.5580382943153381,0.5514034032821655,0.5448982119560242,0.5385168790817261,0.5322538614273071,0.526104211807251,0.5200631618499756,0.5141264200210571,0.5082897543907166,0.5025495290756226,0.4969019889831543,0.4913438558578491,0.4858720004558563,0.48048335313796997,0.4751752018928528,0.4699448347091675,0.4647897481918335,0.4597076177597046,0.4546961486339569,0.4497532546520233,0.44487687945365906,0.4400651156902313,0.4353161156177521,0.4306281507015228,0.42599955201148987,0.42142874002456665,0.4169141948223114,0.4124544560909271,0.40804818272590637,0.4036940038204193,0.39939069747924805,0.3951369822025299,0.39093172550201416,0.38677382469177246,0.38266217708587646,0.378595769405365,0.37457355856895447,0.37059465050697327,0.366658091545105,0.362762987613678,0.358908474445343,0.35509374737739563,0.35131800174713135,0.3475804924964905,0.34388044476509094,0.34021714329719543,0.33658990263938904,0.3329980671405792,0.3294409513473511,0.32591795921325684,0.32242849469184875,0.3189719021320343,0.3155476748943329,0.31215524673461914,0.3087940812110901,0.30546361207962036,0.30216339230537415,0.29889291524887085,0.29565170407295227,0.2924392819404602,0.2892552316188812,0.28609907627105713,0.2829704284667969,0.27986884117126465,0.2767939269542694,0.2737452983856201,0.2707225978374481,0.26772540807724,0.26475343108177185,0.2618062496185303,0.258883535861969,0.2559850215911865,0.25311028957366943,0.25025907158851624,0.24743106961250305,0.2446259707212448,0.24184346199035645,0.23908329010009766,0.23634515702724457,0.2336287796497345,0.23093391954898834,0.22826029360294342,0.22560766339302063,0.22297576069831848,0.22036437690258026,0.21777324378490448,0.21520215272903442,0.212650865316391,0.21011915802955627,0.20760682225227356,0.20511364936828613,0.20263944566249847,0.20018397271633148,0.19774706661701202,0.1953285187482834,0.19292815029621124,0.19054576754570007,0.18818120658397675,0.18583425879478455,0.18350479006767273,0.18119260668754578,0.17889754474163055,0.17661945521831512,0.17435817420482635,0.1721135377883911,0.16988539695739746,0.16767361760139465,0.16547803580760956,0.16329853236675262,0.16113494336605072,0.1589871346950531,0.15685498714447021,0.15473836660385132,0.15263713896274567,0.1505511850118637,0.1484803706407547,0.14642459154129028,0.1443837285041809,0.14235764741897583,0.1403462439775467,0.13834942877292633,0.136367067694664,0.13439907133579254,0.1324453204870224,0.1305057406425476,0.12858019769191742,0.12666863203048706,0.12477091699838638,0.12288697808980942,0.1210167184472084,0.11916005611419678,0.11731690168380737,0.11548716574907303,0.11367076635360718,0.11186762899160385,0.11007767915725708,0.1083008274435997,0.10653700679540634,0.10478614270687103,0.1030481606721878,0.10132300108671188,0.0996105819940567,0.09791085124015808,0.09622374176979065,0.09454918652772903,0.09288713335990906,0.09123751521110535,0.08960027992725372,0.08797537535429001,0.08636274188756943,0.0847623273730278,0.08317409455776215,0.08159798383712769,0.08003395050764084,0.07848194986581802,0.07694194465875626,0.07541389018297195,0.07389774918556213,0.07239348441362381,0.070901058614254,0.06942043453454971,0.06795158982276917,0.06649449467658997,0.06504911929368973,0.06361543387174606,0.06219341605901718,0.06078304722905159,0.0593843050301075,0.05799717456102371,0.05662164092063904,0.05525768920779228,0.05390531197190285,0.05256449431180954,0.05123523622751236,0.04991753399372101,0.04861138388514519,0.047316793352365494,0.04603376239538193,0.044762298464775085,0.04350241273641586,0.04225412383675575,0.04101744294166565,0.039792392402887344,0.03857899457216263,0.03737728297710419,0.03618728369474411,0.03500903770327568,0.03384258225560188,0.0326879620552063,0.031545232981443405,0.030414443463087082,0.0292956605553627,0.028188949450850487,0.027094384655356407,0.02601204626262188,0.024942025542259216,0.023884421214461327,0.022839335724711418,0.021806888282299042,0.020787203684449196,0.019780423492193222,0.018786700442433357,0.017806200310587883,0.016839107498526573,0.015885621309280396,0.014945968054234982,0.01402039173990488,0.013109165243804455,0.012212592177093029,0.011331013403832912,0.010464809834957123,0.009614413604140282,0.008780314587056637,0.007963077165186405,0.007163353264331818,0.0063819061033427715,0.005619642324745655,0.004877655766904354,0.004157294984906912,0.003460264764726162,0.0027887988835573196,0.0021459676790982485,0.001536299823783338,0.0009672692976891994,0.0004541343660093844]);G=$toNativeArray($kindUint32,[1991057938,0,1611602771,1826899878,1918584482,1969227037,2001281515,2023368125,2039498179,2051788381,2061460127,2069267110,2075699398,2081089314,2085670119,2089610331,2093034710,2096037586,2098691595,2101053571,2103168620,2105072996,2106796166,2108362327,2109791536,2111100552,2112303493,2113412330,2114437283,2115387130,2116269447,2117090813,2117856962,2118572919,2119243101,2119871411,2120461303,2121015852,2121537798,2122029592,2122493434,2122931299,2123344971,2123736059,2124106020,2124456175,2124787725,2125101763,2125399283,2125681194,2125948325,2126201433,2126441213,2126668298,2126883268,2127086657,2127278949,2127460589,2127631985,2127793506,2127945490,2128088244,2128222044,2128347141,2128463758,2128572095,2128672327,2128764606,2128849065,2128925811,2128994934,2129056501,2129110560,2129157136,2129196237,2129227847,2129251929,2129268426,2129277255,2129278312,2129271467,2129256561,2129233410,2129201800,2129161480,2129112170,2129053545,2128985244,2128906855,2128817916,2128717911,2128606255,2128482298,2128345305,2128194452,2128028813,2127847342,2127648860,2127432031,2127195339,2126937058,2126655214,2126347546,2126011445,2125643893,2125241376,2124799783,2124314271,2123779094,2123187386,2122530867,2121799464,2120980787,2120059418,2119015917,2117825402,2116455471,2114863093,2112989789,2110753906,2108037662,2104664315,2100355223,2094642347,2086670106,2074676188,2054300022,2010539237]);H=$toNativeArray($kindFloat32,[1.7290404663583558e-09,1.2680928529462676e-10,1.689751810696194e-10,1.9862687883343e-10,2.223243117382978e-10,2.4244936613904144e-10,2.601613091623989e-10,2.761198769629658e-10,2.9073962681813725e-10,3.042996965518796e-10,3.169979556627567e-10,3.289802041894774e-10,3.4035738116777736e-10,3.5121602848242617e-10,3.61625090983253e-10,3.7164057942185025e-10,3.813085680537398e-10,3.906675816178762e-10,3.997501218933053e-10,4.0858399996679395e-10,4.1719308563337165e-10,4.255982233303257e-10,4.3381759295968436e-10,4.4186720948857783e-10,4.497613115272969e-10,4.57512583373898e-10,4.6513240481438345e-10,4.726310454117311e-10,4.800177477726209e-10,4.873009773476156e-10,4.944885056978876e-10,5.015873272284921e-10,5.086040477664255e-10,5.155446070048697e-10,5.224146670812502e-10,5.292193350214802e-10,5.359634958068682e-10,5.426517013518151e-10,5.492881705038144e-10,5.558769555769061e-10,5.624218868405251e-10,5.689264614971989e-10,5.75394121238304e-10,5.818281967329142e-10,5.882316855831959e-10,5.946076964136182e-10,6.009590047817426e-10,6.072883862451306e-10,6.135985053390414e-10,6.19892026598734e-10,6.261713370037114e-10,6.324390455780815e-10,6.386973727678935e-10,6.449488165749528e-10,6.511955974453087e-10,6.574400468473129e-10,6.636843297158634e-10,6.699307220081607e-10,6.761814441702541e-10,6.824387166481927e-10,6.887046488657234e-10,6.949815167800466e-10,7.012714853260604e-10,7.075767749498141e-10,7.13899661608508e-10,7.202424212593428e-10,7.266072743483676e-10,7.329966078550854e-10,7.394128087589991e-10,7.458582640396116e-10,7.523354716987285e-10,7.588469852493063e-10,7.653954137154528e-10,7.719834771435785e-10,7.786139510912449e-10,7.852897221383159e-10,7.920137878869582e-10,7.987892014504894e-10,8.056192379868321e-10,8.125072836762115e-10,8.194568912323064e-10,8.264716688799467e-10,8.3355555791087e-10,8.407127216614185e-10,8.479473234679347e-10,8.552640262671218e-10,8.626675485068347e-10,8.701631637464402e-10,8.777562010564566e-10,8.854524335966119e-10,8.932581896381464e-10,9.011799639857543e-10,9.092249730890956e-10,9.174008219758889e-10,9.25715837318819e-10,9.341788453909317e-10,9.42799727177146e-10,9.515889187738935e-10,9.605578554783278e-10,9.697193048552322e-10,9.790869226478094e-10,9.886760299337993e-10,9.985036131254788e-10,1.008588212947359e-09,1.0189509236369076e-09,1.0296150598776421e-09,1.040606933955246e-09,1.0519566329136865e-09,1.0636980185552147e-09,1.0758701707302976e-09,1.0885182755160372e-09,1.101694735439196e-09,1.115461056855338e-09,1.1298901814171813e-09,1.1450695946990663e-09,1.1611052119775422e-09,1.178127595480305e-09,1.1962995039027646e-09,1.2158286599728285e-09,1.2369856250415978e-09,1.2601323318151003e-09,1.2857697129220469e-09,1.3146201904845611e-09,1.3477839955200466e-09,1.3870635751089821e-09,1.43574030442295e-09,1.5008658760251592e-09,1.6030947680434338e-09]);I=$toNativeArray($kindFloat32,[1,0.963599681854248,0.9362826943397522,0.9130436182022095,0.8922816514968872,0.8732430338859558,0.8555005788803101,0.8387836217880249,0.8229072093963623,0.8077383041381836,0.7931770086288452,0.7791460752487183,0.7655841708183289,0.7524415850639343,0.7396772503852844,0.7272568941116333,0.7151514887809753,0.7033361196517944,0.6917891502380371,0.6804918646812439,0.6694276928901672,0.6585819721221924,0.6479418277740479,0.6374954581260681,0.6272324919700623,0.6171433925628662,0.6072195172309875,0.5974531769752502,0.5878370404243469,0.5783646702766418,0.5690299868583679,0.5598273873329163,0.550751805305481,0.5417983531951904,0.5329626798629761,0.5242405533790588,0.5156282186508179,0.5071220397949219,0.49871864914894104,0.4904148280620575,0.48220765590667725,0.47409430146217346,0.466072142124176,0.45813870429992676,0.45029163360595703,0.44252872467041016,0.4348478317260742,0.42724698781967163,0.41972434520721436,0.41227802634239197,0.40490642189979553,0.39760786294937134,0.3903807997703552,0.3832238018512726,0.3761354684829712,0.3691144585609436,0.36215949058532715,0.3552693724632263,0.3484429717063904,0.3416791558265686,0.33497685194015503,0.32833510637283325,0.3217529058456421,0.3152293860912323,0.30876362323760986,0.3023548424243927,0.2960021495819092,0.2897048592567444,0.28346219658851624,0.2772735059261322,0.271138072013855,0.2650552988052368,0.25902456045150757,0.25304529070854187,0.24711695313453674,0.24123899638652802,0.23541094362735748,0.22963231801986694,0.22390270233154297,0.21822164952754974,0.21258877217769623,0.20700371265411377,0.20146611332893372,0.1959756463766098,0.19053204357624054,0.18513499200344086,0.17978426814079285,0.1744796335697174,0.16922089457511902,0.16400785744190216,0.1588403731584549,0.15371830761432648,0.14864157140254974,0.14361007511615753,0.13862377405166626,0.13368265330791473,0.12878671288490295,0.12393598258495331,0.11913054436445236,0.11437050998210907,0.10965602099895477,0.1049872562289238,0.10036443918943405,0.09578784555196762,0.09125780314207077,0.08677466958761215,0.08233889937400818,0.07795098423957825,0.07361150532960892,0.06932111829519272,0.06508058309555054,0.06089077144861221,0.05675266310572624,0.05266740173101425,0.048636294901371,0.044660862535238266,0.040742866694927216,0.03688438981771469,0.03308788686990738,0.029356317594647408,0.025693291798233986,0.02210330404341221,0.018592102453112602,0.015167297795414925,0.011839478276669979,0.0086244847625494,0.005548994988203049,0.0026696291752159595]);AH=$toNativeArray($kindInt64,[new $Int64(-973649357,3952672746),new $Int64(-1065661887,3130416987),new $Int64(324977939,3414273807),new $Int64(1241840476,2806224363),new $Int64(-1477934308,1997590414),new $Int64(2103305448,2402795971),new $Int64(1663160183,1140819369),new $Int64(1120601685,1788868961),new $Int64(1848035537,1089001426),new $Int64(1235702047,873593504),new $Int64(1911387977,581324885),new $Int64(-1654874170,1609182556),new $Int64(1069394745,1241596776),new $Int64(1895445337,1771189259),new $Int64(-1374618802,3467012610),new $Int64(-140526423,2344407434),new $Int64(-1745367887,782467244),new $Int64(26335124,3404933915),new $Int64(1063924276,618867887),new $Int64(-968700782,520164395),new $Int64(-1591572833,1341358184),new $Int64(-1515085039,665794848),new $Int64(1527227641,3183648150),new $Int64(1781176124,696329606),new $Int64(1789146075,4151988961),new $Int64(-2087444114,998951326),new $Int64(-612324923,1364957564),new $Int64(63173359,4090230633),new $Int64(-1498029007,4009697548),new $Int64(248009524,2569622517),new $Int64(778703922,3742421481),new $Int64(-1109106023,1506914633),new $Int64(1738099768,1983412561),new $Int64(236311649,1436266083),new $Int64(-1111517500,3922894967),new $Int64(-1336974714,1792680179),new $Int64(563141142,1188796351),new $Int64(1349617468,405968250),new $Int64(1044074554,433754187),new $Int64(870549669,4073162024),new $Int64(-1094251604,433121399),new $Int64(2451824,4162580594),new $Int64(-137262572,4132415622),new $Int64(-1536231048,3033822028),new $Int64(2016407895,824682382),new $Int64(2366218,3583765414),new $Int64(-624604839,535386927),new $Int64(1637219058,2286693689),new $Int64(1453075389,2968466525),new $Int64(193683513,1351410206),new $Int64(-283806096,1412813499),new $Int64(492736522,4126267639),new $Int64(512765208,2105529399),new $Int64(2132966268,2413882233),new $Int64(947457634,32226200),new $Int64(1149341356,2032329073),new $Int64(106485445,1356518208),new $Int64(-2067810156,3430061722),new $Int64(-1484435135,3820169661),new $Int64(-1665985194,2981816134),new $Int64(1017155588,4184371017),new $Int64(206574701,2119206761),new $Int64(-852109057,2472200560),new $Int64(-560457548,2853524696),new $Int64(1307803389,1681119904),new $Int64(-174986835,95608918),new $Int64(392686347,3690479145),new $Int64(-1205570926,1397922290),new $Int64(-1159314025,1516129515),new $Int64(-320178155,1547420459),new $Int64(1311333971,1470949486),new $Int64(-1953469798,1336785672),new $Int64(-45086614,4131677129),new $Int64(-1392278100,4246329084),new $Int64(-1142500187,3788585631),new $Int64(-66478285,3080389532),new $Int64(-646438364,2215402037),new $Int64(391002300,1171593935),new $Int64(1408774047,1423855166),new $Int64(-519177718,2276716302),new $Int64(-368453140,2068027241),new $Int64(1369359303,3427553297),new $Int64(189241615,3289637845),new $Int64(1057480830,3486407650),new $Int64(-1512910664,3071877822),new $Int64(1159653919,3363620705),new $Int64(-934256930,4159821533),new $Int64(-76621938,1894661),new $Int64(-674493898,1156868282),new $Int64(348271067,776219088),new $Int64(-501428838,2425634259),new $Int64(1716021749,680510161),new $Int64(-574263456,1310101429),new $Int64(1095885995,2964454134),new $Int64(-325695512,3467098407),new $Int64(1990672920,2109628894),new $Int64(-2139648704,1232604732),new $Int64(-1838070714,3261916179),new $Int64(1699175360,434597899),new $Int64(235436061,1624796439),new $Int64(-1626402839,3589632480),new $Int64(1198416575,864579159),new $Int64(-1938748161,1380889830),new $Int64(619206309,2654509477),new $Int64(1419738251,1468209306),new $Int64(-1744284772,100794388),new $Int64(-1191421458,2991674471),new $Int64(-208666741,2224662036),new $Int64(-173659161,977097250),new $Int64(1351320195,726419512),new $Int64(-183459897,1747974366),new $Int64(-753095183,1556430604),new $Int64(-1049492215,1080776742),new $Int64(-385846958,280794874),new $Int64(117767733,919835643),new $Int64(-967009426,3434019658),new $Int64(-1951414480,2461941785),new $Int64(133215641,3615001066),new $Int64(417204809,3103414427),new $Int64(790056561,3380809712),new $Int64(-1267681408,2724693469),new $Int64(547796833,598827710),new $Int64(-1846559452,3452273442),new $Int64(-75778224,649274915),new $Int64(-801301329,2585724112),new $Int64(-1510934263,3165579553),new $Int64(1185578221,2635894283),new $Int64(-52910178,2053289721),new $Int64(985976581,3169337108),new $Int64(1170569632,144717764),new $Int64(1079216270,1383666384),new $Int64(-124804942,681540375),new $Int64(1375448925,537050586),new $Int64(-1964768344,315246468),new $Int64(226402871,849323088),new $Int64(-885062465,45543944),new $Int64(-946445250,2319052083),new $Int64(-40708194,3613090841),new $Int64(560472520,2992171180),new $Int64(-381863169,2068244785),new $Int64(917538188,4239862634),new $Int64(-1369555809,3892253031),new $Int64(720683925,958186149),new $Int64(-423297785,1877702262),new $Int64(1357886971,837674867),new $Int64(1837048883,1507589294),new $Int64(1905518400,873336795),new $Int64(-1879761037,2764496274),new $Int64(-1806480530,4196182374),new $Int64(-1066765755,550964545),new $Int64(818747069,420611474),new $Int64(-1924830376,204265180),new $Int64(1549974541,1787046383),new $Int64(1215581865,3102292318),new $Int64(418321538,1552199393),new $Int64(1243493047,980542004),new $Int64(267284263,3293718720),new $Int64(1179528763,3771917473),new $Int64(599484404,2195808264),new $Int64(252818753,3894702887),new $Int64(-1367475956,2099949527),new $Int64(1424094358,338442522),new $Int64(490737398,637158004),new $Int64(-1727621530,281976339),new $Int64(574970164,3619802330),new $Int64(-431930823,3084554784),new $Int64(-1264611183,4129772886),new $Int64(-2104399043,1680378557),new $Int64(-1621962591,3339087776),new $Int64(1680500332,4220317857),new $Int64(-1935828963,2959322499),new $Int64(1675600481,1488354890),new $Int64(-834863562,3958162143),new $Int64(-1226511573,2773705983),new $Int64(1876039582,225908689),new $Int64(-1183735113,908216283),new $Int64(-605696219,3574646075),new $Int64(-1827723091,1936937569),new $Int64(1519770881,75492235),new $Int64(816689472,1935193178),new $Int64(2142521206,2018250883),new $Int64(455141620,3943126022),new $Int64(-601399488,3066544345),new $Int64(1932392669,2793082663),new $Int64(-1239009361,3297036421),new $Int64(1640597065,2206987825),new $Int64(-553246738,807894872),new $Int64(-1781325307,766252117),new $Int64(2060649606,3833114345),new $Int64(845619743,1255067973),new $Int64(1201145605,741697208),new $Int64(-1476242608,2810093753),new $Int64(1109032642,4229340371),new $Int64(1462188720,1361684224),new $Int64(-1159399429,1906263026),new $Int64(475781207,3904421704),new $Int64(-623537128,1769075545),new $Int64(1062308525,2621599764),new $Int64(1279509432,3431891480),new $Int64(-1742751146,1871896503),new $Int64(128756421,1412808876),new $Int64(1605404688,952876175),new $Int64(-230443691,1824438899),new $Int64(1662295856,1005035476),new $Int64(-156574141,527508597),new $Int64(1288873303,3066806859),new $Int64(565995893,3244940914),new $Int64(-889746188,209092916),new $Int64(-247669406,1242699167),new $Int64(-713830396,456723774),new $Int64(1776978905,1001252870),new $Int64(1468772157,2026725874),new $Int64(857254202,2137562569),new $Int64(765939740,3183366709),new $Int64(1533887628,2612072960),new $Int64(56977098,1727148468),new $Int64(-1197583895,3803658212),new $Int64(1883670356,479946959),new $Int64(685713571,1562982345),new $Int64(-1946242443,1766109365),new $Int64(700596547,3257093788),new $Int64(-184714929,2365720207),new $Int64(93384808,3742754173),new $Int64(-458385235,2878193673),new $Int64(1096135042,2174002182),new $Int64(-834260953,3573511231),new $Int64(-754572527,1760299077),new $Int64(-1375627191,2260779833),new $Int64(-866019274,1452805722),new $Int64(-1229671918,2940011802),new $Int64(1890251082,1886183802),new $Int64(893897673,2514369088),new $Int64(1644345561,3924317791),new $Int64(-1974867432,500935732),new $Int64(1403501753,676580929),new $Int64(-1565912283,1184984890),new $Int64(-691968413,1271474274),new $Int64(-1828754738,3163791473),new $Int64(2051027584,2842487377),new $Int64(1511537551,2170968612),new $Int64(573262976,3535856740),new $Int64(-2053227187,1488599718),new $Int64(-1180531831,3408913763),new $Int64(-2086531912,2501050084),new $Int64(-875130448,1639124157),new $Int64(-2009482504,4088176393),new $Int64(1574896563,3989947576),new $Int64(-165243708,3414355209),new $Int64(-792329287,2275136352),new $Int64(-2057774345,2151835223),new $Int64(-931144933,1654534827),new $Int64(-679921451,377892833),new $Int64(-482716010,660204544),new $Int64(85706799,390828249),new $Int64(-1422172693,3402783878),new $Int64(-1468634160,3717936603),new $Int64(1113532086,2211058823),new $Int64(1564224320,2692150867),new $Int64(1952770442,1928910388),new $Int64(788716862,3931011137),new $Int64(1083670504,1112701047),new $Int64(-68150572,2452299106),new $Int64(-896164822,2337204777),new $Int64(1774877857,273889282),new $Int64(1798719843,1462008793),new $Int64(2138834788,1554494002),new $Int64(-1194967131,182675323),new $Int64(-1598554764,1882802136),new $Int64(589279648,3700220025),new $Int64(381039426,3083431543),new $Int64(-851859191,3622207527),new $Int64(338126939,432729309),new $Int64(-1667470126,2391914317),new $Int64(-1849558151,235747924),new $Int64(2120733629,3088823825),new $Int64(-745079795,2314658321),new $Int64(1165929723,2957634338),new $Int64(501323675,4117056981),new $Int64(1564699815,1482500298),new $Int64(-740826490,840489337),new $Int64(799522364,3483178565),new $Int64(532129761,2074004656),new $Int64(724246478,3643392642),new $Int64(-665153481,1583624461),new $Int64(-885822954,287473085),new $Int64(1667835381,3136843981),new $Int64(1138806821,1266970974),new $Int64(135185781,1998688839),new $Int64(392094735,1492900209),new $Int64(1031326774,1538112737),new $Int64(-2070568842,2207265429),new $Int64(-1886797613,963263315),new $Int64(1671145500,2295892134),new $Int64(1068469660,2002560897),new $Int64(-356250305,1369254035),new $Int64(33436120,3353312708),new $Int64(57507843,947771099),new $Int64(-1945755145,1747061399),new $Int64(1507240140,2047354631),new $Int64(720000810,4165367136),new $Int64(479265078,3388864963),new $Int64(-952181250,286492130),new $Int64(2045622690,2795735007),new $Int64(-715730566,3703961339),new $Int64(-148436487,1797825479),new $Int64(1429039600,1116589674),new $Int64(-1665420098,2593309206),new $Int64(1329049334,3404995677),new $Int64(-750579440,3453462936),new $Int64(1014767077,3016498634),new $Int64(75698599,1650371545),new $Int64(1592007860,212344364),new $Int64(1127766888,3843932156),new $Int64(-748019856,3573129983),new $Int64(-890581831,665897820),new $Int64(1071492673,1675628772),new $Int64(243225682,2831752928),new $Int64(2120298836,1486294219),new $Int64(-1954407413,268782709),new $Int64(-1002123503,4186179080),new $Int64(624342951,1613720397),new $Int64(857179861,2703686015),new $Int64(-911618704,2205342611),new $Int64(-672703993,1411666394),new $Int64(-1528454899,677744900),new $Int64(-1876628533,4172867247),new $Int64(135494707,2163418403),new $Int64(849547544,2841526879),new $Int64(-1117516959,1082141470),new $Int64(-1770111792,4046134367),new $Int64(51415528,2142943655),new $Int64(-249824333,3124627521),new $Int64(998228909,219992939),new $Int64(-1078790951,1756846531),new $Int64(1283749206,1225118210),new $Int64(-525858006,1647770243),new $Int64(-2035959705,444807907),new $Int64(2036369448,3952076173),new $Int64(53201823,1461839639),new $Int64(315761893,3699250910),new $Int64(702974850,1373688981),new $Int64(734022261,147523747),new $Int64(-2047330906,1211276581),new $Int64(1294440951,2548832680),new $Int64(1144696256,1995631888),new $Int64(-1992983070,2011457303),new $Int64(-1351022674,3057425772),new $Int64(667839456,81484597),new $Int64(-1681980888,3646681560),new $Int64(-1372462725,635548515),new $Int64(602489502,2508044581),new $Int64(-1794220117,1014917157),new $Int64(719992433,3214891315),new $Int64(-1294799037,959582252),new $Int64(226415134,3347040449),new $Int64(-362868096,4102971975),new $Int64(397887437,4078022210),new $Int64(-536803826,2851767182),new $Int64(-1398321012,1540160644),new $Int64(-1549098876,1057290595),new $Int64(-112592988,3907769253),new $Int64(579300318,4248952684),new $Int64(-1054576049,132554364),new $Int64(-1085862414,1029351092),new $Int64(697840928,2583007416),new $Int64(298619124,1486185789),new $Int64(55905697,2871589073),new $Int64(2017643612,723203291),new $Int64(146250550,2494333952),new $Int64(-1082993397,2230939180),new $Int64(-1804568072,3943232912),new $Int64(1768732449,2181367922),new $Int64(-729261111,2889274791),new $Int64(1824032949,2046728161),new $Int64(1653899792,1376052477),new $Int64(1022327048,381236993),new $Int64(-1113097690,3188942166),new $Int64(-74480109,350070824),new $Int64(144881592,61758415),new $Int64(-741824226,3492950336),new $Int64(-2030042720,3093818430),new $Int64(-453590535,2962480613),new $Int64(-1912050708,3154871160),new $Int64(-1636478569,3228564679),new $Int64(610731502,888276216),new $Int64(-946702974,3574998604),new $Int64(-1277068380,1967526716),new $Int64(-1556147941,1554691298),new $Int64(-1573024234,339944798),new $Int64(1223764147,1154515356),new $Int64(1825645307,967516237),new $Int64(1546195135,596588202),new $Int64(-1867600880,3764362170),new $Int64(-1655392592,266611402),new $Int64(-393255880,2047856075),new $Int64(-1000726433,21444105),new $Int64(-949424754,3065563181),new $Int64(-232418803,1140663212),new $Int64(633187674,2323741028),new $Int64(2126290159,3103873707),new $Int64(1008658319,2766828349),new $Int64(-485587503,1970872996),new $Int64(1628585413,3766615585),new $Int64(-595148528,2036813414),new $Int64(-1994877121,3105536507),new $Int64(13954645,3396176938),new $Int64(-721402003,1377154485),new $Int64(-61839181,3807014186),new $Int64(543009040,3710110597),new $Int64(-1751425519,916420443),new $Int64(734556788,2103831255),new $Int64(-1766161494,717331943),new $Int64(-1574598896,3550505941),new $Int64(45939673,378749927),new $Int64(-1997615719,611017331),new $Int64(592130075,758907650),new $Int64(1012992349,154266815),new $Int64(-1040454942,1407468696),new $Int64(-1678191250,970098704),new $Int64(-285057486,1971660656),new $Int64(998365243,3332747885),new $Int64(1947089649,1935189867),new $Int64(1510248801,203520055),new $Int64(-1305165746,3916463034),new $Int64(-388598655,3474113316),new $Int64(1036101639,316544223),new $Int64(-1773744891,1650844677),new $Int64(-907191419,4267565603),new $Int64(-1070275024,2501167616),new $Int64(-1520651863,3929401789),new $Int64(-2091360852,337170252),new $Int64(-960502090,2061966842),new $Int64(-304190848,2508461464),new $Int64(-1941471116,2791377107),new $Int64(1240791848,1227227588),new $Int64(1813978778,1709681848),new $Int64(1153692192,3768820575),new $Int64(-1002297449,2887126398),new $Int64(-1447111334,296561685),new $Int64(700300844,3729960077),new $Int64(-1572311344,372833036),new $Int64(2078875613,2409779288),new $Int64(1829161290,555274064),new $Int64(-1105595719,4239804901),new $Int64(1839403216,3723486978),new $Int64(-1649093095,2145871984),new $Int64(-1582765715,3565480803),new $Int64(-1568653827,2197313814),new $Int64(974785092,3613674566),new $Int64(438638731,3042093666),new $Int64(-96556264,3324034321),new $Int64(869420878,3708873369),new $Int64(946682149,1698090092),new $Int64(1618900382,4213940712),new $Int64(-1843479747,2087477361),new $Int64(-1766167800,2407950639),new $Int64(-1296225558,3942568569),new $Int64(-1223900450,4088074412),new $Int64(723260036,2964773675),new $Int64(-673921829,1539178386),new $Int64(1062961552,2694849566),new $Int64(460977733,2120273838),new $Int64(-1604570740,2484608657),new $Int64(880846449,2956190677),new $Int64(1970902366,4223313749),new $Int64(662161910,3502682327),new $Int64(705634754,4133891139),new $Int64(-1031359300,1166449596),new $Int64(1038247601,3362705993),new $Int64(93734798,3892921029),new $Int64(1876124043,786869787),new $Int64(1057490746,1046342263),new $Int64(242763728,493777327),new $Int64(-853573201,3304827646),new $Int64(616460742,125356352),new $Int64(499300063,74094113),new $Int64(-795586925,2500816079),new $Int64(-490248444,514015239),new $Int64(1377565129,543520454),new $Int64(-2039776725,3614531153),new $Int64(2056746300,2356753985),new $Int64(1390062617,2018141668),new $Int64(131272971,2087974891),new $Int64(-1502927041,3166972343),new $Int64(372256200,1517638666),new $Int64(-935275664,173466846),new $Int64(-695774461,4241513471),new $Int64(-1413550842,2783126920),new $Int64(1972004134,4167264826),new $Int64(29260506,3907395640),new $Int64(-910901561,1539634186),new $Int64(-595957298,178241987),new $Int64(-113277636,182168164),new $Int64(-1102530459,2386154934),new $Int64(1379126408,4077374341),new $Int64(-2114679722,1732699140),new $Int64(-421057745,1041306002),new $Int64(1860414813,2068001749),new $Int64(1005320202,3208962910),new $Int64(844054010,697710380),new $Int64(-1509359403,2228431183),new $Int64(-810313977,3554678728),new $Int64(-750989047,173470263),new $Int64(-85886265,3848297795),new $Int64(-926936977,246236185),new $Int64(-1984190461,2066374846),new $Int64(1771673660,312890749),new $Int64(703378057,3573310289),new $Int64(-598851901,143166754),new $Int64(613554316,2081511079),new $Int64(1197802104,486038032),new $Int64(-1906483789,2982218564),new $Int64(364901986,1000939191),new $Int64(1902782651,2750454885),new $Int64(-671844857,3375313137),new $Int64(-1643868040,881302957),new $Int64(-1508784745,2514186393),new $Int64(-1703622845,360024739),new $Int64(1399671872,292500025),new $Int64(1381210821,2276300752),new $Int64(521803381,4069087683),new $Int64(-1938982667,1637778212),new $Int64(720490469,1676670893),new $Int64(1067262482,3855174429),new $Int64(2114075974,2067248671),new $Int64(-89426259,2884561259),new $Int64(-805741095,2456511185),new $Int64(983726246,561175414),new $Int64(-1719489563,432588903),new $Int64(885133709,4059399550),new $Int64(-93096266,1075014784),new $Int64(-1733832628,2728058415),new $Int64(1839142064,1299703678),new $Int64(1262333188,2347583393),new $Int64(1285481956,2468164145),new $Int64(-1158354011,1140014346),new $Int64(2033889184,1936972070),new $Int64(-1737578993,3870530098),new $Int64(-484494257,1717789158),new $Int64(-232997156,1153452491),new $Int64(-990424416,3948827651),new $Int64(-1357145630,2101413152),new $Int64(1495744672,3854091229),new $Int64(83644069,4215565463),new $Int64(-1385277313,1202710438),new $Int64(-564909037,2072216740),new $Int64(705690639,2066751068),new $Int64(-2113583312,173902580),new $Int64(-741983806,142459001),new $Int64(172391592,1889151926),new $Int64(-498943125,3034199774),new $Int64(1618587731,516490102),new $Int64(93114264,3692577783),new $Int64(-2078821353,2953948865),new $Int64(-320938673,4041040923),new $Int64(-1942517976,592046130),new $Int64(-705643640,384297211),new $Int64(-2051649464,265863924),new $Int64(2101717619,1333136237),new $Int64(1499611781,1406273556),new $Int64(1074670496,426305476),new $Int64(125704633,2750898176),new $Int64(488068495,1633944332),new $Int64(2037723464,3236349343),new $Int64(-1703423246,4013676611),new $Int64(1718532237,2265047407),new $Int64(1433593806,875071080),new $Int64(-343047503,1418843655),new $Int64(2009228711,451657300),new $Int64(1229446621,1866374663),new $Int64(1653472867,1551455622),new $Int64(577191481,3560962459),new $Int64(1669204077,3347903778),new $Int64(-298327194,2675874918),new $Int64(-1831355577,2762991672),new $Int64(530492383,3689068477),new $Int64(844089962,4071997905),new $Int64(1508155730,1381702441),new $Int64(2089931018,2373284878),new $Int64(-864267462,2143983064),new $Int64(308739063,1938207195),new $Int64(1754949306,1188152253),new $Int64(1272345009,615870490),new $Int64(742653194,2662252621),new $Int64(1477718295,3839976789),new $Int64(-2091334213,306752547),new $Int64(-1426688067,2162363077),new $Int64(-57052633,2767224719),new $Int64(-1471624099,2628837712),new $Int64(1678405918,2967771969),new $Int64(1694285728,499792248),new $Int64(-1744131281,4285253508),new $Int64(962357072,2856511070),new $Int64(679471692,2526409716),new $Int64(-1793706473,1240875658),new $Int64(-914893422,2577342868),new $Int64(-1001298215,4136853496),new $Int64(-1477114974,2403540137),new $Int64(1372824515,1371410668),new $Int64(-176562048,371758825),new $Int64(-441063112,1528834084),new $Int64(-71688630,1504757260),new $Int64(-1461820072,699052551),new $Int64(-505543539,3347789870),new $Int64(1951619734,3430604759),new $Int64(2119672219,1935601723),new $Int64(966789690,834676166)]);P=N(new AG.ptr(new B.Mutex.ptr(false),$assertType(L(new $Int64(0,1)),K)));}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["math/big"]=(function(){var $pkg={},$init,H,G,J,C,K,E,D,B,I,A,F,L,AN,AS,AT,AV,AW,AX,BL,BW,BX,CX,DA,DN,DO,DP,DR,DS,DT,DU,DV,DW,DX,DY,DZ,EA,EB,M,BF,BM,BY,BZ,CA,CE,CM,CN,CQ,CW,CY,DJ,DK,b,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AO,AP,AQ,AR,AU,AY,AZ,BA,BB,BC,BD,BH,BI,BJ,BK,BN,BO,BP,BQ,BR,BS,BT,BU,BV,CB,CC,CD,CF,CG,CH,CI,CJ,CK,CL,CO,CP,CR,CS,CT,CU,CV,CZ,DC,DD,DE,DF,DG,DI,DL;H=$packages["bytes"];G=$packages["encoding/binary"];J=$packages["errors"];C=$packages["fmt"];K=$packages["github.com/gopherjs/gopherjs/nosync"];E=$packages["io"];D=$packages["math"];B=$packages["math/bits"];I=$packages["math/rand"];A=$packages["strconv"];F=$packages["strings"];L=$pkg.Word=$newType(4,$kindUintptr,"big.Word",true,"math/big",true,null);AN=$pkg.decimal=$newType(0,$kindStruct,"big.decimal",true,"math/big",false,function(mant_,exp_){this.$val=this;if(arguments.length===0){this.mant=DR.nil;this.exp=0;return;}this.mant=mant_;this.exp=exp_;});AS=$pkg.Float=$newType(0,$kindStruct,"big.Float",true,"math/big",true,function(prec_,mode_,acc_,form_,neg_,mant_,exp_){this.$val=this;if(arguments.length===0){this.prec=0;this.mode=0;this.acc=0;this.form=0;this.neg=false;this.mant=BX.nil;this.exp=0;return;}this.prec=prec_;this.mode=mode_;this.acc=acc_;this.form=form_;this.neg=neg_;this.mant=mant_;this.exp=exp_;});AT=$pkg.ErrNaN=$newType(0,$kindStruct,"big.ErrNaN",true,"math/big",true,function(msg_){this.$val=this;if(arguments.length===0){this.msg="";return;}this.msg=msg_;});AV=$pkg.form=$newType(1,$kindUint8,"big.form",true,"math/big",false,null);AW=$pkg.RoundingMode=$newType(1,$kindUint8,"big.RoundingMode",true,"math/big",true,null);AX=$pkg.Accuracy=$newType(1,$kindInt8,"big.Accuracy",true,"math/big",true,null);BL=$pkg.Int=$newType(0,$kindStruct,"big.Int",true,"math/big",true,function(neg_,abs_){this.$val=this;if(arguments.length===0){this.neg=false;this.abs=BX.nil;return;}this.neg=neg_;this.abs=abs_;});BW=$pkg.byteReader=$newType(0,$kindStruct,"big.byteReader",true,"math/big",false,function(ScanState_){this.$val=this;if(arguments.length===0){this.ScanState=$ifaceNil;return;}this.ScanState=ScanState_;});BX=$pkg.nat=$newType(12,$kindSlice,"big.nat",true,"math/big",false,null);CX=$pkg.divisor=$newType(0,$kindStruct,"big.divisor",true,"math/big",false,function(bbb_,nbits_,ndigits_){this.$val=this;if(arguments.length===0){this.bbb=BX.nil;this.nbits=0;this.ndigits=0;return;}this.bbb=bbb_;this.nbits=nbits_;this.ndigits=ndigits_;});DA=$pkg.Rat=$newType(0,$kindStruct,"big.Rat",true,"math/big",true,function(a_,b_){this.$val=this;if(arguments.length===0){this.a=new BL.ptr(false,BX.nil);this.b=new BL.ptr(false,BX.nil);return;}this.a=a_;this.b=b_;});DN=$sliceType($emptyInterface);DO=$arrayType(CX,64);DP=$structType("math/big",[{prop:"Mutex",name:"Mutex",embedded:true,exported:true,typ:K.Mutex,tag:""},{prop:"table",name:"table",embedded:false,exported:false,typ:DO,tag:""}]);DR=$sliceType($Uint8);DS=$ptrType(AS);DT=$sliceType(L);DU=$ptrType(BL);DV=$ptrType(DA);DW=$ptrType(L);DX=$ptrType(BX);DY=$arrayType(BX,16);DZ=$sliceType(CX);EA=$ptrType(AN);EB=$ptrType(I.Rand);AX.prototype.String=function(){var c,d;c=this.$val;c=c-(-1)<<24>>24;if(c<0||c>=3){return"Accuracy("+A.FormatInt((new $Int64(0,(c+-1<<24>>24))),10)+")";}return $substring("BelowExactAbove",((c<0||c>=M.length)?($throwRuntimeError("index out of range"),undefined):M[c]),(d=c+1<<24>>24,((d<0||d>=M.length)?($throwRuntimeError("index out of range"),undefined):M[d])));};$ptrType(AX).prototype.String=function(){return new AX(this.$get()).String();};N=function(c,d,e){var c,d,e,f,g,h;f=0;g=0;h=d+e>>>0;g=c+h>>>0;if(g>>0;g=c-h>>>0;if(g>c||h>>0;h=c>>>16>>>0;i=(d&65535)>>>0;j=d>>>16>>>0;k=$imul(g,i)>>>0;l=($imul(h,i)>>>0)+(k>>>16>>>0)>>>0;m=(l&65535)>>>0;n=l>>>16>>>0;m=m+(($imul(g,j)>>>0))>>>0;e=(($imul(h,j)>>>0)+n>>>0)+(m>>>16>>>0)>>>0;f=$imul(c,d)>>>0;return[e,f];};Q=function(c,d,e){var c,d,e,f,g,h,i;f=0;g=0;h=P(c,d);f=h[0];i=h[1];g=i+e>>>0;if(g>>0;}return[f,g];};R=function(c){var c;return((B.LeadingZeros(((c>>>0)))>>>0));};S=function(c,d,e){var aa,ab,ac,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;f=0;g=0;if(c>=e){h=4294967295;i=4294967295;f=h;g=i;return[f,g];}j=R(e);e=(k=(j),k<32?(e<>>0;l=e>>>16>>>0;m=(e&65535)>>>0;p=(((n=j,n<32?(c<>>0)|((o=((32-j>>>0)),o<32?(d>>>o):0)>>>0))>>>0;r=(q=j,q<32?(d<>>0;s=r>>>16>>>0;t=(r&65535)>>>0;v=(u=p/l,(u===u&&u!==1/0&&u!==-1/0)?u>>>0:$throwRuntimeError("integer divide by zero"));w=p-($imul(v,l)>>>0)>>>0;while(true){if(!(v>=65536||($imul(v,m)>>>0)>(($imul(65536,w)>>>0)+s>>>0))){break;}v=v-(1)>>>0;w=w+(l)>>>0;if(w>=65536){break;}}x=(($imul(p,65536)>>>0)+s>>>0)-($imul(v,e)>>>0)>>>0;z=(y=x/l,(y===y&&y!==1/0&&y!==-1/0)?y>>>0:$throwRuntimeError("integer divide by zero"));w=x-($imul(z,l)>>>0)>>>0;while(true){if(!(z>=65536||($imul(z,m)>>>0)>(($imul(65536,w)>>>0)+t>>>0))){break;}z=z-(1)>>>0;w=w+(l)>>>0;if(w>=65536){break;}}aa=($imul(v,65536)>>>0)+z>>>0;ab=(ac=j,ac<32?((((($imul(x,65536)>>>0)+t>>>0)-($imul(z,e)>>>0)>>>0))>>>ac):0)>>>0;f=aa;g=ab;return[f,g];};T=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p;f=0;if(false){g=c;h=0;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]),((i<0||i>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+i]),f);f=j[0];((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]=j[1]);h++;}return f;}k=$subslice(d,0,c.$length);l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);o=((m<0||m>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]);p=(n+o>>>0)+f>>>0;((m<0||m>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+m]=p);f=(((((n&o)>>>0)|(((((n|o)>>>0))&~p)>>>0))>>>0))>>>31>>>0;l++;}return f;};U=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p;f=0;if(false){g=c;h=0;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]),((i<0||i>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+i]),f);f=j[0];((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]=j[1]);h++;}return f;}k=$subslice(d,0,c.$length);l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);o=((m<0||m>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]);p=(n-o>>>0)-f>>>0;((m<0||m>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+m]=p);f=(((((o&~n)>>>0)|(((((o|(~n>>>0))>>>0))&p)>>>0))>>>0))>>>31>>>0;l++;}return f;};V=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o;f=0;if(false){f=e;g=c;h=0;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]),f,0);f=j[0];((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]=j[1]);h++;}return f;}f=e;k=$subslice(d,0,c.$length);l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);o=n+f>>>0;((m<0||m>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+m]=o);f=((n&~o)>>>0)>>>31>>>0;l++;}return f;};W=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o;f=0;if(false){f=e;g=c;h=0;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]),f,0);f=j[0];((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]=j[1]);h++;}return f;}f=e;k=$subslice(d,0,c.$length);l=0;while(true){if(!(l=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]);o=n-f>>>0;((m<0||m>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+m]=o);f=(((o&~n)>>>0))>>>31>>>0;l++;}return f;};X=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;f=0;g=c.$length;if(g>0){h=32-e>>>0;j=(i=g-1>>0,((i<0||i>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]));f=(k=h,k<32?(j>>>k):0)>>>0;l=g-1>>0;while(true){if(!(l>0)){break;}m=j;j=(n=l-1>>0,((n<0||n>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+n]));((l<0||l>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+l]=((((o=e,o<32?(m<>>0)|((p=h,p<32?(j>>>p):0)>>>0))>>>0));l=l-(1)>>0;}(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]=((q=e,q<32?(j<>>0));}return f;};Y=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;f=0;g=c.$length;if(g>0){h=32-e>>>0;i=(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]);f=(j=h,j<32?(i<>>0;k=0;while(true){if(!(k<(g-1>>0))){break;}l=i;i=(m=k+1>>0,((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m]));((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k]=((((n=e,n<32?(l>>>n):0)>>>0)|((o=h,o<32?(i<>>0))>>>0));k=k+(1)>>0;}(q=g-1>>0,((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]=((p=e,p<32?(i>>>p):0)>>>0)));}return f;};Z=function(c,d,e,f){var c,d,e,f,g,h,i,j,k;g=0;g=f;h=c;i=0;while(true){if(!(i=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+j]),e,g);g=k[0];((j<0||j>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+j]=k[1]);i++;}return g;};AA=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m;f=0;g=c;h=0;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]),e,((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]));k=j[0];l=j[1];m=N(l,f,0);f=m[0];((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i]=m[1]);f=f+(k)>>>0;h++;}return f;};AB=function(c,d,e,f){var c,d,e,f,g,h,i;g=0;g=d;h=c.$length-1>>0;while(true){if(!(h>=0)){break;}i=S(g,((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]),f);((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h]=i[0]);g=i[1];h=h-(1)>>0;}return g;};AC=function(c,d){var c,d,e,f,g;e=0;f=0;g=P(c,d);e=g[0];f=g[1];return[e,f];};AD=function(c,d,e){var c,d,e,f,g,h;f=0;g=0;h=S(c,d,e);f=h[0];g=h[1];return[f,g];};AE=function(c,d,e){var c,d,e,f;f=0;f=T(c,d,e);return f;};AF=function(c,d,e){var c,d,e,f;f=0;f=U(c,d,e);return f;};AG=function(c,d,e){var c,d,e,f;f=0;f=V(c,d,e);return f;};AH=function(c,d,e){var c,d,e,f;f=0;f=W(c,d,e);return f;};AI=function(c,d,e){var c,d,e,f;f=0;f=X(c,d,e);return f;};AJ=function(c,d,e){var c,d,e,f;f=0;f=Y(c,d,e);return f;};AK=function(c,d,e,f){var c,d,e,f,g;g=0;g=Z(c,d,e,f);return g;};AL=function(c,d,e){var c,d,e,f;f=0;f=AA(c,d,e);return f;};AM=function(c,d,e,f){var c,d,e,f,g;g=0;g=AB(c,d,e,f);return g;};AN.ptr.prototype.at=function(c){var c,d,e;d=this;if(0<=c&&c=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+c]));}return 48;};AN.prototype.at=function(c){return this.$val.at(c);};AN.ptr.prototype.init=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(c.$length===0){e.mant=$subslice(e.mant,0,0);e.exp=0;$s=-1;return;}if(d<0){f=c.trailingZeroBits();g=((-d>>>0));if(g>=f){g=f;}c=(BX.nil).shr(c,g);d=d+(((g>>0)))>>0;}if(d>0){c=(BX.nil).shl(c,((d>>>0)));d=0;}h=c.utoa(10);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;j=i.$length;e.exp=j;while(true){if(!(j>0&&((k=j-1>>0,((k<0||k>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+k]))===48))){break;}j=j-(1)>>0;}e.mant=$appendSlice($subslice(e.mant,0,0),$subslice(i,0,j));if(d<0){while(true){if(!(d<-28)){break;}AO(e,28);d=d+(28)>>0;}AO(e,((-d>>>0)));}$s=-1;return;}return;}if($f===undefined){$f={$blk:AN.ptr.prototype.init};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};AN.prototype.init=function(c,d){return this.$val.init(c,d);};AO=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;e=0;f=0;while(true){if(!((((g=d,g<32?(f>>>g):0)>>>0)===0)&&e=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+e]))>>>0));e=e+(1)>>0;f=(($imul(f,10)>>>0)+i>>>0)-48>>>0;}if(f===0){c.mant=$subslice(c.mant,0,0);return;}while(true){if(!(((j=d,j<32?(f>>>j):0)>>>0)===0)){break;}e=e+(1)>>0;f=$imul(f,(10))>>>0;}c.exp=c.exp+((1-e>>0))>>0;k=0;m=((l=d,l<32?(1<>>0)-1>>>0;while(true){if(!(e=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+e]))>>>0));e=e+(1)>>0;q=(p=d,p<32?(f>>>p):0)>>>0;f=(f&(m))>>>0;(r=c.mant,((k<0||k>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+k]=(((q+48>>>0)<<24>>>24))));k=k+(1)>>0;f=(($imul(f,10)>>>0)+o>>>0)-48>>>0;}while(true){if(!(f>0&&k>>s):0)>>>0;f=(f&(m))>>>0;(u=c.mant,((k<0||k>=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+k]=(((t+48>>>0)<<24>>>24))));k=k+(1)>>0;f=$imul(f,10)>>>0;}c.mant=$subslice(c.mant,0,k);while(true){if(!(f>0)){break;}w=(v=d,v<32?(f>>>v):0)>>>0;f=(f&(m))>>>0;c.mant=$append(c.mant,(((w+48>>>0)<<24>>>24)));f=$imul(f,10)>>>0;}AR(c);};AN.ptr.prototype.String=function(){var c,d;c=this;if(c.mant.$length===0){return"0";}d=DR.nil;if(c.exp<=0){d=$appendSlice(d,"0.");d=AP(d,-c.exp);d=$appendSlice(d,c.mant);}else if(c.exp>0);}return($bytesToString(d));};AN.prototype.String=function(){return this.$val.String();};AP=function(c,d){var c,d;while(true){if(!(d>0)){break;}c=$append(c,48);d=d-(1)>>0;}return c;};AQ=function(c,d){var c,d,e,f,g,h;if(((e=c.mant,((d<0||d>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+d]))===53)&&((d+1>>0)===c.mant.$length)){return d>0&&!(((((((f=c.mant,g=d-1>>0,((g<0||g>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]))-48<<24>>>24))&1)>>>0)===0));}return(h=c.mant,((d<0||d>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+d]))>=53;};AN.ptr.prototype.round=function(c){var c,d;d=this;if(c<0||c>=d.mant.$length){return;}if(AQ(d,c)){d.roundUp(c);}else{d.roundDown(c);}};AN.prototype.round=function(c){return this.$val.round(c);};AN.ptr.prototype.roundUp=function(c){var c,d,e,f,g,h,i,j;d=this;if(c<0||c>=d.mant.$length){return;}while(true){if(!(c>0&&(e=d.mant,f=c-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]))>=57)){break;}c=c-(1)>>0;}if(c===0){(g=d.mant,(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]=49));d.mant=$subslice(d.mant,0,1);d.exp=d.exp+(1)>>0;return;}h=c-1>>0;(j=d.mant,((h<0||h>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+h]=((i=d.mant,((h<0||h>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+h]))+(1)<<24>>>24)));d.mant=$subslice(d.mant,0,c);};AN.prototype.roundUp=function(c){return this.$val.roundUp(c);};AN.ptr.prototype.roundDown=function(c){var c,d;d=this;if(c<0||c>=d.mant.$length){return;}d.mant=$subslice(d.mant,0,c);AR(d);};AN.prototype.roundDown=function(c){return this.$val.roundDown(c);};AR=function(c){var c,d,e,f;d=c.mant.$length;while(true){if(!(d>0&&((e=c.mant,f=d-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]))===48))){break;}d=d-(1)>>0;}c.mant=$subslice(c.mant,0,d);if(d===0){c.exp=0;}};AT.ptr.prototype.Error=function(){var c;c=this;return c.msg;};AT.prototype.Error=function(){return this.$val.Error();};AU=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(D.IsNaN(c)){$panic((d=new AT.ptr("NewFloat(NaN)"),new d.constructor.elem(d)));}e=new AS.ptr(0,0,0,0,false,BX.nil,0).SetFloat64(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:AU};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewFloat=AU;AS.ptr.prototype.SetPrec=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;d.acc=0;if(c===0){d.prec=0;if(d.form===1){d.acc=AY(d.neg);d.form=0;}$s=-1;return d;}if(c>4294967295){c=4294967295;}e=d.prec;d.prec=((c>>>0));if(d.prec>>0));};AS.prototype.Prec=function(){return this.$val.Prec();};AS.ptr.prototype.MinPrec=function(){var c;c=this;if(!((c.form===1))){return 0;}return(((c.mant.$length>>>0))*32>>>0)-c.mant.trailingZeroBits()>>>0;};AS.prototype.MinPrec=function(){return this.$val.MinPrec();};AS.ptr.prototype.Mode=function(){var c;c=this;return c.mode;};AS.prototype.Mode=function(){return this.$val.Mode();};AS.ptr.prototype.Acc=function(){var c;c=this;return c.acc;};AS.prototype.Acc=function(){return this.$val.Acc();};AS.ptr.prototype.Sign=function(){var c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(c.form===0){$s=-1;return 0;}if(c.neg){$s=-1;return-1;}$s=-1;return 1;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Sign};}$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Sign=function(){return this.$val.Sign();};AS.ptr.prototype.MantExp=function(c){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=0;e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=e.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.form===1){d=((e.exp>>0));}if(!(c===DS.nil)){$s=4;continue;}$s=5;continue;case 4:f=c.Copy(e);$s=6;case 6:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;if(c.form===1){c.exp=0;}case 5:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.MantExp};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.MantExp=function(c){return this.$val.MantExp(c);};AS.ptr.prototype.setExpAndRound=function(c,d){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if((c.$high<-1||(c.$high===-1&&c.$low<2147483648))){e.acc=AY(e.neg);e.form=0;$s=-1;return;}if((c.$high>0||(c.$high===0&&c.$low>2147483647))){e.acc=AY(!e.neg);e.form=2;$s=-1;return;}e.form=1;e.exp=(((c.$low+((c.$high>>31)*4294967296))>>0));$r=e.round(d);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.setExpAndRound};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.setExpAndRound=function(c,d){return this.$val.setExpAndRound(c,d);};AS.ptr.prototype.SetMantExp=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=e.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=c.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:f=e.Copy(c);$s=5;case 5:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;if(!((e.form===1))){$s=-1;return e;}$r=e.setExpAndRound((g=(new $Int64(0,e.exp)),h=(new $Int64(0,d)),new $Int64(g.$high+h.$high,g.$low+h.$low)),0);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetMantExp};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetMantExp=function(c,d){return this.$val.SetMantExp(c,d);};AS.ptr.prototype.Signbit=function(){var c;c=this;return c.neg;};AS.prototype.Signbit=function(){return this.$val.Signbit();};AS.ptr.prototype.IsInf=function(){var c;c=this;return c.form===2;};AS.prototype.IsInf=function(){return this.$val.IsInf();};AS.ptr.prototype.IsInt=function(){var c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(!((c.form===1))){$s=-1;return c.form===0;}if(c.exp<=0){$s=-1;return false;}$s=-1;return c.prec<=((c.exp>>>0))||c.MinPrec()<=((c.exp>>>0));}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.IsInt};}$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.IsInt=function(){return this.$val.IsInt();};AS.ptr.prototype.validate=function(){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(true){$panic(new $String("validate called but debugFloat is not set"));}if(!((c.form===1))){$s=-1;return;}d=c.mant.$length;if(d===0){$panic(new $String("nonzero finite number with empty mantissa"));}if((((e=c.mant,f=d-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]))&2147483648)>>>0)===0){$s=1;continue;}$s=2;continue;case 1:i=new L((g=c.mant,h=d-1>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h])));j=c.Text(112,0);$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=new $String(j);l=C.Sprintf("msb not set in last word %#x of %s",new DN([i,k]));$s=4;case 4:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$panic(new $String(l));case 2:if(c.prec===0){$panic(new $String("zero precision finite number"));}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.validate};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.validate=function(){return this.$val.validate();};AS.ptr.prototype.round=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=d.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d.acc=0;if(!((d.form===1))){$s=-1;return;}e=((d.mant.$length>>>0));f=$imul(e,32)>>>0;if(f<=d.prec){$s=-1;return;}g=((((f-d.prec>>>0)-1>>>0)>>>0));h=(d.mant.bit(g)&1)>>>0;if((c===0)&&((h===0)||(d.mode===0))){c=d.mant.sticky(g);}c=(c&(1))>>>0;j=(i=((d.prec+31>>>0))/32,(i===i&&i!==1/0&&i!==-1/0)?i>>>0:$throwRuntimeError("integer divide by zero"));if(e>j){$copySlice(d.mant,$subslice(d.mant,(e-j>>>0)));d.mant=$subslice(d.mant,0,j);}k=($imul(j,32)>>>0)-d.prec>>>0;m=(l=k,l<32?(1<>>0;if(!((((h|c)>>>0)===0))){n=false;o=d.mode;if(o===(4)){n=d.neg;}else if(o===(2)){}else if(o===(0)){n=!((h===0))&&(!((c===0))||!(((((p=d.mant,(0>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+0]))&m)>>>0)===0)));}else if(o===(1)){n=!((h===0));}else if(o===(3)){n=true;}else if(o===(5)){n=!d.neg;}else{$panic(new $String("unreachable"));}d.acc=AY(!(n===d.neg));if(n){if(!((AG((q=d.mant,$subslice(new DT(q.$array),q.$offset,q.$offset+q.$length)),(r=d.mant,$subslice(new DT(r.$array),r.$offset,r.$offset+r.$length)),m)===0))){if(d.exp>=2147483647){d.form=2;$s=-1;return;}d.exp=d.exp+(1)>>0;AJ((s=d.mant,$subslice(new DT(s.$array),s.$offset,s.$offset+s.$length)),(t=d.mant,$subslice(new DT(t.$array),t.$offset,t.$offset+t.$length)),1);u=j-1>>>0;(w=d.mant,((u<0||u>=w.$length)?($throwRuntimeError("index out of range"),undefined):w.$array[w.$offset+u]=(((v=d.mant,((u<0||u>=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+u]))|(2147483648))>>>0)));}}}(y=d.mant,(0>=y.$length?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+0]=(((x=d.mant,(0>=x.$length?($throwRuntimeError("index out of range"),undefined):x.$array[x.$offset+0]))&~((m-1>>>0)))>>>0)));if(false){$s=4;continue;}$s=5;continue;case 4:$r=d.validate();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 5:$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.round};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.round=function(c){return this.$val.round(c);};AS.ptr.prototype.setBits64=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(e.prec===0){e.prec=64;}e.acc=0;e.neg=c;if((d.$high===0&&d.$low===0)){e.form=0;$s=-1;return e;}e.form=1;f=B.LeadingZeros64(d);e.mant=e.mant.setUint64($shiftLeft64(d,((f>>>0))));e.exp=(((64-f>>0)>>0));if(e.prec<64){$s=1;continue;}$s=2;continue;case 1:$r=e.round(0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return e;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.setBits64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.setBits64=function(c,d){return this.$val.setBits64(c,d);};AS.ptr.prototype.SetUint64=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.setBits64(false,c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetUint64};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetUint64=function(c){return this.$val.SetUint64(c);};AS.ptr.prototype.SetInt64=function(c){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=c;if((e.$high<0||(e.$high===0&&e.$low<0))){e=new $Int64(-e.$high,-e.$low);}f=d.setBits64((c.$high<0||(c.$high===0&&c.$low<0)),(new $Uint64(e.$high,e.$low)));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetInt64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetInt64=function(c){return this.$val.SetInt64(c);};AS.ptr.prototype.SetFloat64=function(c){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(d.prec===0){d.prec=53;}if(D.IsNaN(c)){$panic((e=new AT.ptr("Float.SetFloat64(NaN)"),new e.constructor.elem(e)));}d.acc=0;d.neg=D.Signbit(c);if(c===0){d.form=0;$s=-1;return d;}if(D.IsInf(c,0)){d.form=2;$s=-1;return d;}d.form=1;f=D.Frexp(c);g=f[0];h=f[1];d.mant=d.mant.setUint64((i=$shiftLeft64(D.Float64bits(g),11),new $Uint64(2147483648|i.$high,(0|i.$low)>>>0)));d.exp=((h>>0));if(d.prec<53){$s=1;continue;}$s=2;continue;case 1:$r=d.round(0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetFloat64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetFloat64=function(c){return this.$val.SetFloat64(c);};AZ=function(c){var c,d,e,f,g;if(false&&((c.$length===0)||((d=c.$length-1>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]))===0))){$panic(new $String("msw of mantissa is 0"));}f=R((e=c.$length-1>>0,((e<0||e>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e])));if(f>0){g=AI($subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),f);if(false&&!((g===0))){$panic(new $String("nlz or shlVU incorrect"));}}return(new $Int64(0,f));};AS.ptr.prototype.SetInt=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=((c.BitLen()>>>0));if(d.prec===0){d.prec=BD(e,64);}d.acc=0;d.neg=c.neg;if(c.abs.$length===0){d.form=0;$s=-1;return d;}d.mant=d.mant.set(c.abs);AZ(d.mant);$r=d.setExpAndRound((new $Int64(0,e)),0);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetInt};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetInt=function(c){return this.$val.SetInt(c);};AS.ptr.prototype.SetRat=function(c){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=[d];e=[e];f=this;if(c.IsInt()){$s=1;continue;}$s=2;continue;case 1:g=f.SetInt(c.Num());$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return g;case 2:h=new AS.ptr(0,0,0,0,false,BX.nil,0);i=new AS.ptr(0,0,0,0,false,BX.nil,0);d[0]=$clone(h,AS);e[0]=$clone(i,AS);j=d[0].SetInt(c.Num());$s=4;case 4:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}j;k=e[0].SetInt(c.Denom());$s=5;case 5:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}k;if(f.prec===0){f.prec=BD(d[0].prec,e[0].prec);}l=f.Quo(d[0],e[0]);$s=6;case 6:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$s=-1;return l;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetRat};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetRat=function(c){return this.$val.SetRat(c);};AS.ptr.prototype.SetInf=function(c){var c,d;d=this;d.acc=0;d.form=2;d.neg=c;return d;};AS.prototype.SetInf=function(c){return this.$val.SetInf(c);};AS.ptr.prototype.Set=function(c){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d.acc=0;if(!(d===c)){$s=4;continue;}$s=5;continue;case 4:d.form=c.form;d.neg=c.neg;if(c.form===1){d.exp=c.exp;d.mant=d.mant.set(c.mant);}if(d.prec===0){$s=6;continue;}if(d.prec>0;if(d<0){return 0;}if(false&&(((((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])&2147483648)>>>0)===0)){$panic(new $String("x not normalized"));}e=32;if(e===(32)){return((((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])>>>0));}else if(e===(64)){return((0>>>0));}$panic(new $String("unreachable"));};BB=function(c){var c,d,e,f,g,h,i,j,k;d=c.$length-1>>0;if(d<0){return new $Uint64(0,0);}if(false&&(((((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])&2147483648)>>>0)===0)){$panic(new $String("x not normalized"));}e=32;if(e===(32)){g=$shiftLeft64(((f=((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),new $Uint64(0,f.constructor===Number?f:1))),32);if(d>0){g=(h=((i=(j=d-1>>0,((j<0||j>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+j])),new $Uint64(0,i.constructor===Number?i:1))),new $Uint64(g.$high|h.$high,(g.$low|h.$low)>>>0));}return g;}else if(e===(64)){return((k=((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),new $Uint64(0,k.constructor===Number?k:1)));}$panic(new $String("unreachable"));};AS.ptr.prototype.Uint64=function(){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d=c.form;if(d===(1)){if(c.neg){$s=-1;return[new $Uint64(0,0),1];}if(c.exp<=0){$s=-1;return[new $Uint64(0,0),-1];}if(c.exp<=64){e=$shiftRightUint64(BB(c.mant),((64-((c.exp>>>0))>>>0)));if(c.MinPrec()<=64){$s=-1;return[e,0];}$s=-1;return[e,-1];}$s=-1;return[new $Uint64(4294967295,4294967295),-1];}else if(d===(0)){$s=-1;return[new $Uint64(0,0),0];}else if(d===(2)){if(c.neg){$s=-1;return[new $Uint64(0,0),1];}$s=-1;return[new $Uint64(4294967295,4294967295),-1];}$panic(new $String("unreachable"));$s=-1;return[new $Uint64(0,0),0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Uint64};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Uint64=function(){return this.$val.Uint64();};AS.ptr.prototype.Int64=function(){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d=c.form;if(d===(1)){e=AY(c.neg);if(c.exp<=0){$s=-1;return[new $Int64(0,0),e];}if(c.exp<=63){g=((f=$shiftRightUint64(BB(c.mant),((64-((c.exp>>>0))>>>0))),new $Int64(f.$high,f.$low)));if(c.neg){g=new $Int64(-g.$high,-g.$low);}if(c.MinPrec()<=((c.exp>>>0))){$s=-1;return[g,0];}$s=-1;return[g,e];}if(c.neg){if((c.exp===64)&&(c.MinPrec()===1)){e=0;}$s=-1;return[new $Int64(-2147483648,0),e];}$s=-1;return[new $Int64(2147483647,4294967295),-1];}else if(d===(0)){$s=-1;return[new $Int64(0,0),0];}else if(d===(2)){if(c.neg){$s=-1;return[new $Int64(-2147483648,0),1];}$s=-1;return[new $Int64(2147483647,4294967295),-1];}$panic(new $String("unreachable"));$s=-1;return[new $Int64(0,0),0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Int64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Int64=function(){return this.$val.Int64();};AS.ptr.prototype.Float32=function(){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d=c.form;if(d===(1)){$s=5;continue;}if(d===(0)){$s=6;continue;}if(d===(2)){$s=7;continue;}$s=8;continue;case 5:e=c.exp-1>>0;f=24;if(e<-126){f=150+((e>>0))>>0;if(f<0||(f===0)&&(c.mant.sticky((((c.mant.$length>>>0))*32>>>0)-1>>>0)===0)){if(c.neg){g=0;$s=-1;return[-g,1];}$s=-1;return[0,-1];}if(f===0){if(c.neg){$s=-1;return[-1.401298464324817e-45,-1];}$s=-1;return[1.401298464324817e-45,1];}}h=new AS.ptr(0,0,0,0,false,BX.nil,0);h.prec=((f>>>0));i=h.Set(c);$s=9;case 9:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;e=h.exp-1>>0;if((h.form===2)||e>127){if(c.neg){$s=-1;return[($fround(D.Inf(-1))),-1];}$s=-1;return[($fround(D.Inf(1))),1];}j=0;k=0;l=0;m=j;n=k;o=l;if(c.neg){m=2147483648;}if(e<-126){f=150+((e>>0))>>0;o=(p=(((32-f>>0)>>>0)),p<32?(BA(h.mant)>>>p):0)>>>0;}else{n=(((e+127>>0)>>>0))<<23>>>0;o=((BA(h.mant)>>>8>>>0)&8388607)>>>0;}$s=-1;return[D.Float32frombits((((m|n)>>>0)|o)>>>0),h.acc];case 6:if(c.neg){q=0;$s=-1;return[-q,0];}$s=-1;return[0,0];case 7:if(c.neg){$s=-1;return[($fround(D.Inf(-1))),0];}$s=-1;return[($fround(D.Inf(1))),0];case 8:case 4:$panic(new $String("unreachable"));$s=-1;return[0,0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Float32};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Float32=function(){return this.$val.Float32();};AS.ptr.prototype.Float64=function(){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:d=c.form;if(d===(1)){$s=5;continue;}if(d===(0)){$s=6;continue;}if(d===(2)){$s=7;continue;}$s=8;continue;case 5:e=c.exp-1>>0;f=53;if(e<-1022){f=1075+((e>>0))>>0;if(f<0||(f===0)&&(c.mant.sticky((((c.mant.$length>>>0))*32>>>0)-1>>>0)===0)){if(c.neg){g=0;$s=-1;return[-g,1];}$s=-1;return[0,-1];}if(f===0){if(c.neg){$s=-1;return[-5e-324,-1];}$s=-1;return[5e-324,1];}}h=new AS.ptr(0,0,0,0,false,BX.nil,0);h.prec=((f>>>0));i=h.Set(c);$s=9;case 9:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;e=h.exp-1>>0;if((h.form===2)||e>1023){if(c.neg){$s=-1;return[D.Inf(-1),-1];}$s=-1;return[D.Inf(1),1];}j=new $Uint64(0,0);k=new $Uint64(0,0);l=new $Uint64(0,0);m=j;n=k;o=l;if(c.neg){m=new $Uint64(2147483648,0);}if(e<-1022){f=1075+((e>>0))>>0;o=$shiftRightUint64(BB(h.mant),(((64-f>>0)>>>0)));}else{n=$shiftLeft64((new $Uint64(0,(e+1023>>0))),52);o=(p=$shiftRightUint64(BB(h.mant),11),new $Uint64(p.$high&1048575,(p.$low&4294967295)>>>0));}$s=-1;return[D.Float64frombits((q=new $Uint64(m.$high|n.$high,(m.$low|n.$low)>>>0),new $Uint64(q.$high|o.$high,(q.$low|o.$low)>>>0))),h.acc];case 6:if(c.neg){r=0;$s=-1;return[-r,0];}$s=-1;return[0,0];case 7:if(c.neg){$s=-1;return[D.Inf(-1),0];}$s=-1;return[D.Inf(1),0];case 8:case 4:$panic(new $String("unreachable"));$s=-1;return[0,0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Float64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Float64=function(){return this.$val.Float64();};AS.ptr.prototype.Int=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=d.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(c===DU.nil&&d.form<=1){c=new BL.ptr(false,BX.nil);}e=d.form;if(e===(1)){f=AY(d.neg);if(d.exp<=0){$s=-1;return[c.SetInt64(new $Int64(0,0)),f];}g=((d.mant.$length>>>0))*32>>>0;h=((d.exp>>>0));if(d.MinPrec()<=h){f=0;}if(c===DU.nil){c=new BL.ptr(false,BX.nil);}c.neg=d.neg;if(h>g){c.abs=c.abs.shl(d.mant,h-g>>>0);}else if(h>>0);}else{c.abs=c.abs.set(d.mant);}$s=-1;return[c,f];}else if(e===(0)){$s=-1;return[c.SetInt64(new $Int64(0,0)),0];}else if(e===(2)){$s=-1;return[DU.nil,AY(d.neg)];}$panic(new $String("unreachable"));$s=-1;return[DU.nil,0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Int};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Int=function(c){return this.$val.Int(c);};AS.ptr.prototype.Rat=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=d.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(c===DV.nil&&d.form<=1){c=new DA.ptr(new BL.ptr(false,BX.nil),new BL.ptr(false,BX.nil));}e=d.form;if(e===(1)){$s=5;continue;}if(e===(0)){$s=6;continue;}if(e===(2)){$s=7;continue;}$s=8;continue;case 5:f=$imul(((d.mant.$length>>0)),32);c.a.neg=d.neg;if(d.exp>f){$s=10;continue;}if(d.exp>0)>>>0)));c.b.abs=$subslice(c.b.abs,0,0);$s=13;continue;case 11:c.a.abs=c.a.abs.set(d.mant);g=c.b.abs.setUint64(new $Uint64(0,1));c.b.abs=g.shl(g,(((f-d.exp>>0)>>>0)));h=c.norm();$s=14;case 14:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;$s=13;continue;case 12:c.a.abs=c.a.abs.set(d.mant);c.b.abs=$subslice(c.b.abs,0,0);case 13:case 9:$s=-1;return[c,0];case 6:$s=-1;return[c.SetInt64(new $Int64(0,0)),0];case 7:$s=-1;return[DV.nil,AY(d.neg)];case 8:case 4:$panic(new $String("unreachable"));$s=-1;return[DV.nil,0];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Rat};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Rat=function(c){return this.$val.Rat(c);};AS.ptr.prototype.Abs=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.Set(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;d.neg=false;$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Abs};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Abs=function(c){return this.$val.Abs(c);};AS.ptr.prototype.Neg=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.Set(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}e;d.neg=!d.neg;$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Neg};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Neg=function(c){return this.$val.Neg(c);};BC=function(c,d){var c,d;if(true){$panic(new $String("validateBinaryOperands called but debugFloat is not set"));}if(c.mant.$length===0){$panic(new $String("empty mantissa for x"));}if(d.mant.$length===0){$panic(new $String("empty mantissa for y"));}};AS.ptr.prototype.uadd=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){BC(c,d);}h=(f=(new $Int64(0,c.exp)),g=$mul64((new $Int64(0,c.mant.$length)),new $Int64(0,32)),new $Int64(f.$high-g.$high,f.$low-g.$low));k=(i=(new $Int64(0,d.exp)),j=$mul64((new $Int64(0,d.mant.$length)),new $Int64(0,32)),new $Int64(i.$high-j.$high,i.$low-j.$low));l=CG(e.mant,c.mant)||CG(e.mant,d.mant);if((h.$high>>0)));e.mant=e.mant.add(c.mant,m);}else{e.mant=e.mant.shl(d.mant,((new $Int64(k.$high-h.$high,k.$low-h.$low).$low>>>0)));e.mant=e.mant.add(c.mant,e.mant);}}else if((h.$high>k.$high||(h.$high===k.$high&&h.$low>k.$low))){if(l){n=(BX.nil).shl(c.mant,((new $Int64(h.$high-k.$high,h.$low-k.$low).$low>>>0)));e.mant=e.mant.add(n,d.mant);}else{e.mant=e.mant.shl(c.mant,((new $Int64(h.$high-k.$high,h.$low-k.$low).$low>>>0)));e.mant=e.mant.add(e.mant,d.mant);}h=k;}else{e.mant=e.mant.add(c.mant,d.mant);}$r=e.setExpAndRound((o=(p=$mul64((new $Int64(0,e.mant.$length)),new $Int64(0,32)),new $Int64(h.$high+p.$high,h.$low+p.$low)),q=AZ(e.mant),new $Int64(o.$high-q.$high,o.$low-q.$low)),0);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.uadd};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.uadd=function(c,d){return this.$val.uadd(c,d);};AS.ptr.prototype.usub=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){BC(c,d);}h=(f=(new $Int64(0,c.exp)),g=$mul64((new $Int64(0,c.mant.$length)),new $Int64(0,32)),new $Int64(f.$high-g.$high,f.$low-g.$low));k=(i=(new $Int64(0,d.exp)),j=$mul64((new $Int64(0,d.mant.$length)),new $Int64(0,32)),new $Int64(i.$high-j.$high,i.$low-j.$low));l=CG(e.mant,c.mant)||CG(e.mant,d.mant);if((h.$high>>0)));e.mant=m.sub(c.mant,m);}else{e.mant=e.mant.shl(d.mant,((new $Int64(k.$high-h.$high,k.$low-h.$low).$low>>>0)));e.mant=e.mant.sub(c.mant,e.mant);}}else if((h.$high>k.$high||(h.$high===k.$high&&h.$low>k.$low))){if(l){n=(BX.nil).shl(c.mant,((new $Int64(h.$high-k.$high,h.$low-k.$low).$low>>>0)));e.mant=n.sub(n,d.mant);}else{e.mant=e.mant.shl(c.mant,((new $Int64(h.$high-k.$high,h.$low-k.$low).$low>>>0)));e.mant=e.mant.sub(e.mant,d.mant);}h=k;}else{e.mant=e.mant.sub(c.mant,d.mant);}if(e.mant.$length===0){e.acc=0;e.form=0;e.neg=false;$s=-1;return;}$r=e.setExpAndRound((o=(p=$mul64((new $Int64(0,e.mant.$length)),new $Int64(0,32)),new $Int64(h.$high+p.$high,h.$low+p.$low)),q=AZ(e.mant),new $Int64(o.$high-q.$high,o.$low-q.$low)),0);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.usub};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.usub=function(c,d){return this.$val.usub(c,d);};AS.ptr.prototype.umul=function(c,d){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){BC(c,d);}h=(f=(new $Int64(0,c.exp)),g=(new $Int64(0,d.exp)),new $Int64(f.$high+g.$high,f.$low+g.$low));if(c===d){e.mant=e.mant.sqr(c.mant);}else{e.mant=e.mant.mul(c.mant,d.mant);}$r=e.setExpAndRound((i=AZ(e.mant),new $Int64(h.$high-i.$high,h.$low-i.$low)),0);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.umul};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.umul=function(c,d){return this.$val.umul(c,d);};AS.ptr.prototype.uquo=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){BC(c,d);}g=(((f=e.prec/32,(f===f&&f!==1/0&&f!==-1/0)?f>>>0:$throwRuntimeError("integer divide by zero"))>>0))+1>>0;h=c.mant;i=(g-c.mant.$length>>0)+d.mant.$length>>0;if(i>0){h=$makeSlice(BX,(c.mant.$length+i>>0));$copySlice($subslice(h,i),c.mant);}j=h.$length-d.mant.$length>>0;k=BX.nil;m=e.mant.div(BX.nil,h,d.mant);$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;e.mant=l[0];k=l[1];r=(n=(o=(new $Int64(0,c.exp)),p=(new $Int64(0,d.exp)),new $Int64(o.$high-p.$high,o.$low-p.$low)),q=$mul64((new $Int64(0,(j-e.mant.$length>>0))),new $Int64(0,32)),new $Int64(n.$high-q.$high,n.$low-q.$low));s=0;if(k.$length>0){s=1;}$r=e.setExpAndRound((t=AZ(e.mant),new $Int64(r.$high-t.$high,r.$low-t.$low)),s);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.uquo};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.uquo=function(c,d){return this.$val.uquo(c,d);};AS.ptr.prototype.ucmp=function(c){var c,d,e,f,g,h,i,j,k,l;d=this;if(false){BC(d,c);}if(d.expc.exp){return 1;}e=d.mant.$length;f=c.mant.$length;while(true){if(!(e>0||f>0)){break;}g=0;h=0;i=g;j=h;if(e>0){e=e-(1)>>0;i=(k=d.mant,((e<0||e>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+e]));}if(f>0){f=f-(1)>>0;j=(l=c.mant,((f<0||f>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+f]));}if(ij){return 1;}}return 0;};AS.prototype.ucmp=function(c){return this.$val.ucmp(c);};AS.ptr.prototype.Add=function(c,d){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=d.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.prec===0){e.prec=BD(c.prec,d.prec);}if((c.form===1)&&(d.form===1)){$s=5;continue;}$s=6;continue;case 5:f=d.neg;e.neg=c.neg;if(c.neg===f){$s=7;continue;}$s=8;continue;case 7:$r=e.uadd(c,d);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=9;continue;case 8:if(c.ucmp(d)>0){$s=11;continue;}$s=12;continue;case 11:$r=e.usub(c,d);$s=14;case 14:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=13;continue;case 12:e.neg=!e.neg;$r=e.usub(d,c);$s=15;case 15:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 13:case 9:if((e.form===0)&&(e.mode===4)&&(e.acc===0)){e.neg=true;}$s=-1;return e;case 6:if((c.form===2)&&(d.form===2)&&!(c.neg===d.neg)){e.acc=0;e.form=0;e.neg=false;$panic((g=new AT.ptr("addition of infinities with opposite signs"),new g.constructor.elem(g)));}if((c.form===0)&&(d.form===0)){e.acc=0;e.form=0;e.neg=c.neg&&d.neg;$s=-1;return e;}if((c.form===2)||(d.form===0)){$s=16;continue;}$s=17;continue;case 16:h=e.Set(c);$s=18;case 18:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;case 17:i=e.Set(d);$s=19;case 19:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$s=-1;return i;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Add};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Add=function(c,d){return this.$val.Add(c,d);};AS.ptr.prototype.Sub=function(c,d){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=d.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.prec===0){e.prec=BD(c.prec,d.prec);}if((c.form===1)&&(d.form===1)){$s=5;continue;}$s=6;continue;case 5:f=d.neg;e.neg=c.neg;if(!(c.neg===f)){$s=7;continue;}$s=8;continue;case 7:$r=e.uadd(c,d);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=9;continue;case 8:if(c.ucmp(d)>0){$s=11;continue;}$s=12;continue;case 11:$r=e.usub(c,d);$s=14;case 14:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=13;continue;case 12:e.neg=!e.neg;$r=e.usub(d,c);$s=15;case 15:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 13:case 9:if((e.form===0)&&(e.mode===4)&&(e.acc===0)){e.neg=true;}$s=-1;return e;case 6:if((c.form===2)&&(d.form===2)&&c.neg===d.neg){e.acc=0;e.form=0;e.neg=false;$panic((g=new AT.ptr("subtraction of infinities with equal signs"),new g.constructor.elem(g)));}if((c.form===0)&&(d.form===0)){e.acc=0;e.form=0;e.neg=c.neg&&!d.neg;$s=-1;return e;}if((c.form===2)||(d.form===0)){$s=16;continue;}$s=17;continue;case 16:h=e.Set(c);$s=18;case 18:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;case 17:i=e.Neg(d);$s=19;case 19:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$s=-1;return i;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Sub};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Sub=function(c,d){return this.$val.Sub(c,d);};AS.ptr.prototype.Mul=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=d.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.prec===0){e.prec=BD(c.prec,d.prec);}e.neg=!(c.neg===d.neg);if((c.form===1)&&(d.form===1)){$s=5;continue;}$s=6;continue;case 5:$r=e.umul(c,d);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return e;case 6:e.acc=0;if((c.form===0)&&(d.form===2)||(c.form===2)&&(d.form===0)){e.form=0;e.neg=false;$panic((f=new AT.ptr("multiplication of zero with infinity"),new f.constructor.elem(f)));}if((c.form===2)||(d.form===2)){e.form=2;$s=-1;return e;}e.form=0;$s=-1;return e;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Mul};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Mul=function(c,d){return this.$val.Mul(c,d);};AS.ptr.prototype.Quo=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=d.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.prec===0){e.prec=BD(c.prec,d.prec);}e.neg=!(c.neg===d.neg);if((c.form===1)&&(d.form===1)){$s=5;continue;}$s=6;continue;case 5:$r=e.uquo(c,d);$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return e;case 6:e.acc=0;if((c.form===0)&&(d.form===0)||(c.form===2)&&(d.form===2)){e.form=0;e.neg=false;$panic((f=new AT.ptr("division of zero by zero or infinity by infinity"),new f.constructor.elem(f)));}if((c.form===0)||(d.form===2)){e.form=0;$s=-1;return e;}e.form=2;$s=-1;return e;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Quo};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Quo=function(c,d){return this.$val.Quo(c,d);};AS.ptr.prototype.Cmp=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=d.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=c.validate();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:e=d.ord();f=c.ord();if(ef){$s=-1;return 1;}g=e;if(g===(-1)){$s=-1;return c.ucmp(d);}else if(g===(1)){$s=-1;return d.ucmp(c);}$s=-1;return 0;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Cmp};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Cmp=function(c){return this.$val.Cmp(c);};AS.ptr.prototype.ord=function(){var c,d,e;c=this;d=0;e=c.form;if(e===(1)){d=1;}else if(e===(0)){return 0;}else if(e===(2)){d=2;}if(c.neg){d=-d;}return d;};AS.prototype.ord=function(){return this.$val.ord();};BD=function(c,d){var c,d;if(c>d){return c;}return d;};AS.ptr.prototype.SetString=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;f=d.Parse(c,0);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[0];h=e[2];if($interfaceIsEqual(h,$ifaceNil)){$s=-1;return[g,true];}$s=-1;return[DS.nil,false];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.SetString};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.SetString=function(c){return this.$val.SetString(c);};AS.ptr.prototype.scan=function(c,d){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=DS.nil;f=0;g=$ifaceNil;h=this;i=h.prec;if(i===0){i=64;}h.form=0;k=BV(c);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;h.neg=j[0];g=j[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[e,f,g];}l=0;n=h.mant.scan(c,d,true);$s=2;case 2:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;h.mant=m[0];f=m[1];l=m[2];g=m[3];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[e,f,g];}o=new $Int64(0,0);p=0;r=DI(c,true);$s=3;case 3:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;o=q[0];p=q[1];g=q[2];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[e,f,g];}if(h.mant.$length===0){h.prec=i;h.acc=0;h.form=0;e=h;$s=-1;return[e,f,g];}u=(s=$mul64((new $Int64(0,h.mant.$length)),new $Int64(0,32)),t=AZ(h.mant),new $Int64(s.$high-t.$high,s.$low-t.$low));v=new $Int64(0,0);if(l<0){w=(new $Int64(0,l));x=f;if(x===(10)){v=w;u=(y=w,new $Int64(u.$high+y.$high,u.$low+y.$low));}else if(x===(2)){u=(z=w,new $Int64(u.$high+z.$high,u.$low+z.$low));}else if(x===(16)){u=(aa=$mul64(w,new $Int64(0,4)),new $Int64(u.$high+aa.$high,u.$low+aa.$low));}else{$panic(new $String("unexpected mantissa base"));}}ab=p;if(ab===(10)){v=(ac=o,new $Int64(v.$high+ac.$high,v.$low+ac.$low));u=(ad=o,new $Int64(u.$high+ad.$high,u.$low+ad.$low));}else if(ab===(2)){u=(ae=o,new $Int64(u.$high+ae.$high,u.$low+ae.$low));}else{$panic(new $String("unexpected exponent base"));}if((-1>31)*4294967296))>>0));e=h;$s=6;continue;case 5:af=C.Errorf("exponent overflow",new DN([]));$s=7;case 7:if($c){$c=false;af=af.$blk();}if(af&&af.$blk!==undefined){break s;}g=af;$s=-1;return[e,f,g];case 6:if((v.$high===0&&v.$low===0)){$s=8;continue;}$s=9;continue;case 8:$r=h.round(0);$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return[e,f,g];case 9:ag=new AS.ptr(0,0,0,0,false,BX.nil,0).SetPrec(h.Prec()+64>>>0);$s=11;case 11:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}ah=ag;if((v.$high<0||(v.$high===0&&v.$low<0))){$s=12;continue;}$s=13;continue;case 12:ai=h;ak=ah.pow5(((aj=new $Int64(-v.$high,-v.$low),new $Uint64(aj.$high,aj.$low))));$s=15;case 15:if($c){$c=false;ak=ak.$blk();}if(ak&&ak.$blk!==undefined){break s;}al=ak;am=h.Quo(ai,al);$s=16;case 16:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}am;$s=14;continue;case 13:an=h;ao=ah.pow5((new $Uint64(v.$high,v.$low)));$s=17;case 17:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}ap=ao;aq=h.Mul(an,ap);$s=18;case 18:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}aq;case 14:$s=-1;return[e,f,g];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.scan};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.scan=function(c,d){return this.$val.scan(c,d);};AS.ptr.prototype.pow5=function(c){var c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if((c.$high<0||(c.$high===0&&c.$low<=27))){$s=1;continue;}$s=2;continue;case 1:e=d.SetUint64((($flatten64(c)<0||$flatten64(c)>=BF.length)?($throwRuntimeError("index out of range"),undefined):BF[$flatten64(c)]));$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;case 2:f=d.SetUint64(BF[27]);$s=4;case 4:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}f;c=(g=new $Uint64(0,27),new $Uint64(c.$high-g.$high,c.$low-g.$low));h=new AS.ptr(0,0,0,0,false,BX.nil,0).SetPrec(d.Prec()+64>>>0);$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h.SetUint64(new $Uint64(0,5));$s=6;case 6:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;case 7:if(!((c.$high>0||(c.$high===0&&c.$low>0)))){$s=8;continue;}if(!((k=new $Uint64(c.$high&0,(c.$low&1)>>>0),(k.$high===0&&k.$low===0)))){$s=9;continue;}$s=10;continue;case 9:l=d.Mul(d,j);$s=11;case 11:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;case 10:m=j.Mul(j,j);$s=12;case 12:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;c=$shiftRightUint64(c,(1));$s=7;continue;case 8:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.pow5};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.pow5=function(c){return this.$val.pow5(c);};AS.ptr.prototype.Parse=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=DS.nil;f=0;g=$ifaceNil;h=this;if((c.length===3)&&(c==="Inf"||c==="inf")){e=h.SetInf(false);$s=-1;return[e,f,g];}if((c.length===4)&&((c.charCodeAt(0)===43)||(c.charCodeAt(0)===45))&&($substring(c,1)==="Inf"||$substring(c,1)==="inf")){e=h.SetInf(c.charCodeAt(0)===45);$s=-1;return[e,f,g];}i=F.NewReader(c);k=h.scan(i,d);$s=1;case 1:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;e=j[0];f=j[1];g=j[2];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[e,f,g];}l=i.ReadByte();m=l[0];n=l[1];if($interfaceIsEqual(n,$ifaceNil)){$s=2;continue;}if(!($interfaceIsEqual(n,E.EOF))){$s=3;continue;}$s=4;continue;case 2:o=C.Errorf("expected end of string, found %q",new DN([new $Uint8(m)]));$s=5;case 5:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}g=o;$s=4;continue;case 3:g=n;case 4:$s=-1;return[e,f,g];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Parse};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Parse=function(c,d){return this.$val.Parse(c,d);};AS.ptr.prototype.Scan=function(c,d){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;$r=c.SkipSpace();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}h=e.scan((g=new BW.ptr(c),new g.constructor.elem(g)),0);$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}f=h;i=f[2];$s=-1;return i;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Scan};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Scan=function(c,d){return this.$val.Scan(c,d);};AS.ptr.prototype.GobEncode=function(){var c,d,e,f,g,h;c=this;if(c===DS.nil){return[DR.nil,$ifaceNil];}d=6;e=0;if(c.form===1){e=(((f=((c.prec+31>>>0))/32,(f===f&&f!==1/0&&f!==-1/0)?f>>>0:$throwRuntimeError("integer divide by zero"))>>0));if(c.mant.$length>0))>>0;}g=$makeSlice(DR,d);(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]=1);h=((((((((c.mode&7)>>>0)<<24>>>24))<<5<<24>>>24)|((((((c.acc+1<<24>>24))&3)<<24>>>24))<<3<<24>>>24))>>>0)|(((((c.form&3)>>>0)<<24>>>24))<<1<<24>>>24))>>>0;if(c.neg){h=(h|(1))>>>0;}(1>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+1]=h);$clone(G.BigEndian,G.bigEndian).PutUint32($subslice(g,2),c.prec);if(c.form===1){$clone(G.BigEndian,G.bigEndian).PutUint32($subslice(g,6),((c.exp>>>0)));$subslice(c.mant,(c.mant.$length-e>>0)).bytes($subslice(g,10));}return[g,$ifaceNil];};AS.prototype.GobEncode=function(){return this.$val.GobEncode();};AS.ptr.prototype.GobDecode=function(c){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.$length===0){AS.copy(d,new AS.ptr(0,0,0,0,false,BX.nil,0));$s=-1;return $ifaceNil;}if(!(((0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0])===1))){$s=1;continue;}$s=2;continue;case 1:e=C.Errorf("Float.GobDecode: encoding version %d not supported",new DN([new $Uint8((0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]))]));$s=3;case 3:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;case 2:f=d.prec;g=d.mode;h=(1>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+1]);d.mode=((((((h>>>5<<24>>>24))&7)>>>0)<<24>>>24));d.acc=((((((h>>>3<<24>>>24))&3)>>>0)<<24>>24))-1<<24>>24;d.form=((((((h>>>1<<24>>>24))&3)>>>0)<<24>>>24));d.neg=!((((h&1)>>>0)===0));d.prec=$clone(G.BigEndian,G.bigEndian).Uint32($subslice(c,2));if(d.form===1){d.exp=(($clone(G.BigEndian,G.bigEndian).Uint32($subslice(c,6))>>0));d.mant=d.mant.setBytes($subslice(c,10));}if(!((f===0))){$s=4;continue;}$s=5;continue;case 4:d.mode=g;i=d.SetPrec(((f>>>0)));$s=6;case 6:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;case 5:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.GobDecode};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.GobDecode=function(c){return this.$val.GobDecode(c);};AS.ptr.prototype.MarshalText=function(){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=DR.nil;d=$ifaceNil;e=this;if(e===DS.nil){f=(new DR($stringToBytes("")));g=$ifaceNil;c=f;d=g;$s=-1;return[c,d];}h=DR.nil;j=e.Append(h,103,-1);$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=$ifaceNil;c=i;d=k;$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.MarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.MarshalText=function(){return this.$val.MarshalText();};AS.ptr.prototype.UnmarshalText=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;f=d.Parse(($bytesToString(c)),0);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[2];if(!($interfaceIsEqual(g,$ifaceNil))){$s=2;continue;}$s=3;continue;case 2:h=C.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)",new DN([c,g]));$s=4;case 4:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;case 3:$s=-1;return g;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.UnmarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.UnmarshalText=function(c){return this.$val.UnmarshalText(c);};AS.ptr.prototype.Text=function(c,d){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=10;if(d>0){f=f+(d)>>0;}g=e.Append($makeSlice(DR,0,f),c,d);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return($bytesToString(g));}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Text};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Text=function(c,d){return this.$val.Text(c,d);};AS.ptr.prototype.String=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.Text(103,10);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.String};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.String=function(){return this.$val.String();};AS.ptr.prototype.Append=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=[f];g=this;if(g.neg){c=$append(c,45);}if(g.form===2){if(!g.neg){c=$append(c,43);}$s=-1;return $appendSlice(c,"Inf");}h=d;if(h===(98)){$s=2;continue;}if(h===(112)){$s=3;continue;}$s=4;continue;case 2:i=g.fmtB(c);$s=5;case 5:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$s=-1;return i;case 3:j=g.fmtP(c);$s=6;case 6:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$s=-1;return j;case 4:case 1:f[0]=new AN.ptr(DR.nil,0);if(g.form===1){$s=7;continue;}$s=8;continue;case 7:$r=f[0].init(g.mant,((g.exp>>0))-g.mant.bitLen()>>0);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 8:k=false;if(e<0){$s=10;continue;}$s=11;continue;case 10:k=true;$r=BH(f[0],g);$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=d;if((l===(101))||(l===(69))){e=f[0].mant.$length-1>>0;}else if(l===(102)){e=CI(f[0].mant.$length-f[0].exp>>0,0);}else if((l===(103))||(l===(71))){e=f[0].mant.$length;}$s=12;continue;case 11:m=d;if((m===(101))||(m===(69))){f[0].round(1+e>>0);}else if(m===(102)){f[0].round(f[0].exp+e>>0);}else if((m===(103))||(m===(71))){if(e===0){e=1;}f[0].round(e);}case 12:n=d;if((n===(101))||(n===(69))){$s=-1;return BI(c,d,e,$clone(f[0],AN));}else if(n===(102)){$s=-1;return BJ(c,e,$clone(f[0],AN));}else if((n===(103))||(n===(71))){o=e;if(o>f[0].mant.$length&&f[0].mant.$length>=f[0].exp){o=f[0].mant.$length;}if(k){o=6;}p=f[0].exp-1>>0;if(p<-4||p>=o){if(e>f[0].mant.$length){e=f[0].mant.$length;}$s=-1;return BI(c,(d+101<<24>>>24)-103<<24>>>24,e-1>>0,$clone(f[0],AN));}if(e>f[0].exp){e=f[0].mant.$length;}$s=-1;return BJ(c,CI(e-f[0].exp>>0,0),$clone(f[0],AN));}if(g.neg){c=$subslice(c,0,(c.$length-1>>0));}$s=-1;return $append(c,37,d);}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Append};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Append=function(c,d,e){return this.$val.Append(c,d,e);};BH=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(c.mant.$length===0){$s=-1;return;}e=(BX.nil).set(d.mant);f=((d.exp>>0))-e.bitLen()>>0;g=e.bitLen()-(((d.prec+1>>>0)>>0))>>0;if(g<0){e=e.shl(e,((-g>>>0)));}else if(g>0){e=e.shr(e,((g>>>0)));}f=f+(g)>>0;h=new AN.ptr(DR.nil,0);i=BX.nil;$r=h.init(i.sub(e,BY),f);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}j=new AN.ptr(DR.nil,0);$r=j.init(i.add(e,BY),f);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}k=(((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])&2)>>>0)===0;l=c.mant;m=0;while(true){if(!(m=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]);p=h.at(n);q=j.at(n);r=!((p===o))||k&&((n+1>>0)===h.mant.$length);s=!((o===q))&&(k||(o+1<<24>>>24)>0)>0);$s=-1;return;}else if(r){c.roundDown(n+1>>0);$s=-1;return;}else if(s){c.roundUp(n+1>>0);$s=-1;return;}m++;}$s=-1;return;}return;}if($f===undefined){$f={$blk:BH};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};BI=function(c,d,e,f){var c,d,e,f,g,h,i,j,k,l;g=48;if(f.mant.$length>0){g=(h=f.mant,(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0]));}c=$append(c,g);if(e>0){c=$append(c,46);i=1;j=BK(f.mant.$length,e+1>>0);if(i>0;}}c=$append(c,d);k=new $Int64(0,0);if(f.mant.$length>0){k=(l=(new $Int64(0,f.exp)),new $Int64(l.$high-0,l.$low-1));}if((k.$high<0||(k.$high===0&&k.$low<0))){g=45;k=new $Int64(-k.$high,-k.$low);}else{g=43;}c=$append(c,g);if((k.$high<0||(k.$high===0&&k.$low<10))){c=$append(c,48);}return A.AppendInt(c,k,10);};BJ=function(c,d,e){var c,d,e,f,g;if(e.exp>0){f=BK(e.mant.$length,e.exp);c=$appendSlice(c,$subslice(e.mant,0,f));while(true){if(!(f>0;}}else{c=$append(c,48);}if(d>0){c=$append(c,46);g=0;while(true){if(!(g>0));g=g+(1)>>0;}}return c;};AS.ptr.prototype.fmtB=function(c){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(d.form===0){$s=-1;return $append(c,48);}if(false&&!((d.form===1))){$panic(new $String("non-finite float"));}e=d.mant;f=$imul(((d.mant.$length>>>0)),32)>>>0;if(f>>0)>>>0)));}else if(f>d.prec){e=(BX.nil).shr(e,(((f-d.prec>>>0)>>>0)));}g=c;h=e.utoa(10);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;c=$appendSlice(g,i);c=$append(c,112);l=(j=(new $Int64(0,d.exp)),k=(new $Int64(0,d.prec)),new $Int64(j.$high-k.$high,j.$low-k.$low));if((l.$high>0||(l.$high===0&&l.$low>=0))){c=$append(c,43);}$s=-1;return A.AppendInt(c,l,10);}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.fmtB};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.fmtB=function(c){return this.$val.fmtB(c);};AS.ptr.prototype.fmtP=function(c){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(d.form===0){$s=-1;return $append(c,48);}if(false&&!((d.form===1))){$panic(new $String("non-finite float"));}e=d.mant;f=0;while(true){if(!(f=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f])===0))){break;}f=f+(1)>>0;}e=$subslice(e,f);c=$appendSlice(c,"0x.");g=c;h=e.utoa(16);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=H.TrimRight(h,"0");$s=2;case 2:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;c=$appendSlice(g,j);c=$append(c,112);if(d.exp>=0){c=$append(c,43);}$s=-1;return A.AppendInt(c,(new $Int64(0,d.exp)),10);}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.fmtP};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.fmtP=function(c){return this.$val.fmtP(c);};BK=function(c,d){var c,d;if(c>>24)),h);$s=11;case 11:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;if(p.$length===0){p=(new DR($stringToBytes("?")));}r="";if(((0>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+0])===45)){$s=13;continue;}if(((0>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+0])===43)){$s=14;continue;}s=c.Flag(43);$s=18;case 18:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}if(s){$s=15;continue;}t=c.Flag(32);$s=19;case 19:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}if(t){$s=16;continue;}$s=17;continue;case 13:r="-";p=$subslice(p,1);$s=17;continue;case 14:r="+";u=c.Flag(32);$s=22;case 22:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}if(u){$s=20;continue;}$s=21;continue;case 20:r=" ";case 21:p=$subslice(p,1);$s=17;continue;case 15:r="+";$s=17;continue;case 16:r=" ";case 17:case 12:v=0;x=c.Width();$s=23;case 23:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}w=x;y=w[0];z=w[1];if(z&&y>(r.length+p.$length>>0)){v=(y-r.length>>0)-p.$length>>0;}aa=c.Flag(48);$s=29;case 29:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}if(aa&&!e.IsInf()){$s=25;continue;}ab=c.Flag(45);$s=30;case 30:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}if(ab){$s=26;continue;}$s=27;continue;case 25:$r=BU(c,r,1);$s=31;case 31:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=BU(c,"0",v);$s=32;case 32:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ac=c.Write(p);$s=33;case 33:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ac;$s=28;continue;case 26:$r=BU(c,r,1);$s=34;case 34:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ad=c.Write(p);$s=35;case 35:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ad;$r=BU(c," ",v);$s=36;case 36:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=28;continue;case 27:$r=BU(c," ",v);$s=37;case 37:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=BU(c,r,1);$s=38;case 38:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ae=c.Write(p);$s=39;case 39:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ae;case 28:case 24:$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Format};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Format=function(c,d){return this.$val.Format(c,d);};BL.ptr.prototype.Sign=function(){var c;c=this;if(c.abs.$length===0){return 0;}if(c.neg){return-1;}return 1;};BL.prototype.Sign=function(){return this.$val.Sign();};BL.ptr.prototype.SetInt64=function(c){var c,d,e;d=this;e=false;if((c.$high<0||(c.$high===0&&c.$low<0))){e=true;c=new $Int64(-c.$high,-c.$low);}d.abs=d.abs.setUint64((new $Uint64(c.$high,c.$low)));d.neg=e;return d;};BL.prototype.SetInt64=function(c){return this.$val.SetInt64(c);};BL.ptr.prototype.SetUint64=function(c){var c,d;d=this;d.abs=d.abs.setUint64(c);d.neg=false;return d;};BL.prototype.SetUint64=function(c){return this.$val.SetUint64(c);};BN=function(c){var c;return new BL.ptr(false,BX.nil).SetInt64(c);};$pkg.NewInt=BN;BL.ptr.prototype.Set=function(c){var c,d;d=this;if(!(d===c)){d.abs=d.abs.set(c.abs);d.neg=c.neg;}return d;};BL.prototype.Set=function(c){return this.$val.Set(c);};BL.ptr.prototype.Bits=function(){var c,d;c=this;return(d=c.abs,$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length));};BL.prototype.Bits=function(){return this.$val.Bits();};BL.ptr.prototype.SetBits=function(c){var c,d;d=this;d.abs=($subslice(new BX(c.$array),c.$offset,c.$offset+c.$length)).norm();d.neg=false;return d;};BL.prototype.SetBits=function(c){return this.$val.SetBits(c);};BL.ptr.prototype.Abs=function(c){var c,d;d=this;d.Set(c);d.neg=false;return d;};BL.prototype.Abs=function(c){return this.$val.Abs(c);};BL.ptr.prototype.Neg=function(c){var c,d;d=this;d.Set(c);d.neg=d.abs.$length>0&&!d.neg;return d;};BL.prototype.Neg=function(c){return this.$val.Neg(c);};BL.ptr.prototype.Add=function(c,d){var c,d,e,f;e=this;f=c.neg;if(c.neg===d.neg){e.abs=e.abs.add(c.abs,d.abs);}else{if(c.abs.cmp(d.abs)>=0){e.abs=e.abs.sub(c.abs,d.abs);}else{f=!f;e.abs=e.abs.sub(d.abs,c.abs);}}e.neg=e.abs.$length>0&&f;return e;};BL.prototype.Add=function(c,d){return this.$val.Add(c,d);};BL.ptr.prototype.Sub=function(c,d){var c,d,e,f;e=this;f=c.neg;if(!(c.neg===d.neg)){e.abs=e.abs.add(c.abs,d.abs);}else{if(c.abs.cmp(d.abs)>=0){e.abs=e.abs.sub(c.abs,d.abs);}else{f=!f;e.abs=e.abs.sub(d.abs,c.abs);}}e.neg=e.abs.$length>0&&f;return e;};BL.prototype.Sub=function(c,d){return this.$val.Sub(c,d);};BL.ptr.prototype.Mul=function(c,d){var c,d,e;e=this;if(c===d){e.abs=e.abs.sqr(c.abs);e.neg=false;return e;}e.abs=e.abs.mul(c.abs,d.abs);e.neg=e.abs.$length>0&&!(c.neg===d.neg);return e;};BL.prototype.Mul=function(c,d){return this.$val.Mul(c,d);};BL.ptr.prototype.MulRange=function(c,d){var c,d,e,f,g,h,i,j;e=this;if((c.$high>d.$high||(c.$high===d.$high&&c.$low>d.$low))){return e.SetInt64(new $Int64(0,1));}else if((c.$high<0||(c.$high===0&&c.$low<=0))&&(d.$high>0||(d.$high===0&&d.$low>=0))){return e.SetInt64(new $Int64(0,0));}f=false;if((c.$high<0||(c.$high===0&&c.$low<0))){f=(g=(h=new $Int64(d.$high-c.$high,d.$low-c.$low),new $Int64(h.$high&0,(h.$low&1)>>>0)),(g.$high===0&&g.$low===0));i=new $Int64(-d.$high,-d.$low);j=new $Int64(-c.$high,-c.$low);c=i;d=j;}e.abs=e.abs.mulRange((new $Uint64(c.$high,c.$low)),(new $Uint64(d.$high,d.$low)));e.neg=f;return e;};BL.prototype.MulRange=function(c,d){return this.$val.MulRange(c,d);};BL.ptr.prototype.Binomial=function(c,d){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=[f];g=this;if((h=$div64(c,new $Int64(0,2),false),(h.$high0&&!(c.neg===d.neg);$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Quo};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Quo=function(c,d){return this.$val.Quo(c,d);};BL.ptr.prototype.Rem=function(c,d){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;g=(BX.nil).div(e.abs,c.abs,d.abs);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;e.abs=f[1];e.neg=e.abs.$length>0&&c.neg;$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Rem};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Rem=function(c,d){return this.$val.Rem(c,d);};BL.ptr.prototype.QuoRem=function(c,d,e){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;h=f.abs.div(e.abs,c.abs,d.abs);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;f.abs=g[0];e.abs=g[1];i=f.abs.$length>0&&!(c.neg===d.neg);j=e.abs.$length>0&&c.neg;f.neg=i;e.neg=j;$s=-1;return[f,e];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.QuoRem};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.QuoRem=function(c,d,e){return this.$val.QuoRem(c,d,e);};BL.ptr.prototype.Div=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=this;g=d.neg;e[0]=new BL.ptr(false,BX.nil);h=f.QuoRem(c,d,e[0]);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;if(e[0].neg){if(g){f.Add(f,BM);}else{f.Sub(f,BM);}}$s=-1;return f;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Div};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Div=function(c,d){return this.$val.Div(c,d);};BL.ptr.prototype.Mod=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=d;if(e===d||CG(e.abs,d.abs)){f=new BL.ptr(false,BX.nil).Set(d);}g=new BL.ptr(false,BX.nil);h=g.QuoRem(c,d,e);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;if(e.neg){if(f.neg){e.Sub(e,f);}else{e.Add(e,f);}}$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Mod};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Mod=function(c,d){return this.$val.Mod(c,d);};BL.ptr.prototype.DivMod=function(c,d,e){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;g=d;if(f===d||CG(f.abs,d.abs)){g=new BL.ptr(false,BX.nil).Set(d);}h=f.QuoRem(c,d,e);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;if(e.neg){if(g.neg){f.Add(f,BM);e.Sub(e,g);}else{f.Sub(f,BM);e.Add(e,g);}}$s=-1;return[f,e];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.DivMod};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.DivMod=function(c,d,e){return this.$val.DivMod(c,d,e);};BL.ptr.prototype.Cmp=function(c){var c,d,e;d=0;e=this;if(e.neg===c.neg){d=e.abs.cmp(c.abs);if(e.neg){d=-d;}}else if(e.neg){d=-1;}else{d=1;}return d;};BL.prototype.Cmp=function(c){return this.$val.Cmp(c);};BL.ptr.prototype.CmpAbs=function(c){var c,d;d=this;return d.abs.cmp(c.abs);};BL.prototype.CmpAbs=function(c){return this.$val.CmpAbs(c);};BO=function(c){var c;if(c.$length===0){return 0;}return(((0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0])>>>0));};BP=function(c){var c,d,e,f,g;if(c.$length===0){return new $Uint64(0,0);}e=((d=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]),new $Uint64(0,d.constructor===Number?d:1)));if(true&&c.$length>1){return(f=$shiftLeft64(((g=(1>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+1]),new $Uint64(0,g.constructor===Number?g:1))),32),new $Uint64(f.$high|e.$high,(f.$low|e.$low)>>>0));}return e;};BL.ptr.prototype.Int64=function(){var c,d,e;c=this;e=((d=BP(c.abs),new $Int64(d.$high,d.$low)));if(c.neg){e=new $Int64(-e.$high,-e.$low);}return e;};BL.prototype.Int64=function(){return this.$val.Int64();};BL.ptr.prototype.Uint64=function(){var c;c=this;return BP(c.abs);};BL.prototype.Uint64=function(){return this.$val.Uint64();};BL.ptr.prototype.IsInt64=function(){var c,d,e,f;c=this;if(c.abs.$length<=2){e=((d=BP(c.abs),new $Int64(d.$high,d.$low)));return(e.$high>0||(e.$high===0&&e.$low>=0))||c.neg&&(f=new $Int64(-e.$high,-e.$low),(e.$high===f.$high&&e.$low===f.$low));}return false;};BL.prototype.IsInt64=function(){return this.$val.IsInt64();};BL.ptr.prototype.IsUint64=function(){var c;c=this;return!c.neg&&c.abs.$length<=2;};BL.prototype.IsUint64=function(){return this.$val.IsUint64();};BL.ptr.prototype.SetString=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=e.setFromScanner(F.NewReader(c),d);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.SetString};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.SetString=function(c,d){return this.$val.SetString(c,d);};BL.ptr.prototype.setFromScanner=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;g=e.scan(c,d);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[2];if(!($interfaceIsEqual(h,$ifaceNil))){$s=-1;return[DU.nil,false];}j=c.ReadByte();$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[1];if(!($interfaceIsEqual(k,E.EOF))){$s=-1;return[DU.nil,false];}$s=-1;return[e,true];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.setFromScanner};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.setFromScanner=function(c,d){return this.$val.setFromScanner(c,d);};BL.ptr.prototype.SetBytes=function(c){var c,d;d=this;d.abs=d.abs.setBytes(c);d.neg=false;return d;};BL.prototype.SetBytes=function(c){return this.$val.SetBytes(c);};BL.ptr.prototype.Bytes=function(){var c,d;c=this;d=$makeSlice(DR,($imul(c.abs.$length,4)));return $subslice(d,c.abs.bytes(d));};BL.prototype.Bytes=function(){return this.$val.Bytes();};BL.ptr.prototype.BitLen=function(){var c;c=this;return c.abs.bitLen();};BL.prototype.BitLen=function(){return this.$val.BitLen();};BL.ptr.prototype.Exp=function(c,d,e){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;g=c.abs;if(d.neg){$s=1;continue;}$s=2;continue;case 1:if(e===DU.nil||(e.abs.$length===0)){$s=-1;return f.SetInt64(new $Int64(0,1));}h=new BL.ptr(false,BX.nil).ModInverse(c,e);$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h.abs;case 2:i=d.abs;j=BX.nil;if(!(e===DU.nil)){j=e.abs;}k=f.abs.expNN(g,i,j);$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}f.abs=k;f.neg=f.abs.$length>0&&c.neg&&i.$length>0&&((((0>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+0])&1)>>>0)===1);if(f.neg&&j.$length>0){f.abs=f.abs.sub(j,f.abs);f.neg=false;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Exp};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Exp=function(c,d,e){return this.$val.Exp(c,d,e);};BL.ptr.prototype.GCD=function(c,d,e,f){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;if(e.Sign()<=0||f.Sign()<=0){g.SetInt64(new $Int64(0,0));if(!(c===DU.nil)){c.SetInt64(new $Int64(0,0));}if(!(d===DU.nil)){d.SetInt64(new $Int64(0,0));}$s=-1;return g;}h=g.lehmerGCD(c,d,e,f);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.GCD};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.GCD=function(c,d,e,f){return this.$val.GCD(c,d,e,f);};BQ=function(c,d){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;e=0;f=0;g=0;h=0;i=false;j=0;k=0;l=0;m=0;n=j;o=k;p=l;q=m;r=d.abs.$length;s=c.abs.$length;v=R((t=c.abs,u=s-1>>0,((u<0||u>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u])));n=(((w=v,w<32?((x=c.abs,y=s-1>>0,((y<0||y>=x.$length)?($throwRuntimeError("index out of range"),undefined):x.$array[x.$offset+y]))<>>0)|((z=((32-v>>>0)),z<32?((aa=c.abs,ab=s-2>>0,((ab<0||ab>=aa.$length)?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+ab]))>>>z):0)>>>0))>>>0;if((s===r)){o=(((ac=v,ac<32?((ad=d.abs,ae=s-1>>0,((ae<0||ae>=ad.$length)?($throwRuntimeError("index out of range"),undefined):ad.$array[ad.$offset+ae]))<>>0)|((af=((32-v>>>0)),af<32?((ag=d.abs,ah=s-2>>0,((ah<0||ah>=ag.$length)?($throwRuntimeError("index out of range"),undefined):ag.$array[ag.$offset+ah]))>>>af):0)>>>0))>>>0;}else if((s===(r+1>>0))){o=(ai=((32-v>>>0)),ai<32?((aj=d.abs,ak=s-2>>0,((ak<0||ak>=aj.$length)?($throwRuntimeError("index out of range"),undefined):aj.$array[aj.$offset+ak]))>>>ai):0)>>>0;}else{o=0;}i=false;al=0;am=1;an=0;e=al;f=am;p=an;ao=0;ap=0;aq=1;g=ao;h=ap;q=aq;while(true){if(!(o>=q&&(n-o>>>0)>=(h+q>>>0))){break;}ar=(as=n/o,(as===as&&as!==1/0&&as!==-1/0)?as>>>0:$throwRuntimeError("integer divide by zero"));at=(au=n%o,au===au?au:$throwRuntimeError("integer divide by zero"));av=ar;aw=at;ax=o;ay=aw;n=ax;o=ay;az=f;ba=p;bb=f+($imul(av,p)>>>0)>>>0;e=az;f=ba;p=bb;bc=h;bd=q;be=h+($imul(av,q)>>>0)>>>0;g=bc;h=bd;q=be;i=!i;}return[e,f,g,h,i];};BR=function(c,d,e,f,g,h,i,j,k,l,m){var c,d,e,f,g,h,i,j,k,l,m;h.abs=h.abs.setWord(i);g.abs=g.abs.setWord(k);h.neg=!m;g.neg=m;h.Mul(c,h);g.Mul(d,g);f.abs=f.abs.setWord(j);e.abs=e.abs.setWord(l);f.neg=m;e.neg=!m;f.Mul(c,f);e.Mul(d,e);c.Add(h,g);d.Add(f,e);};BS=function(c,d,e,f,g,h,i,j,k){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:m=g.QuoRem(c,d,h);$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;g=l[0];h=l[1];n=$clone(d,BL);o=$clone(h,BL);p=$clone(c,BL);BL.copy(c,n);BL.copy(d,o);BL.copy(h,p);if(k){j.Set(f);i.Mul(f,g);f.Sub(e,i);e.Set(j);}$s=-1;return;}return;}if($f===undefined){$f={$blk:BS};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};BL.ptr.prototype.lehmerGCD=function(c,d,e,f){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;h=DU.nil;i=DU.nil;j=DU.nil;k=DU.nil;l=h;m=i;n=j;o=k;l=new BL.ptr(false,BX.nil).Set(e);m=new BL.ptr(false,BX.nil).Set(f);p=!(c===DU.nil)||!(d===DU.nil);if(p){n=new BL.ptr(false,BX.nil).SetInt64(new $Int64(0,1));o=new BL.ptr(false,BX.nil);}q=new BL.ptr(false,BX.nil);r=new BL.ptr(false,BX.nil);s=new BL.ptr(false,BX.nil);t=new BL.ptr(false,BX.nil);if(l.abs.cmp(m.abs)<0){u=m;v=l;l=u;m=v;w=n;x=o;o=w;n=x;}case 1:if(!(m.abs.$length>1)){$s=2;continue;}y=BQ(l,m);z=y[0];aa=y[1];ab=y[2];ac=y[3];ad=y[4];if(!((ab===0))){$s=3;continue;}$s=4;continue;case 3:BR(l,m,q,r,s,t,z,aa,ab,ac,ad);if(p){BR(n,o,q,r,s,t,z,aa,ab,ac,ad);}$s=5;continue;case 4:$r=BS(l,m,n,o,q,r,s,t,p);$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 5:$s=1;continue;case 2:if(m.abs.$length>0){$s=7;continue;}$s=8;continue;case 7:if(l.abs.$length>1){$s=9;continue;}$s=10;continue;case 9:$r=BS(l,m,n,o,q,r,s,t,p);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 10:if(m.abs.$length>0){ae=(af=l.abs,(0>=af.$length?($throwRuntimeError("index out of range"),undefined):af.$array[af.$offset+0]));ag=(ah=m.abs,(0>=ah.$length?($throwRuntimeError("index out of range"),undefined):ah.$array[ah.$offset+0]));ai=ae;aj=ag;if(p){ak=0;al=0;am=0;an=0;ao=ak;ap=al;aq=am;ar=an;as=1;at=0;ao=as;ap=at;au=0;av=1;aq=au;ar=av;aw=true;while(true){if(!(!((aj===0)))){break;}ax=(ay=ai/aj,(ay===ay&&ay!==1/0&&ay!==-1/0)?ay>>>0:$throwRuntimeError("integer divide by zero"));az=(ba=ai%aj,ba===ba?ba:$throwRuntimeError("integer divide by zero"));bb=ax;bc=az;bd=aj;be=bc;ai=bd;aj=be;bf=ap;bg=ao+($imul(bb,ap)>>>0)>>>0;ao=bf;ap=bg;bh=ar;bi=aq+($imul(bb,ar)>>>0)>>>0;aq=bh;ar=bi;aw=!aw;}t.abs=t.abs.setWord(ao);s.abs=s.abs.setWord(aq);t.neg=!aw;s.neg=aw;t.Mul(n,t);s.Mul(o,s);n.Add(t,s);}else{while(true){if(!(!((aj===0)))){break;}bj=aj;bk=(bl=ai%aj,bl===bl?bl:$throwRuntimeError("integer divide by zero"));ai=bj;aj=bk;}}(bm=l.abs,(0>=bm.$length?($throwRuntimeError("index out of range"),undefined):bm.$array[bm.$offset+0]=ai));}case 8:if(!(c===DU.nil)){BL.copy(c,n);}if(!(d===DU.nil)){$s=12;continue;}$s=13;continue;case 12:d.Mul(e,n);d.Sub(l,d);bn=d.Div(d,f);$s=14;case 14:if($c){$c=false;bn=bn.$blk();}if(bn&&bn.$blk!==undefined){break s;}bn;case 13:BL.copy(g,l);$s=-1;return g;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.lehmerGCD};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.lehmerGCD=function(c,d,e,f){return this.$val.lehmerGCD(c,d,e,f);};BL.ptr.prototype.Rand=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;e.neg=false;if(d.neg||(d.abs.$length===0)){e.abs=BX.nil;$s=-1;return e;}f=e.abs.random(c,d.abs,d.abs.bitLen());$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e.abs=f;$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Rand};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Rand=function(c,d){return this.$val.Rand(c,d);};BL.ptr.prototype.ModInverse=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=this;if(d.neg){g=new BL.ptr(false,BX.nil);d=g.Neg(d);}if(c.neg){$s=1;continue;}$s=2;continue;case 1:h=new BL.ptr(false,BX.nil);i=h.Mod(c,d);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}c=i;case 2:j=new BL.ptr(false,BX.nil);k=new BL.ptr(false,BX.nil);l=$clone(j,BL);e[0]=$clone(k,BL);m=l.GCD(e[0],DU.nil,c,d);$s=4;case 4:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;if(!((l.Cmp(BM)===0))){$s=-1;return DU.nil;}if(e[0].neg){f.Add(e[0],d);}else{f.Set(e[0]);}$s=-1;return f;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.ModInverse};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.ModInverse=function(c,d){return this.$val.ModInverse(c,d);};BT=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=[f];g=[g];if((d.abs.$length===0)||((((h=d.abs,(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0]))&1)>>>0)===0)){$s=1;continue;}$s=2;continue;case 1:i=C.Sprintf("big: invalid 2nd argument to Int.Jacobi: need odd integer but got %s",new DN([d]));$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$panic(new $String(i));case 2:j=new BL.ptr(false,BX.nil);k=new BL.ptr(false,BX.nil);l=new BL.ptr(false,BX.nil);e[0]=$clone(j,BL);f[0]=$clone(k,BL);g[0]=$clone(l,BL);e[0].Set(c);f[0].Set(d);m=1;if(f[0].neg){if(e[0].neg){m=-1;}f[0].neg=false;}case 4:if(f[0].Cmp(BM)===0){$s=-1;return m;}if(e[0].abs.$length===0){$s=-1;return 0;}n=e[0].Mod(e[0],f[0]);$s=6;case 6:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}n;if(e[0].abs.$length===0){$s=-1;return 0;}o=e[0].abs.trailingZeroBits();if(!((((o&1)>>>0)===0))){q=((p=f[0].abs,(0>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+0]))&7)>>>0;if((q===3)||(q===5)){m=-m;}}g[0].Rsh(e[0],o);if(((((r=f[0].abs,(0>=r.$length?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+0]))&3)>>>0)===3)&&((((s=g[0].abs,(0>=s.$length?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+0]))&3)>>>0)===3)){m=-m;}e[0].Set(f[0]);f[0].Set(g[0]);$s=4;continue;case 5:$s=-1;return 0;}return;}if($f===undefined){$f={$blk:BT};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Jacobi=BT;BL.ptr.prototype.modSqrt3Mod4Prime=function(c,d){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=new BL.ptr(false,BX.nil).Add(d,BM);f.Rsh(f,2);g=e.Exp(c,f,d);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}g;$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.modSqrt3Mod4Prime};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.modSqrt3Mod4Prime=function(c,d){return this.$val.modSqrt3Mod4Prime(c,d);};BL.ptr.prototype.modSqrt5Mod8Prime=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=new BL.ptr(false,BX.nil).Rsh(d,3);g=new BL.ptr(false,BX.nil).Lsh(c,1);h=new BL.ptr(false,BX.nil).Exp(g,f,d);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;j=new BL.ptr(false,BX.nil).Mul(i,i);k=j.Mod(j,d);$s=2;case 2:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}k;j.Mul(j,g);l=j.Mod(j,d);$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;j.Sub(j,BM);j.Mul(j,c);m=j.Mod(j,d);$s=4;case 4:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;j.Mul(j,i);n=e.Mod(j,d);$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}n;$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.modSqrt5Mod8Prime};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.modSqrt5Mod8Prime=function(c,d){return this.$val.modSqrt5Mod8Prime(c,d);};BL.ptr.prototype.modSqrtTonelliShanks=function(c,d){var aa,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=[e];f=[f];g=[g];h=[h];i=[i];j=[j];k=this;h[0]=new BL.ptr(false,BX.nil);h[0].Sub(d,BM);l=h[0].abs.trailingZeroBits();h[0].Rsh(h[0],l);g[0]=new BL.ptr(false,BX.nil);g[0].SetInt64(new $Int64(0,2));case 1:m=BT(g[0],d);$s=3;case 3:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}if(!(!((m===-1)))){$s=2;continue;}g[0].Add(g[0],BM);$s=1;continue;case 2:n=new BL.ptr(false,BX.nil);o=new BL.ptr(false,BX.nil);p=new BL.ptr(false,BX.nil);q=new BL.ptr(false,BX.nil);j[0]=$clone(n,BL);e[0]=$clone(o,BL);f[0]=$clone(p,BL);i[0]=$clone(q,BL);j[0].Add(h[0],BM);j[0].Rsh(j[0],1);r=j[0].Exp(c,j[0],d);$s=4;case 4:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}r;s=e[0].Exp(c,h[0],d);$s=5;case 5:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}s;t=f[0].Exp(g[0],h[0],d);$s=6;case 6:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}t;u=l;case 7:v=0;i[0].Set(e[0]);case 9:if(!(!((i[0].Cmp(BM)===0)))){$s=10;continue;}w=i[0].Mul(i[0],i[0]).Mod(i[0],d);$s=11;case 11:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}w;v=v+(1)>>>0;$s=9;continue;case 10:if(v===0){$s=-1;return k.Set(j[0]);}x=i[0].SetInt64(new $Int64(0,0)).SetBit(i[0],((((u-v>>>0)-1>>>0)>>0)),1).Exp(f[0],i[0],d);$s=12;case 12:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}x;y=f[0].Mul(i[0],i[0]).Mod(f[0],d);$s=13;case 13:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}y;z=j[0].Mul(j[0],i[0]).Mod(j[0],d);$s=14;case 14:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}z;aa=e[0].Mul(e[0],f[0]).Mod(e[0],d);$s=15;case 15:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}aa;u=v;$s=7;continue;case 8:$s=-1;return DU.nil;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.modSqrtTonelliShanks};}$f.aa=aa;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.modSqrtTonelliShanks=function(c,d){return this.$val.modSqrtTonelliShanks(c,d);};BL.ptr.prototype.ModSqrt=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=BT(c,d);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(g===(-1)){$s=-1;return DU.nil;}else if(g===(0)){$s=-1;return e.SetInt64(new $Int64(0,0));}else if(g===(1)){$s=1;continue;}case 1:if(c.neg||c.Cmp(d)>=0){$s=3;continue;}$s=4;continue;case 3:h=new BL.ptr(false,BX.nil).Mod(c,d);$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}c=h;case 4:if(((i=(j=d.abs,(0>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+0]))%4,i===i?i:$throwRuntimeError("integer divide by zero"))===3)){$s=7;continue;}if(((k=(l=d.abs,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0]))%8,k===k?k:$throwRuntimeError("integer divide by zero"))===5)){$s=8;continue;}$s=9;continue;case 7:m=e.modSqrt3Mod4Prime(c,d);$s=11;case 11:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return m;case 8:n=e.modSqrt5Mod8Prime(c,d);$s=12;case 12:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}$s=-1;return n;case 9:o=e.modSqrtTonelliShanks(c,d);$s=13;case 13:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}$s=-1;return o;case 10:case 6:$s=-1;return DU.nil;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.ModSqrt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.ModSqrt=function(c,d){return this.$val.ModSqrt(c,d);};BL.ptr.prototype.Lsh=function(c,d){var c,d,e;e=this;e.abs=e.abs.shl(c.abs,d);e.neg=c.neg;return e;};BL.prototype.Lsh=function(c,d){return this.$val.Lsh(c,d);};BL.ptr.prototype.Rsh=function(c,d){var c,d,e,f;e=this;if(c.neg){f=e.abs.sub(c.abs,BY);f=f.shr(f,d);e.abs=f.add(f,BY);e.neg=true;return e;}e.abs=e.abs.shr(c.abs,d);e.neg=false;return e;};BL.prototype.Rsh=function(c,d){return this.$val.Rsh(c,d);};BL.ptr.prototype.Bit=function(c){var c,d,e,f;d=this;if(c===0){if(d.abs.$length>0){return(((((e=d.abs,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]))&1)>>>0)>>>0));}return 0;}if(c<0){$panic(new $String("negative bit index"));}if(d.neg){f=(BX.nil).sub(d.abs,BY);return(f.bit(((c>>>0)))^1)>>>0;}return d.abs.bit(((c>>>0)));};BL.prototype.Bit=function(c){return this.$val.Bit(c);};BL.ptr.prototype.SetBit=function(c,d,e){var c,d,e,f,g;f=this;if(d<0){$panic(new $String("negative bit index"));}if(c.neg){g=f.abs.sub(c.abs,BY);g=g.setBit(g,((d>>>0)),(e^1)>>>0);f.abs=g.add(g,BY);f.neg=f.abs.$length>0;return f;}f.abs=f.abs.setBit(c.abs,((d>>>0)),e);f.neg=false;return f;};BL.prototype.SetBit=function(c,d,e){return this.$val.SetBit(c,d,e);};BL.ptr.prototype.And=function(c,d){var c,d,e,f,g,h,i,j;e=this;if(c.neg===d.neg){if(c.neg){f=(BX.nil).sub(c.abs,BY);g=(BX.nil).sub(d.abs,BY);e.abs=e.abs.add(e.abs.or(f,g),BY);e.neg=true;return e;}e.abs=e.abs.and(c.abs,d.abs);e.neg=false;return e;}if(c.neg){h=d;i=c;c=h;d=i;}j=(BX.nil).sub(d.abs,BY);e.abs=e.abs.andNot(c.abs,j);e.neg=false;return e;};BL.prototype.And=function(c,d){return this.$val.And(c,d);};BL.ptr.prototype.AndNot=function(c,d){var c,d,e,f,g,h,i;e=this;if(c.neg===d.neg){if(c.neg){f=(BX.nil).sub(c.abs,BY);g=(BX.nil).sub(d.abs,BY);e.abs=e.abs.andNot(g,f);e.neg=false;return e;}e.abs=e.abs.andNot(c.abs,d.abs);e.neg=false;return e;}if(c.neg){h=(BX.nil).sub(c.abs,BY);e.abs=e.abs.add(e.abs.or(h,d.abs),BY);e.neg=true;return e;}i=(BX.nil).sub(d.abs,BY);e.abs=e.abs.and(c.abs,i);e.neg=false;return e;};BL.prototype.AndNot=function(c,d){return this.$val.AndNot(c,d);};BL.ptr.prototype.Or=function(c,d){var c,d,e,f,g,h,i,j;e=this;if(c.neg===d.neg){if(c.neg){f=(BX.nil).sub(c.abs,BY);g=(BX.nil).sub(d.abs,BY);e.abs=e.abs.add(e.abs.and(f,g),BY);e.neg=true;return e;}e.abs=e.abs.or(c.abs,d.abs);e.neg=false;return e;}if(c.neg){h=d;i=c;c=h;d=i;}j=(BX.nil).sub(d.abs,BY);e.abs=e.abs.add(e.abs.andNot(j,c.abs),BY);e.neg=true;return e;};BL.prototype.Or=function(c,d){return this.$val.Or(c,d);};BL.ptr.prototype.Xor=function(c,d){var c,d,e,f,g,h,i,j;e=this;if(c.neg===d.neg){if(c.neg){f=(BX.nil).sub(c.abs,BY);g=(BX.nil).sub(d.abs,BY);e.abs=e.abs.xor(f,g);e.neg=false;return e;}e.abs=e.abs.xor(c.abs,d.abs);e.neg=false;return e;}if(c.neg){h=d;i=c;c=h;d=i;}j=(BX.nil).sub(d.abs,BY);e.abs=e.abs.add(e.abs.xor(c.abs,j),BY);e.neg=true;return e;};BL.prototype.Xor=function(c,d){return this.$val.Xor(c,d);};BL.ptr.prototype.Not=function(c){var c,d;d=this;if(c.neg){d.abs=d.abs.sub(c.abs,BY);d.neg=false;return d;}d.abs=d.abs.add(c.abs,BY);d.neg=true;return d;};BL.prototype.Not=function(c){return this.$val.Not(c);};BL.ptr.prototype.Sqrt=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.neg){$panic(new $String("square root of negative number"));}d.neg=false;e=d.abs.sqrt(c.abs);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d.abs=e;$s=-1;return d;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Sqrt};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Sqrt=function(c){return this.$val.Sqrt(c);};BL.ptr.prototype.Text=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(d===DU.nil){$s=-1;return"";}e=d.abs.itoa(d.neg,c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return($bytesToString(e));}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Text};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Text=function(c){return this.$val.Text(c);};BL.ptr.prototype.Append=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(e===DU.nil){$s=-1;return $appendSlice(c,"");}f=c;g=e.abs.itoa(e.neg,d);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;$s=-1;return $appendSlice(f,h);}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Append};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Append=function(c,d){return this.$val.Append(c,d);};BL.ptr.prototype.String=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.Text(10);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.String};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.String=function(){return this.$val.String();};BU=function(c,d,e){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(d.length>0){$s=1;continue;}$s=2;continue;case 1:f=(new DR($stringToBytes(d)));case 3:if(!(e>0)){$s=4;continue;}g=c.Write(f);$s=5;case 5:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}g;e=e-(1)>>0;$s=3;continue;case 4:case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:BU};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BL.ptr.prototype.Format=function(c,d){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=0;g=d;if(g===(98)){$s=2;continue;}if(g===(111)){$s=3;continue;}if((g===(100))||(g===(115))||(g===(118))){$s=4;continue;}if((g===(120))||(g===(88))){$s=5;continue;}$s=6;continue;case 2:f=2;$s=7;continue;case 3:f=8;$s=7;continue;case 4:f=10;$s=7;continue;case 5:f=16;$s=7;continue;case 6:h=c;i=new $Int32(d);j=e.String();$s=8;case 8:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=new $String(j);l=C.Fprintf(h,"%%!%c(big.Int=%s)",new DN([i,k]));$s=9;case 9:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;$s=-1;return;case 7:case 1:if(e===DU.nil){$s=10;continue;}$s=11;continue;case 10:m=C.Fprint(c,new DN([new $String("")]));$s=12;case 12:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;$s=-1;return;case 11:n="";if(e.neg){$s=14;continue;}o=c.Flag(43);$s=18;case 18:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}if(o){$s=15;continue;}p=c.Flag(32);$s=19;case 19:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}if(p){$s=16;continue;}$s=17;continue;case 14:n="-";$s=17;continue;case 15:n="+";$s=17;continue;case 16:n=" ";case 17:case 13:q="";r=c.Flag(35);$s=22;case 22:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}if(r){$s=20;continue;}$s=21;continue;case 20:s=d;if(s===(111)){q="0";}else if(s===(120)){q="0x";}else if(s===(88)){q="0X";}case 21:t=e.abs.utoa(f);$s=23;case 23:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=t;if(d===88){v=u;w=0;while(true){if(!(w=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+w]);if(97<=y&&y<=122){((x<0||x>=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+x]=(65+((y-97<<24>>>24))<<24>>>24));}w++;}}z=0;aa=0;ab=0;ad=c.Precision();$s=24;case 24:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ac=ad;ae=ac[0];af=ac[1];if(af){if(u.$length>0;}else if((u.$length===1)&&((0>=u.$length?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+0])===48)&&(ae===0)){$s=-1;return;}}ag=((n.length+q.length>>0)+aa>>0)+u.$length>>0;ai=c.Width();$s=25;case 25:if($c){$c=false;ai=ai.$blk();}if(ai&&ai.$blk!==undefined){break s;}ah=ai;aj=ah[0];ak=ah[1];if(ak&&ag>0;am=c.Flag(45);$s=33;case 33:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}if(am){$s=29;continue;}an=c.Flag(48);$s=34;case 34:if($c){$c=false;an=an.$blk();}if(an&&an.$blk!==undefined){break s;}if(an&&!af){$s=30;continue;}$s=31;continue;case 29:ab=al;$s=32;continue;case 30:aa=al;$s=32;continue;case 31:z=al;case 32:case 28:case 27:$r=BU(c," ",z);$s=35;case 35:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=BU(c,n,1);$s=36;case 36:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=BU(c,q,1);$s=37;case 37:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=BU(c,"0",aa);$s=38;case 38:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}ao=c.Write(u);$s=39;case 39:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}ao;$r=BU(c," ",ab);$s=40;case 40:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Format};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Format=function(c,d){return this.$val.Format(c,d);};BL.ptr.prototype.scan=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;g=BV(c);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[0];i=f[1];if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[DU.nil,0,i];}k=e.abs.scan(c,d,false);$s=2;case 2:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;e.abs=j[0];d=j[1];i=j[3];if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[DU.nil,d,i];}e.neg=e.abs.$length>0&&h;$s=-1;return[e,d,$ifaceNil];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.scan};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.scan=function(c,d){return this.$val.scan(c,d);};BV=function(c){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=false;e=$ifaceNil;f=0;h=c.ReadByte();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;f=g[0];e=g[1];if(!($interfaceIsEqual(e,$ifaceNil))){i=false;j=e;d=i;e=j;$s=-1;return[d,e];}k=f;if(k===(45)){$s=3;continue;}if(k===(43)){$s=4;continue;}$s=5;continue;case 3:d=true;$s=6;continue;case 4:$s=6;continue;case 5:l=c.UnreadByte();$s=7;case 7:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;case 6:case 2:$s=-1;return[d,e];}return;}if($f===undefined){$f={$blk:BV};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};BW.ptr.prototype.ReadByte=function(){var c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;e=c.ScanState.ReadRune();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;f=d[0];g=d[1];h=d[2];if(!((g===1))&&$interfaceIsEqual(h,$ifaceNil)){$s=2;continue;}$s=3;continue;case 2:i=C.Errorf("invalid rune %#U",new DN([new $Int32(f)]));$s=4;case 4:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;case 3:$s=-1;return[((f<<24>>>24)),h];}return;}if($f===undefined){$f={$blk:BW.ptr.prototype.ReadByte};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};BW.prototype.ReadByte=function(){return this.$val.ReadByte();};BW.ptr.prototype.UnreadByte=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.ScanState.UnreadRune();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:BW.ptr.prototype.UnreadByte};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};BW.prototype.UnreadByte=function(){return this.$val.UnreadByte();};BL.ptr.prototype.Scan=function(c,d){var c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;$r=c.SkipSpace();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=0;g=d;if(g===(98)){f=2;}else if(g===(111)){f=8;}else if(g===(100)){f=10;}else if((g===(120))||(g===(88))){f=16;}else if((g===(115))||(g===(118))){}else{$s=-1;return J.New("Int.Scan: invalid verb");}j=e.scan((i=new BW.ptr(c),new i.constructor.elem(i)),f);$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}h=j;k=h[2];$s=-1;return k;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.Scan};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.Scan=function(c,d){return this.$val.Scan(c,d);};BL.ptr.prototype.GobEncode=function(){var c,d,e,f;c=this;if(c===DU.nil){return[DR.nil,$ifaceNil];}d=$makeSlice(DR,(1+($imul(c.abs.$length,4))>>0));e=c.abs.bytes(d)-1>>0;f=2;if(c.neg){f=(f|(1))>>>0;}((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]=f);return[$subslice(d,e),$ifaceNil];};BL.prototype.GobEncode=function(){return this.$val.GobEncode();};BL.ptr.prototype.GobDecode=function(c){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.$length===0){BL.copy(d,new BL.ptr(false,BX.nil));$s=-1;return $ifaceNil;}e=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]);if(!(((e>>>1<<24>>>24)===1))){$s=1;continue;}$s=2;continue;case 1:f=C.Errorf("Int.GobDecode: encoding version %d not supported",new DN([new $Uint8((e>>>1<<24>>>24))]));$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;case 2:d.neg=!((((e&1)>>>0)===0));d.abs=d.abs.setBytes($subslice(c,1));$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.GobDecode};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.GobDecode=function(c){return this.$val.GobDecode(c);};BL.ptr.prototype.MarshalText=function(){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=DR.nil;d=$ifaceNil;e=this;if(e===DU.nil){f=(new DR($stringToBytes("")));g=$ifaceNil;c=f;d=g;$s=-1;return[c,d];}i=e.abs.itoa(e.neg,10);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=$ifaceNil;c=h;d=j;$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.MarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.MarshalText=function(){return this.$val.MarshalText();};BL.ptr.prototype.UnmarshalText=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;f=d.setFromScanner(H.NewReader(c),0);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[1];if(!g){$s=2;continue;}$s=3;continue;case 2:h=C.Errorf("math/big: cannot unmarshal %q into a *big.Int",new DN([c]));$s=4;case 4:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;case 3:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.UnmarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.UnmarshalText=function(c){return this.$val.UnmarshalText(c);};BL.ptr.prototype.MarshalJSON=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.MarshalText();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.MarshalJSON};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.MarshalJSON=function(){return this.$val.MarshalJSON();};BL.ptr.prototype.UnmarshalJSON=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(($bytesToString(c))==="null"){$s=-1;return $ifaceNil;}e=d.UnmarshalText(c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.UnmarshalJSON};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.UnmarshalJSON=function(c){return this.$val.UnmarshalJSON(c);};BX.prototype.clear=function(){var c,d,e,f;c=this;d=c;e=0;while(true){if(!(e=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=0);e++;}};$ptrType(BX).prototype.clear=function(){return this.$get().clear();};BX.prototype.norm=function(){var c,d,e;c=this;d=c.$length;while(true){if(!(d>0&&((e=d-1>>0,((e<0||e>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e]))===0))){break;}d=d-(1)>>0;}return $subslice(c,0,d);};$ptrType(BX).prototype.norm=function(){return this.$get().norm();};BX.prototype.make=function(c){var c,d;d=this;if(c<=d.$capacity){return $subslice(d,0,c);}if(c===1){return $makeSlice(BX,1);}return $makeSlice(BX,c,(c+4>>0));};$ptrType(BX).prototype.make=function(c){return this.$get().make(c);};BX.prototype.setWord=function(c){var c,d;d=this;if(c===0){return $subslice(d,0,0);}d=d.make(1);(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]=c);return d;};$ptrType(BX).prototype.setWord=function(c){return this.$get().setWord(c);};BX.prototype.setUint64=function(c){var c,d,e,f;d=this;e=((c.$low>>>0));if((f=(new $Uint64(0,e.constructor===Number?e:1)),(f.$high===c.$high&&f.$low===c.$low))){return d.setWord(e);}d=d.make(2);(1>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+1]=(($shiftRightUint64(c,32).$low>>>0)));(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]=((c.$low>>>0)));return d;};$ptrType(BX).prototype.setUint64=function(c){return this.$get().setUint64(c);};BX.prototype.set=function(c){var c,d;d=this;d=d.make(c.$length);$copySlice(d,c);return d;};$ptrType(BX).prototype.set=function(c){return this.$get().set(c);};BX.prototype.add=function(c,d){var c,d,e,f,g,h,i,j,k;e=this;f=c.$length;g=d.$length;if(f>0);i=AE((h=$subslice(e,0,g),$subslice(new DT(h.$array),h.$offset,h.$offset+h.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length));if(f>g){i=AG((j=$subslice(e,g,f),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length)),(k=$subslice(c,g),$subslice(new DT(k.$array),k.$offset,k.$offset+k.$length)),i);}((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]=i);return e.norm();};$ptrType(BX).prototype.add=function(c,d){return this.$get().add(c,d);};BX.prototype.sub=function(c,d){var c,d,e,f,g,h,i,j,k;e=this;f=c.$length;g=d.$length;if(fg){i=AH((j=$subslice(e,g),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length)),(k=$subslice(c,g),$subslice(new DT(k.$array),k.$offset,k.$offset+k.$length)),i);}if(!((i===0))){$panic(new $String("underflow"));}return e.norm();};$ptrType(BX).prototype.sub=function(c,d){return this.$get().sub(c,d);};BX.prototype.cmp=function(c){var c,d,e,f,g,h;d=0;e=this;f=e.$length;g=c.$length;if(!((f===g))||(f===0)){if(fg){d=1;}return d;}h=f-1>>0;while(true){if(!(h>0&&(((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])===((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h])))){break;}h=h-(1)>>0;}if(((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])<((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h])){d=-1;}else if(((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])>((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h])){d=1;}return d;};$ptrType(BX).prototype.cmp=function(c){return this.$get().cmp(c);};BX.prototype.mulAddWW=function(c,d,e){var c,d,e,f,g,h;f=this;g=c.$length;if((g===0)||(d===0)){return f.setWord(e);}f=f.make(g+1>>0);((g<0||g>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]=AK((h=$subslice(f,0,g),$subslice(new DT(h.$array),h.$offset,h.$offset+h.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),d,e));return f.norm();};$ptrType(BX).prototype.mulAddWW=function(c,d,e){return this.$get().mulAddWW(c,d,e);};CB=function(c,d,e){var c,d,e,f,g,h,i,j,k;$subslice(c,0,(d.$length+e.$length>>0)).clear();f=e;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(!((i===0))){(k=d.$length+h>>0,((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k]=AL((j=$subslice(c,h,(h+d.$length>>0)),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length)),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length),i)));}g++;}};BX.prototype.montgomery=function(c,d,e,f,g){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;h=this;if(!((c.$length===g))||!((d.$length===g))||!((e.$length===g))){$panic(new $String("math/big: mismatched montgomery number lengths"));}h=h.make($imul(g,2));h.clear();i=0;j=0;while(true){if(!(j=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+j]);m=AL((l=$subslice(h,j,(g+j>>0)),$subslice(new DT(l.$array),l.$offset,l.$offset+l.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),k);n=$imul(((j<0||j>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+j]),f)>>>0;p=AL((o=$subslice(h,j,(g+j>>0)),$subslice(new DT(o.$array),o.$offset,o.$offset+o.$length)),$subslice(new DT(e.$array),e.$offset,e.$offset+e.$length),n);q=i+m>>>0;r=q+p>>>0;(s=g+j>>0,((s<0||s>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+s]=r));if(q>0;}if(!((i===0))){AF((t=$subslice(h,0,g),$subslice(new DT(t.$array),t.$offset,t.$offset+t.$length)),(u=$subslice(h,g),$subslice(new DT(u.$array),u.$offset,u.$offset+u.$length)),$subslice(new DT(e.$array),e.$offset,e.$offset+e.$length));}else{$copySlice($subslice(h,0,g),$subslice(h,g));}return $subslice(h,0,g);};$ptrType(BX).prototype.montgomery=function(c,d,e,f,g){return this.$get().montgomery(c,d,e,f,g);};CC=function(c,d,e){var c,d,e,f,g,h,i;g=AE((f=$subslice(c,0,e),$subslice(new DT(f.$array),f.$offset,f.$offset+f.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length));if(!((g===0))){AG((h=$subslice(c,e,(e+(e>>1>>0)>>0)),$subslice(new DT(h.$array),h.$offset,h.$offset+h.$length)),(i=$subslice(c,e),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length)),g);}};CD=function(c,d,e){var c,d,e,f,g,h,i;g=AF((f=$subslice(c,0,e),$subslice(new DT(f.$array),f.$offset,f.$offset+f.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length));if(!((g===0))){AH((h=$subslice(c,e,(e+(e>>1>>0)>>0)),$subslice(new DT(h.$array),h.$offset,h.$offset+h.$length)),(i=$subslice(c,e),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length)),g);}};CF=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;f=e.$length;if(!(((f&1)===0))||f>1>>0;h=$subslice(d,g);i=$subslice(d,0,g);j=h;k=i;l=$subslice(e,g);m=$subslice(e,0,g);n=l;o=m;CF(c,k,o);CF($subslice(c,f),j,n);p=1;q=$subslice(c,($imul(2,f)),(($imul(2,f))+g>>0));if(!((AF($subslice(new DT(q.$array),q.$offset,q.$offset+q.$length),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length),$subslice(new DT(k.$array),k.$offset,k.$offset+k.$length))===0))){p=-p;AF($subslice(new DT(q.$array),q.$offset,q.$offset+q.$length),$subslice(new DT(k.$array),k.$offset,k.$offset+k.$length),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length));}r=$subslice(c,(($imul(2,f))+g>>0),($imul(3,f)));if(!((AF($subslice(new DT(r.$array),r.$offset,r.$offset+r.$length),$subslice(new DT(o.$array),o.$offset,o.$offset+o.$length),$subslice(new DT(n.$array),n.$offset,n.$offset+n.$length))===0))){p=-p;AF($subslice(new DT(r.$array),r.$offset,r.$offset+r.$length),$subslice(new DT(n.$array),n.$offset,n.$offset+n.$length),$subslice(new DT(o.$array),o.$offset,o.$offset+o.$length));}s=$subslice(c,($imul(f,3)));CF(s,q,r);t=$subslice(c,($imul(f,4)));$copySlice(t,$subslice(c,0,($imul(f,2))));CC($subslice(c,g),t,f);CC($subslice(c,g),$subslice(t,f),f);if(p>0){CC($subslice(c,g),s,f);}else{CD($subslice(c,g),s,f);}};CG=function(c,d){var c,d,e,f;return c.$capacity>0&&d.$capacity>0&&(e=$subslice(c,0,c.$capacity),$indexPtr(e.$array,e.$offset+(c.$capacity-1>>0),DW))===(f=$subslice(d,0,d.$capacity),$indexPtr(f.$array,f.$offset+(d.$capacity-1>>0),DW));};CH=function(c,d,e){var c,d,e,f,g,h,i,j,k,l;f=d.$length;if(f>0){i=AE((g=$subslice(c,e,(e+f>>0)),$subslice(new DT(g.$array),g.$offset,g.$offset+g.$length)),(h=$subslice(c,e),$subslice(new DT(h.$array),h.$offset,h.$offset+h.$length)),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length));if(!((i===0))){j=e+f>>0;if(jd){return c;}return d;};CJ=function(c,d){var c,d,e,f;e=0;while(true){if(!(c>d)){break;}c=(c>>$min((1),31))>>0;e=e+(1)>>>0;}return(f=e,f<32?(c<>0;};BX.prototype.mul=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p;e=this;f=c.$length;g=d.$length;if(f=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]),0);}if(CG(e,c)||CG(e,d)){e=BX.nil;}if(g>0);CB(e,c,d);return e.norm();}h=CJ(g,CE);i=$subslice(c,0,h);j=$subslice(d,0,h);e=e.make(CI($imul(6,h),f+g>>0));CF(e,i,j);e=$subslice(e,0,(f+g>>0));$subslice(e,($imul(2,h))).clear();if(hh){p=$subslice(p,0,h);}p=p.norm();k=k.mul(p,n);CH(e,k,o);k=k.mul(p,m);CH(e,k,o+h>>0);o=o+(h)>>0;}}return e.norm();};$ptrType(BX).prototype.mul=function(c,d){return this.$get().mul(c,d);};CK=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;e=d.$length;f=$makeSlice(BX,($imul(2,e)));g=AC((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]),(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]));(1>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+1]=g[0]);(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]=g[1]);h=1;while(true){if(!(h=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+h]);j=AC(i,i);(k=($imul(2,h))+1>>0,((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k]=j[0]));(l=$imul(2,h),((l<0||l>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+l]=j[1]));(o=$imul(2,h),((o<0||o>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+o]=AL((m=$subslice(f,h,($imul(2,h))),$subslice(new DT(m.$array),m.$offset,m.$offset+m.$length)),(n=$subslice(d,0,h),$subslice(new DT(n.$array),n.$offset,n.$offset+n.$length)),i)));h=h+(1)>>0;}(r=($imul(2,e))-1>>0,((r<0||r>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+r]=AI((p=$subslice(f,1,(($imul(2,e))-1>>0)),$subslice(new DT(p.$array),p.$offset,p.$offset+p.$length)),(q=$subslice(f,1,(($imul(2,e))-1>>0)),$subslice(new DT(q.$array),q.$offset,q.$offset+q.$length)),1)));AE($subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(f.$array),f.$offset,f.$offset+f.$length));};CL=function(c,d){var c,d,e,f,g,h,i,j,k,l,m;e=d.$length;if(!(((e&1)===0))||e>1>>0;g=$subslice(d,f);h=$subslice(d,0,f);i=g;j=h;CL(c,j);CL($subslice(c,e),i);k=$subslice(c,($imul(2,e)),(($imul(2,e))+f>>0));if(!((AF($subslice(new DT(k.$array),k.$offset,k.$offset+k.$length),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length))===0))){AF($subslice(new DT(k.$array),k.$offset,k.$offset+k.$length),$subslice(new DT(j.$array),j.$offset,j.$offset+j.$length),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length));}l=$subslice(c,($imul(e,3)));CL(l,k);m=$subslice(c,($imul(e,4)));$copySlice(m,$subslice(c,0,($imul(e,2))));CC($subslice(c,f),m,e);CC($subslice(c,f),$subslice(m,e),e);CD($subslice(c,f),l,e);};BX.prototype.sqr=function(c){var c,d,e,f,g,h,i,j,k,l;d=this;e=c.$length;if((e===0)){return $subslice(d,0,0);}else if((e===1)){f=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]);d=d.make(2);g=AC(f,f);(1>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+1]=g[0]);(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]=g[1]);return d.norm();}if(CG(d,c)){d=BX.nil;}if(ed.$high||(c.$high===d.$high&&c.$low>d.$low))){return e.setUint64(new $Uint64(0,1));}else if((c.$high===d.$high&&c.$low===d.$low)){return e.setUint64(c);}else if((f=new $Uint64(c.$high+0,c.$low+1),(f.$high===d.$high&&f.$low===d.$low))){return e.mul((BX.nil).setUint64(c),(BX.nil).setUint64(d));}g=$div64((new $Uint64(c.$high+d.$high,c.$low+d.$low)),new $Uint64(0,2),false);return e.mul((BX.nil).mulRange(c,g),(BX.nil).mulRange(new $Uint64(g.$high+0,g.$low+1),d));};$ptrType(BX).prototype.mulRange=function(c,d){return this.$get().mulRange(c,d);};BX.prototype.divW=function(c,d){var c,d,e,f,g,h;e=BX.nil;f=0;g=this;h=c.$length;if((d===0)){$panic(new $String("division by zero"));}else if((d===1)){e=g.set(c);return[e,f];}else if((h===0)){e=$subslice(g,0,0);return[e,f];}g=g.make(h);f=AM($subslice(new DT(g.$array),g.$offset,g.$offset+g.$length),0,$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),d);e=g.norm();return[e,f];};$ptrType(BX).prototype.divW=function(c,d){return this.$get().divW(c,d);};BX.prototype.div=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BX.nil;g=BX.nil;h=this;if(e.$length===0){$panic(new $String("division by zero"));}if(d.cmp(e)<0){f=$subslice(h,0,0);g=c.set(d);$s=-1;return[f,g];}if(e.$length===1){i=0;j=h.divW(d,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));f=j[0];i=j[1];g=c.setWord(i);$s=-1;return[f,g];}l=h.divLarge(c,d,e);$s=1;case 1:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;f=k[0];g=k[1];$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:BX.prototype.div};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.div=function(c,d,e){return this.$get().div(c,d,e);};CO=function(c){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=DX.nil;e=CQ.Get();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!($interfaceIsEqual(f,$ifaceNil))){d=$assertType(f,DX);}if(d===DX.nil){d=$newDataPointer(BX.nil,DX);}d.$set(d.make(c));$s=-1;return d;}return;}if($f===undefined){$f={$blk:CO};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};CP=function(c){var c;CQ.Put(c);};BX.prototype.divLarge=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BX.nil;g=BX.nil;h=this;i=e.$length;j=d.$length-i>>0;l=R((k=i-1>>0,((k<0||k>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k])));m=CO(i);$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;o=n.$get();AI($subslice(new DT(o.$array),o.$offset,o.$offset+o.$length),$subslice(new DT(e.$array),e.$offset,e.$offset+e.$length),l);c=c.make(d.$length+1>>0);(q=d.$length,((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]=AI((p=$subslice(c,0,d.$length),$subslice(new DT(p.$array),p.$offset,p.$offset+p.$length)),$subslice(new DT(d.$array),d.$offset,d.$offset+d.$length),l)));if(CG(h,c)){h=BX.nil;}f=h.make(j+1>>0);r=CO(i+1>>0);$s=2;case 2:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}s=r;t=s.$get();v=(u=i-1>>0,((u<0||u>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+u]));w=j;while(true){if(!(w>=0)){break;}x=4294967295;z=(y=w+i>>0,((y<0||y>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+y]));if(!((z===v))){aa=0;ab=AD(z,(ac=(w+i>>0)-1>>0,((ac<0||ac>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+ac])),v);x=ab[0];aa=ab[1];ae=(ad=i-2>>0,((ad<0||ad>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+ad]));af=AC(x,ae);ag=af[0];ah=af[1];aj=(ai=(w+i>>0)-2>>0,((ai<0||ai>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+ai]));while(true){if(!(CS(ag,ah,aa,aj))){break;}x=x-(1)>>>0;ak=aa;aa=aa+(v)>>>0;if(aa=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+i]=AK((am=$subslice(t,0,i),$subslice(new DT(am.$array),am.$offset,am.$offset+am.$length)),$subslice(new DT(o.$array),o.$offset,o.$offset+o.$length),x,0));ap=AF((an=$subslice(c,w,(w+t.$length>>0)),$subslice(new DT(an.$array),an.$offset,an.$offset+an.$length)),(ao=$subslice(c,w),$subslice(new DT(ao.$array),ao.$offset,ao.$offset+ao.$length)),$subslice(new DT(t.$array),t.$offset,t.$offset+t.$length));if(!((ap===0))){as=AE((aq=$subslice(c,w,(w+i>>0)),$subslice(new DT(aq.$array),aq.$offset,aq.$offset+aq.$length)),(ar=$subslice(c,w),$subslice(new DT(ar.$array),ar.$offset,ar.$offset+ar.$length)),$subslice(new DT(o.$array),o.$offset,o.$offset+o.$length));at=w+i>>0;((at<0||at>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+at]=(((at<0||at>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+at])+(as)>>>0));x=x-(1)>>>0;}((w<0||w>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+w]=x);w=w-(1)>>0;}CP(n);CP(s);f=f.norm();AJ($subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),l);g=c.norm();au=f;av=g;f=au;g=av;$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:BX.prototype.divLarge};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.divLarge=function(c,d,e){return this.$get().divLarge(c,d,e);};BX.prototype.bitLen=function(){var c,d;c=this;d=c.$length-1>>0;if(d>=0){return($imul(d,32))+B.Len(((((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])>>>0)))>>0;}return 0;};$ptrType(BX).prototype.bitLen=function(){return this.$get().bitLen();};BX.prototype.trailingZeroBits=function(){var c,d;c=this;if(c.$length===0){return 0;}d=0;while(true){if(!(((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])===0)){break;}d=d+(1)>>>0;}return(d*32>>>0)+((B.TrailingZeros(((((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])>>>0)))>>>0))>>>0;};$ptrType(BX).prototype.trailingZeroBits=function(){return this.$get().trailingZeroBits();};CR=function(c,d){var c,d;return(c.$length===d.$length)&&c.$length>0&&$indexPtr(c.$array,c.$offset+0,DW)===$indexPtr(d.$array,d.$offset+0,DW);};BX.prototype.shl=function(c,d){var c,d,e,f,g,h,i,j;e=this;if(d===0){if(CR(e,c)){return e;}if(!CG(e,c)){return e.set(c);}}f=c.$length;if(f===0){return $subslice(e,0,0);}h=f+(((g=d/32,(g===g&&g!==1/0&&g!==-1/0)?g>>>0:$throwRuntimeError("integer divide by zero"))>>0))>>0;e=e.make(h+1>>0);((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]=AI((i=$subslice(e,(h-f>>0),h),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length)),$subslice(new DT(c.$array),c.$offset,c.$offset+c.$length),(j=d%32,j===j?j:$throwRuntimeError("integer divide by zero"))));$subslice(e,0,(h-f>>0)).clear();return e.norm();};$ptrType(BX).prototype.shl=function(c,d){return this.$get().shl(c,d);};BX.prototype.shr=function(c,d){var c,d,e,f,g,h,i,j;e=this;if(d===0){if(CR(e,c)){return e;}if(!CG(e,c)){return e.set(c);}}f=c.$length;h=f-(((g=d/32,(g===g&&g!==1/0&&g!==-1/0)?g>>>0:$throwRuntimeError("integer divide by zero"))>>0))>>0;if(h<=0){return $subslice(e,0,0);}e=e.make(h);AJ($subslice(new DT(e.$array),e.$offset,e.$offset+e.$length),(i=$subslice(c,(f-h>>0)),$subslice(new DT(i.$array),i.$offset,i.$offset+i.$length)),(j=d%32,j===j?j:$throwRuntimeError("integer divide by zero")));return e.norm();};$ptrType(BX).prototype.shr=function(c,d){return this.$get().shr(c,d);};BX.prototype.setBit=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m;f=this;h=(((g=d/32,(g===g&&g!==1/0&&g!==-1/0)?g>>>0:$throwRuntimeError("integer divide by zero"))>>0));k=(i=((j=d%32,j===j?j:$throwRuntimeError("integer divide by zero"))),i<32?(1<>>0;l=c.$length;m=e;if(m===(0)){f=f.make(l);$copySlice(f,c);if(h>=l){return f;}((h<0||h>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+h]=((((h<0||h>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+h])&~(k))>>>0));return f.norm();}else if(m===(1)){if(h>=l){f=f.make(h+1>>0);$subslice(f,l).clear();}else{f=f.make(l);}$copySlice(f,c);((h<0||h>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+h]=((((h<0||h>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+h])|(k))>>>0));return f;}$panic(new $String("set bit is not 0 or 1"));};$ptrType(BX).prototype.setBit=function(c,d,e){return this.$get().setBit(c,d,e);};BX.prototype.bit=function(c){var c,d,e,f,g,h;d=this;f=(e=c/32,(e===e&&e!==1/0&&e!==-1/0)?e>>>0:$throwRuntimeError("integer divide by zero"));if(f>=((d.$length>>>0))){return 0;}return((((((g=((h=c%32,h===h?h:$throwRuntimeError("integer divide by zero"))),g<32?(((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])>>>g):0)>>>0)&1)>>>0)>>>0));};$ptrType(BX).prototype.bit=function(c){return this.$get().bit(c);};BX.prototype.sticky=function(c){var c,d,e,f,g,h,i,j,k;d=this;f=(e=c/32,(e===e&&e!==1/0&&e!==-1/0)?e>>>0:$throwRuntimeError("integer divide by zero"));if(f>=((d.$length>>>0))){if(d.$length===0){return 0;}return 1;}g=$subslice(d,0,f);h=0;while(true){if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);if(!((i===0))){return 1;}h++;}if(!((((j=((32-(k=c%32,k===k?k:$throwRuntimeError("integer divide by zero"))>>>0)),j<32?(((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])<>>0)===0))){return 1;}return 0;};$ptrType(BX).prototype.sticky=function(c){return this.$get().sticky(c);};BX.prototype.and=function(c,d){var c,d,e,f,g,h;e=this;f=c.$length;g=d.$length;if(f>g){f=g;}e=e.make(f);h=0;while(true){if(!(h=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]=((((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h])&((h<0||h>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+h]))>>>0));h=h+(1)>>0;}return e.norm();};$ptrType(BX).prototype.and=function(c,d){return this.$get().and(c,d);};BX.prototype.andNot=function(c,d){var c,d,e,f,g,h;e=this;f=c.$length;g=d.$length;if(g>f){g=f;}e=e.make(f);h=0;while(true){if(!(h=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]=((((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h])&~((h<0||h>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+h]))>>>0));h=h+(1)>>0;}$copySlice($subslice(e,g,f),$subslice(c,g,f));return e.norm();};$ptrType(BX).prototype.andNot=function(c,d){return this.$get().andNot(c,d);};BX.prototype.or=function(c,d){var c,d,e,f,g,h,i,j,k;e=this;f=c.$length;g=d.$length;h=c;if(f=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k]=((((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k])|((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k]))>>>0));k=k+(1)>>0;}$copySlice($subslice(e,g,f),$subslice(h,g,f));return e.norm();};$ptrType(BX).prototype.or=function(c,d){return this.$get().or(c,d);};BX.prototype.xor=function(c,d){var c,d,e,f,g,h,i,j,k;e=this;f=c.$length;g=d.$length;h=c;if(f=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k]=((((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k])^((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k]))>>>0));k=k+(1)>>0;}$copySlice($subslice(e,g,f),$subslice(h,g,f));return e.norm();};$ptrType(BX).prototype.xor=function(c,d){return this.$get().xor(c,d);};CS=function(c,d,e,f){var c,d,e,f;return c>e||(c===e)&&d>f;};BX.prototype.modW=function(c){var c,d,e,f;d=0;e=this;f=BX.nil;f=f.make(e.$length);d=AM($subslice(new DT(f.$array),f.$offset,f.$offset+f.$length),0,$subslice(new DT(e.$array),e.$offset,e.$offset+e.$length),c);return d;};$ptrType(BX).prototype.modW=function(c){return this.$get().modW(c);};BX.prototype.random=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;if(CG(f,d)){f=BX.nil;}f=f.make(d.$length);h=(((g=e%32,g===g?g:$throwRuntimeError("integer divide by zero"))>>>0));if(h===0){h=32;}j=(((((i=h,i<32?(1<>>0))-1>>>0));case 1:k=32;if(k===(32)){$s=4;continue;}if(k===(64)){$s=5;continue;}$s=6;continue;case 4:l=f;m=0;case 8:if(!(m=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+n]=((o>>>0)));m++;$s=8;continue;case 9:$s=7;continue;case 5:p=f;q=0;case 11:if(!(q=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+r]=((((s>>>0))|0)>>>0));q++;$s=11;continue;case 12:$s=7;continue;case 6:$panic(new $String("unknown word size"));case 7:case 3:t=d.$length-1>>0;((t<0||t>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+t]=((((t<0||t>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+t])&(j))>>>0));if(f.cmp(d)<0){$s=2;continue;}$s=1;continue;case 2:$s=-1;return f.norm();}return;}if($f===undefined){$f={$blk:BX.prototype.random};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.random=function(c,d,e){return this.$get().random(c,d,e);};BX.prototype.expNN=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;if(CG(f,c)||CG(f,d)){f=BX.nil;}if((e.$length===1)&&((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])===1)){$s=-1;return f.setWord(0);}if(d.$length===0){$s=-1;return f.setWord(1);}if((d.$length===1)&&((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])===1)&&!((e.$length===0))){$s=1;continue;}$s=2;continue;case 1:h=(BX.nil).div(f,c,e);$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;f=g[1];$s=-1;return f;case 2:if(!((e.$length===0))){f=f.make(e.$length);}f=f.set(c);if(c.cmp(BY)>0&&d.$length>1&&e.$length>0){$s=4;continue;}$s=5;continue;case 4:if((((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])&1)>>>0)===1){$s=6;continue;}$s=7;continue;case 6:i=f.expNNMontgomery(c,d,e);$s=8;case 8:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$s=-1;return i;case 7:j=f.expNNWindowed(c,d,e);$s=9;case 9:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$s=-1;return j;case 5:l=(k=d.$length-1>>0,((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k]));m=R(l)+1>>>0;l=(n=(m),n<32?(l<>>0;o=BX.nil;p=32-((m>>0))>>0;q=BX.nil;r=BX.nil;s=q;t=r;u=0;case 10:if(!(u>>0)===0))){s=s.mul(f,c);x=f;y=s;s=x;f=y;}if(!((e.$length===0))){$s=12;continue;}$s=13;continue;case 12:aa=s.div(t,f,e);$s=14;case 14:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}z=aa;s=z[0];t=z[1];ab=o;ac=f;ad=s;ae=t;s=ab;t=ac;o=ad;f=ae;case 13:l=(af=(1),af<32?(l<>>0;u=u+(1)>>0;$s=10;continue;case 11:ag=d.$length-2>>0;case 15:if(!(ag>=0)){$s=16;continue;}l=((ag<0||ag>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+ag]);ah=0;case 17:if(!(ah<32)){$s=18;continue;}s=s.sqr(f);ai=f;aj=s;s=ai;f=aj;if(!((((l&2147483648)>>>0)===0))){s=s.mul(f,c);ak=f;al=s;s=ak;f=al;}if(!((e.$length===0))){$s=19;continue;}$s=20;continue;case 19:an=s.div(t,f,e);$s=21;case 21:if($c){$c=false;an=an.$blk();}if(an&&an.$blk!==undefined){break s;}am=an;s=am[0];t=am[1];ao=o;ap=f;aq=s;ar=t;s=ao;t=ap;o=aq;f=ar;case 20:l=(as=(1),as<32?(l<>>0;ah=ah+(1)>>0;$s=17;continue;case 18:ag=ag-(1)>>0;$s=15;continue;case 16:$s=-1;return f.norm();}return;}if($f===undefined){$f={$blk:BX.prototype.expNN};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.expNN=function(c,d,e){return this.$get().expNN(c,d,e);};BX.prototype.expNNWindowed=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;g=BX.nil;h=BX.nil;i=g;j=h;k=DY.zero();k[0]=BY;k[1]=c;l=2;case 1:if(!(l<16)){$s=2;continue;}m=$indexPtr(k,(n=l/2,(n===n&&n!==1/0&&n!==-1/0)?n>>0:$throwRuntimeError("integer divide by zero")),DX);o=$indexPtr(k,l,DX);p=$indexPtr(k,(l+1>>0),DX);q=m;r=o;s=p;r.$set(r.sqr(q.$get()));u=i.div(j,r.$get(),e);$s=3;case 3:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}t=u;i=t[0];j=t[1];v=j;w=r.$get();r.$set(v);j=w;s.$set(s.mul(r.$get(),c));y=i.div(j,s.$get(),e);$s=4;case 4:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}x=y;i=x[0];j=x[1];z=j;aa=s.$get();s.$set(z);j=aa;l=l+(2)>>0;$s=1;continue;case 2:f=f.setWord(1);ab=d.$length-1>>0;case 5:if(!(ab>=0)){$s=6;continue;}ac=((ab<0||ab>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+ab]);ad=0;case 7:if(!(ad<32)){$s=8;continue;}if(!((ab===(d.$length-1>>0)))||!((ad===0))){$s=9;continue;}$s=10;continue;case 9:i=i.sqr(f);ae=f;af=i;i=ae;f=af;ah=i.div(j,f,e);$s=11;case 11:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ag=ah;i=ag[0];j=ag[1];ai=j;aj=f;f=ai;j=aj;i=i.sqr(f);ak=f;al=i;i=ak;f=al;an=i.div(j,f,e);$s=12;case 12:if($c){$c=false;an=an.$blk();}if(an&&an.$blk!==undefined){break s;}am=an;i=am[0];j=am[1];ao=j;ap=f;f=ao;j=ap;i=i.sqr(f);aq=f;ar=i;i=aq;f=ar;at=i.div(j,f,e);$s=13;case 13:if($c){$c=false;at=at.$blk();}if(at&&at.$blk!==undefined){break s;}as=at;i=as[0];j=as[1];au=j;av=f;f=au;j=av;i=i.sqr(f);aw=f;ax=i;i=aw;f=ax;az=i.div(j,f,e);$s=14;case 14:if($c){$c=false;az=az.$blk();}if(az&&az.$blk!==undefined){break s;}ay=az;i=ay[0];j=ay[1];ba=j;bb=f;f=ba;j=bb;case 10:i=i.mul(f,(bc=ac>>>28>>>0,((bc<0||bc>=k.length)?($throwRuntimeError("index out of range"),undefined):k[bc])));bd=f;be=i;i=bd;f=be;bg=i.div(j,f,e);$s=15;case 15:if($c){$c=false;bg=bg.$blk();}if(bg&&bg.$blk!==undefined){break s;}bf=bg;i=bf[0];j=bf[1];bh=j;bi=f;f=bh;j=bi;ac=(bj=(4),bj<32?(ac<>>0;ad=ad+(4)>>0;$s=7;continue;case 8:ab=ab-(1)>>0;$s=5;continue;case 6:$s=-1;return f.norm();}return;}if($f===undefined){$f={$blk:BX.prototype.expNNWindowed};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.expNNWindowed=function(c,d,e){return this.$get().expNNWindowed(c,d,e);};BX.prototype.expNNMontgomery=function(c,d,e){var aa,ab,ac,ad,ae,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;g=e.$length;if(c.$length>g){$s=1;continue;}$s=2;continue;case 1:i=(BX.nil).div(BX.nil,c,e);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;c=h[1];case 2:if(c.$length=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])>>>0;l=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])-1>>>0;m=1;while(true){if(!(m<32)){break;}l=$imul(l,(l))>>>0;k=$imul(k,(((l+1>>>0))))>>>0;m=(n=(1),n<32?(m<>0;}k=-k>>>0;o=(BX.nil).setWord(1);p=(BX.nil).shl(o,((($imul(($imul(2,g)),32))>>>0)));r=(BX.nil).div(o,p,e);$s=4;case 4:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;o=q[1];if(o.$length=s.$length?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+0]=1);t=DY.zero();t[0]=t[0].montgomery(s,o,e,k,g);t[1]=t[1].montgomery(c,o,e,k,g);u=2;while(true){if(!(u<16)){break;}((u<0||u>=t.length)?($throwRuntimeError("index out of range"),undefined):t[u]=((u<0||u>=t.length)?($throwRuntimeError("index out of range"),undefined):t[u]).montgomery((v=u-1>>0,((v<0||v>=t.length)?($throwRuntimeError("index out of range"),undefined):t[v])),t[1],e,k,g));u=u+(1)>>0;}f=f.make(g);$copySlice(f,t[0]);p=p.make(g);w=d.$length-1>>0;while(true){if(!(w>=0)){break;}x=((w<0||w>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+w]);y=0;while(true){if(!(y<32)){break;}if(!((w===(d.$length-1>>0)))||!((y===0))){p=p.montgomery(f,f,e,k,g);f=f.montgomery(p,p,e,k,g);p=p.montgomery(f,f,e,k,g);f=f.montgomery(p,p,e,k,g);}p=p.montgomery(f,(z=x>>>28>>>0,((z<0||z>=t.length)?($throwRuntimeError("index out of range"),undefined):t[z])),e,k,g);aa=p;ab=f;f=aa;p=ab;x=(ac=(4),ac<32?(x<>>0;y=y+(4)>>0;}w=w-(1)>>0;}p=p.montgomery(f,s,e,k,g);if(p.cmp(e)>=0){$s=5;continue;}$s=6;continue;case 5:p=p.sub(p,e);if(p.cmp(e)>=0){$s=7;continue;}$s=8;continue;case 7:ae=(BX.nil).div(BX.nil,p,e);$s=9;case 9:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ad=ae;p=ad[1];case 8:case 6:$s=-1;return p.norm();}return;}if($f===undefined){$f={$blk:BX.prototype.expNNMontgomery};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.expNNMontgomery=function(c,d,e){return this.$get().expNNMontgomery(c,d,e);};BX.prototype.bytes=function(c){var c,d,e,f,g,h,i,j;d=0;e=this;d=c.$length;f=e;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);i=0;while(true){if(!(i<4)){break;}d=d-(1)>>0;((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=((h<<24>>>24)));h=(j=(8),j<32?(h>>>j):0)>>>0;i=i+(1)>>0;}g++;}while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])===0))){break;}d=d+(1)>>0;}return d;};$ptrType(BX).prototype.bytes=function(c){return this.$get().bytes(c);};CT=function(c){var c;if(false){return(($clone(G.BigEndian,G.bigEndian).Uint64(c).$low>>>0));}return(($clone(G.BigEndian,G.bigEndian).Uint32(c)>>>0));};BX.prototype.setBytes=function(c){var c,d,e,f,g,h,i,j,k,l;d=this;d=d.make((e=(((c.$length+4>>0)-1>>0))/4,(e===e&&e!==1/0&&e!==-1/0)?e>>0:$throwRuntimeError("integer divide by zero")));f=c.$length;g=0;while(true){if(!(f>=4)){break;}((g<0||g>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g]=CT($subslice(c,(f-4>>0),f)));f=f-(4)>>0;g=g+(1)>>0;}if(f>0){h=0;i=0;while(true){if(!(f>0)){break;}h=(h|(((j=i,j<32?((((k=f-1>>0,((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k]))>>>0))<>>0)))>>>0;f=f-(1)>>0;i=i+(8)>>>0;}(l=d.$length-1>>0,((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l]=h));}return d.norm();};$ptrType(BX).prototype.setBytes=function(c){return this.$get().setBytes(c);};BX.prototype.sqrt=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.cmp(BY)<=0){$s=-1;return d.set(c);}if(CG(d,c)){d=BX.nil;}e=BX.nil;f=BX.nil;g=e;h=f;g=d;g=g.setUint64(new $Uint64(0,1));g=g.shl(g,((((i=c.bitLen()/2,(i===i&&i!==1/0&&i!==-1/0)?i>>0:$throwRuntimeError("integer divide by zero"))+1>>0)>>>0)));j=0;case 1:l=h.div(BX.nil,c,g);$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;h=k[0];h=h.add(h,g);h=h.shr(h,1);if(h.cmp(g)>=0){if((j&1)===0){$s=-1;return g;}$s=-1;return d.set(g);}m=h;n=g;g=m;h=n;j=j+(1)>>0;$s=1;continue;case 2:$s=-1;return BX.nil;}return;}if($f===undefined){$f={$blk:BX.prototype.sqrt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.sqrt=function(c){return this.$get().sqrt(c);};CU=function(c){var c,d,e,f,g,h,i;d=0;e=0;f=c;g=1;d=f;e=g;i=(h=4294967295/c,(h===h&&h!==1/0&&h!==-1/0)?h>>>0:$throwRuntimeError("integer divide by zero"));while(true){if(!(d<=i)){break;}d=$imul(d,(c))>>>0;e=e+(1)>>0;}return[d,e];};CV=function(c,d){var c,d,e;e=0;e=1;while(true){if(!(d>0)){break;}if(!(((d&1)===0))){e=$imul(e,(c))>>>0;}c=$imul(c,(c))>>>0;d=(d>>$min((1),31))>>0;}return e;};BX.prototype.scan=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BX.nil;g=0;h=0;i=$ifaceNil;j=this;k=(d===0)||!e&&2<=d&&d<=62||e&&((d===2)||(d===10)||(d===16));if(!k){$s=1;continue;}$s=2;continue;case 1:l=C.Sprintf("illegal number base %d",new DN([new $Int(d)]));$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$panic(new $String(l));case 2:n=c.ReadByte();$s=4;case 4:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];i=m[1];if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[f,g,h,i];}g=d;if(d===0){$s=5;continue;}$s=6;continue;case 5:g=10;if(o===48){$s=7;continue;}$s=8;continue;case 7:h=1;q=c.ReadByte();$s=10;case 10:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;o=p[0];i=p[1];r=i;if($interfaceIsEqual(r,$ifaceNil)){$s=11;continue;}if($interfaceIsEqual(r,(E.EOF))){$s=12;continue;}$s=13;continue;case 11:if(!e){g=8;}s=o;if((s===(120))||(s===(88))){g=16;}else if((s===(98))||(s===(66))){g=2;}t=g;if((t===(16))||(t===(2))){$s=16;continue;}if(t===(8)){$s=17;continue;}$s=18;continue;case 16:h=0;v=c.ReadByte();$s=19;case 19:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}u=v;o=u[0];i=u[1];if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[f,g,h,i];}$s=18;continue;case 17:h=0;case 18:case 15:$s=14;continue;case 12:f=$subslice(j,0,0);i=$ifaceNil;$s=-1;return[f,g,h,i];case 13:$s=-1;return[f,g,h,i];case 14:case 9:case 8:case 6:j=$subslice(j,0,0);w=((g>>>0));x=CU(w);y=x[0];z=x[1];aa=0;ab=0;ac=-1;case 20:if(e&&(o===46)){$s=22;continue;}$s=23;continue;case 22:e=false;ac=h;ae=c.ReadByte();$s=24;case 24:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ad=ae;o=ad[0];i=ad[1];if(!($interfaceIsEqual(i,$ifaceNil))){if($interfaceIsEqual(i,E.EOF)){i=$ifaceNil;$s=21;continue;}$s=-1;return[f,g,h,i];}case 23:af=0;if(48<=o&&o<=57){af=(((o-48<<24>>>24)>>>0));}else if(97<=o&&o<=122){af=((((o-97<<24>>>24)+10<<24>>>24)>>>0));}else if(65<=o&&o<=90){if(g<=36){af=((((o-65<<24>>>24)+10<<24>>>24)>>>0));}else{af=((((o-65<<24>>>24)+36<<24>>>24)>>>0));}}else{af=63;}if(af>=w){$s=25;continue;}$s=26;continue;case 25:ag=c.UnreadByte();$s=27;case 27:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}ag;$s=21;continue;case 26:h=h+(1)>>0;aa=($imul(aa,w)>>>0)+af>>>0;ab=ab+(1)>>0;if(ab===z){j=j.mulAddWW(j,y,aa);aa=0;ab=0;}ai=c.ReadByte();$s=28;case 28:if($c){$c=false;ai=ai.$blk();}if(ai&&ai.$blk!==undefined){break s;}ah=ai;o=ah[0];i=ah[1];if(!($interfaceIsEqual(i,$ifaceNil))){if($interfaceIsEqual(i,E.EOF)){i=$ifaceNil;$s=21;continue;}$s=-1;return[f,g,h,i];}$s=20;continue;case 21:if(h===0){if((d===0)&&(g===8)){h=1;g=10;}else if(!((d===0))||!((g===8))){i=J.New("syntax error scanning number");}$s=-1;return[f,g,h,i];}if(ab>0){j=j.mulAddWW(j,CV(w,ab),aa);}f=j.norm();if(ac>=0){h=ac-h>>0;}$s=-1;return[f,g,h,i];}return;}if($f===undefined){$f={$blk:BX.prototype.scan};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.scan=function(c,d,e){return this.$get().scan(c,d,e);};BX.prototype.utoa=function(c){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.itoa(false,c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:BX.prototype.utoa};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.utoa=function(c){return this.$get().utoa(c);};BX.prototype.itoa=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(d<2||d>62){$panic(new $String("invalid base"));}if(e.$length===0){$s=-1;return(new DR($stringToBytes("0")));}f=(((e.bitLen())/D.Log2((d))>>0))+1>>0;if(c){f=f+(1)>>0;}g=$makeSlice(DR,f);h=((d>>>0));if(h===((h&(-h>>>0))>>>0)){$s=1;continue;}$s=2;continue;case 1:i=((B.TrailingZeros(((h>>>0)))>>>0));k=((((j=i,j<32?(1<>>0)-1>>>0));l=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);m=32;n=1;while(true){if(!(n=i)){break;}f=f-(1)>>0;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((l&k)>>>0)));l=(o=(i),o<32?(l>>>o):0)>>>0;m=m-(i)>>>0;}if(m===0){l=((n<0||n>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+n]);m=32;}else{l=(l|(((p=m,p<32?(((n<0||n>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+n])<>>0)))>>>0;f=f-(1)>>0;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((l&k)>>>0)));l=(q=((i-m>>>0)),q<32?(((n<0||n>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+n])>>>q):0)>>>0;m=32-((i-m>>>0))>>>0;}n=n+(1)>>0;}while(true){if(!(!((l===0)))){break;}f=f-(1)>>0;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt(((l&k)>>>0)));l=(r=(i),r<32?(l>>>r):0)>>>0;}$s=3;continue;case 2:s=CU(h);t=s[0];u=s[1];v=CZ(e.$length,h,u,t);$s=4;case 4:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}w=v;x=(BX.nil).set(e);$r=x.convertWords(g,h,u,t,w);$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=0;while(true){if(!(((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f])===48)){break;}f=f+(1)>>0;}case 3:if(c){f=f-(1)>>0;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=45);}$s=-1;return $subslice(g,f);}return;}if($f===undefined){$f={$blk:BX.prototype.itoa};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.itoa=function(c,d){return this.$get().itoa(c,d);};BX.prototype.convertWords=function(c,d,e,f,g){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:h=this;if(!(g===DZ.nil)){$s=1;continue;}$s=2;continue;case 1:i=BX.nil;j=g.$length-1>>0;case 3:if(!(h.$length>CW)){$s=4;continue;}k=h.bitLen();l=k>>1>>0;while(true){if(!(j>0&&(m=j-1>>0,((m<0||m>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+m])).nbits>l)){break;}j=j-(1)>>0;}if(((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]).nbits>=k&&((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]).bbb.cmp(h)>=0){j=j-(1)>>0;if(j<0){$panic(new $String("internal inconsistency"));}}o=h.div(i,h,((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]).bbb);$s=5;case 5:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;h=n[0];i=n[1];p=c.$length-((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]).ndigits>>0;$r=i.convertWords($subslice(c,p),d,e,f,$subslice(g,0,j));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=$subslice(c,0,p);$s=3;continue;case 4:case 2:q=c.$length;r=0;if(d===10){while(true){if(!(h.$length>0)){break;}s=h.divW(h,f);h=s[0];r=s[1];t=0;while(true){if(!(t0)){break;}q=q-(1)>>0;v=(u=r/10,(u===u&&u!==1/0&&u!==-1/0)?u>>>0:$throwRuntimeError("integer divide by zero"));((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]=(48+(((r-($imul(v,10)>>>0)>>>0)<<24>>>24))<<24>>>24));r=v;t=t+(1)>>0;}}}else{while(true){if(!(h.$length>0)){break;}w=h.divW(h,f);h=w[0];r=w[1];x=0;while(true){if(!(x0)){break;}q=q-(1)>>0;((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".charCodeAt((y=r%d,y===y?y:$throwRuntimeError("integer divide by zero"))));r=(z=r/(d),(z===z&&z!==1/0&&z!==-1/0)?z>>>0:$throwRuntimeError("integer divide by zero"));x=x+(1)>>0;}}}while(true){if(!(q>0)){break;}q=q-(1)>>0;((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]=48);}$s=-1;return;}return;}if($f===undefined){$f={$blk:BX.prototype.convertWords};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.convertWords=function(c,d,e,f,g){return this.$get().convertWords(c,d,e,f,g);};BX.prototype.expWW=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=e.expNN((BX.nil).setWord(c),(BX.nil).setWord(d),BX.nil);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:BX.prototype.expWW};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.expWW=function(c,d){return this.$get().expWW(c,d);};CZ=function(c,d,e,f){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if((CW===0)||c<=CW){$s=-1;return DZ.nil;}g=1;h=CW;while(true){if(!(h<(c>>1>>0)&&g<64)){break;}g=g+(1)>>0;h=(i=(1),i<32?(h<>0;}j=DZ.nil;if(d===10){CY.Mutex.Lock();j=$subslice(new DZ(CY.table),0,g);}else{j=$makeSlice(DZ,g);}if((k=g-1>>0,((k<0||k>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k])).ndigits===0){$s=1;continue;}$s=2;continue;case 1:l=BX.nil;m=0;case 3:if(!(m=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).ndigits===0){$s=5;continue;}$s=6;continue;case 5:if(m===0){$s=7;continue;}$s=8;continue;case 7:n=(BX.nil).expWW(f,((CW>>>0)));$s=10;case 10:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}(0>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+0]).bbb=n;(0>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+0]).ndigits=$imul(e,CW);$s=9;continue;case 8:((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).bbb=(BX.nil).sqr((o=m-1>>0,((o<0||o>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+o])).bbb);((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).ndigits=$imul(2,(p=m-1>>0,((p<0||p>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+p])).ndigits);case 9:l=(BX.nil).set(((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).bbb);while(true){if(!(AK($subslice(new DT(l.$array),l.$offset,l.$offset+l.$length),$subslice(new DT(l.$array),l.$offset,l.$offset+l.$length),d,0)===0)){break;}((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).bbb=((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).bbb.set(l);((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).ndigits=((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).ndigits+(1)>>0;}((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).nbits=((m<0||m>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+m]).bbb.bitLen();case 6:m=m+(1)>>0;$s=3;continue;case 4:case 2:if(d===10){CY.Mutex.Unlock();}$s=-1;return j;}return;}if($f===undefined){$f={$blk:CZ};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};BL.ptr.prototype.ProbablyPrime=function(c){var aa,ab,ac,ad,ae,af,ag,ah,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c<0){$panic(new $String("negative n for ProbablyPrime"));}if(d.neg||(d.abs.$length===0)){$s=-1;return false;}f=(e=d.abs,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));if((d.abs.$length===1)&&f<64){$s=-1;return!((g=(h=$shiftLeft64(new $Uint64(0,1),f),new $Uint64(673221152&h.$high,(2693408940&h.$low)>>>0)),(g.$high===0&&g.$low===0)));}if(((f&1)>>>0)===0){$s=-1;return false;}i=0;j=0;k=i;l=j;m=32;if(m===(32)){k=((d.abs.modW(4127218095)>>>0));l=((d.abs.modW(3948078067)>>>0));}else if(m===(64)){n=d.abs.modW(820596253);k=(((o=n%4127218095,o===o?o:$throwRuntimeError("integer divide by zero"))>>>0));l=(((p=n%3948078067,p===p?p:$throwRuntimeError("integer divide by zero"))>>>0));}else{$panic(new $String("math/big: invalid word size"));}if(((q=k%3,q===q?q:$throwRuntimeError("integer divide by zero"))===0)||((r=k%5,r===r?r:$throwRuntimeError("integer divide by zero"))===0)||((s=k%7,s===s?s:$throwRuntimeError("integer divide by zero"))===0)||((t=k%11,t===t?t:$throwRuntimeError("integer divide by zero"))===0)||((u=k%13,u===u?u:$throwRuntimeError("integer divide by zero"))===0)||((v=k%17,v===v?v:$throwRuntimeError("integer divide by zero"))===0)||((w=k%19,w===w?w:$throwRuntimeError("integer divide by zero"))===0)||((x=k%23,x===x?x:$throwRuntimeError("integer divide by zero"))===0)||((y=k%37,y===y?y:$throwRuntimeError("integer divide by zero"))===0)||((z=l%29,z===z?z:$throwRuntimeError("integer divide by zero"))===0)||((aa=l%31,aa===aa?aa:$throwRuntimeError("integer divide by zero"))===0)||((ab=l%41,ab===ab?ab:$throwRuntimeError("integer divide by zero"))===0)||((ac=l%43,ac===ac?ac:$throwRuntimeError("integer divide by zero"))===0)||((ad=l%47,ad===ad?ad:$throwRuntimeError("integer divide by zero"))===0)||((ae=l%53,ae===ae?ae:$throwRuntimeError("integer divide by zero"))===0)){$s=-1;return false;}ag=d.abs.probablyPrimeMillerRabin(c+1>>0,true);$s=2;case 2:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}if(!(ag)){af=false;$s=1;continue s;}ah=d.abs.probablyPrimeLucas();$s=3;case 3:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}af=ah;case 1:$s=-1;return af;}return;}if($f===undefined){$f={$blk:BL.ptr.prototype.ProbablyPrime};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};BL.prototype.ProbablyPrime=function(c){return this.$val.ProbablyPrime(c);};BX.prototype.probablyPrimeMillerRabin=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=(BX.nil).sub(e,BY);g=f.trailingZeroBits();h=(BX.nil).shr(f,g);i=(BX.nil).sub(f,BZ);k=I.New(I.NewSource(((j=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),new $Int64(0,j.constructor===Number?j:1)))));l=BX.nil;m=BX.nil;n=BX.nil;o=l;p=m;q=n;r=i.bitLen();s=0;case 1:if(!(s>0))&&d){$s=3;continue;}$s=4;continue;case 3:o=o.set(BZ);$s=5;continue;case 4:t=o.random(k,i,r);$s=6;case 6:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}o=t;o=o.add(o,BZ);case 5:u=p.expNN(o,h,e);$s=7;case 7:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}p=u;if((p.cmp(BY)===0)||(p.cmp(f)===0)){$s=8;continue;}$s=9;continue;case 8:s=s+(1)>>0;$s=1;continue;case 9:v=1;case 10:if(!(v>0;$s=1;continue s;}if(p.cmp(BY)===0){$s=-1;return false;}v=v+(1)>>>0;$s=10;continue;case 11:$s=-1;return false;$s=1;continue;case 2:$s=-1;return true;}return;}if($f===undefined){$f={$blk:BX.prototype.probablyPrimeMillerRabin};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.probablyPrimeMillerRabin=function(c,d){return this.$get().probablyPrimeMillerRabin(c,d);};BX.prototype.probablyPrimeLucas=function(){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if((c.$length===0)||(c.cmp(BY)===0)){$s=-1;return false;}if((((0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0])&1)>>>0)===0){$s=-1;return c.cmp(BZ)===0;}d=3;e=new BX([1]);f=(BX.nil);g=new BL.ptr(false,e);h=new BL.ptr(false,c);case 1:if(d>10000){$s=3;continue;}$s=4;continue;case 3:i=h.String();$s=5;case 5:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$panic(new $String("math/big: internal error: cannot find (D/n) = -1 for "+i));case 4:(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]=(($imul(d,d)>>>0)-4>>>0));j=BT(g,h);$s=6;case 6:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(k===-1){$s=2;continue;}if(k===0){$s=-1;return(c.$length===1)&&((0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0])===(d+2>>>0));}if(d===40){$s=7;continue;}$s=8;continue;case 7:l=f.sqrt(c);$s=9;case 9:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}f=l;f=f.sqr(f);if(f.cmp(c)===0){$s=-1;return false;}case 8:d=d+(1)>>>0;$s=1;continue;case 2:m=(BX.nil).add(c,BY);n=((m.trailingZeroBits()>>0));m=m.shr(m,((n>>>0)));o=(BX.nil).sub(c,BZ);p=(BX.nil).setWord(d);q=(BX.nil).setWord(2);r=(BX.nil).setWord(d);s=(BX.nil);t=(m.bitLen());case 10:if(!(t>=0)){$s=11;continue;}if(!((m.bit(((t>>>0)))===0))){$s=12;continue;}$s=13;continue;case 12:f=f.mul(q,r);f=f.add(f,c);f=f.sub(f,p);v=s.div(q,f,c);$s=15;case 15:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}u=v;s=u[0];q=u[1];f=f.sqr(r);f=f.add(f,o);x=s.div(r,f,c);$s=16;case 16:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}w=x;s=w[0];r=w[1];$s=14;continue;case 13:f=f.mul(q,r);f=f.add(f,c);f=f.sub(f,p);z=s.div(r,f,c);$s=17;case 17:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}y=z;s=y[0];r=y[1];f=f.sqr(q);f=f.add(f,o);ab=s.div(q,f,c);$s=18;case 18:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=ab;s=aa[0];q=aa[1];case 14:t=t-(1)>>0;$s=10;continue;case 11:if((q.cmp(BZ)===0)||(q.cmp(o)===0)){$s=19;continue;}$s=20;continue;case 19:ac=f.mul(q,p);ad=s.shl(r,1);if(ac.cmp(ad)<0){ae=ad;af=ac;ac=ae;ad=af;}ac=ac.sub(ac,ad);ag=r;r=BX.nil;$unused(r);ai=ad.div(ag,ac,c);$s=21;case 21:if($c){$c=false;ai=ai.$blk();}if(ai&&ai.$blk!==undefined){break s;}ah=ai;ad=ah[0];ag=ah[1];if(ag.$length===0){$s=-1;return true;}case 20:aj=0;case 22:if(!(aj<(n-1>>0))){$s=23;continue;}if(q.$length===0){$s=-1;return true;}if((q.$length===1)&&((0>=q.$length?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+0])===2)){$s=-1;return false;}f=f.sqr(q);f=f.sub(f,BZ);al=s.div(q,f,c);$s=24;case 24:if($c){$c=false;al=al.$blk();}if(al&&al.$blk!==undefined){break s;}ak=al;s=ak[0];q=ak[1];aj=aj+(1)>>0;$s=22;continue;case 23:$s=-1;return false;}return;}if($f===undefined){$f={$blk:BX.prototype.probablyPrimeLucas};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BX).prototype.probablyPrimeLucas=function(){return this.$get().probablyPrimeLucas();};DA.ptr.prototype.SetFloat64=function(c){var c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=D.Float64bits(c);f=new $Uint64(e.$high&1048575,(e.$low&4294967295)>>>0);h=(((g=$shiftRightUint64(e,52),new $Uint64(g.$high&0,(g.$low&2047)>>>0)).$low>>0));i=h;if(i===(2047)){$s=-1;return DV.nil;}else if(i===(0)){h=h-(1022)>>0;}else{f=(j=new $Uint64(1048576,0),new $Uint64(f.$high|j.$high,(f.$low|j.$low)>>>0));h=h-(1023)>>0;}k=52-h>>0;while(true){if(!((l=new $Uint64(f.$high&0,(f.$low&1)>>>0),(l.$high===0&&l.$low===0))&&k>0)){break;}f=$shiftRightUint64(f,(1));k=k-(1)>>0;}d.a.SetUint64(f);d.a.neg=c<0;d.b.Set(BM);if(k>0){d.b.Lsh(d.b,((k>>>0)));}else{d.a.Lsh(d.a,((-k>>>0)));}m=d.norm();$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return m;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.SetFloat64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.SetFloat64=function(c){return this.$val.SetFloat64(c);};DC=function(c,d){var aa,ab,ac,ad,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=false;g=c.bitLen();if(g===0){h=0;i=true;e=h;f=i;$s=-1;return[e,f];}j=d.bitLen();if(j===0){$panic(new $String("division by zero"));}k=g-j>>0;l=BX.nil;m=BX.nil;n=l;o=m;n=n.set(c);o=o.set(d);p=25-k>>0;if(p>0){n=n.shl(n,((p>>>0)));}else if(p<0){o=o.shl(o,((-p>>>0)));}q=BX.nil;s=q.div(n,n,o);$s=1;case 1:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}r=s;q=r[0];t=r[1];u=BO(q);v=t.$length>0;if((u>>>25>>>0)===1){if(((u&1)>>>0)===1){v=true;}u=(w=(1),w<32?(u>>>w):0)>>>0;k=k+(1)>>0;}if(!(((u>>>24>>>0)===1))){$s=2;continue;}$s=3;continue;case 2:x=C.Sprintf("expected exactly %d bits of result",new DN([new $Int(25)]));$s=4;case 4:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}$panic(new $String(x));case 3:if(-149<=k&&k<=-126){y=(((-126-((k-1>>0))>>0)>>>0));aa=(u&((((z=y,z<32?(1<>>0)-1>>>0)))>>>0;v=v||!((aa===0));u=(ab=(y),ab<32?(u>>>ab):0)>>>0;k=-125;}f=!v;if(!((((u&1)>>>0)===0))){f=false;if(v||!((((u&2)>>>0)===0))){u=u+(1)>>>0;if(u>=33554432){u=(ac=(1),ac<32?(u>>>ac):0)>>>0;k=k+(1)>>0;}}}u=(ad=(1),ad<32?(u>>>ad):0)>>>0;e=($fround(D.Ldexp((u),k-24>>0)));if(D.IsInf((e),0)){f=false;}$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DC};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};DD=function(c,d){var aa,ab,ac,ad,ae,af,ag,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=0;f=false;g=c.bitLen();if(g===0){h=0;i=true;e=h;f=i;$s=-1;return[e,f];}j=d.bitLen();if(j===0){$panic(new $String("division by zero"));}k=g-j>>0;l=BX.nil;m=BX.nil;n=l;o=m;n=n.set(c);o=o.set(d);p=54-k>>0;if(p>0){n=n.shl(n,((p>>>0)));}else if(p<0){o=o.shl(o,((-p>>>0)));}q=BX.nil;s=q.div(n,n,o);$s=1;case 1:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}r=s;q=r[0];t=r[1];u=BP(q);v=t.$length>0;if((w=$shiftRightUint64(u,54),(w.$high===0&&w.$low===1))){if((x=new $Uint64(u.$high&0,(u.$low&1)>>>0),(x.$high===0&&x.$low===1))){v=true;}u=$shiftRightUint64(u,(1));k=k+(1)>>0;}if(!((y=$shiftRightUint64(u,53),(y.$high===0&&y.$low===1)))){$s=2;continue;}$s=3;continue;case 2:z=C.Sprintf("expected exactly %d bits of result",new DN([new $Int(54)]));$s=4;case 4:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}$panic(new $String(z));case 3:if(-1074<=k&&k<=-1022){aa=(((-1022-((k-1>>0))>>0)>>>0));ad=(ab=(ac=$shiftLeft64(new $Uint64(0,1),aa),new $Uint64(ac.$high-0,ac.$low-1)),new $Uint64(u.$high&ab.$high,(u.$low&ab.$low)>>>0));v=v||!((ad.$high===0&&ad.$low===0));u=$shiftRightUint64(u,(aa));k=-1021;}f=!v;if(!((ae=new $Uint64(u.$high&0,(u.$low&1)>>>0),(ae.$high===0&&ae.$low===0)))){f=false;if(v||!((af=new $Uint64(u.$high&0,(u.$low&2)>>>0),(af.$high===0&&af.$low===0)))){u=(ag=new $Uint64(0,1),new $Uint64(u.$high+ag.$high,u.$low+ag.$low));if((u.$high>4194304||(u.$high===4194304&&u.$low>=0))){u=$shiftRightUint64(u,(1));k=k+(1)>>0;}}}u=$shiftRightUint64(u,(1));e=D.Ldexp(($flatten64(u)),k-53>>0);if(D.IsInf(e,0)){f=false;}$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:DD};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};DA.ptr.prototype.Float32=function(){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=false;e=this;f=e.b.abs;if(f.$length===0){f=f.set(BY);}h=DC(e.a.abs,f);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;c=g[0];d=g[1];if(e.a.neg){c=-c;}$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Float32};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Float32=function(){return this.$val.Float32();};DA.ptr.prototype.Float64=function(){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=0;d=false;e=this;f=e.b.abs;if(f.$length===0){f=f.set(BY);}h=DD(e.a.abs,f);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;c=g[0];d=g[1];if(e.a.neg){c=-c;}$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Float64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Float64=function(){return this.$val.Float64();};DA.ptr.prototype.SetFrac=function(c,d){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;e.a.neg=!(c.neg===d.neg);f=d.abs;if(f.$length===0){$panic(new $String("division by zero"));}if(e.a===d||CG(e.a.abs,f)){f=(BX.nil).set(f);}e.a.abs=e.a.abs.set(c.abs);e.b.abs=e.b.abs.set(f);g=e.norm();$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return g;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.SetFrac};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.SetFrac=function(c,d){return this.$val.SetFrac(c,d);};DA.ptr.prototype.SetFrac64=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;e.a.SetInt64(c);if((d.$high===0&&d.$low===0)){$panic(new $String("division by zero"));}if((d.$high<0||(d.$high===0&&d.$low<0))){d=new $Int64(-d.$high,-d.$low);e.a.neg=!e.a.neg;}e.b.abs=e.b.abs.setUint64((new $Uint64(d.$high,d.$low)));f=e.norm();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.SetFrac64};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.SetFrac64=function(c,d){return this.$val.SetFrac64(c,d);};DA.ptr.prototype.SetInt=function(c){var c,d;d=this;d.a.Set(c);d.b.abs=$subslice(d.b.abs,0,0);return d;};DA.prototype.SetInt=function(c){return this.$val.SetInt(c);};DA.ptr.prototype.SetInt64=function(c){var c,d;d=this;d.a.SetInt64(c);d.b.abs=$subslice(d.b.abs,0,0);return d;};DA.prototype.SetInt64=function(c){return this.$val.SetInt64(c);};DA.ptr.prototype.Set=function(c){var c,d;d=this;if(!(d===c)){d.a.Set(c.a);d.b.Set(c.b);}return d;};DA.prototype.Set=function(c){return this.$val.Set(c);};DA.ptr.prototype.Abs=function(c){var c,d;d=this;d.Set(c);d.a.neg=false;return d;};DA.prototype.Abs=function(c){return this.$val.Abs(c);};DA.ptr.prototype.Neg=function(c){var c,d;d=this;d.Set(c);d.a.neg=d.a.abs.$length>0&&!d.a.neg;return d;};DA.prototype.Neg=function(c){return this.$val.Neg(c);};DA.ptr.prototype.Inv=function(c){var c,d,e,f,g,h;d=this;if(c.a.abs.$length===0){$panic(new $String("division by zero"));}d.Set(c);e=d.b.abs;if(e.$length===0){e=e.set(BY);}f=d.a.abs;if(f.cmp(BY)===0){f=$subslice(f,0,0);}g=e;h=f;d.a.abs=g;d.b.abs=h;return d;};DA.prototype.Inv=function(c){return this.$val.Inv(c);};DA.ptr.prototype.Sign=function(){var c;c=this;return c.a.Sign();};DA.prototype.Sign=function(){return this.$val.Sign();};DA.ptr.prototype.IsInt=function(){var c;c=this;return(c.b.abs.$length===0)||(c.b.abs.cmp(BY)===0);};DA.prototype.IsInt=function(){return this.$val.IsInt();};DA.ptr.prototype.Num=function(){var c;c=this;return c.a;};DA.prototype.Num=function(){return this.$val.Num();};DA.ptr.prototype.Denom=function(){var c;c=this;c.b.neg=false;if(c.b.abs.$length===0){c.b.abs=c.b.abs.set(BY);}return c.b;};DA.prototype.Denom=function(){return this.$val.Denom();};DA.ptr.prototype.norm=function(){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if((c.a.abs.$length===0)){$s=2;continue;}if((c.b.abs.$length===0)){$s=3;continue;}if((c.b.abs.cmp(BY)===0)){$s=4;continue;}$s=5;continue;case 2:c.a.neg=false;c.b.abs=$subslice(c.b.abs,0,0);$s=6;continue;case 3:$s=6;continue;case 4:c.b.abs=$subslice(c.b.abs,0,0);$s=6;continue;case 5:d=c.a.neg;c.a.neg=false;c.b.neg=false;e=BN(new $Int64(0,0)).lehmerGCD(DU.nil,DU.nil,c.a,c.b);$s=7;case 7:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;if(!((f.Cmp(BM)===0))){$s=8;continue;}$s=9;continue;case 8:h=c.a.abs.div(BX.nil,c.a.abs,f.abs);$s=10;case 10:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;c.a.abs=g[0];j=c.b.abs.div(BX.nil,c.b.abs,f.abs);$s=11;case 11:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;c.b.abs=i[0];if(c.b.abs.cmp(BY)===0){c.b.abs=$subslice(c.b.abs,0,0);}case 9:c.a.neg=d;case 6:case 1:$s=-1;return c;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.norm};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.norm=function(){return this.$val.norm();};DE=function(c,d,e){var c,d,e;if((d.$length===0)){return c.set(e);}else if((e.$length===0)){return c.set(d);}return c.mul(d,e);};DF=function(c,d){var c,d,e;e=new BL.ptr(false,BX.nil);if(d.$length===0){return e.Set(c);}e.abs=e.abs.mul(c.abs,d);e.neg=c.neg;return e;};DA.ptr.prototype.Cmp=function(c){var c,d;d=this;return DF(d.a,c.b.abs).Cmp(DF(c.a,d.b.abs));};DA.prototype.Cmp=function(c){return this.$val.Cmp(c);};DA.ptr.prototype.Add=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=DF(c.a,d.b.abs);g=DF(d.a,c.b.abs);e.a.Add(f,g);e.b.abs=DE(e.b.abs,c.b.abs,d.b.abs);h=e.norm();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Add};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Add=function(c,d){return this.$val.Add(c,d);};DA.ptr.prototype.Sub=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=DF(c.a,d.b.abs);g=DF(d.a,c.b.abs);e.a.Sub(f,g);e.b.abs=DE(e.b.abs,c.b.abs,d.b.abs);h=e.norm();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Sub};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Sub=function(c,d){return this.$val.Sub(c,d);};DA.ptr.prototype.Mul=function(c,d){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(c===d){e.a.neg=false;e.a.abs=e.a.abs.sqr(c.a.abs);e.b.abs=e.b.abs.sqr(c.b.abs);$s=-1;return e;}e.a.Mul(c.a,d.a);e.b.abs=DE(e.b.abs,c.b.abs,d.b.abs);f=e.norm();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Mul};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Mul=function(c,d){return this.$val.Mul(c,d);};DA.ptr.prototype.Quo=function(c,d){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;if(d.a.abs.$length===0){$panic(new $String("division by zero"));}f=DF(c.a,d.b.abs);g=DF(d.a,c.b.abs);e.a.abs=f.abs;e.b.abs=g.abs;e.a.neg=!(f.neg===g.neg);h=e.norm();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Quo};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Quo=function(c,d){return this.$val.Quo(c,d);};DG=function(c){var c;return F.ContainsRune("+-/0123456789.eE",c);};DA.ptr.prototype.Scan=function(c,d){var c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;g=c.Token(true,DG);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[0];i=f[1];if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return i;}if(!F.ContainsRune("efgEFGv",d)){$s=-1;return J.New("Rat.Scan: invalid verb");}k=e.SetString(($bytesToString(h)));$s=2;case 2:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[1];if(!l){$s=-1;return J.New("Rat.Scan: invalid syntax");}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.Scan};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.Scan=function(c,d){return this.$val.Scan(c,d);};DA.ptr.prototype.SetString=function(c){var aa,ab,ac,ad,ae,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.length===0){$s=-1;return[DV.nil,false];}e=F.Index(c,"/");if(e>=0){$s=1;continue;}$s=2;continue;case 1:g=d.a.SetString($substring(c,0,e),0);$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[1];if(!h){$s=-1;return[DV.nil,false];}i=F.NewReader($substring(c,(e+1>>0)));j=$ifaceNil;l=d.b.abs.scan(i,0,false);$s=4;case 4:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;d.b.abs=k[0];j=k[3];if(!($interfaceIsEqual(j,$ifaceNil))){$s=-1;return[DV.nil,false];}m=i.ReadByte();j=m[1];if(!($interfaceIsEqual(j,E.EOF))){$s=-1;return[DV.nil,false];}if(d.b.abs.$length===0){$s=-1;return[DV.nil,false];}n=d.norm();$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}$s=-1;return[n,true];case 2:o=F.NewReader(c);q=BV(o);$s=6;case 6:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;r=p[0];s=p[1];if(!($interfaceIsEqual(s,$ifaceNil))){$s=-1;return[DV.nil,false];}t=0;v=d.a.abs.scan(o,10,true);$s=7;case 7:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}u=v;d.a.abs=u[0];t=u[2];s=u[3];if(!($interfaceIsEqual(s,$ifaceNil))){$s=-1;return[DV.nil,false];}w=new $Int64(0,0);y=DI(o,false);$s=8;case 8:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}x=y;w=x[0];s=x[2];if(!($interfaceIsEqual(s,$ifaceNil))){$s=-1;return[DV.nil,false];}z=o.ReadByte();s=z[1];if(!($interfaceIsEqual(s,E.EOF))){$s=-1;return[DV.nil,false];}if(d.a.abs.$length===0){$s=-1;return[d,true];}if(t<0){w=(aa=(new $Int64(0,t)),new $Int64(w.$high+aa.$high,w.$low+aa.$low));}ab=w;if((ab.$high<0||(ab.$high===0&&ab.$low<0))){ab=new $Int64(-ab.$high,-ab.$low);}ac=(BX.nil).expNN(CA,(BX.nil).setWord(((ab.$low>>>0))),BX.nil);$s=9;case 9:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ad=ac;if((w.$high<0||(w.$high===0&&w.$low<0))){$s=10;continue;}$s=11;continue;case 10:d.b.abs=ad;ae=d.norm();$s=13;case 13:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ae;$s=12;continue;case 11:d.a.abs=d.a.abs.mul(d.a.abs,ad);d.b.abs=$subslice(d.b.abs,0,0);case 12:d.a.neg=r&&d.a.abs.$length>0;$s=-1;return[d,true];}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.SetString};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.SetString=function(c){return this.$val.SetString(c);};DI=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=new $Int64(0,0);f=0;g=$ifaceNil;f=10;h=0;j=c.ReadByte();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;h=i[0];g=i[1];if(!($interfaceIsEqual(g,$ifaceNil))){if($interfaceIsEqual(g,E.EOF)){g=$ifaceNil;}$s=-1;return[e,f,g];}k=h;if((k===(101))||(k===(69))){$s=3;continue;}if(k===(112)){$s=4;continue;}$s=5;continue;case 3:$s=6;continue;case 4:if(d){f=2;$s=2;continue;}l=c.UnreadByte();$s=7;case 7:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;$s=-1;return[e,f,g];case 5:m=c.UnreadByte();$s=8;case 8:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}m;$s=-1;return[e,f,g];case 6:case 2:n=false;p=BV(c);$s=9;case 9:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}o=p;n=o[0];g=o[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[e,f,g];}q=DR.nil;if(n){q=$append(q,45);}r=0;case 10:t=c.ReadByte();$s=12;case 12:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;h=s[0];g=s[1];if(!($interfaceIsEqual(g,$ifaceNil))){if(!($interfaceIsEqual(g,E.EOF))||(r===0)){$s=-1;return[e,f,g];}g=$ifaceNil;$s=11;continue;}if(h<48||57>0;$s=10;continue;case 11:w=A.ParseInt(($bytesToString(q)),10,64);e=w[0];g=w[1];$s=-1;return[e,f,g];}return;}if($f===undefined){$f={$blk:DI};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.$s=$s;$f.$r=$r;return $f;};DA.ptr.prototype.String=function(){var c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=c.marshal();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return($bytesToString(d));}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.String};}$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.String=function(){return this.$val.String();};DA.ptr.prototype.marshal=function(){var c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;d=DR.nil;e=c.a.Append(d,10);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;d=$append(d,47);if(!((c.b.abs.$length===0))){$s=2;continue;}$s=3;continue;case 2:f=c.b.Append(d,10);$s=5;case 5:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}d=f;$s=4;continue;case 3:d=$append(d,49);case 4:$s=-1;return d;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.marshal};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.marshal=function(){return this.$val.marshal();};DA.ptr.prototype.RatString=function(){var c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(c.IsInt()){$s=1;continue;}$s=2;continue;case 1:d=c.a.String();$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;case 2:e=c.String();$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return e;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.RatString};}$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.RatString=function(){return this.$val.RatString();};DA.ptr.prototype.FloatString=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=DR.nil;if(d.IsInt()){$s=1;continue;}$s=2;continue;case 1:f=d.a.Append(e,10);$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;if(c>0){e=$append(e,46);g=c;while(true){if(!(g>0)){break;}e=$append(e,48);g=g-(1)>>0;}}$s=-1;return($bytesToString(e));case 2:i=(BX.nil).div((BX.nil),d.a.abs,d.b.abs);$s=4;case 4:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=h[0];k=h[1];l=BY;if(c>0){$s=5;continue;}$s=6;continue;case 5:m=(BX.nil).expNN(CA,(BX.nil).setUint64((new $Uint64(0,c))),BX.nil);$s=7;case 7:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;case 6:k=k.mul(k,l);o=k.div((BX.nil),k,d.b.abs);$s=8;case 8:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;k=n[0];p=n[1];p=p.add(p,p);if(d.b.abs.cmp(p)<=0){k=k.add(k,BY);if(k.cmp(l)>=0){j=(BX.nil).add(j,BY);k=(BX.nil).sub(k,l);}}if(d.a.neg){e=$append(e,45);}q=e;r=j.utoa(10);$s=9;case 9:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}s=r;e=$appendSlice(q,s);if(c>0){$s=10;continue;}$s=11;continue;case 10:e=$append(e,46);t=k.utoa(10);$s=12;case 12:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=t;v=c-u.$length>>0;while(true){if(!(v>0)){break;}e=$append(e,48);v=v-(1)>>0;}e=$appendSlice(e,u);case 11:$s=-1;return($bytesToString(e));}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.FloatString};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.FloatString=function(c){return this.$val.FloatString(c);};DA.ptr.prototype.GobEncode=function(){var c,d,e,f,g,h;c=this;if(c===DV.nil){return[DR.nil,$ifaceNil];}d=$makeSlice(DR,(5+($imul(((c.a.abs.$length+c.b.abs.$length>>0)),4))>>0));e=c.b.abs.bytes(d);f=c.a.abs.bytes($subslice(d,0,e));g=e-f>>0;if(!((((((g>>>0))>>0))===g))){return[DR.nil,J.New("Rat.GobEncode: numerator too large")];}$clone(G.BigEndian,G.bigEndian).PutUint32($subslice(d,(f-4>>0),f),((g>>>0)));f=f-(5)>>0;h=2;if(c.a.neg){h=(h|(1))>>>0;}((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f]=h);return[$subslice(d,f),$ifaceNil];};DA.prototype.GobEncode=function(){return this.$val.GobEncode();};DA.ptr.prototype.GobDecode=function(c){var c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(c.$length===0){DA.copy(d,new DA.ptr(new BL.ptr(false,BX.nil),new BL.ptr(false,BX.nil)));$s=-1;return $ifaceNil;}e=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]);if(!(((e>>>1<<24>>>24)===1))){$s=1;continue;}$s=2;continue;case 1:f=C.Errorf("Rat.GobDecode: encoding version %d not supported",new DN([new $Uint8((e>>>1<<24>>>24))]));$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$s=-1;return f;case 2:g=5+$clone(G.BigEndian,G.bigEndian).Uint32($subslice(c,1,5))>>>0;d.a.neg=!((((e&1)>>>0)===0));d.a.abs=d.a.abs.setBytes($subslice(c,5,g));d.b.abs=d.b.abs.setBytes($subslice(c,g));$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.GobDecode};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.GobDecode=function(c){return this.$val.GobDecode(c);};DA.ptr.prototype.MarshalText=function(){var c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=DR.nil;d=$ifaceNil;e=this;if(e.IsInt()){$s=1;continue;}$s=2;continue;case 1:g=e.a.MarshalText();$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;c=f[0];d=f[1];$s=-1;return[c,d];case 2:i=e.marshal();$s=4;case 4:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=$ifaceNil;c=h;d=j;$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.MarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.MarshalText=function(){return this.$val.MarshalText();};DA.ptr.prototype.UnmarshalText=function(c){var c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;f=d.SetString(($bytesToString(c)));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[1];if(!g){$s=2;continue;}$s=3;continue;case 2:h=C.Errorf("math/big: cannot unmarshal %q into a *big.Rat",new DN([c]));$s=4;case 4:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;case 3:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:DA.ptr.prototype.UnmarshalText};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};DA.prototype.UnmarshalText=function(c){return this.$val.UnmarshalText(c);};AW.prototype.String=function(){var c,d;c=this.$val;if(c>=6){return"RoundingMode("+A.FormatInt((new $Int64(0,c)),10)+")";}return $substring("ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegativeInfToPositiveInf",((c<0||c>=DJ.length)?($throwRuntimeError("index out of range"),undefined):DJ[c]),(d=c+1<<24>>>24,((d<0||d>=DJ.length)?($throwRuntimeError("index out of range"),undefined):DJ[d])));};$ptrType(AW).prototype.String=function(){return new AW(this.$get()).String();};AS.ptr.prototype.Sqrt=function(c){var c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;if(false){$s=1;continue;}$s=2;continue;case 1:$r=c.validate();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(d.prec===0){d.prec=c.prec;}e=c.Sign();$s=6;case 6:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}if(e===-1){$s=4;continue;}$s=5;continue;case 4:$panic((f=new AT.ptr("square root of negative operand"),new f.constructor.elem(f)));case 5:if(!((c.form===1))){d.acc=0;d.form=c.form;d.neg=c.neg;$s=-1;return d;}g=d.prec;h=c.MantExp(d);$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;d.prec=g;k=(j=i%2,j===j?j:$throwRuntimeError("integer divide by zero"));if(k===(0)){}else if(k===(1)){d.exp=d.exp+(1)>>0;}else if(k===(-1)){d.exp=d.exp-(1)>>0;}if(d.prec<=128){$s=8;continue;}$s=9;continue;case 8:$r=d.sqrtDirect(d);$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=10;continue;case 9:$r=d.sqrtInverse(d);$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 10:m=d.SetMantExp(d,(l=i/2,(l===l&&l!==1/0&&l!==-1/0)?l>>0:$throwRuntimeError("integer divide by zero")));$s=13;case 13:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return m;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.Sqrt};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.Sqrt=function(c){return this.$val.Sqrt(c);};AS.ptr.prototype.sqrtDirect=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=[d];e=this;d[0]=new AS.ptr(0,0,0,0,false,BX.nil,0);f=(function(c,d){return function $b(f){var f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d[0].prec=f.prec;g=d[0].Mul(f,f);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}g;h=d[0].Add(d[0],c[0]);$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;d[0].exp=d[0].exp-(1)>>0;i=f.Quo(d[0],f);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}$s=-1;return i;}return;}if($f===undefined){$f={$blk:$b};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};})(c,d);h=c[0].Float64();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;i=g[0];j=AU(D.Sqrt(i));$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(e.prec>128){$s=4;continue;}if(e.prec>64){$s=5;continue;}$s=6;continue;case 4:$panic(new $String("sqrtDirect: only for z.prec <= 128"));$s=7;continue;case 5:k.prec=$imul(k.prec,(2))>>>0;l=f(k);$s=8;case 8:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;k.prec=$imul(k.prec,(2))>>>0;m=f(k);$s=9;case 9:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}k=m;$s=7;continue;case 6:k.prec=$imul(k.prec,(2))>>>0;n=f(k);$s=10;case 10:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}k=n;case 7:case 3:o=e.Set(k);$s=11;case 11:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}o;$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.sqrtDirect};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.sqrtDirect=function(c){return this.$val.sqrtDirect(c);};AS.ptr.prototype.sqrtInverse=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=[d];e=[e];f=this;d[0]=DL(f.prec);e[0]=DL(f.prec);g=(function(c,d,e){return function $b(g){var g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d[0].prec=g.prec;e[0].prec=g.prec;h=d[0].Mul(g,g);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;i=d[0].Mul(c[0],d[0]);$s=2;case 2:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;j=e[0].Sub(DK,d[0]);$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}j;k=d[0].Mul(g,e[0]);$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}k;d[0].exp=d[0].exp-(1)>>0;l=g.Set(d[0]);$s=5;case 5:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$s=-1;return l;}return;}if($f===undefined){$f={$blk:$b};}$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};})(c,d,e);i=c[0].Float64();$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=h[0];k=DL(f.prec);l=k.SetFloat64(1/D.Sqrt(j));$s=2;case 2:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;m=f.prec+32>>>0;case 3:if(!(k.prec>>0;n=g(k);$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}k=n;$s=3;continue;case 4:o=f.Mul(c[0],k);$s=6;case 6:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}o;$s=-1;return;}return;}if($f===undefined){$f={$blk:AS.ptr.prototype.sqrtInverse};}$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};AS.prototype.sqrtInverse=function(c){return this.$val.sqrtInverse(c);};DL=function(c){var c,d,e;d=new AS.ptr(0,0,0,0,false,BX.nil,0);d.mant=d.mant.make($imul((((e=c/32,(e===e&&e!==1/0&&e!==-1/0)?e>>>0:$throwRuntimeError("integer divide by zero"))>>0)),2));return d;};EA.methods=[{prop:"at",name:"at",pkg:"math/big",typ:$funcType([$Int],[$Uint8],false)},{prop:"init",name:"init",pkg:"math/big",typ:$funcType([BX,$Int],[],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"round",name:"round",pkg:"math/big",typ:$funcType([$Int],[],false)},{prop:"roundUp",name:"roundUp",pkg:"math/big",typ:$funcType([$Int],[],false)},{prop:"roundDown",name:"roundDown",pkg:"math/big",typ:$funcType([$Int],[],false)}];DS.methods=[{prop:"SetPrec",name:"SetPrec",pkg:"",typ:$funcType([$Uint],[DS],false)},{prop:"SetMode",name:"SetMode",pkg:"",typ:$funcType([AW],[DS],false)},{prop:"Prec",name:"Prec",pkg:"",typ:$funcType([],[$Uint],false)},{prop:"MinPrec",name:"MinPrec",pkg:"",typ:$funcType([],[$Uint],false)},{prop:"Mode",name:"Mode",pkg:"",typ:$funcType([],[AW],false)},{prop:"Acc",name:"Acc",pkg:"",typ:$funcType([],[AX],false)},{prop:"Sign",name:"Sign",pkg:"",typ:$funcType([],[$Int],false)},{prop:"MantExp",name:"MantExp",pkg:"",typ:$funcType([DS],[$Int],false)},{prop:"setExpAndRound",name:"setExpAndRound",pkg:"math/big",typ:$funcType([$Int64,$Uint],[],false)},{prop:"SetMantExp",name:"SetMantExp",pkg:"",typ:$funcType([DS,$Int],[DS],false)},{prop:"Signbit",name:"Signbit",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsInf",name:"IsInf",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsInt",name:"IsInt",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"validate",name:"validate",pkg:"math/big",typ:$funcType([],[],false)},{prop:"round",name:"round",pkg:"math/big",typ:$funcType([$Uint],[],false)},{prop:"setBits64",name:"setBits64",pkg:"math/big",typ:$funcType([$Bool,$Uint64],[DS],false)},{prop:"SetUint64",name:"SetUint64",pkg:"",typ:$funcType([$Uint64],[DS],false)},{prop:"SetInt64",name:"SetInt64",pkg:"",typ:$funcType([$Int64],[DS],false)},{prop:"SetFloat64",name:"SetFloat64",pkg:"",typ:$funcType([$Float64],[DS],false)},{prop:"SetInt",name:"SetInt",pkg:"",typ:$funcType([DU],[DS],false)},{prop:"SetRat",name:"SetRat",pkg:"",typ:$funcType([DV],[DS],false)},{prop:"SetInf",name:"SetInf",pkg:"",typ:$funcType([$Bool],[DS],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([DS],[DS],false)},{prop:"Copy",name:"Copy",pkg:"",typ:$funcType([DS],[DS],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64,AX],false)},{prop:"Int64",name:"Int64",pkg:"",typ:$funcType([],[$Int64,AX],false)},{prop:"Float32",name:"Float32",pkg:"",typ:$funcType([],[$Float32,AX],false)},{prop:"Float64",name:"Float64",pkg:"",typ:$funcType([],[$Float64,AX],false)},{prop:"Int",name:"Int",pkg:"",typ:$funcType([DU],[DU,AX],false)},{prop:"Rat",name:"Rat",pkg:"",typ:$funcType([DV],[DV,AX],false)},{prop:"Abs",name:"Abs",pkg:"",typ:$funcType([DS],[DS],false)},{prop:"Neg",name:"Neg",pkg:"",typ:$funcType([DS],[DS],false)},{prop:"uadd",name:"uadd",pkg:"math/big",typ:$funcType([DS,DS],[],false)},{prop:"usub",name:"usub",pkg:"math/big",typ:$funcType([DS,DS],[],false)},{prop:"umul",name:"umul",pkg:"math/big",typ:$funcType([DS,DS],[],false)},{prop:"uquo",name:"uquo",pkg:"math/big",typ:$funcType([DS,DS],[],false)},{prop:"ucmp",name:"ucmp",pkg:"math/big",typ:$funcType([DS],[$Int],false)},{prop:"Add",name:"Add",pkg:"",typ:$funcType([DS,DS],[DS],false)},{prop:"Sub",name:"Sub",pkg:"",typ:$funcType([DS,DS],[DS],false)},{prop:"Mul",name:"Mul",pkg:"",typ:$funcType([DS,DS],[DS],false)},{prop:"Quo",name:"Quo",pkg:"",typ:$funcType([DS,DS],[DS],false)},{prop:"Cmp",name:"Cmp",pkg:"",typ:$funcType([DS],[$Int],false)},{prop:"ord",name:"ord",pkg:"math/big",typ:$funcType([],[$Int],false)},{prop:"SetString",name:"SetString",pkg:"",typ:$funcType([$String],[DS,$Bool],false)},{prop:"scan",name:"scan",pkg:"math/big",typ:$funcType([E.ByteScanner,$Int],[DS,$Int,$error],false)},{prop:"pow5",name:"pow5",pkg:"math/big",typ:$funcType([$Uint64],[DS],false)},{prop:"Parse",name:"Parse",pkg:"",typ:$funcType([$String,$Int],[DS,$Int,$error],false)},{prop:"Scan",name:"Scan",pkg:"",typ:$funcType([C.ScanState,$Int32],[$error],false)},{prop:"GobEncode",name:"GobEncode",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"GobDecode",name:"GobDecode",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"Text",name:"Text",pkg:"",typ:$funcType([$Uint8,$Int],[$String],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Append",name:"Append",pkg:"",typ:$funcType([DR,$Uint8,$Int],[DR],false)},{prop:"fmtB",name:"fmtB",pkg:"math/big",typ:$funcType([DR],[DR],false)},{prop:"fmtP",name:"fmtP",pkg:"math/big",typ:$funcType([DR],[DR],false)},{prop:"Format",name:"Format",pkg:"",typ:$funcType([C.State,$Int32],[],false)},{prop:"Sqrt",name:"Sqrt",pkg:"",typ:$funcType([DS],[DS],false)},{prop:"sqrtDirect",name:"sqrtDirect",pkg:"math/big",typ:$funcType([DS],[],false)},{prop:"sqrtInverse",name:"sqrtInverse",pkg:"math/big",typ:$funcType([DS],[],false)}];AT.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];AW.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];AX.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];DU.methods=[{prop:"Sign",name:"Sign",pkg:"",typ:$funcType([],[$Int],false)},{prop:"SetInt64",name:"SetInt64",pkg:"",typ:$funcType([$Int64],[DU],false)},{prop:"SetUint64",name:"SetUint64",pkg:"",typ:$funcType([$Uint64],[DU],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([DU],[DU],false)},{prop:"Bits",name:"Bits",pkg:"",typ:$funcType([],[DT],false)},{prop:"SetBits",name:"SetBits",pkg:"",typ:$funcType([DT],[DU],false)},{prop:"Abs",name:"Abs",pkg:"",typ:$funcType([DU],[DU],false)},{prop:"Neg",name:"Neg",pkg:"",typ:$funcType([DU],[DU],false)},{prop:"Add",name:"Add",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Sub",name:"Sub",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Mul",name:"Mul",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"MulRange",name:"MulRange",pkg:"",typ:$funcType([$Int64,$Int64],[DU],false)},{prop:"Binomial",name:"Binomial",pkg:"",typ:$funcType([$Int64,$Int64],[DU],false)},{prop:"Quo",name:"Quo",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Rem",name:"Rem",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"QuoRem",name:"QuoRem",pkg:"",typ:$funcType([DU,DU,DU],[DU,DU],false)},{prop:"Div",name:"Div",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Mod",name:"Mod",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"DivMod",name:"DivMod",pkg:"",typ:$funcType([DU,DU,DU],[DU,DU],false)},{prop:"Cmp",name:"Cmp",pkg:"",typ:$funcType([DU],[$Int],false)},{prop:"CmpAbs",name:"CmpAbs",pkg:"",typ:$funcType([DU],[$Int],false)},{prop:"Int64",name:"Int64",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"IsInt64",name:"IsInt64",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsUint64",name:"IsUint64",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"SetString",name:"SetString",pkg:"",typ:$funcType([$String,$Int],[DU,$Bool],false)},{prop:"setFromScanner",name:"setFromScanner",pkg:"math/big",typ:$funcType([E.ByteScanner,$Int],[DU,$Bool],false)},{prop:"SetBytes",name:"SetBytes",pkg:"",typ:$funcType([DR],[DU],false)},{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[DR],false)},{prop:"BitLen",name:"BitLen",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Exp",name:"Exp",pkg:"",typ:$funcType([DU,DU,DU],[DU],false)},{prop:"GCD",name:"GCD",pkg:"",typ:$funcType([DU,DU,DU,DU],[DU],false)},{prop:"lehmerGCD",name:"lehmerGCD",pkg:"math/big",typ:$funcType([DU,DU,DU,DU],[DU],false)},{prop:"Rand",name:"Rand",pkg:"",typ:$funcType([EB,DU],[DU],false)},{prop:"ModInverse",name:"ModInverse",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"modSqrt3Mod4Prime",name:"modSqrt3Mod4Prime",pkg:"math/big",typ:$funcType([DU,DU],[DU],false)},{prop:"modSqrt5Mod8Prime",name:"modSqrt5Mod8Prime",pkg:"math/big",typ:$funcType([DU,DU],[DU],false)},{prop:"modSqrtTonelliShanks",name:"modSqrtTonelliShanks",pkg:"math/big",typ:$funcType([DU,DU],[DU],false)},{prop:"ModSqrt",name:"ModSqrt",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Lsh",name:"Lsh",pkg:"",typ:$funcType([DU,$Uint],[DU],false)},{prop:"Rsh",name:"Rsh",pkg:"",typ:$funcType([DU,$Uint],[DU],false)},{prop:"Bit",name:"Bit",pkg:"",typ:$funcType([$Int],[$Uint],false)},{prop:"SetBit",name:"SetBit",pkg:"",typ:$funcType([DU,$Int,$Uint],[DU],false)},{prop:"And",name:"And",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"AndNot",name:"AndNot",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Or",name:"Or",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Xor",name:"Xor",pkg:"",typ:$funcType([DU,DU],[DU],false)},{prop:"Not",name:"Not",pkg:"",typ:$funcType([DU],[DU],false)},{prop:"Sqrt",name:"Sqrt",pkg:"",typ:$funcType([DU],[DU],false)},{prop:"Text",name:"Text",pkg:"",typ:$funcType([$Int],[$String],false)},{prop:"Append",name:"Append",pkg:"",typ:$funcType([DR,$Int],[DR],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Format",name:"Format",pkg:"",typ:$funcType([C.State,$Int32],[],false)},{prop:"scan",name:"scan",pkg:"math/big",typ:$funcType([E.ByteScanner,$Int],[DU,$Int,$error],false)},{prop:"Scan",name:"Scan",pkg:"",typ:$funcType([C.ScanState,$Int32],[$error],false)},{prop:"GobEncode",name:"GobEncode",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"GobDecode",name:"GobDecode",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"MarshalJSON",name:"MarshalJSON",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"UnmarshalJSON",name:"UnmarshalJSON",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"ProbablyPrime",name:"ProbablyPrime",pkg:"",typ:$funcType([$Int],[$Bool],false)}];BW.methods=[{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)}];BX.methods=[{prop:"clear",name:"clear",pkg:"math/big",typ:$funcType([],[],false)},{prop:"norm",name:"norm",pkg:"math/big",typ:$funcType([],[BX],false)},{prop:"make",name:"make",pkg:"math/big",typ:$funcType([$Int],[BX],false)},{prop:"setWord",name:"setWord",pkg:"math/big",typ:$funcType([L],[BX],false)},{prop:"setUint64",name:"setUint64",pkg:"math/big",typ:$funcType([$Uint64],[BX],false)},{prop:"set",name:"set",pkg:"math/big",typ:$funcType([BX],[BX],false)},{prop:"add",name:"add",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"sub",name:"sub",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"cmp",name:"cmp",pkg:"math/big",typ:$funcType([BX],[$Int],false)},{prop:"mulAddWW",name:"mulAddWW",pkg:"math/big",typ:$funcType([BX,L,L],[BX],false)},{prop:"montgomery",name:"montgomery",pkg:"math/big",typ:$funcType([BX,BX,BX,L,$Int],[BX],false)},{prop:"mul",name:"mul",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"sqr",name:"sqr",pkg:"math/big",typ:$funcType([BX],[BX],false)},{prop:"mulRange",name:"mulRange",pkg:"math/big",typ:$funcType([$Uint64,$Uint64],[BX],false)},{prop:"divW",name:"divW",pkg:"math/big",typ:$funcType([BX,L],[BX,L],false)},{prop:"div",name:"div",pkg:"math/big",typ:$funcType([BX,BX,BX],[BX,BX],false)},{prop:"divLarge",name:"divLarge",pkg:"math/big",typ:$funcType([BX,BX,BX],[BX,BX],false)},{prop:"bitLen",name:"bitLen",pkg:"math/big",typ:$funcType([],[$Int],false)},{prop:"trailingZeroBits",name:"trailingZeroBits",pkg:"math/big",typ:$funcType([],[$Uint],false)},{prop:"shl",name:"shl",pkg:"math/big",typ:$funcType([BX,$Uint],[BX],false)},{prop:"shr",name:"shr",pkg:"math/big",typ:$funcType([BX,$Uint],[BX],false)},{prop:"setBit",name:"setBit",pkg:"math/big",typ:$funcType([BX,$Uint,$Uint],[BX],false)},{prop:"bit",name:"bit",pkg:"math/big",typ:$funcType([$Uint],[$Uint],false)},{prop:"sticky",name:"sticky",pkg:"math/big",typ:$funcType([$Uint],[$Uint],false)},{prop:"and",name:"and",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"andNot",name:"andNot",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"or",name:"or",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"xor",name:"xor",pkg:"math/big",typ:$funcType([BX,BX],[BX],false)},{prop:"modW",name:"modW",pkg:"math/big",typ:$funcType([L],[L],false)},{prop:"random",name:"random",pkg:"math/big",typ:$funcType([EB,BX,$Int],[BX],false)},{prop:"expNN",name:"expNN",pkg:"math/big",typ:$funcType([BX,BX,BX],[BX],false)},{prop:"expNNWindowed",name:"expNNWindowed",pkg:"math/big",typ:$funcType([BX,BX,BX],[BX],false)},{prop:"expNNMontgomery",name:"expNNMontgomery",pkg:"math/big",typ:$funcType([BX,BX,BX],[BX],false)},{prop:"bytes",name:"bytes",pkg:"math/big",typ:$funcType([DR],[$Int],false)},{prop:"setBytes",name:"setBytes",pkg:"math/big",typ:$funcType([DR],[BX],false)},{prop:"sqrt",name:"sqrt",pkg:"math/big",typ:$funcType([BX],[BX],false)},{prop:"scan",name:"scan",pkg:"math/big",typ:$funcType([E.ByteScanner,$Int,$Bool],[BX,$Int,$Int,$error],false)},{prop:"utoa",name:"utoa",pkg:"math/big",typ:$funcType([$Int],[DR],false)},{prop:"itoa",name:"itoa",pkg:"math/big",typ:$funcType([$Bool,$Int],[DR],false)},{prop:"convertWords",name:"convertWords",pkg:"math/big",typ:$funcType([DR,L,$Int,L,DZ],[],false)},{prop:"expWW",name:"expWW",pkg:"math/big",typ:$funcType([L,L],[BX],false)},{prop:"probablyPrimeMillerRabin",name:"probablyPrimeMillerRabin",pkg:"math/big",typ:$funcType([$Int,$Bool],[$Bool],false)},{prop:"probablyPrimeLucas",name:"probablyPrimeLucas",pkg:"math/big",typ:$funcType([],[$Bool],false)}];DV.methods=[{prop:"SetFloat64",name:"SetFloat64",pkg:"",typ:$funcType([$Float64],[DV],false)},{prop:"Float32",name:"Float32",pkg:"",typ:$funcType([],[$Float32,$Bool],false)},{prop:"Float64",name:"Float64",pkg:"",typ:$funcType([],[$Float64,$Bool],false)},{prop:"SetFrac",name:"SetFrac",pkg:"",typ:$funcType([DU,DU],[DV],false)},{prop:"SetFrac64",name:"SetFrac64",pkg:"",typ:$funcType([$Int64,$Int64],[DV],false)},{prop:"SetInt",name:"SetInt",pkg:"",typ:$funcType([DU],[DV],false)},{prop:"SetInt64",name:"SetInt64",pkg:"",typ:$funcType([$Int64],[DV],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([DV],[DV],false)},{prop:"Abs",name:"Abs",pkg:"",typ:$funcType([DV],[DV],false)},{prop:"Neg",name:"Neg",pkg:"",typ:$funcType([DV],[DV],false)},{prop:"Inv",name:"Inv",pkg:"",typ:$funcType([DV],[DV],false)},{prop:"Sign",name:"Sign",pkg:"",typ:$funcType([],[$Int],false)},{prop:"IsInt",name:"IsInt",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Num",name:"Num",pkg:"",typ:$funcType([],[DU],false)},{prop:"Denom",name:"Denom",pkg:"",typ:$funcType([],[DU],false)},{prop:"norm",name:"norm",pkg:"math/big",typ:$funcType([],[DV],false)},{prop:"Cmp",name:"Cmp",pkg:"",typ:$funcType([DV],[$Int],false)},{prop:"Add",name:"Add",pkg:"",typ:$funcType([DV,DV],[DV],false)},{prop:"Sub",name:"Sub",pkg:"",typ:$funcType([DV,DV],[DV],false)},{prop:"Mul",name:"Mul",pkg:"",typ:$funcType([DV,DV],[DV],false)},{prop:"Quo",name:"Quo",pkg:"",typ:$funcType([DV,DV],[DV],false)},{prop:"Scan",name:"Scan",pkg:"",typ:$funcType([C.ScanState,$Int32],[$error],false)},{prop:"SetString",name:"SetString",pkg:"",typ:$funcType([$String],[DV,$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"marshal",name:"marshal",pkg:"math/big",typ:$funcType([],[DR],false)},{prop:"RatString",name:"RatString",pkg:"",typ:$funcType([],[$String],false)},{prop:"FloatString",name:"FloatString",pkg:"",typ:$funcType([$Int],[$String],false)},{prop:"GobEncode",name:"GobEncode",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"GobDecode",name:"GobDecode",pkg:"",typ:$funcType([DR],[$error],false)},{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[DR,$error],false)},{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([DR],[$error],false)}];AN.init("math/big",[{prop:"mant",name:"mant",embedded:false,exported:false,typ:DR,tag:""},{prop:"exp",name:"exp",embedded:false,exported:false,typ:$Int,tag:""}]);AS.init("math/big",[{prop:"prec",name:"prec",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"mode",name:"mode",embedded:false,exported:false,typ:AW,tag:""},{prop:"acc",name:"acc",embedded:false,exported:false,typ:AX,tag:""},{prop:"form",name:"form",embedded:false,exported:false,typ:AV,tag:""},{prop:"neg",name:"neg",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"mant",name:"mant",embedded:false,exported:false,typ:BX,tag:""},{prop:"exp",name:"exp",embedded:false,exported:false,typ:$Int32,tag:""}]);AT.init("math/big",[{prop:"msg",name:"msg",embedded:false,exported:false,typ:$String,tag:""}]);BL.init("math/big",[{prop:"neg",name:"neg",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"abs",name:"abs",embedded:false,exported:false,typ:BX,tag:""}]);BW.init("",[{prop:"ScanState",name:"ScanState",embedded:true,exported:true,typ:C.ScanState,tag:""}]);BX.init(L);CX.init("math/big",[{prop:"bbb",name:"bbb",embedded:false,exported:false,typ:BX,tag:""},{prop:"nbits",name:"nbits",embedded:false,exported:false,typ:$Int,tag:""},{prop:"ndigits",name:"ndigits",embedded:false,exported:false,typ:$Int,tag:""}]);DA.init("math/big",[{prop:"a",name:"a",embedded:false,exported:false,typ:BL,tag:""},{prop:"b",name:"b",embedded:false,exported:false,typ:BL,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=H.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=J.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}CQ=new K.Pool.ptr(DN.nil,$throwNilPointerError);CY=new DP.ptr(new K.Mutex.ptr(false),DO.zero());M=$toNativeArray($kindUint8,[0,5,10,15]);BF=$toNativeArray($kindUint64,[new $Uint64(0,1),new $Uint64(0,5),new $Uint64(0,25),new $Uint64(0,125),new $Uint64(0,625),new $Uint64(0,3125),new $Uint64(0,15625),new $Uint64(0,78125),new $Uint64(0,390625),new $Uint64(0,1953125),new $Uint64(0,9765625),new $Uint64(0,48828125),new $Uint64(0,244140625),new $Uint64(0,1220703125),new $Uint64(1,1808548329),new $Uint64(7,452807053),new $Uint64(35,2264035265),new $Uint64(177,2730241733),new $Uint64(888,766306777),new $Uint64(4440,3831533885),new $Uint64(22204,1977800241),new $Uint64(111022,1299066613),new $Uint64(555111,2200365769),new $Uint64(2775557,2411894253),new $Uint64(13877787,3469536673),new $Uint64(69388939,167814181),new $Uint64(346944695,839070905),new $Uint64(1734723475,4195354525)]);BY=new BX([1]);BM=new BL.ptr(false,BY);BZ=new BX([2]);CA=new BX([10]);CE=40;CM=20;CN=260;CW=8;DJ=$toNativeArray($kindUint8,[0,13,26,32,44,57,70]);b=AU(3);$s=12;case 12:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}DK=b;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["regexp/syntax"]=(function(){var $pkg={},$init,C,B,D,A,E,F,G,H,M,N,O,P,Z,AM,BK,BL,BN,BQ,BV,BW,CA,CB,CC,CD,CE,CF,CG,CH,CI,CJ,CK,CL,CM,CN,CO,CP,CQ,CR,J,K,L,AA,AR,AS,AT,AU,AV,AW,AX,AY,AZ,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BM,I,Q,R,S,T,U,V,W,X,Y,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AN,AO,AP,AQ,BP,BR,BS,BT,BU,BX,BY,BZ;C=$packages["sort"];B=$packages["strconv"];D=$packages["strings"];A=$packages["unicode"];E=$packages["unicode/utf8"];F=$pkg.patchList=$newType(4,$kindUint32,"syntax.patchList",true,"regexp/syntax",false,null);G=$pkg.frag=$newType(0,$kindStruct,"syntax.frag",true,"regexp/syntax",false,function(i_,out_){this.$val=this;if(arguments.length===0){this.i=0;this.out=0;return;}this.i=i_;this.out=out_;});H=$pkg.compiler=$newType(0,$kindStruct,"syntax.compiler",true,"regexp/syntax",false,function(p_){this.$val=this;if(arguments.length===0){this.p=CE.nil;return;}this.p=p_;});M=$pkg.Error=$newType(0,$kindStruct,"syntax.Error",true,"regexp/syntax",true,function(Code_,Expr_){this.$val=this;if(arguments.length===0){this.Code="";this.Expr="";return;}this.Code=Code_;this.Expr=Expr_;});N=$pkg.ErrorCode=$newType(8,$kindString,"syntax.ErrorCode",true,"regexp/syntax",true,null);O=$pkg.Flags=$newType(2,$kindUint16,"syntax.Flags",true,"regexp/syntax",true,null);P=$pkg.parser=$newType(0,$kindStruct,"syntax.parser",true,"regexp/syntax",false,function(flags_,stack_,free_,numCap_,wholeRegexp_,tmpClass_){this.$val=this;if(arguments.length===0){this.flags=0;this.stack=CH.nil;this.free=CG.nil;this.numCap=0;this.wholeRegexp="";this.tmpClass=CA.nil;return;}this.flags=flags_;this.stack=stack_;this.free=free_;this.numCap=numCap_;this.wholeRegexp=wholeRegexp_;this.tmpClass=tmpClass_;});Z=$pkg.charGroup=$newType(0,$kindStruct,"syntax.charGroup",true,"regexp/syntax",false,function(sign_,class$1_){this.$val=this;if(arguments.length===0){this.sign=0;this.class$1=CA.nil;return;}this.sign=sign_;this.class$1=class$1_;});AM=$pkg.ranges=$newType(0,$kindStruct,"syntax.ranges",true,"regexp/syntax",false,function(p_){this.$val=this;if(arguments.length===0){this.p=CK.nil;return;}this.p=p_;});BK=$pkg.Prog=$newType(0,$kindStruct,"syntax.Prog",true,"regexp/syntax",true,function(Inst_,Start_,NumCap_){this.$val=this;if(arguments.length===0){this.Inst=CF.nil;this.Start=0;this.NumCap=0;return;}this.Inst=Inst_;this.Start=Start_;this.NumCap=NumCap_;});BL=$pkg.InstOp=$newType(1,$kindUint8,"syntax.InstOp",true,"regexp/syntax",true,null);BN=$pkg.EmptyOp=$newType(1,$kindUint8,"syntax.EmptyOp",true,"regexp/syntax",true,null);BQ=$pkg.Inst=$newType(0,$kindStruct,"syntax.Inst",true,"regexp/syntax",true,function(Op_,Out_,Arg_,Rune_){this.$val=this;if(arguments.length===0){this.Op=0;this.Out=0;this.Arg=0;this.Rune=CA.nil;return;}this.Op=Op_;this.Out=Out_;this.Arg=Arg_;this.Rune=Rune_;});BV=$pkg.Regexp=$newType(0,$kindStruct,"syntax.Regexp",true,"regexp/syntax",true,function(Op_,Flags_,Sub_,Sub0_,Rune_,Rune0_,Min_,Max_,Cap_,Name_){this.$val=this;if(arguments.length===0){this.Op=0;this.Flags=0;this.Sub=CH.nil;this.Sub0=CI.zero();this.Rune=CA.nil;this.Rune0=CJ.zero();this.Min=0;this.Max=0;this.Cap=0;this.Name="";return;}this.Op=Op_;this.Flags=Flags_;this.Sub=Sub_;this.Sub0=Sub0_;this.Rune=Rune_;this.Rune0=Rune0_;this.Min=Min_;this.Max=Max_;this.Cap=Cap_;this.Name=Name_;});BW=$pkg.Op=$newType(1,$kindUint8,"syntax.Op",true,"regexp/syntax",true,null);CA=$sliceType($Int32);CB=$sliceType(A.Range16);CC=$sliceType(A.Range32);CD=$sliceType($String);CE=$ptrType(BK);CF=$sliceType(BQ);CG=$ptrType(BV);CH=$sliceType(CG);CI=$arrayType(CG,1);CJ=$arrayType($Int32,2);CK=$ptrType(CA);CL=$ptrType(A.RangeTable);CM=$ptrType(D.Builder);CN=$sliceType($Uint8);CO=$ptrType(H);CP=$ptrType(M);CQ=$ptrType(P);CR=$ptrType(BQ);F.prototype.next=function(a){var a,b,c,d,e;b=this.$val;e=(c=a.Inst,d=b>>>1>>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]));if(((b&1)>>>0)===0){return((e.Out>>>0));}return((e.Arg>>>0));};$ptrType(F).prototype.next=function(a){return new F(this.$get()).next(a);};F.prototype.patch=function(a,b){var a,b,c,d,e,f;c=this.$val;while(true){if(!(!((c===0)))){break;}f=(d=a.Inst,e=c>>>1>>>0,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]));if(((c&1)>>>0)===0){c=((f.Out>>>0));f.Out=b;}else{c=((f.Arg>>>0));f.Arg=b;}}};$ptrType(F).prototype.patch=function(a,b){return new F(this.$get()).patch(a,b);};F.prototype.append=function(a,b){var a,b,c,d,e,f,g,h;c=this.$val;if(c===0){return b;}if(b===0){return c;}d=c;while(true){e=new F(d).next(a);if(e===0){break;}d=e;}h=(f=a.Inst,g=d>>>1>>>0,((g<0||g>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]));if(((d&1)>>>0)===0){h.Out=((b>>>0));}else{h.Arg=((b>>>0));}return c;};$ptrType(F).prototype.append=function(a,b){return new F(this.$get()).append(a,b);};I=function(a){var a,b,c;b=new H.ptr(CE.nil);b.init();c=$clone(b.compile(a),G);new F(c.out).patch(b.p,b.inst(4).i);b.p.Start=((c.i>>0));return[b.p,$ifaceNil];};$pkg.Compile=I;H.ptr.prototype.init=function(){var a;a=this;a.p=new BK.ptr(CF.nil,0,0);a.p.NumCap=2;a.inst(5);};H.prototype.init=function(){return this.$val.init();};H.ptr.prototype.compile=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;b=this;c=a.Op;if(c===(1)){return b.fail();}else if(c===(2)){return b.nop();}else if(c===(3)){if(a.Rune.$length===0){return b.nop();}d=new G.ptr(0,0);e=a.Rune;f=0;while(true){if(!(f>0)),a.Flags),G);if(g===0){G.copy(d,h);}else{G.copy(d,b.cat($clone(d,G),$clone(h,G)));}f++;}return d;}else if(c===(4)){return b.rune(a.Rune,a.Flags);}else if(c===(5)){return b.rune(J,0);}else if(c===(6)){return b.rune(K,0);}else if(c===(7)){return b.empty(1);}else if(c===(8)){return b.empty(2);}else if(c===(9)){return b.empty(4);}else if(c===(10)){return b.empty(8);}else if(c===(11)){return b.empty(16);}else if(c===(12)){return b.empty(32);}else if(c===(13)){i=$clone(b.cap((((a.Cap<<1>>0)>>>0))),G);k=$clone(b.compile((j=a.Sub,(0>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+0]))),G);l=$clone(b.cap(((((a.Cap<<1>>0)|1)>>>0))),G);return b.cat($clone(b.cat($clone(i,G),$clone(k,G)),G),$clone(l,G));}else if(c===(14)){return b.star($clone(b.compile((m=a.Sub,(0>=m.$length?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+0]))),G),!((((a.Flags&32)>>>0)===0)));}else if(c===(15)){return b.plus($clone(b.compile((n=a.Sub,(0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0]))),G),!((((a.Flags&32)>>>0)===0)));}else if(c===(16)){return b.quest($clone(b.compile((o=a.Sub,(0>=o.$length?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+0]))),G),!((((a.Flags&32)>>>0)===0)));}else if(c===(18)){if(a.Sub.$length===0){return b.nop();}p=new G.ptr(0,0);q=a.Sub;r=0;while(true){if(!(r=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r]);if(s===0){G.copy(p,b.compile(t));}else{G.copy(p,b.cat($clone(p,G),$clone(b.compile(t),G)));}r++;}return p;}else if(c===(19)){u=new G.ptr(0,0);v=a.Sub;w=0;while(true){if(!(w=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+w]);G.copy(u,b.alt($clone(u,G),$clone(b.compile(x),G)));w++;}return u;}$panic(new $String("regexp: unhandled case in compile"));};H.prototype.compile=function(a){return this.$val.compile(a);};H.ptr.prototype.inst=function(a){var a,b,c;b=this;c=new G.ptr(((b.p.Inst.$length>>>0)),0);b.p.Inst=$append(b.p.Inst,new BQ.ptr(a,0,0,CA.nil));return c;};H.prototype.inst=function(a){return this.$val.inst(a);};H.ptr.prototype.nop=function(){var a,b;a=this;b=$clone(a.inst(6),G);b.out=(((b.i<<1>>>0)>>>0));return b;};H.prototype.nop=function(){return this.$val.nop();};H.ptr.prototype.fail=function(){var a;a=this;return new G.ptr(0,0);};H.prototype.fail=function(){return this.$val.fail();};H.ptr.prototype.cap=function(a){var a,b,c,d,e;b=this;c=$clone(b.inst(2),G);c.out=(((c.i<<1>>>0)>>>0));(d=b.p.Inst,e=c.i,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e])).Arg=a;if(b.p.NumCap<(((a>>0))+1>>0)){b.p.NumCap=((a>>0))+1>>0;}return c;};H.prototype.cap=function(a){return this.$val.cap(a);};H.ptr.prototype.cat=function(a,b){var a,b,c;c=this;if((a.i===0)||(b.i===0)){return new G.ptr(0,0);}new F(a.out).patch(c.p,b.i);return new G.ptr(a.i,b.out);};H.prototype.cat=function(a,b){return this.$val.cat(a,b);};H.ptr.prototype.alt=function(a,b){var a,b,c,d,e,f,g;c=this;if(a.i===0){return b;}if(b.i===0){return a;}d=$clone(c.inst(0),G);g=(e=c.p.Inst,f=d.i,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));g.Out=a.i;g.Arg=b.i;d.out=new F(a.out).append(c.p,b.out);return d;};H.prototype.alt=function(a,b){return this.$val.alt(a,b);};H.ptr.prototype.quest=function(a,b){var a,b,c,d,e,f,g;c=this;d=$clone(c.inst(0),G);g=(e=c.p.Inst,f=d.i,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));if(b){g.Arg=a.i;d.out=(((d.i<<1>>>0)>>>0));}else{g.Out=a.i;d.out=(((((d.i<<1>>>0)|1)>>>0)>>>0));}d.out=new F(d.out).append(c.p,a.out);return d;};H.prototype.quest=function(a,b){return this.$val.quest(a,b);};H.ptr.prototype.star=function(a,b){var a,b,c,d,e,f,g;c=this;d=$clone(c.inst(0),G);g=(e=c.p.Inst,f=d.i,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));if(b){g.Arg=a.i;d.out=(((d.i<<1>>>0)>>>0));}else{g.Out=a.i;d.out=(((((d.i<<1>>>0)|1)>>>0)>>>0));}new F(a.out).patch(c.p,d.i);return d;};H.prototype.star=function(a,b){return this.$val.star(a,b);};H.ptr.prototype.plus=function(a,b){var a,b,c;c=this;return new G.ptr(a.i,c.star($clone(a,G),b).out);};H.prototype.plus=function(a,b){return this.$val.plus(a,b);};H.ptr.prototype.empty=function(a){var a,b,c,d,e;b=this;c=$clone(b.inst(3),G);(d=b.p.Inst,e=c.i,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e])).Arg=((a>>>0));c.out=(((c.i<<1>>>0)>>>0));return c;};H.prototype.empty=function(a){return this.$val.empty(a);};H.ptr.prototype.rune=function(a,b){var a,b,c,d,e,f,g;c=this;d=$clone(c.inst(7),G);g=(e=c.p.Inst,f=d.i,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));g.Rune=a;b=(b&(1))>>>0;if(!((a.$length===1))||(A.SimpleFold((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]))===(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]))){b=(b&~(1))<<16>>>16;}g.Arg=((b>>>0));d.out=(((d.i<<1>>>0)>>>0));if((((b&1)>>>0)===0)&&((a.$length===1)||(a.$length===2)&&((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])===(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])))){g.Op=8;}else if((a.$length===2)&&((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])===0)&&((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])===1114111)){g.Op=9;}else if((a.$length===4)&&((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])===0)&&((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])===9)&&((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2])===11)&&((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3])===1114111)){g.Op=10;}return d;};H.prototype.rune=function(a,b){return this.$val.rune(a,b);};BW.prototype.String=function(){var a,b;a=this.$val;if(1<=a&&a<=19){a=a-(1)<<24>>>24;return $substring("NoMatchEmptyMatchLiteralCharClassAnyCharNotNLAnyCharBeginLineEndLineBeginTextEndTextWordBoundaryNoWordBoundaryCaptureStarPlusQuestRepeatConcatAlternate",((a<0||a>=L.length)?($throwRuntimeError("index out of range"),undefined):L[a]),(b=a+1<<24>>>24,((b<0||b>=L.length)?($throwRuntimeError("index out of range"),undefined):L[b])));}else if((a===128)){return"opPseudo";}else{return"Op("+B.FormatInt((new $Int64(0,a)),10)+")";}};$ptrType(BW).prototype.String=function(){return new BW(this.$get()).String();};M.ptr.prototype.Error=function(){var a;a=this;return"error parsing regexp: "+new N(a.Code).String()+": `"+a.Expr+"`";};M.prototype.Error=function(){return this.$val.Error();};N.prototype.String=function(){var a;a=this.$val;return(a);};$ptrType(N).prototype.String=function(){return new N(this.$get()).String();};P.ptr.prototype.newRegexp=function(a){var a,b,c;b=this;c=b.free;if(!(c===CG.nil)){b.free=c.Sub0[0];BV.copy(c,new BV.ptr(0,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,""));}else{c=new BV.ptr(0,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");}c.Op=a;return c;};P.prototype.newRegexp=function(a){return this.$val.newRegexp(a);};P.ptr.prototype.reuse=function(a){var a,b;b=this;a.Sub0[0]=b.free;b.free=a;};P.prototype.reuse=function(a){return this.$val.reuse(a);};P.ptr.prototype.push=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;b=this;if((a.Op===4)&&(a.Rune.$length===2)&&((c=a.Rune,(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]))===(d=a.Rune,(1>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+1])))){if(b.maybeConcat((s=a.Rune,(0>=s.$length?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+0])),(b.flags&~1)<<16>>>16)){return CG.nil;}a.Op=3;a.Rune=$subslice(a.Rune,0,1);a.Flags=(b.flags&~1)<<16>>>16;}else if((a.Op===4)&&(a.Rune.$length===4)&&((e=a.Rune,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]))===(f=a.Rune,(1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1])))&&((g=a.Rune,(2>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+2]))===(h=a.Rune,(3>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+3])))&&(A.SimpleFold((i=a.Rune,(0>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+0])))===(j=a.Rune,(2>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+2])))&&(A.SimpleFold((k=a.Rune,(2>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+2])))===(l=a.Rune,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0])))||(a.Op===4)&&(a.Rune.$length===2)&&(((m=a.Rune,(0>=m.$length?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+0]))+1>>0)===(n=a.Rune,(1>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+1])))&&(A.SimpleFold((o=a.Rune,(0>=o.$length?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+0])))===(p=a.Rune,(1>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+1])))&&(A.SimpleFold((q=a.Rune,(1>=q.$length?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+1])))===(r=a.Rune,(0>=r.$length?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+0])))){if(b.maybeConcat((t=a.Rune,(0>=t.$length?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+0])),(b.flags|1)>>>0)){return CG.nil;}a.Op=3;a.Rune=$subslice(a.Rune,0,1);a.Flags=(b.flags|1)>>>0;}else{b.maybeConcat(-1,0);}b.stack=$append(b.stack,a);return a;};P.prototype.push=function(a){return this.$val.push(a);};P.ptr.prototype.maybeConcat=function(a,b){var a,b,c,d,e,f,g,h,i,j,k;c=this;d=c.stack.$length;if(d<2){return false;}g=(e=c.stack,f=d-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));j=(h=c.stack,i=d-2>>0,((i<0||i>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+i]));if(!((g.Op===3))||!((j.Op===3))||!((((g.Flags&1)>>>0)===((j.Flags&1)>>>0)))){return false;}j.Rune=$appendSlice(j.Rune,g.Rune);if(a>=0){g.Rune=$subslice(new CA(g.Rune0),0,1);(k=g.Rune,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]=a));g.Flags=b;return true;}c.stack=$subslice(c.stack,0,(d-1>>0));c.reuse(g);return false;};P.prototype.maybeConcat=function(a,b){return this.$val.maybeConcat(a,b);};P.ptr.prototype.newLiteral=function(a,b){var a,b,c,d;c=this;d=c.newRegexp(3);d.Flags=b;if(!((((b&1)>>>0)===0))){a=Q(a);}d.Rune0[0]=a;d.Rune=$subslice(new CA(d.Rune0),0,1);return d;};P.prototype.newLiteral=function(a,b){return this.$val.newLiteral(a,b);};Q=function(a){var a,b,c;if(a<65||a>125251){return a;}b=a;c=a;a=A.SimpleFold(a);while(true){if(!(!((a===c)))){break;}if(b>a){b=a;}a=A.SimpleFold(a);}return b;};P.ptr.prototype.literal=function(a){var a,b;b=this;b.push(b.newLiteral(a,b.flags));};P.prototype.literal=function(a){return this.$val.literal(a);};P.ptr.prototype.op=function(a){var a,b,c;b=this;c=b.newRegexp(a);c.Flags=b.flags;return b.push(c);};P.prototype.op=function(a){return this.$val.op(a);};P.ptr.prototype.repeat=function(a,b,c,d,e,f){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p;g=this;h=g.flags;if(!((((g.flags&64)>>>0)===0))){if(e.length>0&&(e.charCodeAt(0)===63)){e=$substring(e,1);h=(h^(32))<<16>>>16;}if(!(f==="")){return["",new M.ptr("invalid nested repetition operator",$substring(f,0,(f.length-e.length>>0)))];}}i=g.stack.$length;if(i===0){return["",new M.ptr("missing argument to repetition operator",$substring(d,0,(d.length-e.length>>0)))];}l=(j=g.stack,k=i-1>>0,((k<0||k>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]));if(l.Op>=128){return["",new M.ptr("missing argument to repetition operator",$substring(d,0,(d.length-e.length>>0)))];}m=g.newRegexp(a);m.Min=b;m.Max=c;m.Flags=h;m.Sub=$subslice(new CH(m.Sub0),0,1);(n=m.Sub,(0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0]=l));(o=g.stack,p=i-1>>0,((p<0||p>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]=m));if((a===17)&&(b>=2||c>=2)&&!R(m,1000)){return["",new M.ptr("invalid repeat count",$substring(d,0,(d.length-e.length>>0)))];}return[e,$ifaceNil];};P.prototype.repeat=function(a,b,c,d,e,f){return this.$val.repeat(a,b,c,d,e,f);};R=function(a,b){var a,b,c,d,e,f,g;if(a.Op===17){c=a.Max;if(c===0){return true;}if(c<0){c=a.Min;}if(c>b){return false;}if(c>0){b=(d=b/(c),(d===d&&d!==1/0&&d!==-1/0)?d>>0:$throwRuntimeError("integer divide by zero"));}}e=a.Sub;f=0;while(true){if(!(f=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]);if(!R(g,b)){return false;}f++;}return true;};P.ptr.prototype.concat=function(){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;a.maybeConcat(-1,0);b=a.stack.$length;while(true){if(!(b>0&&(c=a.stack,d=b-1>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])).Op<128)){break;}b=b-(1)>>0;}e=$subslice(a.stack,b);a.stack=$subslice(a.stack,0,b);if(e.$length===0){$s=-1;return a.push(a.newRegexp(2));}f=a.collapse(e,18);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=a.push(f);$s=2;case 2:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return g;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.concat};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.concat=function(){return this.$val.concat();};P.ptr.prototype.alternate=function(){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.stack.$length;while(true){if(!(b>0&&(c=a.stack,d=b-1>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])).Op<128)){break;}b=b-(1)>>0;}e=$subslice(a.stack,b);a.stack=$subslice(a.stack,0,b);if(e.$length>0){$s=1;continue;}$s=2;continue;case 1:$r=S((f=e.$length-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f])));$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(e.$length===0){$s=-1;return a.push(a.newRegexp(1));}g=a.collapse(e,19);$s=4;case 4:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=a.push(g);$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.alternate};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.alternate=function(){return this.$val.alternate();};S=function(a){var a,b,c,d,e,f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=a.Op;if(b===(4)){$s=2;continue;}$s=3;continue;case 2:c=AC((a.$ptr_Rune||(a.$ptr_Rune=new CK(function(){return this.$target.Rune;},function($v){this.$target.Rune=$v;},a))));$s=4;case 4:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}a.Rune=c;if((a.Rune.$length===2)&&((d=a.Rune,(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]))===0)&&((e=a.Rune,(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]))===1114111)){a.Rune=CA.nil;a.Op=6;$s=-1;return;}if((a.Rune.$length===4)&&((f=a.Rune,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]))===0)&&((g=a.Rune,(1>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+1]))===9)&&((h=a.Rune,(2>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+2]))===11)&&((i=a.Rune,(3>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+3]))===1114111)){a.Rune=CA.nil;a.Op=5;$s=-1;return;}if((a.Rune.$capacity-a.Rune.$length>>0)>100){a.Rune=$appendSlice($subslice(new CA(a.Rune0),0,0),a.Rune);}case 3:case 1:$s=-1;return;}return;}if($f===undefined){$f={$blk:S};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};P.ptr.prototype.collapse=function(a,b){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(a.$length===1){$s=-1;return(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]);}d=c.newRegexp(b);d.Sub=$subslice(new CH(d.Sub0),0,0);e=a;f=0;while(true){if(!(f=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]);if(g.Op===b){d.Sub=$appendSlice(d.Sub,g.Sub);c.reuse(g);}else{d.Sub=$append(d.Sub,g);}f++;}if(b===19){$s=1;continue;}$s=2;continue;case 1:h=c.factor(d.Sub);$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}d.Sub=h;if(d.Sub.$length===1){i=d;d=(j=d.Sub,(0>=j.$length?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+0]));c.reuse(i);}case 2:$s=-1;return d;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.collapse};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.collapse=function(a,b){return this.$val.collapse(a,b);};P.ptr.prototype.factor=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if(a.$length<2){$s=-1;return a;}c=CA.nil;d=0;e=0;f=$subslice(a,0,0);g=0;case 1:if(!(g<=a.$length)){$s=2;continue;}h=CA.nil;i=0;if(g=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]));h=j[0];i=j[1];if(i===d){k=0;while(true){if(!(k=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k])===((k<0||k>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+k])))){break;}k=k+(1)>>0;}if(k>0){c=$subslice(c,0,k);g=g+(1)>>0;$s=1;continue;}}case 4:if(g===e){$s=5;continue;}if(g===(e+1>>0)){$s=6;continue;}$s=7;continue;case 5:$s=8;continue;case 6:f=$append(f,((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]));$s=8;continue;case 7:l=b.newRegexp(3);l.Flags=d;l.Rune=$appendSlice($subslice(l.Rune,0,0),c);m=e;while(true){if(!(m=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+m]=b.removeLeadingString(((m<0||m>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+m]),c.$length));m=m+(1)>>0;}n=b.collapse($subslice(a,e,g),19);$s=9;case 9:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}o=n;p=b.newRegexp(18);p.Sub=$append($subslice(p.Sub,0,0),l,o);f=$append(f,p);case 8:e=g;c=h;d=i;g=g+(1)>>0;$s=1;continue;case 2:a=f;e=0;f=$subslice(a,0,0);q=CG.nil;r=0;case 10:if(!(r<=a.$length)){$s=11;continue;}s=CG.nil;if(r=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+r]));if(!(q===CG.nil)&&q.Equal(s)&&(W(q)||((q.Op===17)&&(q.Min===q.Max)&&W((t=q.Sub,(0>=t.$length?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+0])))))){r=r+(1)>>0;$s=10;continue;}case 13:if(r===e){$s=14;continue;}if(r===(e+1>>0)){$s=15;continue;}$s=16;continue;case 14:$s=17;continue;case 15:f=$append(f,((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]));$s=17;continue;case 16:u=q;v=e;while(true){if(!(v=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+v]=b.removeLeadingRegexp(((v<0||v>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+v]),w));v=v+(1)>>0;}x=b.collapse($subslice(a,e,r),19);$s=18;case 18:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}y=x;z=b.newRegexp(18);z.Sub=$append($subslice(z.Sub,0,0),u,y);f=$append(f,z);case 17:e=r;q=s;r=r+(1)>>0;$s=10;continue;case 11:a=f;e=0;f=$subslice(a,0,0);aa=0;case 19:if(!(aa<=a.$length)){$s=20;continue;}if(aa=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+aa]))){$s=21;continue;}$s=22;continue;case 21:aa=aa+(1)>>0;$s=19;continue;case 22:if(aa===e){$s=23;continue;}if(aa===(e+1>>0)){$s=24;continue;}$s=25;continue;case 23:$s=26;continue;case 24:f=$append(f,((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]));$s=26;continue;case 25:ab=e;ac=e+1>>0;while(true){if(!(ac=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ab]).Op<((ac<0||ac>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ac]).Op||(((ab<0||ab>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ab]).Op===((ac<0||ac>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ac]).Op)&&((ab<0||ab>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ab]).Rune.$length<((ac<0||ac>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ac]).Rune.$length){ab=ac;}ac=ac+(1)>>0;}ad=((ab<0||ab>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ab]);ae=((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]);((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]=ad);((ab<0||ab>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ab]=ae);af=e+1>>0;while(true){if(!(af=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]),((af<0||af>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+af]));b.reuse(((af<0||af>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+af]));af=af+(1)>>0;}$r=S(((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]));$s=27;case 27:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}f=$append(f,((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e]));case 26:if(aa=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+aa]));}e=aa+1>>0;aa=aa+(1)>>0;$s=19;continue;case 20:a=f;e=0;f=$subslice(a,0,0);ag=a;ah=0;while(true){if(!(ah>0)=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ai]).Op===2)&&((aj=ai+1>>0,((aj<0||aj>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+aj])).Op===2)){ah++;continue;}f=$append(f,((ai<0||ai>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+ai]));ah++;}a=f;$s=-1;return a;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.factor};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.factor=function(a){return this.$val.factor(a);};P.ptr.prototype.leadingString=function(a){var a,b,c;b=this;if((a.Op===18)&&a.Sub.$length>0){a=(c=a.Sub,(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]));}if(!((a.Op===3))){return[CA.nil,0];}return[a.Rune,(a.Flags&1)>>>0];};P.prototype.leadingString=function(a){return this.$val.leadingString(a);};P.ptr.prototype.removeLeadingString=function(a,b){var a,b,c,d,e,f,g,h,i;c=this;if((a.Op===18)&&a.Sub.$length>0){e=(d=a.Sub,(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]));e=c.removeLeadingString(e,b);(f=a.Sub,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]=e));if(e.Op===2){c.reuse(e);g=a.Sub.$length;if((g===(0))||(g===(1))){a.Op=2;a.Sub=CH.nil;}else if(g===(2)){h=a;a=(i=a.Sub,(1>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+1]));c.reuse(h);}else{$copySlice(a.Sub,$subslice(a.Sub,1));a.Sub=$subslice(a.Sub,0,(a.Sub.$length-1>>0));}}return a;}if(a.Op===3){a.Rune=$subslice(a.Rune,0,$copySlice(a.Rune,$subslice(a.Rune,b)));if(a.Rune.$length===0){a.Op=2;}}return a;};P.prototype.removeLeadingString=function(a,b){return this.$val.removeLeadingString(a,b);};P.ptr.prototype.leadingRegexp=function(a){var a,b,c,d;b=this;if(a.Op===2){return CG.nil;}if((a.Op===18)&&a.Sub.$length>0){d=(c=a.Sub,(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]));if(d.Op===2){return CG.nil;}return d;}return a;};P.prototype.leadingRegexp=function(a){return this.$val.leadingRegexp(a);};P.ptr.prototype.removeLeadingRegexp=function(a,b){var a,b,c,d,e,f,g;c=this;if((a.Op===18)&&a.Sub.$length>0){if(b){c.reuse((d=a.Sub,(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])));}a.Sub=$subslice(a.Sub,0,$copySlice(a.Sub,$subslice(a.Sub,1)));e=a.Sub.$length;if(e===(0)){a.Op=2;a.Sub=CH.nil;}else if(e===(1)){f=a;a=(g=a.Sub,(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]));c.reuse(f);}return a;}if(b){c.reuse(a);}return c.newRegexp(2);};P.prototype.removeLeadingRegexp=function(a,b){return this.$val.removeLeadingRegexp(a,b);};T=function(a,b){var a,b,c,d,e,f,g;c=new BV.ptr(3,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");c.Flags=b;c.Rune=$subslice(new CA(c.Rune0),0,0);d=a;e=0;while(true){if(!(e=c.Rune.$capacity){c.Rune=(new CA($stringToRunes(a)));break;}c.Rune=$append(c.Rune,g);e+=f[1];}return c;};U=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:if(!((((b&2)>>>0)===0))){c=AN(a);if(!($interfaceIsEqual(c,$ifaceNil))){$s=-1;return[CG.nil,c];}$s=-1;return[T(a,b),$ifaceNil];}d=new P.ptr(0,CH.nil,CG.nil,0,"",CA.nil);e=$ifaceNil;f=0;g=0;h="";d.flags=b;d.wholeRegexp=a;i=a;case 1:if(!(!(i===""))){$s=2;continue;}j="";k=i.charCodeAt(0);if(k===(40)){$s=4;continue;}if(k===(124)){$s=5;continue;}if(k===(41)){$s=6;continue;}if(k===(94)){$s=7;continue;}if(k===(36)){$s=8;continue;}if(k===(46)){$s=9;continue;}if(k===(91)){$s=10;continue;}if((k===(42))||(k===(43))||(k===(63))){$s=11;continue;}if(k===(123)){$s=12;continue;}if(k===(92)){$s=13;continue;}$s=14;continue;case 4:if(!((((d.flags&64)>>>0)===0))&&i.length>=2&&(i.charCodeAt(1)===63)){l=d.parsePerlFlags(i);i=l[0];e=l[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}$s=3;continue;}d.numCap=d.numCap+(1)>>0;d.op(128).Cap=d.numCap;i=$substring(i,1);$s=15;continue;case 5:m=d.parseVerticalBar();$s=16;case 16:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}e=m;if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}i=$substring(i,1);$s=15;continue;case 6:n=d.parseRightParen();$s=17;case 17:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}e=n;if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}i=$substring(i,1);$s=15;continue;case 7:if(!((((d.flags&16)>>>0)===0))){d.op(9);}else{d.op(7);}i=$substring(i,1);$s=15;continue;case 8:if(!((((d.flags&16)>>>0)===0))){o=d.op(10);o.Flags=(o.Flags|(256))>>>0;}else{d.op(8);}i=$substring(i,1);$s=15;continue;case 9:if(!((((d.flags&8)>>>0)===0))){d.op(6);}else{d.op(5);}i=$substring(i,1);$s=15;continue;case 10:q=d.parseClass(i);$s=18;case 18:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;i=p[0];e=p[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}$s=15;continue;case 11:r=i;s=i.charCodeAt(0);if(s===(42)){g=14;}else if(s===(43)){g=15;}else if(s===(63)){g=16;}t=$substring(i,1);u=d.repeat(g,0,0,r,t,h);t=u[0];e=u[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}j=r;i=t;$s=15;continue;case 12:g=17;v=i;w=d.parseRepeat(i);x=w[0];y=w[1];z=w[2];aa=w[3];if(!aa){d.literal(123);i=$substring(i,1);$s=3;continue;}if(x<0||x>1000||y>1000||y>=0&&x>y){$s=-1;return[CG.nil,new M.ptr("invalid repeat count",$substring(v,0,(v.length-z.length>>0)))];}ab=d.repeat(g,x,y,v,z,h);z=ab[0];e=ab[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}j=v;i=z;$s=15;continue;case 13:if(!((((d.flags&64)>>>0)===0))&&i.length>=2){ac=i.charCodeAt(1);if(ac===(65)){d.op(9);i=$substring(i,2);$s=3;continue s;}else if(ac===(98)){d.op(11);i=$substring(i,2);$s=3;continue s;}else if(ac===(66)){d.op(12);i=$substring(i,2);$s=3;continue s;}else if(ac===(67)){$s=-1;return[CG.nil,new M.ptr("invalid escape sequence",$substring(i,0,2))];}else if(ac===(81)){ad="";ae=D.Index(i,"\\E");if(ae<0){ad=$substring(i,2);i="";}else{ad=$substring(i,2,ae);i=$substring(i,(ae+2>>0));}while(true){if(!(!(ad===""))){break;}af=AO(ad);ag=af[0];ah=af[1];ai=af[2];if(!($interfaceIsEqual(ai,$ifaceNil))){$s=-1;return[CG.nil,ai];}d.literal(ag);ad=ah;}$s=3;continue s;}else if(ac===(122)){d.op(10);i=$substring(i,2);$s=3;continue s;}}aj=d.newRegexp(4);aj.Flags=d.flags;if(i.length>=2&&((i.charCodeAt(1)===112)||(i.charCodeAt(1)===80))){$s=19;continue;}$s=20;continue;case 19:al=d.parseUnicodeClass(i,$subslice(new CA(aj.Rune0),0,0));$s=21;case 21:if($c){$c=false;al=al.$blk();}if(al&&al.$blk!==undefined){break s;}ak=al;am=ak[0];an=ak[1];ao=ak[2];if(!($interfaceIsEqual(ao,$ifaceNil))){$s=-1;return[CG.nil,ao];}if(!(am===CA.nil)){aj.Rune=am;i=an;d.push(aj);$s=3;continue s;}case 20:aq=d.parsePerlClassEscape(i,$subslice(new CA(aj.Rune0),0,0));$s=22;case 22:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ap=aq;ar=ap[0];as=ap[1];if(!(ar===CA.nil)){aj.Rune=ar;i=as;d.push(aj);$s=3;continue s;}d.reuse(aj);at=d.parseEscape(i);f=at[0];i=at[1];e=at[2];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}d.literal(f);$s=15;continue;case 14:au=AO(i);f=au[0];i=au[1];e=au[2];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[CG.nil,e];}d.literal(f);case 15:case 3:h=j;$s=1;continue;case 2:av=d.concat();$s=23;case 23:if($c){$c=false;av=av.$blk();}if(av&&av.$blk!==undefined){break s;}av;aw=d.swapVerticalBar();$s=26;case 26:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}if(aw){$s=24;continue;}$s=25;continue;case 24:d.stack=$subslice(d.stack,0,(d.stack.$length-1>>0));case 25:ax=d.alternate();$s=27;case 27:if($c){$c=false;ax=ax.$blk();}if(ax&&ax.$blk!==undefined){break s;}ax;ay=d.stack.$length;if(!((ay===1))){$s=-1;return[CG.nil,new M.ptr("missing closing )",a)];}$s=-1;return[(az=d.stack,(0>=az.$length?($throwRuntimeError("index out of range"),undefined):az.$array[az.$offset+0])),$ifaceNil];}return;}if($f===undefined){$f={$blk:U};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Parse=U;P.ptr.prototype.parseRepeat=function(a){var a,b,c,d,e,f,g,h,i;b=0;c=0;d="";e=false;f=this;if(a===""||!((a.charCodeAt(0)===123))){return[b,c,d,e];}a=$substring(a,1);g=false;h=f.parseInt(a);b=h[0];a=h[1];g=h[2];if(!g){return[b,c,d,e];}if(a===""){return[b,c,d,e];}if(!((a.charCodeAt(0)===44))){c=b;}else{a=$substring(a,1);if(a===""){return[b,c,d,e];}if(a.charCodeAt(0)===125){c=-1;}else{i=f.parseInt(a);c=i[0];a=i[1];g=i[2];if(!g){return[b,c,d,e];}else if(c<0){b=-1;}}}if(a===""||!((a.charCodeAt(0)===125))){return[b,c,d,e];}d=$substring(a,1);e=true;return[b,c,d,e];};P.prototype.parseRepeat=function(a){return this.$val.parseRepeat(a);};P.ptr.prototype.parsePerlFlags=function(a){var a,aa,ab,ac,ad,ae,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;b="";c=$ifaceNil;d=this;e=a;if(e.length>4&&(e.charCodeAt(2)===80)&&(e.charCodeAt(3)===60)){f=D.IndexRune(e,62);if(f<0){c=AN(e);if(!($interfaceIsEqual(c,$ifaceNil))){g="";h=c;b=g;c=h;return[b,c];}i="";j=new M.ptr("invalid named capture",a);b=i;c=j;return[b,c];}k=$substring(e,0,(f+1>>0));l=$substring(e,4,f);c=AN(l);if(!($interfaceIsEqual(c,$ifaceNil))){m="";n=c;b=m;c=n;return[b,c];}if(!V(l)){o="";p=new M.ptr("invalid named capture",k);b=o;c=p;return[b,c];}d.numCap=d.numCap+(1)>>0;q=d.op(128);q.Cap=d.numCap;q.Name=l;r=$substring(e,(f+1>>0));s=$ifaceNil;b=r;c=s;return[b,c];}t=0;e=$substring(e,2);u=d.flags;v=1;w=false;Loop:while(true){if(!(!(e===""))){break;}x=AO(e);t=x[0];e=x[1];c=x[2];if(!($interfaceIsEqual(c,$ifaceNil))){y="";z=c;b=y;c=z;return[b,c];}aa=t;if(aa===(105)){u=(u|(1))>>>0;w=true;}else if(aa===(109)){u=(u&~(16))<<16>>>16;w=true;}else if(aa===(115)){u=(u|(8))>>>0;w=true;}else if(aa===(85)){u=(u|(32))>>>0;w=true;}else if(aa===(45)){if(v<0){break Loop;}v=-1;u=~u<<16>>>16;w=false;}else if((aa===(58))||(aa===(41))){if(v<0){if(!w){break Loop;}u=~u<<16>>>16;}if(t===58){d.op(128);}d.flags=u;ab=e;ac=$ifaceNil;b=ab;c=ac;return[b,c];}else{break Loop;}}ad="";ae=new M.ptr("invalid or unsupported Perl syntax",$substring(a,0,(a.length-e.length>>0)));b=ad;c=ae;return[b,c];};P.prototype.parsePerlFlags=function(a){return this.$val.parsePerlFlags(a);};V=function(a){var a,b,c,d,e;if(a===""){return false;}b=a;c=0;while(true){if(!(c=2&&(a.charCodeAt(0)===48)&&48<=a.charCodeAt(1)&&a.charCodeAt(1)<=57){return[b,c,d];}f=a;while(true){if(!(!(a==="")&&48<=a.charCodeAt(0)&&a.charCodeAt(0)<=57)){break;}a=$substring(a,1);}c=a;d=true;f=$substring(f,0,(f.length-a.length>>0));g=0;while(true){if(!(g=100000000){b=-1;break;}b=(($imul(b,10))+((f.charCodeAt(g)>>0))>>0)-48>>0;g=g+(1)>>0;}return[b,c,d];};P.prototype.parseInt=function(a){return this.$val.parseInt(a);};W=function(a){var a;return(a.Op===3)&&(a.Rune.$length===1)||(a.Op===4)||(a.Op===5)||(a.Op===6);};X=function(a,b){var a,b,c,d,e,f,g,h;c=a.Op;if(c===(3)){return(a.Rune.$length===1)&&((d=a.Rune,(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]))===b);}else if(c===(4)){e=0;while(true){if(!(e=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]))<=b&&b<=(g=a.Rune,h=e+1>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]))){return true;}e=e+(2)>>0;}return false;}else if(c===(5)){return!((b===10));}else if(c===(6)){return true;}return false;};P.ptr.prototype.parseVerticalBar=function(){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.concat();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}b;c=a.swapVerticalBar();$s=4;case 4:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}if(!c){$s=2;continue;}$s=3;continue;case 2:a.op(129);case 3:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parseVerticalBar};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parseVerticalBar=function(){return this.$val.parseVerticalBar();};Y=function(a,b){var a,b,c,d,e,f,g,h;switch(0){default:c=a.Op;if(c===(6)){}else if(c===(5)){if(X(b,10)){a.Op=6;}}else if(c===(4)){if(b.Op===3){a.Rune=AD(a.Rune,(d=b.Rune,(0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])),b.Flags);}else{a.Rune=AG(a.Rune,b.Rune);}}else if(c===(3)){if(((e=b.Rune,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]))===(f=a.Rune,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0])))&&(b.Flags===a.Flags)){break;}a.Op=4;a.Rune=AD($subslice(a.Rune,0,0),(g=a.Rune,(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0])),a.Flags);a.Rune=AD(a.Rune,(h=b.Rune,(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0])),b.Flags);}}};P.ptr.prototype.swapVerticalBar=function(){var a,aa,ab,ac,ad,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.stack.$length;if(b>=3&&((c=a.stack,d=b-2>>0,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])).Op===129)&&W((e=a.stack,f=b-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f])))&&W((g=a.stack,h=b-3>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h])))){k=(i=a.stack,j=b-1>>0,((j<0||j>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]));n=(l=a.stack,m=b-3>>0,((m<0||m>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]));if(k.Op>n.Op){o=n;p=k;k=o;n=p;(q=a.stack,r=b-3>>0,((r<0||r>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r]=n));}Y(n,k);a.reuse(k);a.stack=$subslice(a.stack,0,(b-1>>0));$s=-1;return true;}if(b>=2){$s=1;continue;}$s=2;continue;case 1:u=(s=a.stack,t=b-1>>0,((t<0||t>=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+t]));x=(v=a.stack,w=b-2>>0,((w<0||w>=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+w]));if(x.Op===129){$s=3;continue;}$s=4;continue;case 3:if(b>=3){$s=5;continue;}$s=6;continue;case 5:$r=S((y=a.stack,z=b-3>>0,((z<0||z>=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+z])));$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 6:(aa=a.stack,ab=b-2>>0,((ab<0||ab>=aa.$length)?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+ab]=u));(ac=a.stack,ad=b-1>>0,((ad<0||ad>=ac.$length)?($throwRuntimeError("index out of range"),undefined):ac.$array[ac.$offset+ad]=x));$s=-1;return true;case 4:case 2:$s=-1;return false;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.swapVerticalBar};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.swapVerticalBar=function(){return this.$val.swapVerticalBar();};P.ptr.prototype.parseRightParen=function(){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.concat();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}b;c=a.swapVerticalBar();$s=4;case 4:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}if(c){$s=2;continue;}$s=3;continue;case 2:a.stack=$subslice(a.stack,0,(a.stack.$length-1>>0));case 3:d=a.alternate();$s=5;case 5:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}d;e=a.stack.$length;if(e<2){$s=-1;return new M.ptr("unexpected )",a.wholeRegexp);}h=(f=a.stack,g=e-1>>0,((g<0||g>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]));k=(i=a.stack,j=e-2>>0,((j<0||j>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]));a.stack=$subslice(a.stack,0,(e-2>>0));if(!((k.Op===128))){$s=-1;return new M.ptr("unexpected )",a.wholeRegexp);}a.flags=k.Flags;if(k.Cap===0){a.push(h);}else{k.Op=13;k.Sub=$subslice(new CH(k.Sub0),0,1);(l=k.Sub,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0]=h));a.push(k);}$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parseRightParen};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parseRightParen=function(){return this.$val.parseRightParen();};P.ptr.prototype.parseEscape=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;b=0;c="";d=$ifaceNil;e=this;f=$substring(a,1);if(f===""){g=0;h="";i=new M.ptr("trailing backslash at end of expression","");b=g;c=h;d=i;return[b,c,d];}j=AO(f);k=j[0];f=j[1];d=j[2];if(!($interfaceIsEqual(d,$ifaceNil))){l=0;m="";n=d;b=l;c=m;d=n;return[b,c,d];}Switch:switch(0){default:o=k;if((o===(49))||(o===(50))||(o===(51))||(o===(52))||(o===(53))||(o===(54))||(o===(55))){if(f===""||f.charCodeAt(0)<48||f.charCodeAt(0)>55){break;}b=k-48>>0;p=1;while(true){if(!(p<3)){break;}if(f===""||f.charCodeAt(0)<48||f.charCodeAt(0)>55){break;}b=(($imul(b,8))+((f.charCodeAt(0)>>0))>>0)-48>>0;f=$substring(f,1);p=p+(1)>>0;}q=b;r=f;s=$ifaceNil;b=q;c=r;d=s;return[b,c,d];}else if(o===(48)){b=k-48>>0;p=1;while(true){if(!(p<3)){break;}if(f===""||f.charCodeAt(0)<48||f.charCodeAt(0)>55){break;}b=(($imul(b,8))+((f.charCodeAt(0)>>0))>>0)-48>>0;f=$substring(f,1);p=p+(1)>>0;}t=b;u=f;v=$ifaceNil;b=t;c=u;d=v;return[b,c,d];}else if(o===(120)){if(f===""){break;}w=AO(f);k=w[0];f=w[1];d=w[2];if(!($interfaceIsEqual(d,$ifaceNil))){x=0;y="";z=d;b=x;c=y;d=z;return[b,c,d];}if(k===123){aa=0;b=0;while(true){if(f===""){break Switch;}ab=AO(f);k=ab[0];f=ab[1];d=ab[2];if(!($interfaceIsEqual(d,$ifaceNil))){ac=0;ad="";ae=d;b=ac;c=ad;d=ae;return[b,c,d];}if(k===125){break;}af=AQ(k);if(af<0){break Switch;}b=($imul(b,16))+af>>0;if(b>1114111){break Switch;}aa=aa+(1)>>0;}if(aa===0){break Switch;}ag=b;ah=f;ai=$ifaceNil;b=ag;c=ah;d=ai;return[b,c,d];}aj=AQ(k);ak=AO(f);k=ak[0];f=ak[1];d=ak[2];if(!($interfaceIsEqual(d,$ifaceNil))){al=0;am="";an=d;b=al;c=am;d=an;return[b,c,d];}ao=AQ(k);if(aj<0||ao<0){break;}ap=($imul(aj,16))+ao>>0;aq=f;ar=$ifaceNil;b=ap;c=aq;d=ar;return[b,c,d];}else if(o===(97)){as=7;at=f;au=d;b=as;c=at;d=au;return[b,c,d];}else if(o===(102)){av=12;aw=f;ax=d;b=av;c=aw;d=ax;return[b,c,d];}else if(o===(110)){ay=10;az=f;ba=d;b=ay;c=az;d=ba;return[b,c,d];}else if(o===(114)){bb=13;bc=f;bd=d;b=bb;c=bc;d=bd;return[b,c,d];}else if(o===(116)){be=9;bf=f;bg=d;b=be;c=bf;d=bg;return[b,c,d];}else if(o===(118)){bh=11;bi=f;bj=d;b=bh;c=bi;d=bj;return[b,c,d];}else if(k<128&&!AP(k)){bk=k;bl=f;bm=$ifaceNil;b=bk;c=bl;d=bm;return[b,c,d];}}bn=0;bo="";bp=new M.ptr("invalid escape sequence",$substring(a,0,(a.length-f.length>>0)));b=bn;c=bo;d=bp;return[b,c,d];};P.prototype.parseEscape=function(a){return this.$val.parseEscape(a);};P.ptr.prototype.parseClassChar=function(a,b){var a,b,c,d,e,f,g,h,i,j,k;c=0;d="";e=$ifaceNil;f=this;if(a===""){g=0;h="";i=new M.ptr("missing closing ]",b);c=g;d=h;e=i;return[c,d,e];}if(a.charCodeAt(0)===92){j=f.parseEscape(a);c=j[0];d=j[1];e=j[2];return[c,d,e];}k=AO(a);c=k[0];d=k[1];e=k[2];return[c,d,e];};P.prototype.parseClassChar=function(a,b){return this.$val.parseClassChar(a,b);};P.ptr.prototype.parsePerlClassEscape=function(a,b){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=CA.nil;d="";e=this;if((((e.flags&64)>>>0)===0)||a.length<2||!((a.charCodeAt(0)===92))){$s=-1;return[c,d];}g=$clone((f=AU[$String.keyFor($substring(a,0,2))],f!==undefined?f.v:new Z.ptr(0,CA.nil)),Z);if(g.sign===0){$s=-1;return[c,d];}i=e.appendGroup(b,$clone(g,Z));$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;j=$substring(a,2);c=h;d=j;$s=-1;return[c,d];}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parsePerlClassEscape};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parsePerlClassEscape=function(a,b){return this.$val.parsePerlClassEscape(a,b);};P.ptr.prototype.parseNamedClass=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=CA.nil;d="";e=$ifaceNil;f=this;if(a.length<2||!((a.charCodeAt(0)===91))||!((a.charCodeAt(1)===58))){$s=-1;return[c,d,e];}g=D.Index($substring(a,2),":]");if(g<0){$s=-1;return[c,d,e];}g=g+(2)>>0;h=$substring(a,0,(g+2>>0));i=$substring(a,(g+2>>0));j=h;a=i;l=$clone((k=BJ[$String.keyFor(j)],k!==undefined?k.v:new Z.ptr(0,CA.nil)),Z);if(l.sign===0){m=CA.nil;n="";o=new M.ptr("invalid character class range",j);c=m;d=n;e=o;$s=-1;return[c,d,e];}q=f.appendGroup(b,$clone(l,Z));$s=1;case 1:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;r=a;s=$ifaceNil;c=p;d=r;e=s;$s=-1;return[c,d,e];}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parseNamedClass};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parseNamedClass=function(a,b){return this.$val.parseNamedClass(a,b);};P.ptr.prototype.appendGroup=function(a,b){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(((c.flags&1)>>>0)===0){$s=1;continue;}$s=2;continue;case 1:if(b.sign<0){a=AI(a,b.class$1);}else{a=AG(a,b.class$1);}$s=3;continue;case 2:d=$subslice(c.tmpClass,0,0);d=AH(d,b.class$1);c.tmpClass=d;e=AC((c.$ptr_tmpClass||(c.$ptr_tmpClass=new CK(function(){return this.$target.tmpClass;},function($v){this.$target.tmpClass=$v;},c))));$s=4;case 4:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;if(b.sign<0){a=AI(a,d);}else{a=AG(a,d);}case 3:$s=-1;return a;}return;}if($f===undefined){$f={$blk:P.ptr.prototype.appendGroup};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.appendGroup=function(a,b){return this.$val.appendGroup(a,b);};AB=function(a){var a,b,c,d,e,f,g;if(a==="Any"){return[AA,AA];}c=(b=A.Categories[$String.keyFor(a)],b!==undefined?b.v:CL.nil);if(!(c===CL.nil)){return[c,(d=A.FoldCategory[$String.keyFor(a)],d!==undefined?d.v:CL.nil)];}f=(e=A.Scripts[$String.keyFor(a)],e!==undefined?e.v:CL.nil);if(!(f===CL.nil)){return[f,(g=A.FoldScript[$String.keyFor(a)],g!==undefined?g.v:CL.nil)];}return[CL.nil,CL.nil];};P.ptr.prototype.parseUnicodeClass=function(a,b){var a,aa,ab,ac,ad,ae,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=CA.nil;d="";e=$ifaceNil;f=this;if((((f.flags&128)>>>0)===0)||a.length<2||!((a.charCodeAt(0)===92))||!((a.charCodeAt(1)===112))&&!((a.charCodeAt(1)===80))){$s=-1;return[c,d,e];}g=1;if(a.charCodeAt(1)===80){g=-1;}h=$substring(a,2);i=AO(h);j=i[0];h=i[1];e=i[2];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[c,d,e];}k="";l="";m=k;n=l;if(!((j===123))){m=$substring(a,0,(a.length-h.length>>0));n=$substring(m,2);}else{o=D.IndexRune(a,125);if(o<0){e=AN(a);if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[c,d,e];}p=CA.nil;q="";r=new M.ptr("invalid character class range",a);c=p;d=q;e=r;$s=-1;return[c,d,e];}s=$substring(a,0,(o+1>>0));t=$substring(a,(o+1>>0));m=s;h=t;n=$substring(a,3,o);e=AN(n);if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[c,d,e];}}if(!(n==="")&&(n.charCodeAt(0)===94)){g=-g;n=$substring(n,1);}u=AB(n);v=u[0];w=u[1];if(v===CL.nil){x=CA.nil;y="";z=new M.ptr("invalid character class range",m);c=x;d=y;e=z;$s=-1;return[c,d,e];}if((((f.flags&1)>>>0)===0)||w===CL.nil){$s=1;continue;}$s=2;continue;case 1:if(g>0){b=AJ(b,v);}else{b=AK(b,v);}$s=3;continue;case 2:aa=$subslice(f.tmpClass,0,0);aa=AJ(aa,v);aa=AJ(aa,w);f.tmpClass=aa;ab=AC((f.$ptr_tmpClass||(f.$ptr_tmpClass=new CK(function(){return this.$target.tmpClass;},function($v){this.$target.tmpClass=$v;},f))));$s=4;case 4:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=ab;if(g>0){b=AG(b,aa);}else{b=AI(b,aa);}case 3:ac=b;ad=h;ae=$ifaceNil;c=ac;d=ad;e=ae;$s=-1;return[c,d,e];}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parseUnicodeClass};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parseUnicodeClass=function(a,b){return this.$val.parseUnicodeClass(a,b);};P.ptr.prototype.parseClass=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;b=$f.b;ba=$f.ba;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b="";c=$ifaceNil;d=this;e=$substring(a,1);f=d.newRegexp(4);f.Flags=d.flags;f.Rune=$subslice(new CA(f.Rune0),0,0);g=1;if(!(e==="")&&(e.charCodeAt(0)===94)){g=-1;e=$substring(e,1);if(((d.flags&4)>>>0)===0){f.Rune=$append(f.Rune,10,10);}}h=f.Rune;i=true;case 1:if(!(e===""||!((e.charCodeAt(0)===93))||i)){$s=2;continue;}if(!(e==="")&&(e.charCodeAt(0)===45)&&(((d.flags&64)>>>0)===0)&&!i&&((e.length===1)||!((e.charCodeAt(1)===93)))){j=E.DecodeRuneInString($substring(e,1));k=j[1];l="";m=new M.ptr("invalid character class range",$substring(e,0,(1+k>>0)));b=l;c=m;$s=-1;return[b,c];}i=false;if(e.length>2&&(e.charCodeAt(0)===91)&&(e.charCodeAt(1)===58)){$s=3;continue;}$s=4;continue;case 3:o=d.parseNamedClass(e,h);$s=5;case 5:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}n=o;p=n[0];q=n[1];r=n[2];if(!($interfaceIsEqual(r,$ifaceNil))){s="";t=r;b=s;c=t;$s=-1;return[b,c];}if(!(p===CA.nil)){u=p;v=q;h=u;e=v;$s=1;continue;}case 4:x=d.parseUnicodeClass(e,h);$s=6;case 6:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}w=x;y=w[0];z=w[1];aa=w[2];if(!($interfaceIsEqual(aa,$ifaceNil))){ab="";ac=aa;b=ab;c=ac;$s=-1;return[b,c];}if(!(y===CA.nil)){$s=7;continue;}$s=8;continue;case 7:ad=y;ae=z;h=ad;e=ae;$s=1;continue;case 8:ag=d.parsePerlClassEscape(e,h);$s=9;case 9:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}af=ag;ah=af[0];ai=af[1];if(!(ah===CA.nil)){aj=ah;ak=ai;h=aj;e=ak;$s=1;continue;}al=e;am=0;an=0;ao=am;ap=an;aq=d.parseClassChar(e,a);ao=aq[0];e=aq[1];aa=aq[2];if(!($interfaceIsEqual(aa,$ifaceNil))){ar="";as=aa;b=ar;c=as;$s=-1;return[b,c];}ap=ao;if(e.length>=2&&(e.charCodeAt(0)===45)&&!((e.charCodeAt(1)===93))){e=$substring(e,1);at=d.parseClassChar(e,a);ap=at[0];e=at[1];aa=at[2];if(!($interfaceIsEqual(aa,$ifaceNil))){au="";av=aa;b=au;c=av;$s=-1;return[b,c];}if(ap>0));aw="";ax=new M.ptr("invalid character class range",al);b=aw;c=ax;$s=-1;return[b,c];}}if(((d.flags&1)>>>0)===0){h=AE(h,ao,ap);}else{h=AF(h,ao,ap);}$s=1;continue;case 2:e=$substring(e,1);f.Rune=h;ay=AC((f.$ptr_Rune||(f.$ptr_Rune=new CK(function(){return this.$target.Rune;},function($v){this.$target.Rune=$v;},f))));$s=10;case 10:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}h=ay;if(g<0){h=AL(h);}f.Rune=h;d.push(f);az=e;ba=$ifaceNil;b=az;c=ba;$s=-1;return[b,c];}return;}if($f===undefined){$f={$blk:P.ptr.prototype.parseClass};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.b=b;$f.ba=ba;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};P.prototype.parseClass=function(a){return this.$val.parseClass(a);};AC=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.Sort((b=new AM.ptr(a),new b.constructor.elem(b)));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=a.$get();if(c.$length<2){$s=-1;return c;}d=2;e=2;while(true){if(!(e=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e]);g=(h=e+1>>0,((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h]));i=f;j=g;if(i<=((k=d-1>>0,((k<0||k>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+k]))+1>>0)){if(j>(l=d-1>>0,((l<0||l>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+l]))){(m=d-1>>0,((m<0||m>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+m]=j));}e=e+(2)>>0;continue;}((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=i);(n=d+1>>0,((n<0||n>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+n]=j));d=d+(2)>>0;e=e+(2)>>0;}$s=-1;return $subslice(c,0,d);}return;}if($f===undefined){$f={$blk:AC};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$r=$r;return $f;};AD=function(a,b,c){var a,b,c;if(!((((c&1)>>>0)===0))){return AF(a,b,b);}return AE(a,b,b);};AE=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m;d=a.$length;e=2;while(true){if(!(e<=4)){break;}if(d>=e){f=(g=d-e>>0,((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]));h=(i=(d-e>>0)+1>>0,((i<0||i>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+i]));j=f;k=h;if(b<=(k+1>>0)&&j<=(c+1>>0)){if(b>0,((l<0||l>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+l]=b));}if(c>k){(m=(d-e>>0)+1>>0,((m<0||m>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+m]=c));}return a;}}e=e+(2)>>0;}return $append(a,b,c);};AF=function(a,b,c){var a,b,c,d,e;if(b<=65&&c>=125251){return AE(a,b,c);}if(c<65||b>125251){return AE(a,b,c);}if(b<65){a=AE(a,b,64);b=65;}if(c>125251){a=AE(a,125252,c);c=125251;}d=b;while(true){if(!(d<=c)){break;}a=AE(a,d,d);e=A.SimpleFold(d);while(true){if(!(!((e===d)))){break;}a=AE(a,e,e);e=A.SimpleFold(e);}d=d+(1)>>0;}return a;};AG=function(a,b){var a,b,c,d;c=0;while(true){if(!(c=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c]),(d=c+1>>0,((d<0||d>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+d])));c=c+(2)>>0;}return a;};AH=function(a,b){var a,b,c,d;c=0;while(true){if(!(c=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c]),(d=c+1>>0,((d<0||d>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+d])));c=c+(2)>>0;}return a;};AI=function(a,b){var a,b,c,d,e,f,g,h,i;c=0;d=0;while(true){if(!(d=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+d]);f=(g=d+1>>0,((g<0||g>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+g]));h=e;i=f;if(c<=(h-1>>0)){a=AE(a,c,h-1>>0);}c=i+1>>0;d=d+(2)>>0;}if(c<=1114111){a=AE(a,c,1114111);}return a;};AJ=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;c=b.R16;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),A.Range16);f=((e.Lo>>0));g=((e.Hi>>0));h=((e.Stride>>0));i=f;j=g;k=h;if(k===1){a=AE(a,i,j);d++;continue;}l=i;while(true){if(!(l<=j)){break;}a=AE(a,l,l);l=l+(k)>>0;}d++;}m=b.R32;n=0;while(true){if(!(n=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]),A.Range32);p=((o.Lo>>0));q=((o.Hi>>0));r=((o.Stride>>0));s=p;t=q;u=r;if(u===1){a=AE(a,s,t);n++;continue;}v=s;while(true){if(!(v<=t)){break;}a=AE(a,v,v);v=v+(u)>>0;}n++;}return a;};AK=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;c=0;d=b.R16;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]),A.Range16);g=((f.Lo>>0));h=((f.Hi>>0));i=((f.Stride>>0));j=g;k=h;l=i;if(l===1){if(c<=(j-1>>0)){a=AE(a,c,j-1>>0);}c=k+1>>0;e++;continue;}m=j;while(true){if(!(m<=k)){break;}if(c<=(m-1>>0)){a=AE(a,c,m-1>>0);}c=m+1>>0;m=m+(l)>>0;}e++;}n=b.R32;o=0;while(true){if(!(o=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]),A.Range32);q=((p.Lo>>0));r=((p.Hi>>0));s=((p.Stride>>0));t=q;u=r;v=s;if(v===1){if(c<=(t-1>>0)){a=AE(a,c,t-1>>0);}c=u+1>>0;o++;continue;}w=t;while(true){if(!(w<=u)){break;}if(c<=(w-1>>0)){a=AE(a,c,w-1>>0);}c=w+1>>0;w=w+(v)>>0;}o++;}if(c<=1114111){a=AE(a,c,1114111);}return a;};AL=function(a){var a,b,c,d,e,f,g,h,i,j;b=0;c=0;d=0;while(true){if(!(d=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+d]);f=(g=d+1>>0,((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]));h=e;i=f;if(b<=(h-1>>0)){((c<0||c>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+c]=b);(j=c+1>>0,((j<0||j>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+j]=(h-1>>0)));c=c+(2)>>0;}b=i+1>>0;d=d+(2)>>0;}a=$subslice(a,0,c);if(b<=1114111){a=$append(a,b,1114111);}return a;};AM.ptr.prototype.Less=function(a,b){var a,b,c,d,e,f;c=this;d=c.p.$get();a=$imul(a,(2));b=$imul(b,(2));return((a<0||a>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+a])<((b<0||b>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+b])||(((a<0||a>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+a])===((b<0||b>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+b]))&&(e=a+1>>0,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]))>(f=b+1>>0,((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f]));};AM.prototype.Less=function(a,b){return this.$val.Less(a,b);};AM.ptr.prototype.Len=function(){var a,b;a=this;return(b=a.p.$get().$length/2,(b===b&&b!==1/0&&b!==-1/0)?b>>0:$throwRuntimeError("integer divide by zero"));};AM.prototype.Len=function(){return this.$val.Len();};AM.ptr.prototype.Swap=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l;c=this;d=c.p.$get();a=$imul(a,(2));b=$imul(b,(2));e=((b<0||b>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+b]);f=(g=b+1>>0,((g<0||g>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g]));h=((a<0||a>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+a]);i=(j=a+1>>0,((j<0||j>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+j]));((a<0||a>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+a]=e);(k=a+1>>0,((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k]=f));((b<0||b>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+b]=h);(l=b+1>>0,((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l]=i));};AM.prototype.Swap=function(a,b){return this.$val.Swap(a,b);};AN=function(a){var a,b,c,d;while(true){if(!(!(a===""))){break;}b=E.DecodeRuneInString(a);c=b[0];d=b[1];if((c===65533)&&(d===1)){return new M.ptr("invalid UTF-8",a);}a=$substring(a,d);}return $ifaceNil;};AO=function(a){var a,b,c,d,e,f,g,h,i,j,k,l;b=0;c="";d=$ifaceNil;e=E.DecodeRuneInString(a);b=e[0];f=e[1];if((b===65533)&&(f===1)){g=0;h="";i=new M.ptr("invalid UTF-8",a);b=g;c=h;d=i;return[b,c,d];}j=b;k=$substring(a,f);l=$ifaceNil;b=j;c=k;d=l;return[b,c,d];};AP=function(a){var a;return 48<=a&&a<=57||65<=a&&a<=90||97<=a&&a<=122;};AQ=function(a){var a;if(48<=a&&a<=57){return a-48>>0;}if(97<=a&&a<=102){return(a-97>>0)+10>>0;}if(65<=a&&a<=70){return(a-65>>0)+10>>0;}return-1;};BL.prototype.String=function(){var a;a=this.$val;if(((a>>>0))>=((BM.$length>>>0))){return"";}return((a<0||a>=BM.$length)?($throwRuntimeError("index out of range"),undefined):BM.$array[BM.$offset+a]);};$ptrType(BL).prototype.String=function(){return new BL(this.$get()).String();};BP=function(a){var a;return 65<=a&&a<=90||97<=a&&a<=122||48<=a&&a<=57||(a===95);};$pkg.IsWordChar=BP;BK.ptr.prototype.String=function(){var a,b;a=this;b=new D.Builder.ptr(CM.nil,CN.nil);BS(b,a);return b.String();};BK.prototype.String=function(){return this.$val.String();};BK.ptr.prototype.skipNop=function(a){var a,b,c,d,e,f;b=this;d=(c=b.Inst,((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]));while(true){if(!((d.Op===6)||(d.Op===2))){break;}d=(e=b.Inst,f=d.Out,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));}return d;};BK.prototype.skipNop=function(a){return this.$val.skipNop(a);};BQ.ptr.prototype.op=function(){var a,b,c;a=this;b=a.Op;c=b;if((c===(8))||(c===(9))||(c===(10))){b=7;}return b;};BQ.prototype.op=function(){return this.$val.op();};BK.ptr.prototype.Prefix=function(){var a,b,c,d,e,f,g,h,i,j;a="";b=false;c=this;d=c.skipNop(((c.Start>>>0)));if(!((d.op()===7))||!((d.Rune.$length===1))){e="";f=d.Op===4;a=e;b=f;return[a,b];}g=new D.Builder.ptr(CM.nil,CN.nil);while(true){if(!((d.op()===7)&&(d.Rune.$length===1)&&(((((d.Arg<<16>>>16))&1)>>>0)===0))){break;}g.WriteRune((h=d.Rune,(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0])));d=c.skipNop(d.Out);}i=g.String();j=d.Op===4;a=i;b=j;return[a,b];};BK.prototype.Prefix=function(){return this.$val.Prefix();};BK.ptr.prototype.StartCond=function(){var a,b,c,d,e,f,g;a=this;b=0;c=((a.Start>>>0));e=(d=a.Inst,((c<0||c>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+c]));Loop:while(true){f=e.Op;if(f===(3)){b=(b|(((e.Arg<<24>>>24))))>>>0;}else if(f===(5)){return 255;}else if((f===(2))||(f===(6))){}else{break Loop;}c=e.Out;e=(g=a.Inst,((c<0||c>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+c]));}return b;};BK.prototype.StartCond=function(){return this.$val.StartCond();};BQ.ptr.prototype.MatchRune=function(a){var a,b;b=this;return!((b.MatchRunePos(a)===-1));};BQ.prototype.MatchRune=function(a){return this.$val.MatchRune(a);};BQ.ptr.prototype.MatchRunePos=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;b=this;c=b.Rune;d=c.$length;if(d===(0)){return-1;}else if(d===(1)){e=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0]);if(a===e){return 0;}if(!((((((b.Arg<<16>>>16))&1)>>>0)===0))){f=A.SimpleFold(e);while(true){if(!(!((f===e)))){break;}if(a===f){return 0;}f=A.SimpleFold(f);}}return-1;}else if(d===(2)){if(a>=(0>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+0])&&a<=(1>=c.$length?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+1])){return 0;}return-1;}else if((d===(4))||(d===(6))||(d===(8))){g=0;while(true){if(!(g=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+g])){return-1;}if(a<=(h=g+1>>0,((h<0||h>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+h]))){return(i=g/2,(i===i&&i!==1/0&&i!==-1/0)?i>>0:$throwRuntimeError("integer divide by zero"));}g=g+(2)>>0;}return-1;}j=0;l=(k=c.$length/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"));while(true){if(!(j>0))/2,(m===m&&m!==1/0&&m!==-1/0)?m>>0:$throwRuntimeError("integer divide by zero"))>>0;p=(o=$imul(2,n),((o<0||o>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+o]));if(p<=a){if(a<=(q=($imul(2,n))+1>>0,((q<0||q>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+q]))){return n;}j=n+1>>0;}else{l=n;}}return-1;};BQ.prototype.MatchRunePos=function(a){return this.$val.MatchRunePos(a);};BQ.ptr.prototype.MatchEmptyWidth=function(a,b){var a,b,c,d;c=this;d=((c.Arg<<24>>>24));if(d===(1)){return(a===10)||(a===-1);}else if(d===(2)){return(b===10)||(b===-1);}else if(d===(4)){return a===-1;}else if(d===(8)){return b===-1;}else if(d===(16)){return!(BP(a)===BP(b));}else if(d===(32)){return BP(a)===BP(b);}$panic(new $String("unknown empty width arg"));};BQ.prototype.MatchEmptyWidth=function(a,b){return this.$val.MatchEmptyWidth(a,b);};BQ.ptr.prototype.String=function(){var a,b;a=this;b=new D.Builder.ptr(CM.nil,CN.nil);BU(b,a);return b.String();};BQ.prototype.String=function(){return this.$val.String();};BR=function(a,b){var a,b,c,d,e;c=b;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);a.WriteString(e);d++;}};BS=function(a,b){var a,b,c,d,e,f,g,h;c=b.Inst;d=0;while(true){if(!(d=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+e]));h=B.Itoa(e);if(h.length<3){a.WriteString($substring(" ",h.length));}if(e===b.Start){h=h+("*");}BR(a,new CD([h,"\t"]));BU(a,g);BR(a,new CD(["\n"]));d++;}};BT=function(a){var a;return B.FormatUint((new $Uint64(0,a)),10);};BU=function(a,b){var a,b,c;c=b.Op;if(c===(0)){BR(a,new CD(["alt -> ",BT(b.Out),", ",BT(b.Arg)]));}else if(c===(1)){BR(a,new CD(["altmatch -> ",BT(b.Out),", ",BT(b.Arg)]));}else if(c===(2)){BR(a,new CD(["cap ",BT(b.Arg)," -> ",BT(b.Out)]));}else if(c===(3)){BR(a,new CD(["empty ",BT(b.Arg)," -> ",BT(b.Out)]));}else if(c===(4)){BR(a,new CD(["match"]));}else if(c===(5)){BR(a,new CD(["fail"]));}else if(c===(6)){BR(a,new CD(["nop -> ",BT(b.Out)]));}else if(c===(7)){if(b.Rune===CA.nil){BR(a,new CD(["rune "]));}BR(a,new CD(["rune ",B.QuoteToASCII(($runesToString(b.Rune)))]));if(!((((((b.Arg<<16>>>16))&1)>>>0)===0))){BR(a,new CD(["/i"]));}BR(a,new CD([" -> ",BT(b.Out)]));}else if(c===(8)){BR(a,new CD(["rune1 ",B.QuoteToASCII(($runesToString(b.Rune)))," -> ",BT(b.Out)]));}else if(c===(9)){BR(a,new CD(["any -> ",BT(b.Out)]));}else if(c===(10)){BR(a,new CD(["anynotnl -> ",BT(b.Out)]));}};BV.ptr.prototype.Equal=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;b=this;if(b===CG.nil||a===CG.nil){return b===a;}if(!((b.Op===a.Op))){return false;}c=b.Op;if(c===(10)){if(!((((b.Flags&256)>>>0)===((a.Flags&256)>>>0)))){return false;}}else if((c===(3))||(c===(4))){if(!((b.Rune.$length===a.Rune.$length))){return false;}d=b.Rune;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);if(!((g===(h=a.Rune,((f<0||f>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+f]))))){return false;}e++;}}else if((c===(19))||(c===(18))){if(!((b.Sub.$length===a.Sub.$length))){return false;}i=b.Sub;j=0;while(true){if(!(j=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]);if(!l.Equal((m=a.Sub,((k<0||k>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+k])))){return false;}j++;}}else if((c===(14))||(c===(15))||(c===(16))){if(!((((b.Flags&32)>>>0)===((a.Flags&32)>>>0)))||!(n=b.Sub,(0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0])).Equal((o=a.Sub,(0>=o.$length?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+0])))){return false;}}else if(c===(17)){if(!((((b.Flags&32)>>>0)===((a.Flags&32)>>>0)))||!((b.Min===a.Min))||!((b.Max===a.Max))||!(p=b.Sub,(0>=p.$length?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+0])).Equal((q=a.Sub,(0>=q.$length?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+0])))){return false;}}else if(c===(13)){if(!((b.Cap===a.Cap))||!(b.Name===a.Name)||!(r=b.Sub,(0>=r.$length?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+0])).Equal((s=a.Sub,(0>=s.$length?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+0])))){return false;}}return true;};BV.prototype.Equal=function(a){return this.$val.Equal(a);};BX=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,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;switch(0){default:c=b.Op;if(c===(1)){a.WriteString("[^\\x00-\\x{10FFFF}]");}else if(c===(2)){a.WriteString("(?:)");}else if(c===(3)){if(!((((b.Flags&1)>>>0)===0))){a.WriteString("(?i:");}d=b.Rune;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);BY(a,f,false);e++;}if(!((((b.Flags&1)>>>0)===0))){a.WriteString(")");}}else if(c===(4)){if(!(((g=b.Rune.$length%2,g===g?g:$throwRuntimeError("integer divide by zero"))===0))){a.WriteString("[invalid char class]");break;}a.WriteRune(91);if(b.Rune.$length===0){a.WriteString("^\\x00-\\x{10FFFF}");}else if(((h=b.Rune,(0>=h.$length?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+0]))===0)&&((i=b.Rune,j=b.Rune.$length-1>>0,((j<0||j>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]))===1114111)){a.WriteRune(94);k=1;while(true){if(!(k<(b.Rune.$length-1>>0))){break;}l=(m=b.Rune,((k<0||k>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+k]))+1>>0;n=(o=b.Rune,p=k+1>>0,((p<0||p>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]))-1>>0;q=l;r=n;BY(a,q,q===45);if(!((q===r))){a.WriteRune(45);BY(a,r,r===45);}k=k+(2)>>0;}}else{s=0;while(true){if(!(s=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+s]));v=(w=b.Rune,x=s+1>>0,((x<0||x>=w.$length)?($throwRuntimeError("index out of range"),undefined):w.$array[w.$offset+x]));y=t;z=v;BY(a,y,y===45);if(!((y===z))){a.WriteRune(45);BY(a,z,z===45);}s=s+(2)>>0;}}a.WriteRune(93);}else if(c===(5)){a.WriteString("(?-s:.)");}else if(c===(6)){a.WriteString("(?s:.)");}else if(c===(7)){a.WriteString("(?m:^)");}else if(c===(8)){a.WriteString("(?m:$)");}else if(c===(9)){a.WriteString("\\A");}else if(c===(10)){if(!((((b.Flags&256)>>>0)===0))){a.WriteString("(?-m:$)");}else{a.WriteString("\\z");}}else if(c===(11)){a.WriteString("\\b");}else if(c===(12)){a.WriteString("\\B");}else if(c===(13)){if(!(b.Name==="")){a.WriteString("(?P<");a.WriteString(b.Name);a.WriteRune(62);}else{a.WriteRune(40);}if(!(((aa=b.Sub,(0>=aa.$length?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+0])).Op===2))){BX(a,(ab=b.Sub,(0>=ab.$length?($throwRuntimeError("index out of range"),undefined):ab.$array[ab.$offset+0])));}a.WriteRune(41);}else if((c===(14))||(c===(15))||(c===(16))||(c===(17))){ad=(ac=b.Sub,(0>=ac.$length?($throwRuntimeError("index out of range"),undefined):ac.$array[ac.$offset+0]));if(ad.Op>13||(ad.Op===3)&&ad.Rune.$length>1){a.WriteString("(?:");BX(a,ad);a.WriteString(")");}else{BX(a,ad);}ae=b.Op;if(ae===(14)){a.WriteRune(42);}else if(ae===(15)){a.WriteRune(43);}else if(ae===(16)){a.WriteRune(63);}else if(ae===(17)){a.WriteRune(123);a.WriteString(B.Itoa(b.Min));if(!((b.Max===b.Min))){a.WriteRune(44);if(b.Max>=0){a.WriteString(B.Itoa(b.Max));}}a.WriteRune(125);}if(!((((b.Flags&32)>>>0)===0))){a.WriteRune(63);}}else if(c===(18)){af=b.Sub;ag=0;while(true){if(!(ag=af.$length)?($throwRuntimeError("index out of range"),undefined):af.$array[af.$offset+ag]);if(ah.Op===19){a.WriteString("(?:");BX(a,ah);a.WriteString(")");}else{BX(a,ah);}ag++;}}else if(c===(19)){ai=b.Sub;aj=0;while(true){if(!(aj=ai.$length)?($throwRuntimeError("index out of range"),undefined):ai.$array[ai.$offset+aj]);if(ak>0){a.WriteRune(124);}BX(a,al);aj++;}}else{a.WriteString(">0)))+">");}}};BV.ptr.prototype.String=function(){var a,b;a=this;b=new D.Builder.ptr(CM.nil,CN.nil);BX(b,a);return b.String();};BV.prototype.String=function(){return this.$val.String();};BY=function(a,b,c){var a,b,c,d,e;if(A.IsPrint(b)){if(D.ContainsRune("\\.+*?()|[]{}^$",b)||c){a.WriteRune(92);}a.WriteRune(b);return;}switch(0){default:d=b;if(d===(7)){a.WriteString("\\a");}else if(d===(12)){a.WriteString("\\f");}else if(d===(10)){a.WriteString("\\n");}else if(d===(13)){a.WriteString("\\r");}else if(d===(9)){a.WriteString("\\t");}else if(d===(11)){a.WriteString("\\v");}else{if(b<256){a.WriteString("\\x");e=B.FormatInt((new $Int64(0,b)),16);if(e.length===1){a.WriteRune(48);}a.WriteString(e);break;}a.WriteString("\\x{");a.WriteString(B.FormatInt((new $Int64(0,b)),16));a.WriteString("}");}}};BV.ptr.prototype.MaxCap=function(){var a,b,c,d,e,f;a=this;b=0;if(a.Op===13){b=a.Cap;}c=a.Sub;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);f=e.MaxCap();if(b>0));a.capNames(b);return b;};BV.prototype.CapNames=function(){return this.$val.CapNames();};BV.ptr.prototype.capNames=function(a){var a,b,c,d,e,f;b=this;if(b.Op===13){(c=b.Cap,((c<0||c>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+c]=b.Name));}d=b.Sub;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);f.capNames(a);e++;}};BV.prototype.capNames=function(a){return this.$val.capNames(a);};BV.ptr.prototype.Simplify=function(){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;a=this;if(a===CG.nil){return CG.nil;}b=a.Op;if((b===(13))||(b===(18))||(b===(19))){c=a;d=a.Sub;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);h=g.Simplify();if(c===a&&!(h===g)){c=new BV.ptr(0,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");BV.copy(c,a);c.Rune=CA.nil;c.Sub=$appendSlice($subslice(new CH(c.Sub0),0,0),$subslice(a.Sub,0,f));}if(!(c===a)){c.Sub=$append(c.Sub,h);}e++;}return c;}else if((b===(14))||(b===(15))||(b===(16))){j=(i=a.Sub,(0>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+0])).Simplify();return BZ(a.Op,a.Flags,j,a);}else if(b===(17)){if((a.Min===0)&&(a.Max===0)){return new BV.ptr(2,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");}l=(k=a.Sub,(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0])).Simplify();if(a.Max===-1){if(a.Min===0){return BZ(14,a.Flags,l,CG.nil);}if(a.Min===1){return BZ(15,a.Flags,l,CG.nil);}m=new BV.ptr(18,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");m.Sub=$subslice(new CH(m.Sub0),0,0);n=0;while(true){if(!(n<(a.Min-1>>0))){break;}m.Sub=$append(m.Sub,l);n=n+(1)>>0;}m.Sub=$append(m.Sub,BZ(15,a.Flags,l,CG.nil));return m;}if((a.Min===1)&&(a.Max===1)){return l;}o=CG.nil;if(a.Min>0){o=new BV.ptr(18,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");o.Sub=$subslice(new CH(o.Sub0),0,0);p=0;while(true){if(!(p>0;}}if(a.Max>a.Min){q=BZ(16,a.Flags,l,CG.nil);r=a.Min+1>>0;while(true){if(!(r>0;}if(o===CG.nil){return q;}o.Sub=$append(o.Sub,q);}if(!(o===CG.nil)){return o;}return new BV.ptr(1,0,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");}return a;};BV.prototype.Simplify=function(){return this.$val.Simplify();};BZ=function(a,b,c,d){var a,b,c,d,e;if(c.Op===2){return c;}if((a===c.Op)&&(((b&32)>>>0)===((c.Flags&32)>>>0))){return c;}if(!(d===CG.nil)&&(d.Op===a)&&(((d.Flags&32)>>>0)===((b&32)>>>0))&&c===(e=d.Sub,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]))){return d;}d=new BV.ptr(a,b,CH.nil,CI.zero(),CA.nil,CJ.zero(),0,0,0,"");d.Sub=$append($subslice(new CH(d.Sub0),0,0),c);return d;};F.methods=[{prop:"next",name:"next",pkg:"regexp/syntax",typ:$funcType([CE],[F],false)},{prop:"patch",name:"patch",pkg:"regexp/syntax",typ:$funcType([CE,$Uint32],[],false)},{prop:"append",name:"append",pkg:"regexp/syntax",typ:$funcType([CE,F],[F],false)}];CO.methods=[{prop:"init",name:"init",pkg:"regexp/syntax",typ:$funcType([],[],false)},{prop:"compile",name:"compile",pkg:"regexp/syntax",typ:$funcType([CG],[G],false)},{prop:"inst",name:"inst",pkg:"regexp/syntax",typ:$funcType([BL],[G],false)},{prop:"nop",name:"nop",pkg:"regexp/syntax",typ:$funcType([],[G],false)},{prop:"fail",name:"fail",pkg:"regexp/syntax",typ:$funcType([],[G],false)},{prop:"cap",name:"cap",pkg:"regexp/syntax",typ:$funcType([$Uint32],[G],false)},{prop:"cat",name:"cat",pkg:"regexp/syntax",typ:$funcType([G,G],[G],false)},{prop:"alt",name:"alt",pkg:"regexp/syntax",typ:$funcType([G,G],[G],false)},{prop:"quest",name:"quest",pkg:"regexp/syntax",typ:$funcType([G,$Bool],[G],false)},{prop:"star",name:"star",pkg:"regexp/syntax",typ:$funcType([G,$Bool],[G],false)},{prop:"plus",name:"plus",pkg:"regexp/syntax",typ:$funcType([G,$Bool],[G],false)},{prop:"empty",name:"empty",pkg:"regexp/syntax",typ:$funcType([BN],[G],false)},{prop:"rune",name:"rune",pkg:"regexp/syntax",typ:$funcType([CA,O],[G],false)}];CP.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];N.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];CQ.methods=[{prop:"newRegexp",name:"newRegexp",pkg:"regexp/syntax",typ:$funcType([BW],[CG],false)},{prop:"reuse",name:"reuse",pkg:"regexp/syntax",typ:$funcType([CG],[],false)},{prop:"push",name:"push",pkg:"regexp/syntax",typ:$funcType([CG],[CG],false)},{prop:"maybeConcat",name:"maybeConcat",pkg:"regexp/syntax",typ:$funcType([$Int32,O],[$Bool],false)},{prop:"newLiteral",name:"newLiteral",pkg:"regexp/syntax",typ:$funcType([$Int32,O],[CG],false)},{prop:"literal",name:"literal",pkg:"regexp/syntax",typ:$funcType([$Int32],[],false)},{prop:"op",name:"op",pkg:"regexp/syntax",typ:$funcType([BW],[CG],false)},{prop:"repeat",name:"repeat",pkg:"regexp/syntax",typ:$funcType([BW,$Int,$Int,$String,$String,$String],[$String,$error],false)},{prop:"concat",name:"concat",pkg:"regexp/syntax",typ:$funcType([],[CG],false)},{prop:"alternate",name:"alternate",pkg:"regexp/syntax",typ:$funcType([],[CG],false)},{prop:"collapse",name:"collapse",pkg:"regexp/syntax",typ:$funcType([CH,BW],[CG],false)},{prop:"factor",name:"factor",pkg:"regexp/syntax",typ:$funcType([CH],[CH],false)},{prop:"leadingString",name:"leadingString",pkg:"regexp/syntax",typ:$funcType([CG],[CA,O],false)},{prop:"removeLeadingString",name:"removeLeadingString",pkg:"regexp/syntax",typ:$funcType([CG,$Int],[CG],false)},{prop:"leadingRegexp",name:"leadingRegexp",pkg:"regexp/syntax",typ:$funcType([CG],[CG],false)},{prop:"removeLeadingRegexp",name:"removeLeadingRegexp",pkg:"regexp/syntax",typ:$funcType([CG,$Bool],[CG],false)},{prop:"parseRepeat",name:"parseRepeat",pkg:"regexp/syntax",typ:$funcType([$String],[$Int,$Int,$String,$Bool],false)},{prop:"parsePerlFlags",name:"parsePerlFlags",pkg:"regexp/syntax",typ:$funcType([$String],[$String,$error],false)},{prop:"parseInt",name:"parseInt",pkg:"regexp/syntax",typ:$funcType([$String],[$Int,$String,$Bool],false)},{prop:"parseVerticalBar",name:"parseVerticalBar",pkg:"regexp/syntax",typ:$funcType([],[$error],false)},{prop:"swapVerticalBar",name:"swapVerticalBar",pkg:"regexp/syntax",typ:$funcType([],[$Bool],false)},{prop:"parseRightParen",name:"parseRightParen",pkg:"regexp/syntax",typ:$funcType([],[$error],false)},{prop:"parseEscape",name:"parseEscape",pkg:"regexp/syntax",typ:$funcType([$String],[$Int32,$String,$error],false)},{prop:"parseClassChar",name:"parseClassChar",pkg:"regexp/syntax",typ:$funcType([$String,$String],[$Int32,$String,$error],false)},{prop:"parsePerlClassEscape",name:"parsePerlClassEscape",pkg:"regexp/syntax",typ:$funcType([$String,CA],[CA,$String],false)},{prop:"parseNamedClass",name:"parseNamedClass",pkg:"regexp/syntax",typ:$funcType([$String,CA],[CA,$String,$error],false)},{prop:"appendGroup",name:"appendGroup",pkg:"regexp/syntax",typ:$funcType([CA,Z],[CA],false)},{prop:"parseUnicodeClass",name:"parseUnicodeClass",pkg:"regexp/syntax",typ:$funcType([$String,CA],[CA,$String,$error],false)},{prop:"parseClass",name:"parseClass",pkg:"regexp/syntax",typ:$funcType([$String],[$String,$error],false)}];AM.methods=[{prop:"Less",name:"Less",pkg:"",typ:$funcType([$Int,$Int],[$Bool],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$Int,$Int],[],false)}];CE.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"skipNop",name:"skipNop",pkg:"regexp/syntax",typ:$funcType([$Uint32],[CR],false)},{prop:"Prefix",name:"Prefix",pkg:"",typ:$funcType([],[$String,$Bool],false)},{prop:"StartCond",name:"StartCond",pkg:"",typ:$funcType([],[BN],false)}];BL.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];CR.methods=[{prop:"op",name:"op",pkg:"regexp/syntax",typ:$funcType([],[BL],false)},{prop:"MatchRune",name:"MatchRune",pkg:"",typ:$funcType([$Int32],[$Bool],false)},{prop:"MatchRunePos",name:"MatchRunePos",pkg:"",typ:$funcType([$Int32],[$Int],false)},{prop:"MatchEmptyWidth",name:"MatchEmptyWidth",pkg:"",typ:$funcType([$Int32,$Int32],[$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];CG.methods=[{prop:"Equal",name:"Equal",pkg:"",typ:$funcType([CG],[$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"MaxCap",name:"MaxCap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"CapNames",name:"CapNames",pkg:"",typ:$funcType([],[CD],false)},{prop:"capNames",name:"capNames",pkg:"regexp/syntax",typ:$funcType([CD],[],false)},{prop:"Simplify",name:"Simplify",pkg:"",typ:$funcType([],[CG],false)}];BW.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];G.init("regexp/syntax",[{prop:"i",name:"i",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"out",name:"out",embedded:false,exported:false,typ:F,tag:""}]);H.init("regexp/syntax",[{prop:"p",name:"p",embedded:false,exported:false,typ:CE,tag:""}]);M.init("",[{prop:"Code",name:"Code",embedded:false,exported:true,typ:N,tag:""},{prop:"Expr",name:"Expr",embedded:false,exported:true,typ:$String,tag:""}]);P.init("regexp/syntax",[{prop:"flags",name:"flags",embedded:false,exported:false,typ:O,tag:""},{prop:"stack",name:"stack",embedded:false,exported:false,typ:CH,tag:""},{prop:"free",name:"free",embedded:false,exported:false,typ:CG,tag:""},{prop:"numCap",name:"numCap",embedded:false,exported:false,typ:$Int,tag:""},{prop:"wholeRegexp",name:"wholeRegexp",embedded:false,exported:false,typ:$String,tag:""},{prop:"tmpClass",name:"tmpClass",embedded:false,exported:false,typ:CA,tag:""}]);Z.init("regexp/syntax",[{prop:"sign",name:"sign",embedded:false,exported:false,typ:$Int,tag:""},{prop:"class$1",name:"class",embedded:false,exported:false,typ:CA,tag:""}]);AM.init("regexp/syntax",[{prop:"p",name:"p",embedded:false,exported:false,typ:CK,tag:""}]);BK.init("",[{prop:"Inst",name:"Inst",embedded:false,exported:true,typ:CF,tag:""},{prop:"Start",name:"Start",embedded:false,exported:true,typ:$Int,tag:""},{prop:"NumCap",name:"NumCap",embedded:false,exported:true,typ:$Int,tag:""}]);BQ.init("",[{prop:"Op",name:"Op",embedded:false,exported:true,typ:BL,tag:""},{prop:"Out",name:"Out",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Arg",name:"Arg",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Rune",name:"Rune",embedded:false,exported:true,typ:CA,tag:""}]);BV.init("",[{prop:"Op",name:"Op",embedded:false,exported:true,typ:BW,tag:""},{prop:"Flags",name:"Flags",embedded:false,exported:true,typ:O,tag:""},{prop:"Sub",name:"Sub",embedded:false,exported:true,typ:CH,tag:""},{prop:"Sub0",name:"Sub0",embedded:false,exported:true,typ:CI,tag:""},{prop:"Rune",name:"Rune",embedded:false,exported:true,typ:CA,tag:""},{prop:"Rune0",name:"Rune0",embedded:false,exported:true,typ:CJ,tag:""},{prop:"Min",name:"Min",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Max",name:"Max",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Cap",name:"Cap",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Name",name:"Name",embedded:false,exported:true,typ:$String,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}J=new CA([0,9,11,1114111]);K=new CA([0,1114111]);L=$toNativeArray($kindUint8,[0,7,17,24,33,45,52,61,68,77,84,96,110,117,121,125,130,136,142,151]);AA=new A.RangeTable.ptr(new CB([new A.Range16.ptr(0,65535,1)]),new CC([new A.Range32.ptr(65536,1114111,1)]),0);AR=new CA([48,57]);AS=new CA([9,10,12,13,32,32]);AT=new CA([48,57,65,90,95,95,97,122]);AU=$makeMap($String.keyFor,[{k:"\\d",v:new Z.ptr(1,AR)},{k:"\\D",v:new Z.ptr(-1,AR)},{k:"\\s",v:new Z.ptr(1,AS)},{k:"\\S",v:new Z.ptr(-1,AS)},{k:"\\w",v:new Z.ptr(1,AT)},{k:"\\W",v:new Z.ptr(-1,AT)}]);AV=new CA([48,57,65,90,97,122]);AW=new CA([65,90,97,122]);AX=new CA([0,127]);AY=new CA([9,9,32,32]);AZ=new CA([0,31,127,127]);BA=new CA([48,57]);BB=new CA([33,126]);BC=new CA([97,122]);BD=new CA([32,126]);BE=new CA([33,47,58,64,91,96,123,126]);BF=new CA([9,13,32,32]);BG=new CA([65,90]);BH=new CA([48,57,65,90,95,95,97,122]);BI=new CA([48,57,65,70,97,102]);BJ=$makeMap($String.keyFor,[{k:"[:alnum:]",v:new Z.ptr(1,AV)},{k:"[:^alnum:]",v:new Z.ptr(-1,AV)},{k:"[:alpha:]",v:new Z.ptr(1,AW)},{k:"[:^alpha:]",v:new Z.ptr(-1,AW)},{k:"[:ascii:]",v:new Z.ptr(1,AX)},{k:"[:^ascii:]",v:new Z.ptr(-1,AX)},{k:"[:blank:]",v:new Z.ptr(1,AY)},{k:"[:^blank:]",v:new Z.ptr(-1,AY)},{k:"[:cntrl:]",v:new Z.ptr(1,AZ)},{k:"[:^cntrl:]",v:new Z.ptr(-1,AZ)},{k:"[:digit:]",v:new Z.ptr(1,BA)},{k:"[:^digit:]",v:new Z.ptr(-1,BA)},{k:"[:graph:]",v:new Z.ptr(1,BB)},{k:"[:^graph:]",v:new Z.ptr(-1,BB)},{k:"[:lower:]",v:new Z.ptr(1,BC)},{k:"[:^lower:]",v:new Z.ptr(-1,BC)},{k:"[:print:]",v:new Z.ptr(1,BD)},{k:"[:^print:]",v:new Z.ptr(-1,BD)},{k:"[:punct:]",v:new Z.ptr(1,BE)},{k:"[:^punct:]",v:new Z.ptr(-1,BE)},{k:"[:space:]",v:new Z.ptr(1,BF)},{k:"[:^space:]",v:new Z.ptr(-1,BF)},{k:"[:upper:]",v:new Z.ptr(1,BG)},{k:"[:^upper:]",v:new Z.ptr(-1,BG)},{k:"[:word:]",v:new Z.ptr(1,BH)},{k:"[:^word:]",v:new Z.ptr(-1,BH)},{k:"[:xdigit:]",v:new Z.ptr(1,BI)},{k:"[:^xdigit:]",v:new Z.ptr(-1,BI)}]);BM=new CD(["InstAlt","InstAltMatch","InstCapture","InstEmptyWidth","InstMatch","InstFail","InstNop","InstRune","InstRune1","InstRuneAny","InstRuneAnyNotNL"]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["regexp"]=(function(){var $pkg={},$init,G,B,C,A,D,H,E,F,I,J,K,Q,R,S,T,U,V,X,AC,AD,AH,AO,AT,BC,BD,BE,BF,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,CA,CB,CC,CD,CE,CF,CG,CH,CI,CJ,CK,CL,CM,CN,CO,CP,CQ,CR,CS,CT,CU,CV,CW,CX,CY,CZ,DA,DB,DC,DD,DE,DF,L,Y,AB,AJ,AK,AP,AQ,AX,AY,BJ,M,N,O,P,W,Z,AA,AE,AF,AG,AI,AL,AM,AN,AR,AS,AU,AW,AZ,BB,BL,BN;G=$packages["bytes"];B=$packages["github.com/gopherjs/gopherjs/nosync"];C=$packages["io"];A=$packages["regexp/syntax"];D=$packages["sort"];H=$packages["strconv"];E=$packages["strings"];F=$packages["unicode"];I=$packages["unicode/utf8"];J=$pkg.job=$newType(0,$kindStruct,"regexp.job",true,"regexp",false,function(pc_,arg_,pos_){this.$val=this;if(arguments.length===0){this.pc=0;this.arg=false;this.pos=0;return;}this.pc=pc_;this.arg=arg_;this.pos=pos_;});K=$pkg.bitState=$newType(0,$kindStruct,"regexp.bitState",true,"regexp",false,function(end_,cap_,matchcap_,jobs_,visited_,inputs_){this.$val=this;if(arguments.length===0){this.end=0;this.cap=BV.nil;this.matchcap=BV.nil;this.jobs=BW.nil;this.visited=BT.nil;this.inputs=new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0));return;}this.end=end_;this.cap=cap_;this.matchcap=matchcap_;this.jobs=jobs_;this.visited=visited_;this.inputs=inputs_;});Q=$pkg.queue=$newType(0,$kindStruct,"regexp.queue",true,"regexp",false,function(sparse_,dense_){this.$val=this;if(arguments.length===0){this.sparse=BT.nil;this.dense=CP.nil;return;}this.sparse=sparse_;this.dense=dense_;});R=$pkg.entry=$newType(0,$kindStruct,"regexp.entry",true,"regexp",false,function(pc_,t_){this.$val=this;if(arguments.length===0){this.pc=0;this.t=BY.nil;return;}this.pc=pc_;this.t=t_;});S=$pkg.thread=$newType(0,$kindStruct,"regexp.thread",true,"regexp",false,function(inst_,cap_){this.$val=this;if(arguments.length===0){this.inst=BZ.nil;this.cap=BV.nil;return;}this.inst=inst_;this.cap=cap_;});T=$pkg.machine=$newType(0,$kindStruct,"regexp.machine",true,"regexp",false,function(re_,p_,q0_,q1_,pool_,matched_,matchcap_,inputs_){this.$val=this;if(arguments.length===0){this.re=CL.nil;this.p=CM.nil;this.q0=new Q.ptr(BT.nil,CP.nil);this.q1=new Q.ptr(BT.nil,CP.nil);this.pool=CQ.nil;this.matched=false;this.matchcap=BV.nil;this.inputs=new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0));return;}this.re=re_;this.p=p_;this.q0=q0_;this.q1=q1_;this.pool=pool_;this.matched=matched_;this.matchcap=matchcap_;this.inputs=inputs_;});U=$pkg.inputs=$newType(0,$kindStruct,"regexp.inputs",true,"regexp",false,function(bytes_,string_,reader_){this.$val=this;if(arguments.length===0){this.bytes=new BE.ptr(BX.nil);this.string=new BD.ptr("");this.reader=new BF.ptr($ifaceNil,false,0);return;}this.bytes=bytes_;this.string=string_;this.reader=reader_;});V=$pkg.lazyFlag=$newType(8,$kindUint64,"regexp.lazyFlag",true,"regexp",false,null);X=$pkg.onePassMachine=$newType(0,$kindStruct,"regexp.onePassMachine",true,"regexp",false,function(inputs_,matchcap_){this.$val=this;if(arguments.length===0){this.inputs=new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0));this.matchcap=BV.nil;return;}this.inputs=inputs_;this.matchcap=matchcap_;});AC=$pkg.onePassProg=$newType(0,$kindStruct,"regexp.onePassProg",true,"regexp",false,function(Inst_,Start_,NumCap_){this.$val=this;if(arguments.length===0){this.Inst=CG.nil;this.Start=0;this.NumCap=0;return;}this.Inst=Inst_;this.Start=Start_;this.NumCap=NumCap_;});AD=$pkg.onePassInst=$newType(0,$kindStruct,"regexp.onePassInst",true,"regexp",false,function(Inst_,Next_){this.$val=this;if(arguments.length===0){this.Inst=new A.Inst.ptr(0,0,0,BS.nil);this.Next=BT.nil;return;}this.Inst=Inst_;this.Next=Next_;});AH=$pkg.queueOnePass=$newType(0,$kindStruct,"regexp.queueOnePass",true,"regexp",false,function(sparse_,dense_,size_,nextIndex_){this.$val=this;if(arguments.length===0){this.sparse=BT.nil;this.dense=BT.nil;this.size=0;this.nextIndex=0;return;}this.sparse=sparse_;this.dense=dense_;this.size=size_;this.nextIndex=nextIndex_;});AO=$pkg.runeSlice=$newType(12,$kindSlice,"regexp.runeSlice",true,"regexp",false,null);AT=$pkg.Regexp=$newType(0,$kindStruct,"regexp.Regexp",true,"regexp",true,function(expr_,prog_,onepass_,numSubexp_,maxBitStateLen_,subexpNames_,prefix_,prefixBytes_,prefixRune_,prefixEnd_,mpool_,matchcap_,prefixComplete_,cond_,longest_){this.$val=this;if(arguments.length===0){this.expr="";this.prog=CM.nil;this.onepass=CD.nil;this.numSubexp=0;this.maxBitStateLen=0;this.subexpNames=CN.nil;this.prefix="";this.prefixBytes=BX.nil;this.prefixRune=0;this.prefixEnd=0;this.mpool=0;this.matchcap=0;this.prefixComplete=false;this.cond=0;this.longest=false;return;}this.expr=expr_;this.prog=prog_;this.onepass=onepass_;this.numSubexp=numSubexp_;this.maxBitStateLen=maxBitStateLen_;this.subexpNames=subexpNames_;this.prefix=prefix_;this.prefixBytes=prefixBytes_;this.prefixRune=prefixRune_;this.prefixEnd=prefixEnd_;this.mpool=mpool_;this.matchcap=matchcap_;this.prefixComplete=prefixComplete_;this.cond=cond_;this.longest=longest_;});BC=$pkg.input=$newType(8,$kindInterface,"regexp.input",true,"regexp",false,null);BD=$pkg.inputString=$newType(0,$kindStruct,"regexp.inputString",true,"regexp",false,function(str_){this.$val=this;if(arguments.length===0){this.str="";return;}this.str=str_;});BE=$pkg.inputBytes=$newType(0,$kindStruct,"regexp.inputBytes",true,"regexp",false,function(str_){this.$val=this;if(arguments.length===0){this.str=BX.nil;return;}this.str=str_;});BF=$pkg.inputReader=$newType(0,$kindStruct,"regexp.inputReader",true,"regexp",false,function(r_,atEOT_,pos_){this.$val=this;if(arguments.length===0){this.r=$ifaceNil;this.atEOT=false;this.pos=0;return;}this.r=r_;this.atEOT=atEOT_;this.pos=pos_;});BO=$sliceType($emptyInterface);BP=$arrayType($Int,0);BQ=$arrayType(B.Pool,5);BR=$arrayType($Uint8,16);BS=$sliceType($Int32);BT=$sliceType($Uint32);BU=$ptrType(K);BV=$sliceType($Int);BW=$sliceType(J);BX=$sliceType($Uint8);BY=$ptrType(S);BZ=$ptrType(A.Inst);CA=$ptrType(V);CB=$ptrType($Int);CC=$ptrType(X);CD=$ptrType(AC);CE=$ptrType(E.Builder);CF=$ptrType(AH);CG=$sliceType(AD);CH=$ptrType($Uint32);CI=$sliceType(BS);CJ=$ptrType(BS);CK=$sliceType($Bool);CL=$ptrType(AT);CM=$ptrType(A.Prog);CN=$sliceType($String);CO=$ptrType(T);CP=$sliceType(R);CQ=$sliceType(BY);CR=$arrayType($Int,2);CS=$arrayType($Int,4);CT=$sliceType(BX);CU=$sliceType(BV);CV=$sliceType(CT);CW=$sliceType(CN);CX=$ptrType(Q);CY=$ptrType(U);CZ=$funcType([$String],[$String],false);DA=$funcType([BX,BV],[BX],false);DB=$funcType([BX],[BX],false);DC=$funcType([BV],[],false);DD=$ptrType(BD);DE=$ptrType(BE);DF=$ptrType(BF);M=function(){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=L.Get();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}a=$assertType(b,BU,true);c=a[0];d=a[1];if(!d){c=new K.ptr(0,BV.nil,BV.nil,BW.nil,BT.nil,new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0)));}$s=-1;return c;}return;}if($f===undefined){$f={$blk:M};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};N=function(a){var a;a.inputs.clear();L.Put(a);};O=function(a){var a,b;if(!P(a)){return 0;}return(b=262144/a.Inst.$length,(b===b&&b!==1/0&&b!==-1/0)?b>>0:$throwRuntimeError("integer divide by zero"));};P=function(a){var a;return a.Inst.$length<=500;};K.ptr.prototype.reset=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;d=this;d.end=b;if(d.jobs.$capacity===0){d.jobs=$makeSlice(BW,0,256);}else{d.jobs=$subslice(d.jobs,0,0);}f=(e=(((($imul(a.Inst.$length,((b+1>>0))))+32>>0)-1>>0))/32,(e===e&&e!==1/0&&e!==-1/0)?e>>0:$throwRuntimeError("integer divide by zero"));if(d.visited.$capacity=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+i]=0));h++;}}if(d.cap.$capacity=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+m]=-1));l++;}if(d.matchcap.$capacity=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+q]=-1));p++;}};K.prototype.reset=function(a,b,c){return this.$val.reset(a,b,c);};K.ptr.prototype.shouldVisit=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m;c=this;d=(((($imul(((a>>0)),((c.end+1>>0))))+b>>0)>>>0));if(!(((((e=c.visited,f=(g=d/32,(g===g&&g!==1/0&&g!==-1/0)?g>>>0:$throwRuntimeError("integer divide by zero")),((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]))&(((h=(((d&31)>>>0)),h<32?(1<>>0)))>>>0)===0))){return false;}j=(i=d/32,(i===i&&i!==1/0&&i!==-1/0)?i>>>0:$throwRuntimeError("integer divide by zero"));(m=c.visited,((j<0||j>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+j]=(((k=c.visited,((j<0||j>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+j]))|(((l=(((d&31)>>>0)),l<32?(1<>>0)))>>>0)));return true;};K.prototype.shouldVisit=function(a,b){return this.$val.shouldVisit(a,b);};K.ptr.prototype.push=function(a,b,c,d){var a,b,c,d,e,f;e=this;if(!(((f=a.prog.Inst,((b<0||b>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+b])).Op===5))&&(d||e.shouldVisit(b,c))){e.jobs=$append(e.jobs,new J.ptr(b,d,c));}};K.prototype.push=function(a,b,c,d){return this.$val.push(a,b,c,d);};AT.ptr.prototype.tryBacktrack=function(a,b,c,d){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=e.longest;a.push(e,c,d,false);case 1:if(!(a.jobs.$length>0)){$s=2;continue;}g=a.jobs.$length-1>>0;i=(h=a.jobs,((g<0||g>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+g])).pc;k=(j=a.jobs,((g<0||g>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+g])).pos;m=(l=a.jobs,((g<0||g>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+g])).arg;a.jobs=$subslice(a.jobs,0,g);$s=3;continue;case 4:if(!a.shouldVisit(i,k)){$s=1;continue;}case 3:o=$clone((n=e.prog.Inst,((i<0||i>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+i])),A.Inst);p=o.Op;if(p===(5)){$s=6;continue;}if(p===(0)){$s=7;continue;}if(p===(1)){$s=8;continue;}if(p===(7)){$s=9;continue;}if(p===(8)){$s=10;continue;}if(p===(10)){$s=11;continue;}if(p===(9)){$s=12;continue;}if(p===(2)){$s=13;continue;}if(p===(3)){$s=14;continue;}if(p===(6)){$s=15;continue;}if(p===(4)){$s=16;continue;}$s=17;continue;case 6:$panic(new $String("unexpected InstFail"));$s=18;continue;case 7:if(m){$s=19;continue;}$s=20;continue;case 19:m=false;i=o.Arg;$s=4;continue;$s=21;continue;case 20:a.push(e,i,k,true);i=o.Out;$s=4;continue;case 21:$s=18;continue;case 8:s=(q=e.prog.Inst,r=o.Out,((r<0||r>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r])).Op;if((s===(7))||(s===(8))||(s===(9))||(s===(10))){$s=23;continue;}$s=24;continue;case 23:a.push(e,o.Arg,k,false);i=o.Arg;k=a.end;$s=4;continue;case 24:case 22:a.push(e,o.Out,a.end,false);i=o.Out;$s=4;continue;$s=18;continue;case 9:u=b.step(k);$s=25;case 25:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}t=u;v=t[0];w=t[1];if(!o.MatchRune(v)){$s=26;continue;}$s=27;continue;case 26:$s=1;continue;case 27:k=k+(w)>>0;i=o.Out;$s=4;continue;$s=18;continue;case 10:y=b.step(k);$s=28;case 28:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}x=y;z=x[0];aa=x[1];if(!((z===(ab=o.Rune,(0>=ab.$length?($throwRuntimeError("index out of range"),undefined):ab.$array[ab.$offset+0]))))){$s=29;continue;}$s=30;continue;case 29:$s=1;continue;case 30:k=k+(aa)>>0;i=o.Out;$s=4;continue;$s=18;continue;case 11:ad=b.step(k);$s=31;case 31:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ac=ad;ae=ac[0];af=ac[1];if((ae===10)||(ae===-1)){$s=32;continue;}$s=33;continue;case 32:$s=1;continue;case 33:k=k+(af)>>0;i=o.Out;$s=4;continue;$s=18;continue;case 12:ah=b.step(k);$s=34;case 34:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ag=ah;ai=ag[0];aj=ag[1];if(ai===-1){$s=35;continue;}$s=36;continue;case 35:$s=1;continue;case 36:k=k+(aj)>>0;i=o.Out;$s=4;continue;$s=18;continue;case 13:if(m){$s=37;continue;}$s=38;continue;case 37:(ak=a.cap,al=o.Arg,((al<0||al>=ak.$length)?($throwRuntimeError("index out of range"),undefined):ak.$array[ak.$offset+al]=k));$s=1;continue;$s=39;continue;case 38:if(0<=o.Arg&&o.Arg<((a.cap.$length>>>0))){a.push(e,i,(am=a.cap,an=o.Arg,((an<0||an>=am.$length)?($throwRuntimeError("index out of range"),undefined):am.$array[am.$offset+an])),true);(ao=a.cap,ap=o.Arg,((ap<0||ap>=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+ap]=k));}i=o.Out;$s=4;continue;case 39:$s=18;continue;case 14:aq=b.context(k);$s=40;case 40:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}ar=aq;if(!ar.match(((o.Arg<<24>>>24)))){$s=41;continue;}$s=42;continue;case 41:$s=1;continue;case 42:i=o.Out;$s=4;continue;$s=18;continue;case 15:i=o.Out;$s=4;continue;$s=18;continue;case 16:if(a.cap.$length===0){$s=-1;return true;}if(a.cap.$length>1){(as=a.cap,(1>=as.$length?($throwRuntimeError("index out of range"),undefined):as.$array[as.$offset+1]=k));}au=(at=a.matchcap,(1>=at.$length?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+1]));if((au===-1)||(f&&k>0&&k>au)){$copySlice(a.matchcap,a.cap);}if(!f){$s=-1;return true;}if(k===a.end){$s=-1;return true;}$s=1;continue;$s=18;continue;case 17:$panic(new $String("bad inst"));case 18:case 5:$s=1;continue;case 2:$s=-1;return f&&a.matchcap.$length>1&&(av=a.matchcap,(1>=av.$length?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+1]))>=0;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.tryBacktrack};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.tryBacktrack=function(a,b,c,d){return this.$val.tryBacktrack(a,b,c,d);};AT.ptr.prototype.backtrack=function(a,b,c,d,e){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this;g=f.cond;if(g===255){$s=-1;return BV.nil;}if(!((((g&4)>>>0)===0))&&!((c===0))){$s=-1;return BV.nil;}h=M();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;j=i.inputs.init($ifaceNil,a,b);k=j[0];l=j[1];i.reset(f.prog,l,d);if(!((((g&4)>>>0)===0))){$s=2;continue;}$s=3;continue;case 2:if(i.cap.$length>0){(m=i.cap,(0>=m.$length?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+0]=c));}n=f.tryBacktrack(i,k,((f.prog.Start>>>0)),c);$s=7;case 7:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}if(!n){$s=5;continue;}$s=6;continue;case 5:N(i);$s=-1;return BV.nil;case 6:$s=4;continue;case 3:o=-1;case 8:if(!(c<=l&&!((o===0)))){$s=9;continue;}if(f.prefix.length>0){$s=10;continue;}$s=11;continue;case 10:p=k.index(f,c);$s=12;case 12:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=p;if(q<0){N(i);$s=-1;return BV.nil;}c=c+(q)>>0;case 11:if(i.cap.$length>0){(r=i.cap,(0>=r.$length?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+0]=c));}s=f.tryBacktrack(i,k,((f.prog.Start>>>0)),c);$s=15;case 15:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}if(s){$s=13;continue;}$s=14;continue;case 13:$s=16;continue;case 14:u=k.step(c);$s=17;case 17:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}t=u;o=t[1];c=c+(o)>>0;$s=8;continue;case 9:N(i);$s=-1;return BV.nil;case 4:case 16:e=$appendSlice(e,i.matchcap);N(i);$s=-1;return e;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.backtrack};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.backtrack=function(a,b,c,d,e){return this.$val.backtrack(a,b,c,d,e);};U.ptr.prototype.newBytes=function(a){var a,b;b=this;b.bytes.str=a;return b.bytes;};U.prototype.newBytes=function(a){return this.$val.newBytes(a);};U.ptr.prototype.newString=function(a){var a,b;b=this;b.string.str=a;return b.string;};U.prototype.newString=function(a){return this.$val.newString(a);};U.ptr.prototype.newReader=function(a){var a,b;b=this;b.reader.r=a;b.reader.atEOT=false;b.reader.pos=0;return b.reader;};U.prototype.newReader=function(a){return this.$val.newReader(a);};U.ptr.prototype.clear=function(){var a;a=this;if(!(a.bytes.str===BX.nil)){a.bytes.str=BX.nil;}else if(!($interfaceIsEqual(a.reader.r,$ifaceNil))){a.reader.r=$ifaceNil;}else{a.string.str="";}};U.prototype.clear=function(){return this.$val.clear();};U.ptr.prototype.init=function(a,b,c){var a,b,c,d;d=this;if(!($interfaceIsEqual(a,$ifaceNil))){return[d.newReader(a),0];}if(!(b===BX.nil)){return[d.newBytes(b),b.$length];}return[d.newString(c),c.length];};U.prototype.init=function(a,b,c){return this.$val.init(a,b,c);};T.ptr.prototype.init=function(a){var a,b,c,d,e;b=this;c=b.pool;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);e.cap=$subslice(e.cap,0,a);d++;}b.matchcap=$subslice(b.matchcap,0,a);};T.prototype.init=function(a){return this.$val.init(a);};T.ptr.prototype.alloc=function(a){var a,b,c,d,e,f;b=this;c=BY.nil;d=b.pool.$length;if(d>0){c=(e=b.pool,f=d-1>>0,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));b.pool=$subslice(b.pool,0,(d-1>>0));}else{c=new S.ptr(BZ.nil,BV.nil);c.cap=$makeSlice(BV,b.matchcap.$length,b.matchcap.$capacity);}c.inst=a;return c;};T.prototype.alloc=function(a){return this.$val.alloc(a);};W=function(a,b){var a,b,c,d,e;return((c=(d=$shiftLeft64((new $Uint64(0,a)),32),e=(new $Uint64(0,((b>>>0)))),new $Uint64(d.$high|e.$high,(d.$low|e.$low)>>>0)),new V(c.$high,c.$low)));};V.prototype.match=function(a){var a,b,c,d;b=this;if(a===0){return true;}c=(($shiftRightUint64(b,32).$low>>0));if(!((((a&1)>>>0)===0))){if(!((c===10))&&c>=0){return false;}a=(a&~(1))<<24>>>24;}if(!((((a&4)>>>0)===0))){if(c>=0){return false;}a=(a&~(4))<<24>>>24;}if(a===0){return true;}d=((b.$low>>0));if(!((((a&2)>>>0)===0))){if(!((d===10))&&d>=0){return false;}a=(a&~(2))<<24>>>24;}if(!((((a&8)>>>0)===0))){if(d>=0){return false;}a=(a&~(8))<<24>>>24;}if(a===0){return true;}if(!(A.IsWordChar(c)===A.IsWordChar(d))){a=(a&~(16))<<24>>>24;}else{a=(a&~(32))<<24>>>24;}return a===0;};$ptrType(V).prototype.match=function(a){return this.$get().match(a);};T.ptr.prototype.match=function(a,b){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;e=d.re.cond;if(e===255){$s=-1;return false;}d.matched=false;f=d.matchcap;g=0;while(true){if(!(g=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+h]=-1));g++;}j=d.q0;k=d.q1;l=j;m=k;n=-1;o=-1;p=n;q=o;r=0;s=0;t=r;u=s;w=a.step(b);$s=1;case 1:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}v=w;p=v[0];t=v[1];if(!((p===-1))){$s=2;continue;}$s=3;continue;case 2:y=a.step(b+t>>0);$s=4;case 4:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}x=y;q=x[0];u=x[1];case 3:c[0]=new V(0,0);if(b===0){$s=5;continue;}$s=6;continue;case 5:c[0]=W(-1,p);$s=7;continue;case 6:z=a.context(b);$s=8;case 8:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}c[0]=z;case 7:case 9:if(l.dense.$length===0){$s=11;continue;}$s=12;continue;case 11:if(!((((e&4)>>>0)===0))&&!((b===0))){$s=10;continue;}if(d.matched){$s=10;continue;}if(!(d.re.prefix.length>0&&!((q===d.re.prefixRune)))){aa=false;$s=15;continue s;}ab=a.canCheckPrefix();$s=16;case 16:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=ab;case 15:if(aa){$s=13;continue;}$s=14;continue;case 13:ac=a.index(d.re,b);$s=17;case 17:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ad=ac;if(ad<0){$s=10;continue;}b=b+(ad)>>0;af=a.step(b);$s=18;case 18:if($c){$c=false;af=af.$blk();}if(af&&af.$blk!==undefined){break s;}ae=af;p=ae[0];t=ae[1];ah=a.step(b+t>>0);$s=19;case 19:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ag=ah;q=ag[0];u=ag[1];case 14:case 12:if(!d.matched){if(d.matchcap.$length>0){(ai=d.matchcap,(0>=ai.$length?($throwRuntimeError("index out of range"),undefined):ai.$array[ai.$offset+0]=b));}d.add(l,((d.p.Start>>>0)),b,d.matchcap,(c.$ptr||(c.$ptr=new CA(function(){return this.$target[0];},function($v){this.$target[0]=$v;},c))),BY.nil);}c[0]=W(p,q);d.step(l,m,b,b+t>>0,p,(c.$ptr||(c.$ptr=new CA(function(){return this.$target[0];},function($v){this.$target[0]=$v;},c))));if(t===0){$s=10;continue;}if((d.matchcap.$length===0)&&d.matched){$s=10;continue;}b=b+(t)>>0;aj=q;ak=u;p=aj;t=ak;if(!((p===-1))){$s=20;continue;}$s=21;continue;case 20:am=a.step(b+t>>0);$s=22;case 22:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}al=am;q=al[0];u=al[1];case 21:an=m;ao=l;l=an;m=ao;$s=9;continue;case 10:d.clear(m);$s=-1;return d.matched;}return;}if($f===undefined){$f={$blk:T.ptr.prototype.match};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};T.prototype.match=function(a,b){return this.$val.match(a,b);};T.ptr.prototype.clear=function(a){var a,b,c,d,e;b=this;c=a.dense;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),R);if(!(e.t===BY.nil)){b.pool=$append(b.pool,e.t);}d++;}a.dense=$subslice(a.dense,0,0);};T.prototype.clear=function(a){return this.$val.clear(a);};T.ptr.prototype.step=function(a,b,c,d,e,f){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;g=this;h=g.re.longest;i=0;while(true){if(!(i=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+i]));l=k.t;if(l===BY.nil){i=i+(1)>>0;continue;}if(h&&g.matched&&l.cap.$length>0&&(m=g.matchcap,(0>=m.$length?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+0]))<(n=l.cap,(0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0]))){g.pool=$append(g.pool,l);i=i+(1)>>0;continue;}o=l.inst;p=false;q=o.Op;if(q===(4)){if(l.cap.$length>0&&(!h||!g.matched||(r=g.matchcap,(1>=r.$length?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+1]))=s.$length?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+1]=c));$copySlice(g.matchcap,l.cap);}if(!h){t=$subslice(a.dense,(i+1>>0));u=0;while(true){if(!(u=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u]),R);if(!(v.t===BY.nil)){g.pool=$append(g.pool,v.t);}u++;}a.dense=$subslice(a.dense,0,0);}g.matched=true;}else if(q===(7)){p=o.MatchRune(e);}else if(q===(8)){p=e===(w=o.Rune,(0>=w.$length?($throwRuntimeError("index out of range"),undefined):w.$array[w.$offset+0]));}else if(q===(9)){p=true;}else if(q===(10)){p=!((e===10));}else{$panic(new $String("bad inst"));}if(p){l=g.add(b,o.Out,d,l.cap,f,l);}if(!(l===BY.nil)){g.pool=$append(g.pool,l);}i=i+(1)>>0;}a.dense=$subslice(a.dense,0,0);};T.prototype.step=function(a,b,c,d,e,f){return this.$val.step(a,b,c,d,e,f);};T.ptr.prototype.add=function(a,b,c,d,e,f){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s;$s=0;s:while(true){switch($s){case 0:g=this;case 1:if(b===0){$s=-1;return f;}i=(h=a.sparse,((b<0||b>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+b]));if(i<((a.dense.$length>>>0))&&((j=a.dense,((i<0||i>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+i])).pc===b)){$s=-1;return f;}k=a.dense.$length;a.dense=$subslice(a.dense,0,(k+1>>0));m=(l=a.dense,((k<0||k>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+k]));m.t=BY.nil;m.pc=b;(n=a.sparse,((b<0||b>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+b]=((k>>>0))));p=(o=g.p.Inst,((b<0||b>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+b]));q=p.Op;if(q===(5)){$s=3;continue;}if((q===(0))||(q===(1))){$s=4;continue;}if(q===(3)){$s=5;continue;}if(q===(6)){$s=6;continue;}if(q===(2)){$s=7;continue;}if((q===(4))||(q===(7))||(q===(8))||(q===(9))||(q===(10))){$s=8;continue;}$s=9;continue;case 3:$s=10;continue;case 4:f=g.add(a,p.Out,c,d,e,f);b=p.Arg;$s=1;continue;$s=10;continue;case 5:if(e.match(((p.Arg<<24>>>24)))){$s=11;continue;}$s=12;continue;case 11:b=p.Out;$s=1;continue;case 12:$s=10;continue;case 6:b=p.Out;$s=1;continue;$s=10;continue;case 7:if(((p.Arg>>0))=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+r]));(t=p.Arg,((t<0||t>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+t]=c));g.add(a,p.Out,c,d,e,BY.nil);(u=p.Arg,((u<0||u>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+u]=s));$s=15;continue;case 14:b=p.Out;$s=1;continue;case 15:$s=10;continue;case 8:if(f===BY.nil){f=g.alloc(p);}else{f.inst=p;}if(d.$length>0&&!((v=f.cap,$indexPtr(v.$array,v.$offset+0,CB))===$indexPtr(d.$array,d.$offset+0,CB))){$copySlice(f.cap,d);}m.t=f;f=BY.nil;$s=10;continue;case 9:$panic(new $String("unhandled"));case 10:case 2:$s=-1;return f;}return;}};T.prototype.add=function(a,b,c,d,e,f){return this.$val.add(a,b,c,d,e,f);};Z=function(){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=Y.Get();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}a=$assertType(b,CC,true);c=a[0];d=a[1];if(!d){c=new X.ptr(new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0)),BV.nil);}$s=-1;return c;}return;}if($f===undefined){$f={$blk:Z};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AA=function(a){var a;a.inputs.clear();Y.Put(a);};AT.ptr.prototype.doOnePass=function(a,b,c,d,e,f){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,b,ba,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;b=$f.b;ba=$f.ba;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=[g];h=this;i=h.cond;if(i===255){$s=-1;return BV.nil;}j=Z();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;if(k.matchcap.$capacity=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+o]=-1));n++;}q=k.inputs.init(a,b,c);r=q[0];s=-1;t=-1;u=s;v=t;w=0;x=0;y=w;z=x;ab=r.step(d);$s=2;case 2:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}aa=ab;u=aa[0];y=aa[1];if(!((u===-1))){$s=3;continue;}$s=4;continue;case 3:ad=r.step(d+y>>0);$s=5;case 5:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ac=ad;v=ac[0];z=ac[1];case 4:ae=new V(0,0);if(d===0){$s=6;continue;}$s=7;continue;case 6:ae=W(-1,u);$s=8;continue;case 7:af=r.context(d);$s=9;case 9:if($c){$c=false;af=af.$blk();}if(af&&af.$blk!==undefined){break s;}ae=af;case 8:ag=h.onepass.Start;g[0]=$clone((ah=h.onepass.Inst,((ag<0||ag>=ah.$length)?($throwRuntimeError("index out of range"),undefined):ah.$array[ah.$offset+ag])),AD);if(!((d===0)&&ae.match(((g[0].Inst.Arg<<24>>>24)))&&h.prefix.length>0)){ai=false;$s=12;continue s;}aj=r.canCheckPrefix();$s=13;case 13:if($c){$c=false;aj=aj.$blk();}if(aj&&aj.$blk!==undefined){break s;}ai=aj;case 12:if(ai){$s=10;continue;}$s=11;continue;case 10:ak=r.hasPrefix(h);$s=16;case 16:if($c){$c=false;ak=ak.$blk();}if(ak&&ak.$blk!==undefined){break s;}if(!ak){$s=14;continue;}$s=15;continue;case 14:$s=17;continue;case 15:d=d+(h.prefix.length)>>0;am=r.step(d);$s=18;case 18:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}al=am;u=al[0];y=al[1];ao=r.step(d+y>>0);$s=19;case 19:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}an=ao;v=an[0];z=an[1];ap=r.context(d);$s=20;case 20:if($c){$c=false;ap=ap.$blk();}if(ap&&ap.$blk!==undefined){break s;}ae=ap;ag=((h.prefixEnd>>0));case 11:case 21:AD.copy(g[0],(aq=h.onepass.Inst,((ag<0||ag>=aq.$length)?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+ag])));ag=((g[0].Inst.Out>>0));ar=g[0].Inst.Op;if(ar===(4)){$s=24;continue;}if(ar===(7)){$s=25;continue;}if(ar===(8)){$s=26;continue;}if(ar===(9)){$s=27;continue;}if(ar===(10)){$s=28;continue;}if((ar===(0))||(ar===(1))){$s=29;continue;}if(ar===(5)){$s=30;continue;}if(ar===(6)){$s=31;continue;}if(ar===(3)){$s=32;continue;}if(ar===(2)){$s=33;continue;}$s=34;continue;case 24:l=true;if(k.matchcap.$length>0){(as=k.matchcap,(0>=as.$length?($throwRuntimeError("index out of range"),undefined):as.$array[as.$offset+0]=0));(at=k.matchcap,(1>=at.$length?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+1]=d));}$s=17;continue;$s=35;continue;case 25:if(!g[0].Inst.MatchRune(u)){$s=36;continue;}$s=37;continue;case 36:$s=17;continue;case 37:$s=35;continue;case 26:if(!((u===(au=g[0].Inst.Rune,(0>=au.$length?($throwRuntimeError("index out of range"),undefined):au.$array[au.$offset+0]))))){$s=38;continue;}$s=39;continue;case 38:$s=17;continue;case 39:$s=35;continue;case 27:$s=35;continue;case 28:if(u===10){$s=40;continue;}$s=41;continue;case 40:$s=17;continue;case 41:$s=35;continue;case 29:ag=((AF(g[0],u)>>0));$s=21;continue;$s=35;continue;case 30:$s=17;continue;$s=35;continue;case 31:$s=21;continue;$s=35;continue;case 32:if(!ae.match(((g[0].Inst.Arg<<24>>>24)))){$s=42;continue;}$s=43;continue;case 42:$s=17;continue;case 43:$s=21;continue;$s=35;continue;case 33:if(((g[0].Inst.Arg>>0))=av.$length)?($throwRuntimeError("index out of range"),undefined):av.$array[av.$offset+aw]=d));}$s=21;continue;$s=35;continue;case 34:$panic(new $String("bad inst"));case 35:case 23:if(y===0){$s=22;continue;}ae=W(u,v);d=d+(y)>>0;ax=v;ay=z;u=ax;y=ay;if(!((u===-1))){$s=44;continue;}$s=45;continue;case 44:ba=r.step(d+y>>0);$s=46;case 46:if($c){$c=false;ba=ba.$blk();}if(ba&&ba.$blk!==undefined){break s;}az=ba;v=az[0];z=az[1];case 45:$s=21;continue;case 22:case 17:if(!l){AA(k);$s=-1;return BV.nil;}f=$appendSlice(f,k.matchcap);AA(k);$s=-1;return f;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.doOnePass};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.b=b;$f.ba=ba;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.doOnePass=function(a,b,c,d,e,f){return this.$val.doOnePass(a,b,c,d,e,f);};AT.ptr.prototype.doMatch=function(a,b,c){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=this;e=d.doExecute(a,b,c,0,0,BV.nil);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$s=-1;return!(e===BV.nil);}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.doMatch};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.doMatch=function(a,b,c){return this.$val.doMatch(a,b,c);};AT.ptr.prototype.doExecute=function(a,b,c,d,e,f){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;if(f===BV.nil){f=$subslice(new BV(AB),0,0,0);}if(!(g.onepass===CD.nil)){$s=1;continue;}$s=2;continue;case 1:h=g.doOnePass(a,b,c,d,e,f);$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;case 2:if($interfaceIsEqual(a,$ifaceNil)&&(b.$length+c.length>>0)=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));if(!((g.Op===3))||((((((g.Arg<<24>>>24)))&4)>>>0)===0)){h="";i=g.Op===4;j=((a.Start>>>0));b=h;c=i;d=j;return[b,c,d];}d=g.Out;g=(k=a.Inst,((d<0||d>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+d]));while(true){if(!(g.Op===6)){break;}d=g.Out;g=(l=a.Inst,((d<0||d>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+d]));}if(!((AG(g)===7))||!((g.Rune.$length===1))){m="";n=g.Op===4;o=((a.Start>>>0));b=m;c=n;d=o;return[b,c,d];}p=new E.Builder.ptr(CE.nil,BX.nil);while(true){if(!((AG(g)===7)&&(g.Rune.$length===1)&&(((((g.Arg<<16>>>16))&1)>>>0)===0))){break;}p.WriteRune((q=g.Rune,(0>=q.$length?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+0])));r=g.Out;s=(t=a.Inst,u=g.Out,((u<0||u>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u]));d=r;g=s;}if((g.Op===3)&&!((((((g.Arg<<24>>>24))&8)>>>0)===0))&&((v=a.Inst,w=g.Out,((w<0||w>=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+w])).Op===4)){c=true;}x=p.String();y=c;z=d;b=x;c=y;d=z;return[b,c,d];};AF=function(a,b){var a,b,c,d;c=a.Inst.MatchRunePos(b);if(c>=0){return(d=a.Next,((c<0||c>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+c]));}if(a.Inst.Op===1){return a.Inst.Out;}return 0;};AG=function(a){var a,b,c;b=a.Op;c=b;if((c===(8))||(c===(9))||(c===(10))){b=7;}return b;};AH.ptr.prototype.empty=function(){var a;a=this;return a.nextIndex>=a.size;};AH.prototype.empty=function(){return this.$val.empty();};AH.ptr.prototype.next=function(){var a,b,c,d;a=0;b=this;a=(c=b.dense,d=b.nextIndex,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]));b.nextIndex=b.nextIndex+(1)>>>0;return a;};AH.prototype.next=function(){return this.$val.next();};AH.ptr.prototype.clear=function(){var a;a=this;a.size=0;a.nextIndex=0;};AH.prototype.clear=function(){return this.$val.clear();};AH.ptr.prototype.contains=function(a){var a,b,c,d,e,f;b=this;if(a>=((b.sparse.$length>>>0))){return false;}return(c=b.sparse,((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]))=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+a])),((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]))===a);};AH.prototype.contains=function(a){return this.$val.contains(a);};AH.ptr.prototype.insert=function(a){var a,b;b=this;if(!b.contains(a)){b.insertNew(a);}};AH.prototype.insert=function(a){return this.$val.insert(a);};AH.ptr.prototype.insertNew=function(a){var a,b,c,d,e;b=this;if(a>=((b.sparse.$length>>>0))){return;}(c=b.sparse,((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]=b.size));(d=b.dense,e=b.size,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]=a));b.size=b.size+(1)>>>0;};AH.prototype.insertNew=function(a){return this.$val.insertNew(a);};AI=function(a){var a,b;b=CF.nil;b=new AH.ptr($makeSlice(BT,a),$makeSlice(BT,a),0,0);return b;};AL=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);e=[e];f=[f];g=[g];h=[h];i=[i];j=[j];k=a.$get().$length;l=b.$get().$length;if(!(((k&1)===0))||!(((l&1)===0))){$panic(new $String("mergeRuneSets odd length []rune"));}m=0;n=0;f[0]=m;j[0]=n;g[0]=$makeSlice(BS,0);h[0]=$makeSlice(BT,0);i[0]=true;$deferred.push([(function(e,f,g,h,i,j){return function(){if(!i[0]){g[0]=BS.nil;h[0]=BT.nil;}};})(e,f,g,h,i,j),[]]);e[0]=-1;o=(function(e,f,g,h,i,j){return function(o,p,q){var o,p,q,r,s,t,u,v,w;if(e[0]>0&&(r=p.$get(),s=o.$get(),((s<0||s>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+s]))<=((e[0]<0||e[0]>=g[0].$length)?($throwRuntimeError("index out of range"),undefined):g[0].$array[g[0].$offset+e[0]])){return false;}g[0]=$append(g[0],(t=p.$get(),u=o.$get(),((u<0||u>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u])),(v=p.$get(),w=o.$get()+1>>0,((w<0||w>=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+w])));o.$set(o.$get()+(2)>>0);e[0]=e[0]+(2)>>0;h[0]=$append(h[0],q);return true;};})(e,f,g,h,i,j);case 1:if(!(f[0]=l){$s=4;continue;}if(f[0]>=k){$s=5;continue;}if((p=b.$get(),((j[0]<0||j[0]>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+j[0]]))<(q=a.$get(),((f[0]<0||f[0]>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+f[0]]))){$s=6;continue;}$s=7;continue;case 4:r=o((f.$ptr||(f.$ptr=new CB(function(){return this.$target[0];},function($v){this.$target[0]=$v;},f))),a,c);$s=9;case 9:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}i[0]=r;$s=8;continue;case 5:s=o((j.$ptr||(j.$ptr=new CB(function(){return this.$target[0];},function($v){this.$target[0]=$v;},j))),b,d);$s=10;case 10:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}i[0]=s;$s=8;continue;case 6:t=o((j.$ptr||(j.$ptr=new CB(function(){return this.$target[0];},function($v){this.$target[0]=$v;},j))),b,d);$s=11;case 11:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}i[0]=t;$s=8;continue;case 7:u=o((f.$ptr||(f.$ptr=new CB(function(){return this.$target[0];},function($v){this.$target[0]=$v;},f))),a,c);$s=12;case 12:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}i[0]=u;case 8:case 3:if(!i[0]){$s=-1;return[AJ,AK];}$s=1;continue;case 2:$s=-1;return[g[0],h[0]];}return;}}catch(err){$err=err;$s=-1;return[BS.nil,BT.nil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:AL};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};AM=function(a,b){var a,b,c,d,e,f,g,h,i,j;c=b.Inst;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),A.Inst);g=f.Op;if((g===(0))||(g===(1))||(g===(7))){}else if((g===(2))||(g===(3))||(g===(6))||(g===(4))||(g===(5))){(h=a.Inst,((e<0||e>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+e])).Next=BT.nil;}else if((g===(8))||(g===(9))||(g===(10))){(i=a.Inst,((e<0||e>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+e])).Next=BT.nil;AD.copy((j=a.Inst,((e<0||e>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+e])),new AD.ptr($clone(f,A.Inst),BT.nil));}d++;}};AN=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,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;b=new AC.ptr($makeSlice(CG,a.Inst.$length),a.Start,a.NumCap);c=a.Inst;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]),A.Inst);AD.copy((g=b.Inst,((e<0||e>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+e])),new AD.ptr($clone(f,A.Inst),BT.nil));d++;}h=b.Inst;i=0;while(true){if(!(i=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+j])).Inst.Op;if((l===(0))||(l===(1))){o=(m=(n=b.Inst,((j<0||j>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+j])),(m.$ptr_Out||(m.$ptr_Out=new CH(function(){return this.$target.Inst.Out;},function($v){this.$target.Inst.Out=$v;},m))));r=(p=(q=b.Inst,((j<0||j>=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+j])),(p.$ptr_Arg||(p.$ptr_Arg=new CH(function(){return this.$target.Inst.Arg;},function($v){this.$target.Inst.Arg=$v;},p))));u=$clone((s=b.Inst,t=r.$get(),((t<0||t>=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+t])),AD);if(!((u.Inst.Op===0)||(u.Inst.Op===1))){v=o;w=r;r=v;o=w;AD.copy(u,(x=b.Inst,y=r.$get(),((y<0||y>=x.$length)?($throwRuntimeError("index out of range"),undefined):x.$array[x.$offset+y])));if(!((u.Inst.Op===0)||(u.Inst.Op===1))){i++;continue;}}ab=$clone((z=b.Inst,aa=o.$get(),((aa<0||aa>=z.$length)?($throwRuntimeError("index out of range"),undefined):z.$array[z.$offset+aa])),AD);if((ab.Inst.Op===0)||(ab.Inst.Op===1)){i++;continue;}af=(ac=(ad=b.Inst,ae=r.$get(),((ae<0||ae>=ad.$length)?($throwRuntimeError("index out of range"),undefined):ad.$array[ad.$offset+ae])),(ac.$ptr_Out||(ac.$ptr_Out=new CH(function(){return this.$target.Inst.Out;},function($v){this.$target.Inst.Out=$v;},ac))));aj=(ag=(ah=b.Inst,ai=r.$get(),((ai<0||ai>=ah.$length)?($throwRuntimeError("index out of range"),undefined):ah.$array[ah.$offset+ai])),(ag.$ptr_Arg||(ag.$ptr_Arg=new CH(function(){return this.$target.Inst.Arg;},function($v){this.$target.Inst.Arg=$v;},ag))));ak=false;if(u.Inst.Out===((j>>>0))){ak=true;}else if(u.Inst.Arg===((j>>>0))){ak=true;al=aj;am=af;af=al;aj=am;}if(ak){af.$set(o.$get());}if(o.$get()===af.$get()){r.$set(aj.$get());}}else{i++;continue;}i++;}return b;};AO.prototype.Len=function(){var a;a=this;return a.$length;};$ptrType(AO).prototype.Len=function(){return this.$get().Len();};AO.prototype.Less=function(a,b){var a,b,c;c=this;return((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a])<((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]);};$ptrType(AO).prototype.Less=function(a,b){return this.$get().Less(a,b);};AO.prototype.Swap=function(a,b){var a,b,c,d,e;c=this;d=((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]);e=((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]);((a<0||a>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]=d);((b<0||b>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+b]=e);};$ptrType(AO).prototype.Swap=function(a,b){return this.$get().Swap(a,b);};AR=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=[c];d=[d];e=[e];if(a[0].Inst.$length>=1000){$s=-1;return CD.nil;}c[0]=AI(a[0].Inst.$length);e[0]=AI(a[0].Inst.$length);b[0]=$throwNilPointerError;d[0]=$makeSlice(CI,a[0].Inst.$length);b[0]=(function(a,b,c,d,e){return function $b(f,g){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;az=$f.az;ba=$f.ba;bb=$f.bb;bc=$f.bc;bd=$f.bd;be=$f.be;bf=$f.bf;bg=$f.bg;bh=$f.bh;bi=$f.bi;bj=$f.bj;bk=$f.bk;bl=$f.bl;bm=$f.bm;bn=$f.bn;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:h=false;h=true;j=(i=a[0].Inst,((f<0||f>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+f]));if(e[0].contains(f)){$s=-1;return h;}e[0].insert(f);k=j.Inst.Op;if((k===(0))||(k===(1))){$s=2;continue;}if((k===(2))||(k===(6))){$s=3;continue;}if(k===(3)){$s=4;continue;}if((k===(4))||(k===(5))){$s=5;continue;}if(k===(7)){$s=6;continue;}if(k===(8)){$s=7;continue;}if(k===(9)){$s=8;continue;}if(k===(10)){$s=9;continue;}$s=10;continue;case 2:m=b[0](j.Inst.Out,g);$s=12;case 12:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}if(!(m)){l=false;$s=11;continue s;}n=b[0](j.Inst.Arg,g);$s=13;case 13:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}l=n;case 11:h=l;p=(o=j.Inst.Out,((o<0||o>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+o]));r=(q=j.Inst.Arg,((q<0||q>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+q]));if(p&&r){h=false;$s=1;continue;}if(r){s=j.Inst.Arg;t=j.Inst.Out;j.Inst.Out=s;j.Inst.Arg=t;u=r;v=p;p=u;r=v;}if(p){((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=true);j.Inst.Op=1;}x=AL($indexPtr(d[0].$array,d[0].$offset+j.Inst.Out,CJ),$indexPtr(d[0].$array,d[0].$offset+j.Inst.Arg,CJ),j.Inst.Out,j.Inst.Arg);$s=14;case 14:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}w=x;((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=w[0]);j.Next=w[1];if(j.Next.$length>0&&((y=j.Next,(0>=y.$length?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+0]))===4294967295)){h=false;$s=1;continue;}$s=10;continue;case 3:z=b[0](j.Inst.Out,g);$s=15;case 15:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}h=z;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=(aa=j.Inst.Out,((aa<0||aa>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+aa])));((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=$appendSlice(new BS([]),(ab=j.Inst.Out,((ab<0||ab>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+ab]))));j.Next=$makeSlice(BT,((ac=((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]).$length/2,(ac===ac&&ac!==1/0&&ac!==-1/0)?ac>>0:$throwRuntimeError("integer divide by zero"))+1>>0));ad=j.Next;ae=0;while(true){if(!(ae=ag.$length)?($throwRuntimeError("index out of range"),undefined):ag.$array[ag.$offset+af]=j.Inst.Out));ae++;}$s=10;continue;case 4:ah=b[0](j.Inst.Out,g);$s=16;case 16:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}h=ah;((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=(ai=j.Inst.Out,((ai<0||ai>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+ai])));((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=$appendSlice(new BS([]),(aj=j.Inst.Out,((aj<0||aj>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+aj]))));j.Next=$makeSlice(BT,((ak=((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]).$length/2,(ak===ak&&ak!==1/0&&ak!==-1/0)?ak>>0:$throwRuntimeError("integer divide by zero"))+1>>0));al=j.Next;am=0;while(true){if(!(am=ao.$length)?($throwRuntimeError("index out of range"),undefined):ao.$array[ao.$offset+an]=j.Inst.Out));am++;}$s=10;continue;case 5:((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=(j.Inst.Op===4));$s=10;continue;case 6:((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=false);if(j.Next.$length>0){$s=1;continue;}c[0].insert(j.Inst.Out);if(j.Inst.Rune.$length===0){((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=new BS([]));j.Next=new BT([j.Inst.Out]);$s=1;continue;}ap=$makeSlice(BS,0);if((j.Inst.Rune.$length===1)&&!((((((j.Inst.Arg<<16>>>16))&1)>>>0)===0))){$s=17;continue;}$s=18;continue;case 17:ar=(aq=j.Inst.Rune,(0>=aq.$length?($throwRuntimeError("index out of range"),undefined):aq.$array[aq.$offset+0]));ap=$append(ap,ar,ar);as=F.SimpleFold(ar);while(true){if(!(!((as===ar)))){break;}ap=$append(ap,as,as);as=F.SimpleFold(as);}$r=D.Sort(($subslice(new AO(ap.$array),ap.$offset,ap.$offset+ap.$length)));$s=20;case 20:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=19;continue;case 18:ap=$appendSlice(ap,j.Inst.Rune);case 19:((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=ap);j.Next=$makeSlice(BT,((at=((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]).$length/2,(at===at&&at!==1/0&&at!==-1/0)?at>>0:$throwRuntimeError("integer divide by zero"))+1>>0));au=j.Next;av=0;while(true){if(!(av=ax.$length)?($throwRuntimeError("index out of range"),undefined):ax.$array[ax.$offset+aw]=j.Inst.Out));av++;}j.Inst.Op=7;$s=10;continue;case 7:((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=false);if(j.Next.$length>0){$s=1;continue;}c[0].insert(j.Inst.Out);ay=new BS([]);if(!((((((j.Inst.Arg<<16>>>16))&1)>>>0)===0))){$s=21;continue;}$s=22;continue;case 21:ba=(az=j.Inst.Rune,(0>=az.$length?($throwRuntimeError("index out of range"),undefined):az.$array[az.$offset+0]));ay=$append(ay,ba,ba);bb=F.SimpleFold(ba);while(true){if(!(!((bb===ba)))){break;}ay=$append(ay,bb,bb);bb=F.SimpleFold(bb);}$r=D.Sort(($subslice(new AO(ay.$array),ay.$offset,ay.$offset+ay.$length)));$s=24;case 24:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=23;continue;case 22:ay=$append(ay,(bc=j.Inst.Rune,(0>=bc.$length?($throwRuntimeError("index out of range"),undefined):bc.$array[bc.$offset+0])),(bd=j.Inst.Rune,(0>=bd.$length?($throwRuntimeError("index out of range"),undefined):bd.$array[bd.$offset+0])));case 23:((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=ay);j.Next=$makeSlice(BT,((be=((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]).$length/2,(be===be&&be!==1/0&&be!==-1/0)?be>>0:$throwRuntimeError("integer divide by zero"))+1>>0));bf=j.Next;bg=0;while(true){if(!(bg=bi.$length)?($throwRuntimeError("index out of range"),undefined):bi.$array[bi.$offset+bh]=j.Inst.Out));bg++;}j.Inst.Op=7;$s=10;continue;case 8:((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=false);if(j.Next.$length>0){$s=1;continue;}c[0].insert(j.Inst.Out);((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=$appendSlice(new BS([]),AQ));j.Next=new BT([j.Inst.Out]);$s=10;continue;case 9:((f<0||f>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+f]=false);if(j.Next.$length>0){$s=1;continue;}c[0].insert(j.Inst.Out);((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]=$appendSlice(new BS([]),AP));j.Next=$makeSlice(BT,((bj=((f<0||f>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+f]).$length/2,(bj===bj&&bj!==1/0&&bj!==-1/0)?bj>>0:$throwRuntimeError("integer divide by zero"))+1>>0));bk=j.Next;bl=0;while(true){if(!(bl=bn.$length)?($throwRuntimeError("index out of range"),undefined):bn.$array[bn.$offset+bm]=j.Inst.Out));bl++;}case 10:case 1:$s=-1;return h;}return;}if($f===undefined){$f={$blk:$b};}$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.az=az;$f.ba=ba;$f.bb=bb;$f.bc=bc;$f.bd=bd;$f.be=be;$f.bf=bf;$f.bg=bg;$f.bh=bh;$f.bi=bi;$f.bj=bj;$f.bk=bk;$f.bl=bl;$f.bm=bm;$f.bn=bn;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};})(a,b,c,d,e);c[0].clear();c[0].insert(((a[0].Start>>>0)));f=$makeSlice(CK,a[0].Inst.$length);case 1:if(!(!c[0].empty())){$s=2;continue;}e[0].clear();g=c[0].next();h=b[0](g,f);$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}if(!h){$s=3;continue;}$s=4;continue;case 3:a[0]=CD.nil;$s=2;continue;case 4:$s=1;continue;case 2:if(!(a[0]===CD.nil)){i=a[0].Inst;j=0;while(true){if(!(j=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+k])).Inst.Rune=((k<0||k>=d[0].$length)?($throwRuntimeError("index out of range"),undefined):d[0].$array[d[0].$offset+k]);j++;}}$s=-1;return a[0];}return;}if($f===undefined){$f={$blk:AR};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AS=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=CD.nil;if(a.Start===0){b=CD.nil;$s=-1;return b;}if(!(((c=a.Inst,d=a.Start,((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d])).Op===3))||!(((((((e=a.Inst,f=a.Start,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f])).Arg<<24>>>24))&4)>>>0)===4))){b=CD.nil;$s=-1;return b;}g=a.Inst;h=0;case 1:if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]),A.Inst);l=(j=a.Inst,k=i.Out,((k<0||k>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k])).Op;m=i.Op;if((m===(0))||(m===(1))){if((l===4)||((n=a.Inst,o=i.Arg,((o<0||o>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o])).Op===4)){b=CD.nil;$s=-1;return b;}}else if(m===(3)){if(l===4){if(((((i.Arg<<24>>>24))&8)>>>0)===8){h++;$s=1;continue;}b=CD.nil;$s=-1;return b;}}else if(l===4){b=CD.nil;$s=-1;return b;}h++;$s=1;continue;case 2:b=AN(a);p=AR(b);$s=3;case 3:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}b=p;if(!(b===CD.nil)){AM(b,a);}b=b;$s=-1;return b;}return;}if($f===undefined){$f={$blk:AS};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};AT.ptr.prototype.String=function(){var a;a=this;return a.expr;};AT.prototype.String=function(){return this.$val.String();};AT.ptr.prototype.Copy=function(){var a,b;a=this;b=$clone(a,AT);return b;};AT.prototype.Copy=function(){return this.$val.Copy();};AU=function(a){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=AW(a,212,false);$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;}return;}if($f===undefined){$f={$blk:AU};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};$pkg.Compile=AU;AT.ptr.prototype.Longest=function(){var a;a=this;a.longest=true;};AT.prototype.Longest=function(){return this.$val.Longest();};AW=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=A.Parse(a,b);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;f=d[0];g=d[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[CL.nil,g];}h=f.MaxCap();i=f.CapNames();f=f.Simplify();j=A.Compile(f);k=j[0];g=j[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[CL.nil,g];}l=k.NumCap;if(l<2){l=2;}m=AS(k);$s=2;case 2:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=new AT.ptr(a,k,m,h,0,i,"",BX.nil,0,0,0,l,false,k.StartCond(),c);if(n.onepass===CD.nil){o=k.Prefix();n.prefix=o[0];n.prefixComplete=o[1];n.maxBitStateLen=O(k);}else{p=AE(k);n.prefix=p[0];n.prefixComplete=p[1];n.prefixEnd=p[2];}if(!(n.prefix==="")){n.prefixBytes=(new BX($stringToBytes(n.prefix)));q=I.DecodeRuneInString(n.prefix);n.prefixRune=q[0];}r=k.Inst.$length;s=0;while(true){if(!(!((((s<0||s>=AX.length)?($throwRuntimeError("index out of range"),undefined):AX[s])===0))&&((s<0||s>=AX.length)?($throwRuntimeError("index out of range"),undefined):AX[s])>0;}n.mpool=s;$s=-1;return[n,$ifaceNil];}return;}if($f===undefined){$f={$blk:AW};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.$s=$s;$f.$r=$r;return $f;};AT.ptr.prototype.get=function(){var a,b,c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;d=(c=a.mpool,((c<0||c>=AY.length)?($throwRuntimeError("index out of range"),undefined):AY[c])).Get();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}b=$assertType(d,CO,true);e=b[0];f=b[1];if(!f){e=new T.ptr(CL.nil,CM.nil,new Q.ptr(BT.nil,CP.nil),new Q.ptr(BT.nil,CP.nil),CQ.nil,false,BV.nil,new U.ptr(new BE.ptr(BX.nil),new BD.ptr(""),new BF.ptr($ifaceNil,false,0)));}e.re=a;e.p=a.prog;if(e.matchcap.$capacity=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);i.cap=$makeSlice(BV,a.matchcap);h++;}}k=(j=a.mpool,((j<0||j>=AX.length)?($throwRuntimeError("index out of range"),undefined):AX[j]));if(k===0){k=a.prog.Inst.$length;}if(e.q0.sparse.$length=AY.length)?($throwRuntimeError("index out of range"),undefined):AY[c])).Put(a);};AT.prototype.put=function(a){return this.$val.put(a);};AZ=function(a){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=AU(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=2;continue;}$s=3;continue;case 2:f=e.Error();$s=4;case 4:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}$panic(new $String("regexp: Compile("+BB(a)+"): "+f));case 3:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AZ};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};$pkg.MustCompile=AZ;BB=function(a){var a;if(H.CanBackquote(a)){return"`"+a+"`";}return H.Quote(a);};AT.ptr.prototype.NumSubexp=function(){var a;a=this;return a.numSubexp;};AT.prototype.NumSubexp=function(){return this.$val.NumSubexp();};AT.ptr.prototype.SubexpNames=function(){var a;a=this;return a.subexpNames;};AT.prototype.SubexpNames=function(){return this.$val.SubexpNames();};BD.ptr.prototype.step=function(a){var a,b,c;b=this;if(a>0)),1];}return I.DecodeRuneInString($substring(b.str,a));}return[-1,0];};BD.prototype.step=function(a){return this.$val.step(a);};BD.ptr.prototype.canCheckPrefix=function(){var a;a=this;return true;};BD.prototype.canCheckPrefix=function(){return this.$val.canCheckPrefix();};BD.ptr.prototype.hasPrefix=function(a){var a,b;b=this;return E.HasPrefix(b.str,a.prefix);};BD.prototype.hasPrefix=function(a){return this.$val.hasPrefix(a);};BD.ptr.prototype.index=function(a,b){var a,b,c;c=this;return E.Index($substring(c.str,b),a.prefix);};BD.prototype.index=function(a,b){return this.$val.index(a,b);};BD.ptr.prototype.context=function(a){var a,b,c,d,e,f,g,h;b=this;c=-1;d=-1;e=c;f=d;if((((a-1>>0)>>>0))<((b.str.length>>>0))){e=((b.str.charCodeAt((a-1>>0))>>0));if(e>=128){g=I.DecodeLastRuneInString($substring(b.str,0,a));e=g[0];}}if(((a>>>0))<((b.str.length>>>0))){f=((b.str.charCodeAt(a)>>0));if(f>=128){h=I.DecodeRuneInString($substring(b.str,a));f=h[0];}}return W(e,f);};BD.prototype.context=function(a){return this.$val.context(a);};BE.ptr.prototype.step=function(a){var a,b,c,d;b=this;if(a=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+a]));if(d<128){return[((d>>0)),1];}return I.DecodeRune($subslice(b.str,a));}return[-1,0];};BE.prototype.step=function(a){return this.$val.step(a);};BE.ptr.prototype.canCheckPrefix=function(){var a;a=this;return true;};BE.prototype.canCheckPrefix=function(){return this.$val.canCheckPrefix();};BE.ptr.prototype.hasPrefix=function(a){var a,b;b=this;return G.HasPrefix(b.str,a.prefixBytes);};BE.prototype.hasPrefix=function(a){return this.$val.hasPrefix(a);};BE.ptr.prototype.index=function(a,b){var a,b,c;c=this;return G.Index($subslice(c.str,b),a.prefixBytes);};BE.prototype.index=function(a,b){return this.$val.index(a,b);};BE.ptr.prototype.context=function(a){var a,b,c,d,e,f,g,h,i,j,k;b=this;c=-1;d=-1;e=c;f=d;if((((a-1>>0)>>>0))<((b.str.$length>>>0))){e=(((g=b.str,h=a-1>>0,((h<0||h>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]))>>0));if(e>=128){i=I.DecodeLastRune($subslice(b.str,0,a));e=i[0];}}if(((a>>>0))<((b.str.$length>>>0))){f=(((j=b.str,((a<0||a>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+a]))>>0));if(f>=128){k=I.DecodeRune($subslice(b.str,a));f=k[0];}}return W(e,f);};BE.prototype.context=function(a){return this.$val.context(a);};BF.ptr.prototype.step=function(a){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;if(!b.atEOT&&!((a===b.pos))){$s=-1;return[-1,0];}d=b.r.ReadRune();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;e=c[0];f=c[1];g=c[2];if(!($interfaceIsEqual(g,$ifaceNil))){b.atEOT=true;$s=-1;return[-1,0];}b.pos=b.pos+(f)>>0;$s=-1;return[e,f];}return;}if($f===undefined){$f={$blk:BF.ptr.prototype.step};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};BF.prototype.step=function(a){return this.$val.step(a);};BF.ptr.prototype.canCheckPrefix=function(){var a;a=this;return false;};BF.prototype.canCheckPrefix=function(){return this.$val.canCheckPrefix();};BF.ptr.prototype.hasPrefix=function(a){var a,b;b=this;return false;};BF.prototype.hasPrefix=function(a){return this.$val.hasPrefix(a);};BF.ptr.prototype.index=function(a,b){var a,b,c;c=this;return-1;};BF.prototype.index=function(a,b){return this.$val.index(a,b);};BF.ptr.prototype.context=function(a){var a,b;b=this;return new V(0,0);};BF.prototype.context=function(a){return this.$val.context(a);};AT.ptr.prototype.LiteralPrefix=function(){var a,b,c,d,e;a="";b=false;c=this;d=c.prefix;e=c.prefixComplete;a=d;b=e;return[a,b];};AT.prototype.LiteralPrefix=function(){return this.$val.LiteralPrefix();};AT.ptr.prototype.MatchReader=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doMatch(a,BX.nil,"");$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.MatchReader};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.MatchReader=function(a){return this.$val.MatchReader(a);};AT.ptr.prototype.MatchString=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doMatch($ifaceNil,BX.nil,a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.MatchString};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.MatchString=function(a){return this.$val.MatchString(a);};AT.ptr.prototype.Match=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doMatch($ifaceNil,a,"");$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.Match};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.Match=function(a){return this.$val.Match(a);};AT.ptr.prototype.ReplaceAllString=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=[c];c[0]=this;d=2;if(E.Contains(b[0],"$")){d=$imul(2,((c[0].numSubexp+1>>0)));}e=c[0].replaceAll(BX.nil,a[0],d,(function(a,b,c){return function(e,f){var e,f;return c[0].expand(e,b[0],BX.nil,a[0],f);};})(a,b,c));$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;$s=-1;return($bytesToString(f));}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAllString};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAllString=function(a,b){return this.$val.ReplaceAllString(a,b);};AT.ptr.prototype.ReplaceAllLiteralString=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=[b];c=this;d=c.replaceAll(BX.nil,a,2,(function(b){return function(d,e){var d,e;return $appendSlice(d,b[0]);};})(b));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return($bytesToString(d));}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAllLiteralString};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAllLiteralString=function(a,b){return this.$val.ReplaceAllLiteralString(a,b);};AT.ptr.prototype.ReplaceAllStringFunc=function(a,b){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=this;d=c.replaceAll(BX.nil,a[0],2,(function(a,b){return function $b(d,e){var d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=d;g=b[0]($substring(a[0],(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1])));$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;$s=-1;return $appendSlice(f,h);}return;}if($f===undefined){$f={$blk:$b};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};})(a,b));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;$s=-1;return($bytesToString(e));}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAllStringFunc};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAllStringFunc=function(a,b){return this.$val.ReplaceAllStringFunc(a,b);};AT.ptr.prototype.replaceAll=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=this;f=0;g=0;h=BX.nil;i=0;if(!(a===BX.nil)){i=a.$length;}else{i=b.length;}if(c>e.prog.NumCap){c=e.prog.NumCap;}j=CR.zero();case 1:if(!(g<=i)){$s=2;continue;}k=e.doExecute($ifaceNil,a,b,g,c,$subslice(new BV(j),0,0));$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=k;if(l.$length===0){$s=2;continue;}if(!(a===BX.nil)){h=$appendSlice(h,$subslice(a,f,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0])));}else{h=$appendSlice(h,$substring(b,f,(0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0])));}if((1>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+1])>f||((0>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+0])===0)){$s=4;continue;}$s=5;continue;case 4:m=d(h,l);$s=6;case 6:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}h=m;case 5:f=(1>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+1]);n=0;if(!(a===BX.nil)){o=I.DecodeRune($subslice(a,g));n=o[1];}else{p=I.DecodeRuneInString($substring(b,g));n=p[1];}if((g+n>>0)>(1>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+1])){g=g+(n)>>0;}else if((g+1>>0)>(1>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+1])){g=g+(1)>>0;}else{g=(1>=l.$length?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+1]);}$s=1;continue;case 2:if(!(a===BX.nil)){h=$appendSlice(h,$subslice(a,f));}else{h=$appendSlice(h,$substring(b,f));}$s=-1;return h;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.replaceAll};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.replaceAll=function(a,b,c,d){return this.$val.replaceAll(a,b,c,d);};AT.ptr.prototype.ReplaceAll=function(a,b){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=[c];d=[d];c[0]=this;e=2;if(G.IndexByte(b[0],36)>=0){e=$imul(2,((c[0].numSubexp+1>>0)));}d[0]="";f=c[0].replaceAll(a[0],"",e,(function(a,b,c,d){return function(f,g){var f,g;if(!((d[0].length===b[0].$length))){d[0]=($bytesToString(b[0]));}return c[0].expand(f,d[0],a[0],"",g);};})(a,b,c,d));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;$s=-1;return g;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAll};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAll=function(a,b){return this.$val.ReplaceAll(a,b);};AT.ptr.prototype.ReplaceAllLiteral=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=[b];c=this;d=c.replaceAll(a,"",2,(function(b){return function(d,e){var d,e;return $appendSlice(d,b[0]);};})(b));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAllLiteral};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAllLiteral=function(a,b){return this.$val.ReplaceAllLiteral(a,b);};AT.ptr.prototype.ReplaceAllFunc=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];b=[b];c=this;d=c.replaceAll(a[0],"",2,(function(a,b){return function $b(d,e){var d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=d;g=b[0]($subslice(a[0],(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1])));$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;$s=-1;return $appendSlice(f,h);}return;}if($f===undefined){$f={$blk:$b};}$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};})(a,b));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.ReplaceAllFunc};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.ReplaceAllFunc=function(a,b){return this.$val.ReplaceAllFunc(a,b);};BL=function(){var a,b,c,d,e,f,g;a=(new BX($stringToBytes("\\.+*?()|[]{}^$")));b=0;while(true){if(!(b=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+b]);e=(d=c%16,d===d?d:$throwRuntimeError("integer divide by zero"));((e<0||e>=BJ.length)?($throwRuntimeError("index out of range"),undefined):BJ[e]=((((e<0||e>=BJ.length)?($throwRuntimeError("index out of range"),undefined):BJ[e])|(((f=((g=c/16,(g===g&&g!==1/0&&g!==-1/0)?g>>>0:$throwRuntimeError("integer divide by zero"))),f<32?(1<>>24)))>>>0));b++;}};AT.ptr.prototype.pad=function(a){var a,b,c;b=this;if(a===BV.nil){return BV.nil;}c=$imul(((1+b.numSubexp>>0)),2);while(true){if(!(a.$length=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+1])===j){if((0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0])===l){o=false;}p=0;if(b===BX.nil){q=I.DecodeRuneInString($substring(a,j,f));p=q[1];}else{r=I.DecodeRune($subslice(b,j,f));p=r[1];}if(p>0){j=j+(p)>>0;}else{j=f+1>>0;}}else{j=(1>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+1]);}l=(1>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+1]);if(o){$s=4;continue;}$s=5;continue;case 4:$r=d(e.pad(n));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}k=k+(1)>>0;case 5:$s=1;continue;case 2:$s=-1;return;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.allMatches};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.allMatches=function(a,b,c,d){return this.$val.allMatches(a,b,c,d);};AT.ptr.prototype.Find=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=CR.zero();d=b.doExecute($ifaceNil,a,"",0,2,$subslice(new BV(c),0,0));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){$s=-1;return BX.nil;}$s=-1;return $subslice(a,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]));}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.Find};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.Find=function(a){return this.$val.Find(a);};AT.ptr.prototype.FindIndex=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=BV.nil;c=this;d=c.doExecute($ifaceNil,a,"",0,2,BV.nil);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){b=BV.nil;$s=-1;return b;}b=$subslice(e,0,2);$s=-1;return b;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindIndex=function(a){return this.$val.FindIndex(a);};AT.ptr.prototype.FindString=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=CR.zero();d=b.doExecute($ifaceNil,BX.nil,a,0,2,$subslice(new BV(c),0,0));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){$s=-1;return"";}$s=-1;return $substring(a,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]));}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindString};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindString=function(a){return this.$val.FindString(a);};AT.ptr.prototype.FindStringIndex=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=BV.nil;c=this;d=c.doExecute($ifaceNil,BX.nil,a,0,2,BV.nil);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){b=BV.nil;$s=-1;return b;}b=$subslice(e,0,2);$s=-1;return b;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindStringIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindStringIndex=function(a){return this.$val.FindStringIndex(a);};AT.ptr.prototype.FindReaderIndex=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=BV.nil;c=this;d=c.doExecute(a,BX.nil,"",0,2,BV.nil);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){b=BV.nil;$s=-1;return b;}b=$subslice(e,0,2);$s=-1;return b;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindReaderIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindReaderIndex=function(a){return this.$val.FindReaderIndex(a);};AT.ptr.prototype.FindSubmatch=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=CS.zero();d=b.doExecute($ifaceNil,a,"",0,b.prog.NumCap,$subslice(new BV(c),0,0));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){$s=-1;return CT.nil;}f=$makeSlice(CT,(1+b.numSubexp>>0));g=f;h=0;while(true){if(!(h=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+j]))>=0){((i<0||i>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+i]=$subslice(a,(k=$imul(2,i),((k<0||k>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k])),(l=($imul(2,i))+1>>0,((l<0||l>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l]))));}h++;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindSubmatch};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindSubmatch=function(a){return this.$val.FindSubmatch(a);};AT.ptr.prototype.Expand=function(a,b,c,d){var a,b,c,d,e;e=this;return e.expand(a,($bytesToString(b)),c,"",d);};AT.prototype.Expand=function(a,b,c,d){return this.$val.Expand(a,b,c,d);};AT.ptr.prototype.ExpandString=function(a,b,c,d){var a,b,c,d,e;e=this;return e.expand(a,b,BX.nil,c,d);};AT.prototype.ExpandString=function(a,b,c,d){return this.$val.ExpandString(a,b,c,d);};AT.ptr.prototype.expand=function(a,b,c,d,e){var 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;f=this;while(true){if(!(b.length>0)){break;}g=E.Index(b,"$");if(g<0){break;}a=$appendSlice(a,$substring(b,0,g));b=$substring(b,g);if(b.length>1&&(b.charCodeAt(1)===36)){a=$append(a,36);b=$substring(b,2);continue;}h=BN(b);i=h[0];j=h[1];k=h[2];l=h[3];if(!l){a=$append(a,36);b=$substring(b,1);continue;}b=k;if(j>=0){if((($imul(2,j))+1>>0)=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]))>=0){if(!(c===BX.nil)){a=$appendSlice(a,$subslice(c,(n=$imul(2,j),((n<0||n>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+n])),(o=($imul(2,j))+1>>0,((o<0||o>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+o]))));}else{a=$appendSlice(a,$substring(d,(p=$imul(2,j),((p<0||p>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+p])),(q=($imul(2,j))+1>>0,((q<0||q>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+q]))));}}}else{r=f.subexpNames;s=0;while(true){if(!(s=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+s]);if(i===u&&(($imul(2,t))+1>>0)=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+v]))>=0){if(!(c===BX.nil)){a=$appendSlice(a,$subslice(c,(w=$imul(2,t),((w<0||w>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+w])),(x=($imul(2,t))+1>>0,((x<0||x>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+x]))));}else{a=$appendSlice(a,$substring(d,(y=$imul(2,t),((y<0||y>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+y])),(z=($imul(2,t))+1>>0,((z<0||z>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+z]))));}break;}s++;}}}a=$appendSlice(a,b);return a;};AT.prototype.expand=function(a,b,c,d,e){return this.$val.expand(a,b,c,d,e);};BN=function(a){var a,b,c,d,e,f,g,h,i,j,k;b="";c=0;d="";e=false;if(a.length<2||!((a.charCodeAt(0)===36))){return[b,c,d,e];}f=false;if(a.charCodeAt(1)===123){f=true;a=$substring(a,2);}else{a=$substring(a,1);}g=0;while(true){if(!(g>0;}if(g===0){return[b,c,d,e];}b=$substring(a,0,g);if(f){if(g>=a.length||!((a.charCodeAt(g)===125))){return[b,c,d,e];}g=g+(1)>>0;}c=0;k=0;while(true){if(!(k=100000000){c=-1;break;}c=(($imul(c,10))+((b.charCodeAt(k)>>0))>>0)-48>>0;k=k+(1)>>0;}if((b.charCodeAt(0)===48)&&b.length>1){c=-1;}d=$substring(a,g);e=true;return[b,c,d,e];};AT.ptr.prototype.FindSubmatchIndex=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doExecute($ifaceNil,a,"",0,b.prog.NumCap,BV.nil);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=b.pad(c);$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindSubmatchIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindSubmatchIndex=function(a){return this.$val.FindSubmatchIndex(a);};AT.ptr.prototype.FindStringSubmatch=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=CS.zero();d=b.doExecute($ifaceNil,BX.nil,a,0,b.prog.NumCap,$subslice(new BV(c),0,0));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;if(e===BV.nil){$s=-1;return CN.nil;}f=$makeSlice(CN,(1+b.numSubexp>>0));g=f;h=0;while(true){if(!(h=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+j]))>=0){((i<0||i>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+i]=$substring(a,(k=$imul(2,i),((k<0||k>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k])),(l=($imul(2,i))+1>>0,((l<0||l>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l]))));}h++;}$s=-1;return f;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindStringSubmatch};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindStringSubmatch=function(a){return this.$val.FindStringSubmatch(a);};AT.ptr.prototype.FindStringSubmatchIndex=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doExecute($ifaceNil,BX.nil,a,0,b.prog.NumCap,BV.nil);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=b.pad(c);$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindStringSubmatchIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindStringSubmatchIndex=function(a){return this.$val.FindStringSubmatchIndex(a);};AT.ptr.prototype.FindReaderSubmatchIndex=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.doExecute(a,BX.nil,"",0,b.prog.NumCap,BV.nil);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=b.pad(c);$s=2;case 2:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindReaderSubmatchIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindReaderSubmatchIndex=function(a){return this.$val.FindReaderSubmatchIndex(a);};AT.ptr.prototype.FindAll=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];c=[c];d=this;if(b<0){b=a[0].$length+1>>0;}c[0]=CT.nil;$r=d.allMatches("",a[0],b,(function(a,c){return function(e){var e;if(c[0]===CT.nil){c[0]=$makeSlice(CT,0,10);}c[0]=$append(c[0],$subslice(a[0],(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1])));};})(a,c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAll};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAll=function(a,b){return this.$val.FindAll(a,b);};AT.ptr.prototype.FindAllIndex=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;if(b<0){b=a.$length+1>>0;}c[0]=CU.nil;$r=d.allMatches("",a,b,(function(c){return function(e){var e;if(c[0]===CU.nil){c[0]=$makeSlice(CU,0,10);}c[0]=$append(c[0],$subslice(e,0,2));};})(c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllIndex=function(a,b){return this.$val.FindAllIndex(a,b);};AT.ptr.prototype.FindAllString=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];c=[c];d=this;if(b<0){b=a[0].length+1>>0;}c[0]=CN.nil;$r=d.allMatches(a[0],BX.nil,b,(function(a,c){return function(e){var e;if(c[0]===CN.nil){c[0]=$makeSlice(CN,0,10);}c[0]=$append(c[0],$substring(a[0],(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]),(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1])));};})(a,c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllString};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllString=function(a,b){return this.$val.FindAllString(a,b);};AT.ptr.prototype.FindAllStringIndex=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;if(b<0){b=a.length+1>>0;}c[0]=CU.nil;$r=d.allMatches(a,BX.nil,b,(function(c){return function(e){var e;if(c[0]===CU.nil){c[0]=$makeSlice(CU,0,10);}c[0]=$append(c[0],$subslice(e,0,2));};})(c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllStringIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllStringIndex=function(a,b){return this.$val.FindAllStringIndex(a,b);};AT.ptr.prototype.FindAllSubmatch=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];c=[c];d=this;if(b<0){b=a[0].$length+1>>0;}c[0]=CV.nil;$r=d.allMatches("",a[0],b,(function(a,c){return function(e){var e,f,g,h,i,j,k,l,m;if(c[0]===CV.nil){c[0]=$makeSlice(CV,0,10);}g=$makeSlice(CT,(f=e.$length/2,(f===f&&f!==1/0&&f!==-1/0)?f>>0:$throwRuntimeError("integer divide by zero")));h=g;i=0;while(true){if(!(i=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k]))>=0){((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]=$subslice(a[0],(l=$imul(2,j),((l<0||l>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l])),(m=($imul(2,j))+1>>0,((m<0||m>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]))));}i++;}c[0]=$append(c[0],g);};})(a,c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllSubmatch};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllSubmatch=function(a,b){return this.$val.FindAllSubmatch(a,b);};AT.ptr.prototype.FindAllSubmatchIndex=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;if(b<0){b=a.$length+1>>0;}c[0]=CU.nil;$r=d.allMatches("",a,b,(function(c){return function(e){var e;if(c[0]===CU.nil){c[0]=$makeSlice(CU,0,10);}c[0]=$append(c[0],e);};})(c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllSubmatchIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllSubmatchIndex=function(a,b){return this.$val.FindAllSubmatchIndex(a,b);};AT.ptr.prototype.FindAllStringSubmatch=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];c=[c];d=this;if(b<0){b=a[0].length+1>>0;}c[0]=CW.nil;$r=d.allMatches(a[0],BX.nil,b,(function(a,c){return function(e){var e,f,g,h,i,j,k,l,m;if(c[0]===CW.nil){c[0]=$makeSlice(CW,0,10);}g=$makeSlice(CN,(f=e.$length/2,(f===f&&f!==1/0&&f!==-1/0)?f>>0:$throwRuntimeError("integer divide by zero")));h=g;i=0;while(true){if(!(i=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+k]))>=0){((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j]=$substring(a[0],(l=$imul(2,j),((l<0||l>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l])),(m=($imul(2,j))+1>>0,((m<0||m>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+m]))));}i++;}c[0]=$append(c[0],g);};})(a,c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllStringSubmatch};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllStringSubmatch=function(a,b){return this.$val.FindAllStringSubmatch(a,b);};AT.ptr.prototype.FindAllStringSubmatchIndex=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];d=this;if(b<0){b=a.length+1>>0;}c[0]=CU.nil;$r=d.allMatches(a,BX.nil,b,(function(c){return function(e){var e;if(c[0]===CU.nil){c[0]=$makeSlice(CU,0,10);}c[0]=$append(c[0],e);};})(c));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return c[0];}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.FindAllStringSubmatchIndex};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.FindAllStringSubmatchIndex=function(a,b){return this.$val.FindAllStringSubmatchIndex(a,b);};AT.ptr.prototype.Split=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=this;if(b===0){$s=-1;return CN.nil;}if(c.expr.length>0&&(a.length===0)){$s=-1;return new CN([""]);}d=c.FindAllStringIndex(a,b);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;f=$makeSlice(CN,0,e.$length);g=0;h=0;i=e;j=0;while(true){if(!(j=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]);if(b>0&&f.$length>=(b-1>>0)){break;}h=(0>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+0]);if(!(((1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1])===0))){f=$append(f,$substring(a,g,h));}g=(1>=k.$length?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+1]);j++;}if(!((h===a.length))){f=$append(f,$substring(a,g));}$s=-1;return f;}return;}if($f===undefined){$f={$blk:AT.ptr.prototype.Split};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};AT.prototype.Split=function(a,b){return this.$val.Split(a,b);};BU.methods=[{prop:"reset",name:"reset",pkg:"regexp",typ:$funcType([CM,$Int,$Int],[],false)},{prop:"shouldVisit",name:"shouldVisit",pkg:"regexp",typ:$funcType([$Uint32,$Int],[$Bool],false)},{prop:"push",name:"push",pkg:"regexp",typ:$funcType([CL,$Uint32,$Int,$Bool],[],false)}];CO.methods=[{prop:"init",name:"init",pkg:"regexp",typ:$funcType([$Int],[],false)},{prop:"alloc",name:"alloc",pkg:"regexp",typ:$funcType([BZ],[BY],false)},{prop:"match",name:"match",pkg:"regexp",typ:$funcType([BC,$Int],[$Bool],false)},{prop:"clear",name:"clear",pkg:"regexp",typ:$funcType([CX],[],false)},{prop:"step",name:"step",pkg:"regexp",typ:$funcType([CX,CX,$Int,$Int,$Int32,CA],[],false)},{prop:"add",name:"add",pkg:"regexp",typ:$funcType([CX,$Uint32,$Int,BV,CA,BY],[BY],false)}];CY.methods=[{prop:"newBytes",name:"newBytes",pkg:"regexp",typ:$funcType([BX],[BC],false)},{prop:"newString",name:"newString",pkg:"regexp",typ:$funcType([$String],[BC],false)},{prop:"newReader",name:"newReader",pkg:"regexp",typ:$funcType([C.RuneReader],[BC],false)},{prop:"clear",name:"clear",pkg:"regexp",typ:$funcType([],[],false)},{prop:"init",name:"init",pkg:"regexp",typ:$funcType([C.RuneReader,BX,$String],[BC,$Int],false)}];V.methods=[{prop:"match",name:"match",pkg:"regexp",typ:$funcType([A.EmptyOp],[$Bool],false)}];CF.methods=[{prop:"empty",name:"empty",pkg:"regexp",typ:$funcType([],[$Bool],false)},{prop:"next",name:"next",pkg:"regexp",typ:$funcType([],[$Uint32],false)},{prop:"clear",name:"clear",pkg:"regexp",typ:$funcType([],[],false)},{prop:"contains",name:"contains",pkg:"regexp",typ:$funcType([$Uint32],[$Bool],false)},{prop:"insert",name:"insert",pkg:"regexp",typ:$funcType([$Uint32],[],false)},{prop:"insertNew",name:"insertNew",pkg:"regexp",typ:$funcType([$Uint32],[],false)}];AO.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Less",name:"Less",pkg:"",typ:$funcType([$Int,$Int],[$Bool],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$Int,$Int],[],false)}];CL.methods=[{prop:"tryBacktrack",name:"tryBacktrack",pkg:"regexp",typ:$funcType([BU,BC,$Uint32,$Int],[$Bool],false)},{prop:"backtrack",name:"backtrack",pkg:"regexp",typ:$funcType([BX,$String,$Int,$Int,BV],[BV],false)},{prop:"doOnePass",name:"doOnePass",pkg:"regexp",typ:$funcType([C.RuneReader,BX,$String,$Int,$Int,BV],[BV],false)},{prop:"doMatch",name:"doMatch",pkg:"regexp",typ:$funcType([C.RuneReader,BX,$String],[$Bool],false)},{prop:"doExecute",name:"doExecute",pkg:"regexp",typ:$funcType([C.RuneReader,BX,$String,$Int,$Int,BV],[BV],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Copy",name:"Copy",pkg:"",typ:$funcType([],[CL],false)},{prop:"Longest",name:"Longest",pkg:"",typ:$funcType([],[],false)},{prop:"get",name:"get",pkg:"regexp",typ:$funcType([],[CO],false)},{prop:"put",name:"put",pkg:"regexp",typ:$funcType([CO],[],false)},{prop:"NumSubexp",name:"NumSubexp",pkg:"",typ:$funcType([],[$Int],false)},{prop:"SubexpNames",name:"SubexpNames",pkg:"",typ:$funcType([],[CN],false)},{prop:"LiteralPrefix",name:"LiteralPrefix",pkg:"",typ:$funcType([],[$String,$Bool],false)},{prop:"MatchReader",name:"MatchReader",pkg:"",typ:$funcType([C.RuneReader],[$Bool],false)},{prop:"MatchString",name:"MatchString",pkg:"",typ:$funcType([$String],[$Bool],false)},{prop:"Match",name:"Match",pkg:"",typ:$funcType([BX],[$Bool],false)},{prop:"ReplaceAllString",name:"ReplaceAllString",pkg:"",typ:$funcType([$String,$String],[$String],false)},{prop:"ReplaceAllLiteralString",name:"ReplaceAllLiteralString",pkg:"",typ:$funcType([$String,$String],[$String],false)},{prop:"ReplaceAllStringFunc",name:"ReplaceAllStringFunc",pkg:"",typ:$funcType([$String,CZ],[$String],false)},{prop:"replaceAll",name:"replaceAll",pkg:"regexp",typ:$funcType([BX,$String,$Int,DA],[BX],false)},{prop:"ReplaceAll",name:"ReplaceAll",pkg:"",typ:$funcType([BX,BX],[BX],false)},{prop:"ReplaceAllLiteral",name:"ReplaceAllLiteral",pkg:"",typ:$funcType([BX,BX],[BX],false)},{prop:"ReplaceAllFunc",name:"ReplaceAllFunc",pkg:"",typ:$funcType([BX,DB],[BX],false)},{prop:"pad",name:"pad",pkg:"regexp",typ:$funcType([BV],[BV],false)},{prop:"allMatches",name:"allMatches",pkg:"regexp",typ:$funcType([$String,BX,$Int,DC],[],false)},{prop:"Find",name:"Find",pkg:"",typ:$funcType([BX],[BX],false)},{prop:"FindIndex",name:"FindIndex",pkg:"",typ:$funcType([BX],[BV],false)},{prop:"FindString",name:"FindString",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"FindStringIndex",name:"FindStringIndex",pkg:"",typ:$funcType([$String],[BV],false)},{prop:"FindReaderIndex",name:"FindReaderIndex",pkg:"",typ:$funcType([C.RuneReader],[BV],false)},{prop:"FindSubmatch",name:"FindSubmatch",pkg:"",typ:$funcType([BX],[CT],false)},{prop:"Expand",name:"Expand",pkg:"",typ:$funcType([BX,BX,BX,BV],[BX],false)},{prop:"ExpandString",name:"ExpandString",pkg:"",typ:$funcType([BX,$String,$String,BV],[BX],false)},{prop:"expand",name:"expand",pkg:"regexp",typ:$funcType([BX,$String,BX,$String,BV],[BX],false)},{prop:"FindSubmatchIndex",name:"FindSubmatchIndex",pkg:"",typ:$funcType([BX],[BV],false)},{prop:"FindStringSubmatch",name:"FindStringSubmatch",pkg:"",typ:$funcType([$String],[CN],false)},{prop:"FindStringSubmatchIndex",name:"FindStringSubmatchIndex",pkg:"",typ:$funcType([$String],[BV],false)},{prop:"FindReaderSubmatchIndex",name:"FindReaderSubmatchIndex",pkg:"",typ:$funcType([C.RuneReader],[BV],false)},{prop:"FindAll",name:"FindAll",pkg:"",typ:$funcType([BX,$Int],[CT],false)},{prop:"FindAllIndex",name:"FindAllIndex",pkg:"",typ:$funcType([BX,$Int],[CU],false)},{prop:"FindAllString",name:"FindAllString",pkg:"",typ:$funcType([$String,$Int],[CN],false)},{prop:"FindAllStringIndex",name:"FindAllStringIndex",pkg:"",typ:$funcType([$String,$Int],[CU],false)},{prop:"FindAllSubmatch",name:"FindAllSubmatch",pkg:"",typ:$funcType([BX,$Int],[CV],false)},{prop:"FindAllSubmatchIndex",name:"FindAllSubmatchIndex",pkg:"",typ:$funcType([BX,$Int],[CU],false)},{prop:"FindAllStringSubmatch",name:"FindAllStringSubmatch",pkg:"",typ:$funcType([$String,$Int],[CW],false)},{prop:"FindAllStringSubmatchIndex",name:"FindAllStringSubmatchIndex",pkg:"",typ:$funcType([$String,$Int],[CU],false)},{prop:"Split",name:"Split",pkg:"",typ:$funcType([$String,$Int],[CN],false)}];DD.methods=[{prop:"step",name:"step",pkg:"regexp",typ:$funcType([$Int],[$Int32,$Int],false)},{prop:"canCheckPrefix",name:"canCheckPrefix",pkg:"regexp",typ:$funcType([],[$Bool],false)},{prop:"hasPrefix",name:"hasPrefix",pkg:"regexp",typ:$funcType([CL],[$Bool],false)},{prop:"index",name:"index",pkg:"regexp",typ:$funcType([CL,$Int],[$Int],false)},{prop:"context",name:"context",pkg:"regexp",typ:$funcType([$Int],[V],false)}];DE.methods=[{prop:"step",name:"step",pkg:"regexp",typ:$funcType([$Int],[$Int32,$Int],false)},{prop:"canCheckPrefix",name:"canCheckPrefix",pkg:"regexp",typ:$funcType([],[$Bool],false)},{prop:"hasPrefix",name:"hasPrefix",pkg:"regexp",typ:$funcType([CL],[$Bool],false)},{prop:"index",name:"index",pkg:"regexp",typ:$funcType([CL,$Int],[$Int],false)},{prop:"context",name:"context",pkg:"regexp",typ:$funcType([$Int],[V],false)}];DF.methods=[{prop:"step",name:"step",pkg:"regexp",typ:$funcType([$Int],[$Int32,$Int],false)},{prop:"canCheckPrefix",name:"canCheckPrefix",pkg:"regexp",typ:$funcType([],[$Bool],false)},{prop:"hasPrefix",name:"hasPrefix",pkg:"regexp",typ:$funcType([CL],[$Bool],false)},{prop:"index",name:"index",pkg:"regexp",typ:$funcType([CL,$Int],[$Int],false)},{prop:"context",name:"context",pkg:"regexp",typ:$funcType([$Int],[V],false)}];J.init("regexp",[{prop:"pc",name:"pc",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"arg",name:"arg",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"pos",name:"pos",embedded:false,exported:false,typ:$Int,tag:""}]);K.init("regexp",[{prop:"end",name:"end",embedded:false,exported:false,typ:$Int,tag:""},{prop:"cap",name:"cap",embedded:false,exported:false,typ:BV,tag:""},{prop:"matchcap",name:"matchcap",embedded:false,exported:false,typ:BV,tag:""},{prop:"jobs",name:"jobs",embedded:false,exported:false,typ:BW,tag:""},{prop:"visited",name:"visited",embedded:false,exported:false,typ:BT,tag:""},{prop:"inputs",name:"inputs",embedded:false,exported:false,typ:U,tag:""}]);Q.init("regexp",[{prop:"sparse",name:"sparse",embedded:false,exported:false,typ:BT,tag:""},{prop:"dense",name:"dense",embedded:false,exported:false,typ:CP,tag:""}]);R.init("regexp",[{prop:"pc",name:"pc",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"t",name:"t",embedded:false,exported:false,typ:BY,tag:""}]);S.init("regexp",[{prop:"inst",name:"inst",embedded:false,exported:false,typ:BZ,tag:""},{prop:"cap",name:"cap",embedded:false,exported:false,typ:BV,tag:""}]);T.init("regexp",[{prop:"re",name:"re",embedded:false,exported:false,typ:CL,tag:""},{prop:"p",name:"p",embedded:false,exported:false,typ:CM,tag:""},{prop:"q0",name:"q0",embedded:false,exported:false,typ:Q,tag:""},{prop:"q1",name:"q1",embedded:false,exported:false,typ:Q,tag:""},{prop:"pool",name:"pool",embedded:false,exported:false,typ:CQ,tag:""},{prop:"matched",name:"matched",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"matchcap",name:"matchcap",embedded:false,exported:false,typ:BV,tag:""},{prop:"inputs",name:"inputs",embedded:false,exported:false,typ:U,tag:""}]);U.init("regexp",[{prop:"bytes",name:"bytes",embedded:false,exported:false,typ:BE,tag:""},{prop:"string",name:"string",embedded:false,exported:false,typ:BD,tag:""},{prop:"reader",name:"reader",embedded:false,exported:false,typ:BF,tag:""}]);X.init("regexp",[{prop:"inputs",name:"inputs",embedded:false,exported:false,typ:U,tag:""},{prop:"matchcap",name:"matchcap",embedded:false,exported:false,typ:BV,tag:""}]);AC.init("",[{prop:"Inst",name:"Inst",embedded:false,exported:true,typ:CG,tag:""},{prop:"Start",name:"Start",embedded:false,exported:true,typ:$Int,tag:""},{prop:"NumCap",name:"NumCap",embedded:false,exported:true,typ:$Int,tag:""}]);AD.init("",[{prop:"Inst",name:"Inst",embedded:true,exported:true,typ:A.Inst,tag:""},{prop:"Next",name:"Next",embedded:false,exported:true,typ:BT,tag:""}]);AH.init("regexp",[{prop:"sparse",name:"sparse",embedded:false,exported:false,typ:BT,tag:""},{prop:"dense",name:"dense",embedded:false,exported:false,typ:BT,tag:""},{prop:"size",name:"size",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"nextIndex",name:"nextIndex",embedded:false,exported:false,typ:$Uint32,tag:""}]);AO.init($Int32);AT.init("regexp",[{prop:"expr",name:"expr",embedded:false,exported:false,typ:$String,tag:""},{prop:"prog",name:"prog",embedded:false,exported:false,typ:CM,tag:""},{prop:"onepass",name:"onepass",embedded:false,exported:false,typ:CD,tag:""},{prop:"numSubexp",name:"numSubexp",embedded:false,exported:false,typ:$Int,tag:""},{prop:"maxBitStateLen",name:"maxBitStateLen",embedded:false,exported:false,typ:$Int,tag:""},{prop:"subexpNames",name:"subexpNames",embedded:false,exported:false,typ:CN,tag:""},{prop:"prefix",name:"prefix",embedded:false,exported:false,typ:$String,tag:""},{prop:"prefixBytes",name:"prefixBytes",embedded:false,exported:false,typ:BX,tag:""},{prop:"prefixRune",name:"prefixRune",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"prefixEnd",name:"prefixEnd",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"mpool",name:"mpool",embedded:false,exported:false,typ:$Int,tag:""},{prop:"matchcap",name:"matchcap",embedded:false,exported:false,typ:$Int,tag:""},{prop:"prefixComplete",name:"prefixComplete",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"cond",name:"cond",embedded:false,exported:false,typ:A.EmptyOp,tag:""},{prop:"longest",name:"longest",embedded:false,exported:false,typ:$Bool,tag:""}]);BC.init([{prop:"canCheckPrefix",name:"canCheckPrefix",pkg:"regexp",typ:$funcType([],[$Bool],false)},{prop:"context",name:"context",pkg:"regexp",typ:$funcType([$Int],[V],false)},{prop:"hasPrefix",name:"hasPrefix",pkg:"regexp",typ:$funcType([CL],[$Bool],false)},{prop:"index",name:"index",pkg:"regexp",typ:$funcType([CL,$Int],[$Int],false)},{prop:"step",name:"step",pkg:"regexp",typ:$funcType([$Int],[$Int32,$Int],false)}]);BD.init("regexp",[{prop:"str",name:"str",embedded:false,exported:false,typ:$String,tag:""}]);BE.init("regexp",[{prop:"str",name:"str",embedded:false,exported:false,typ:BX,tag:""}]);BF.init("regexp",[{prop:"r",name:"r",embedded:false,exported:false,typ:C.RuneReader,tag:""},{prop:"atEOT",name:"atEOT",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"pos",name:"pos",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=G.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}L=new B.Pool.ptr(BO.nil,$throwNilPointerError);Y=new B.Pool.ptr(BO.nil,$throwNilPointerError);AB=BP.zero();AY=BQ.zero();BJ=BR.zero();AJ=new BS([]);AK=new BT([4294967295]);AP=new BS([0,9,11,1114111]);AQ=new BS([0,1114111]);AX=$toNativeArray($kindInt,[128,512,2048,16384,0]);BL();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["github.com/bonedaddy/vcaptcha/vdf"]=(function(){var $pkg={},$init,B,C,D,G,E,F,A,H,I,J,K,L,T,AW,AY,AZ,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,R,S,U,Y,M,N,O,P,Q,V,W,X,Z,AA,AB,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR,AS,AT,AU,AV,AX;B=$packages["bytes"];C=$packages["crypto/sha256"];D=$packages["encoding/binary"];G=$packages["fmt"];E=$packages["log"];F=$packages["math"];A=$packages["math/big"];H=$packages["regexp"];I=$packages["runtime"];J=$packages["sort"];K=$packages["time"];L=$pkg.ClassGroup=$newType(0,$kindStruct,"vdf.ClassGroup",true,"github.com/bonedaddy/vcaptcha/vdf",true,function(a_,b_,c_,d_){this.$val=this;if(arguments.length===0){this.a=BA.nil;this.b=BA.nil;this.c=BA.nil;this.d=BA.nil;return;}this.a=a_;this.b=b_;this.c=c_;this.d=d_;});T=$pkg.Pair=$newType(0,$kindStruct,"vdf.Pair",true,"github.com/bonedaddy/vcaptcha/vdf",true,function(p_,q_){this.$val=this;if(arguments.length===0){this.p=new $Int64(0,0);this.q=new $Int64(0,0);return;}this.p=p_;this.q=q_;});AW=$pkg.VDF=$newType(0,$kindStruct,"vdf.VDF",true,"github.com/bonedaddy/vcaptcha/vdf",true,function(difficulty_,input_,output_,outputChan_,finished_){this.$val=this;if(arguments.length===0){this.difficulty=0;this.input=BD.zero();this.output=BH.zero();this.outputChan=$chanNil;this.finished=false;return;}this.difficulty=difficulty_;this.input=input_;this.output=output_;this.outputChan=outputChan_;this.finished=finished_;});AY=$sliceType($Int);AZ=$sliceType(T);BA=$ptrType(A.Int);BB=$ptrType(L);BC=$sliceType($Uint8);BD=$arrayType($Uint8,32);BE=$sliceType($Bool);BF=$sliceType($emptyInterface);BG=$sliceType(BB);BH=$arrayType($Uint8,516);BI=$chanType(BH,false,false);BJ=$ptrType(AW);M=function(a){var a;return new L.ptr(a.a,a.b,a.c,BA.nil);};$pkg.CloneClassGroup=M;N=function(a,b,c){var a,b,c;return new L.ptr(a,b,c,BA.nil);};$pkg.NewClassGroup=N;O=function(a,b,c){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=new A.Int.ptr(false,A.nat.nil).Sub(new A.Int.ptr(false,A.nat.nil).Mul(b,b),c);e=X(d,new A.Int.ptr(false,A.nat.nil).Mul(a,A.NewInt(new $Int64(0,4))));$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;$s=-1;return N(a,b,f);}return;}if($f===undefined){$f={$blk:O};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewClassGroupFromAbDiscriminant=O;P=function(a,b){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=b.BitLen();d=((c+16>>0))>>4>>0;if(!((a.$length===($imul(d,2))))){$s=-1;return[BB.nil,false];}e=Z($subslice(a,0,d));f=Z($subslice(a,d));g=O(e,f,b);$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return[g,true];}return;}if($f===undefined){$f={$blk:P};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewClassGroupFromBytesDiscriminant=P;Q=function(a){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=O(A.NewInt(new $Int64(0,1)),A.NewInt(new $Int64(0,1)),a);$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;}return;}if($f===undefined){$f={$blk:Q};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};$pkg.IdentityForDiscriminant=Q;L.ptr.prototype.Normalized=function(){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=new A.Int.ptr(false,A.nat.nil).Set(a.a);c=new A.Int.ptr(false,A.nat.nil).Set(a.b);d=new A.Int.ptr(false,A.nat.nil).Set(a.c);if(((c.Cmp(new A.Int.ptr(false,A.nat.nil).Neg(b))===1))&&(c.Cmp(b)<1)){$s=-1;return a;}e=new A.Int.ptr(false,A.nat.nil).Sub(b,c);f=X(e,new A.Int.ptr(false,A.nat.nil).Mul(b,A.NewInt(new $Int64(0,2))));$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=new A.Int.ptr(false,A.nat.nil).Mul(A.NewInt(new $Int64(0,2)),e);g.Mul(g,b);h=new A.Int.ptr(false,A.nat.nil).Set(c);c.Add(c,g);i=new A.Int.ptr(false,A.nat.nil).Mul(b,e);i.Mul(i,e);j=new A.Int.ptr(false,A.nat.nil).Mul(h,e);d.Add(d,i);d.Add(d,j);$s=-1;return N(b,c,d);}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Normalized};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Normalized=function(){return this.$val.Normalized();};L.ptr.prototype.Reduced=function(){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Normalized();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;d=new A.Int.ptr(false,A.nat.nil).Set(c.a);e=new A.Int.ptr(false,A.nat.nil).Set(c.b);f=new A.Int.ptr(false,A.nat.nil).Set(c.c);case 2:if(!(((d.Cmp(f)===1))||(((d.Cmp(f)===0))&&((e.Sign()===-1))))){$s=3;continue;}g=new A.Int.ptr(false,A.nat.nil).Add(f,e);h=X(g,new A.Int.ptr(false,A.nat.nil).Add(f,f));$s=4;case 4:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;i=new A.Int.ptr(false,A.nat.nil).Set(d);j=new A.Int.ptr(false,A.nat.nil).Set(e);d=new A.Int.ptr(false,A.nat.nil).Set(f);e.Neg(e);k=new A.Int.ptr(false,A.nat.nil).Mul(A.NewInt(new $Int64(0,2)),g);k.Mul(k,f);e.Add(e,k);f.Mul(f,g);f.Mul(f,g);j.Mul(j,g);f.Sub(f,j);f.Add(f,i);$s=2;continue;case 3:l=N(d,e,f).Normalized();$s=5;case 5:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$s=-1;return l;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Reduced};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Reduced=function(){return this.$val.Reduced();};L.ptr.prototype.identity=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=O(A.NewInt(new $Int64(0,1)),A.NewInt(new $Int64(0,1)),a.Discriminant());$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.identity};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.identity=function(){return this.$val.identity();};L.ptr.prototype.Discriminant=function(){var a,b,c;a=this;if(a.d===BA.nil){b=new A.Int.ptr(false,A.nat.nil).Set(a.b);b.Mul(b,b);c=new A.Int.ptr(false,A.nat.nil).Set(a.a);c.Mul(c,a.c);c.Mul(c,A.NewInt(new $Int64(0,4)));b.Sub(b,c);a.d=b;}return a.d;};L.prototype.Discriminant=function(){return this.$val.Discriminant();};L.ptr.prototype.Multiply=function(a){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;ar=$f.ar;as=$f.as;at=$f.at;au=$f.au;av=$f.av;aw=$f.aw;ax=$f.ax;ay=$f.ay;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.Reduced();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=a.Reduced();$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=new A.Int.ptr(false,A.nat.nil).Add(d.b,f.b);h=X(g,A.NewInt(new $Int64(0,2)));$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;i=new A.Int.ptr(false,A.nat.nil).Sub(f.b,d.b);j=X(i,A.NewInt(new $Int64(0,2)));$s=4;case 4:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=AE(f.a,g);$s=5;case 5:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=k;m=AE(d.a,l);$s=6;case 6:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;o=new A.Int.ptr(false,A.nat.nil).Set(n);p=A.NewInt(new $Int64(0,0));q=X(d.a,n);$s=7;case 7:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=q;s=X(f.a,n);$s=8;case 8:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=s;u=X(g,n);$s=9;case 9:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}v=u;w=new A.Int.ptr(false,A.nat.nil).Mul(i,v);x=new A.Int.ptr(false,A.nat.nil).Mul(r,d.c);w.Add(w,x);z=AF(new A.Int.ptr(false,A.nat.nil).Mul(t,v),w,new A.Int.ptr(false,A.nat.nil).Mul(r,t));$s=10;case 10:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}y=z;aa=y[0];ab=y[1];ac=y[2];if(!ac){$s=-1;return BB.nil;}ae=AF(new A.Int.ptr(false,A.nat.nil).Mul(t,ab),new A.Int.ptr(false,A.nat.nil).Sub(i,new A.Int.ptr(false,A.nat.nil).Mul(t,aa)),r);$s=11;case 11:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ad=ae;af=ad[0];ac=ad[2];if(!ac){$s=-1;return BB.nil;}ag=new A.Int.ptr(false,A.nat.nil).Add(aa,new A.Int.ptr(false,A.nat.nil).Mul(ab,af));ah=X(new A.Int.ptr(false,A.nat.nil).Sub(new A.Int.ptr(false,A.nat.nil).Mul(t,ag),i),r);$s=12;case 12:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ai=ah;aj=new A.Int.ptr(false,A.nat.nil).Mul(t,v);aj.Mul(aj,ag);ak=new A.Int.ptr(false,A.nat.nil).Mul(i,v);aj.Sub(aj,ak);aj.Sub(aj,x);al=new A.Int.ptr(false,A.nat.nil).Mul(r,t);am=X(aj,al);$s=13;case 13:if($c){$c=false;am=am.$blk();}if(am&&am.$blk!==undefined){break s;}an=am;ao=new A.Int.ptr(false,A.nat.nil).Mul(p,v);ap=al.Sub(al,ao);aq=new A.Int.ptr(false,A.nat.nil).Mul(o,v);ar=new A.Int.ptr(false,A.nat.nil).Mul(an,p);aq=aq.Add(aq,ar);as=new A.Int.ptr(false,A.nat.nil).Mul(ag,t);at=new A.Int.ptr(false,A.nat.nil).Mul(ai,r);as=as.Add(as,at);au=aq.Sub(aq,as);av=new A.Int.ptr(false,A.nat.nil).Mul(ag,ai);aw=new A.Int.ptr(false,A.nat.nil).Mul(o,an);ax=av.Sub(av,aw);ay=N(ap,au,ax).Reduced();$s=14;case 14:if($c){$c=false;ay=ay.$blk();}if(ay&&ay.$blk!==undefined){break s;}$s=-1;return ay;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Multiply};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.ar=ar;$f.as=as;$f.at=at;$f.au=au;$f.av=av;$f.aw=aw;$f.ax=ax;$f.ay=ay;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Multiply=function(a){return this.$val.Multiply(a);};L.ptr.prototype.Pow=function(a){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=M(b);d=b.identity();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;case 2:if(!((a.$high>0||(a.$high===0&&a.$low>0)))){$s=3;continue;}if((f=new $Int64(a.$high&0,(a.$low&1)>>>0),(f.$high===0&&f.$low===1))){$s=4;continue;}$s=5;continue;case 4:g=e.Multiply(c);$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}e=g;if(e===BB.nil){$s=-1;return BB.nil;}case 5:h=c.Square();$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}c=h;if(c===BB.nil){$s=-1;return BB.nil;}a=$shiftRightInt64(a,(1));$s=2;continue;case 3:$s=-1;return e;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Pow};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Pow=function(a){return this.$val.Pow(a);};L.ptr.prototype.BigPow=function(a){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=M(b);d=b.identity();$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=d;f=new A.Int.ptr(false,A.nat.nil).Set(a);case 2:if(!(f.Sign()>0)){$s=3;continue;}if(f.Bit(0)===1){$s=4;continue;}$s=5;continue;case 4:g=e.Multiply(c);$s=6;case 6:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}e=g;if(e===BB.nil){$s=-1;return BB.nil;}case 5:h=c.Square();$s=7;case 7:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}c=h;if(c===BB.nil){$s=-1;return BB.nil;}f.Rsh(f,1);$s=2;continue;case 3:$s=-1;return e;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.BigPow};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.BigPow=function(a){return this.$val.BigPow(a);};L.ptr.prototype.Square=function(){var a,b,c,d,e,f,g,h,i,j,k,l,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;c=AF(a.b,a.c,a.a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[2];if(!e){$s=-1;return BB.nil;}f=new A.Int.ptr(false,A.nat.nil).Mul(a.a,a.a);g=new A.Int.ptr(false,A.nat.nil).Mul(a.a,d);h=new A.Int.ptr(false,A.nat.nil).Sub(a.b,new A.Int.ptr(false,A.nat.nil).Mul(g,A.NewInt(new $Int64(0,2))));i=new A.Int.ptr(false,A.nat.nil).Mul(d,d);j=new A.Int.ptr(false,A.nat.nil).Mul(a.b,d);j=new A.Int.ptr(false,A.nat.nil).Sub(j,a.c);k=X(j,a.a);$s=2;case 2:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;i=new A.Int.ptr(false,A.nat.nil).Sub(i,j);l=N(f,h,i).Reduced();$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}$s=-1;return l;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Square};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Square=function(){return this.$val.Square();};L.ptr.prototype.SquareUsingMultiply=function(){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Reduced();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;d=c.b;e=A.NewInt(new $Int64(0,0));f=AE(c.a,d);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;h=new A.Int.ptr(false,A.nat.nil).Set(g);i=A.NewInt(new $Int64(0,0));j=X(c.a,g);$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;l=k;m=X(d,g);$s=4;case 4:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;o=new A.Int.ptr(false,A.nat.nil).Mul(e,n);p=new A.Int.ptr(false,A.nat.nil).Mul(k,c.c);o.Add(o,p);r=AF(new A.Int.ptr(false,A.nat.nil).Mul(l,n),o,new A.Int.ptr(false,A.nat.nil).Mul(k,l));$s=5;case 5:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;s=q[0];t=q[1];u=q[2];if(!u){$s=-1;return BB.nil;}w=AF(new A.Int.ptr(false,A.nat.nil).Mul(l,t),new A.Int.ptr(false,A.nat.nil).Sub(e,new A.Int.ptr(false,A.nat.nil).Mul(l,s)),k);$s=6;case 6:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}v=w;x=v[0];u=v[2];if(!u){$s=-1;return BB.nil;}y=new A.Int.ptr(false,A.nat.nil).Add(s,new A.Int.ptr(false,A.nat.nil).Mul(t,x));z=X(new A.Int.ptr(false,A.nat.nil).Sub(new A.Int.ptr(false,A.nat.nil).Mul(l,y),e),k);$s=7;case 7:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}aa=z;ab=new A.Int.ptr(false,A.nat.nil).Mul(l,n);ab.Mul(ab,y);ac=new A.Int.ptr(false,A.nat.nil).Mul(e,n);ab.Sub(ab,ac);ab.Sub(ab,p);ad=new A.Int.ptr(false,A.nat.nil).Mul(k,l);ae=X(ab,ad);$s=8;case 8:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}af=ae;ag=new A.Int.ptr(false,A.nat.nil).Mul(i,n);ah=ad.Sub(ad,ag);ai=new A.Int.ptr(false,A.nat.nil).Mul(h,n);aj=new A.Int.ptr(false,A.nat.nil).Mul(af,i);ai=ai.Add(ai,aj);ak=new A.Int.ptr(false,A.nat.nil).Mul(y,l);al=new A.Int.ptr(false,A.nat.nil).Mul(aa,k);ak=ak.Add(ak,al);am=ai.Sub(ai,ak);an=new A.Int.ptr(false,A.nat.nil).Mul(y,aa);ao=new A.Int.ptr(false,A.nat.nil).Mul(h,af);ap=an.Sub(an,ao);aq=N(ah,am,ap).Reduced();$s=9;case 9:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}$s=-1;return aq;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.SquareUsingMultiply};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.SquareUsingMultiply=function(){return this.$val.SquareUsingMultiply();};L.ptr.prototype.Serialize=function(){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=a.Reduced();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}c=b;d=a.Discriminant().BitLen();e=((d+16>>0))>>4>>0;f=$makeSlice(BC,($imul(e,2)));$copySlice($subslice(f,0,e),AB(AA(c.a),e));$copySlice($subslice(f,e),AB(AA(c.b),e));$s=-1;return f;}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Serialize};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Serialize=function(){return this.$val.Serialize();};L.ptr.prototype.Equal=function(a){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=b.Reduced();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=c;e=a.Reduced();$s=2;case 2:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;$s=-1;return(d.a.Cmp(f.a)===0)&&(d.b.Cmp(f.b)===0)&&(d.c.Cmp(f.c)===0);}return;}if($f===undefined){$f={$blk:L.ptr.prototype.Equal};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};L.prototype.Equal=function(a){return this.$val.Equal(a);};V=function(a,b){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=new B.Buffer.ptr(BC.nil,0,0);d=0;e=0;f=$makeSlice(BC,(a.$length+2>>0));$copySlice(f,a);case 1:if(!(d<=b)){$s=2;continue;}$clone(D.BigEndian,D.bigEndian).PutUint16($subslice(f,a.$length),e);g=C.Sum256(f);$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=$clone(g,BD);c.Write(new BC(h));d=d+(32)>>0;e=e+(1)<<16>>>16;$s=1;continue;case 2:$s=-1;return $subslice(c.Bytes(),0,b);}return;}if($f===undefined){$f={$blk:V};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};$pkg.EntropyFromSeed=V;W=function(a,b){var a,aa,ab,ac,ad,ae,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=(((b<<24>>>24))&7)>>>0;d=((((b+7>>0))>>3>>0))+2>>0;e=V(a,d);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=new A.Int.ptr(false,A.nat.nil);g.SetBytes($subslice(f,0,(f.$length-2>>0)));g=new A.Int.ptr(false,A.nat.nil).Rsh(g,(((((((8-c<<24>>>24))&7)>>>0))>>>0)));g=new A.Int.ptr(false,A.nat.nil).SetBit(g,b-1>>0,1);h=g;i=new A.Int.ptr(false,A.nat.nil).Mod(g,A.NewInt((new $Int64(0,U))));$s=2;case 2:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;k=new A.Int.ptr(false,A.nat.nil).Sub(h,j);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}g=k;g=new A.Int.ptr(false,A.nat.nil).Add(g,A.NewInt((new $Int64(0,(l=(m=(($clone(D.BigEndian,D.bigEndian).Uint16($subslice(f,(f.$length-2>>0),f.$length))>>0))%R.$length,m===m?m:$throwRuntimeError("integer divide by zero")),((l<0||l>=R.$length)?($throwRuntimeError("index out of range"),undefined):R.$array[R.$offset+l]))))));n=new A.Int.ptr(false,A.nat.nil).Neg(g);case 4:o=$makeSlice(BE,65536);p=S;q=0;case 6:if(!(q=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+q]),T);s=new A.Int.ptr(false,A.nat.nil).Mod(n,A.NewInt(r.p));$s=8;case 8:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=s.Int64();$s=9;case 9:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=$div64(($mul64(t,r.q)),r.p,true);while(true){if(!((v=(new $Int64(0,o.$length)),(u.$high=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(u)]=true);u=(w=r.p,new $Int64(u.$high+w.$high,u.$low+w.$low));}q++;$s=6;continue;case 7:x=o;y=0;case 10:if(!(y=x.$length)?($throwRuntimeError("index out of range"),undefined):x.$array[x.$offset+y]);ab=new A.Int.ptr(false,A.nat.nil).Add(g,A.NewInt($mul64((new $Int64(0,U)),(new $Int64(0,z)))));if(!(!aa)){ac=false;$s=14;continue s;}ad=ab.ProbablyPrime(1);$s=15;case 15:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}ac=ad;case 14:if(ac){$s=12;continue;}$s=13;continue;case 12:$s=-1;return new A.Int.ptr(false,A.nat.nil).Neg(ab);case 13:y++;$s=10;continue;case 11:ae=A.NewInt((new $Int64(0,U)));g=new A.Int.ptr(false,A.nat.nil).Add(g,ae.Mul(ae,A.NewInt(new $Int64(0,65536))));$s=4;continue;case 5:$s=-1;return BA.nil;}return;}if($f===undefined){$f={$blk:W};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};$pkg.CreateDiscriminant=W;X=function(a,b){var a,b,c,d,e,f,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=[c];c[0]=new A.Int.ptr(false,A.nat.nil);e=new A.Int.ptr(false,A.nat.nil).QuoRem(a,b,c[0]);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}d=e;f=d[0];if(((c[0].Sign()===1)&&(b.Sign()===-1))||((c[0].Sign()===-1)&&(b.Sign()===1))){f.Sub(f,A.NewInt(new $Int64(0,1)));}$s=-1;return f;}return;}if($f===undefined){$f={$blk:X};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.$s=$s;$f.$r=$r;return $f;};Z=function(a){var a,b,c,d,e,f;if((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])&128)>>>0)===0){return new A.Int.ptr(false,A.nat.nil).SetBytes(a);}b=$makeSlice(BC,a.$length);c=a;d=0;while(true){if(!(d=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+e]=((((e<0||e>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+e])^255)<<24>>>24));d++;}f=new A.Int.ptr(false,A.nat.nil).SetBytes(b);return f.Sub(f.Neg(f),Y);};AA=function(a){var a,b,c,d,e,f,g,h,i;if(a.Sign()>0){b=a.Bytes();if((((0>=b.$length?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+0])&128)>>>0)===0){return b;}c=$makeSlice(BC,(b.$length+1>>0));$copySlice($subslice(c,1),b);return c;}if(a.Sign()<0){d=new A.Int.ptr(false,A.nat.nil).Neg(a);d.Sub(d,Y);e=d.Bytes();if(e.$length===0){return new BC([255]);}f=e;g=0;while(true){if(!(g=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h]=((((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])^(255))<<24>>>24));g++;}if(!(((((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])&128)>>>0)===0))){return e;}i=$makeSlice(BC,(e.$length+1>>0));(0>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+0]=255);$copySlice($subslice(i,1),e);return i;}return new BC([]);};AB=function(a,b){var a,b,c,d,e;if(a.$length>=b){return a;}c=$makeSlice(BC,b);d=b-a.$length>>0;if(!(((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])&128)>>>0)===0))){e=0;while(true){if(!(e=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e]=255);e=e+(1)>>0;}}$copySlice($subslice(c,d),a);return c;};AD=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=BA.nil;d=BA.nil;e=BA.nil;f=new A.Int.ptr(false,A.nat.nil).Set(a);g=new A.Int.ptr(false,A.nat.nil).Set(b);h=A.NewInt(new $Int64(0,1));i=A.NewInt(new $Int64(0,0));j=A.NewInt(new $Int64(0,0));k=A.NewInt(new $Int64(0,1));if(f.Cmp(g)===1){l=new A.Int.ptr(false,A.nat.nil).Set(f);f=g;g=l;m=new A.Int.ptr(false,A.nat.nil).Set(h);h=j;n=new A.Int.ptr(false,A.nat.nil).Set(i);i=k;j=m;k=n;}case 1:if(!(g.Sign()===1)){$s=2;continue;}o=A.NewInt(new $Int64(0,1));p=new A.Int.ptr(false,A.nat.nil).Set(b);r=p.DivMod(f,g,o);$s=3;case 3:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;s=q[0];o=q[1];f=g;g=o;t=new A.Int.ptr(false,A.nat.nil).Set(h);h=i;i=new A.Int.ptr(false,A.nat.nil).Sub(t,new A.Int.ptr(false,A.nat.nil).Mul(s,i));u=new A.Int.ptr(false,A.nat.nil).Set(j);j=k;k=new A.Int.ptr(false,A.nat.nil).Sub(u,new A.Int.ptr(false,A.nat.nil).Mul(s,k));$s=1;continue;case 2:v=f;w=h;x=j;c=v;d=w;e=x;$s=-1;return[c,d,e];}return;}if($f===undefined){$f={$blk:AD};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};AE=function(a,b){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=BA.nil;if(a.Sign()===0){c=new A.Int.ptr(false,A.nat.nil).Abs(b);$s=-1;return c;}if(b.Sign()===0){c=new A.Int.ptr(false,A.nat.nil).Abs(a);$s=-1;return c;}d=new A.Int.ptr(false,A.nat.nil).GCD(BA.nil,BA.nil,new A.Int.ptr(false,A.nat.nil).Abs(a),new A.Int.ptr(false,A.nat.nil).Abs(b));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;$s=-1;return c;}return;}if($f===undefined){$f={$blk:AE};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};AF=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=BA.nil;e=BA.nil;f=false;h=AD(a,c);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;i=g[0];j=g[1];k=A.NewInt(new $Int64(0,1));l=new A.Int.ptr(false,A.nat.nil).Set(b);n=l.DivMod(b,i,k);$s=2;case 2:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];k=m[1];if(!((k.Cmp(A.NewInt(new $Int64(0,0)))===0))){p=BA.nil;q=BA.nil;r=false;d=p;e=q;f=r;$s=-1;return[d,e,f];}o.Mul(o,j);s=o.Mod(o,c);$s=3;case 3:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}d=s;t=X(c,i);$s=4;case 4:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}e=t;u=d;v=e;w=true;d=u;e=v;f=w;$s=-1;return[d,e,f];}return;}if($f===undefined){$f={$blk:AF};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.$s=$s;$f.$r=$r;return $f;};$pkg.SolveMod=AF;AG=function(a){var a,b,c,d,e,f;b=$makeSlice(BE,(a+1>>0));c=3;while(true){if(!(c<=((F.Floor(F.Sqrt((a)))>>0)))){break;}if(((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c])===false){d=$imul(c,2);while(true){if(!(d<=a)){break;}((d<0||d>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+d]=true);d=d+(c)>>0;}}c=c+(2)>>0;}e=$makeSlice(AY,0,a);f=3;while(true){if(!(f<=a)){break;}if(((f<0||f>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f])===false){e=$append(e,f);}f=f+(2)>>0;}return e;};AH=function(a,b){var a,b,c,d,e,f;if(!((a.$length===b.$length))){return false;}c=a;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);if(!((f===((e<0||e>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+e])))){return false;}d++;}return true;};AI=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=$makeSlice(AY,0,a);c=3;case 1:if(!(c>0;$s=1;continue;case 2:e=AG(a);$r=E.Printf("%v ",new BF([e]));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(AH(b,e)){$s=7;continue;}$s=8;continue;case 7:$r=E.Printf("OK",new BF([]));$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=9;continue;case 8:$r=E.Printf("ERROR",new BF([]));$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 9:$s=-1;return;}return;}if($f===undefined){$f={$blk:AI};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AJ=function(){var $s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=AI(65536);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AJ};}$f.$s=$s;$f.$r=$r;return $f;};AK=function(a){var a,b,c,d,e,f,g;b=F.Log(1e+07)/F.Log(2);c=F.Log((a))/F.Log(2);d=1;if(c-b>0){d=((F.Ceil(F.Pow(2,b-20))>>0));}e=(a)*F.Log(2)/(($imul(2,d)));f=((F.Max(F.Round(F.Log(e)-F.Log(F.Log(e))+0.25),1)>>0));g=((F.Floor((a)/((a)/(f)+(d)*F.Pow(2,((f+1>>0)))))-2>>0));return[d,f,g];};AL=function(a,b,c){var a,b,c,d,e,f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d={};e=0;f=M(a);$r=J.Ints(b);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}g=b;h=0;case 2:if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);j=0;case 4:if(!(j<(i-e>>0))){$s=5;continue;}k=f.Pow(new $Int64(0,2));$s=6;case 6:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}f=k;if(f===BB.nil){$s=-1;return false;}j=j+(1)>>0;$s=4;continue;case 5:e=i;l=i;(d||$throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(l)]={k:l,v:f};m=$select([[c],[]]);if(m[0]===0){$s=-1;return false;}else if(m[0]===1){}h++;$s=2;continue;case 3:$s=-1;return d;}return;}if($f===undefined){$f={$blk:AL};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AM=function(a,b,c){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:d=AN(a,b,c,$chanNil);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:AM};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.GenerateVDF=AM;AN=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);$deferred.push([AV,[$clone(K.Now(),K.Time)]]);e=W(a,c);$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=O(A.NewInt(new $Int64(0,2)),A.NewInt(new $Int64(0,1)),f);$s=2;case 2:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;j=AT(f,h,b,c,d);$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[0];l=i[1];if((k===BB.nil)||(l===BB.nil)){$s=4;continue;}$s=5;continue;case 4:$s=-1;return[BC.nil,BC.nil];case 5:m=k.Serialize();$s=7;case 7:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=l.Serialize();$s=8;case 8:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}$s=-1;return[m,n];case 6:$s=-1;return[BC.nil,BC.nil];}return;}}catch(err){$err=err;$s=-1;return[BC.nil,BC.nil];}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:AN};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};$pkg.GenerateVDFWithStopChan=AN;AO=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$deferred,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;$s=$f.$s;$deferred=$f.$deferred;$r=$f.$r;}var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$deferred.index=$curGoroutine.deferStack.length;$curGoroutine.deferStack.push($deferred);$deferred.push([AV,[$clone(K.Now(),K.Time)]]);e=((d+16>>0))>>4>>0;f=W(a,d);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;h=O(A.NewInt(new $Int64(0,2)),A.NewInt(new $Int64(0,1)),g);$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;k=P($subslice(b,0,(($imul(2,e)))),g);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[0];n=P($subslice(b,($imul(2,e))),g);$s=4;case 4:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];p=AU(i,l,o,c);$s=5;case 5:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}$s=-1;return p;}return;}}catch(err){$err=err;$s=-1;return false;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){if($f===undefined){$f={$blk:AO};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.$s=$s;$f.$deferred=$deferred;$f.$r=$r;return $f;}}};$pkg.VerifyVDF=AO;AP=function(a,b){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=new $Uint64(0,0);d=$makeSlice(BC,8);e=new A.Int.ptr(false,A.nat.nil);case 1:$clone(D.BigEndian,D.bigEndian).PutUint64(d,c);f=$appendSlice((new BC($stringToBytes("prime"))),d);f=$appendSlice(f,a);f=$appendSlice(f,b);g=C.Sum256(f);$s=3;case 3:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=$clone(g,BD);e.SetBytes($subslice(new BC(h),0,16));i=e.ProbablyPrime(1);$s=6;case 6:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}if(i){$s=4;continue;}$s=5;continue;case 4:$s=-1;return e;case 5:c=(j=new $Uint64(0,1),new $Uint64(c.$high+j.$high,c.$low+j.$low));$s=1;continue;case 2:$s=-1;return BA.nil;}return;}if($f===undefined){$f={$blk:AP};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};AQ=function(a,b,c,d){var a,b,c,d,e,f,g,h,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=A.NewInt((new $Int64(0,F.Pow(2,(b)))));f=new A.Int.ptr(false,A.nat.nil).Exp(A.NewInt(new $Int64(0,2)),A.NewInt((new $Int64(0,(c-($imul(b,((a+1>>0))))>>0)))),d);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;h=X(new A.Int.ptr(false,A.nat.nil).Mul(e,g),d);$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}$s=-1;return h;}return;}if($f===undefined){$f={$blk:AQ};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.$s=$s;$f.$r=$r;return $f;};AR=function(a,b,c,d,e,f,g){var a,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,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,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;aa=$f.aa;ab=$f.ab;ac=$f.ac;ad=$f.ad;ae=$f.ae;af=$f.af;ag=$f.ag;ah=$f.ah;ai=$f.ai;aj=$f.aj;ak=$f.ak;al=$f.al;am=$f.am;an=$f.an;ao=$f.ao;ap=$f.ap;aq=$f.aq;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;y=$f.y;z=$f.z;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:i=(h=e/2,(h===h&&h!==1/0&&h!==-1/0)?h>>0:$throwRuntimeError("integer divide by zero"));j=e-i>>0;k=M(a);l=f-1>>0;case 1:if(!(l>-1)){$s=2;continue;}m=(new $Int64(0,F.Pow(2,(e))));n=k.Pow(m);$s=3;case 3:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}k=n;if(k===BB.nil){$s=-1;return BB.nil;}o=$makeSlice(BG,$flatten64(m));p=new $Int64(0,0);while(true){if(!((p.$high=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(p)]=a);p=(q=new $Int64(0,1),new $Int64(p.$high+q.$high,p.$low+q.$low));}r=0;case 4:if(!(r<((F.Ceil((d)/(($imul(e,f))))>>0)))){$s=5;continue;}if((d-($imul(e,(((($imul(r,f))+l>>0)+1>>0))))>>0)<0){$s=6;continue;}$s=7;continue;case 6:r=r+(1)>>0;$s=4;continue;case 7:s=AQ(($imul(r,f))+l>>0,e,d,c);$s=8;case 8:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=s.Int64();$s=9;case 9:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=t;w=(($flatten64(u)<0||$flatten64(u)>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(u)]).Multiply((v=g[$Int.keyFor($imul(($imul(r,e)),f))],v!==undefined?v.v:BB.nil));$s=10;case 10:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}(($flatten64(u)<0||$flatten64(u)>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(u)]=w);if((($flatten64(u)<0||$flatten64(u)>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(u)])===BB.nil){$s=-1;return BB.nil;}r=r+(1)>>0;$s=4;continue;case 5:x=0;case 11:if(!(x<((F.Pow(2,(i))>>0)))){$s=12;continue;}y=a;z=0;case 13:if(!(z<((F.Pow(2,((j)))>>0)))){$s=14;continue;}ad=y.Multiply((aa=(ab=$mul64((new $Int64(0,x)),(new $Int64(0,F.Pow(2,(j))))),ac=(new $Int64(0,z)),new $Int64(ab.$high+ac.$high,ab.$low+ac.$low)),(($flatten64(aa)<0||$flatten64(aa)>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(aa)])));$s=15;case 15:if($c){$c=false;ad=ad.$blk();}if(ad&&ad.$blk!==undefined){break s;}y=ad;if(y===BB.nil){$s=-1;return BB.nil;}z=z+(1)>>0;$s=13;continue;case 14:ae=y.Pow($mul64((new $Int64(0,x)),(new $Int64(0,F.Pow(2,(j))))));$s=16;case 16:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}af=ae;if(af===BB.nil){$s=-1;return BB.nil;}ag=k.Multiply(af);$s=17;case 17:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}k=ag;if(k===BB.nil){$s=-1;return BB.nil;}x=x+(1)>>0;$s=11;continue;case 12:ah=0;case 18:if(!(ah<((F.Pow(2,(j))>>0)))){$s=19;continue;}ai=a;aj=0;case 20:if(!(aj<((F.Pow(2,(i))>>0)))){$s=21;continue;}an=ai.Multiply((ak=(al=$mul64((new $Int64(0,aj)),(new $Int64(0,F.Pow(2,(j))))),am=(new $Int64(0,ah)),new $Int64(al.$high+am.$high,al.$low+am.$low)),(($flatten64(ak)<0||$flatten64(ak)>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+$flatten64(ak)])));$s=22;case 22:if($c){$c=false;an=an.$blk();}if(an&&an.$blk!==undefined){break s;}ai=an;if(ai===BB.nil){$s=-1;return BB.nil;}aj=aj+(1)>>0;$s=20;continue;case 21:ao=ai.Pow((new $Int64(0,ah)));$s=23;case 23:if($c){$c=false;ao=ao.$blk();}if(ao&&ao.$blk!==undefined){break s;}ap=ao;if(ap===BB.nil){$s=-1;return BB.nil;}aq=k.Multiply(ap);$s=24;case 24:if($c){$c=false;aq=aq.$blk();}if(aq&&aq.$blk!==undefined){break s;}k=aq;if(k===BB.nil){$s=-1;return BB.nil;}ah=ah+(1)>>0;$s=18;continue;case 19:l=l-(1)>>0;$s=1;continue;case 2:$s=-1;return k;}return;}if($f===undefined){$f={$blk:AR};}$f.a=a;$f.aa=aa;$f.ab=ab;$f.ac=ac;$f.ad=ad;$f.ae=ae;$f.af=af;$f.ag=ag;$f.ah=ah;$f.ai=ai;$f.aj=aj;$f.ak=ak;$f.al=al;$f.am=am;$f.an=an;$f.ao=ao;$f.ap=ap;$f.aq=aq;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.y=y;$f.z=z;$f.$s=$s;$f.$r=$r;return $f;};AS=function(a,b,c,d,e,f,g){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:h=b.Serialize();$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;j=c.Serialize();$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}k=j;l=AP(i,k);$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}m=l;n=AR(a,b,m,d,e,f,g);$s=4;case 4:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}o=n;$s=-1;return o;}return;}if($f===undefined){$f={$blk:AS};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.$s=$s;$f.$r=$r;return $f;};AT=function(a,b,c,d,e){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;u=$f.u;v=$f.v;w=$f.w;x=$f.x;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BB.nil;g=BB.nil;h=AK(c);i=h[0];j=h[1];k=((F.Ceil((c)/(($imul(j,i))))>>0));l=$makeSlice(AY,(k+2>>0));m=0;while(true){if(!(m<(k+1>>0))){break;}((m<0||m>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]=($imul(($imul(m,j)),i)));m=m+(1)>>0;}(n=k+1>>0,((n<0||n>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+n]=c));o=AL(b,l,e);$s=1;case 1:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}p=o;if(p===false){q=BB.nil;r=BB.nil;f=q;g=r;$s=-1;return[f,g];}f=(s=p[$Int.keyFor(c)],s!==undefined?s.v:BB.nil);t=Q(a);$s=2;case 2:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=t;v=AS(u,b,f,c,j,i,p);$s=3;case 3:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}g=v;w=f;x=g;f=w;g=x;$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:AT};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.u=u;$f.v=v;$f.w=w;$f.x=x;$f.$s=$s;$f.$r=$r;return $f;};AU=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;n=$f.n;o=$f.o;p=$f.p;q=$f.q;r=$f.r;s=$f.s;t=$f.t;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:e=a.Serialize();$s=1;case 1:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}f=e;g=b.Serialize();$s=2;case 2:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;i=AP(f,h);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;k=new A.Int.ptr(false,A.nat.nil).Exp(A.NewInt(new $Int64(0,2)),A.NewInt((new $Int64(0,d))),j);$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=k;m=c.BigPow(j);$s=5;case 5:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;if(n===BB.nil){$s=-1;return false;}o=a.BigPow(l);$s=6;case 6:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}p=o;if(p===BB.nil){$s=-1;return false;}q=n.Multiply(p);$s=7;case 7:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=q;if(!(!(r===BB.nil))){s=false;$s=11;continue s;}t=r.Equal(b);$s=12;case 12:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;case 11:if(s){$s=8;continue;}$s=9;continue;case 8:$s=-1;return true;case 9:$s=-1;return false;case 10:$s=-1;return false;}return;}if($f===undefined){$f={$blk:AU};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.n=n;$f.o=o;$f.p=p;$f.q=q;$f.r=r;$f.s=s;$f.t=t;$f.$s=$s;$f.$r=$r;return $f;};AV=function(a){var a,b,c,d,e,f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=K.Since($clone(a,K.Time));c=I.Caller(1);d=c[0];e=I.FuncForPC(d);f=H.MustCompile("^.*\\.(.*)$");$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;h=g.ReplaceAllString(e.Name(),"$1");$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;j=G.Sprintf("%s took %s",new BF([new $String(i),b]));$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}$r=E.Println(new BF([new $String(j)]));$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:AV};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};AX=function(a,b){var a,b;return new AW.ptr(a,$clone(b,BD),BH.zero(),new $Chan(BH,0),false);};$pkg.New=AX;AW.ptr.prototype.GetOutputChannel=function(){var a;a=this;return a.outputChan;};AW.prototype.GetOutputChannel=function(){return this.$val.GetOutputChannel();};AW.ptr.prototype.Execute=function(){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=[a];a[0]=this;a[0].finished=false;c=AM(new BC(a[0].input),a[0].difficulty,2048);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];$copySlice(new BC(a[0].output),d);$copySlice($subslice(new BC(a[0].output),258),e);$go((function(a){return function $b(){var $s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=$send(a[0].outputChan,$clone($clone(a[0].output,BH),BH));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}if($f===undefined){$f={$blk:$b};}$f.$s=$s;$f.$r=$r;return $f;};})(a),[]);a[0].finished=true;$s=-1;return;}return;}if($f===undefined){$f={$blk:AW.ptr.prototype.Execute};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};AW.prototype.Execute=function(){return this.$val.Execute();};AW.ptr.prototype.Verify=function(a){var a,b,c,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=AO(new BC(b.input),new BC(a),b.difficulty,2048);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}$s=-1;return c;}return;}if($f===undefined){$f={$blk:AW.ptr.prototype.Verify};}$f.a=a;$f.b=b;$f.c=c;$f.$s=$s;$f.$r=$r;return $f;};AW.prototype.Verify=function(a){return this.$val.Verify(a);};AW.ptr.prototype.IsFinished=function(){var a;a=this;return a.finished;};AW.prototype.IsFinished=function(){return this.$val.IsFinished();};AW.ptr.prototype.GetOutput=function(){var a;a=this;return a.output;};AW.prototype.GetOutput=function(){return this.$val.GetOutput();};BB.methods=[{prop:"Normalized",name:"Normalized",pkg:"",typ:$funcType([],[BB],false)},{prop:"Reduced",name:"Reduced",pkg:"",typ:$funcType([],[BB],false)},{prop:"identity",name:"identity",pkg:"github.com/bonedaddy/vcaptcha/vdf",typ:$funcType([],[BB],false)},{prop:"Discriminant",name:"Discriminant",pkg:"",typ:$funcType([],[BA],false)},{prop:"Multiply",name:"Multiply",pkg:"",typ:$funcType([BB],[BB],false)},{prop:"Pow",name:"Pow",pkg:"",typ:$funcType([$Int64],[BB],false)},{prop:"BigPow",name:"BigPow",pkg:"",typ:$funcType([BA],[BB],false)},{prop:"Square",name:"Square",pkg:"",typ:$funcType([],[BB],false)},{prop:"SquareUsingMultiply",name:"SquareUsingMultiply",pkg:"",typ:$funcType([],[BB],false)},{prop:"Serialize",name:"Serialize",pkg:"",typ:$funcType([],[BC],false)},{prop:"Equal",name:"Equal",pkg:"",typ:$funcType([BB],[$Bool],false)}];BJ.methods=[{prop:"GetOutputChannel",name:"GetOutputChannel",pkg:"",typ:$funcType([],[BI],false)},{prop:"Execute",name:"Execute",pkg:"",typ:$funcType([],[],false)},{prop:"Verify",name:"Verify",pkg:"",typ:$funcType([BH],[$Bool],false)},{prop:"IsFinished",name:"IsFinished",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"GetOutput",name:"GetOutput",pkg:"",typ:$funcType([],[BH],false)}];L.init("github.com/bonedaddy/vcaptcha/vdf",[{prop:"a",name:"a",embedded:false,exported:false,typ:BA,tag:""},{prop:"b",name:"b",embedded:false,exported:false,typ:BA,tag:""},{prop:"c",name:"c",embedded:false,exported:false,typ:BA,tag:""},{prop:"d",name:"d",embedded:false,exported:false,typ:BA,tag:""}]);T.init("github.com/bonedaddy/vcaptcha/vdf",[{prop:"p",name:"p",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"q",name:"q",embedded:false,exported:false,typ:$Int64,tag:""}]);AW.init("github.com/bonedaddy/vcaptcha/vdf",[{prop:"difficulty",name:"difficulty",embedded:false,exported:false,typ:$Int,tag:""},{prop:"input",name:"input",embedded:false,exported:false,typ:BD,tag:""},{prop:"output",name:"output",embedded:false,exported:false,typ:BH,tag:""},{prop:"outputChan",name:"outputChan",embedded:false,exported:false,typ:BI,tag:""},{prop:"finished",name:"finished",embedded:false,exported:false,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=J.$init();$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K.$init();$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}R=new AY([23,31,47,71,79,103,127,151,167,191,199,223,239,263,271,311,359,367,383,391,431,439,463,479,487,503,527,551,599,607,631,647,703,719,727,743,751,799,823,839,863,887,911,919,943,967,983,991,1007,1031,1039,1063,1087,1103,1151,1159,1207,1223,1231,1247,1271,1279,1303,1319,1327,1343,1367,1399,1423,1439,1447,1471,1487,1511,1543,1559,1567,1583,1591,1607,1663,1679,1711,1751,1759,1783,1823,1831,1847,1871,1879,1919,1927,1943,1951,1999,2039,2047,2063,2071,2087,2111,2143,2159,2183,2207,2231,2239,2263,2279,2287,2311,2351,2383,2399,2407,2423,2447,2479,2503,2543,2551,2567,2591,2599,2623,2647,2663,2671,2687,2711,2719,2759,2767,2791,2831,2839,2879,2887,2903,2911,2927,2983,2999,3007,3023,3071,3079,3103,3119,3127,3151,3167,3191,3239,3247,3271,3287,3319,3343,3359,3383,3391,3407,3431,3439,3463,3503,3511,3527,3551,3559,3583,3599,3607,3623,3631,3671,3719,3727,3743,3767,3791,3799,3823,3847,3863,3911,3919,3943,3959,3967,4007,4031,4063,4079,4087,4111,4127,4159,4183,4223,4231,4247,4271,4327,4343,4351,4391,4399,4423,4439,4447,4463,4471,4519,4559,4567,4583,4591,4607,4639,4663,4679,4687,4703,4727,4751,4759,4783,4799,4831,4847,4871,4903,4919,4943,4951,4967,4999,5023,5039,5063,5087,5111,5119,5143,5167,5183,5191,5207,5231,5263,5279,5287,5303,5311,5351,5359,5399,5407,5431,5471,5479,5503,5519,5527,5543,5567,5591,5623,5639,5647,5671,5711,5743,5767,5783,5791,5807,5839,5879,5903,5911,5927,5959,5983,6007,6023,6031,6047,6079,6103,6119,6143,6151,6191,6199,6239,6247,6263,6271,6287,6311,6319,6343,6359,6367,6407,6431,6439,6463,6511,6527,6551,6583,6599,6607,6623,6631,6647,6679,6703,6719,6751,6767,6791,6823,6847,6863,6871,6887,6911,6943,6959,6967,6983,6991,7031,7039,7079,7087,7103,7127,7151,7159,7199,7207,7223,7247,7279,7303,7327,7351,7367,7391,7439,7463,7471,7487,7519,7543,7559,7583,7591,7607,7639,7663,7687,7703,7727,7751,7759,7783,7807,7823,7831,7871,7879,7919,7927,7951,7967,7991,7999,8023,8039,8087,8111,8119,8143,8159,8167,8191,8207,8231,8263,8279,8287,8303,8311,8383,8399,8423,8431,8447,8471,8479,8527,8543,8551,8599,8623,8639,8647,8663,8711,8719,8759,8783,8791,8807,8831,8839,8863,8887,8903,8927,8951,8959,8999,9007,9047,9071,9103,9127,9143,9151,9167,9199,9223,9239,9263,9271,9287,9311,9319,9343,9367,9391,9407,9431,9439,9463,9479,9487,9511,9551,9599,9623,9631,9671,9679,9703,9719,9727,9743,9767,9791,9799,9839,9847,9871,9887,9943,9959,9967,9983,9991,10007,10039,10063,10079,10103,10111,10151,10159,10183,10207,10223,10247,10271,10279,10303,10319,10327,10343,10391,10399,10447,10463,10471,10487,10511,10519,10559,10567,10583,10607,10631,10639,10663,10679,10687,10711,10727,10783,10799,10807,10823,10831,10847,10903,10919,10943,10951,10991,10999,11023,11047,11071,11087,11111,11119,11159,11183,11191,11239,11279,11287,11303,11311,11327,11351,11359,11383,11399,11423,11447,11471,11503,11519,11527,11551,11567,11591,11623,11639,11647,11663,11719,11743,11783,11807,11831,11839,11863,11887,11903,11911,11927,11951,11959,11983,12007,12031,12071,12079,12119,12127,12143,12151,12167,12191,12223,12239,12247,12263,12319,12343,12359,12367,12391,12407,12431,12479,12487,12503,12511,12527,12559,12583,12599,12631,12647,12671,12679,12703,12743,12751,12767,12791,12799,12823,12839,12847,12863,12871,12911,12919,12959,12967,12983,13007,13031,13063,13087,13103,13127,13151,13159,13183,13199,13207,13231,13271,13303,13319,13327,13367,13399,13423,13439,13463,13471,13487,13511,13543,13567,13583,13591,13631,13639,13679,13687,13703,13711,13751,13759,13799,13807,13823,13831,13847,13879,13903,13919,13927,13943,13967,13991,13999,14023,14039,14071,14087,14111,14143,14159,14167,14191,14207,14239,14263,14279,14303,14327,14351,14359,14383,14407,14423,14431,14447,14471,14479,14503,14519,14527,14543,14551,14591,14639,14647,14671,14687,14711,14719,14743,14759,14767,14783,14831,14863,14879,14887,14951,14983,14999,15007,15023,15031,15047,15079,15143,15151,15167,15199,15247,15263,15271,15287,15311,15319,15343,15359,15383,15391,15439,15479,15487,15503,15511,15527,15551,15559,15583,15599,15607,15623,15647,15671,15679,15703,15727,15751,15767,15791,15823,15839,15863,15871,15887,15919,15943,15959,15991,16007,16031,16039,16063,16087,16103,16111,16127,16151,16183,16199,16207,16223,16231,16271,16279,16319,16327,16343,16351,16391,16399,16439,16447,16463,16487,16519,16543,16559,16567,16591,16607,16631,16663,16703,16711,16727,16759,16799,16823,16831,16847,16871,16879,16903,16927,16943,16967,16999,17023,17047,17063,17071,17111,17119,17159,17167,17183,17191,17207,17231,17239,17263,17279,17287,17327,17351,17359,17383,17399,17431,17447,17471,17503,17519,17527,17543,17551,17599,17623,17639,17663,17671,17687,17711,17767,17783,17791,17807,17839,17863,17879,17887,17903,17911,17951,17959,17999,18023,18047,18071,18079,18103,18119,18127,18143,18167,18191,18199,18223,18247,18287,18311,18367,18383,18391,18407,18439,18463,18479,18503,18511,18527,18559,18583,18607,18631,18647,18671,18679,18703,18719,18727,18743,18751,18791,18839,18847,18871,18911,18919,18943,18959,18983,19007,19031,19039,19079,19087,19111,19127,19183,19199,19207,19223,19231,19247,19303,19319,19343,19351,19367,19391,19399,19423,19447,19463,19471,19511,19519,19543,19559,19567,19583,19631,19639,19687,19703,19711,19727,19751,19759,19783,19807,19823,19847,19871,19879,19919,19927,19951,19967,19991,20023,20039,20047,20063,20071,20087,20143,20159,20183,20191,20231,20239,20263,20287,20303,20311,20327,20351,20359,20399,20407,20431,20479,20519,20543,20551,20567,20591,20599,20623,20639,20663,20687,20711,20719,20743,20759,20767,20791,20807,20831,20863,20879,20887,20903,20927,20959,20983,21023,21031,21071,21079,21103,21127,21143,21167,21191,21199,21223,21239,21247,21271,21311,21319,21367,21383,21391,21407,21431,21479,21487,21503,21551,21559,21583,21599,21607,21631,21647,21719,21727,21743,21751,21767,21799,21823,21839,21863,21871,21887,21911,21919,21943,21991,22007,22031,22039,22063,22079,22103,22111,22151,22159,22199,22207,22223,22247,22271,22279,22303,22327,22343,22367,22391,22423,22439,22447,22471,22487,22511,22543,22559,22567,22591,22639,22663,22679,22703,22727,22751,22783,22807,22823,22831,22871,22879,22903,22927,22943,22951,22991,22999,23039,23047,23063,23071,23087,23119,23143,23159,23167,23183,23207,23239,23263,23279,23311,23327,23351,23383,23399,23407,23423,23431,23447,23479,23503,23519,23567,23591,23599,23623,23663,23671,23687,23711,23719,23743,23759,23767,23783,23791,23831,23839,23879,23887,23911,23927,23951,23983,23999,24007,24023,24047,24071,24103,24119,24127,24151,24191,24223,24239,24247,24263,24287,24319,24359,24383,24391,24407,24439,24463,24487,24503,24511,24527,24551,24559,24599,24623,24631,24671,24679,24719,24727,24743,24751,24767,24799,24823,24839,24847,24863,24887,24911,24919,24943,24967,24991,25007,25031,25063,25079,25087,25111,25127,25159,25183,25199,25231,25247,25271,25279,25303,25327,25343,25351,25367,25391,25423,25439,25447,25463,25471,25511,25559,25567,25583,25591,25607,25631,25639,25679,25687,25703,25759,25783,25799,25807,25847,25871,25903,25919,25943,25951,25967,25999,26023,26063,26071,26087,26111,26119,26167,26183,26207,26231,26239,26263,26287,26303,26311,26359,26399,26407,26423,26431,26447,26471,26479,26503,26519,26527,26567,26591,26599,26623,26639,26647,26671,26687,26711,26743,26759,26783,26791,26839,26863,26879,26903,26911,26927,26951,26959,27007,27023,27031,27047,27103,27119,27127,27143,27151,27191,27199,27239,27263,27271,27311,27319,27343,27359,27367,27383,27407,27431,27439,27463,27479,27487,27527,27551,27583,27607,27623,27631,27647,27679,27719,27743,27751,27767,27791,27799,27823,27847,27871,27887,27919,27943,27959,27967,27983,27991,28031,28079,28087,28103,28111,28151,28159,28183,28199,28207,28247,28271,28279,28319,28351,28367,28423,28439,28447,28463,28471,28487,28519,28543,28559,28583,28591,28607,28631,28663,28687,28703,28711,28727,28751,28759,28783,28799,28807,28823,28871,28879,28927,28943,28967,28991,28999,29023,29039,29047,29063,29087,29111,29119,29143,29167,29191,29207,29231,29279,29287,29303,29311,29327,29383,29399,29423,29431,29479,29503,29527,29543,29551,29567,29591,29599,29639,29647,29663,29671,29719,29759,29767,29791,29807,29831,29839,29863,29879,29903,29927,29951,29959,29983,29999,30007,30031,30047,30071,30103,30119,30127,30143,30167,30223,30263,30271,30287,30311,30319,30343,30367,30383,30391,30431,30439,30463,30479,30487,30551,30559,30599,30607,30623,30631,30647,30671,30703,30727,30743,30791,30799,30839,30847,30871,30887,30911,30959,30967,30983,30991,31007,31039,31063,31079,31103,31111,31127,31151,31159,31183,31223,31231,31247,31271,31279,31303,31319,31327,31351,31391,31399,31439,31463,31487,31511,31519,31543,31567,31583,31607,31631,31639,31663,31679,31687,31711,31727,31751,31783,31799,31807,31831,31847,31879,31903,31919,31943,31951,31991,32023,32047,32063,32111,32119,32143,32159,32167,32183,32191,32231,32239,32287,32303,32311,32327,32359,32399,32407,32423,32447,32471,32479,32503,32519,32551,32567,32623,32639,32647,32663,32671,32687,32719,32743,32759,32783,32807,32831,32839,32863,32887,32911,32927,32951,32959,32983,32999,33023,33031,33071,33079,33119,33127,33151,33167,33191,33199,33223,33239,33247,33263,33287,33311,33343,33359,33367,33391,33431,33463,33479,33487,33503,33511,33559,33599,33623,33647,33679,33703,33727,33743,33751,33767,33791,33799,33823,33863,33871,33911,33919,33959,33967,33983,33991,34007,34031,34039,34063,34079,34087,34103,34127,34159,34183,34207,34231,34247,34271,34303,34319,34327,34343,34351,34367,34399,34423,34439,34471,34487,34511,34519,34543,34583,34591,34607,34631,34663,34679,34687,34703,34711,34751,34759,34799,34807,34823,34831,34847,34871,34919,34927,34943,34967,34999,35023,35039,35047,35071,35111,35143,35159,35183,35207,35239,35263,35279,35303,35311,35327,35351,35359,35383,35407,35423,35447,35471,35479,35527,35543,35551,35591,35599,35639,35647,35663,35671,35687,35719,35743,35759,35767,35807,35831,35839,35863,35879,35887,35911,35927,35951,35983,35999,36007,36031,36079,36103,36119,36143,36151,36167,36191,36199,36247,36263,36271,36287,36319,36343,36359,36367,36383,36391,36431,36479,36503,36511,36527,36551,36559,36583,36599,36607,36623,36671,36679,36703,36719,36727,36767,36791,36823,36847,36863,36871,36887,36919,36943,36983,36991,37007,37031,37039,37087,37111,37127,37151,37159,37183,37199,37207,37223,37231,37319,37327,37343,37351,37391,37399,37423,37439,37447,37463,37487,37511,37519,37559,37567,37591,37607,37663,37679,37703,37711,37727,37759,37783,37799,37823,37831,37847,37871,37879,37903,37927,37943,37951,37967,37991,38023,38039,38047,38063,38111,38119,38167,38183,38191,38231,38239,38263,38279,38287,38303,38327,38351,38359,38383,38399,38407,38431,38447,38471,38503,38527,38543,38551,38567,38639,38663,38671,38711,38719,38743,38767,38783,38791,38807,38839,38879,38887,38903,38911,38959,38999,39007,39023,39031,39047,39071,39079,39103,39119,39167,39191,39199,39223,39239,39271,39287,39311,39343,39359,39367,39383,39407,39439,39463,39503,39511,39527,39551,39583,39607,39623,39631,39647,39671,39679,39703,39719,39727,39751,39791,39799,39839,39847,39863,39887,39911,39943,39959,39967,39983,40031,40039,40063,40087,40111,40127,40151,40199,40207,40223,40231,40247,40279,40303,40319,40343,40351,40367,40399,40423,40463,40471,40487,40511,40519,40543,40559,40567,40583,40591,40631,40639,40679,40687,40727,40751,40759,40783,40823,40847,40871,40879,40903,40919,40927,40951,40967,40991,41023,41039,41047,41071,41087,41143,41159,41183,41191,41207,41231,41263,41287,41303,41311,41351,41359,41383,41399,41407,41423,41471,41479,41519,41527,41543,41551,41567,41599,41623,41647,41663,41687,41711,41719,41759,41791,41807,41831,41863,41879,41887,41903,41911,41927,41959,41983,41999,42023,42047,42071,42079,42103,42127,42143,42151,42167,42191,42199,42223,42239,42247,42271,42311,42319,42359,42391,42407,42431,42439,42463,42479,42487,42503,42527,42551,42583,42599,42607,42631,42671,42703,42719,42727,42743,42751,42767,42799,42839,42863,42871,42919,42943,42967,42983,43007,43031,43039,43063,43079,43103,43111,43151,43159,43207,43223,43231,43247,43271,43279,43319,43327,43343,43367,43391,43399,43423,43447,43471,43487,43543,43559,43567,43583,43591,43607,43639,43663,43679,43711,43727,43751,43759,43783,43807,43831,43847,43871,43903,43919,43943,43951,43991,43999,44039,44047,44063,44071,44087,44111,44119,44159,44167,44183,44207,44263,44279,44287,44311,44327,44351,44383,44399,44423,44431,44479,44503,44519,44543,44567,44591,44599,44623,44647,44663,44687,44711,44719,44743,44767,44783,44791,44831,44839,44879,44887,44903,44911,44927,44951,44959,44983,44999,45007,45047,45079,45103,45119,45127,45151,45167,45191,45223,45239,45247,45263,45271,45319,45343,45359,45391,45407,45431,45439,45503,45511,45527,45559,45583,45599,45607,45623,45631,45671,45679,45719,45743,45751,45767,45791,45823,45839,45847,45863,45887,45911,45919,45943,45959,45967,46031,46063,46087,46103,46127,46159,46183,46199,46223,46231,46247,46271,46279,46303,46327,46351,46367,46391,46399,46439,46447,46463,46471,46511,46559,46567,46583,46591,46639,46663,46679,46687,46703,46727,46751,46759,46799,46807,46831,46847,46903,46919,46927,46951,46967,46999,47023,47039,47063,47071,47087,47111,47119,47143,47167,47183,47191,47207,47231,47239,47263,47279,47287,47303,47351,47407,47423,47431,47447,47471,47479,47503,47519,47527,47543,47591,47599,47623,47639,47647,47687,47711,47743,47759,47767,47783,47791,47807,47863,47903,47911,47951,47959,48007,48023,48031,48047,48071,48079,48119,48127,48143,48151,48199,48239,48247,48263,48271,48287,48311,48319,48343,48359,48383,48407,48431,48439,48463,48479,48487,48511,48527,48551,48583,48599,48623,48647,48679,48703,48743,48751,48767,48791,48799,48823,48847,48863,48871,48887,48911,48943,48959,48967,48991,49031,49039,49079,49087,49103,49111,49151,49183,49199,49207,49223,49271,49279,49303,49319,49327,49351,49367,49391,49447,49463,49471,49487,49519,49559,49583,49591,49607,49631,49639,49663,49703,49711,49727,49759,49783,49799,49807,49823,49831,49871,49879,49919,49927,49943,49967,49991,49999,50023,50047,50087,50111,50119,50143,50159,50191,50207,50231,50263,50279,50287,50311,50327,50359,50383,50399,50423,50431,50447,50471,50503,50527,50543,50551,50591,50599,50623,50639,50647,50663,50671,50711,50719,50759,50767,50783,50807,50839,50863,50879,50887,50903,50927,50951,50959,50983,51031,51047,51071,51119,51127,51143,51151,51167,51199,51223,51239,51263,51287,51319,51343,51367,51383,51391,51407,51431,51439,51463,51479,51487,51503,51511,51551,51559,51599,51607,51631,51647,51671,51679,51703,51719,51743,51767,51791,51823,51839,51847,51871,51911,51943,51959,51967,51983,51991,52007,52079,52103,52111,52127,52159,52183,52207,52223,52231,52271,52279,52303,52319,52343,52391,52399,52439,52447,52463,52471,52487,52511,52519,52543,52567,52583,52607,52631,52639,52687,52711,52727,52751,52783,52799,52807,52823,52831,52847,52879,52903,52919,52951,52967,52991,52999,53023,53047,53063,53071,53087,53111,53143,53159,53167,53191,53231,53239,53279,53303,53311,53327,53351,53359,53399,53407,53423,53447,53479,53503,53519,53527,53551,53567,53591,53623,53639,53663,53671,53687,53719,53743,53759,53783,53791,53831,53839,53863,53887,53903,53927,53951,53959,53983,54007,54023,54031,54071,54079,54127,54143,54151,54167,54191,54199,54239,54247,54287,54311,54319,54343,54359,54367,54391,54407,54463,54479,54487,54503,54511,54559,54583,54599,54623,54631,54647,54671,54679,54727,54751,54767,54799,54823,54839,54863,54871,54911,54919,54959,54983,54991,55007,55031,55039,55063,55079,55087,55103,55127,55151,55183,55199,55207,55247,55271,55303,55327,55343,55351,55399,55423,55439,55463,55487,55511,55519,55543,55567,55591,55607,55631,55639,55663,55687,55703,55711,55751,55799,55807,55823,55831,55871,55879,55903,55919,55927,55943,55967,55999,56039,56047,56071,56087,56143,56159,56167,56183,56191,56207,56239,56263,56279,56311,56327,56351,56359,56383,56423,56431,56447,56471,56479,56503,56519,56527,56543,56591,56599,56647,56663,56671,56687,56711,56743,56759,56767,56783,56807,56831,56839,56863,56879,56887,56911,56951,56983,56999,57007,57023,57047,57103,57119,57143,57151,57191,57199,57223,57247,57263,57271,57287,57311,57319,57359,57367,57383,57391,57439,57479,57487,57503,57511,57527,57559,57583,57599,57623,57647,57671,57679,57703,57719,57727,57751,57767,57791,57823,57839,57847,57887,57919,57943,57983,57991,58007,58031,58039,58063,58087,58103,58111,58127,58151,58159,58183,58199,58207,58231,58271,58319,58327,58343,58351,58367,58391,58423,58439,58447,58463,58511,58519,58543,58559,58567,58607,58631,58679,58687,58703,58711,58727,58759,58783,58823,58831,58847,58871,58879,58943,58951,58967,58991,58999,59023,59039,59047,59063,59071,59119,59159,59167,59183,59207,59231,59239,59263,59287,59303,59327,59351,59359,59383,59399,59407,59431,59447,59471,59503,59519,59551,59567,59599,59623,59639,59663,59671,59687,59711,59743,59767,59783,59791,59831,59863,59879,59887,59903,59911,59951,59959,59999,60007,60023,60031,60079,60103,60119,60127,60143,60167,60191,60199,60223,60239,60271,60287,60311,60343,60367,60383,60391,60407,60439,60479,60503,60527,60551,60559,60583,60607,60623,60631,60647,60679,60703,60719,60727,60743,60751,60791,60799,60839,60847,60871,60887,60911,60919,60943,60959,60967,61007,61031,61063,61079,61111,61151,61183,61199,61207,61223,61231,61247,61279,61319,61343,61351,61367,61423,61447,61463,61471,61487,61511,61519,61543,61559,61583,61591,61631,61639,61679,61687,61703,61727,61751,61759,61783,61799,61807,61823,61847,61871,61879,61903,61927,61951,61967,61991,62039,62047,62063,62071,62087,62119,62143,62159,62191,62207,62239,62263,62287,62303,62311,62327,62351,62383,62399,62407,62423,62431,62471,62479,62519,62527,62551,62567,62591,62599,62639,62663,62687,62719,62743,62759,62767,62791,62807,62831,62863,62879,62903,62911,62927,62983,62999,63023,63031,63047,63071,63079,63103,63127,63143,63191,63199,63223,63247,63263,63311,63319,63359,63367,63383,63391,63407,63431,63439,63463,63487,63527,63551,63559,63599,63607,63631,63647,63671,63703,63719,63727,63743,63751,63799,63823,63839,63863,63871,63887,63911,63919,63967,63983,63991,64007,64039,64063,64079,64087,64111,64151,64159,64199,64223,64231,64247,64271,64279,64303,64319,64327,64343,64367,64391,64399,64423,64439,64447,64487,64511,64543,64567,64583,64591,64607,64639,64663,64679,64703,64711,64751,64759,64783,64807,64847,64871,64879,64903,64919,64927,64943,64951,64991,65047,65063,65071,65111,65119,65159,65167,65183,65207,65231,65239,65279,65287,65311,65327,65383,65399,65407,65423,65431,65447,65479,65503,65519,65543,65551,65567,65591,65599,65623,65647,65671,65687,65711,65719,65743,65759,65783,65831,65839,65887,65903,65911,65927,65951,65959,65983,65999,66007,66023,66047,66071,66103,66119,66127,66151,66167,66191,66223,66239,66247,66263,66271,66343,66359,66383,66431,66439,66463,66487,66503,66511,66527,66551,66559,66607,66623,66631,66679,66719,66727,66743,66751,66767,66791,66799,66823,66839,66863,66887,66919,66943,66959,66967,66991,67007,67031,67063,67079,67087,67103,67127,67159,67183,67231,67247,67271,67279,67303,67343,67351,67367,67391,67399,67423,67439,67447,67471,67511,67519,67559,67567,67583,67591,67607,67631,67663,67679,67687,67703,67751,67759,67783,67799,67807,67831,67871,67919,67927,67943,67967,67999,68023,68039,68063,68071,68087,68111,68119,68143,68183,68191,68207,68231,68239,68279,68287,68303,68311,68351,68359,68399,68407,68423,68447,68479,68503,68527,68543,68567,68591,68599,68623,68639,68647,68671,68687,68711,68743,68759,68767,68791,68807,68839,68863,68879,68903,68911,68927,68951,68983,69007,69023,69031,69071,69079,69103,69119,69127,69143,69151,69191,69239,69247,69263,69271,69287,69319,69343,69359,69367,69383,69431,69439,69463,69479,69527,69551,69583,69599,69607,69623,69631,69647,69679,69703,69743,69767,69791,69799,69847,69863,69871,69887,69911,69919,69943,69959,69967,69983,69991,70039,70079,70087,70111,70127,70151,70159,70183,70199,70207,70223,70247,70271,70303,70319,70327,70351,70391,70423,70439,70463,70471,70487,70519,70559,70583,70591,70607,70639,70663,70687,70703,70711,70727,70751,70783,70799,70823,70831,70871,70879,70919,70927,70943,70951,70991,70999,71023,71039,71047,71063,71087,71111,71119,71143,71167,71191,71207,71231,71263,71287,71303,71311,71327,71359,71399,71431,71447,71471,71479,71503,71527,71543,71551,71567,71623,71639,71647,71663,71671,71711,71719,71759,71767,71783,71791,71807,71831,71839,71879,71887,71927,71959,71983,71999,72031,72047,72071,72103,72119,72143,72151,72167,72199,72223,72239,72263,72271,72287,72311,72343,72367,72383,72407,72431,72439,72463,72487,72503,72511,72551,72559,72599,72607,72623,72647,72671,72679,72703,72719,72727,72767,72791,72799,72823,72847,72871,72887,72911,72959,72967,72983,72991,73039,73063,73079,73103,73111,73127,73159,73207,73223,73231,73247,73279,73303,73319,73327,73343,73351,73391,73399,73439,73471,73487,73511,73519,73543,73559,73583,73607,73631,73639,73663,73679,73687,73727,73751,73783,73807,73823,73831,73847,73903,73919,73943,73951,73967,73991,73999,74023,74047,74071,74111,74119,74143,74159,74167,74183,74231,74279,74287,74303,74311,74351,74359,74383,74407,74423,74447,74471,74479,74519,74527,74551,74567,74623,74639,74647,74663,74671,74687,74719,74743,74759,74783,74791,74807,74831,74839,74863,74887,74903,74911,74927,74951,74959,74983,74999,75007,75071,75079,75143,75151,75167,75191,75199,75223,75239,75247,75263,75287,75311,75319,75343,75359,75367,75391,75407,75431,75463,75479,75487,75503,75511,75527,75583,75599,75623,75631,75671,75679,75703,75727,75743,75767,75791,75799,75839,75847,75863,75871,75919,75967,75983,75991,76007,76031,76039,76079,76103,76127,76151,76159,76183,76199,76207,76231,76247,76303,76319,76327,76343,76367,76399,76423,76463,76471,76487,76511,76519,76543,76567,76591,76607,76631,76639,76663,76679,76711,76751,76759,76799,76807,76823,76831,76847,76871,76903,76919,76927,76943,76991,77023,77039,77047,77071,77087,77111,77159,77167,77183,77191,77239,77263,77279,77303,77327,77351,77359,77383,77423,77431,77447,77471,77479,77503,77527,77543,77551,77591,77599,77639,77647,77663,77687,77711,77719,77743,77767,77783,77807,77839,77863,77879,77887,77911,77927,77951,77983,77999,78007,78031,78047,78079,78103,78119,78151,78167,78191,78223,78263,78271,78311,78319,78343,78359,78367,78383,78391,78431,78439,78479,78487,78503,78511,78527,78583,78599,78607,78623,78647,78671,78679,78703,78719,78751,78791,78823,78839,78847,78863,78887,78919,78943,78959,78983,79007,79031,79039,79063,79087,79103,79111,79127,79151,79159,79199,79207,79223,79231,79271,79279,79319,79327,79351,79367,79399,79423,79439,79447,79463,79487,79511,79543,79559,79567,79591,79631,79663,79679,79687,79711,79727,79759,79799,79823,79831,79847,79879,79903,79927,79943,79951,79967,79991,79999,80023,80039,80063,80071,80111,80159,80167,80183,80191,80207,80231,80239,80263,80279,80287,80303,80351,80359,80383,80407,80447,80471,80503,80519,80527,80543,80551,80567,80599,80623,80671,80687,80711,80719,80767,80783,80791,80807,80831,80863,80879,80887,80903,80911,80959,80999,81007,81023,81031,81047,81071,81079,81119,81127,81143,81167,81199,81223,81239,81247,81271,81287,81311,81343,81359,81383,81391,81407,81439,81463,81479,81503,81511,81527,81551,81559,81583,81607,81623,81647,81671,81703,81727,81743,81751,81791,81799,81839,81847,81863,81871,81911,81919,81943,81959,81967,82007,82031,82039,82063,82079,82087,82111,82127,82151,82183,82207,82223,82231,82279,82319,82343,82351,82367,82391,82399,82447,82463,82471,82487,82519,82543,82559,82567,82583,82591,82631,82639,82679,82703,82711,82727,82751,82759,82783,82799,82807,82847,82871,82879,82903,82919,82967,82991,83023,83047,83063,83071,83087,83119,83143,83159,83183,83191,83207,83231,83263,83287,83311,83327,83351,83359,83383,83399,83407,83423,83431,83471,83519,83527,83543,83591,83599,83623,83639,83647,83663,83687,83711,83719,83767,83791,83807,83879,83887,83903,83911,83927,83959,83983,83999,84023,84031,84047,84079,84103,84127,84143,84151,84167,84191,84199,84223,84239,84247,84263,84311,84319,84367,84391,84407,84431,84439,84463,84479,84503,84527,84551,84559,84583,84599,84607,84631,84647,84671,84703,84719,84727,84743,84751,84767,84823,84839,84863,84871,84911,84919,84943,84967,84983,84991,85031,85039,85079,85087,85103,85159,85199,85207,85223,85231,85247,85271,85279,85303,85343,85367,85391,85399,85439,85447,85471,85487,85511,85543,85559,85567,85583,85607,85639,85663,85703,85711,85727,85751,85759,85783,85807,85823,85831,85847,85871,85879,85903,85919,85927,85951,85991,85999,86039,86063,86071,86087,86111,86143,86159,86167,86183,86231,86239,86263,86279,86287,86311,86327,86351,86399,86407,86423,86431,86447,86479,86503,86519,86543,86551,86591,86599,86623,86663,86687,86711,86719,86743,86759,86767,86783,86791,86831,86839,86887,86903,86927,86951,86959,87007,87023,87047,87071,87079,87103,87119,87127,87151,87167,87223,87239,87247,87271,87287,87319,87343,87359,87383,87391,87407,87431,87463,87487,87511,87551,87559,87583,87599,87623,87631,87671,87679,87719,87727,87743,87751,87767,87799,87823,87839,87847,87863,87887,87911,87943,87959,87991,88007,88031,88063,88079,88087,88103,88111,88159,88183,88199,88223,88247,88271,88279,88303,88327,88343,88351,88367,88391,88399,88423,88447,88463,88471,88511,88519,88559,88567,88591,88607,88631,88639,88663,88679,88687,88703,88727,88783,88799,88807,88831,88871,88903,88919,88927,88943,88951,88967,88999,89039,89071,89087,89119,89143,89183,89191,89207,89231,89239,89263,89279,89303,89311,89351,89359,89399,89407,89423,89431,89447,89471,89503,89519,89527,89543,89567,89591,89599,89623,89647,89671,89711,89743,89759,89767,89783,89807,89839,89863,89879,89911,89927,89951,89959,89983,90007,90023,90031,90047,90071,90119,90127,90143,90151,90191,90199,90239,90247,90263,90271,90287,90319,90359,90367,90383,90407,90439,90463,90479,90487,90511,90527,90551,90583,90599,90631,90647,90679,90703,90719,90743,90751,90767,90791,90799,90823,90847,90863,90887,90911,90919,90943,90967,90983,90991,91031,91079,91087,91103,91111,91127,91151,91159,91183,91199,91207,91271,91279,91303,91319,91327,91367,91391,91423,91439,91447,91463,91471,91519,91543,91583,91591,91607,91631,91639,91687,91703,91711,91727,91759,91783,91799,91807,91823,91831,91879,91919,91943,91951,91967,91991,91999,92023,92039,92047,92063,92087,92111,92119,92143,92159,92167,92207,92231,92263,92303,92311,92327,92359,92383,92399,92423,92431,92447,92471,92479,92503,92527,92551,92567,92591,92623,92639,92647,92663,92671,92711,92759,92767,92783,92791,92831,92839,92863,92879,92887,92903,92927,92951,92959,92999,93007,93031,93047,93103,93127,93143,93151,93167,93199,93239,93263,93271,93287,93311,93319,93343,93367,93383,93391,93407,93439,93463,93479,93487,93503,93551,93559,93607,93623,93631,93647,93671,93679,93703,93719,93727,93767,93791,93799,93823,93839,93871,93887,93911,93943,93959,93967,93983,93991,94007,94063,94079,94103,94111,94151,94183,94207,94223,94231,94247,94271,94279,94319,94327,94343,94351,94399,94439,94447,94463,94487,94511,94519,94543,94559,94583,94607,94631,94639,94663,94687,94711,94727,94751,94799,94807,94823,94847,94879,94903,94943,94951,94967,94999,95023,95047,95063,95071,95087,95111,95119,95143,95159,95167,95191,95231,95239,95279,95287,95311,95327,95351,95383,95399,95423,95471,95479,95503,95519,95527,95551,95567,95591,95639,95647,95663,95671,95687,95743,95759,95783,95791,95807,95831,95839,95863,95903,95911,95951,95959,95983,95999,96007,96023,96071,96079,96119,96127,96143,96167,96191,96199,96223,96247,96263,96287,96311,96319,96359,96367,96391,96407,96431,96463,96479,96487,96511,96527,96559,96583,96599,96623,96631,96647,96671,96703,96727,96743,96751,96791,96799,96823,96839,96847,96871,96911,96919,96959,96983,96991,97007,97039,97063,97079,97087,97103,97127,97151,97159,97183,97199,97231,97247,97271,97303,97319,97327,97343,97351,97367,97399,97423,97439,97463,97511,97519,97543,97567,97583,97607,97631,97639,97663,97679,97687,97703,97711,97751,97759,97807,97831,97847,97871,97879,97919,97927,97943,97967,97991,98023,98039,98047,98071,98143,98159,98167,98183,98191,98207,98239,98279,98303,98311,98327,98359,98383,98407,98431,98447,98471,98479,98503,98519,98543,98551,98591,98599,98639,98647,98663,98671,98687,98711,98719,98743,98759,98767,98783,98807,98831,98863,98887,98911,98927,98951,98983,98999,99007,99023,99031,99079,99103,99119,99167,99191,99199,99223,99247,99263,99271,99287,99311,99343,99367,99383,99391,99431,99439,99479,99487,99503,99511,99527,99551,99559,99599,99607,99623,99647,99679,99703,99719,99727,99751,99767,99791,99823,99839,99863,99871,99887,99919,99943,99959,99991,100007,100031,100039,100063,100103,100127,100151,100159,100183,100207,100223,100231,100271,100279,100319,100327,100343,100351,100367,100391,100423,100439,100447,100487,100511,100519,100543,100559,100567,100591,100631,100663,100679,100687,100703,100759,100783,100799,100823,100831,100847,100871,100879,100927,100943,100951,100967,100999,101039,101047,101063,101071,101111,101119,101159,101183,101191,101207,101239,101263,101279,101287,101303,101327,101351,101359,101383,101399,101407,101447,101471,101503,101527,101551,101567,101599,101623,101639,101663,101671,101687,101711,101719,101743,101767,101791,101807,101831,101839,101863,101879,101887,101903,101911,101951,101999,102007,102023,102031,102071,102079,102103,102119,102127,102143,102191,102199,102239,102247,102287,102343,102359,102367,102383,102391,102407,102439,102463,102503,102511,102527,102551,102559,102607,102623,102631,102647,102671,102679,102703,102719,102727,102743,102799,102847,102863,102871,102887,102911,102919,102943,102959,102967,102983,103007,103031,103039,103063,103079,103087,103111,103127,103151,103183,103199,103223,103231,103247,103303,103319,103343,103351,103391,103399,103423,103447,103463,103471,103487,103511,103559,103567,103583,103591,103639,103679,103687,103703,103711,103751,103759,103783,103799,103823,103847,103871,103879,103903,103919,103927,103951,103967,103991,104023,104047,104063,104087,104119,104183,104191,104207,104231,104239,104263,104287,104303,104311,104327,104359,104383,104399,104407,104431,104471,104479,104519,104527,104543,104551,104567,104591,104623,104639,104647,104711,104719,104743,104759,104791,104807,104831,104879,104887,104903,104911,104927,104959,104983,104999,105023,105031,105047,105071,105103,105143,105151,105167,105191,105199,105223,105239,105247,105263,105271,105311,105319,105359,105367,105383,105407,105431,105439,105463,105487,105503,105527,105551,105559,105583,105607,105631,105647,105671,105719,105727,105751,105767,105799,105823,105839,105863,105871,105887,105943,105967,105983,105991,106031,106039,106063,106079,106087,106103,106111,106151,106159,106199,106207,106231,106247,106279,106303,106319,106343,106367,106391,106399,106423,106439,106471,106487,106511,106543,106559,106567,106583,106591,106607,106663,106679,106703,106727,106751,106759,106783,106807,106823,106831,106871,106879,106903,106919,106927,106943,106991,106999,107039,107047,107071,107087,107111,107119,107143,107167,107183,107207,107231,107279,107287,107311,107351,107383,107399,107407,107423,107431,107447,107479,107519,107543,107551,107567,107599,107623,107647,107663,107671,107687,107711,107719,107743,107759,107791,107831,107839,107879,107903,107911,107927,107951,107959,107983,107999,108007,108023,108047,108071,108079,108103,108127,108151,108167,108191,108223,108239,108247,108263,108271,108287,108319,108343,108359,108391,108431,108439,108463,108487,108503,108527,108551,108583,108599,108607,108623,108631,108671,108679,108727,108743,108751,108767,108791,108799,108839,108847,108863,108887,108919,108943,108959,108967,108991,109007,109063,109079,109103,109111,109127,109159,109183,109199,109223,109231,109247,109271,109279,109303,109327,109367,109391,109399,109423,109463,109471,109511,109519,109559,109567,109583,109591,109607,109631,109639,109663,109679,109687,109727,109751,109783,109799,109807,109831,109847,109871,109903,109919,109927,109943,109951,109999,110023,110039,110063,110087,110111,110119,110167,110183,110191,110207,110239,110263,110287,110303,110311,110351,110359,110399,110423,110431,110447,110471,110479,110503,110519,110527,110543,110567,110599,110623,110639,110647,110687,110711,110743,110767,110783,110791,110807,110839,110863,110879,110911,110927,110951,110959,110983,111031,111047,111071,111079,111103,111119,111127,111143,111151,111191,111239,111247,111263,111271,111311,111343,111359,111367,111383,111407,111431,111439,111479,111487,111511,111583,111599,111607,111623,111647,111679,111703,111719,111743,111751,111767,111791,111799,111823,111847,111863,111871,111887,111911,111919,111959,111967,111983,112031,112039,112087,112103,112111,112127,112159,112183,112199,112207,112223,112247,112271,112279,112303,112319,112327,112351,112367,112391,112423,112439,112447,112471,112487,112543,112559,112583,112591,112631,112639,112663,112687,112703,112711,112727,112751,112759,112799,112807,112823,112831,112919,112927,112943,112951,112967,112991,112999,113023,113039,113063,113111,113119,113143,113159,113167,113207,113231,113263,113279,113287,113303,113327,113359,113383,113423,113431,113447,113471,113479,113527,113543,113551,113567,113591,113599,113623,113639,113647,113671,113719,113759,113767,113783,113791,113807,113831,113863,113879,113887,113903,113951,113959,113983,113999,114007,114031,114047,114071,114119,114143,114151,114167,114199,114223,114239,114263,114271,114287,114311,114319,114343,114383,114391,114407,114431,114463,114479,114487,114503,114511,114551,114559,114599,114607,114623,114671,114679,114703,114727,114743,114767,114791,114799,114823,114839,114847,114871,114887,114911,114943,114967,114991,115007,115039,115079,115103,115111,115127,115151,115183,115207,115223,115231,115279,115303,115319,115327,115343,115351,115391,115399,115439,115447,115463,115471,115487,115519,115543,115559,115567,115607,115631,115639,115663,115679,115711,115727,115751,115783,115799,115807,115823,115831,115847,115879,115903,115919,115943,115967,115991,116023,116047,116063,116071,116087,116111,116119,116143,116159,116167,116183,116191,116231,116239,116279,116287,116327,116351,116359,116383,116399,116407,116423,116447,116471,116503,116527,116551,116591,116639,116647,116663,116671,116687,116719,116759,116783,116791,116807,116839,116863,116887,116903,116911,116927,116951,116959,116983,116999,117023,117031,117071,117079,117119,117127,117151,117167,117191,117199,117223,117239,117263,117287,117311,117319,117343,117367,117391,117407,117431,117463,117479,117487,117503,117511,117527,117583,117599,117631,117647,117671,117679,117703,117727,117743,117751,117791,117823,117839,117847,117863,117911,117919,117959,117967,117983,117991,118007,118031,118039,118087,118103,118127,118159,118199,118207,118231,118247,118271,118303,118319,118343,118351,118367,118399,118423,118439,118463,118471,118487,118511,118519,118543,118567,118583,118607,118631,118639,118663,118687,118711,118751,118759,118799,118823,118831,118847,118871,118879,118903,118919,118927,118967,118991,118999,119023,119039,119047,119071,119087,119111,119143,119159,119167,119183,119191,119239,119263,119279,119303,119311,119351,119359,119407,119423,119447,119479,119503,119519,119527,119543,119551,119591,119599,119663,119671,119687,119711,119719,119759,119767,119783,119807,119831,119839,119863,119879,119887,119927,119983,120007,120023,120031,120047,120079,120103,120119]);S=new AZ([new T.ptr(new $Int64(0,17),new $Int64(0,8)),new T.ptr(new $Int64(0,19),new $Int64(0,10)),new T.ptr(new $Int64(0,23),new $Int64(0,5)),new T.ptr(new $Int64(0,29),new $Int64(0,15)),new T.ptr(new $Int64(0,31),new $Int64(0,6)),new T.ptr(new $Int64(0,37),new $Int64(0,35)),new T.ptr(new $Int64(0,41),new $Int64(0,4)),new T.ptr(new $Int64(0,43),new $Int64(0,41)),new T.ptr(new $Int64(0,47),new $Int64(0,43)),new T.ptr(new $Int64(0,53),new $Int64(0,41)),new T.ptr(new $Int64(0,59),new $Int64(0,44)),new T.ptr(new $Int64(0,61),new $Int64(0,50)),new T.ptr(new $Int64(0,67),new $Int64(0,6)),new T.ptr(new $Int64(0,71),new $Int64(0,65)),new T.ptr(new $Int64(0,73),new $Int64(0,48)),new T.ptr(new $Int64(0,79),new $Int64(0,2)),new T.ptr(new $Int64(0,83),new $Int64(0,35)),new T.ptr(new $Int64(0,89),new $Int64(0,86)),new T.ptr(new $Int64(0,97),new $Int64(0,20)),new T.ptr(new $Int64(0,101),new $Int64(0,88)),new T.ptr(new $Int64(0,103),new $Int64(0,89)),new T.ptr(new $Int64(0,107),new $Int64(0,60)),new T.ptr(new $Int64(0,109),new $Int64(0,55)),new T.ptr(new $Int64(0,113),new $Int64(0,1)),new T.ptr(new $Int64(0,127),new $Int64(0,75)),new T.ptr(new $Int64(0,131),new $Int64(0,56)),new T.ptr(new $Int64(0,137),new $Int64(0,85)),new T.ptr(new $Int64(0,139),new $Int64(0,29)),new T.ptr(new $Int64(0,149),new $Int64(0,86)),new T.ptr(new $Int64(0,151),new $Int64(0,149)),new T.ptr(new $Int64(0,157),new $Int64(0,21)),new T.ptr(new $Int64(0,163),new $Int64(0,74)),new T.ptr(new $Int64(0,167),new $Int64(0,32)),new T.ptr(new $Int64(0,173),new $Int64(0,3)),new T.ptr(new $Int64(0,179),new $Int64(0,114)),new T.ptr(new $Int64(0,181),new $Int64(0,82)),new T.ptr(new $Int64(0,191),new $Int64(0,10)),new T.ptr(new $Int64(0,193),new $Int64(0,60)),new T.ptr(new $Int64(0,197),new $Int64(0,130)),new T.ptr(new $Int64(0,199),new $Int64(0,144)),new T.ptr(new $Int64(0,211),new $Int64(0,128)),new T.ptr(new $Int64(0,223),new $Int64(0,139)),new T.ptr(new $Int64(0,227),new $Int64(0,135)),new T.ptr(new $Int64(0,229),new $Int64(0,205)),new T.ptr(new $Int64(0,233),new $Int64(0,192)),new T.ptr(new $Int64(0,239),new $Int64(0,170)),new T.ptr(new $Int64(0,241),new $Int64(0,26)),new T.ptr(new $Int64(0,251),new $Int64(0,175)),new T.ptr(new $Int64(0,257),new $Int64(0,28)),new T.ptr(new $Int64(0,263),new $Int64(0,100)),new T.ptr(new $Int64(0,269),new $Int64(0,234)),new T.ptr(new $Int64(0,271),new $Int64(0,89)),new T.ptr(new $Int64(0,277),new $Int64(0,65)),new T.ptr(new $Int64(0,281),new $Int64(0,131)),new T.ptr(new $Int64(0,283),new $Int64(0,241)),new T.ptr(new $Int64(0,293),new $Int64(0,205)),new T.ptr(new $Int64(0,307),new $Int64(0,37)),new T.ptr(new $Int64(0,311),new $Int64(0,290)),new T.ptr(new $Int64(0,313),new $Int64(0,213)),new T.ptr(new $Int64(0,317),new $Int64(0,124)),new T.ptr(new $Int64(0,331),new $Int64(0,10)),new T.ptr(new $Int64(0,337),new $Int64(0,189)),new T.ptr(new $Int64(0,347),new $Int64(0,6)),new T.ptr(new $Int64(0,349),new $Int64(0,60)),new T.ptr(new $Int64(0,353),new $Int64(0,293)),new T.ptr(new $Int64(0,359),new $Int64(0,307)),new T.ptr(new $Int64(0,367),new $Int64(0,205)),new T.ptr(new $Int64(0,373),new $Int64(0,80)),new T.ptr(new $Int64(0,379),new $Int64(0,346)),new T.ptr(new $Int64(0,383),new $Int64(0,89)),new T.ptr(new $Int64(0,389),new $Int64(0,24)),new T.ptr(new $Int64(0,397),new $Int64(0,65)),new T.ptr(new $Int64(0,401),new $Int64(0,225)),new T.ptr(new $Int64(0,409),new $Int64(0,198)),new T.ptr(new $Int64(0,419),new $Int64(0,63)),new T.ptr(new $Int64(0,421),new $Int64(0,184)),new T.ptr(new $Int64(0,431),new $Int64(0,147)),new T.ptr(new $Int64(0,433),new $Int64(0,254)),new T.ptr(new $Int64(0,439),new $Int64(0,119)),new T.ptr(new $Int64(0,443),new $Int64(0,324)),new T.ptr(new $Int64(0,449),new $Int64(0,36)),new T.ptr(new $Int64(0,457),new $Int64(0,354)),new T.ptr(new $Int64(0,461),new $Int64(0,211)),new T.ptr(new $Int64(0,463),new $Int64(0,333)),new T.ptr(new $Int64(0,467),new $Int64(0,37)),new T.ptr(new $Int64(0,479),new $Int64(0,312)),new T.ptr(new $Int64(0,487),new $Int64(0,219)),new T.ptr(new $Int64(0,491),new $Int64(0,101)),new T.ptr(new $Int64(0,499),new $Int64(0,140)),new T.ptr(new $Int64(0,503),new $Int64(0,140)),new T.ptr(new $Int64(0,509),new $Int64(0,127)),new T.ptr(new $Int64(0,521),new $Int64(0,106)),new T.ptr(new $Int64(0,523),new $Int64(0,483)),new T.ptr(new $Int64(0,541),new $Int64(0,511)),new T.ptr(new $Int64(0,547),new $Int64(0,455)),new T.ptr(new $Int64(0,557),new $Int64(0,293)),new T.ptr(new $Int64(0,563),new $Int64(0,549)),new T.ptr(new $Int64(0,569),new $Int64(0,28)),new T.ptr(new $Int64(0,571),new $Int64(0,242)),new T.ptr(new $Int64(0,577),new $Int64(0,172)),new T.ptr(new $Int64(0,587),new $Int64(0,172)),new T.ptr(new $Int64(0,593),new $Int64(0,87)),new T.ptr(new $Int64(0,599),new $Int64(0,526)),new T.ptr(new $Int64(0,601),new $Int64(0,308)),new T.ptr(new $Int64(0,607),new $Int64(0,561)),new T.ptr(new $Int64(0,613),new $Int64(0,197)),new T.ptr(new $Int64(0,617),new $Int64(0,405)),new T.ptr(new $Int64(0,619),new $Int64(0,528)),new T.ptr(new $Int64(0,631),new $Int64(0,107)),new T.ptr(new $Int64(0,641),new $Int64(0,603)),new T.ptr(new $Int64(0,643),new $Int64(0,457)),new T.ptr(new $Int64(0,647),new $Int64(0,102)),new T.ptr(new $Int64(0,653),new $Int64(0,102)),new T.ptr(new $Int64(0,659),new $Int64(0,554)),new T.ptr(new $Int64(0,661),new $Int64(0,69)),new T.ptr(new $Int64(0,673),new $Int64(0,64)),new T.ptr(new $Int64(0,677),new $Int64(0,114)),new T.ptr(new $Int64(0,683),new $Int64(0,520)),new T.ptr(new $Int64(0,691),new $Int64(0,297)),new T.ptr(new $Int64(0,701),new $Int64(0,442)),new T.ptr(new $Int64(0,709),new $Int64(0,396)),new T.ptr(new $Int64(0,719),new $Int64(0,153)),new T.ptr(new $Int64(0,727),new $Int64(0,141)),new T.ptr(new $Int64(0,733),new $Int64(0,486)),new T.ptr(new $Int64(0,739),new $Int64(0,307)),new T.ptr(new $Int64(0,743),new $Int64(0,595)),new T.ptr(new $Int64(0,751),new $Int64(0,582)),new T.ptr(new $Int64(0,757),new $Int64(0,676)),new T.ptr(new $Int64(0,761),new $Int64(0,316)),new T.ptr(new $Int64(0,769),new $Int64(0,350)),new T.ptr(new $Int64(0,773),new $Int64(0,147)),new T.ptr(new $Int64(0,787),new $Int64(0,668)),new T.ptr(new $Int64(0,797),new $Int64(0,639)),new T.ptr(new $Int64(0,809),new $Int64(0,98)),new T.ptr(new $Int64(0,811),new $Int64(0,573)),new T.ptr(new $Int64(0,821),new $Int64(0,320)),new T.ptr(new $Int64(0,823),new $Int64(0,758)),new T.ptr(new $Int64(0,827),new $Int64(0,472)),new T.ptr(new $Int64(0,829),new $Int64(0,39)),new T.ptr(new $Int64(0,839),new $Int64(0,751)),new T.ptr(new $Int64(0,853),new $Int64(0,223)),new T.ptr(new $Int64(0,857),new $Int64(0,655)),new T.ptr(new $Int64(0,859),new $Int64(0,362)),new T.ptr(new $Int64(0,863),new $Int64(0,773)),new T.ptr(new $Int64(0,877),new $Int64(0,756)),new T.ptr(new $Int64(0,881),new $Int64(0,739)),new T.ptr(new $Int64(0,883),new $Int64(0,138)),new T.ptr(new $Int64(0,887),new $Int64(0,123)),new T.ptr(new $Int64(0,907),new $Int64(0,836)),new T.ptr(new $Int64(0,911),new $Int64(0,490)),new T.ptr(new $Int64(0,919),new $Int64(0,878)),new T.ptr(new $Int64(0,929),new $Int64(0,313)),new T.ptr(new $Int64(0,937),new $Int64(0,606)),new T.ptr(new $Int64(0,941),new $Int64(0,175)),new T.ptr(new $Int64(0,947),new $Int64(0,286)),new T.ptr(new $Int64(0,953),new $Int64(0,295)),new T.ptr(new $Int64(0,967),new $Int64(0,260)),new T.ptr(new $Int64(0,971),new $Int64(0,612)),new T.ptr(new $Int64(0,977),new $Int64(0,613)),new T.ptr(new $Int64(0,983),new $Int64(0,907)),new T.ptr(new $Int64(0,991),new $Int64(0,569)),new T.ptr(new $Int64(0,997),new $Int64(0,970)),new T.ptr(new $Int64(0,1009),new $Int64(0,556)),new T.ptr(new $Int64(0,1013),new $Int64(0,223)),new T.ptr(new $Int64(0,1019),new $Int64(0,877)),new T.ptr(new $Int64(0,1021),new $Int64(0,77)),new T.ptr(new $Int64(0,1031),new $Int64(0,364)),new T.ptr(new $Int64(0,1033),new $Int64(0,704)),new T.ptr(new $Int64(0,1039),new $Int64(0,18)),new T.ptr(new $Int64(0,1049),new $Int64(0,497)),new T.ptr(new $Int64(0,1051),new $Int64(0,79)),new T.ptr(new $Int64(0,1061),new $Int64(0,846)),new T.ptr(new $Int64(0,1063),new $Int64(0,1)),new T.ptr(new $Int64(0,1069),new $Int64(0,30)),new T.ptr(new $Int64(0,1087),new $Int64(0,251)),new T.ptr(new $Int64(0,1091),new $Int64(0,486)),new T.ptr(new $Int64(0,1093),new $Int64(0,467)),new T.ptr(new $Int64(0,1097),new $Int64(0,365)),new T.ptr(new $Int64(0,1103),new $Int64(0,134)),new T.ptr(new $Int64(0,1109),new $Int64(0,290)),new T.ptr(new $Int64(0,1117),new $Int64(0,184)),new T.ptr(new $Int64(0,1123),new $Int64(0,493)),new T.ptr(new $Int64(0,1129),new $Int64(0,524)),new T.ptr(new $Int64(0,1151),new $Int64(0,534)),new T.ptr(new $Int64(0,1153),new $Int64(0,704)),new T.ptr(new $Int64(0,1163),new $Int64(0,1033)),new T.ptr(new $Int64(0,1171),new $Int64(0,19)),new T.ptr(new $Int64(0,1181),new $Int64(0,701)),new T.ptr(new $Int64(0,1187),new $Int64(0,917)),new T.ptr(new $Int64(0,1193),new $Int64(0,790)),new T.ptr(new $Int64(0,1201),new $Int64(0,1141)),new T.ptr(new $Int64(0,1213),new $Int64(0,1066)),new T.ptr(new $Int64(0,1217),new $Int64(0,580)),new T.ptr(new $Int64(0,1223),new $Int64(0,823)),new T.ptr(new $Int64(0,1229),new $Int64(0,729)),new T.ptr(new $Int64(0,1231),new $Int64(0,1029)),new T.ptr(new $Int64(0,1237),new $Int64(0,661)),new T.ptr(new $Int64(0,1249),new $Int64(0,133)),new T.ptr(new $Int64(0,1259),new $Int64(0,1237)),new T.ptr(new $Int64(0,1277),new $Int64(0,1168)),new T.ptr(new $Int64(0,1279),new $Int64(0,1098)),new T.ptr(new $Int64(0,1283),new $Int64(0,732)),new T.ptr(new $Int64(0,1289),new $Int64(0,1167)),new T.ptr(new $Int64(0,1291),new $Int64(0,453)),new T.ptr(new $Int64(0,1297),new $Int64(0,787)),new T.ptr(new $Int64(0,1301),new $Int64(0,459)),new T.ptr(new $Int64(0,1303),new $Int64(0,518)),new T.ptr(new $Int64(0,1307),new $Int64(0,917)),new T.ptr(new $Int64(0,1319),new $Int64(0,29)),new T.ptr(new $Int64(0,1321),new $Int64(0,450)),new T.ptr(new $Int64(0,1327),new $Int64(0,1302)),new T.ptr(new $Int64(0,1361),new $Int64(0,58)),new T.ptr(new $Int64(0,1367),new $Int64(0,800)),new T.ptr(new $Int64(0,1373),new $Int64(0,353)),new T.ptr(new $Int64(0,1381),new $Int64(0,358)),new T.ptr(new $Int64(0,1399),new $Int64(0,512)),new T.ptr(new $Int64(0,1409),new $Int64(0,897)),new T.ptr(new $Int64(0,1423),new $Int64(0,651)),new T.ptr(new $Int64(0,1427),new $Int64(0,957)),new T.ptr(new $Int64(0,1429),new $Int64(0,1412)),new T.ptr(new $Int64(0,1433),new $Int64(0,1052)),new T.ptr(new $Int64(0,1439),new $Int64(0,1163)),new T.ptr(new $Int64(0,1447),new $Int64(0,457)),new T.ptr(new $Int64(0,1451),new $Int64(0,700)),new T.ptr(new $Int64(0,1453),new $Int64(0,91)),new T.ptr(new $Int64(0,1459),new $Int64(0,112)),new T.ptr(new $Int64(0,1471),new $Int64(0,126)),new T.ptr(new $Int64(0,1481),new $Int64(0,1155)),new T.ptr(new $Int64(0,1483),new $Int64(0,494)),new T.ptr(new $Int64(0,1487),new $Int64(0,432)),new T.ptr(new $Int64(0,1489),new $Int64(0,880)),new T.ptr(new $Int64(0,1493),new $Int64(0,797)),new T.ptr(new $Int64(0,1499),new $Int64(0,757)),new T.ptr(new $Int64(0,1511),new $Int64(0,1175)),new T.ptr(new $Int64(0,1523),new $Int64(0,201)),new T.ptr(new $Int64(0,1531),new $Int64(0,1097)),new T.ptr(new $Int64(0,1543),new $Int64(0,877)),new T.ptr(new $Int64(0,1549),new $Int64(0,876)),new T.ptr(new $Int64(0,1553),new $Int64(0,1092)),new T.ptr(new $Int64(0,1559),new $Int64(0,81)),new T.ptr(new $Int64(0,1567),new $Int64(0,282)),new T.ptr(new $Int64(0,1571),new $Int64(0,1009)),new T.ptr(new $Int64(0,1579),new $Int64(0,667)),new T.ptr(new $Int64(0,1583),new $Int64(0,1002)),new T.ptr(new $Int64(0,1597),new $Int64(0,287)),new T.ptr(new $Int64(0,1601),new $Int64(0,676)),new T.ptr(new $Int64(0,1607),new $Int64(0,865)),new T.ptr(new $Int64(0,1609),new $Int64(0,316)),new T.ptr(new $Int64(0,1613),new $Int64(0,1164)),new T.ptr(new $Int64(0,1619),new $Int64(0,892)),new T.ptr(new $Int64(0,1621),new $Int64(0,1455)),new T.ptr(new $Int64(0,1627),new $Int64(0,357)),new T.ptr(new $Int64(0,1637),new $Int64(0,1198)),new T.ptr(new $Int64(0,1657),new $Int64(0,729)),new T.ptr(new $Int64(0,1663),new $Int64(0,1113)),new T.ptr(new $Int64(0,1667),new $Int64(0,1476)),new T.ptr(new $Int64(0,1669),new $Int64(0,452)),new T.ptr(new $Int64(0,1693),new $Int64(0,1591)),new T.ptr(new $Int64(0,1697),new $Int64(0,1119)),new T.ptr(new $Int64(0,1699),new $Int64(0,1215)),new T.ptr(new $Int64(0,1709),new $Int64(0,143)),new T.ptr(new $Int64(0,1721),new $Int64(0,890)),new T.ptr(new $Int64(0,1723),new $Int64(0,1185)),new T.ptr(new $Int64(0,1733),new $Int64(0,1583)),new T.ptr(new $Int64(0,1741),new $Int64(0,1354)),new T.ptr(new $Int64(0,1747),new $Int64(0,413)),new T.ptr(new $Int64(0,1753),new $Int64(0,932)),new T.ptr(new $Int64(0,1759),new $Int64(0,1250)),new T.ptr(new $Int64(0,1777),new $Int64(0,1025)),new T.ptr(new $Int64(0,1783),new $Int64(0,1204)),new T.ptr(new $Int64(0,1787),new $Int64(0,1202)),new T.ptr(new $Int64(0,1789),new $Int64(0,1253)),new T.ptr(new $Int64(0,1801),new $Int64(0,1317)),new T.ptr(new $Int64(0,1811),new $Int64(0,1686)),new T.ptr(new $Int64(0,1823),new $Int64(0,267)),new T.ptr(new $Int64(0,1831),new $Int64(0,744)),new T.ptr(new $Int64(0,1847),new $Int64(0,341)),new T.ptr(new $Int64(0,1861),new $Int64(0,1676)),new T.ptr(new $Int64(0,1867),new $Int64(0,322)),new T.ptr(new $Int64(0,1871),new $Int64(0,1040)),new T.ptr(new $Int64(0,1873),new $Int64(0,1080)),new T.ptr(new $Int64(0,1877),new $Int64(0,1173)),new T.ptr(new $Int64(0,1879),new $Int64(0,1202)),new T.ptr(new $Int64(0,1889),new $Int64(0,1463)),new T.ptr(new $Int64(0,1901),new $Int64(0,213)),new T.ptr(new $Int64(0,1907),new $Int64(0,454)),new T.ptr(new $Int64(0,1913),new $Int64(0,1563)),new T.ptr(new $Int64(0,1931),new $Int64(0,131)),new T.ptr(new $Int64(0,1933),new $Int64(0,515)),new T.ptr(new $Int64(0,1949),new $Int64(0,19)),new T.ptr(new $Int64(0,1951),new $Int64(0,95)),new T.ptr(new $Int64(0,1973),new $Int64(0,525)),new T.ptr(new $Int64(0,1979),new $Int64(0,1120)),new T.ptr(new $Int64(0,1987),new $Int64(0,170)),new T.ptr(new $Int64(0,1993),new $Int64(0,1635)),new T.ptr(new $Int64(0,1997),new $Int64(0,446)),new T.ptr(new $Int64(0,1999),new $Int64(0,1788)),new T.ptr(new $Int64(0,2003),new $Int64(0,1569)),new T.ptr(new $Int64(0,2011),new $Int64(0,1903)),new T.ptr(new $Int64(0,2017),new $Int64(0,567)),new T.ptr(new $Int64(0,2027),new $Int64(0,1977)),new T.ptr(new $Int64(0,2029),new $Int64(0,888)),new T.ptr(new $Int64(0,2039),new $Int64(0,1487)),new T.ptr(new $Int64(0,2053),new $Int64(0,1474)),new T.ptr(new $Int64(0,2063),new $Int64(0,1244)),new T.ptr(new $Int64(0,2069),new $Int64(0,1806)),new T.ptr(new $Int64(0,2081),new $Int64(0,18)),new T.ptr(new $Int64(0,2083),new $Int64(0,3)),new T.ptr(new $Int64(0,2087),new $Int64(0,746)),new T.ptr(new $Int64(0,2089),new $Int64(0,836)),new T.ptr(new $Int64(0,2099),new $Int64(0,2077)),new T.ptr(new $Int64(0,2111),new $Int64(0,1030)),new T.ptr(new $Int64(0,2113),new $Int64(0,678)),new T.ptr(new $Int64(0,2129),new $Int64(0,796)),new T.ptr(new $Int64(0,2131),new $Int64(0,405)),new T.ptr(new $Int64(0,2137),new $Int64(0,415)),new T.ptr(new $Int64(0,2141),new $Int64(0,411)),new T.ptr(new $Int64(0,2143),new $Int64(0,1856)),new T.ptr(new $Int64(0,2153),new $Int64(0,1658)),new T.ptr(new $Int64(0,2161),new $Int64(0,41)),new T.ptr(new $Int64(0,2179),new $Int64(0,1038)),new T.ptr(new $Int64(0,2203),new $Int64(0,78)),new T.ptr(new $Int64(0,2207),new $Int64(0,2125)),new T.ptr(new $Int64(0,2213),new $Int64(0,863)),new T.ptr(new $Int64(0,2221),new $Int64(0,203)),new T.ptr(new $Int64(0,2237),new $Int64(0,551)),new T.ptr(new $Int64(0,2239),new $Int64(0,1524)),new T.ptr(new $Int64(0,2243),new $Int64(0,1999)),new T.ptr(new $Int64(0,2251),new $Int64(0,529)),new T.ptr(new $Int64(0,2267),new $Int64(0,585)),new T.ptr(new $Int64(0,2269),new $Int64(0,2004)),new T.ptr(new $Int64(0,2273),new $Int64(0,254)),new T.ptr(new $Int64(0,2281),new $Int64(0,180)),new T.ptr(new $Int64(0,2287),new $Int64(0,1394)),new T.ptr(new $Int64(0,2293),new $Int64(0,1699)),new T.ptr(new $Int64(0,2297),new $Int64(0,1315)),new T.ptr(new $Int64(0,2309),new $Int64(0,2087)),new T.ptr(new $Int64(0,2311),new $Int64(0,1911)),new T.ptr(new $Int64(0,2333),new $Int64(0,1898)),new T.ptr(new $Int64(0,2339),new $Int64(0,805)),new T.ptr(new $Int64(0,2341),new $Int64(0,228)),new T.ptr(new $Int64(0,2347),new $Int64(0,2175)),new T.ptr(new $Int64(0,2351),new $Int64(0,365)),new T.ptr(new $Int64(0,2357),new $Int64(0,298)),new T.ptr(new $Int64(0,2371),new $Int64(0,74)),new T.ptr(new $Int64(0,2377),new $Int64(0,350)),new T.ptr(new $Int64(0,2381),new $Int64(0,2134)),new T.ptr(new $Int64(0,2383),new $Int64(0,2071)),new T.ptr(new $Int64(0,2389),new $Int64(0,2036)),new T.ptr(new $Int64(0,2393),new $Int64(0,779)),new T.ptr(new $Int64(0,2399),new $Int64(0,2272)),new T.ptr(new $Int64(0,2411),new $Int64(0,1127)),new T.ptr(new $Int64(0,2417),new $Int64(0,937)),new T.ptr(new $Int64(0,2423),new $Int64(0,534)),new T.ptr(new $Int64(0,2437),new $Int64(0,455)),new T.ptr(new $Int64(0,2441),new $Int64(0,621)),new T.ptr(new $Int64(0,2447),new $Int64(0,530)),new T.ptr(new $Int64(0,2459),new $Int64(0,1372)),new T.ptr(new $Int64(0,2467),new $Int64(0,2370)),new T.ptr(new $Int64(0,2473),new $Int64(0,124)),new T.ptr(new $Int64(0,2477),new $Int64(0,427)),new T.ptr(new $Int64(0,2503),new $Int64(0,730)),new T.ptr(new $Int64(0,2521),new $Int64(0,1093)),new T.ptr(new $Int64(0,2531),new $Int64(0,642)),new T.ptr(new $Int64(0,2539),new $Int64(0,271)),new T.ptr(new $Int64(0,2543),new $Int64(0,1851)),new T.ptr(new $Int64(0,2549),new $Int64(0,1568)),new T.ptr(new $Int64(0,2551),new $Int64(0,1796)),new T.ptr(new $Int64(0,2557),new $Int64(0,130)),new T.ptr(new $Int64(0,2579),new $Int64(0,210)),new T.ptr(new $Int64(0,2591),new $Int64(0,1756)),new T.ptr(new $Int64(0,2593),new $Int64(0,1161)),new T.ptr(new $Int64(0,2609),new $Int64(0,1846)),new T.ptr(new $Int64(0,2617),new $Int64(0,869)),new T.ptr(new $Int64(0,2621),new $Int64(0,2192)),new T.ptr(new $Int64(0,2633),new $Int64(0,2509)),new T.ptr(new $Int64(0,2647),new $Int64(0,1230)),new T.ptr(new $Int64(0,2657),new $Int64(0,608)),new T.ptr(new $Int64(0,2659),new $Int64(0,406)),new T.ptr(new $Int64(0,2663),new $Int64(0,2364)),new T.ptr(new $Int64(0,2671),new $Int64(0,1104)),new T.ptr(new $Int64(0,2677),new $Int64(0,1032)),new T.ptr(new $Int64(0,2683),new $Int64(0,1143)),new T.ptr(new $Int64(0,2687),new $Int64(0,1041)),new T.ptr(new $Int64(0,2689),new $Int64(0,2610)),new T.ptr(new $Int64(0,2693),new $Int64(0,574)),new T.ptr(new $Int64(0,2699),new $Int64(0,2606)),new T.ptr(new $Int64(0,2707),new $Int64(0,2057)),new T.ptr(new $Int64(0,2711),new $Int64(0,1469)),new T.ptr(new $Int64(0,2713),new $Int64(0,1128)),new T.ptr(new $Int64(0,2719),new $Int64(0,1264)),new T.ptr(new $Int64(0,2729),new $Int64(0,2667)),new T.ptr(new $Int64(0,2731),new $Int64(0,931)),new T.ptr(new $Int64(0,2741),new $Int64(0,1093)),new T.ptr(new $Int64(0,2749),new $Int64(0,2384)),new T.ptr(new $Int64(0,2753),new $Int64(0,1537)),new T.ptr(new $Int64(0,2767),new $Int64(0,2303)),new T.ptr(new $Int64(0,2777),new $Int64(0,2730)),new T.ptr(new $Int64(0,2789),new $Int64(0,1763)),new T.ptr(new $Int64(0,2791),new $Int64(0,2478)),new T.ptr(new $Int64(0,2797),new $Int64(0,1204)),new T.ptr(new $Int64(0,2801),new $Int64(0,2246)),new T.ptr(new $Int64(0,2803),new $Int64(0,2289)),new T.ptr(new $Int64(0,2819),new $Int64(0,866)),new T.ptr(new $Int64(0,2833),new $Int64(0,2126)),new T.ptr(new $Int64(0,2837),new $Int64(0,2558)),new T.ptr(new $Int64(0,2843),new $Int64(0,219)),new T.ptr(new $Int64(0,2851),new $Int64(0,445)),new T.ptr(new $Int64(0,2857),new $Int64(0,1882)),new T.ptr(new $Int64(0,2861),new $Int64(0,1158)),new T.ptr(new $Int64(0,2879),new $Int64(0,1858)),new T.ptr(new $Int64(0,2887),new $Int64(0,583)),new T.ptr(new $Int64(0,2897),new $Int64(0,1016)),new T.ptr(new $Int64(0,2903),new $Int64(0,1040)),new T.ptr(new $Int64(0,2909),new $Int64(0,2051)),new T.ptr(new $Int64(0,2917),new $Int64(0,396)),new T.ptr(new $Int64(0,2927),new $Int64(0,1865)),new T.ptr(new $Int64(0,2939),new $Int64(0,1264)),new T.ptr(new $Int64(0,2953),new $Int64(0,2042)),new T.ptr(new $Int64(0,2957),new $Int64(0,2229)),new T.ptr(new $Int64(0,2963),new $Int64(0,2913)),new T.ptr(new $Int64(0,2969),new $Int64(0,155)),new T.ptr(new $Int64(0,2971),new $Int64(0,253)),new T.ptr(new $Int64(0,2999),new $Int64(0,2268)),new T.ptr(new $Int64(0,3001),new $Int64(0,1463)),new T.ptr(new $Int64(0,3011),new $Int64(0,1609)),new T.ptr(new $Int64(0,3019),new $Int64(0,467)),new T.ptr(new $Int64(0,3023),new $Int64(0,2596)),new T.ptr(new $Int64(0,3037),new $Int64(0,297)),new T.ptr(new $Int64(0,3041),new $Int64(0,2)),new T.ptr(new $Int64(0,3049),new $Int64(0,1208)),new T.ptr(new $Int64(0,3061),new $Int64(0,1136)),new T.ptr(new $Int64(0,3067),new $Int64(0,2208)),new T.ptr(new $Int64(0,3079),new $Int64(0,1579)),new T.ptr(new $Int64(0,3083),new $Int64(0,527)),new T.ptr(new $Int64(0,3089),new $Int64(0,44)),new T.ptr(new $Int64(0,3109),new $Int64(0,2485)),new T.ptr(new $Int64(0,3119),new $Int64(0,2957)),new T.ptr(new $Int64(0,3121),new $Int64(0,1905)),new T.ptr(new $Int64(0,3137),new $Int64(0,2454)),new T.ptr(new $Int64(0,3163),new $Int64(0,1496)),new T.ptr(new $Int64(0,3167),new $Int64(0,2116)),new T.ptr(new $Int64(0,3169),new $Int64(0,787)),new T.ptr(new $Int64(0,3181),new $Int64(0,2690)),new T.ptr(new $Int64(0,3187),new $Int64(0,2686)),new T.ptr(new $Int64(0,3191),new $Int64(0,1388)),new T.ptr(new $Int64(0,3203),new $Int64(0,2349)),new T.ptr(new $Int64(0,3209),new $Int64(0,2309)),new T.ptr(new $Int64(0,3217),new $Int64(0,1666)),new T.ptr(new $Int64(0,3221),new $Int64(0,1175)),new T.ptr(new $Int64(0,3229),new $Int64(0,539)),new T.ptr(new $Int64(0,3251),new $Int64(0,292)),new T.ptr(new $Int64(0,3253),new $Int64(0,3226)),new T.ptr(new $Int64(0,3257),new $Int64(0,921)),new T.ptr(new $Int64(0,3259),new $Int64(0,1992)),new T.ptr(new $Int64(0,3271),new $Int64(0,339)),new T.ptr(new $Int64(0,3299),new $Int64(0,1287)),new T.ptr(new $Int64(0,3301),new $Int64(0,1324)),new T.ptr(new $Int64(0,3307),new $Int64(0,610)),new T.ptr(new $Int64(0,3313),new $Int64(0,1116)),new T.ptr(new $Int64(0,3319),new $Int64(0,2531)),new T.ptr(new $Int64(0,3323),new $Int64(0,412)),new T.ptr(new $Int64(0,3329),new $Int64(0,2545)),new T.ptr(new $Int64(0,3331),new $Int64(0,2237)),new T.ptr(new $Int64(0,3343),new $Int64(0,2214)),new T.ptr(new $Int64(0,3347),new $Int64(0,3338)),new T.ptr(new $Int64(0,3359),new $Int64(0,2302)),new T.ptr(new $Int64(0,3361),new $Int64(0,188)),new T.ptr(new $Int64(0,3371),new $Int64(0,30)),new T.ptr(new $Int64(0,3373),new $Int64(0,2014)),new T.ptr(new $Int64(0,3389),new $Int64(0,2772)),new T.ptr(new $Int64(0,3391),new $Int64(0,1510)),new T.ptr(new $Int64(0,3407),new $Int64(0,806)),new T.ptr(new $Int64(0,3413),new $Int64(0,349)),new T.ptr(new $Int64(0,3433),new $Int64(0,1177)),new T.ptr(new $Int64(0,3449),new $Int64(0,342)),new T.ptr(new $Int64(0,3457),new $Int64(0,1849)),new T.ptr(new $Int64(0,3461),new $Int64(0,208)),new T.ptr(new $Int64(0,3463),new $Int64(0,2847)),new T.ptr(new $Int64(0,3467),new $Int64(0,150)),new T.ptr(new $Int64(0,3469),new $Int64(0,1993)),new T.ptr(new $Int64(0,3491),new $Int64(0,2005)),new T.ptr(new $Int64(0,3499),new $Int64(0,1513)),new T.ptr(new $Int64(0,3511),new $Int64(0,2998)),new T.ptr(new $Int64(0,3517),new $Int64(0,3225)),new T.ptr(new $Int64(0,3527),new $Int64(0,2427)),new T.ptr(new $Int64(0,3529),new $Int64(0,3450)),new T.ptr(new $Int64(0,3533),new $Int64(0,1766)),new T.ptr(new $Int64(0,3539),new $Int64(0,670)),new T.ptr(new $Int64(0,3541),new $Int64(0,168)),new T.ptr(new $Int64(0,3547),new $Int64(0,2100)),new T.ptr(new $Int64(0,3557),new $Int64(0,2596)),new T.ptr(new $Int64(0,3559),new $Int64(0,3322)),new T.ptr(new $Int64(0,3571),new $Int64(0,643)),new T.ptr(new $Int64(0,3581),new $Int64(0,1453)),new T.ptr(new $Int64(0,3583),new $Int64(0,1181)),new T.ptr(new $Int64(0,3593),new $Int64(0,2810)),new T.ptr(new $Int64(0,3607),new $Int64(0,732)),new T.ptr(new $Int64(0,3613),new $Int64(0,811)),new T.ptr(new $Int64(0,3617),new $Int64(0,1077)),new T.ptr(new $Int64(0,3623),new $Int64(0,2467)),new T.ptr(new $Int64(0,3631),new $Int64(0,2005)),new T.ptr(new $Int64(0,3637),new $Int64(0,2939)),new T.ptr(new $Int64(0,3643),new $Int64(0,3459)),new T.ptr(new $Int64(0,3659),new $Int64(0,817)),new T.ptr(new $Int64(0,3671),new $Int64(0,933)),new T.ptr(new $Int64(0,3673),new $Int64(0,2705)),new T.ptr(new $Int64(0,3677),new $Int64(0,2364)),new T.ptr(new $Int64(0,3691),new $Int64(0,318)),new T.ptr(new $Int64(0,3697),new $Int64(0,910)),new T.ptr(new $Int64(0,3701),new $Int64(0,2585)),new T.ptr(new $Int64(0,3709),new $Int64(0,2142)),new T.ptr(new $Int64(0,3719),new $Int64(0,2010)),new T.ptr(new $Int64(0,3727),new $Int64(0,492)),new T.ptr(new $Int64(0,3733),new $Int64(0,1636)),new T.ptr(new $Int64(0,3739),new $Int64(0,3335)),new T.ptr(new $Int64(0,3761),new $Int64(0,2610)),new T.ptr(new $Int64(0,3767),new $Int64(0,1768)),new T.ptr(new $Int64(0,3769),new $Int64(0,3406)),new T.ptr(new $Int64(0,3779),new $Int64(0,1361)),new T.ptr(new $Int64(0,3793),new $Int64(0,607)),new T.ptr(new $Int64(0,3797),new $Int64(0,738)),new T.ptr(new $Int64(0,3803),new $Int64(0,1957)),new T.ptr(new $Int64(0,3821),new $Int64(0,2310)),new T.ptr(new $Int64(0,3823),new $Int64(0,1199)),new T.ptr(new $Int64(0,3833),new $Int64(0,727)),new T.ptr(new $Int64(0,3847),new $Int64(0,896)),new T.ptr(new $Int64(0,3851),new $Int64(0,469)),new T.ptr(new $Int64(0,3853),new $Int64(0,3005)),new T.ptr(new $Int64(0,3863),new $Int64(0,2642)),new T.ptr(new $Int64(0,3877),new $Int64(0,3009)),new T.ptr(new $Int64(0,3881),new $Int64(0,2418)),new T.ptr(new $Int64(0,3889),new $Int64(0,1568)),new T.ptr(new $Int64(0,3907),new $Int64(0,627)),new T.ptr(new $Int64(0,3911),new $Int64(0,1877)),new T.ptr(new $Int64(0,3917),new $Int64(0,2937)),new T.ptr(new $Int64(0,3919),new $Int64(0,3106)),new T.ptr(new $Int64(0,3923),new $Int64(0,2152)),new T.ptr(new $Int64(0,3929),new $Int64(0,578)),new T.ptr(new $Int64(0,3931),new $Int64(0,429)),new T.ptr(new $Int64(0,3943),new $Int64(0,3734)),new T.ptr(new $Int64(0,3947),new $Int64(0,2509)),new T.ptr(new $Int64(0,3967),new $Int64(0,1669)),new T.ptr(new $Int64(0,3989),new $Int64(0,3466)),new T.ptr(new $Int64(0,4001),new $Int64(0,3512)),new T.ptr(new $Int64(0,4003),new $Int64(0,3069)),new T.ptr(new $Int64(0,4007),new $Int64(0,1024)),new T.ptr(new $Int64(0,4013),new $Int64(0,2928)),new T.ptr(new $Int64(0,4019),new $Int64(0,259)),new T.ptr(new $Int64(0,4021),new $Int64(0,954)),new T.ptr(new $Int64(0,4027),new $Int64(0,2352)),new T.ptr(new $Int64(0,4049),new $Int64(0,4046)),new T.ptr(new $Int64(0,4051),new $Int64(0,2761)),new T.ptr(new $Int64(0,4057),new $Int64(0,569)),new T.ptr(new $Int64(0,4073),new $Int64(0,1155)),new T.ptr(new $Int64(0,4079),new $Int64(0,3207)),new T.ptr(new $Int64(0,4091),new $Int64(0,1569)),new T.ptr(new $Int64(0,4093),new $Int64(0,3000)),new T.ptr(new $Int64(0,4099),new $Int64(0,3738)),new T.ptr(new $Int64(0,4111),new $Int64(0,1346)),new T.ptr(new $Int64(0,4127),new $Int64(0,2106)),new T.ptr(new $Int64(0,4129),new $Int64(0,2168)),new T.ptr(new $Int64(0,4133),new $Int64(0,4023)),new T.ptr(new $Int64(0,4139),new $Int64(0,4046)),new T.ptr(new $Int64(0,4153),new $Int64(0,1428)),new T.ptr(new $Int64(0,4157),new $Int64(0,48)),new T.ptr(new $Int64(0,4159),new $Int64(0,4015)),new T.ptr(new $Int64(0,4177),new $Int64(0,1604)),new T.ptr(new $Int64(0,4201),new $Int64(0,1792)),new T.ptr(new $Int64(0,4211),new $Int64(0,3954)),new T.ptr(new $Int64(0,4217),new $Int64(0,1896)),new T.ptr(new $Int64(0,4219),new $Int64(0,2014)),new T.ptr(new $Int64(0,4229),new $Int64(0,2424)),new T.ptr(new $Int64(0,4231),new $Int64(0,1529)),new T.ptr(new $Int64(0,4241),new $Int64(0,2816)),new T.ptr(new $Int64(0,4243),new $Int64(0,2028)),new T.ptr(new $Int64(0,4253),new $Int64(0,78)),new T.ptr(new $Int64(0,4259),new $Int64(0,3891)),new T.ptr(new $Int64(0,4261),new $Int64(0,3731)),new T.ptr(new $Int64(0,4271),new $Int64(0,3701)),new T.ptr(new $Int64(0,4273),new $Int64(0,2720)),new T.ptr(new $Int64(0,4283),new $Int64(0,3693)),new T.ptr(new $Int64(0,4289),new $Int64(0,1685)),new T.ptr(new $Int64(0,4297),new $Int64(0,285)),new T.ptr(new $Int64(0,4327),new $Int64(0,1466)),new T.ptr(new $Int64(0,4337),new $Int64(0,3813)),new T.ptr(new $Int64(0,4339),new $Int64(0,1148)),new T.ptr(new $Int64(0,4349),new $Int64(0,3088)),new T.ptr(new $Int64(0,4357),new $Int64(0,857)),new T.ptr(new $Int64(0,4363),new $Int64(0,2713)),new T.ptr(new $Int64(0,4373),new $Int64(0,3562)),new T.ptr(new $Int64(0,4391),new $Int64(0,3669)),new T.ptr(new $Int64(0,4397),new $Int64(0,4193)),new T.ptr(new $Int64(0,4409),new $Int64(0,4278)),new T.ptr(new $Int64(0,4421),new $Int64(0,1732)),new T.ptr(new $Int64(0,4423),new $Int64(0,4056)),new T.ptr(new $Int64(0,4441),new $Int64(0,417)),new T.ptr(new $Int64(0,4447),new $Int64(0,436)),new T.ptr(new $Int64(0,4451),new $Int64(0,1796)),new T.ptr(new $Int64(0,4457),new $Int64(0,2605)),new T.ptr(new $Int64(0,4463),new $Int64(0,4381)),new T.ptr(new $Int64(0,4481),new $Int64(0,1995)),new T.ptr(new $Int64(0,4483),new $Int64(0,1874)),new T.ptr(new $Int64(0,4493),new $Int64(0,630)),new T.ptr(new $Int64(0,4507),new $Int64(0,2907)),new T.ptr(new $Int64(0,4513),new $Int64(0,73)),new T.ptr(new $Int64(0,4517),new $Int64(0,2525)),new T.ptr(new $Int64(0,4519),new $Int64(0,3884)),new T.ptr(new $Int64(0,4523),new $Int64(0,981)),new T.ptr(new $Int64(0,4547),new $Int64(0,333)),new T.ptr(new $Int64(0,4549),new $Int64(0,2309)),new T.ptr(new $Int64(0,4561),new $Int64(0,1335)),new T.ptr(new $Int64(0,4567),new $Int64(0,1561)),new T.ptr(new $Int64(0,4583),new $Int64(0,424)),new T.ptr(new $Int64(0,4591),new $Int64(0,274)),new T.ptr(new $Int64(0,4597),new $Int64(0,2360)),new T.ptr(new $Int64(0,4603),new $Int64(0,2968)),new T.ptr(new $Int64(0,4621),new $Int64(0,1955)),new T.ptr(new $Int64(0,4637),new $Int64(0,577)),new T.ptr(new $Int64(0,4639),new $Int64(0,2620)),new T.ptr(new $Int64(0,4643),new $Int64(0,3688)),new T.ptr(new $Int64(0,4649),new $Int64(0,1153)),new T.ptr(new $Int64(0,4651),new $Int64(0,4299)),new T.ptr(new $Int64(0,4657),new $Int64(0,2435)),new T.ptr(new $Int64(0,4663),new $Int64(0,2832)),new T.ptr(new $Int64(0,4673),new $Int64(0,919)),new T.ptr(new $Int64(0,4679),new $Int64(0,790)),new T.ptr(new $Int64(0,4691),new $Int64(0,4475)),new T.ptr(new $Int64(0,4703),new $Int64(0,717)),new T.ptr(new $Int64(0,4721),new $Int64(0,2116)),new T.ptr(new $Int64(0,4723),new $Int64(0,4626)),new T.ptr(new $Int64(0,4729),new $Int64(0,1113)),new T.ptr(new $Int64(0,4733),new $Int64(0,588)),new T.ptr(new $Int64(0,4751),new $Int64(0,4041)),new T.ptr(new $Int64(0,4759),new $Int64(0,1542)),new T.ptr(new $Int64(0,4783),new $Int64(0,4195)),new T.ptr(new $Int64(0,4787),new $Int64(0,3679)),new T.ptr(new $Int64(0,4789),new $Int64(0,3225)),new T.ptr(new $Int64(0,4793),new $Int64(0,3217)),new T.ptr(new $Int64(0,4799),new $Int64(0,1026)),new T.ptr(new $Int64(0,4801),new $Int64(0,2729)),new T.ptr(new $Int64(0,4813),new $Int64(0,4273)),new T.ptr(new $Int64(0,4817),new $Int64(0,3364)),new T.ptr(new $Int64(0,4831),new $Int64(0,1630)),new T.ptr(new $Int64(0,4861),new $Int64(0,2581)),new T.ptr(new $Int64(0,4871),new $Int64(0,1710)),new T.ptr(new $Int64(0,4877),new $Int64(0,3345)),new T.ptr(new $Int64(0,4889),new $Int64(0,4817)),new T.ptr(new $Int64(0,4903),new $Int64(0,2101)),new T.ptr(new $Int64(0,4909),new $Int64(0,4012)),new T.ptr(new $Int64(0,4919),new $Int64(0,4521)),new T.ptr(new $Int64(0,4931),new $Int64(0,236)),new T.ptr(new $Int64(0,4933),new $Int64(0,511)),new T.ptr(new $Int64(0,4937),new $Int64(0,602)),new T.ptr(new $Int64(0,4943),new $Int64(0,2714)),new T.ptr(new $Int64(0,4951),new $Int64(0,340)),new T.ptr(new $Int64(0,4957),new $Int64(0,3352)),new T.ptr(new $Int64(0,4967),new $Int64(0,659)),new T.ptr(new $Int64(0,4969),new $Int64(0,3721)),new T.ptr(new $Int64(0,4973),new $Int64(0,4319)),new T.ptr(new $Int64(0,4987),new $Int64(0,1443)),new T.ptr(new $Int64(0,4993),new $Int64(0,1647)),new T.ptr(new $Int64(0,4999),new $Int64(0,4756)),new T.ptr(new $Int64(0,5003),new $Int64(0,1355)),new T.ptr(new $Int64(0,5009),new $Int64(0,887)),new T.ptr(new $Int64(0,5011),new $Int64(0,4837)),new T.ptr(new $Int64(0,5021),new $Int64(0,693)),new T.ptr(new $Int64(0,5023),new $Int64(0,3151)),new T.ptr(new $Int64(0,5039),new $Int64(0,4440)),new T.ptr(new $Int64(0,5051),new $Int64(0,1917)),new T.ptr(new $Int64(0,5059),new $Int64(0,4290)),new T.ptr(new $Int64(0,5077),new $Int64(0,4128)),new T.ptr(new $Int64(0,5081),new $Int64(0,2521)),new T.ptr(new $Int64(0,5087),new $Int64(0,990)),new T.ptr(new $Int64(0,5099),new $Int64(0,1164)),new T.ptr(new $Int64(0,5101),new $Int64(0,507)),new T.ptr(new $Int64(0,5107),new $Int64(0,2493)),new T.ptr(new $Int64(0,5113),new $Int64(0,144)),new T.ptr(new $Int64(0,5119),new $Int64(0,58)),new T.ptr(new $Int64(0,5147),new $Int64(0,3750)),new T.ptr(new $Int64(0,5153),new $Int64(0,1487)),new T.ptr(new $Int64(0,5167),new $Int64(0,1317)),new T.ptr(new $Int64(0,5171),new $Int64(0,1198)),new T.ptr(new $Int64(0,5179),new $Int64(0,3000)),new T.ptr(new $Int64(0,5189),new $Int64(0,3249)),new T.ptr(new $Int64(0,5197),new $Int64(0,150)),new T.ptr(new $Int64(0,5209),new $Int64(0,1814)),new T.ptr(new $Int64(0,5227),new $Int64(0,207)),new T.ptr(new $Int64(0,5231),new $Int64(0,786)),new T.ptr(new $Int64(0,5233),new $Int64(0,1883)),new T.ptr(new $Int64(0,5237),new $Int64(0,3639)),new T.ptr(new $Int64(0,5261),new $Int64(0,3128)),new T.ptr(new $Int64(0,5273),new $Int64(0,4677)),new T.ptr(new $Int64(0,5279),new $Int64(0,5047)),new T.ptr(new $Int64(0,5281),new $Int64(0,3598)),new T.ptr(new $Int64(0,5297),new $Int64(0,3133)),new T.ptr(new $Int64(0,5303),new $Int64(0,978)),new T.ptr(new $Int64(0,5309),new $Int64(0,5138)),new T.ptr(new $Int64(0,5323),new $Int64(0,4198)),new T.ptr(new $Int64(0,5333),new $Int64(0,2426)),new T.ptr(new $Int64(0,5347),new $Int64(0,1654)),new T.ptr(new $Int64(0,5351),new $Int64(0,4840)),new T.ptr(new $Int64(0,5381),new $Int64(0,4511)),new T.ptr(new $Int64(0,5387),new $Int64(0,1600)),new T.ptr(new $Int64(0,5393),new $Int64(0,1233)),new T.ptr(new $Int64(0,5399),new $Int64(0,1219)),new T.ptr(new $Int64(0,5407),new $Int64(0,1470)),new T.ptr(new $Int64(0,5413),new $Int64(0,2183)),new T.ptr(new $Int64(0,5417),new $Int64(0,2468)),new T.ptr(new $Int64(0,5419),new $Int64(0,4644)),new T.ptr(new $Int64(0,5431),new $Int64(0,2375)),new T.ptr(new $Int64(0,5437),new $Int64(0,548)),new T.ptr(new $Int64(0,5441),new $Int64(0,2330)),new T.ptr(new $Int64(0,5443),new $Int64(0,3129)),new T.ptr(new $Int64(0,5449),new $Int64(0,3400)),new T.ptr(new $Int64(0,5471),new $Int64(0,3052)),new T.ptr(new $Int64(0,5477),new $Int64(0,4818)),new T.ptr(new $Int64(0,5479),new $Int64(0,4627)),new T.ptr(new $Int64(0,5483),new $Int64(0,3435)),new T.ptr(new $Int64(0,5501),new $Int64(0,2287)),new T.ptr(new $Int64(0,5503),new $Int64(0,1495)),new T.ptr(new $Int64(0,5507),new $Int64(0,4788)),new T.ptr(new $Int64(0,5519),new $Int64(0,3865)),new T.ptr(new $Int64(0,5521),new $Int64(0,1263)),new T.ptr(new $Int64(0,5527),new $Int64(0,2756)),new T.ptr(new $Int64(0,5531),new $Int64(0,5315)),new T.ptr(new $Int64(0,5557),new $Int64(0,388)),new T.ptr(new $Int64(0,5563),new $Int64(0,4554)),new T.ptr(new $Int64(0,5569),new $Int64(0,4582)),new T.ptr(new $Int64(0,5573),new $Int64(0,5369)),new T.ptr(new $Int64(0,5581),new $Int64(0,1759)),new T.ptr(new $Int64(0,5591),new $Int64(0,4169)),new T.ptr(new $Int64(0,5623),new $Int64(0,1786)),new T.ptr(new $Int64(0,5639),new $Int64(0,3335)),new T.ptr(new $Int64(0,5641),new $Int64(0,2812)),new T.ptr(new $Int64(0,5647),new $Int64(0,1665)),new T.ptr(new $Int64(0,5651),new $Int64(0,39)),new T.ptr(new $Int64(0,5653),new $Int64(0,4070)),new T.ptr(new $Int64(0,5657),new $Int64(0,5533)),new T.ptr(new $Int64(0,5659),new $Int64(0,751)),new T.ptr(new $Int64(0,5669),new $Int64(0,3340)),new T.ptr(new $Int64(0,5683),new $Int64(0,3284)),new T.ptr(new $Int64(0,5689),new $Int64(0,4317)),new T.ptr(new $Int64(0,5693),new $Int64(0,4950)),new T.ptr(new $Int64(0,5701),new $Int64(0,2429)),new T.ptr(new $Int64(0,5711),new $Int64(0,3203)),new T.ptr(new $Int64(0,5717),new $Int64(0,363)),new T.ptr(new $Int64(0,5737),new $Int64(0,1607)),new T.ptr(new $Int64(0,5741),new $Int64(0,5025)),new T.ptr(new $Int64(0,5743),new $Int64(0,975)),new T.ptr(new $Int64(0,5749),new $Int64(0,236)),new T.ptr(new $Int64(0,5779),new $Int64(0,3209)),new T.ptr(new $Int64(0,5783),new $Int64(0,5359)),new T.ptr(new $Int64(0,5791),new $Int64(0,2544)),new T.ptr(new $Int64(0,5801),new $Int64(0,989)),new T.ptr(new $Int64(0,5807),new $Int64(0,2476)),new T.ptr(new $Int64(0,5813),new $Int64(0,1390)),new T.ptr(new $Int64(0,5821),new $Int64(0,3963)),new T.ptr(new $Int64(0,5827),new $Int64(0,2990)),new T.ptr(new $Int64(0,5839),new $Int64(0,5596)),new T.ptr(new $Int64(0,5843),new $Int64(0,561)),new T.ptr(new $Int64(0,5849),new $Int64(0,95)),new T.ptr(new $Int64(0,5851),new $Int64(0,5566)),new T.ptr(new $Int64(0,5857),new $Int64(0,3355)),new T.ptr(new $Int64(0,5861),new $Int64(0,3555)),new T.ptr(new $Int64(0,5867),new $Int64(0,5523)),new T.ptr(new $Int64(0,5869),new $Int64(0,3108)),new T.ptr(new $Int64(0,5879),new $Int64(0,3289)),new T.ptr(new $Int64(0,5881),new $Int64(0,2303)),new T.ptr(new $Int64(0,5897),new $Int64(0,3806)),new T.ptr(new $Int64(0,5903),new $Int64(0,4049)),new T.ptr(new $Int64(0,5923),new $Int64(0,760)),new T.ptr(new $Int64(0,5927),new $Int64(0,739)),new T.ptr(new $Int64(0,5939),new $Int64(0,359)),new T.ptr(new $Int64(0,5953),new $Int64(0,4622)),new T.ptr(new $Int64(0,5981),new $Int64(0,945)),new T.ptr(new $Int64(0,5987),new $Int64(0,3734)),new T.ptr(new $Int64(0,6007),new $Int64(0,901)),new T.ptr(new $Int64(0,6011),new $Int64(0,5470)),new T.ptr(new $Int64(0,6029),new $Int64(0,2215)),new T.ptr(new $Int64(0,6037),new $Int64(0,2074)),new T.ptr(new $Int64(0,6043),new $Int64(0,2997)),new T.ptr(new $Int64(0,6047),new $Int64(0,1497)),new T.ptr(new $Int64(0,6053),new $Int64(0,2814)),new T.ptr(new $Int64(0,6067),new $Int64(0,5883)),new T.ptr(new $Int64(0,6073),new $Int64(0,3884)),new T.ptr(new $Int64(0,6079),new $Int64(0,4909)),new T.ptr(new $Int64(0,6089),new $Int64(0,3481)),new T.ptr(new $Int64(0,6091),new $Int64(0,756)),new T.ptr(new $Int64(0,6101),new $Int64(0,5462)),new T.ptr(new $Int64(0,6113),new $Int64(0,677)),new T.ptr(new $Int64(0,6121),new $Int64(0,3143)),new T.ptr(new $Int64(0,6131),new $Int64(0,3117)),new T.ptr(new $Int64(0,6133),new $Int64(0,862)),new T.ptr(new $Int64(0,6143),new $Int64(0,1047)),new T.ptr(new $Int64(0,6151),new $Int64(0,1805)),new T.ptr(new $Int64(0,6163),new $Int64(0,4214)),new T.ptr(new $Int64(0,6173),new $Int64(0,4578)),new T.ptr(new $Int64(0,6197),new $Int64(0,1254)),new T.ptr(new $Int64(0,6199),new $Int64(0,2857)),new T.ptr(new $Int64(0,6203),new $Int64(0,1302)),new T.ptr(new $Int64(0,6211),new $Int64(0,4531)),new T.ptr(new $Int64(0,6217),new $Int64(0,4704)),new T.ptr(new $Int64(0,6221),new $Int64(0,2866)),new T.ptr(new $Int64(0,6229),new $Int64(0,4817)),new T.ptr(new $Int64(0,6247),new $Int64(0,1611)),new T.ptr(new $Int64(0,6257),new $Int64(0,5301)),new T.ptr(new $Int64(0,6263),new $Int64(0,4127)),new T.ptr(new $Int64(0,6269),new $Int64(0,3324)),new T.ptr(new $Int64(0,6271),new $Int64(0,155)),new T.ptr(new $Int64(0,6277),new $Int64(0,3003)),new T.ptr(new $Int64(0,6287),new $Int64(0,3874)),new T.ptr(new $Int64(0,6299),new $Int64(0,5352)),new T.ptr(new $Int64(0,6301),new $Int64(0,2137)),new T.ptr(new $Int64(0,6311),new $Int64(0,2991)),new T.ptr(new $Int64(0,6317),new $Int64(0,521)),new T.ptr(new $Int64(0,6323),new $Int64(0,5951)),new T.ptr(new $Int64(0,6329),new $Int64(0,773)),new T.ptr(new $Int64(0,6337),new $Int64(0,1142)),new T.ptr(new $Int64(0,6343),new $Int64(0,703)),new T.ptr(new $Int64(0,6353),new $Int64(0,3604)),new T.ptr(new $Int64(0,6359),new $Int64(0,6232)),new T.ptr(new $Int64(0,6361),new $Int64(0,5681)),new T.ptr(new $Int64(0,6367),new $Int64(0,6158)),new T.ptr(new $Int64(0,6373),new $Int64(0,692)),new T.ptr(new $Int64(0,6379),new $Int64(0,2325)),new T.ptr(new $Int64(0,6389),new $Int64(0,2443)),new T.ptr(new $Int64(0,6397),new $Int64(0,4428)),new T.ptr(new $Int64(0,6421),new $Int64(0,991)),new T.ptr(new $Int64(0,6427),new $Int64(0,3773)),new T.ptr(new $Int64(0,6449),new $Int64(0,5684)),new T.ptr(new $Int64(0,6451),new $Int64(0,6343)),new T.ptr(new $Int64(0,6469),new $Int64(0,5623)),new T.ptr(new $Int64(0,6473),new $Int64(0,4073)),new T.ptr(new $Int64(0,6481),new $Int64(0,6086)),new T.ptr(new $Int64(0,6491),new $Int64(0,4357)),new T.ptr(new $Int64(0,6521),new $Int64(0,5496)),new T.ptr(new $Int64(0,6529),new $Int64(0,480)),new T.ptr(new $Int64(0,6547),new $Int64(0,619)),new T.ptr(new $Int64(0,6551),new $Int64(0,3216)),new T.ptr(new $Int64(0,6553),new $Int64(0,2502)),new T.ptr(new $Int64(0,6563),new $Int64(0,499)),new T.ptr(new $Int64(0,6569),new $Int64(0,822)),new T.ptr(new $Int64(0,6571),new $Int64(0,3100)),new T.ptr(new $Int64(0,6577),new $Int64(0,3774)),new T.ptr(new $Int64(0,6581),new $Int64(0,3045)),new T.ptr(new $Int64(0,6599),new $Int64(0,1958)),new T.ptr(new $Int64(0,6607),new $Int64(0,4377)),new T.ptr(new $Int64(0,6619),new $Int64(0,3120)),new T.ptr(new $Int64(0,6637),new $Int64(0,2121)),new T.ptr(new $Int64(0,6653),new $Int64(0,4708)),new T.ptr(new $Int64(0,6659),new $Int64(0,2039)),new T.ptr(new $Int64(0,6661),new $Int64(0,6631)),new T.ptr(new $Int64(0,6673),new $Int64(0,5561)),new T.ptr(new $Int64(0,6679),new $Int64(0,1637)),new T.ptr(new $Int64(0,6689),new $Int64(0,6096)),new T.ptr(new $Int64(0,6691),new $Int64(0,1031)),new T.ptr(new $Int64(0,6701),new $Int64(0,2893)),new T.ptr(new $Int64(0,6703),new $Int64(0,4908)),new T.ptr(new $Int64(0,6709),new $Int64(0,3459)),new T.ptr(new $Int64(0,6719),new $Int64(0,188)),new T.ptr(new $Int64(0,6733),new $Int64(0,5009)),new T.ptr(new $Int64(0,6737),new $Int64(0,2181)),new T.ptr(new $Int64(0,6761),new $Int64(0,2078)),new T.ptr(new $Int64(0,6763),new $Int64(0,2996)),new T.ptr(new $Int64(0,6779),new $Int64(0,2306)),new T.ptr(new $Int64(0,6781),new $Int64(0,5084)),new T.ptr(new $Int64(0,6791),new $Int64(0,4460)),new T.ptr(new $Int64(0,6793),new $Int64(0,2709)),new T.ptr(new $Int64(0,6803),new $Int64(0,2393)),new T.ptr(new $Int64(0,6823),new $Int64(0,504)),new T.ptr(new $Int64(0,6827),new $Int64(0,3685)),new T.ptr(new $Int64(0,6829),new $Int64(0,485)),new T.ptr(new $Int64(0,6833),new $Int64(0,825)),new T.ptr(new $Int64(0,6841),new $Int64(0,4572)),new T.ptr(new $Int64(0,6857),new $Int64(0,4590)),new T.ptr(new $Int64(0,6863),new $Int64(0,2157)),new T.ptr(new $Int64(0,6869),new $Int64(0,314)),new T.ptr(new $Int64(0,6871),new $Int64(0,1879)),new T.ptr(new $Int64(0,6883),new $Int64(0,2836)),new T.ptr(new $Int64(0,6899),new $Int64(0,4635)),new T.ptr(new $Int64(0,6907),new $Int64(0,5007)),new T.ptr(new $Int64(0,6911),new $Int64(0,5533)),new T.ptr(new $Int64(0,6917),new $Int64(0,4758)),new T.ptr(new $Int64(0,6947),new $Int64(0,2334)),new T.ptr(new $Int64(0,6949),new $Int64(0,3791)),new T.ptr(new $Int64(0,6959),new $Int64(0,3198)),new T.ptr(new $Int64(0,6961),new $Int64(0,3623)),new T.ptr(new $Int64(0,6967),new $Int64(0,2437)),new T.ptr(new $Int64(0,6971),new $Int64(0,5104)),new T.ptr(new $Int64(0,6977),new $Int64(0,5444)),new T.ptr(new $Int64(0,6983),new $Int64(0,1239)),new T.ptr(new $Int64(0,6991),new $Int64(0,5327)),new T.ptr(new $Int64(0,6997),new $Int64(0,5067)),new T.ptr(new $Int64(0,7001),new $Int64(0,6544)),new T.ptr(new $Int64(0,7013),new $Int64(0,5250)),new T.ptr(new $Int64(0,7019),new $Int64(0,2598)),new T.ptr(new $Int64(0,7027),new $Int64(0,1584)),new T.ptr(new $Int64(0,7039),new $Int64(0,5853)),new T.ptr(new $Int64(0,7043),new $Int64(0,6699)),new T.ptr(new $Int64(0,7057),new $Int64(0,1589)),new T.ptr(new $Int64(0,7069),new $Int64(0,1067)),new T.ptr(new $Int64(0,7079),new $Int64(0,4222)),new T.ptr(new $Int64(0,7103),new $Int64(0,6270)),new T.ptr(new $Int64(0,7109),new $Int64(0,1930)),new T.ptr(new $Int64(0,7121),new $Int64(0,7083)),new T.ptr(new $Int64(0,7127),new $Int64(0,2099)),new T.ptr(new $Int64(0,7129),new $Int64(0,4199)),new T.ptr(new $Int64(0,7151),new $Int64(0,2639)),new T.ptr(new $Int64(0,7159),new $Int64(0,5445)),new T.ptr(new $Int64(0,7177),new $Int64(0,1193)),new T.ptr(new $Int64(0,7187),new $Int64(0,5344)),new T.ptr(new $Int64(0,7193),new $Int64(0,2320)),new T.ptr(new $Int64(0,7207),new $Int64(0,721)),new T.ptr(new $Int64(0,7211),new $Int64(0,2391)),new T.ptr(new $Int64(0,7213),new $Int64(0,3507)),new T.ptr(new $Int64(0,7219),new $Int64(0,208)),new T.ptr(new $Int64(0,7229),new $Int64(0,5949)),new T.ptr(new $Int64(0,7237),new $Int64(0,7135)),new T.ptr(new $Int64(0,7243),new $Int64(0,611)),new T.ptr(new $Int64(0,7247),new $Int64(0,5204)),new T.ptr(new $Int64(0,7253),new $Int64(0,2727)),new T.ptr(new $Int64(0,7283),new $Int64(0,3384)),new T.ptr(new $Int64(0,7297),new $Int64(0,3655)),new T.ptr(new $Int64(0,7307),new $Int64(0,3674)),new T.ptr(new $Int64(0,7309),new $Int64(0,4002)),new T.ptr(new $Int64(0,7321),new $Int64(0,6926)),new T.ptr(new $Int64(0,7331),new $Int64(0,7074)),new T.ptr(new $Int64(0,7333),new $Int64(0,3895)),new T.ptr(new $Int64(0,7349),new $Int64(0,681)),new T.ptr(new $Int64(0,7351),new $Int64(0,5616)),new T.ptr(new $Int64(0,7369),new $Int64(0,6674)),new T.ptr(new $Int64(0,7393),new $Int64(0,4322)),new T.ptr(new $Int64(0,7411),new $Int64(0,24)),new T.ptr(new $Int64(0,7417),new $Int64(0,3478)),new T.ptr(new $Int64(0,7433),new $Int64(0,1640)),new T.ptr(new $Int64(0,7451),new $Int64(0,4525)),new T.ptr(new $Int64(0,7457),new $Int64(0,4716)),new T.ptr(new $Int64(0,7459),new $Int64(0,1586)),new T.ptr(new $Int64(0,7477),new $Int64(0,1762)),new T.ptr(new $Int64(0,7481),new $Int64(0,6193)),new T.ptr(new $Int64(0,7487),new $Int64(0,6962)),new T.ptr(new $Int64(0,7489),new $Int64(0,3618)),new T.ptr(new $Int64(0,7499),new $Int64(0,5128)),new T.ptr(new $Int64(0,7507),new $Int64(0,4692)),new T.ptr(new $Int64(0,7517),new $Int64(0,6973)),new T.ptr(new $Int64(0,7523),new $Int64(0,91)),new T.ptr(new $Int64(0,7529),new $Int64(0,2123)),new T.ptr(new $Int64(0,7537),new $Int64(0,6531)),new T.ptr(new $Int64(0,7541),new $Int64(0,408)),new T.ptr(new $Int64(0,7547),new $Int64(0,5099)),new T.ptr(new $Int64(0,7549),new $Int64(0,5423)),new T.ptr(new $Int64(0,7559),new $Int64(0,6449)),new T.ptr(new $Int64(0,7561),new $Int64(0,3754)),new T.ptr(new $Int64(0,7573),new $Int64(0,5528)),new T.ptr(new $Int64(0,7577),new $Int64(0,6003)),new T.ptr(new $Int64(0,7583),new $Int64(0,747)),new T.ptr(new $Int64(0,7589),new $Int64(0,5942)),new T.ptr(new $Int64(0,7591),new $Int64(0,3858)),new T.ptr(new $Int64(0,7603),new $Int64(0,5548)),new T.ptr(new $Int64(0,7607),new $Int64(0,4353)),new T.ptr(new $Int64(0,7621),new $Int64(0,491)),new T.ptr(new $Int64(0,7639),new $Int64(0,6764)),new T.ptr(new $Int64(0,7643),new $Int64(0,2154)),new T.ptr(new $Int64(0,7649),new $Int64(0,598)),new T.ptr(new $Int64(0,7669),new $Int64(0,6283)),new T.ptr(new $Int64(0,7673),new $Int64(0,3341)),new T.ptr(new $Int64(0,7681),new $Int64(0,3146)),new T.ptr(new $Int64(0,7687),new $Int64(0,6421)),new T.ptr(new $Int64(0,7691),new $Int64(0,5708)),new T.ptr(new $Int64(0,7699),new $Int64(0,691)),new T.ptr(new $Int64(0,7703),new $Int64(0,1613)),new T.ptr(new $Int64(0,7717),new $Int64(0,1356)),new T.ptr(new $Int64(0,7723),new $Int64(0,2372)),new T.ptr(new $Int64(0,7727),new $Int64(0,5155)),new T.ptr(new $Int64(0,7741),new $Int64(0,259)),new T.ptr(new $Int64(0,7753),new $Int64(0,6097)),new T.ptr(new $Int64(0,7757),new $Int64(0,3383)),new T.ptr(new $Int64(0,7759),new $Int64(0,5289)),new T.ptr(new $Int64(0,7789),new $Int64(0,6428)),new T.ptr(new $Int64(0,7793),new $Int64(0,1735)),new T.ptr(new $Int64(0,7817),new $Int64(0,633)),new T.ptr(new $Int64(0,7823),new $Int64(0,3631)),new T.ptr(new $Int64(0,7829),new $Int64(0,2321)),new T.ptr(new $Int64(0,7841),new $Int64(0,7384)),new T.ptr(new $Int64(0,7853),new $Int64(0,5769)),new T.ptr(new $Int64(0,7867),new $Int64(0,398)),new T.ptr(new $Int64(0,7873),new $Int64(0,5688)),new T.ptr(new $Int64(0,7877),new $Int64(0,5560)),new T.ptr(new $Int64(0,7879),new $Int64(0,5725)),new T.ptr(new $Int64(0,7883),new $Int64(0,1379)),new T.ptr(new $Int64(0,7901),new $Int64(0,4524)),new T.ptr(new $Int64(0,7907),new $Int64(0,2072)),new T.ptr(new $Int64(0,7919),new $Int64(0,7658)),new T.ptr(new $Int64(0,7927),new $Int64(0,7255)),new T.ptr(new $Int64(0,7933),new $Int64(0,7249)),new T.ptr(new $Int64(0,7937),new $Int64(0,1729)),new T.ptr(new $Int64(0,7949),new $Int64(0,1491)),new T.ptr(new $Int64(0,7951),new $Int64(0,3199)),new T.ptr(new $Int64(0,7963),new $Int64(0,5580)),new T.ptr(new $Int64(0,7993),new $Int64(0,5080)),new T.ptr(new $Int64(0,8009),new $Int64(0,7475)),new T.ptr(new $Int64(0,8011),new $Int64(0,178)),new T.ptr(new $Int64(0,8017),new $Int64(0,772)),new T.ptr(new $Int64(0,8039),new $Int64(0,1020)),new T.ptr(new $Int64(0,8053),new $Int64(0,6168)),new T.ptr(new $Int64(0,8059),new $Int64(0,6995)),new T.ptr(new $Int64(0,8069),new $Int64(0,6076)),new T.ptr(new $Int64(0,8081),new $Int64(0,6391)),new T.ptr(new $Int64(0,8087),new $Int64(0,1283)),new T.ptr(new $Int64(0,8089),new $Int64(0,1225)),new T.ptr(new $Int64(0,8093),new $Int64(0,7344)),new T.ptr(new $Int64(0,8101),new $Int64(0,3403)),new T.ptr(new $Int64(0,8111),new $Int64(0,8090)),new T.ptr(new $Int64(0,8117),new $Int64(0,5178)),new T.ptr(new $Int64(0,8123),new $Int64(0,2411)),new T.ptr(new $Int64(0,8147),new $Int64(0,2786)),new T.ptr(new $Int64(0,8161),new $Int64(0,6351)),new T.ptr(new $Int64(0,8167),new $Int64(0,1380)),new T.ptr(new $Int64(0,8171),new $Int64(0,4799)),new T.ptr(new $Int64(0,8179),new $Int64(0,4174)),new T.ptr(new $Int64(0,8191),new $Int64(0,2420)),new T.ptr(new $Int64(0,8209),new $Int64(0,1522)),new T.ptr(new $Int64(0,8219),new $Int64(0,4438)),new T.ptr(new $Int64(0,8221),new $Int64(0,1778)),new T.ptr(new $Int64(0,8231),new $Int64(0,6228)),new T.ptr(new $Int64(0,8233),new $Int64(0,2798)),new T.ptr(new $Int64(0,8237),new $Int64(0,235)),new T.ptr(new $Int64(0,8243),new $Int64(0,6564)),new T.ptr(new $Int64(0,8263),new $Int64(0,5621)),new T.ptr(new $Int64(0,8269),new $Int64(0,1149)),new T.ptr(new $Int64(0,8273),new $Int64(0,6685)),new T.ptr(new $Int64(0,8287),new $Int64(0,1897)),new T.ptr(new $Int64(0,8291),new $Int64(0,8166)),new T.ptr(new $Int64(0,8293),new $Int64(0,1323)),new T.ptr(new $Int64(0,8297),new $Int64(0,1824)),new T.ptr(new $Int64(0,8311),new $Int64(0,1675)),new T.ptr(new $Int64(0,8317),new $Int64(0,8125)),new T.ptr(new $Int64(0,8329),new $Int64(0,1927)),new T.ptr(new $Int64(0,8353),new $Int64(0,3982)),new T.ptr(new $Int64(0,8363),new $Int64(0,5657)),new T.ptr(new $Int64(0,8369),new $Int64(0,6281)),new T.ptr(new $Int64(0,8377),new $Int64(0,1518)),new T.ptr(new $Int64(0,8387),new $Int64(0,388)),new T.ptr(new $Int64(0,8389),new $Int64(0,160)),new T.ptr(new $Int64(0,8419),new $Int64(0,7728)),new T.ptr(new $Int64(0,8423),new $Int64(0,7898)),new T.ptr(new $Int64(0,8429),new $Int64(0,3122)),new T.ptr(new $Int64(0,8431),new $Int64(0,4167)),new T.ptr(new $Int64(0,8443),new $Int64(0,6220)),new T.ptr(new $Int64(0,8447),new $Int64(0,3416)),new T.ptr(new $Int64(0,8461),new $Int64(0,2971)),new T.ptr(new $Int64(0,8467),new $Int64(0,2949)),new T.ptr(new $Int64(0,8501),new $Int64(0,392)),new T.ptr(new $Int64(0,8513),new $Int64(0,2278)),new T.ptr(new $Int64(0,8521),new $Int64(0,2775)),new T.ptr(new $Int64(0,8527),new $Int64(0,4976)),new T.ptr(new $Int64(0,8537),new $Int64(0,3446)),new T.ptr(new $Int64(0,8539),new $Int64(0,7096)),new T.ptr(new $Int64(0,8543),new $Int64(0,1072)),new T.ptr(new $Int64(0,8563),new $Int64(0,5145)),new T.ptr(new $Int64(0,8573),new $Int64(0,2187)),new T.ptr(new $Int64(0,8581),new $Int64(0,7968)),new T.ptr(new $Int64(0,8597),new $Int64(0,7116)),new T.ptr(new $Int64(0,8599),new $Int64(0,5140)),new T.ptr(new $Int64(0,8609),new $Int64(0,3838)),new T.ptr(new $Int64(0,8623),new $Int64(0,7606)),new T.ptr(new $Int64(0,8627),new $Int64(0,8509)),new T.ptr(new $Int64(0,8629),new $Int64(0,5673)),new T.ptr(new $Int64(0,8641),new $Int64(0,7700)),new T.ptr(new $Int64(0,8647),new $Int64(0,1392)),new T.ptr(new $Int64(0,8663),new $Int64(0,6747)),new T.ptr(new $Int64(0,8669),new $Int64(0,327)),new T.ptr(new $Int64(0,8677),new $Int64(0,4888)),new T.ptr(new $Int64(0,8681),new $Int64(0,1983)),new T.ptr(new $Int64(0,8689),new $Int64(0,5005)),new T.ptr(new $Int64(0,8693),new $Int64(0,8149)),new T.ptr(new $Int64(0,8699),new $Int64(0,3159)),new T.ptr(new $Int64(0,8707),new $Int64(0,4520)),new T.ptr(new $Int64(0,8713),new $Int64(0,2700)),new T.ptr(new $Int64(0,8719),new $Int64(0,4933)),new T.ptr(new $Int64(0,8731),new $Int64(0,508)),new T.ptr(new $Int64(0,8737),new $Int64(0,4289)),new T.ptr(new $Int64(0,8741),new $Int64(0,6961)),new T.ptr(new $Int64(0,8747),new $Int64(0,4800)),new T.ptr(new $Int64(0,8753),new $Int64(0,777)),new T.ptr(new $Int64(0,8761),new $Int64(0,7098)),new T.ptr(new $Int64(0,8779),new $Int64(0,709)),new T.ptr(new $Int64(0,8783),new $Int64(0,4682)),new T.ptr(new $Int64(0,8803),new $Int64(0,8631)),new T.ptr(new $Int64(0,8807),new $Int64(0,8383)),new T.ptr(new $Int64(0,8819),new $Int64(0,5643)),new T.ptr(new $Int64(0,8821),new $Int64(0,4102)),new T.ptr(new $Int64(0,8831),new $Int64(0,480)),new T.ptr(new $Int64(0,8837),new $Int64(0,1594)),new T.ptr(new $Int64(0,8839),new $Int64(0,7959)),new T.ptr(new $Int64(0,8849),new $Int64(0,2009)),new T.ptr(new $Int64(0,8861),new $Int64(0,3498)),new T.ptr(new $Int64(0,8863),new $Int64(0,1850)),new T.ptr(new $Int64(0,8867),new $Int64(0,4919)),new T.ptr(new $Int64(0,8887),new $Int64(0,4245)),new T.ptr(new $Int64(0,8893),new $Int64(0,6687)),new T.ptr(new $Int64(0,8923),new $Int64(0,6119)),new T.ptr(new $Int64(0,8929),new $Int64(0,4724)),new T.ptr(new $Int64(0,8933),new $Int64(0,1672)),new T.ptr(new $Int64(0,8941),new $Int64(0,7945)),new T.ptr(new $Int64(0,8951),new $Int64(0,4734)),new T.ptr(new $Int64(0,8963),new $Int64(0,2723)),new T.ptr(new $Int64(0,8969),new $Int64(0,1194)),new T.ptr(new $Int64(0,8971),new $Int64(0,8068)),new T.ptr(new $Int64(0,8999),new $Int64(0,4567)),new T.ptr(new $Int64(0,9001),new $Int64(0,3291)),new T.ptr(new $Int64(0,9007),new $Int64(0,5742)),new T.ptr(new $Int64(0,9011),new $Int64(0,3717)),new T.ptr(new $Int64(0,9013),new $Int64(0,8506)),new T.ptr(new $Int64(0,9029),new $Int64(0,79)),new T.ptr(new $Int64(0,9041),new $Int64(0,7367)),new T.ptr(new $Int64(0,9043),new $Int64(0,5858)),new T.ptr(new $Int64(0,9049),new $Int64(0,6487)),new T.ptr(new $Int64(0,9059),new $Int64(0,77)),new T.ptr(new $Int64(0,9067),new $Int64(0,4725)),new T.ptr(new $Int64(0,9091),new $Int64(0,8739)),new T.ptr(new $Int64(0,9103),new $Int64(0,9057)),new T.ptr(new $Int64(0,9109),new $Int64(0,3113)),new T.ptr(new $Int64(0,9127),new $Int64(0,6940)),new T.ptr(new $Int64(0,9133),new $Int64(0,499)),new T.ptr(new $Int64(0,9137),new $Int64(0,5459)),new T.ptr(new $Int64(0,9151),new $Int64(0,4532)),new T.ptr(new $Int64(0,9157),new $Int64(0,6000)),new T.ptr(new $Int64(0,9161),new $Int64(0,6815)),new T.ptr(new $Int64(0,9173),new $Int64(0,2001)),new T.ptr(new $Int64(0,9181),new $Int64(0,7984)),new T.ptr(new $Int64(0,9187),new $Int64(0,9147)),new T.ptr(new $Int64(0,9199),new $Int64(0,1933)),new T.ptr(new $Int64(0,9203),new $Int64(0,4745)),new T.ptr(new $Int64(0,9209),new $Int64(0,8135)),new T.ptr(new $Int64(0,9221),new $Int64(0,112)),new T.ptr(new $Int64(0,9227),new $Int64(0,4750)),new T.ptr(new $Int64(0,9239),new $Int64(0,7107)),new T.ptr(new $Int64(0,9241),new $Int64(0,4265)),new T.ptr(new $Int64(0,9257),new $Int64(0,2220)),new T.ptr(new $Int64(0,9277),new $Int64(0,2353)),new T.ptr(new $Int64(0,9281),new $Int64(0,5189)),new T.ptr(new $Int64(0,9283),new $Int64(0,6709)),new T.ptr(new $Int64(0,9293),new $Int64(0,2185)),new T.ptr(new $Int64(0,9311),new $Int64(0,4943)),new T.ptr(new $Int64(0,9319),new $Int64(0,4537)),new T.ptr(new $Int64(0,9323),new $Int64(0,6800)),new T.ptr(new $Int64(0,9337),new $Int64(0,7671)),new T.ptr(new $Int64(0,9341),new $Int64(0,4546)),new T.ptr(new $Int64(0,9343),new $Int64(0,5917)),new T.ptr(new $Int64(0,9349),new $Int64(0,7594)),new T.ptr(new $Int64(0,9371),new $Int64(0,8331)),new T.ptr(new $Int64(0,9377),new $Int64(0,1490)),new T.ptr(new $Int64(0,9391),new $Int64(0,598)),new T.ptr(new $Int64(0,9397),new $Int64(0,5594)),new T.ptr(new $Int64(0,9403),new $Int64(0,9332)),new T.ptr(new $Int64(0,9413),new $Int64(0,7404)),new T.ptr(new $Int64(0,9419),new $Int64(0,2376)),new T.ptr(new $Int64(0,9421),new $Int64(0,2094)),new T.ptr(new $Int64(0,9431),new $Int64(0,5572)),new T.ptr(new $Int64(0,9433),new $Int64(0,5835)),new T.ptr(new $Int64(0,9437),new $Int64(0,1146)),new T.ptr(new $Int64(0,9439),new $Int64(0,4652)),new T.ptr(new $Int64(0,9461),new $Int64(0,1854)),new T.ptr(new $Int64(0,9463),new $Int64(0,803)),new T.ptr(new $Int64(0,9467),new $Int64(0,1989)),new T.ptr(new $Int64(0,9473),new $Int64(0,5620)),new T.ptr(new $Int64(0,9479),new $Int64(0,180)),new T.ptr(new $Int64(0,9491),new $Int64(0,4427)),new T.ptr(new $Int64(0,9497),new $Int64(0,6879)),new T.ptr(new $Int64(0,9511),new $Int64(0,6050)),new T.ptr(new $Int64(0,9521),new $Int64(0,5171)),new T.ptr(new $Int64(0,9533),new $Int64(0,2270)),new T.ptr(new $Int64(0,9539),new $Int64(0,6199)),new T.ptr(new $Int64(0,9547),new $Int64(0,1885)),new T.ptr(new $Int64(0,9551),new $Int64(0,6702)),new T.ptr(new $Int64(0,9587),new $Int64(0,5328)),new T.ptr(new $Int64(0,9601),new $Int64(0,4153)),new T.ptr(new $Int64(0,9613),new $Int64(0,7238)),new T.ptr(new $Int64(0,9619),new $Int64(0,3602)),new T.ptr(new $Int64(0,9623),new $Int64(0,8158)),new T.ptr(new $Int64(0,9629),new $Int64(0,8001)),new T.ptr(new $Int64(0,9631),new $Int64(0,36)),new T.ptr(new $Int64(0,9643),new $Int64(0,3453)),new T.ptr(new $Int64(0,9649),new $Int64(0,960)),new T.ptr(new $Int64(0,9661),new $Int64(0,7195)),new T.ptr(new $Int64(0,9677),new $Int64(0,3911)),new T.ptr(new $Int64(0,9679),new $Int64(0,8580)),new T.ptr(new $Int64(0,9689),new $Int64(0,5994)),new T.ptr(new $Int64(0,9697),new $Int64(0,2290)),new T.ptr(new $Int64(0,9719),new $Int64(0,9321)),new T.ptr(new $Int64(0,9721),new $Int64(0,8070)),new T.ptr(new $Int64(0,9733),new $Int64(0,6638)),new T.ptr(new $Int64(0,9739),new $Int64(0,5729)),new T.ptr(new $Int64(0,9743),new $Int64(0,7958)),new T.ptr(new $Int64(0,9749),new $Int64(0,6932)),new T.ptr(new $Int64(0,9767),new $Int64(0,8243)),new T.ptr(new $Int64(0,9769),new $Int64(0,7901)),new T.ptr(new $Int64(0,9781),new $Int64(0,210)),new T.ptr(new $Int64(0,9787),new $Int64(0,2871)),new T.ptr(new $Int64(0,9791),new $Int64(0,7917)),new T.ptr(new $Int64(0,9803),new $Int64(0,7297)),new T.ptr(new $Int64(0,9811),new $Int64(0,1894)),new T.ptr(new $Int64(0,9817),new $Int64(0,5947)),new T.ptr(new $Int64(0,9829),new $Int64(0,4557)),new T.ptr(new $Int64(0,9833),new $Int64(0,2199)),new T.ptr(new $Int64(0,9839),new $Int64(0,3342)),new T.ptr(new $Int64(0,9851),new $Int64(0,8679)),new T.ptr(new $Int64(0,9857),new $Int64(0,2679)),new T.ptr(new $Int64(0,9859),new $Int64(0,9168)),new T.ptr(new $Int64(0,9871),new $Int64(0,6989)),new T.ptr(new $Int64(0,9883),new $Int64(0,3223)),new T.ptr(new $Int64(0,9887),new $Int64(0,7643)),new T.ptr(new $Int64(0,9901),new $Int64(0,4080)),new T.ptr(new $Int64(0,9907),new $Int64(0,521)),new T.ptr(new $Int64(0,9923),new $Int64(0,2975)),new T.ptr(new $Int64(0,9929),new $Int64(0,6936)),new T.ptr(new $Int64(0,9931),new $Int64(0,8852)),new T.ptr(new $Int64(0,9941),new $Int64(0,3974)),new T.ptr(new $Int64(0,9949),new $Int64(0,965)),new T.ptr(new $Int64(0,9967),new $Int64(0,9600)),new T.ptr(new $Int64(0,9973),new $Int64(0,9681)),new T.ptr(new $Int64(0,10007),new $Int64(0,278)),new T.ptr(new $Int64(0,10009),new $Int64(0,9175)),new T.ptr(new $Int64(0,10037),new $Int64(0,5731)),new T.ptr(new $Int64(0,10039),new $Int64(0,4356)),new T.ptr(new $Int64(0,10061),new $Int64(0,8565)),new T.ptr(new $Int64(0,10067),new $Int64(0,6520)),new T.ptr(new $Int64(0,10069),new $Int64(0,6670)),new T.ptr(new $Int64(0,10079),new $Int64(0,4370)),new T.ptr(new $Int64(0,10091),new $Int64(0,1360)),new T.ptr(new $Int64(0,10093),new $Int64(0,3415)),new T.ptr(new $Int64(0,10099),new $Int64(0,8917)),new T.ptr(new $Int64(0,10103),new $Int64(0,2055)),new T.ptr(new $Int64(0,10111),new $Int64(0,7967)),new T.ptr(new $Int64(0,10133),new $Int64(0,611)),new T.ptr(new $Int64(0,10139),new $Int64(0,1251)),new T.ptr(new $Int64(0,10141),new $Int64(0,3490)),new T.ptr(new $Int64(0,10151),new $Int64(0,10145)),new T.ptr(new $Int64(0,10159),new $Int64(0,5017)),new T.ptr(new $Int64(0,10163),new $Int64(0,5707)),new T.ptr(new $Int64(0,10169),new $Int64(0,9684)),new T.ptr(new $Int64(0,10177),new $Int64(0,1102)),new T.ptr(new $Int64(0,10181),new $Int64(0,5026)),new T.ptr(new $Int64(0,10193),new $Int64(0,803)),new T.ptr(new $Int64(0,10211),new $Int64(0,1723)),new T.ptr(new $Int64(0,10223),new $Int64(0,10219)),new T.ptr(new $Int64(0,10243),new $Int64(0,7587)),new T.ptr(new $Int64(0,10247),new $Int64(0,8341)),new T.ptr(new $Int64(0,10253),new $Int64(0,10144)),new T.ptr(new $Int64(0,10259),new $Int64(0,1727)),new T.ptr(new $Int64(0,10267),new $Int64(0,263)),new T.ptr(new $Int64(0,10271),new $Int64(0,1256)),new T.ptr(new $Int64(0,10273),new $Int64(0,3050)),new T.ptr(new $Int64(0,10289),new $Int64(0,126)),new T.ptr(new $Int64(0,10301),new $Int64(0,9006)),new T.ptr(new $Int64(0,10303),new $Int64(0,6350)),new T.ptr(new $Int64(0,10313),new $Int64(0,10157)),new T.ptr(new $Int64(0,10321),new $Int64(0,8764)),new T.ptr(new $Int64(0,10331),new $Int64(0,2218)),new T.ptr(new $Int64(0,10333),new $Int64(0,9184)),new T.ptr(new $Int64(0,10337),new $Int64(0,6620)),new T.ptr(new $Int64(0,10343),new $Int64(0,4439)),new T.ptr(new $Int64(0,10357),new $Int64(0,9673)),new T.ptr(new $Int64(0,10369),new $Int64(0,8003)),new T.ptr(new $Int64(0,10391),new $Int64(0,25)),new T.ptr(new $Int64(0,10399),new $Int64(0,10174)),new T.ptr(new $Int64(0,10427),new $Int64(0,5649)),new T.ptr(new $Int64(0,10429),new $Int64(0,699)),new T.ptr(new $Int64(0,10433),new $Int64(0,2896)),new T.ptr(new $Int64(0,10453),new $Int64(0,6774)),new T.ptr(new $Int64(0,10457),new $Int64(0,5788)),new T.ptr(new $Int64(0,10459),new $Int64(0,10426)),new T.ptr(new $Int64(0,10463),new $Int64(0,1407)),new T.ptr(new $Int64(0,10477),new $Int64(0,10434)),new T.ptr(new $Int64(0,10487),new $Int64(0,6242)),new T.ptr(new $Int64(0,10499),new $Int64(0,3047)),new T.ptr(new $Int64(0,10501),new $Int64(0,1285)),new T.ptr(new $Int64(0,10513),new $Int64(0,2050)),new T.ptr(new $Int64(0,10529),new $Int64(0,3863)),new T.ptr(new $Int64(0,10531),new $Int64(0,1265)),new T.ptr(new $Int64(0,10559),new $Int64(0,6730)),new T.ptr(new $Int64(0,10567),new $Int64(0,4678)),new T.ptr(new $Int64(0,10589),new $Int64(0,2568)),new T.ptr(new $Int64(0,10597),new $Int64(0,2222)),new T.ptr(new $Int64(0,10601),new $Int64(0,6160)),new T.ptr(new $Int64(0,10607),new $Int64(0,496)),new T.ptr(new $Int64(0,10613),new $Int64(0,3545)),new T.ptr(new $Int64(0,10627),new $Int64(0,6090)),new T.ptr(new $Int64(0,10631),new $Int64(0,6812)),new T.ptr(new $Int64(0,10639),new $Int64(0,4712)),new T.ptr(new $Int64(0,10651),new $Int64(0,9132)),new T.ptr(new $Int64(0,10657),new $Int64(0,792)),new T.ptr(new $Int64(0,10663),new $Int64(0,777)),new T.ptr(new $Int64(0,10667),new $Int64(0,3051)),new T.ptr(new $Int64(0,10687),new $Int64(0,909)),new T.ptr(new $Int64(0,10691),new $Int64(0,5980)),new T.ptr(new $Int64(0,10709),new $Int64(0,3239)),new T.ptr(new $Int64(0,10711),new $Int64(0,5861)),new T.ptr(new $Int64(0,10723),new $Int64(0,8521)),new T.ptr(new $Int64(0,10729),new $Int64(0,1389)),new T.ptr(new $Int64(0,10733),new $Int64(0,9032)),new T.ptr(new $Int64(0,10739),new $Int64(0,2945)),new T.ptr(new $Int64(0,10753),new $Int64(0,7715)),new T.ptr(new $Int64(0,10771),new $Int64(0,3575)),new T.ptr(new $Int64(0,10781),new $Int64(0,691)),new T.ptr(new $Int64(0,10789),new $Int64(0,292)),new T.ptr(new $Int64(0,10799),new $Int64(0,8868)),new T.ptr(new $Int64(0,10831),new $Int64(0,3319)),new T.ptr(new $Int64(0,10837),new $Int64(0,5282)),new T.ptr(new $Int64(0,10847),new $Int64(0,6673)),new T.ptr(new $Int64(0,10853),new $Int64(0,1988)),new T.ptr(new $Int64(0,10859),new $Int64(0,971)),new T.ptr(new $Int64(0,10861),new $Int64(0,4736)),new T.ptr(new $Int64(0,10867),new $Int64(0,7400)),new T.ptr(new $Int64(0,10883),new $Int64(0,2567)),new T.ptr(new $Int64(0,10889),new $Int64(0,2842)),new T.ptr(new $Int64(0,10891),new $Int64(0,8228)),new T.ptr(new $Int64(0,10903),new $Int64(0,4781)),new T.ptr(new $Int64(0,10909),new $Int64(0,6311)),new T.ptr(new $Int64(0,10937),new $Int64(0,2164)),new T.ptr(new $Int64(0,10939),new $Int64(0,2774)),new T.ptr(new $Int64(0,10949),new $Int64(0,7654)),new T.ptr(new $Int64(0,10957),new $Int64(0,2396)),new T.ptr(new $Int64(0,10973),new $Int64(0,7491)),new T.ptr(new $Int64(0,10979),new $Int64(0,203)),new T.ptr(new $Int64(0,10987),new $Int64(0,5978)),new T.ptr(new $Int64(0,10993),new $Int64(0,9227)),new T.ptr(new $Int64(0,11003),new $Int64(0,1639)),new T.ptr(new $Int64(0,11027),new $Int64(0,3176)),new T.ptr(new $Int64(0,11047),new $Int64(0,3511)),new T.ptr(new $Int64(0,11057),new $Int64(0,5855)),new T.ptr(new $Int64(0,11059),new $Int64(0,4318)),new T.ptr(new $Int64(0,11069),new $Int64(0,3370)),new T.ptr(new $Int64(0,11071),new $Int64(0,7905)),new T.ptr(new $Int64(0,11083),new $Int64(0,4024)),new T.ptr(new $Int64(0,11087),new $Int64(0,7164)),new T.ptr(new $Int64(0,11093),new $Int64(0,8260)),new T.ptr(new $Int64(0,11113),new $Int64(0,424)),new T.ptr(new $Int64(0,11117),new $Int64(0,10368)),new T.ptr(new $Int64(0,11119),new $Int64(0,1981)),new T.ptr(new $Int64(0,11131),new $Int64(0,681)),new T.ptr(new $Int64(0,11149),new $Int64(0,8967)),new T.ptr(new $Int64(0,11159),new $Int64(0,4894)),new T.ptr(new $Int64(0,11161),new $Int64(0,4248)),new T.ptr(new $Int64(0,11171),new $Int64(0,6773)),new T.ptr(new $Int64(0,11173),new $Int64(0,8993)),new T.ptr(new $Int64(0,11177),new $Int64(0,4266)),new T.ptr(new $Int64(0,11197),new $Int64(0,7717)),new T.ptr(new $Int64(0,11213),new $Int64(0,9884)),new T.ptr(new $Int64(0,11239),new $Int64(0,5730)),new T.ptr(new $Int64(0,11243),new $Int64(0,2753)),new T.ptr(new $Int64(0,11251),new $Int64(0,5454)),new T.ptr(new $Int64(0,11257),new $Int64(0,8360)),new T.ptr(new $Int64(0,11261),new $Int64(0,1408)),new T.ptr(new $Int64(0,11273),new $Int64(0,3208)),new T.ptr(new $Int64(0,11279),new $Int64(0,417)),new T.ptr(new $Int64(0,11287),new $Int64(0,9383)),new T.ptr(new $Int64(0,11299),new $Int64(0,9288)),new T.ptr(new $Int64(0,11311),new $Int64(0,3048)),new T.ptr(new $Int64(0,11317),new $Int64(0,6997)),new T.ptr(new $Int64(0,11321),new $Int64(0,5323)),new T.ptr(new $Int64(0,11329),new $Int64(0,10634)),new T.ptr(new $Int64(0,11351),new $Int64(0,9031)),new T.ptr(new $Int64(0,11353),new $Int64(0,9756)),new T.ptr(new $Int64(0,11369),new $Int64(0,11247)),new T.ptr(new $Int64(0,11383),new $Int64(0,1978)),new T.ptr(new $Int64(0,11393),new $Int64(0,9650)),new T.ptr(new $Int64(0,11399),new $Int64(0,4316)),new T.ptr(new $Int64(0,11411),new $Int64(0,4422)),new T.ptr(new $Int64(0,11423),new $Int64(0,64)),new T.ptr(new $Int64(0,11437),new $Int64(0,6717)),new T.ptr(new $Int64(0,11443),new $Int64(0,7447)),new T.ptr(new $Int64(0,11447),new $Int64(0,6619)),new T.ptr(new $Int64(0,11467),new $Int64(0,6411)),new T.ptr(new $Int64(0,11471),new $Int64(0,10960)),new T.ptr(new $Int64(0,11483),new $Int64(0,4934)),new T.ptr(new $Int64(0,11489),new $Int64(0,8921)),new T.ptr(new $Int64(0,11491),new $Int64(0,8004)),new T.ptr(new $Int64(0,11497),new $Int64(0,2382)),new T.ptr(new $Int64(0,11503),new $Int64(0,5182)),new T.ptr(new $Int64(0,11519),new $Int64(0,9068)),new T.ptr(new $Int64(0,11527),new $Int64(0,4366)),new T.ptr(new $Int64(0,11549),new $Int64(0,11327)),new T.ptr(new $Int64(0,11551),new $Int64(0,5109)),new T.ptr(new $Int64(0,11579),new $Int64(0,1313)),new T.ptr(new $Int64(0,11587),new $Int64(0,5390)),new T.ptr(new $Int64(0,11593),new $Int64(0,6372)),new T.ptr(new $Int64(0,11597),new $Int64(0,10387)),new T.ptr(new $Int64(0,11617),new $Int64(0,5285)),new T.ptr(new $Int64(0,11621),new $Int64(0,4158)),new T.ptr(new $Int64(0,11633),new $Int64(0,9156)),new T.ptr(new $Int64(0,11657),new $Int64(0,1829)),new T.ptr(new $Int64(0,11677),new $Int64(0,9366)),new T.ptr(new $Int64(0,11681),new $Int64(0,10160)),new T.ptr(new $Int64(0,11689),new $Int64(0,8508)),new T.ptr(new $Int64(0,11699),new $Int64(0,228)),new T.ptr(new $Int64(0,11701),new $Int64(0,11321)),new T.ptr(new $Int64(0,11717),new $Int64(0,8329)),new T.ptr(new $Int64(0,11719),new $Int64(0,4)),new T.ptr(new $Int64(0,11731),new $Int64(0,5089)),new T.ptr(new $Int64(0,11743),new $Int64(0,9748)),new T.ptr(new $Int64(0,11777),new $Int64(0,436)),new T.ptr(new $Int64(0,11779),new $Int64(0,10318)),new T.ptr(new $Int64(0,11783),new $Int64(0,9483)),new T.ptr(new $Int64(0,11789),new $Int64(0,904)),new T.ptr(new $Int64(0,11801),new $Int64(0,3462)),new T.ptr(new $Int64(0,11807),new $Int64(0,3784)),new T.ptr(new $Int64(0,11813),new $Int64(0,11534)),new T.ptr(new $Int64(0,11821),new $Int64(0,10020)),new T.ptr(new $Int64(0,11827),new $Int64(0,9826)),new T.ptr(new $Int64(0,11831),new $Int64(0,5288)),new T.ptr(new $Int64(0,11833),new $Int64(0,747)),new T.ptr(new $Int64(0,11839),new $Int64(0,8082)),new T.ptr(new $Int64(0,11863),new $Int64(0,1457)),new T.ptr(new $Int64(0,11867),new $Int64(0,8978)),new T.ptr(new $Int64(0,11887),new $Int64(0,6438)),new T.ptr(new $Int64(0,11897),new $Int64(0,6383)),new T.ptr(new $Int64(0,11903),new $Int64(0,2326)),new T.ptr(new $Int64(0,11909),new $Int64(0,9955)),new T.ptr(new $Int64(0,11923),new $Int64(0,8748)),new T.ptr(new $Int64(0,11927),new $Int64(0,11043)),new T.ptr(new $Int64(0,11933),new $Int64(0,8051)),new T.ptr(new $Int64(0,11939),new $Int64(0,507)),new T.ptr(new $Int64(0,11941),new $Int64(0,11756)),new T.ptr(new $Int64(0,11953),new $Int64(0,11406)),new T.ptr(new $Int64(0,11959),new $Int64(0,11079)),new T.ptr(new $Int64(0,11969),new $Int64(0,8935)),new T.ptr(new $Int64(0,11971),new $Int64(0,9606)),new T.ptr(new $Int64(0,11981),new $Int64(0,8464)),new T.ptr(new $Int64(0,11987),new $Int64(0,3692)),new T.ptr(new $Int64(0,12007),new $Int64(0,1681)),new T.ptr(new $Int64(0,12011),new $Int64(0,10810)),new T.ptr(new $Int64(0,12037),new $Int64(0,10737)),new T.ptr(new $Int64(0,12041),new $Int64(0,5024)),new T.ptr(new $Int64(0,12043),new $Int64(0,10761)),new T.ptr(new $Int64(0,12049),new $Int64(0,7783)),new T.ptr(new $Int64(0,12071),new $Int64(0,7795)),new T.ptr(new $Int64(0,12073),new $Int64(0,6274)),new T.ptr(new $Int64(0,12097),new $Int64(0,3316)),new T.ptr(new $Int64(0,12101),new $Int64(0,10483)),new T.ptr(new $Int64(0,12107),new $Int64(0,548)),new T.ptr(new $Int64(0,12109),new $Int64(0,10973)),new T.ptr(new $Int64(0,12113),new $Int64(0,6920)),new T.ptr(new $Int64(0,12119),new $Int64(0,3160)),new T.ptr(new $Int64(0,12143),new $Int64(0,1548)),new T.ptr(new $Int64(0,12149),new $Int64(0,3893)),new T.ptr(new $Int64(0,12157),new $Int64(0,5391)),new T.ptr(new $Int64(0,12161),new $Int64(0,5803)),new T.ptr(new $Int64(0,12163),new $Int64(0,8353)),new T.ptr(new $Int64(0,12197),new $Int64(0,4503)),new T.ptr(new $Int64(0,12203),new $Int64(0,9181)),new T.ptr(new $Int64(0,12211),new $Int64(0,7615)),new T.ptr(new $Int64(0,12227),new $Int64(0,7467)),new T.ptr(new $Int64(0,12239),new $Int64(0,3607)),new T.ptr(new $Int64(0,12241),new $Int64(0,9734)),new T.ptr(new $Int64(0,12251),new $Int64(0,7489)),new T.ptr(new $Int64(0,12253),new $Int64(0,9899)),new T.ptr(new $Int64(0,12263),new $Int64(0,4871)),new T.ptr(new $Int64(0,12269),new $Int64(0,9925)),new T.ptr(new $Int64(0,12277),new $Int64(0,2145)),new T.ptr(new $Int64(0,12281),new $Int64(0,9455)),new T.ptr(new $Int64(0,12289),new $Int64(0,11486)),new T.ptr(new $Int64(0,12301),new $Int64(0,12135)),new T.ptr(new $Int64(0,12323),new $Int64(0,7794)),new T.ptr(new $Int64(0,12329),new $Int64(0,1124)),new T.ptr(new $Int64(0,12343),new $Int64(0,9013)),new T.ptr(new $Int64(0,12347),new $Int64(0,4913)),new T.ptr(new $Int64(0,12373),new $Int64(0,6399)),new T.ptr(new $Int64(0,12377),new $Int64(0,6826)),new T.ptr(new $Int64(0,12379),new $Int64(0,3201)),new T.ptr(new $Int64(0,12391),new $Int64(0,10073)),new T.ptr(new $Int64(0,12401),new $Int64(0,11926)),new T.ptr(new $Int64(0,12409),new $Int64(0,10718)),new T.ptr(new $Int64(0,12413),new $Int64(0,3241)),new T.ptr(new $Int64(0,12421),new $Int64(0,4771)),new T.ptr(new $Int64(0,12433),new $Int64(0,1704)),new T.ptr(new $Int64(0,12437),new $Int64(0,9139)),new T.ptr(new $Int64(0,12451),new $Int64(0,2130)),new T.ptr(new $Int64(0,12457),new $Int64(0,1660)),new T.ptr(new $Int64(0,12473),new $Int64(0,1967)),new T.ptr(new $Int64(0,12479),new $Int64(0,9724)),new T.ptr(new $Int64(0,12487),new $Int64(0,1112)),new T.ptr(new $Int64(0,12491),new $Int64(0,6887)),new T.ptr(new $Int64(0,12497),new $Int64(0,10263)),new T.ptr(new $Int64(0,12503),new $Int64(0,11324)),new T.ptr(new $Int64(0,12511),new $Int64(0,2259)),new T.ptr(new $Int64(0,12517),new $Int64(0,7939)),new T.ptr(new $Int64(0,12527),new $Int64(0,12437)),new T.ptr(new $Int64(0,12539),new $Int64(0,69)),new T.ptr(new $Int64(0,12541),new $Int64(0,2136)),new T.ptr(new $Int64(0,12547),new $Int64(0,6175)),new T.ptr(new $Int64(0,12553),new $Int64(0,8091)),new T.ptr(new $Int64(0,12569),new $Int64(0,2841)),new T.ptr(new $Int64(0,12577),new $Int64(0,7820)),new T.ptr(new $Int64(0,12583),new $Int64(0,1558)),new T.ptr(new $Int64(0,12589),new $Int64(0,12565)),new T.ptr(new $Int64(0,12601),new $Int64(0,7490)),new T.ptr(new $Int64(0,12611),new $Int64(0,9813)),new T.ptr(new $Int64(0,12613),new $Int64(0,2680)),new T.ptr(new $Int64(0,12619),new $Int64(0,7877)),new T.ptr(new $Int64(0,12637),new $Int64(0,2675)),new T.ptr(new $Int64(0,12641),new $Int64(0,5388)),new T.ptr(new $Int64(0,12647),new $Int64(0,8829)),new T.ptr(new $Int64(0,12653),new $Int64(0,8107)),new T.ptr(new $Int64(0,12659),new $Int64(0,10857)),new T.ptr(new $Int64(0,12671),new $Int64(0,9385)),new T.ptr(new $Int64(0,12689),new $Int64(0,11019)),new T.ptr(new $Int64(0,12697),new $Int64(0,3861)),new T.ptr(new $Int64(0,12703),new $Int64(0,1649)),new T.ptr(new $Int64(0,12713),new $Int64(0,4202)),new T.ptr(new $Int64(0,12721),new $Int64(0,5833)),new T.ptr(new $Int64(0,12739),new $Int64(0,11388)),new T.ptr(new $Int64(0,12743),new $Int64(0,11134)),new T.ptr(new $Int64(0,12757),new $Int64(0,5810)),new T.ptr(new $Int64(0,12763),new $Int64(0,6062)),new T.ptr(new $Int64(0,12781),new $Int64(0,4539)),new T.ptr(new $Int64(0,12791),new $Int64(0,133)),new T.ptr(new $Int64(0,12799),new $Int64(0,7024)),new T.ptr(new $Int64(0,12809),new $Int64(0,6427)),new T.ptr(new $Int64(0,12821),new $Int64(0,271)),new T.ptr(new $Int64(0,12823),new $Int64(0,5213)),new T.ptr(new $Int64(0,12829),new $Int64(0,2872)),new T.ptr(new $Int64(0,12841),new $Int64(0,12161)),new T.ptr(new $Int64(0,12853),new $Int64(0,12772)),new T.ptr(new $Int64(0,12889),new $Int64(0,7244)),new T.ptr(new $Int64(0,12893),new $Int64(0,6947)),new T.ptr(new $Int64(0,12899),new $Int64(0,10818)),new T.ptr(new $Int64(0,12907),new $Int64(0,3451)),new T.ptr(new $Int64(0,12911),new $Int64(0,7254)),new T.ptr(new $Int64(0,12917),new $Int64(0,12279)),new T.ptr(new $Int64(0,12919),new $Int64(0,8032)),new T.ptr(new $Int64(0,12923),new $Int64(0,3074)),new T.ptr(new $Int64(0,12941),new $Int64(0,3066)),new T.ptr(new $Int64(0,12953),new $Int64(0,11476)),new T.ptr(new $Int64(0,12959),new $Int64(0,26)),new T.ptr(new $Int64(0,12967),new $Int64(0,8694)),new T.ptr(new $Int64(0,12973),new $Int64(0,11673)),new T.ptr(new $Int64(0,12979),new $Int64(0,12575)),new T.ptr(new $Int64(0,12983),new $Int64(0,4288)),new T.ptr(new $Int64(0,13001),new $Int64(0,6022)),new T.ptr(new $Int64(0,13003),new $Int64(0,3565)),new T.ptr(new $Int64(0,13007),new $Int64(0,1102)),new T.ptr(new $Int64(0,13009),new $Int64(0,8754)),new T.ptr(new $Int64(0,13033),new $Int64(0,10106)),new T.ptr(new $Int64(0,13037),new $Int64(0,8551)),new T.ptr(new $Int64(0,13043),new $Int64(0,692)),new T.ptr(new $Int64(0,13049),new $Int64(0,1320)),new T.ptr(new $Int64(0,13063),new $Int64(0,10126)),new T.ptr(new $Int64(0,13093),new $Int64(0,1147)),new T.ptr(new $Int64(0,13099),new $Int64(0,12194)),new T.ptr(new $Int64(0,13103),new $Int64(0,1906)),new T.ptr(new $Int64(0,13109),new $Int64(0,429)),new T.ptr(new $Int64(0,13121),new $Int64(0,2119)),new T.ptr(new $Int64(0,13127),new $Int64(0,1899)),new T.ptr(new $Int64(0,13147),new $Int64(0,9189)),new T.ptr(new $Int64(0,13151),new $Int64(0,10358)),new T.ptr(new $Int64(0,13159),new $Int64(0,5368)),new T.ptr(new $Int64(0,13163),new $Int64(0,2158)),new T.ptr(new $Int64(0,13171),new $Int64(0,5490)),new T.ptr(new $Int64(0,13177),new $Int64(0,7706)),new T.ptr(new $Int64(0,13183),new $Int64(0,9442)),new T.ptr(new $Int64(0,13187),new $Int64(0,9397)),new T.ptr(new $Int64(0,13217),new $Int64(0,6365)),new T.ptr(new $Int64(0,13219),new $Int64(0,8410)),new T.ptr(new $Int64(0,13229),new $Int64(0,2336)),new T.ptr(new $Int64(0,13241),new $Int64(0,6530)),new T.ptr(new $Int64(0,13249),new $Int64(0,3105)),new T.ptr(new $Int64(0,13259),new $Int64(0,6974)),new T.ptr(new $Int64(0,13267),new $Int64(0,2646)),new T.ptr(new $Int64(0,13291),new $Int64(0,10081)),new T.ptr(new $Int64(0,13297),new $Int64(0,8002)),new T.ptr(new $Int64(0,13309),new $Int64(0,4083)),new T.ptr(new $Int64(0,13313),new $Int64(0,703)),new T.ptr(new $Int64(0,13327),new $Int64(0,1280)),new T.ptr(new $Int64(0,13331),new $Int64(0,12291)),new T.ptr(new $Int64(0,13337),new $Int64(0,1533)),new T.ptr(new $Int64(0,13339),new $Int64(0,9086)),new T.ptr(new $Int64(0,13367),new $Int64(0,1680)),new T.ptr(new $Int64(0,13381),new $Int64(0,12385)),new T.ptr(new $Int64(0,13397),new $Int64(0,8399)),new T.ptr(new $Int64(0,13399),new $Int64(0,9843)),new T.ptr(new $Int64(0,13411),new $Int64(0,3567)),new T.ptr(new $Int64(0,13417),new $Int64(0,2056)),new T.ptr(new $Int64(0,13421),new $Int64(0,7202)),new T.ptr(new $Int64(0,13441),new $Int64(0,11937)),new T.ptr(new $Int64(0,13451),new $Int64(0,9526)),new T.ptr(new $Int64(0,13457),new $Int64(0,10191)),new T.ptr(new $Int64(0,13463),new $Int64(0,2456)),new T.ptr(new $Int64(0,13469),new $Int64(0,4612)),new T.ptr(new $Int64(0,13477),new $Int64(0,12937)),new T.ptr(new $Int64(0,13487),new $Int64(0,13188)),new T.ptr(new $Int64(0,13499),new $Int64(0,13371)),new T.ptr(new $Int64(0,13513),new $Int64(0,2365)),new T.ptr(new $Int64(0,13523),new $Int64(0,6459)),new T.ptr(new $Int64(0,13537),new $Int64(0,8187)),new T.ptr(new $Int64(0,13553),new $Int64(0,3058)),new T.ptr(new $Int64(0,13567),new $Int64(0,8771)),new T.ptr(new $Int64(0,13577),new $Int64(0,12981)),new T.ptr(new $Int64(0,13591),new $Int64(0,4382)),new T.ptr(new $Int64(0,13597),new $Int64(0,8950)),new T.ptr(new $Int64(0,13613),new $Int64(0,1664)),new T.ptr(new $Int64(0,13619),new $Int64(0,3245)),new T.ptr(new $Int64(0,13627),new $Int64(0,2922)),new T.ptr(new $Int64(0,13633),new $Int64(0,8147)),new T.ptr(new $Int64(0,13649),new $Int64(0,5894)),new T.ptr(new $Int64(0,13669),new $Int64(0,1913)),new T.ptr(new $Int64(0,13679),new $Int64(0,8008)),new T.ptr(new $Int64(0,13681),new $Int64(0,2337)),new T.ptr(new $Int64(0,13687),new $Int64(0,7659)),new T.ptr(new $Int64(0,13691),new $Int64(0,9737)),new T.ptr(new $Int64(0,13693),new $Int64(0,5276)),new T.ptr(new $Int64(0,13697),new $Int64(0,12220)),new T.ptr(new $Int64(0,13709),new $Int64(0,4927)),new T.ptr(new $Int64(0,13711),new $Int64(0,8434)),new T.ptr(new $Int64(0,13721),new $Int64(0,13497)),new T.ptr(new $Int64(0,13723),new $Int64(0,9959)),new T.ptr(new $Int64(0,13729),new $Int64(0,6276)),new T.ptr(new $Int64(0,13751),new $Int64(0,4168)),new T.ptr(new $Int64(0,13757),new $Int64(0,2399)),new T.ptr(new $Int64(0,13759),new $Int64(0,12884)),new T.ptr(new $Int64(0,13763),new $Int64(0,13572)),new T.ptr(new $Int64(0,13781),new $Int64(0,11842)),new T.ptr(new $Int64(0,13789),new $Int64(0,3817)),new T.ptr(new $Int64(0,13799),new $Int64(0,5142)),new T.ptr(new $Int64(0,13807),new $Int64(0,1533)),new T.ptr(new $Int64(0,13829),new $Int64(0,8493)),new T.ptr(new $Int64(0,13831),new $Int64(0,7209)),new T.ptr(new $Int64(0,13841),new $Int64(0,9218)),new T.ptr(new $Int64(0,13859),new $Int64(0,12260)),new T.ptr(new $Int64(0,13873),new $Int64(0,8332)),new T.ptr(new $Int64(0,13877),new $Int64(0,9199)),new T.ptr(new $Int64(0,13879),new $Int64(0,12109)),new T.ptr(new $Int64(0,13883),new $Int64(0,3552)),new T.ptr(new $Int64(0,13901),new $Int64(0,9376)),new T.ptr(new $Int64(0,13903),new $Int64(0,2027)),new T.ptr(new $Int64(0,13907),new $Int64(0,10049)),new T.ptr(new $Int64(0,13913),new $Int64(0,11298)),new T.ptr(new $Int64(0,13921),new $Int64(0,5521)),new T.ptr(new $Int64(0,13931),new $Int64(0,3645)),new T.ptr(new $Int64(0,13933),new $Int64(0,6482)),new T.ptr(new $Int64(0,13963),new $Int64(0,10454)),new T.ptr(new $Int64(0,13967),new $Int64(0,5146)),new T.ptr(new $Int64(0,13997),new $Int64(0,11376)),new T.ptr(new $Int64(0,13999),new $Int64(0,10997)),new T.ptr(new $Int64(0,14009),new $Int64(0,12935)),new T.ptr(new $Int64(0,14011),new $Int64(0,11131)),new T.ptr(new $Int64(0,14029),new $Int64(0,13764)),new T.ptr(new $Int64(0,14033),new $Int64(0,2942)),new T.ptr(new $Int64(0,14051),new $Int64(0,8842)),new T.ptr(new $Int64(0,14057),new $Int64(0,3329)),new T.ptr(new $Int64(0,14071),new $Int64(0,5830)),new T.ptr(new $Int64(0,14081),new $Int64(0,10883)),new T.ptr(new $Int64(0,14083),new $Int64(0,2820)),new T.ptr(new $Int64(0,14087),new $Int64(0,13254)),new T.ptr(new $Int64(0,14107),new $Int64(0,8042)),new T.ptr(new $Int64(0,14143),new $Int64(0,12588)),new T.ptr(new $Int64(0,14149),new $Int64(0,12652)),new T.ptr(new $Int64(0,14153),new $Int64(0,12624)),new T.ptr(new $Int64(0,14159),new $Int64(0,3211)),new T.ptr(new $Int64(0,14173),new $Int64(0,10190)),new T.ptr(new $Int64(0,14177),new $Int64(0,10453)),new T.ptr(new $Int64(0,14197),new $Int64(0,6324)),new T.ptr(new $Int64(0,14207),new $Int64(0,8442)),new T.ptr(new $Int64(0,14221),new $Int64(0,12168)),new T.ptr(new $Int64(0,14243),new $Int64(0,8240)),new T.ptr(new $Int64(0,14249),new $Int64(0,13484)),new T.ptr(new $Int64(0,14251),new $Int64(0,8275)),new T.ptr(new $Int64(0,14281),new $Int64(0,11185)),new T.ptr(new $Int64(0,14293),new $Int64(0,11133)),new T.ptr(new $Int64(0,14303),new $Int64(0,11011)),new T.ptr(new $Int64(0,14321),new $Int64(0,11512)),new T.ptr(new $Int64(0,14323),new $Int64(0,7547)),new T.ptr(new $Int64(0,14327),new $Int64(0,13809)),new T.ptr(new $Int64(0,14341),new $Int64(0,5838)),new T.ptr(new $Int64(0,14347),new $Int64(0,11418)),new T.ptr(new $Int64(0,14369),new $Int64(0,11875)),new T.ptr(new $Int64(0,14387),new $Int64(0,7162)),new T.ptr(new $Int64(0,14389),new $Int64(0,12191)),new T.ptr(new $Int64(0,14401),new $Int64(0,10833)),new T.ptr(new $Int64(0,14407),new $Int64(0,12538)),new T.ptr(new $Int64(0,14411),new $Int64(0,12207)),new T.ptr(new $Int64(0,14419),new $Int64(0,12789)),new T.ptr(new $Int64(0,14423),new $Int64(0,2415)),new T.ptr(new $Int64(0,14431),new $Int64(0,4451)),new T.ptr(new $Int64(0,14437),new $Int64(0,9301)),new T.ptr(new $Int64(0,14447),new $Int64(0,12568)),new T.ptr(new $Int64(0,14449),new $Int64(0,12812)),new T.ptr(new $Int64(0,14461),new $Int64(0,4630)),new T.ptr(new $Int64(0,14479),new $Int64(0,9566)),new T.ptr(new $Int64(0,14489),new $Int64(0,12640)),new T.ptr(new $Int64(0,14503),new $Int64(0,825)),new T.ptr(new $Int64(0,14519),new $Int64(0,6063)),new T.ptr(new $Int64(0,14533),new $Int64(0,1941)),new T.ptr(new $Int64(0,14537),new $Int64(0,3007)),new T.ptr(new $Int64(0,14543),new $Int64(0,13869)),new T.ptr(new $Int64(0,14549),new $Int64(0,4008)),new T.ptr(new $Int64(0,14551),new $Int64(0,98)),new T.ptr(new $Int64(0,14557),new $Int64(0,14410)),new T.ptr(new $Int64(0,14561),new $Int64(0,7501)),new T.ptr(new $Int64(0,14563),new $Int64(0,5884)),new T.ptr(new $Int64(0,14591),new $Int64(0,14320)),new T.ptr(new $Int64(0,14593),new $Int64(0,134)),new T.ptr(new $Int64(0,14621),new $Int64(0,8883)),new T.ptr(new $Int64(0,14627),new $Int64(0,8845)),new T.ptr(new $Int64(0,14629),new $Int64(0,469)),new T.ptr(new $Int64(0,14633),new $Int64(0,7848)),new T.ptr(new $Int64(0,14639),new $Int64(0,14566)),new T.ptr(new $Int64(0,14653),new $Int64(0,10418)),new T.ptr(new $Int64(0,14657),new $Int64(0,14570)),new T.ptr(new $Int64(0,14669),new $Int64(0,13625)),new T.ptr(new $Int64(0,14683),new $Int64(0,1664)),new T.ptr(new $Int64(0,14699),new $Int64(0,1285)),new T.ptr(new $Int64(0,14713),new $Int64(0,1017)),new T.ptr(new $Int64(0,14717),new $Int64(0,9550)),new T.ptr(new $Int64(0,14723),new $Int64(0,3561)),new T.ptr(new $Int64(0,14731),new $Int64(0,5375)),new T.ptr(new $Int64(0,14737),new $Int64(0,3068)),new T.ptr(new $Int64(0,14741),new $Int64(0,12932)),new T.ptr(new $Int64(0,14747),new $Int64(0,13956)),new T.ptr(new $Int64(0,14753),new $Int64(0,1457)),new T.ptr(new $Int64(0,14759),new $Int64(0,3524)),new T.ptr(new $Int64(0,14767),new $Int64(0,14179)),new T.ptr(new $Int64(0,14771),new $Int64(0,8513)),new T.ptr(new $Int64(0,14779),new $Int64(0,7867)),new T.ptr(new $Int64(0,14783),new $Int64(0,2047)),new T.ptr(new $Int64(0,14797),new $Int64(0,10139)),new T.ptr(new $Int64(0,14813),new $Int64(0,7434)),new T.ptr(new $Int64(0,14821),new $Int64(0,1251)),new T.ptr(new $Int64(0,14827),new $Int64(0,9119)),new T.ptr(new $Int64(0,14831),new $Int64(0,3073)),new T.ptr(new $Int64(0,14843),new $Int64(0,10841)),new T.ptr(new $Int64(0,14851),new $Int64(0,5671)),new T.ptr(new $Int64(0,14867),new $Int64(0,8099)),new T.ptr(new $Int64(0,14869),new $Int64(0,5334)),new T.ptr(new $Int64(0,14879),new $Int64(0,3077)),new T.ptr(new $Int64(0,14887),new $Int64(0,8970)),new T.ptr(new $Int64(0,14891),new $Int64(0,8121)),new T.ptr(new $Int64(0,14897),new $Int64(0,6549)),new T.ptr(new $Int64(0,14923),new $Int64(0,588)),new T.ptr(new $Int64(0,14929),new $Int64(0,12477)),new T.ptr(new $Int64(0,14939),new $Int64(0,5037)),new T.ptr(new $Int64(0,14947),new $Int64(0,577)),new T.ptr(new $Int64(0,14951),new $Int64(0,4935)),new T.ptr(new $Int64(0,14957),new $Int64(0,10154)),new T.ptr(new $Int64(0,14969),new $Int64(0,6793)),new T.ptr(new $Int64(0,14983),new $Int64(0,11764)),new T.ptr(new $Int64(0,15013),new $Int64(0,2815)),new T.ptr(new $Int64(0,15017),new $Int64(0,8447)),new T.ptr(new $Int64(0,15031),new $Int64(0,822)),new T.ptr(new $Int64(0,15053),new $Int64(0,10547)),new T.ptr(new $Int64(0,15061),new $Int64(0,4461)),new T.ptr(new $Int64(0,15073),new $Int64(0,1072)),new T.ptr(new $Int64(0,15077),new $Int64(0,4286)),new T.ptr(new $Int64(0,15083),new $Int64(0,10730)),new T.ptr(new $Int64(0,15091),new $Int64(0,6230)),new T.ptr(new $Int64(0,15101),new $Int64(0,13806)),new T.ptr(new $Int64(0,15107),new $Int64(0,10735)),new T.ptr(new $Int64(0,15121),new $Int64(0,10574)),new T.ptr(new $Int64(0,15131),new $Int64(0,12832)),new T.ptr(new $Int64(0,15137),new $Int64(0,10934)),new T.ptr(new $Int64(0,15139),new $Int64(0,3098)),new T.ptr(new $Int64(0,15149),new $Int64(0,7306)),new T.ptr(new $Int64(0,15161),new $Int64(0,5932)),new T.ptr(new $Int64(0,15173),new $Int64(0,3037)),new T.ptr(new $Int64(0,15187),new $Int64(0,298)),new T.ptr(new $Int64(0,15193),new $Int64(0,8290)),new T.ptr(new $Int64(0,15199),new $Int64(0,8250)),new T.ptr(new $Int64(0,15217),new $Int64(0,3776)),new T.ptr(new $Int64(0,15227),new $Int64(0,2469)),new T.ptr(new $Int64(0,15233),new $Int64(0,987)),new T.ptr(new $Int64(0,15241),new $Int64(0,1020)),new T.ptr(new $Int64(0,15259),new $Int64(0,2650)),new T.ptr(new $Int64(0,15263),new $Int64(0,12055)),new T.ptr(new $Int64(0,15269),new $Int64(0,15006)),new T.ptr(new $Int64(0,15271),new $Int64(0,7807)),new T.ptr(new $Int64(0,15277),new $Int64(0,9949)),new T.ptr(new $Int64(0,15287),new $Int64(0,10840)),new T.ptr(new $Int64(0,15289),new $Int64(0,13343)),new T.ptr(new $Int64(0,15299),new $Int64(0,5892)),new T.ptr(new $Int64(0,15307),new $Int64(0,7778)),new T.ptr(new $Int64(0,15313),new $Int64(0,1548)),new T.ptr(new $Int64(0,15319),new $Int64(0,13549)),new T.ptr(new $Int64(0,15329),new $Int64(0,13480)),new T.ptr(new $Int64(0,15331),new $Int64(0,10158)),new T.ptr(new $Int64(0,15349),new $Int64(0,12023)),new T.ptr(new $Int64(0,15359),new $Int64(0,10710)),new T.ptr(new $Int64(0,15361),new $Int64(0,12614)),new T.ptr(new $Int64(0,15373),new $Int64(0,11621)),new T.ptr(new $Int64(0,15377),new $Int64(0,600)),new T.ptr(new $Int64(0,15383),new $Int64(0,10905)),new T.ptr(new $Int64(0,15391),new $Int64(0,11620)),new T.ptr(new $Int64(0,15401),new $Int64(0,11057)),new T.ptr(new $Int64(0,15413),new $Int64(0,760)),new T.ptr(new $Int64(0,15427),new $Int64(0,5743)),new T.ptr(new $Int64(0,15439),new $Int64(0,11866)),new T.ptr(new $Int64(0,15443),new $Int64(0,10369)),new T.ptr(new $Int64(0,15451),new $Int64(0,5329)),new T.ptr(new $Int64(0,15461),new $Int64(0,15448)),new T.ptr(new $Int64(0,15467),new $Int64(0,5351)),new T.ptr(new $Int64(0,15473),new $Int64(0,11761)),new T.ptr(new $Int64(0,15493),new $Int64(0,8415)),new T.ptr(new $Int64(0,15497),new $Int64(0,9553)),new T.ptr(new $Int64(0,15511),new $Int64(0,5156)),new T.ptr(new $Int64(0,15527),new $Int64(0,10762)),new T.ptr(new $Int64(0,15541),new $Int64(0,13639)),new T.ptr(new $Int64(0,15551),new $Int64(0,1389)),new T.ptr(new $Int64(0,15559),new $Int64(0,4544)),new T.ptr(new $Int64(0,15569),new $Int64(0,6692)),new T.ptr(new $Int64(0,15581),new $Int64(0,13451)),new T.ptr(new $Int64(0,15583),new $Int64(0,13714)),new T.ptr(new $Int64(0,15601),new $Int64(0,10333)),new T.ptr(new $Int64(0,15607),new $Int64(0,9092)),new T.ptr(new $Int64(0,15619),new $Int64(0,14103)),new T.ptr(new $Int64(0,15629),new $Int64(0,15594)),new T.ptr(new $Int64(0,15641),new $Int64(0,14120)),new T.ptr(new $Int64(0,15643),new $Int64(0,3945)),new T.ptr(new $Int64(0,15647),new $Int64(0,294)),new T.ptr(new $Int64(0,15649),new $Int64(0,7951)),new T.ptr(new $Int64(0,15661),new $Int64(0,14464)),new T.ptr(new $Int64(0,15667),new $Int64(0,14018)),new T.ptr(new $Int64(0,15671),new $Int64(0,1932)),new T.ptr(new $Int64(0,15679),new $Int64(0,7931)),new T.ptr(new $Int64(0,15683),new $Int64(0,14964)),new T.ptr(new $Int64(0,15727),new $Int64(0,15415)),new T.ptr(new $Int64(0,15731),new $Int64(0,6929)),new T.ptr(new $Int64(0,15733),new $Int64(0,9677)),new T.ptr(new $Int64(0,15737),new $Int64(0,15282)),new T.ptr(new $Int64(0,15739),new $Int64(0,13095)),new T.ptr(new $Int64(0,15749),new $Int64(0,15226)),new T.ptr(new $Int64(0,15761),new $Int64(0,14496)),new T.ptr(new $Int64(0,15767),new $Int64(0,12850)),new T.ptr(new $Int64(0,15773),new $Int64(0,6214)),new T.ptr(new $Int64(0,15787),new $Int64(0,2707)),new T.ptr(new $Int64(0,15791),new $Int64(0,4108)),new T.ptr(new $Int64(0,15797),new $Int64(0,15143)),new T.ptr(new $Int64(0,15803),new $Int64(0,6064)),new T.ptr(new $Int64(0,15809),new $Int64(0,14139)),new T.ptr(new $Int64(0,15817),new $Int64(0,5426)),new T.ptr(new $Int64(0,15823),new $Int64(0,2465)),new T.ptr(new $Int64(0,15859),new $Int64(0,14795)),new T.ptr(new $Int64(0,15877),new $Int64(0,13623)),new T.ptr(new $Int64(0,15881),new $Int64(0,13591)),new T.ptr(new $Int64(0,15887),new $Int64(0,13662)),new T.ptr(new $Int64(0,15889),new $Int64(0,7565)),new T.ptr(new $Int64(0,15901),new $Int64(0,4821)),new T.ptr(new $Int64(0,15907),new $Int64(0,8941)),new T.ptr(new $Int64(0,15913),new $Int64(0,9589)),new T.ptr(new $Int64(0,15919),new $Int64(0,13698)),new T.ptr(new $Int64(0,15923),new $Int64(0,2865)),new T.ptr(new $Int64(0,15937),new $Int64(0,659)),new T.ptr(new $Int64(0,15959),new $Int64(0,5357)),new T.ptr(new $Int64(0,15971),new $Int64(0,13321)),new T.ptr(new $Int64(0,15973),new $Int64(0,8197)),new T.ptr(new $Int64(0,15991),new $Int64(0,1194)),new T.ptr(new $Int64(0,16001),new $Int64(0,12303)),new T.ptr(new $Int64(0,16007),new $Int64(0,1660)),new T.ptr(new $Int64(0,16033),new $Int64(0,15027)),new T.ptr(new $Int64(0,16057),new $Int64(0,2637)),new T.ptr(new $Int64(0,16061),new $Int64(0,14443)),new T.ptr(new $Int64(0,16063),new $Int64(0,6129)),new T.ptr(new $Int64(0,16067),new $Int64(0,21)),new T.ptr(new $Int64(0,16069),new $Int64(0,13502)),new T.ptr(new $Int64(0,16073),new $Int64(0,3177)),new T.ptr(new $Int64(0,16087),new $Int64(0,15800)),new T.ptr(new $Int64(0,16091),new $Int64(0,11042)),new T.ptr(new $Int64(0,16097),new $Int64(0,4584)),new T.ptr(new $Int64(0,16103),new $Int64(0,1345)),new T.ptr(new $Int64(0,16111),new $Int64(0,13081)),new T.ptr(new $Int64(0,16127),new $Int64(0,9744)),new T.ptr(new $Int64(0,16139),new $Int64(0,3394)),new T.ptr(new $Int64(0,16141),new $Int64(0,6861)),new T.ptr(new $Int64(0,16183),new $Int64(0,10653)),new T.ptr(new $Int64(0,16187),new $Int64(0,10419)),new T.ptr(new $Int64(0,16189),new $Int64(0,1360)),new T.ptr(new $Int64(0,16193),new $Int64(0,2586)),new T.ptr(new $Int64(0,16217),new $Int64(0,5169)),new T.ptr(new $Int64(0,16223),new $Int64(0,10366)),new T.ptr(new $Int64(0,16229),new $Int64(0,2428)),new T.ptr(new $Int64(0,16231),new $Int64(0,6125)),new T.ptr(new $Int64(0,16249),new $Int64(0,14473)),new T.ptr(new $Int64(0,16253),new $Int64(0,5916)),new T.ptr(new $Int64(0,16267),new $Int64(0,12426)),new T.ptr(new $Int64(0,16273),new $Int64(0,9367)),new T.ptr(new $Int64(0,16301),new $Int64(0,4774)),new T.ptr(new $Int64(0,16319),new $Int64(0,2201)),new T.ptr(new $Int64(0,16333),new $Int64(0,14011)),new T.ptr(new $Int64(0,16339),new $Int64(0,634)),new T.ptr(new $Int64(0,16349),new $Int64(0,9469)),new T.ptr(new $Int64(0,16361),new $Int64(0,9981)),new T.ptr(new $Int64(0,16363),new $Int64(0,7919)),new T.ptr(new $Int64(0,16369),new $Int64(0,14678)),new T.ptr(new $Int64(0,16381),new $Int64(0,5212)),new T.ptr(new $Int64(0,16411),new $Int64(0,8398)),new T.ptr(new $Int64(0,16417),new $Int64(0,10306)),new T.ptr(new $Int64(0,16421),new $Int64(0,14291)),new T.ptr(new $Int64(0,16427),new $Int64(0,842)),new T.ptr(new $Int64(0,16433),new $Int64(0,1508)),new T.ptr(new $Int64(0,16447),new $Int64(0,6706)),new T.ptr(new $Int64(0,16451),new $Int64(0,14313)),new T.ptr(new $Int64(0,16453),new $Int64(0,13062)),new T.ptr(new $Int64(0,16477),new $Int64(0,8640)),new T.ptr(new $Int64(0,16481),new $Int64(0,10614)),new T.ptr(new $Int64(0,16487),new $Int64(0,5498)),new T.ptr(new $Int64(0,16493),new $Int64(0,2395)),new T.ptr(new $Int64(0,16519),new $Int64(0,5699)),new T.ptr(new $Int64(0,16529),new $Int64(0,4281)),new T.ptr(new $Int64(0,16547),new $Int64(0,15957)),new T.ptr(new $Int64(0,16553),new $Int64(0,13078)),new T.ptr(new $Int64(0,16561),new $Int64(0,6750)),new T.ptr(new $Int64(0,16567),new $Int64(0,9403)),new T.ptr(new $Int64(0,16573),new $Int64(0,16452)),new T.ptr(new $Int64(0,16603),new $Int64(0,12613)),new T.ptr(new $Int64(0,16607),new $Int64(0,12141)),new T.ptr(new $Int64(0,16619),new $Int64(0,8044)),new T.ptr(new $Int64(0,16631),new $Int64(0,256)),new T.ptr(new $Int64(0,16633),new $Int64(0,2047)),new T.ptr(new $Int64(0,16649),new $Int64(0,13726)),new T.ptr(new $Int64(0,16651),new $Int64(0,7739)),new T.ptr(new $Int64(0,16657),new $Int64(0,123)),new T.ptr(new $Int64(0,16661),new $Int64(0,2466)),new T.ptr(new $Int64(0,16673),new $Int64(0,13939)),new T.ptr(new $Int64(0,16691),new $Int64(0,1149)),new T.ptr(new $Int64(0,16693),new $Int64(0,10601)),new T.ptr(new $Int64(0,16699),new $Int64(0,13827)),new T.ptr(new $Int64(0,16703),new $Int64(0,10923)),new T.ptr(new $Int64(0,16729),new $Int64(0,15803)),new T.ptr(new $Int64(0,16741),new $Int64(0,2266)),new T.ptr(new $Int64(0,16747),new $Int64(0,4026)),new T.ptr(new $Int64(0,16759),new $Int64(0,14538)),new T.ptr(new $Int64(0,16763),new $Int64(0,9229)),new T.ptr(new $Int64(0,16787),new $Int64(0,3594)),new T.ptr(new $Int64(0,16811),new $Int64(0,1913)),new T.ptr(new $Int64(0,16823),new $Int64(0,14598)),new T.ptr(new $Int64(0,16829),new $Int64(0,6704)),new T.ptr(new $Int64(0,16831),new $Int64(0,4670)),new T.ptr(new $Int64(0,16843),new $Int64(0,630)),new T.ptr(new $Int64(0,16871),new $Int64(0,5771)),new T.ptr(new $Int64(0,16879),new $Int64(0,16244)),new T.ptr(new $Int64(0,16883),new $Int64(0,862)),new T.ptr(new $Int64(0,16889),new $Int64(0,6517)),new T.ptr(new $Int64(0,16901),new $Int64(0,14962)),new T.ptr(new $Int64(0,16903),new $Int64(0,10232)),new T.ptr(new $Int64(0,16921),new $Int64(0,12137)),new T.ptr(new $Int64(0,16927),new $Int64(0,10233)),new T.ptr(new $Int64(0,16931),new $Int64(0,13868)),new T.ptr(new $Int64(0,16937),new $Int64(0,11219)),new T.ptr(new $Int64(0,16943),new $Int64(0,12671)),new T.ptr(new $Int64(0,16963),new $Int64(0,13039)),new T.ptr(new $Int64(0,16979),new $Int64(0,14138)),new T.ptr(new $Int64(0,16981),new $Int64(0,11018)),new T.ptr(new $Int64(0,16987),new $Int64(0,11839)),new T.ptr(new $Int64(0,16993),new $Int64(0,1599)),new T.ptr(new $Int64(0,17011),new $Int64(0,14483)),new T.ptr(new $Int64(0,17021),new $Int64(0,1312)),new T.ptr(new $Int64(0,17027),new $Int64(0,8102)),new T.ptr(new $Int64(0,17029),new $Int64(0,4884)),new T.ptr(new $Int64(0,17033),new $Int64(0,14274)),new T.ptr(new $Int64(0,17041),new $Int64(0,7201)),new T.ptr(new $Int64(0,17047),new $Int64(0,7155)),new T.ptr(new $Int64(0,17053),new $Int64(0,14799)),new T.ptr(new $Int64(0,17077),new $Int64(0,14755)),new T.ptr(new $Int64(0,17093),new $Int64(0,3353)),new T.ptr(new $Int64(0,17099),new $Int64(0,15297)),new T.ptr(new $Int64(0,17107),new $Int64(0,8761)),new T.ptr(new $Int64(0,17117),new $Int64(0,8132)),new T.ptr(new $Int64(0,17123),new $Int64(0,8264)),new T.ptr(new $Int64(0,17137),new $Int64(0,3619)),new T.ptr(new $Int64(0,17159),new $Int64(0,7354)),new T.ptr(new $Int64(0,17167),new $Int64(0,9109)),new T.ptr(new $Int64(0,17183),new $Int64(0,16009)),new T.ptr(new $Int64(0,17189),new $Int64(0,13802)),new T.ptr(new $Int64(0,17191),new $Int64(0,8239)),new T.ptr(new $Int64(0,17203),new $Int64(0,4115)),new T.ptr(new $Int64(0,17207),new $Int64(0,5910)),new T.ptr(new $Int64(0,17209),new $Int64(0,12543)),new T.ptr(new $Int64(0,17231),new $Int64(0,3467)),new T.ptr(new $Int64(0,17239),new $Int64(0,12750)),new T.ptr(new $Int64(0,17257),new $Int64(0,10954)),new T.ptr(new $Int64(0,17291),new $Int64(0,14802)),new T.ptr(new $Int64(0,17293),new $Int64(0,6594)),new T.ptr(new $Int64(0,17299),new $Int64(0,11023)),new T.ptr(new $Int64(0,17317),new $Int64(0,7264)),new T.ptr(new $Int64(0,17321),new $Int64(0,15031)),new T.ptr(new $Int64(0,17327),new $Int64(0,10746)),new T.ptr(new $Int64(0,17333),new $Int64(0,7729)),new T.ptr(new $Int64(0,17341),new $Int64(0,15288)),new T.ptr(new $Int64(0,17351),new $Int64(0,13302)),new T.ptr(new $Int64(0,17359),new $Int64(0,162)),new T.ptr(new $Int64(0,17377),new $Int64(0,1899)),new T.ptr(new $Int64(0,17383),new $Int64(0,902)),new T.ptr(new $Int64(0,17387),new $Int64(0,15308)),new T.ptr(new $Int64(0,17389),new $Int64(0,5630)),new T.ptr(new $Int64(0,17393),new $Int64(0,9363)),new T.ptr(new $Int64(0,17401),new $Int64(0,6849)),new T.ptr(new $Int64(0,17417),new $Int64(0,9362)),new T.ptr(new $Int64(0,17419),new $Int64(0,16929)),new T.ptr(new $Int64(0,17431),new $Int64(0,13195)),new T.ptr(new $Int64(0,17443),new $Int64(0,2395)),new T.ptr(new $Int64(0,17449),new $Int64(0,13973)),new T.ptr(new $Int64(0,17467),new $Int64(0,9591)),new T.ptr(new $Int64(0,17471),new $Int64(0,3812)),new T.ptr(new $Int64(0,17477),new $Int64(0,1843)),new T.ptr(new $Int64(0,17483),new $Int64(0,4508)),new T.ptr(new $Int64(0,17489),new $Int64(0,10138)),new T.ptr(new $Int64(0,17491),new $Int64(0,13022)),new T.ptr(new $Int64(0,17497),new $Int64(0,14812)),new T.ptr(new $Int64(0,17509),new $Int64(0,10514)),new T.ptr(new $Int64(0,17519),new $Int64(0,9976)),new T.ptr(new $Int64(0,17539),new $Int64(0,3484)),new T.ptr(new $Int64(0,17551),new $Int64(0,17038)),new T.ptr(new $Int64(0,17569),new $Int64(0,13525)),new T.ptr(new $Int64(0,17573),new $Int64(0,10838)),new T.ptr(new $Int64(0,17579),new $Int64(0,10177)),new T.ptr(new $Int64(0,17581),new $Int64(0,12707)),new T.ptr(new $Int64(0,17597),new $Int64(0,10786)),new T.ptr(new $Int64(0,17599),new $Int64(0,12313)),new T.ptr(new $Int64(0,17609),new $Int64(0,6443)),new T.ptr(new $Int64(0,17623),new $Int64(0,87)),new T.ptr(new $Int64(0,17627),new $Int64(0,8951)),new T.ptr(new $Int64(0,17657),new $Int64(0,4111)),new T.ptr(new $Int64(0,17659),new $Int64(0,17568)),new T.ptr(new $Int64(0,17669),new $Int64(0,11981)),new T.ptr(new $Int64(0,17681),new $Int64(0,8649)),new T.ptr(new $Int64(0,17683),new $Int64(0,6226)),new T.ptr(new $Int64(0,17707),new $Int64(0,2081)),new T.ptr(new $Int64(0,17713),new $Int64(0,2233)),new T.ptr(new $Int64(0,17729),new $Int64(0,13536)),new T.ptr(new $Int64(0,17737),new $Int64(0,10355)),new T.ptr(new $Int64(0,17747),new $Int64(0,12806)),new T.ptr(new $Int64(0,17749),new $Int64(0,17396)),new T.ptr(new $Int64(0,17761),new $Int64(0,16714)),new T.ptr(new $Int64(0,17783),new $Int64(0,10439)),new T.ptr(new $Int64(0,17789),new $Int64(0,16985)),new T.ptr(new $Int64(0,17791),new $Int64(0,8100)),new T.ptr(new $Int64(0,17807),new $Int64(0,7895)),new T.ptr(new $Int64(0,17827),new $Int64(0,17785)),new T.ptr(new $Int64(0,17837),new $Int64(0,10648)),new T.ptr(new $Int64(0,17839),new $Int64(0,3802)),new T.ptr(new $Int64(0,17851),new $Int64(0,15323)),new T.ptr(new $Int64(0,17863),new $Int64(0,11634)),new T.ptr(new $Int64(0,17881),new $Int64(0,7681)),new T.ptr(new $Int64(0,17891),new $Int64(0,8220)),new T.ptr(new $Int64(0,17903),new $Int64(0,1549)),new T.ptr(new $Int64(0,17909),new $Int64(0,6186)),new T.ptr(new $Int64(0,17911),new $Int64(0,8763)),new T.ptr(new $Int64(0,17921),new $Int64(0,15122)),new T.ptr(new $Int64(0,17923),new $Int64(0,12631)),new T.ptr(new $Int64(0,17929),new $Int64(0,15844)),new T.ptr(new $Int64(0,17939),new $Int64(0,14794)),new T.ptr(new $Int64(0,17957),new $Int64(0,4136)),new T.ptr(new $Int64(0,17959),new $Int64(0,1872)),new T.ptr(new $Int64(0,17971),new $Int64(0,2428)),new T.ptr(new $Int64(0,17977),new $Int64(0,17122)),new T.ptr(new $Int64(0,17981),new $Int64(0,1871)),new T.ptr(new $Int64(0,17987),new $Int64(0,15405)),new T.ptr(new $Int64(0,17989),new $Int64(0,5986)),new T.ptr(new $Int64(0,18013),new $Int64(0,12429)),new T.ptr(new $Int64(0,18041),new $Int64(0,4824)),new T.ptr(new $Int64(0,18043),new $Int64(0,7975)),new T.ptr(new $Int64(0,18047),new $Int64(0,10237)),new T.ptr(new $Int64(0,18049),new $Int64(0,786)),new T.ptr(new $Int64(0,18059),new $Int64(0,17112)),new T.ptr(new $Int64(0,18061),new $Int64(0,63)),new T.ptr(new $Int64(0,18077),new $Int64(0,14385)),new T.ptr(new $Int64(0,18089),new $Int64(0,13847)),new T.ptr(new $Int64(0,18097),new $Int64(0,1363)),new T.ptr(new $Int64(0,18119),new $Int64(0,13069)),new T.ptr(new $Int64(0,18121),new $Int64(0,16564)),new T.ptr(new $Int64(0,18127),new $Int64(0,10053)),new T.ptr(new $Int64(0,18131),new $Int64(0,1067)),new T.ptr(new $Int64(0,18133),new $Int64(0,3871)),new T.ptr(new $Int64(0,18143),new $Int64(0,3781)),new T.ptr(new $Int64(0,18149),new $Int64(0,5036)),new T.ptr(new $Int64(0,18169),new $Int64(0,15203)),new T.ptr(new $Int64(0,18181),new $Int64(0,9163)),new T.ptr(new $Int64(0,18191),new $Int64(0,1225)),new T.ptr(new $Int64(0,18199),new $Int64(0,5515)),new T.ptr(new $Int64(0,18211),new $Int64(0,6572)),new T.ptr(new $Int64(0,18217),new $Int64(0,14093)),new T.ptr(new $Int64(0,18223),new $Int64(0,7827)),new T.ptr(new $Int64(0,18229),new $Int64(0,8324)),new T.ptr(new $Int64(0,18233),new $Int64(0,2930)),new T.ptr(new $Int64(0,18251),new $Int64(0,15952)),new T.ptr(new $Int64(0,18253),new $Int64(0,13014)),new T.ptr(new $Int64(0,18257),new $Int64(0,13899)),new T.ptr(new $Int64(0,18269),new $Int64(0,9997)),new T.ptr(new $Int64(0,18287),new $Int64(0,16822)),new T.ptr(new $Int64(0,18289),new $Int64(0,3263)),new T.ptr(new $Int64(0,18301),new $Int64(0,16500)),new T.ptr(new $Int64(0,18307),new $Int64(0,2499)),new T.ptr(new $Int64(0,18311),new $Int64(0,13727)),new T.ptr(new $Int64(0,18313),new $Int64(0,717)),new T.ptr(new $Int64(0,18329),new $Int64(0,14342)),new T.ptr(new $Int64(0,18341),new $Int64(0,406)),new T.ptr(new $Int64(0,18353),new $Int64(0,17397)),new T.ptr(new $Int64(0,18367),new $Int64(0,4076)),new T.ptr(new $Int64(0,18371),new $Int64(0,16167)),new T.ptr(new $Int64(0,18379),new $Int64(0,12262)),new T.ptr(new $Int64(0,18397),new $Int64(0,17715)),new T.ptr(new $Int64(0,18401),new $Int64(0,5196)),new T.ptr(new $Int64(0,18413),new $Int64(0,5433)),new T.ptr(new $Int64(0,18427),new $Int64(0,9842)),new T.ptr(new $Int64(0,18433),new $Int64(0,15748)),new T.ptr(new $Int64(0,18439),new $Int64(0,5293)),new T.ptr(new $Int64(0,18443),new $Int64(0,5253)),new T.ptr(new $Int64(0,18451),new $Int64(0,11746)),new T.ptr(new $Int64(0,18457),new $Int64(0,5926)),new T.ptr(new $Int64(0,18461),new $Int64(0,14425)),new T.ptr(new $Int64(0,18481),new $Int64(0,14216)),new T.ptr(new $Int64(0,18493),new $Int64(0,11818)),new T.ptr(new $Int64(0,18503),new $Int64(0,6869)),new T.ptr(new $Int64(0,18517),new $Int64(0,6121)),new T.ptr(new $Int64(0,18521),new $Int64(0,6081)),new T.ptr(new $Int64(0,18523),new $Int64(0,3413)),new T.ptr(new $Int64(0,18539),new $Int64(0,991)),new T.ptr(new $Int64(0,18541),new $Int64(0,18050)),new T.ptr(new $Int64(0,18553),new $Int64(0,782)),new T.ptr(new $Int64(0,18583),new $Int64(0,3192)),new T.ptr(new $Int64(0,18587),new $Int64(0,1844)),new T.ptr(new $Int64(0,18593),new $Int64(0,3025)),new T.ptr(new $Int64(0,18617),new $Int64(0,17279)),new T.ptr(new $Int64(0,18637),new $Int64(0,16829)),new T.ptr(new $Int64(0,18661),new $Int64(0,14196)),new T.ptr(new $Int64(0,18671),new $Int64(0,3850)),new T.ptr(new $Int64(0,18679),new $Int64(0,17827)),new T.ptr(new $Int64(0,18691),new $Int64(0,2712)),new T.ptr(new $Int64(0,18701),new $Int64(0,15173)),new T.ptr(new $Int64(0,18713),new $Int64(0,2465)),new T.ptr(new $Int64(0,18719),new $Int64(0,8995)),new T.ptr(new $Int64(0,18731),new $Int64(0,17382)),new T.ptr(new $Int64(0,18743),new $Int64(0,17219)),new T.ptr(new $Int64(0,18749),new $Int64(0,445)),new T.ptr(new $Int64(0,18757),new $Int64(0,8730)),new T.ptr(new $Int64(0,18773),new $Int64(0,138)),new T.ptr(new $Int64(0,18787),new $Int64(0,9490)),new T.ptr(new $Int64(0,18793),new $Int64(0,8452)),new T.ptr(new $Int64(0,18797),new $Int64(0,3015)),new T.ptr(new $Int64(0,18803),new $Int64(0,6708)),new T.ptr(new $Int64(0,18839),new $Int64(0,4517)),new T.ptr(new $Int64(0,18859),new $Int64(0,2710)),new T.ptr(new $Int64(0,18869),new $Int64(0,6970)),new T.ptr(new $Int64(0,18899),new $Int64(0,13018)),new T.ptr(new $Int64(0,18911),new $Int64(0,10814)),new T.ptr(new $Int64(0,18913),new $Int64(0,15459)),new T.ptr(new $Int64(0,18917),new $Int64(0,13466)),new T.ptr(new $Int64(0,18919),new $Int64(0,8039)),new T.ptr(new $Int64(0,18947),new $Int64(0,7331)),new T.ptr(new $Int64(0,18959),new $Int64(0,682)),new T.ptr(new $Int64(0,18973),new $Int64(0,4183)),new T.ptr(new $Int64(0,18979),new $Int64(0,945)),new T.ptr(new $Int64(0,19001),new $Int64(0,18482)),new T.ptr(new $Int64(0,19009),new $Int64(0,8063)),new T.ptr(new $Int64(0,19013),new $Int64(0,12068)),new T.ptr(new $Int64(0,19031),new $Int64(0,5141)),new T.ptr(new $Int64(0,19037),new $Int64(0,17336)),new T.ptr(new $Int64(0,19051),new $Int64(0,13936)),new T.ptr(new $Int64(0,19069),new $Int64(0,17642)),new T.ptr(new $Int64(0,19073),new $Int64(0,10134)),new T.ptr(new $Int64(0,19079),new $Int64(0,12351)),new T.ptr(new $Int64(0,19081),new $Int64(0,972)),new T.ptr(new $Int64(0,19087),new $Int64(0,1490)),new T.ptr(new $Int64(0,19121),new $Int64(0,3279)),new T.ptr(new $Int64(0,19139),new $Int64(0,19034)),new T.ptr(new $Int64(0,19141),new $Int64(0,9360)),new T.ptr(new $Int64(0,19157),new $Int64(0,17962)),new T.ptr(new $Int64(0,19163),new $Int64(0,1323)),new T.ptr(new $Int64(0,19181),new $Int64(0,17996)),new T.ptr(new $Int64(0,19183),new $Int64(0,2586)),new T.ptr(new $Int64(0,19207),new $Int64(0,9635)),new T.ptr(new $Int64(0,19211),new $Int64(0,13682)),new T.ptr(new $Int64(0,19213),new $Int64(0,8305)),new T.ptr(new $Int64(0,19219),new $Int64(0,15376)),new T.ptr(new $Int64(0,19231),new $Int64(0,17862)),new T.ptr(new $Int64(0,19237),new $Int64(0,8300)),new T.ptr(new $Int64(0,19249),new $Int64(0,13203)),new T.ptr(new $Int64(0,19259),new $Int64(0,8052)),new T.ptr(new $Int64(0,19267),new $Int64(0,3015)),new T.ptr(new $Int64(0,19273),new $Int64(0,14444)),new T.ptr(new $Int64(0,19289),new $Int64(0,12723)),new T.ptr(new $Int64(0,19301),new $Int64(0,11977)),new T.ptr(new $Int64(0,19309),new $Int64(0,3879)),new T.ptr(new $Int64(0,19319),new $Int64(0,3918)),new T.ptr(new $Int64(0,19333),new $Int64(0,12490)),new T.ptr(new $Int64(0,19373),new $Int64(0,13090)),new T.ptr(new $Int64(0,19379),new $Int64(0,17298)),new T.ptr(new $Int64(0,19381),new $Int64(0,15615)),new T.ptr(new $Int64(0,19387),new $Int64(0,1465)),new T.ptr(new $Int64(0,19391),new $Int64(0,5955)),new T.ptr(new $Int64(0,19403),new $Int64(0,3433)),new T.ptr(new $Int64(0,19417),new $Int64(0,8077)),new T.ptr(new $Int64(0,19421),new $Int64(0,18551)),new T.ptr(new $Int64(0,19423),new $Int64(0,13659)),new T.ptr(new $Int64(0,19427),new $Int64(0,13339)),new T.ptr(new $Int64(0,19429),new $Int64(0,3282)),new T.ptr(new $Int64(0,19433),new $Int64(0,10500)),new T.ptr(new $Int64(0,19441),new $Int64(0,9866)),new T.ptr(new $Int64(0,19447),new $Int64(0,741)),new T.ptr(new $Int64(0,19457),new $Int64(0,16698)),new T.ptr(new $Int64(0,19463),new $Int64(0,5981)),new T.ptr(new $Int64(0,19469),new $Int64(0,6472)),new T.ptr(new $Int64(0,19471),new $Int64(0,2193)),new T.ptr(new $Int64(0,19477),new $Int64(0,2469)),new T.ptr(new $Int64(0,19483),new $Int64(0,9935)),new T.ptr(new $Int64(0,19489),new $Int64(0,18235)),new T.ptr(new $Int64(0,19501),new $Int64(0,7471)),new T.ptr(new $Int64(0,19507),new $Int64(0,12504)),new T.ptr(new $Int64(0,19531),new $Int64(0,8980)),new T.ptr(new $Int64(0,19541),new $Int64(0,3556)),new T.ptr(new $Int64(0,19543),new $Int64(0,3025)),new T.ptr(new $Int64(0,19553),new $Int64(0,14745)),new T.ptr(new $Int64(0,19559),new $Int64(0,7347)),new T.ptr(new $Int64(0,19571),new $Int64(0,14740)),new T.ptr(new $Int64(0,19577),new $Int64(0,1996)),new T.ptr(new $Int64(0,19583),new $Int64(0,9911)),new T.ptr(new $Int64(0,19597),new $Int64(0,9258)),new T.ptr(new $Int64(0,19603),new $Int64(0,4082)),new T.ptr(new $Int64(0,19609),new $Int64(0,16643)),new T.ptr(new $Int64(0,19661),new $Int64(0,19232)),new T.ptr(new $Int64(0,19681),new $Int64(0,14156)),new T.ptr(new $Int64(0,19687),new $Int64(0,6316)),new T.ptr(new $Int64(0,19697),new $Int64(0,16963)),new T.ptr(new $Int64(0,19699),new $Int64(0,10545)),new T.ptr(new $Int64(0,19709),new $Int64(0,17755)),new T.ptr(new $Int64(0,19717),new $Int64(0,15086)),new T.ptr(new $Int64(0,19727),new $Int64(0,2637)),new T.ptr(new $Int64(0,19739),new $Int64(0,7247)),new T.ptr(new $Int64(0,19751),new $Int64(0,19029)),new T.ptr(new $Int64(0,19753),new $Int64(0,14488)),new T.ptr(new $Int64(0,19759),new $Int64(0,12403)),new T.ptr(new $Int64(0,19763),new $Int64(0,14316)),new T.ptr(new $Int64(0,19777),new $Int64(0,15043)),new T.ptr(new $Int64(0,19793),new $Int64(0,4723)),new T.ptr(new $Int64(0,19801),new $Int64(0,14361)),new T.ptr(new $Int64(0,19813),new $Int64(0,13097)),new T.ptr(new $Int64(0,19819),new $Int64(0,11520)),new T.ptr(new $Int64(0,19841),new $Int64(0,3898)),new T.ptr(new $Int64(0,19843),new $Int64(0,2784)),new T.ptr(new $Int64(0,19853),new $Int64(0,12740)),new T.ptr(new $Int64(0,19861),new $Int64(0,15843)),new T.ptr(new $Int64(0,19867),new $Int64(0,3744)),new T.ptr(new $Int64(0,19889),new $Int64(0,8072)),new T.ptr(new $Int64(0,19891),new $Int64(0,12464)),new T.ptr(new $Int64(0,19913),new $Int64(0,5428)),new T.ptr(new $Int64(0,19919),new $Int64(0,19163)),new T.ptr(new $Int64(0,19927),new $Int64(0,10892)),new T.ptr(new $Int64(0,19937),new $Int64(0,8207)),new T.ptr(new $Int64(0,19949),new $Int64(0,18310)),new T.ptr(new $Int64(0,19961),new $Int64(0,1748)),new T.ptr(new $Int64(0,19963),new $Int64(0,2043)),new T.ptr(new $Int64(0,19973),new $Int64(0,18344)),new T.ptr(new $Int64(0,19979),new $Int64(0,14700)),new T.ptr(new $Int64(0,19991),new $Int64(0,6319)),new T.ptr(new $Int64(0,19993),new $Int64(0,3579)),new T.ptr(new $Int64(0,19997),new $Int64(0,12317)),new T.ptr(new $Int64(0,20011),new $Int64(0,17417)),new T.ptr(new $Int64(0,20021),new $Int64(0,16684)),new T.ptr(new $Int64(0,20023),new $Int64(0,14461)),new T.ptr(new $Int64(0,20029),new $Int64(0,15949)),new T.ptr(new $Int64(0,20047),new $Int64(0,9776)),new T.ptr(new $Int64(0,20051),new $Int64(0,539)),new T.ptr(new $Int64(0,20063),new $Int64(0,15786)),new T.ptr(new $Int64(0,20071),new $Int64(0,15414)),new T.ptr(new $Int64(0,20089),new $Int64(0,7036)),new T.ptr(new $Int64(0,20101),new $Int64(0,1034)),new T.ptr(new $Int64(0,20107),new $Int64(0,9052)),new T.ptr(new $Int64(0,20113),new $Int64(0,2415)),new T.ptr(new $Int64(0,20117),new $Int64(0,795)),new T.ptr(new $Int64(0,20123),new $Int64(0,14034)),new T.ptr(new $Int64(0,20129),new $Int64(0,6802)),new T.ptr(new $Int64(0,20143),new $Int64(0,19679)),new T.ptr(new $Int64(0,20147),new $Int64(0,8540)),new T.ptr(new $Int64(0,20149),new $Int64(0,807)),new T.ptr(new $Int64(0,20161),new $Int64(0,18469)),new T.ptr(new $Int64(0,20173),new $Int64(0,9647)),new T.ptr(new $Int64(0,20177),new $Int64(0,19513)),new T.ptr(new $Int64(0,20183),new $Int64(0,5799)),new T.ptr(new $Int64(0,20201),new $Int64(0,5785)),new T.ptr(new $Int64(0,20219),new $Int64(0,11261)),new T.ptr(new $Int64(0,20231),new $Int64(0,8901)),new T.ptr(new $Int64(0,20233),new $Int64(0,18539)),new T.ptr(new $Int64(0,20249),new $Int64(0,14752)),new T.ptr(new $Int64(0,20261),new $Int64(0,19070)),new T.ptr(new $Int64(0,20269),new $Int64(0,1723)),new T.ptr(new $Int64(0,20287),new $Int64(0,18932)),new T.ptr(new $Int64(0,20297),new $Int64(0,1380)),new T.ptr(new $Int64(0,20323),new $Int64(0,18322)),new T.ptr(new $Int64(0,20327),new $Int64(0,19389)),new T.ptr(new $Int64(0,20333),new $Int64(0,10448)),new T.ptr(new $Int64(0,20341),new $Int64(0,2672)),new T.ptr(new $Int64(0,20347),new $Int64(0,11335)),new T.ptr(new $Int64(0,20353),new $Int64(0,7039)),new T.ptr(new $Int64(0,20357),new $Int64(0,8024)),new T.ptr(new $Int64(0,20359),new $Int64(0,19288)),new T.ptr(new $Int64(0,20369),new $Int64(0,107)),new T.ptr(new $Int64(0,20389),new $Int64(0,17967)),new T.ptr(new $Int64(0,20393),new $Int64(0,975)),new T.ptr(new $Int64(0,20399),new $Int64(0,15223)),new T.ptr(new $Int64(0,20407),new $Int64(0,18412)),new T.ptr(new $Int64(0,20411),new $Int64(0,7665)),new T.ptr(new $Int64(0,20431),new $Int64(0,16711)),new T.ptr(new $Int64(0,20441),new $Int64(0,5527)),new T.ptr(new $Int64(0,20443),new $Int64(0,3971)),new T.ptr(new $Int64(0,20477),new $Int64(0,12449)),new T.ptr(new $Int64(0,20479),new $Int64(0,989)),new T.ptr(new $Int64(0,20483),new $Int64(0,11318)),new T.ptr(new $Int64(0,20507),new $Int64(0,5804)),new T.ptr(new $Int64(0,20509),new $Int64(0,4243)),new T.ptr(new $Int64(0,20521),new $Int64(0,7011)),new T.ptr(new $Int64(0,20533),new $Int64(0,527)),new T.ptr(new $Int64(0,20543),new $Int64(0,15548)),new T.ptr(new $Int64(0,20549),new $Int64(0,2130)),new T.ptr(new $Int64(0,20551),new $Int64(0,15023)),new T.ptr(new $Int64(0,20563),new $Int64(0,11102)),new T.ptr(new $Int64(0,20593),new $Int64(0,12944)),new T.ptr(new $Int64(0,20599),new $Int64(0,3279)),new T.ptr(new $Int64(0,20611),new $Int64(0,10259)),new T.ptr(new $Int64(0,20627),new $Int64(0,15626)),new T.ptr(new $Int64(0,20639),new $Int64(0,14165)),new T.ptr(new $Int64(0,20641),new $Int64(0,11506)),new T.ptr(new $Int64(0,20663),new $Int64(0,11242)),new T.ptr(new $Int64(0,20681),new $Int64(0,19393)),new T.ptr(new $Int64(0,20693),new $Int64(0,19212)),new T.ptr(new $Int64(0,20707),new $Int64(0,427)),new T.ptr(new $Int64(0,20717),new $Int64(0,322)),new T.ptr(new $Int64(0,20719),new $Int64(0,4540)),new T.ptr(new $Int64(0,20731),new $Int64(0,9656)),new T.ptr(new $Int64(0,20743),new $Int64(0,15727)),new T.ptr(new $Int64(0,20747),new $Int64(0,566)),new T.ptr(new $Int64(0,20749),new $Int64(0,3961)),new T.ptr(new $Int64(0,20753),new $Int64(0,10301)),new T.ptr(new $Int64(0,20759),new $Int64(0,5164)),new T.ptr(new $Int64(0,20771),new $Int64(0,12635)),new T.ptr(new $Int64(0,20773),new $Int64(0,10598)),new T.ptr(new $Int64(0,20789),new $Int64(0,5997)),new T.ptr(new $Int64(0,20807),new $Int64(0,14193)),new T.ptr(new $Int64(0,20809),new $Int64(0,15354)),new T.ptr(new $Int64(0,20849),new $Int64(0,18355)),new T.ptr(new $Int64(0,20857),new $Int64(0,11093)),new T.ptr(new $Int64(0,20873),new $Int64(0,1978)),new T.ptr(new $Int64(0,20879),new $Int64(0,5319)),new T.ptr(new $Int64(0,20887),new $Int64(0,8725)),new T.ptr(new $Int64(0,20897),new $Int64(0,14531)),new T.ptr(new $Int64(0,20899),new $Int64(0,3713)),new T.ptr(new $Int64(0,20903),new $Int64(0,20686)),new T.ptr(new $Int64(0,20921),new $Int64(0,8541)),new T.ptr(new $Int64(0,20929),new $Int64(0,3964)),new T.ptr(new $Int64(0,20939),new $Int64(0,16515)),new T.ptr(new $Int64(0,20947),new $Int64(0,2399)),new T.ptr(new $Int64(0,20959),new $Int64(0,12905)),new T.ptr(new $Int64(0,20963),new $Int64(0,4798)),new T.ptr(new $Int64(0,20981),new $Int64(0,695)),new T.ptr(new $Int64(0,20983),new $Int64(0,12576)),new T.ptr(new $Int64(0,21001),new $Int64(0,15567)),new T.ptr(new $Int64(0,21011),new $Int64(0,8562)),new T.ptr(new $Int64(0,21013),new $Int64(0,1379)),new T.ptr(new $Int64(0,21017),new $Int64(0,16945)),new T.ptr(new $Int64(0,21019),new $Int64(0,7094)),new T.ptr(new $Int64(0,21023),new $Int64(0,2365)),new T.ptr(new $Int64(0,21031),new $Int64(0,5100)),new T.ptr(new $Int64(0,21059),new $Int64(0,17914)),new T.ptr(new $Int64(0,21061),new $Int64(0,12992)),new T.ptr(new $Int64(0,21067),new $Int64(0,9400)),new T.ptr(new $Int64(0,21089),new $Int64(0,18166)),new T.ptr(new $Int64(0,21101),new $Int64(0,4662)),new T.ptr(new $Int64(0,21107),new $Int64(0,1356)),new T.ptr(new $Int64(0,21121),new $Int64(0,5106)),new T.ptr(new $Int64(0,21139),new $Int64(0,9732)),new T.ptr(new $Int64(0,21143),new $Int64(0,5758)),new T.ptr(new $Int64(0,21149),new $Int64(0,6291)),new T.ptr(new $Int64(0,21157),new $Int64(0,14666)),new T.ptr(new $Int64(0,21163),new $Int64(0,4132)),new T.ptr(new $Int64(0,21169),new $Int64(0,7520)),new T.ptr(new $Int64(0,21179),new $Int64(0,7416)),new T.ptr(new $Int64(0,21187),new $Int64(0,6321)),new T.ptr(new $Int64(0,21191),new $Int64(0,18003)),new T.ptr(new $Int64(0,21193),new $Int64(0,12072)),new T.ptr(new $Int64(0,21211),new $Int64(0,2336)),new T.ptr(new $Int64(0,21221),new $Int64(0,16624)),new T.ptr(new $Int64(0,21227),new $Int64(0,16335)),new T.ptr(new $Int64(0,21247),new $Int64(0,4609)),new T.ptr(new $Int64(0,21269),new $Int64(0,19989)),new T.ptr(new $Int64(0,21277),new $Int64(0,14069)),new T.ptr(new $Int64(0,21283),new $Int64(0,4283)),new T.ptr(new $Int64(0,21313),new $Int64(0,1239)),new T.ptr(new $Int64(0,21317),new $Int64(0,9382)),new T.ptr(new $Int64(0,21319),new $Int64(0,5353)),new T.ptr(new $Int64(0,21323),new $Int64(0,4923)),new T.ptr(new $Int64(0,21341),new $Int64(0,3713)),new T.ptr(new $Int64(0,21347),new $Int64(0,17387)),new T.ptr(new $Int64(0,21377),new $Int64(0,15719)),new T.ptr(new $Int64(0,21379),new $Int64(0,19368)),new T.ptr(new $Int64(0,21383),new $Int64(0,12595)),new T.ptr(new $Int64(0,21391),new $Int64(0,13842)),new T.ptr(new $Int64(0,21397),new $Int64(0,19364)),new T.ptr(new $Int64(0,21401),new $Int64(0,1981)),new T.ptr(new $Int64(0,21407),new $Int64(0,18580)),new T.ptr(new $Int64(0,21419),new $Int64(0,4269)),new T.ptr(new $Int64(0,21433),new $Int64(0,19767)),new T.ptr(new $Int64(0,21467),new $Int64(0,3202)),new T.ptr(new $Int64(0,21481),new $Int64(0,18734)),new T.ptr(new $Int64(0,21487),new $Int64(0,13419)),new T.ptr(new $Int64(0,21491),new $Int64(0,19750)),new T.ptr(new $Int64(0,21493),new $Int64(0,7444)),new T.ptr(new $Int64(0,21499),new $Int64(0,14902)),new T.ptr(new $Int64(0,21503),new $Int64(0,3579)),new T.ptr(new $Int64(0,21517),new $Int64(0,10380)),new T.ptr(new $Int64(0,21521),new $Int64(0,6636)),new T.ptr(new $Int64(0,21523),new $Int64(0,7234)),new T.ptr(new $Int64(0,21529),new $Int64(0,15154)),new T.ptr(new $Int64(0,21557),new $Int64(0,5159)),new T.ptr(new $Int64(0,21559),new $Int64(0,19348)),new T.ptr(new $Int64(0,21563),new $Int64(0,8662)),new T.ptr(new $Int64(0,21569),new $Int64(0,8603)),new T.ptr(new $Int64(0,21577),new $Int64(0,21219)),new T.ptr(new $Int64(0,21587),new $Int64(0,287)),new T.ptr(new $Int64(0,21589),new $Int64(0,649)),new T.ptr(new $Int64(0,21599),new $Int64(0,5524)),new T.ptr(new $Int64(0,21601),new $Int64(0,8200)),new T.ptr(new $Int64(0,21611),new $Int64(0,17982)),new T.ptr(new $Int64(0,21613),new $Int64(0,2865)),new T.ptr(new $Int64(0,21617),new $Int64(0,282)),new T.ptr(new $Int64(0,21647),new $Int64(0,1142)),new T.ptr(new $Int64(0,21649),new $Int64(0,8707)),new T.ptr(new $Int64(0,21661),new $Int64(0,21650)),new T.ptr(new $Int64(0,21673),new $Int64(0,9639)),new T.ptr(new $Int64(0,21683),new $Int64(0,10898)),new T.ptr(new $Int64(0,21701),new $Int64(0,11255)),new T.ptr(new $Int64(0,21713),new $Int64(0,16786)),new T.ptr(new $Int64(0,21727),new $Int64(0,13634)),new T.ptr(new $Int64(0,21737),new $Int64(0,12835)),new T.ptr(new $Int64(0,21739),new $Int64(0,16632)),new T.ptr(new $Int64(0,21751),new $Int64(0,10620)),new T.ptr(new $Int64(0,21757),new $Int64(0,20494)),new T.ptr(new $Int64(0,21767),new $Int64(0,1518)),new T.ptr(new $Int64(0,21773),new $Int64(0,7947)),new T.ptr(new $Int64(0,21787),new $Int64(0,20778)),new T.ptr(new $Int64(0,21799),new $Int64(0,21654)),new T.ptr(new $Int64(0,21803),new $Int64(0,11089)),new T.ptr(new $Int64(0,21817),new $Int64(0,5174)),new T.ptr(new $Int64(0,21821),new $Int64(0,12320)),new T.ptr(new $Int64(0,21839),new $Int64(0,9927)),new T.ptr(new $Int64(0,21841),new $Int64(0,7942)),new T.ptr(new $Int64(0,21851),new $Int64(0,5237)),new T.ptr(new $Int64(0,21859),new $Int64(0,3556)),new T.ptr(new $Int64(0,21863),new $Int64(0,12703)),new T.ptr(new $Int64(0,21871),new $Int64(0,18151)),new T.ptr(new $Int64(0,21881),new $Int64(0,16059)),new T.ptr(new $Int64(0,21893),new $Int64(0,8975)),new T.ptr(new $Int64(0,21911),new $Int64(0,6116)),new T.ptr(new $Int64(0,21929),new $Int64(0,7235)),new T.ptr(new $Int64(0,21937),new $Int64(0,18483)),new T.ptr(new $Int64(0,21943),new $Int64(0,12976)),new T.ptr(new $Int64(0,21961),new $Int64(0,21895)),new T.ptr(new $Int64(0,21977),new $Int64(0,21627)),new T.ptr(new $Int64(0,21991),new $Int64(0,13703)),new T.ptr(new $Int64(0,21997),new $Int64(0,4942)),new T.ptr(new $Int64(0,22003),new $Int64(0,1988)),new T.ptr(new $Int64(0,22013),new $Int64(0,14390)),new T.ptr(new $Int64(0,22027),new $Int64(0,21513)),new T.ptr(new $Int64(0,22031),new $Int64(0,17176)),new T.ptr(new $Int64(0,22037),new $Int64(0,2522)),new T.ptr(new $Int64(0,22039),new $Int64(0,1923)),new T.ptr(new $Int64(0,22051),new $Int64(0,7363)),new T.ptr(new $Int64(0,22063),new $Int64(0,15758)),new T.ptr(new $Int64(0,22067),new $Int64(0,1087)),new T.ptr(new $Int64(0,22073),new $Int64(0,12169)),new T.ptr(new $Int64(0,22079),new $Int64(0,7676)),new T.ptr(new $Int64(0,22091),new $Int64(0,7369)),new T.ptr(new $Int64(0,22093),new $Int64(0,11757)),new T.ptr(new $Int64(0,22109),new $Int64(0,5163)),new T.ptr(new $Int64(0,22111),new $Int64(0,17312)),new T.ptr(new $Int64(0,22123),new $Int64(0,10795)),new T.ptr(new $Int64(0,22129),new $Int64(0,3926)),new T.ptr(new $Int64(0,22133),new $Int64(0,3413)),new T.ptr(new $Int64(0,22147),new $Int64(0,12736)),new T.ptr(new $Int64(0,22153),new $Int64(0,978)),new T.ptr(new $Int64(0,22157),new $Int64(0,610)),new T.ptr(new $Int64(0,22159),new $Int64(0,5254)),new T.ptr(new $Int64(0,22171),new $Int64(0,8732)),new T.ptr(new $Int64(0,22189),new $Int64(0,17935)),new T.ptr(new $Int64(0,22193),new $Int64(0,4298)),new T.ptr(new $Int64(0,22229),new $Int64(0,17538)),new T.ptr(new $Int64(0,22247),new $Int64(0,13864)),new T.ptr(new $Int64(0,22259),new $Int64(0,11441)),new T.ptr(new $Int64(0,22271),new $Int64(0,1522)),new T.ptr(new $Int64(0,22273),new $Int64(0,6991)),new T.ptr(new $Int64(0,22277),new $Int64(0,21466)),new T.ptr(new $Int64(0,22279),new $Int64(0,16166)),new T.ptr(new $Int64(0,22283),new $Int64(0,18323)),new T.ptr(new $Int64(0,22291),new $Int64(0,15304)),new T.ptr(new $Int64(0,22303),new $Int64(0,1848)),new T.ptr(new $Int64(0,22307),new $Int64(0,9879)),new T.ptr(new $Int64(0,22343),new $Int64(0,20437)),new T.ptr(new $Int64(0,22349),new $Int64(0,7608)),new T.ptr(new $Int64(0,22367),new $Int64(0,17000)),new T.ptr(new $Int64(0,22369),new $Int64(0,14181)),new T.ptr(new $Int64(0,22381),new $Int64(0,15036)),new T.ptr(new $Int64(0,22391),new $Int64(0,19358)),new T.ptr(new $Int64(0,22397),new $Int64(0,21962)),new T.ptr(new $Int64(0,22409),new $Int64(0,15363)),new T.ptr(new $Int64(0,22433),new $Int64(0,13488)),new T.ptr(new $Int64(0,22441),new $Int64(0,21701)),new T.ptr(new $Int64(0,22447),new $Int64(0,14624)),new T.ptr(new $Int64(0,22453),new $Int64(0,21504)),new T.ptr(new $Int64(0,22469),new $Int64(0,5696)),new T.ptr(new $Int64(0,22481),new $Int64(0,711)),new T.ptr(new $Int64(0,22483),new $Int64(0,1672)),new T.ptr(new $Int64(0,22501),new $Int64(0,10531)),new T.ptr(new $Int64(0,22511),new $Int64(0,4282)),new T.ptr(new $Int64(0,22531),new $Int64(0,1491)),new T.ptr(new $Int64(0,22541),new $Int64(0,6016)),new T.ptr(new $Int64(0,22543),new $Int64(0,18488)),new T.ptr(new $Int64(0,22549),new $Int64(0,20794)),new T.ptr(new $Int64(0,22567),new $Int64(0,12583)),new T.ptr(new $Int64(0,22571),new $Int64(0,12129)),new T.ptr(new $Int64(0,22573),new $Int64(0,2654)),new T.ptr(new $Int64(0,22613),new $Int64(0,6356)),new T.ptr(new $Int64(0,22619),new $Int64(0,16891)),new T.ptr(new $Int64(0,22621),new $Int64(0,15717)),new T.ptr(new $Int64(0,22637),new $Int64(0,3744)),new T.ptr(new $Int64(0,22639),new $Int64(0,6182)),new T.ptr(new $Int64(0,22643),new $Int64(0,7716)),new T.ptr(new $Int64(0,22651),new $Int64(0,7767)),new T.ptr(new $Int64(0,22669),new $Int64(0,17553)),new T.ptr(new $Int64(0,22679),new $Int64(0,22362)),new T.ptr(new $Int64(0,22691),new $Int64(0,5597)),new T.ptr(new $Int64(0,22697),new $Int64(0,4967)),new T.ptr(new $Int64(0,22699),new $Int64(0,17820)),new T.ptr(new $Int64(0,22709),new $Int64(0,18257)),new T.ptr(new $Int64(0,22717),new $Int64(0,11322)),new T.ptr(new $Int64(0,22721),new $Int64(0,4600)),new T.ptr(new $Int64(0,22727),new $Int64(0,13482)),new T.ptr(new $Int64(0,22739),new $Int64(0,6781)),new T.ptr(new $Int64(0,22741),new $Int64(0,670)),new T.ptr(new $Int64(0,22751),new $Int64(0,3964)),new T.ptr(new $Int64(0,22769),new $Int64(0,15951)),new T.ptr(new $Int64(0,22777),new $Int64(0,8519)),new T.ptr(new $Int64(0,22783),new $Int64(0,727)),new T.ptr(new $Int64(0,22787),new $Int64(0,15168)),new T.ptr(new $Int64(0,22807),new $Int64(0,16499)),new T.ptr(new $Int64(0,22811),new $Int64(0,16451)),new T.ptr(new $Int64(0,22817),new $Int64(0,6019)),new T.ptr(new $Int64(0,22853),new $Int64(0,13341)),new T.ptr(new $Int64(0,22859),new $Int64(0,7205)),new T.ptr(new $Int64(0,22861),new $Int64(0,16272)),new T.ptr(new $Int64(0,22871),new $Int64(0,22629)),new T.ptr(new $Int64(0,22877),new $Int64(0,11257)),new T.ptr(new $Int64(0,22901),new $Int64(0,3687)),new T.ptr(new $Int64(0,22907),new $Int64(0,808)),new T.ptr(new $Int64(0,22921),new $Int64(0,10968)),new T.ptr(new $Int64(0,22937),new $Int64(0,22228)),new T.ptr(new $Int64(0,22943),new $Int64(0,4873)),new T.ptr(new $Int64(0,22961),new $Int64(0,13755)),new T.ptr(new $Int64(0,22963),new $Int64(0,18431)),new T.ptr(new $Int64(0,22973),new $Int64(0,12057)),new T.ptr(new $Int64(0,22993),new $Int64(0,5678)),new T.ptr(new $Int64(0,23003),new $Int64(0,12067)),new T.ptr(new $Int64(0,23011),new $Int64(0,8741)),new T.ptr(new $Int64(0,23017),new $Int64(0,32)),new T.ptr(new $Int64(0,23021),new $Int64(0,7386)),new T.ptr(new $Int64(0,23027),new $Int64(0,5229)),new T.ptr(new $Int64(0,23029),new $Int64(0,18775)),new T.ptr(new $Int64(0,23039),new $Int64(0,22763)),new T.ptr(new $Int64(0,23041),new $Int64(0,15606)),new T.ptr(new $Int64(0,23053),new $Int64(0,22355)),new T.ptr(new $Int64(0,23057),new $Int64(0,21469)),new T.ptr(new $Int64(0,23059),new $Int64(0,411)),new T.ptr(new $Int64(0,23063),new $Int64(0,9230)),new T.ptr(new $Int64(0,23071),new $Int64(0,6701)),new T.ptr(new $Int64(0,23081),new $Int64(0,4719)),new T.ptr(new $Int64(0,23087),new $Int64(0,12773)),new T.ptr(new $Int64(0,23099),new $Int64(0,7996)),new T.ptr(new $Int64(0,23117),new $Int64(0,6433)),new T.ptr(new $Int64(0,23131),new $Int64(0,1808)),new T.ptr(new $Int64(0,23143),new $Int64(0,17616)),new T.ptr(new $Int64(0,23159),new $Int64(0,11036)),new T.ptr(new $Int64(0,23167),new $Int64(0,10094)),new T.ptr(new $Int64(0,23173),new $Int64(0,1868)),new T.ptr(new $Int64(0,23189),new $Int64(0,1894)),new T.ptr(new $Int64(0,23197),new $Int64(0,14597)),new T.ptr(new $Int64(0,23201),new $Int64(0,15753)),new T.ptr(new $Int64(0,23203),new $Int64(0,4878)),new T.ptr(new $Int64(0,23209),new $Int64(0,9033)),new T.ptr(new $Int64(0,23227),new $Int64(0,9250)),new T.ptr(new $Int64(0,23251),new $Int64(0,9529)),new T.ptr(new $Int64(0,23269),new $Int64(0,10300)),new T.ptr(new $Int64(0,23279),new $Int64(0,10349)),new T.ptr(new $Int64(0,23291),new $Int64(0,21823)),new T.ptr(new $Int64(0,23293),new $Int64(0,9929)),new T.ptr(new $Int64(0,23297),new $Int64(0,141)),new T.ptr(new $Int64(0,23311),new $Int64(0,16831)),new T.ptr(new $Int64(0,23321),new $Int64(0,5467)),new T.ptr(new $Int64(0,23327),new $Int64(0,415)),new T.ptr(new $Int64(0,23333),new $Int64(0,3971)),new T.ptr(new $Int64(0,23339),new $Int64(0,13908)),new T.ptr(new $Int64(0,23357),new $Int64(0,21410)),new T.ptr(new $Int64(0,23369),new $Int64(0,17632)),new T.ptr(new $Int64(0,23371),new $Int64(0,10372)),new T.ptr(new $Int64(0,23399),new $Int64(0,16106)),new T.ptr(new $Int64(0,23417),new $Int64(0,6458)),new T.ptr(new $Int64(0,23431),new $Int64(0,10621)),new T.ptr(new $Int64(0,23447),new $Int64(0,21147)),new T.ptr(new $Int64(0,23459),new $Int64(0,6527)),new T.ptr(new $Int64(0,23473),new $Int64(0,2326)),new T.ptr(new $Int64(0,23497),new $Int64(0,21018)),new T.ptr(new $Int64(0,23509),new $Int64(0,21327)),new T.ptr(new $Int64(0,23531),new $Int64(0,16171)),new T.ptr(new $Int64(0,23537),new $Int64(0,17660)),new T.ptr(new $Int64(0,23539),new $Int64(0,1854)),new T.ptr(new $Int64(0,23549),new $Int64(0,19097)),new T.ptr(new $Int64(0,23557),new $Int64(0,2845)),new T.ptr(new $Int64(0,23561),new $Int64(0,20752)),new T.ptr(new $Int64(0,23563),new $Int64(0,3353)),new T.ptr(new $Int64(0,23567),new $Int64(0,10025)),new T.ptr(new $Int64(0,23581),new $Int64(0,20483)),new T.ptr(new $Int64(0,23593),new $Int64(0,6109)),new T.ptr(new $Int64(0,23599),new $Int64(0,3898)),new T.ptr(new $Int64(0,23603),new $Int64(0,3846)),new T.ptr(new $Int64(0,23609),new $Int64(0,14063)),new T.ptr(new $Int64(0,23623),new $Int64(0,919)),new T.ptr(new $Int64(0,23627),new $Int64(0,857)),new T.ptr(new $Int64(0,23629),new $Int64(0,3661)),new T.ptr(new $Int64(0,23633),new $Int64(0,1366)),new T.ptr(new $Int64(0,23663),new $Int64(0,18524)),new T.ptr(new $Int64(0,23669),new $Int64(0,20282)),new T.ptr(new $Int64(0,23671),new $Int64(0,18226)),new T.ptr(new $Int64(0,23677),new $Int64(0,4326)),new T.ptr(new $Int64(0,23687),new $Int64(0,15140)),new T.ptr(new $Int64(0,23689),new $Int64(0,11894)),new T.ptr(new $Int64(0,23719),new $Int64(0,6548)),new T.ptr(new $Int64(0,23741),new $Int64(0,17768)),new T.ptr(new $Int64(0,23743),new $Int64(0,3177)),new T.ptr(new $Int64(0,23747),new $Int64(0,22924)),new T.ptr(new $Int64(0,23753),new $Int64(0,6451)),new T.ptr(new $Int64(0,23761),new $Int64(0,5222)),new T.ptr(new $Int64(0,23767),new $Int64(0,2164)),new T.ptr(new $Int64(0,23773),new $Int64(0,21462)),new T.ptr(new $Int64(0,23789),new $Int64(0,17533)),new T.ptr(new $Int64(0,23801),new $Int64(0,23246)),new T.ptr(new $Int64(0,23813),new $Int64(0,23655)),new T.ptr(new $Int64(0,23819),new $Int64(0,488)),new T.ptr(new $Int64(0,23827),new $Int64(0,12869)),new T.ptr(new $Int64(0,23831),new $Int64(0,6890)),new T.ptr(new $Int64(0,23833),new $Int64(0,13052)),new T.ptr(new $Int64(0,23857),new $Int64(0,200)),new T.ptr(new $Int64(0,23869),new $Int64(0,19126)),new T.ptr(new $Int64(0,23873),new $Int64(0,14640)),new T.ptr(new $Int64(0,23879),new $Int64(0,10902)),new T.ptr(new $Int64(0,23887),new $Int64(0,13844)),new T.ptr(new $Int64(0,23893),new $Int64(0,4122)),new T.ptr(new $Int64(0,23899),new $Int64(0,5774)),new T.ptr(new $Int64(0,23909),new $Int64(0,5655)),new T.ptr(new $Int64(0,23911),new $Int64(0,14135)),new T.ptr(new $Int64(0,23917),new $Int64(0,15289)),new T.ptr(new $Int64(0,23929),new $Int64(0,20453)),new T.ptr(new $Int64(0,23957),new $Int64(0,2646)),new T.ptr(new $Int64(0,23971),new $Int64(0,19810)),new T.ptr(new $Int64(0,23977),new $Int64(0,6836)),new T.ptr(new $Int64(0,23981),new $Int64(0,15504)),new T.ptr(new $Int64(0,23993),new $Int64(0,9752)),new T.ptr(new $Int64(0,24001),new $Int64(0,9183)),new T.ptr(new $Int64(0,24007),new $Int64(0,17511)),new T.ptr(new $Int64(0,24019),new $Int64(0,20176)),new T.ptr(new $Int64(0,24023),new $Int64(0,14414)),new T.ptr(new $Int64(0,24029),new $Int64(0,18262)),new T.ptr(new $Int64(0,24043),new $Int64(0,3037)),new T.ptr(new $Int64(0,24049),new $Int64(0,14237)),new T.ptr(new $Int64(0,24061),new $Int64(0,13136)),new T.ptr(new $Int64(0,24071),new $Int64(0,12394)),new T.ptr(new $Int64(0,24077),new $Int64(0,23441)),new T.ptr(new $Int64(0,24083),new $Int64(0,8327)),new T.ptr(new $Int64(0,24091),new $Int64(0,16612)),new T.ptr(new $Int64(0,24097),new $Int64(0,20664)),new T.ptr(new $Int64(0,24103),new $Int64(0,15072)),new T.ptr(new $Int64(0,24107),new $Int64(0,14987)),new T.ptr(new $Int64(0,24109),new $Int64(0,23485)),new T.ptr(new $Int64(0,24113),new $Int64(0,13655)),new T.ptr(new $Int64(0,24121),new $Int64(0,19446)),new T.ptr(new $Int64(0,24133),new $Int64(0,2524)),new T.ptr(new $Int64(0,24137),new $Int64(0,5041)),new T.ptr(new $Int64(0,24151),new $Int64(0,4602)),new T.ptr(new $Int64(0,24169),new $Int64(0,3467)),new T.ptr(new $Int64(0,24179),new $Int64(0,19312)),new T.ptr(new $Int64(0,24181),new $Int64(0,17743)),new T.ptr(new $Int64(0,24197),new $Int64(0,5259)),new T.ptr(new $Int64(0,24203),new $Int64(0,5733)),new T.ptr(new $Int64(0,24223),new $Int64(0,7839)),new T.ptr(new $Int64(0,24229),new $Int64(0,14041)),new T.ptr(new $Int64(0,24239),new $Int64(0,7531)),new T.ptr(new $Int64(0,24247),new $Int64(0,19963)),new T.ptr(new $Int64(0,24251),new $Int64(0,4722)),new T.ptr(new $Int64(0,24281),new $Int64(0,17214)),new T.ptr(new $Int64(0,24317),new $Int64(0,21877)),new T.ptr(new $Int64(0,24329),new $Int64(0,7881)),new T.ptr(new $Int64(0,24337),new $Int64(0,21429)),new T.ptr(new $Int64(0,24359),new $Int64(0,2385)),new T.ptr(new $Int64(0,24371),new $Int64(0,15044)),new T.ptr(new $Int64(0,24373),new $Int64(0,18814)),new T.ptr(new $Int64(0,24379),new $Int64(0,18116)),new T.ptr(new $Int64(0,24391),new $Int64(0,3868)),new T.ptr(new $Int64(0,24407),new $Int64(0,10553)),new T.ptr(new $Int64(0,24413),new $Int64(0,16154)),new T.ptr(new $Int64(0,24419),new $Int64(0,10868)),new T.ptr(new $Int64(0,24421),new $Int64(0,18651)),new T.ptr(new $Int64(0,24439),new $Int64(0,106)),new T.ptr(new $Int64(0,24443),new $Int64(0,18341)),new T.ptr(new $Int64(0,24469),new $Int64(0,20389)),new T.ptr(new $Int64(0,24473),new $Int64(0,16646)),new T.ptr(new $Int64(0,24481),new $Int64(0,9171)),new T.ptr(new $Int64(0,24499),new $Int64(0,19331)),new T.ptr(new $Int64(0,24509),new $Int64(0,12775)),new T.ptr(new $Int64(0,24517),new $Int64(0,2765)),new T.ptr(new $Int64(0,24527),new $Int64(0,11732)),new T.ptr(new $Int64(0,24533),new $Int64(0,20841)),new T.ptr(new $Int64(0,24547),new $Int64(0,3032)),new T.ptr(new $Int64(0,24551),new $Int64(0,22231)),new T.ptr(new $Int64(0,24571),new $Int64(0,10610)),new T.ptr(new $Int64(0,24593),new $Int64(0,15966)),new T.ptr(new $Int64(0,24611),new $Int64(0,21978)),new T.ptr(new $Int64(0,24623),new $Int64(0,11773)),new T.ptr(new $Int64(0,24631),new $Int64(0,12912)),new T.ptr(new $Int64(0,24659),new $Int64(0,9817)),new T.ptr(new $Int64(0,24671),new $Int64(0,18692)),new T.ptr(new $Int64(0,24677),new $Int64(0,8790)),new T.ptr(new $Int64(0,24683),new $Int64(0,10877)),new T.ptr(new $Int64(0,24691),new $Int64(0,21811)),new T.ptr(new $Int64(0,24697),new $Int64(0,7288)),new T.ptr(new $Int64(0,24709),new $Int64(0,101)),new T.ptr(new $Int64(0,24733),new $Int64(0,3921)),new T.ptr(new $Int64(0,24749),new $Int64(0,1700)),new T.ptr(new $Int64(0,24763),new $Int64(0,382)),new T.ptr(new $Int64(0,24767),new $Int64(0,20)),new T.ptr(new $Int64(0,24781),new $Int64(0,12217)),new T.ptr(new $Int64(0,24793),new $Int64(0,1367)),new T.ptr(new $Int64(0,24799),new $Int64(0,14873)),new T.ptr(new $Int64(0,24809),new $Int64(0,12572)),new T.ptr(new $Int64(0,24821),new $Int64(0,9972)),new T.ptr(new $Int64(0,24841),new $Int64(0,3077)),new T.ptr(new $Int64(0,24847),new $Int64(0,3007)),new T.ptr(new $Int64(0,24851),new $Int64(0,4243)),new T.ptr(new $Int64(0,24859),new $Int64(0,12885)),new T.ptr(new $Int64(0,24877),new $Int64(0,11479)),new T.ptr(new $Int64(0,24889),new $Int64(0,3073)),new T.ptr(new $Int64(0,24907),new $Int64(0,8874)),new T.ptr(new $Int64(0,24917),new $Int64(0,17986)),new T.ptr(new $Int64(0,24919),new $Int64(0,24106)),new T.ptr(new $Int64(0,24923),new $Int64(0,6526)),new T.ptr(new $Int64(0,24943),new $Int64(0,13853)),new T.ptr(new $Int64(0,24953),new $Int64(0,23379)),new T.ptr(new $Int64(0,24967),new $Int64(0,14869)),new T.ptr(new $Int64(0,24971),new $Int64(0,22524)),new T.ptr(new $Int64(0,24977),new $Int64(0,12727)),new T.ptr(new $Int64(0,24979),new $Int64(0,9254)),new T.ptr(new $Int64(0,24989),new $Int64(0,14548)),new T.ptr(new $Int64(0,25013),new $Int64(0,4082)),new T.ptr(new $Int64(0,25031),new $Int64(0,19990)),new T.ptr(new $Int64(0,25033),new $Int64(0,3781)),new T.ptr(new $Int64(0,25037),new $Int64(0,10519)),new T.ptr(new $Int64(0,25057),new $Int64(0,22088)),new T.ptr(new $Int64(0,25073),new $Int64(0,1850)),new T.ptr(new $Int64(0,25087),new $Int64(0,5041)),new T.ptr(new $Int64(0,25097),new $Int64(0,16223)),new T.ptr(new $Int64(0,25111),new $Int64(0,20865)),new T.ptr(new $Int64(0,25117),new $Int64(0,15755)),new T.ptr(new $Int64(0,25121),new $Int64(0,23431)),new T.ptr(new $Int64(0,25127),new $Int64(0,8078)),new T.ptr(new $Int64(0,25147),new $Int64(0,16069)),new T.ptr(new $Int64(0,25153),new $Int64(0,1613)),new T.ptr(new $Int64(0,25163),new $Int64(0,12270)),new T.ptr(new $Int64(0,25169),new $Int64(0,5513)),new T.ptr(new $Int64(0,25171),new $Int64(0,7751)),new T.ptr(new $Int64(0,25183),new $Int64(0,2942)),new T.ptr(new $Int64(0,25189),new $Int64(0,7174)),new T.ptr(new $Int64(0,25219),new $Int64(0,14684)),new T.ptr(new $Int64(0,25229),new $Int64(0,4581)),new T.ptr(new $Int64(0,25237),new $Int64(0,1989)),new T.ptr(new $Int64(0,25243),new $Int64(0,24775)),new T.ptr(new $Int64(0,25247),new $Int64(0,22039)),new T.ptr(new $Int64(0,25253),new $Int64(0,4878)),new T.ptr(new $Int64(0,25261),new $Int64(0,3394)),new T.ptr(new $Int64(0,25301),new $Int64(0,13021)),new T.ptr(new $Int64(0,25303),new $Int64(0,11601)),new T.ptr(new $Int64(0,25307),new $Int64(0,19500)),new T.ptr(new $Int64(0,25309),new $Int64(0,7638)),new T.ptr(new $Int64(0,25321),new $Int64(0,5236)),new T.ptr(new $Int64(0,25339),new $Int64(0,20171)),new T.ptr(new $Int64(0,25343),new $Int64(0,15763)),new T.ptr(new $Int64(0,25349),new $Int64(0,20658)),new T.ptr(new $Int64(0,25357),new $Int64(0,14031)),new T.ptr(new $Int64(0,25367),new $Int64(0,3619)),new T.ptr(new $Int64(0,25373),new $Int64(0,5763)),new T.ptr(new $Int64(0,25391),new $Int64(0,4703)),new T.ptr(new $Int64(0,25409),new $Int64(0,8307)),new T.ptr(new $Int64(0,25411),new $Int64(0,16126)),new T.ptr(new $Int64(0,25423),new $Int64(0,24558)),new T.ptr(new $Int64(0,25439),new $Int64(0,17561)),new T.ptr(new $Int64(0,25447),new $Int64(0,16731)),new T.ptr(new $Int64(0,25453),new $Int64(0,14969)),new T.ptr(new $Int64(0,25457),new $Int64(0,23780)),new T.ptr(new $Int64(0,25463),new $Int64(0,10394)),new T.ptr(new $Int64(0,25469),new $Int64(0,11647)),new T.ptr(new $Int64(0,25471),new $Int64(0,23327)),new T.ptr(new $Int64(0,25523),new $Int64(0,2680)),new T.ptr(new $Int64(0,25537),new $Int64(0,15572)),new T.ptr(new $Int64(0,25541),new $Int64(0,1586)),new T.ptr(new $Int64(0,25561),new $Int64(0,153)),new T.ptr(new $Int64(0,25577),new $Int64(0,23100)),new T.ptr(new $Int64(0,25579),new $Int64(0,8863)),new T.ptr(new $Int64(0,25583),new $Int64(0,16679)),new T.ptr(new $Int64(0,25589),new $Int64(0,16789)),new T.ptr(new $Int64(0,25601),new $Int64(0,3802)),new T.ptr(new $Int64(0,25603),new $Int64(0,574)),new T.ptr(new $Int64(0,25609),new $Int64(0,9174)),new T.ptr(new $Int64(0,25621),new $Int64(0,19977)),new T.ptr(new $Int64(0,25633),new $Int64(0,20414)),new T.ptr(new $Int64(0,25639),new $Int64(0,23445)),new T.ptr(new $Int64(0,25643),new $Int64(0,3871)),new T.ptr(new $Int64(0,25657),new $Int64(0,24001)),new T.ptr(new $Int64(0,25667),new $Int64(0,3290)),new T.ptr(new $Int64(0,25673),new $Int64(0,14205)),new T.ptr(new $Int64(0,25679),new $Int64(0,24807)),new T.ptr(new $Int64(0,25693),new $Int64(0,22374)),new T.ptr(new $Int64(0,25703),new $Int64(0,10569)),new T.ptr(new $Int64(0,25717),new $Int64(0,3594)),new T.ptr(new $Int64(0,25733),new $Int64(0,17593)),new T.ptr(new $Int64(0,25741),new $Int64(0,9193)),new T.ptr(new $Int64(0,25747),new $Int64(0,22857)),new T.ptr(new $Int64(0,25759),new $Int64(0,22757)),new T.ptr(new $Int64(0,25763),new $Int64(0,80)),new T.ptr(new $Int64(0,25771),new $Int64(0,21555)),new T.ptr(new $Int64(0,25793),new $Int64(0,14426)),new T.ptr(new $Int64(0,25799),new $Int64(0,10026)),new T.ptr(new $Int64(0,25801),new $Int64(0,4562)),new T.ptr(new $Int64(0,25819),new $Int64(0,20940)),new T.ptr(new $Int64(0,25841),new $Int64(0,13286)),new T.ptr(new $Int64(0,25847),new $Int64(0,8955)),new T.ptr(new $Int64(0,25849),new $Int64(0,7504)),new T.ptr(new $Int64(0,25867),new $Int64(0,24514)),new T.ptr(new $Int64(0,25873),new $Int64(0,19106)),new T.ptr(new $Int64(0,25889),new $Int64(0,9395)),new T.ptr(new $Int64(0,25903),new $Int64(0,6209)),new T.ptr(new $Int64(0,25913),new $Int64(0,9704)),new T.ptr(new $Int64(0,25919),new $Int64(0,10953)),new T.ptr(new $Int64(0,25931),new $Int64(0,21732)),new T.ptr(new $Int64(0,25933),new $Int64(0,2505)),new T.ptr(new $Int64(0,25939),new $Int64(0,9506)),new T.ptr(new $Int64(0,25943),new $Int64(0,24948)),new T.ptr(new $Int64(0,25951),new $Int64(0,25011)),new T.ptr(new $Int64(0,25969),new $Int64(0,6553)),new T.ptr(new $Int64(0,25981),new $Int64(0,19505)),new T.ptr(new $Int64(0,25997),new $Int64(0,12117)),new T.ptr(new $Int64(0,25999),new $Int64(0,8554)),new T.ptr(new $Int64(0,26003),new $Int64(0,4315)),new T.ptr(new $Int64(0,26017),new $Int64(0,530)),new T.ptr(new $Int64(0,26021),new $Int64(0,21424)),new T.ptr(new $Int64(0,26029),new $Int64(0,22703)),new T.ptr(new $Int64(0,26041),new $Int64(0,22945)),new T.ptr(new $Int64(0,26053),new $Int64(0,981)),new T.ptr(new $Int64(0,26083),new $Int64(0,2982)),new T.ptr(new $Int64(0,26099),new $Int64(0,16726)),new T.ptr(new $Int64(0,26107),new $Int64(0,5259)),new T.ptr(new $Int64(0,26111),new $Int64(0,25000)),new T.ptr(new $Int64(0,26113),new $Int64(0,5)),new T.ptr(new $Int64(0,26119),new $Int64(0,7054)),new T.ptr(new $Int64(0,26141),new $Int64(0,9066)),new T.ptr(new $Int64(0,26153),new $Int64(0,25470)),new T.ptr(new $Int64(0,26161),new $Int64(0,20777)),new T.ptr(new $Int64(0,26171),new $Int64(0,3318)),new T.ptr(new $Int64(0,26177),new $Int64(0,25394)),new T.ptr(new $Int64(0,26183),new $Int64(0,13539)),new T.ptr(new $Int64(0,26189),new $Int64(0,11453)),new T.ptr(new $Int64(0,26203),new $Int64(0,2001)),new T.ptr(new $Int64(0,26209),new $Int64(0,3812)),new T.ptr(new $Int64(0,26227),new $Int64(0,6174)),new T.ptr(new $Int64(0,26237),new $Int64(0,15479)),new T.ptr(new $Int64(0,26249),new $Int64(0,15924)),new T.ptr(new $Int64(0,26251),new $Int64(0,10234)),new T.ptr(new $Int64(0,26261),new $Int64(0,22225)),new T.ptr(new $Int64(0,26263),new $Int64(0,7371)),new T.ptr(new $Int64(0,26267),new $Int64(0,2396)),new T.ptr(new $Int64(0,26293),new $Int64(0,12705)),new T.ptr(new $Int64(0,26297),new $Int64(0,8198)),new T.ptr(new $Int64(0,26309),new $Int64(0,21966)),new T.ptr(new $Int64(0,26317),new $Int64(0,24763)),new T.ptr(new $Int64(0,26321),new $Int64(0,4540)),new T.ptr(new $Int64(0,26339),new $Int64(0,17485)),new T.ptr(new $Int64(0,26347),new $Int64(0,7413)),new T.ptr(new $Int64(0,26357),new $Int64(0,357)),new T.ptr(new $Int64(0,26371),new $Int64(0,13890)),new T.ptr(new $Int64(0,26387),new $Int64(0,21123)),new T.ptr(new $Int64(0,26393),new $Int64(0,24860)),new T.ptr(new $Int64(0,26399),new $Int64(0,5222)),new T.ptr(new $Int64(0,26407),new $Int64(0,1824)),new T.ptr(new $Int64(0,26417),new $Int64(0,13883)),new T.ptr(new $Int64(0,26423),new $Int64(0,14455)),new T.ptr(new $Int64(0,26431),new $Int64(0,20800)),new T.ptr(new $Int64(0,26437),new $Int64(0,25589)),new T.ptr(new $Int64(0,26449),new $Int64(0,9105)),new T.ptr(new $Int64(0,26459),new $Int64(0,15080)),new T.ptr(new $Int64(0,26479),new $Int64(0,5326)),new T.ptr(new $Int64(0,26489),new $Int64(0,18610)),new T.ptr(new $Int64(0,26497),new $Int64(0,6628)),new T.ptr(new $Int64(0,26501),new $Int64(0,20469)),new T.ptr(new $Int64(0,26513),new $Int64(0,22086)),new T.ptr(new $Int64(0,26539),new $Int64(0,4662)),new T.ptr(new $Int64(0,26557),new $Int64(0,23397)),new T.ptr(new $Int64(0,26561),new $Int64(0,4661)),new T.ptr(new $Int64(0,26573),new $Int64(0,5717)),new T.ptr(new $Int64(0,26591),new $Int64(0,8113)),new T.ptr(new $Int64(0,26597),new $Int64(0,10829)),new T.ptr(new $Int64(0,26627),new $Int64(0,13202)),new T.ptr(new $Int64(0,26633),new $Int64(0,8191)),new T.ptr(new $Int64(0,26641),new $Int64(0,24831)),new T.ptr(new $Int64(0,26647),new $Int64(0,18851)),new T.ptr(new $Int64(0,26669),new $Int64(0,18510)),new T.ptr(new $Int64(0,26681),new $Int64(0,22114)),new T.ptr(new $Int64(0,26683),new $Int64(0,20084)),new T.ptr(new $Int64(0,26687),new $Int64(0,2341)),new T.ptr(new $Int64(0,26693),new $Int64(0,17796)),new T.ptr(new $Int64(0,26699),new $Int64(0,2094)),new T.ptr(new $Int64(0,26701),new $Int64(0,26314)),new T.ptr(new $Int64(0,26711),new $Int64(0,26375)),new T.ptr(new $Int64(0,26713),new $Int64(0,15243)),new T.ptr(new $Int64(0,26717),new $Int64(0,11038)),new T.ptr(new $Int64(0,26723),new $Int64(0,15113)),new T.ptr(new $Int64(0,26729),new $Int64(0,9326)),new T.ptr(new $Int64(0,26731),new $Int64(0,9620)),new T.ptr(new $Int64(0,26737),new $Int64(0,16464)),new T.ptr(new $Int64(0,26759),new $Int64(0,17296)),new T.ptr(new $Int64(0,26777),new $Int64(0,20305)),new T.ptr(new $Int64(0,26783),new $Int64(0,7401)),new T.ptr(new $Int64(0,26801),new $Int64(0,15627)),new T.ptr(new $Int64(0,26813),new $Int64(0,6224)),new T.ptr(new $Int64(0,26821),new $Int64(0,817)),new T.ptr(new $Int64(0,26833),new $Int64(0,21048)),new T.ptr(new $Int64(0,26839),new $Int64(0,8455)),new T.ptr(new $Int64(0,26849),new $Int64(0,24281)),new T.ptr(new $Int64(0,26861),new $Int64(0,13475)),new T.ptr(new $Int64(0,26863),new $Int64(0,2199)),new T.ptr(new $Int64(0,26879),new $Int64(0,6579)),new T.ptr(new $Int64(0,26881),new $Int64(0,6955)),new T.ptr(new $Int64(0,26891),new $Int64(0,2872)),new T.ptr(new $Int64(0,26893),new $Int64(0,26025)),new T.ptr(new $Int64(0,26903),new $Int64(0,6601)),new T.ptr(new $Int64(0,26921),new $Int64(0,25594)),new T.ptr(new $Int64(0,26927),new $Int64(0,15032)),new T.ptr(new $Int64(0,26947),new $Int64(0,15604)),new T.ptr(new $Int64(0,26951),new $Int64(0,6392)),new T.ptr(new $Int64(0,26953),new $Int64(0,17911)),new T.ptr(new $Int64(0,26959),new $Int64(0,19912)),new T.ptr(new $Int64(0,26981),new $Int64(0,9546)),new T.ptr(new $Int64(0,26987),new $Int64(0,4942)),new T.ptr(new $Int64(0,26993),new $Int64(0,17605)),new T.ptr(new $Int64(0,27011),new $Int64(0,16080)),new T.ptr(new $Int64(0,27017),new $Int64(0,15062)),new T.ptr(new $Int64(0,27031),new $Int64(0,26862)),new T.ptr(new $Int64(0,27043),new $Int64(0,20409)),new T.ptr(new $Int64(0,27059),new $Int64(0,17990)),new T.ptr(new $Int64(0,27061),new $Int64(0,18883)),new T.ptr(new $Int64(0,27067),new $Int64(0,20757)),new T.ptr(new $Int64(0,27073),new $Int64(0,26970)),new T.ptr(new $Int64(0,27077),new $Int64(0,1584)),new T.ptr(new $Int64(0,27091),new $Int64(0,8667)),new T.ptr(new $Int64(0,27103),new $Int64(0,3058)),new T.ptr(new $Int64(0,27107),new $Int64(0,10055)),new T.ptr(new $Int64(0,27109),new $Int64(0,21993)),new T.ptr(new $Int64(0,27127),new $Int64(0,10627)),new T.ptr(new $Int64(0,27143),new $Int64(0,14876)),new T.ptr(new $Int64(0,27179),new $Int64(0,16142)),new T.ptr(new $Int64(0,27191),new $Int64(0,7291)),new T.ptr(new $Int64(0,27197),new $Int64(0,27185)),new T.ptr(new $Int64(0,27211),new $Int64(0,12049)),new T.ptr(new $Int64(0,27239),new $Int64(0,23484)),new T.ptr(new $Int64(0,27241),new $Int64(0,3211)),new T.ptr(new $Int64(0,27253),new $Int64(0,20901)),new T.ptr(new $Int64(0,27259),new $Int64(0,8492)),new T.ptr(new $Int64(0,27271),new $Int64(0,2009)),new T.ptr(new $Int64(0,27277),new $Int64(0,5229)),new T.ptr(new $Int64(0,27281),new $Int64(0,24083)),new T.ptr(new $Int64(0,27283),new $Int64(0,5763)),new T.ptr(new $Int64(0,27299),new $Int64(0,11168)),new T.ptr(new $Int64(0,27329),new $Int64(0,10409)),new T.ptr(new $Int64(0,27337),new $Int64(0,14676)),new T.ptr(new $Int64(0,27361),new $Int64(0,18696)),new T.ptr(new $Int64(0,27367),new $Int64(0,23598)),new T.ptr(new $Int64(0,27397),new $Int64(0,21838)),new T.ptr(new $Int64(0,27407),new $Int64(0,6648)),new T.ptr(new $Int64(0,27409),new $Int64(0,25043)),new T.ptr(new $Int64(0,27427),new $Int64(0,12457)),new T.ptr(new $Int64(0,27431),new $Int64(0,22948)),new T.ptr(new $Int64(0,27437),new $Int64(0,8293)),new T.ptr(new $Int64(0,27449),new $Int64(0,12100)),new T.ptr(new $Int64(0,27457),new $Int64(0,14905)),new T.ptr(new $Int64(0,27479),new $Int64(0,1263)),new T.ptr(new $Int64(0,27481),new $Int64(0,3706)),new T.ptr(new $Int64(0,27487),new $Int64(0,608)),new T.ptr(new $Int64(0,27509),new $Int64(0,8705)),new T.ptr(new $Int64(0,27527),new $Int64(0,12617)),new T.ptr(new $Int64(0,27529),new $Int64(0,13382)),new T.ptr(new $Int64(0,27539),new $Int64(0,10826)),new T.ptr(new $Int64(0,27541),new $Int64(0,14238)),new T.ptr(new $Int64(0,27551),new $Int64(0,7938)),new T.ptr(new $Int64(0,27581),new $Int64(0,9097)),new T.ptr(new $Int64(0,27583),new $Int64(0,14713)),new T.ptr(new $Int64(0,27611),new $Int64(0,9431)),new T.ptr(new $Int64(0,27617),new $Int64(0,27122)),new T.ptr(new $Int64(0,27631),new $Int64(0,22186)),new T.ptr(new $Int64(0,27647),new $Int64(0,24355)),new T.ptr(new $Int64(0,27653),new $Int64(0,16668)),new T.ptr(new $Int64(0,27673),new $Int64(0,17256)),new T.ptr(new $Int64(0,27689),new $Int64(0,18070)),new T.ptr(new $Int64(0,27691),new $Int64(0,11238)),new T.ptr(new $Int64(0,27697),new $Int64(0,25937)),new T.ptr(new $Int64(0,27701),new $Int64(0,6729)),new T.ptr(new $Int64(0,27733),new $Int64(0,4923)),new T.ptr(new $Int64(0,27737),new $Int64(0,251)),new T.ptr(new $Int64(0,27739),new $Int64(0,18867)),new T.ptr(new $Int64(0,27743),new $Int64(0,3897)),new T.ptr(new $Int64(0,27749),new $Int64(0,18622)),new T.ptr(new $Int64(0,27751),new $Int64(0,20314)),new T.ptr(new $Int64(0,27763),new $Int64(0,13658)),new T.ptr(new $Int64(0,27767),new $Int64(0,21132)),new T.ptr(new $Int64(0,27773),new $Int64(0,17212)),new T.ptr(new $Int64(0,27779),new $Int64(0,14306)),new T.ptr(new $Int64(0,27791),new $Int64(0,1927)),new T.ptr(new $Int64(0,27793),new $Int64(0,13999)),new T.ptr(new $Int64(0,27799),new $Int64(0,24226)),new T.ptr(new $Int64(0,27803),new $Int64(0,26695)),new T.ptr(new $Int64(0,27809),new $Int64(0,18315)),new T.ptr(new $Int64(0,27817),new $Int64(0,10015)),new T.ptr(new $Int64(0,27823),new $Int64(0,21901)),new T.ptr(new $Int64(0,27827),new $Int64(0,19885)),new T.ptr(new $Int64(0,27847),new $Int64(0,14303)),new T.ptr(new $Int64(0,27851),new $Int64(0,7621)),new T.ptr(new $Int64(0,27883),new $Int64(0,6224)),new T.ptr(new $Int64(0,27893),new $Int64(0,15503)),new T.ptr(new $Int64(0,27901),new $Int64(0,10494)),new T.ptr(new $Int64(0,27917),new $Int64(0,11980)),new T.ptr(new $Int64(0,27919),new $Int64(0,7317)),new T.ptr(new $Int64(0,27941),new $Int64(0,9774)),new T.ptr(new $Int64(0,27943),new $Int64(0,10969)),new T.ptr(new $Int64(0,27947),new $Int64(0,20920)),new T.ptr(new $Int64(0,27953),new $Int64(0,20884)),new T.ptr(new $Int64(0,27961),new $Int64(0,24525)),new T.ptr(new $Int64(0,27967),new $Int64(0,4111)),new T.ptr(new $Int64(0,27983),new $Int64(0,14945)),new T.ptr(new $Int64(0,27997),new $Int64(0,21645)),new T.ptr(new $Int64(0,28001),new $Int64(0,8746)),new T.ptr(new $Int64(0,28019),new $Int64(0,22519)),new T.ptr(new $Int64(0,28027),new $Int64(0,27093)),new T.ptr(new $Int64(0,28031),new $Int64(0,23982)),new T.ptr(new $Int64(0,28051),new $Int64(0,5163)),new T.ptr(new $Int64(0,28057),new $Int64(0,13577)),new T.ptr(new $Int64(0,28069),new $Int64(0,24258)),new T.ptr(new $Int64(0,28081),new $Int64(0,20787)),new T.ptr(new $Int64(0,28087),new $Int64(0,20010)),new T.ptr(new $Int64(0,28097),new $Int64(0,13587)),new T.ptr(new $Int64(0,28099),new $Int64(0,19168)),new T.ptr(new $Int64(0,28109),new $Int64(0,27681)),new T.ptr(new $Int64(0,28111),new $Int64(0,10917)),new T.ptr(new $Int64(0,28123),new $Int64(0,14397)),new T.ptr(new $Int64(0,28151),new $Int64(0,3105)),new T.ptr(new $Int64(0,28163),new $Int64(0,16265)),new T.ptr(new $Int64(0,28181),new $Int64(0,17234)),new T.ptr(new $Int64(0,28183),new $Int64(0,15934)),new T.ptr(new $Int64(0,28201),new $Int64(0,27750)),new T.ptr(new $Int64(0,28211),new $Int64(0,3633)),new T.ptr(new $Int64(0,28219),new $Int64(0,23112)),new T.ptr(new $Int64(0,28229),new $Int64(0,529)),new T.ptr(new $Int64(0,28277),new $Int64(0,6174)),new T.ptr(new $Int64(0,28279),new $Int64(0,13118)),new T.ptr(new $Int64(0,28283),new $Int64(0,14526)),new T.ptr(new $Int64(0,28289),new $Int64(0,27505)),new T.ptr(new $Int64(0,28297),new $Int64(0,23672)),new T.ptr(new $Int64(0,28307),new $Int64(0,1762)),new T.ptr(new $Int64(0,28309),new $Int64(0,6592)),new T.ptr(new $Int64(0,28319),new $Int64(0,20511)),new T.ptr(new $Int64(0,28349),new $Int64(0,1834)),new T.ptr(new $Int64(0,28351),new $Int64(0,26616)),new T.ptr(new $Int64(0,28387),new $Int64(0,23329)),new T.ptr(new $Int64(0,28393),new $Int64(0,516)),new T.ptr(new $Int64(0,28403),new $Int64(0,15070)),new T.ptr(new $Int64(0,28409),new $Int64(0,24216)),new T.ptr(new $Int64(0,28411),new $Int64(0,5655)),new T.ptr(new $Int64(0,28429),new $Int64(0,9318)),new T.ptr(new $Int64(0,28433),new $Int64(0,16215)),new T.ptr(new $Int64(0,28439),new $Int64(0,21365)),new T.ptr(new $Int64(0,28447),new $Int64(0,3329)),new T.ptr(new $Int64(0,28463),new $Int64(0,16225)),new T.ptr(new $Int64(0,28477),new $Int64(0,1334)),new T.ptr(new $Int64(0,28493),new $Int64(0,9802)),new T.ptr(new $Int64(0,28499),new $Int64(0,954)),new T.ptr(new $Int64(0,28513),new $Int64(0,8209)),new T.ptr(new $Int64(0,28517),new $Int64(0,9702)),new T.ptr(new $Int64(0,28537),new $Int64(0,6169)),new T.ptr(new $Int64(0,28541),new $Int64(0,4538)),new T.ptr(new $Int64(0,28547),new $Int64(0,11901)),new T.ptr(new $Int64(0,28549),new $Int64(0,27696)),new T.ptr(new $Int64(0,28559),new $Int64(0,18973)),new T.ptr(new $Int64(0,28571),new $Int64(0,19235)),new T.ptr(new $Int64(0,28573),new $Int64(0,3074)),new T.ptr(new $Int64(0,28579),new $Int64(0,7647)),new T.ptr(new $Int64(0,28591),new $Int64(0,26927)),new T.ptr(new $Int64(0,28597),new $Int64(0,454)),new T.ptr(new $Int64(0,28603),new $Int64(0,2270)),new T.ptr(new $Int64(0,28607),new $Int64(0,8368)),new T.ptr(new $Int64(0,28619),new $Int64(0,12337)),new T.ptr(new $Int64(0,28621),new $Int64(0,3245)),new T.ptr(new $Int64(0,28627),new $Int64(0,24184)),new T.ptr(new $Int64(0,28631),new $Int64(0,10995)),new T.ptr(new $Int64(0,28643),new $Int64(0,20491)),new T.ptr(new $Int64(0,28649),new $Int64(0,14060)),new T.ptr(new $Int64(0,28657),new $Int64(0,14125)),new T.ptr(new $Int64(0,28661),new $Int64(0,20763)),new T.ptr(new $Int64(0,28663),new $Int64(0,4723)),new T.ptr(new $Int64(0,28669),new $Int64(0,20280)),new T.ptr(new $Int64(0,28687),new $Int64(0,23160)),new T.ptr(new $Int64(0,28697),new $Int64(0,11383)),new T.ptr(new $Int64(0,28703),new $Int64(0,22068)),new T.ptr(new $Int64(0,28711),new $Int64(0,20902)),new T.ptr(new $Int64(0,28723),new $Int64(0,1390)),new T.ptr(new $Int64(0,28729),new $Int64(0,11411)),new T.ptr(new $Int64(0,28751),new $Int64(0,25632)),new T.ptr(new $Int64(0,28753),new $Int64(0,24019)),new T.ptr(new $Int64(0,28759),new $Int64(0,27045)),new T.ptr(new $Int64(0,28771),new $Int64(0,22081)),new T.ptr(new $Int64(0,28789),new $Int64(0,5237)),new T.ptr(new $Int64(0,28793),new $Int64(0,6209)),new T.ptr(new $Int64(0,28807),new $Int64(0,2220)),new T.ptr(new $Int64(0,28813),new $Int64(0,7878)),new T.ptr(new $Int64(0,28817),new $Int64(0,25105)),new T.ptr(new $Int64(0,28837),new $Int64(0,2532)),new T.ptr(new $Int64(0,28843),new $Int64(0,28193)),new T.ptr(new $Int64(0,28859),new $Int64(0,21176)),new T.ptr(new $Int64(0,28867),new $Int64(0,24877)),new T.ptr(new $Int64(0,28871),new $Int64(0,6732)),new T.ptr(new $Int64(0,28879),new $Int64(0,8261)),new T.ptr(new $Int64(0,28901),new $Int64(0,8262)),new T.ptr(new $Int64(0,28909),new $Int64(0,17504)),new T.ptr(new $Int64(0,28921),new $Int64(0,14128)),new T.ptr(new $Int64(0,28927),new $Int64(0,18181)),new T.ptr(new $Int64(0,28933),new $Int64(0,12073)),new T.ptr(new $Int64(0,28949),new $Int64(0,10491)),new T.ptr(new $Int64(0,28961),new $Int64(0,20908)),new T.ptr(new $Int64(0,28979),new $Int64(0,19556)),new T.ptr(new $Int64(0,29009),new $Int64(0,19569)),new T.ptr(new $Int64(0,29017),new $Int64(0,15375)),new T.ptr(new $Int64(0,29021),new $Int64(0,5774)),new T.ptr(new $Int64(0,29023),new $Int64(0,16003)),new T.ptr(new $Int64(0,29027),new $Int64(0,13667)),new T.ptr(new $Int64(0,29033),new $Int64(0,22561)),new T.ptr(new $Int64(0,29059),new $Int64(0,3479)),new T.ptr(new $Int64(0,29063),new $Int64(0,13983)),new T.ptr(new $Int64(0,29077),new $Int64(0,12807)),new T.ptr(new $Int64(0,29101),new $Int64(0,12021)),new T.ptr(new $Int64(0,29123),new $Int64(0,24122)),new T.ptr(new $Int64(0,29129),new $Int64(0,5100)),new T.ptr(new $Int64(0,29131),new $Int64(0,2568)),new T.ptr(new $Int64(0,29137),new $Int64(0,6648)),new T.ptr(new $Int64(0,29147),new $Int64(0,17305)),new T.ptr(new $Int64(0,29153),new $Int64(0,25887)),new T.ptr(new $Int64(0,29167),new $Int64(0,24917)),new T.ptr(new $Int64(0,29173),new $Int64(0,28756)),new T.ptr(new $Int64(0,29179),new $Int64(0,6729)),new T.ptr(new $Int64(0,29191),new $Int64(0,24955)),new T.ptr(new $Int64(0,29201),new $Int64(0,20527)),new T.ptr(new $Int64(0,29207),new $Int64(0,24212)),new T.ptr(new $Int64(0,29209),new $Int64(0,10522)),new T.ptr(new $Int64(0,29221),new $Int64(0,18376)),new T.ptr(new $Int64(0,29231),new $Int64(0,27228)),new T.ptr(new $Int64(0,29243),new $Int64(0,26354)),new T.ptr(new $Int64(0,29251),new $Int64(0,18709)),new T.ptr(new $Int64(0,29269),new $Int64(0,9798)),new T.ptr(new $Int64(0,29287),new $Int64(0,27799)),new T.ptr(new $Int64(0,29297),new $Int64(0,2548)),new T.ptr(new $Int64(0,29303),new $Int64(0,16294)),new T.ptr(new $Int64(0,29311),new $Int64(0,15746)),new T.ptr(new $Int64(0,29327),new $Int64(0,11274)),new T.ptr(new $Int64(0,29333),new $Int64(0,16655)),new T.ptr(new $Int64(0,29339),new $Int64(0,9394)),new T.ptr(new $Int64(0,29347),new $Int64(0,29014)),new T.ptr(new $Int64(0,29363),new $Int64(0,13702)),new T.ptr(new $Int64(0,29383),new $Int64(0,17405)),new T.ptr(new $Int64(0,29387),new $Int64(0,1154)),new T.ptr(new $Int64(0,29389),new $Int64(0,23784)),new T.ptr(new $Int64(0,29399),new $Int64(0,17064)),new T.ptr(new $Int64(0,29401),new $Int64(0,6579)),new T.ptr(new $Int64(0,29411),new $Int64(0,26382)),new T.ptr(new $Int64(0,29423),new $Int64(0,24297)),new T.ptr(new $Int64(0,29429),new $Int64(0,6990)),new T.ptr(new $Int64(0,29437),new $Int64(0,17759)),new T.ptr(new $Int64(0,29443),new $Int64(0,13455)),new T.ptr(new $Int64(0,29453),new $Int64(0,13310)),new T.ptr(new $Int64(0,29473),new $Int64(0,6601)),new T.ptr(new $Int64(0,29483),new $Int64(0,27071)),new T.ptr(new $Int64(0,29501),new $Int64(0,14151)),new T.ptr(new $Int64(0,29527),new $Int64(0,13927)),new T.ptr(new $Int64(0,29531),new $Int64(0,13863)),new T.ptr(new $Int64(0,29537),new $Int64(0,24729)),new T.ptr(new $Int64(0,29567),new $Int64(0,910)),new T.ptr(new $Int64(0,29569),new $Int64(0,8643)),new T.ptr(new $Int64(0,29573),new $Int64(0,28845)),new T.ptr(new $Int64(0,29581),new $Int64(0,19814)),new T.ptr(new $Int64(0,29587),new $Int64(0,551)),new T.ptr(new $Int64(0,29599),new $Int64(0,12104)),new T.ptr(new $Int64(0,29611),new $Int64(0,17756)),new T.ptr(new $Int64(0,29629),new $Int64(0,5597)),new T.ptr(new $Int64(0,29633),new $Int64(0,17373)),new T.ptr(new $Int64(0,29641),new $Int64(0,20402)),new T.ptr(new $Int64(0,29663),new $Int64(0,5678)),new T.ptr(new $Int64(0,29669),new $Int64(0,27676)),new T.ptr(new $Int64(0,29671),new $Int64(0,26551)),new T.ptr(new $Int64(0,29683),new $Int64(0,21749)),new T.ptr(new $Int64(0,29717),new $Int64(0,2065)),new T.ptr(new $Int64(0,29723),new $Int64(0,18710)),new T.ptr(new $Int64(0,29741),new $Int64(0,19733)),new T.ptr(new $Int64(0,29753),new $Int64(0,15333)),new T.ptr(new $Int64(0,29759),new $Int64(0,12546)),new T.ptr(new $Int64(0,29761),new $Int64(0,26193)),new T.ptr(new $Int64(0,29789),new $Int64(0,19128)),new T.ptr(new $Int64(0,29803),new $Int64(0,4628)),new T.ptr(new $Int64(0,29819),new $Int64(0,4275)),new T.ptr(new $Int64(0,29833),new $Int64(0,2688)),new T.ptr(new $Int64(0,29837),new $Int64(0,13102)),new T.ptr(new $Int64(0,29851),new $Int64(0,3377)),new T.ptr(new $Int64(0,29863),new $Int64(0,16675)),new T.ptr(new $Int64(0,29867),new $Int64(0,8841)),new T.ptr(new $Int64(0,29873),new $Int64(0,18409)),new T.ptr(new $Int64(0,29879),new $Int64(0,22805)),new T.ptr(new $Int64(0,29881),new $Int64(0,5164)),new T.ptr(new $Int64(0,29917),new $Int64(0,22173)),new T.ptr(new $Int64(0,29921),new $Int64(0,7343)),new T.ptr(new $Int64(0,29927),new $Int64(0,26513)),new T.ptr(new $Int64(0,29947),new $Int64(0,9832)),new T.ptr(new $Int64(0,29959),new $Int64(0,25001)),new T.ptr(new $Int64(0,29983),new $Int64(0,25039)),new T.ptr(new $Int64(0,29989),new $Int64(0,19566)),new T.ptr(new $Int64(0,30011),new $Int64(0,6713)),new T.ptr(new $Int64(0,30013),new $Int64(0,8386)),new T.ptr(new $Int64(0,30029),new $Int64(0,22522)),new T.ptr(new $Int64(0,30047),new $Int64(0,6628)),new T.ptr(new $Int64(0,30059),new $Int64(0,8033)),new T.ptr(new $Int64(0,30071),new $Int64(0,25487)),new T.ptr(new $Int64(0,30089),new $Int64(0,14917)),new T.ptr(new $Int64(0,30091),new $Int64(0,17142)),new T.ptr(new $Int64(0,30097),new $Int64(0,25268)),new T.ptr(new $Int64(0,30103),new $Int64(0,12268)),new T.ptr(new $Int64(0,30109),new $Int64(0,23344)),new T.ptr(new $Int64(0,30113),new $Int64(0,5170)),new T.ptr(new $Int64(0,30119),new $Int64(0,21574)),new T.ptr(new $Int64(0,30133),new $Int64(0,18504)),new T.ptr(new $Int64(0,30137),new $Int64(0,9365)),new T.ptr(new $Int64(0,30139),new $Int64(0,7673)),new T.ptr(new $Int64(0,30161),new $Int64(0,5353)),new T.ptr(new $Int64(0,30169),new $Int64(0,28921)),new T.ptr(new $Int64(0,30181),new $Int64(0,22236)),new T.ptr(new $Int64(0,30187),new $Int64(0,26678)),new T.ptr(new $Int64(0,30197),new $Int64(0,28434)),new T.ptr(new $Int64(0,30203),new $Int64(0,23176)),new T.ptr(new $Int64(0,30211),new $Int64(0,6134)),new T.ptr(new $Int64(0,30223),new $Int64(0,1840)),new T.ptr(new $Int64(0,30241),new $Int64(0,10785)),new T.ptr(new $Int64(0,30253),new $Int64(0,11294)),new T.ptr(new $Int64(0,30259),new $Int64(0,19523)),new T.ptr(new $Int64(0,30269),new $Int64(0,13963)),new T.ptr(new $Int64(0,30271),new $Int64(0,25969)),new T.ptr(new $Int64(0,30293),new $Int64(0,3945)),new T.ptr(new $Int64(0,30307),new $Int64(0,29842)),new T.ptr(new $Int64(0,30313),new $Int64(0,18236)),new T.ptr(new $Int64(0,30319),new $Int64(0,25362)),new T.ptr(new $Int64(0,30323),new $Int64(0,13635)),new T.ptr(new $Int64(0,30341),new $Int64(0,20707)),new T.ptr(new $Int64(0,30347),new $Int64(0,4284)),new T.ptr(new $Int64(0,30367),new $Int64(0,9439)),new T.ptr(new $Int64(0,30389),new $Int64(0,18390)),new T.ptr(new $Int64(0,30391),new $Int64(0,17237)),new T.ptr(new $Int64(0,30403),new $Int64(0,29323)),new T.ptr(new $Int64(0,30427),new $Int64(0,27802)),new T.ptr(new $Int64(0,30431),new $Int64(0,9467)),new T.ptr(new $Int64(0,30449),new $Int64(0,27415)),new T.ptr(new $Int64(0,30467),new $Int64(0,2353)),new T.ptr(new $Int64(0,30469),new $Int64(0,642)),new T.ptr(new $Int64(0,30491),new $Int64(0,6333)),new T.ptr(new $Int64(0,30493),new $Int64(0,14308)),new T.ptr(new $Int64(0,30497),new $Int64(0,25289)),new T.ptr(new $Int64(0,30509),new $Int64(0,12245)),new T.ptr(new $Int64(0,30517),new $Int64(0,6094)),new T.ptr(new $Int64(0,30529),new $Int64(0,933)),new T.ptr(new $Int64(0,30539),new $Int64(0,30524)),new T.ptr(new $Int64(0,30553),new $Int64(0,20578)),new T.ptr(new $Int64(0,30557),new $Int64(0,1696)),new T.ptr(new $Int64(0,30559),new $Int64(0,621)),new T.ptr(new $Int64(0,30577),new $Int64(0,17790)),new T.ptr(new $Int64(0,30593),new $Int64(0,22184)),new T.ptr(new $Int64(0,30631),new $Int64(0,8040)),new T.ptr(new $Int64(0,30637),new $Int64(0,20656)),new T.ptr(new $Int64(0,30643),new $Int64(0,2187)),new T.ptr(new $Int64(0,30649),new $Int64(0,18481)),new T.ptr(new $Int64(0,30661),new $Int64(0,28195)),new T.ptr(new $Int64(0,30671),new $Int64(0,21185)),new T.ptr(new $Int64(0,30677),new $Int64(0,27844)),new T.ptr(new $Int64(0,30689),new $Int64(0,18127)),new T.ptr(new $Int64(0,30697),new $Int64(0,1024)),new T.ptr(new $Int64(0,30703),new $Int64(0,25947)),new T.ptr(new $Int64(0,30707),new $Int64(0,28201)),new T.ptr(new $Int64(0,30713),new $Int64(0,15705)),new T.ptr(new $Int64(0,30727),new $Int64(0,28644)),new T.ptr(new $Int64(0,30757),new $Int64(0,29033)),new T.ptr(new $Int64(0,30763),new $Int64(0,12706)),new T.ptr(new $Int64(0,30773),new $Int64(0,16950)),new T.ptr(new $Int64(0,30781),new $Int64(0,16159)),new T.ptr(new $Int64(0,30803),new $Int64(0,28960)),new T.ptr(new $Int64(0,30809),new $Int64(0,26508)),new T.ptr(new $Int64(0,30817),new $Int64(0,18453)),new T.ptr(new $Int64(0,30829),new $Int64(0,17527)),new T.ptr(new $Int64(0,30839),new $Int64(0,26865)),new T.ptr(new $Int64(0,30841),new $Int64(0,14080)),new T.ptr(new $Int64(0,30851),new $Int64(0,4312)),new T.ptr(new $Int64(0,30853),new $Int64(0,20703)),new T.ptr(new $Int64(0,30859),new $Int64(0,24596)),new T.ptr(new $Int64(0,30869),new $Int64(0,19914)),new T.ptr(new $Int64(0,30871),new $Int64(0,1349)),new T.ptr(new $Int64(0,30881),new $Int64(0,8319)),new T.ptr(new $Int64(0,30893),new $Int64(0,19948)),new T.ptr(new $Int64(0,30911),new $Int64(0,18201)),new T.ptr(new $Int64(0,30931),new $Int64(0,10050)),new T.ptr(new $Int64(0,30937),new $Int64(0,20781)),new T.ptr(new $Int64(0,30941),new $Int64(0,8907)),new T.ptr(new $Int64(0,30949),new $Int64(0,21831)),new T.ptr(new $Int64(0,30971),new $Int64(0,28988)),new T.ptr(new $Int64(0,30977),new $Int64(0,1611)),new T.ptr(new $Int64(0,30983),new $Int64(0,1845)),new T.ptr(new $Int64(0,31013),new $Int64(0,20862)),new T.ptr(new $Int64(0,31019),new $Int64(0,9715)),new T.ptr(new $Int64(0,31033),new $Int64(0,905)),new T.ptr(new $Int64(0,31039),new $Int64(0,9344)),new T.ptr(new $Int64(0,31051),new $Int64(0,25630)),new T.ptr(new $Int64(0,31063),new $Int64(0,13404)),new T.ptr(new $Int64(0,31069),new $Int64(0,23840)),new T.ptr(new $Int64(0,31079),new $Int64(0,6955)),new T.ptr(new $Int64(0,31081),new $Int64(0,25647)),new T.ptr(new $Int64(0,31091),new $Int64(0,17018)),new T.ptr(new $Int64(0,31121),new $Int64(0,6083)),new T.ptr(new $Int64(0,31123),new $Int64(0,5517)),new T.ptr(new $Int64(0,31139),new $Int64(0,358)),new T.ptr(new $Int64(0,31147),new $Int64(0,28491)),new T.ptr(new $Int64(0,31151),new $Int64(0,27865)),new T.ptr(new $Int64(0,31153),new $Int64(0,5888)),new T.ptr(new $Int64(0,31159),new $Int64(0,6672)),new T.ptr(new $Int64(0,31177),new $Int64(0,14277)),new T.ptr(new $Int64(0,31181),new $Int64(0,6671)),new T.ptr(new $Int64(0,31183),new $Int64(0,11244)),new T.ptr(new $Int64(0,31189),new $Int64(0,8322)),new T.ptr(new $Int64(0,31193),new $Int64(0,19908)),new T.ptr(new $Int64(0,31219),new $Int64(0,6295)),new T.ptr(new $Int64(0,31223),new $Int64(0,12870)),new T.ptr(new $Int64(0,31231),new $Int64(0,21863)),new T.ptr(new $Int64(0,31237),new $Int64(0,21435)),new T.ptr(new $Int64(0,31247),new $Int64(0,7080)),new T.ptr(new $Int64(0,31249),new $Int64(0,4108)),new T.ptr(new $Int64(0,31253),new $Int64(0,13218)),new T.ptr(new $Int64(0,31259),new $Int64(0,10727)),new T.ptr(new $Int64(0,31267),new $Int64(0,8891)),new T.ptr(new $Int64(0,31271),new $Int64(0,9947)),new T.ptr(new $Int64(0,31277),new $Int64(0,18015)),new T.ptr(new $Int64(0,31307),new $Int64(0,20808)),new T.ptr(new $Int64(0,31319),new $Int64(0,20525)),new T.ptr(new $Int64(0,31321),new $Int64(0,3160)),new T.ptr(new $Int64(0,31327),new $Int64(0,11177)),new T.ptr(new $Int64(0,31333),new $Int64(0,4623)),new T.ptr(new $Int64(0,31337),new $Int64(0,14152)),new T.ptr(new $Int64(0,31357),new $Int64(0,22927)),new T.ptr(new $Int64(0,31379),new $Int64(0,11834)),new T.ptr(new $Int64(0,31387),new $Int64(0,20464)),new T.ptr(new $Int64(0,31391),new $Int64(0,24881)),new T.ptr(new $Int64(0,31393),new $Int64(0,15875)),new T.ptr(new $Int64(0,31397),new $Int64(0,10525)),new T.ptr(new $Int64(0,31469),new $Int64(0,17566)),new T.ptr(new $Int64(0,31477),new $Int64(0,2072)),new T.ptr(new $Int64(0,31481),new $Int64(0,7317)),new T.ptr(new $Int64(0,31489),new $Int64(0,26034)),new T.ptr(new $Int64(0,31511),new $Int64(0,16697)),new T.ptr(new $Int64(0,31513),new $Int64(0,2619)),new T.ptr(new $Int64(0,31517),new $Int64(0,1277)),new T.ptr(new $Int64(0,31531),new $Int64(0,7095)),new T.ptr(new $Int64(0,31541),new $Int64(0,16642)),new T.ptr(new $Int64(0,31543),new $Int64(0,5040)),new T.ptr(new $Int64(0,31547),new $Int64(0,6691)),new T.ptr(new $Int64(0,31567),new $Int64(0,4924)),new T.ptr(new $Int64(0,31573),new $Int64(0,10052)),new T.ptr(new $Int64(0,31583),new $Int64(0,14312)),new T.ptr(new $Int64(0,31601),new $Int64(0,12396)),new T.ptr(new $Int64(0,31607),new $Int64(0,9435)),new T.ptr(new $Int64(0,31627),new $Int64(0,29404)),new T.ptr(new $Int64(0,31643),new $Int64(0,14924)),new T.ptr(new $Int64(0,31649),new $Int64(0,9525)),new T.ptr(new $Int64(0,31657),new $Int64(0,30689)),new T.ptr(new $Int64(0,31663),new $Int64(0,15371)),new T.ptr(new $Int64(0,31667),new $Int64(0,15258)),new T.ptr(new $Int64(0,31687),new $Int64(0,6019)),new T.ptr(new $Int64(0,31699),new $Int64(0,660)),new T.ptr(new $Int64(0,31721),new $Int64(0,25404)),new T.ptr(new $Int64(0,31723),new $Int64(0,21881)),new T.ptr(new $Int64(0,31727),new $Int64(0,12989)),new T.ptr(new $Int64(0,31729),new $Int64(0,14758)),new T.ptr(new $Int64(0,31741),new $Int64(0,24622)),new T.ptr(new $Int64(0,31751),new $Int64(0,8482)),new T.ptr(new $Int64(0,31769),new $Int64(0,4864)),new T.ptr(new $Int64(0,31771),new $Int64(0,16766)),new T.ptr(new $Int64(0,31793),new $Int64(0,26135)),new T.ptr(new $Int64(0,31799),new $Int64(0,22555)),new T.ptr(new $Int64(0,31817),new $Int64(0,13447)),new T.ptr(new $Int64(0,31847),new $Int64(0,21151)),new T.ptr(new $Int64(0,31849),new $Int64(0,11823)),new T.ptr(new $Int64(0,31859),new $Int64(0,16439)),new T.ptr(new $Int64(0,31873),new $Int64(0,15863)),new T.ptr(new $Int64(0,31883),new $Int64(0,30485)),new T.ptr(new $Int64(0,31891),new $Int64(0,20748)),new T.ptr(new $Int64(0,31907),new $Int64(0,11963)),new T.ptr(new $Int64(0,31957),new $Int64(0,3636)),new T.ptr(new $Int64(0,31963),new $Int64(0,525)),new T.ptr(new $Int64(0,31973),new $Int64(0,25181)),new T.ptr(new $Int64(0,31981),new $Int64(0,25543)),new T.ptr(new $Int64(0,31991),new $Int64(0,20339)),new T.ptr(new $Int64(0,32003),new $Int64(0,515)),new T.ptr(new $Int64(0,32009),new $Int64(0,10113)),new T.ptr(new $Int64(0,32027),new $Int64(0,31173)),new T.ptr(new $Int64(0,32029),new $Int64(0,20641)),new T.ptr(new $Int64(0,32051),new $Int64(0,8322)),new T.ptr(new $Int64(0,32057),new $Int64(0,23252)),new T.ptr(new $Int64(0,32059),new $Int64(0,6016)),new T.ptr(new $Int64(0,32063),new $Int64(0,23306)),new T.ptr(new $Int64(0,32069),new $Int64(0,15370)),new T.ptr(new $Int64(0,32077),new $Int64(0,30984)),new T.ptr(new $Int64(0,32083),new $Int64(0,15014)),new T.ptr(new $Int64(0,32089),new $Int64(0,8482)),new T.ptr(new $Int64(0,32099),new $Int64(0,19994)),new T.ptr(new $Int64(0,32117),new $Int64(0,3451)),new T.ptr(new $Int64(0,32119),new $Int64(0,4824)),new T.ptr(new $Int64(0,32141),new $Int64(0,7647)),new T.ptr(new $Int64(0,32143),new $Int64(0,2278)),new T.ptr(new $Int64(0,32159),new $Int64(0,3984)),new T.ptr(new $Int64(0,32173),new $Int64(0,19821)),new T.ptr(new $Int64(0,32183),new $Int64(0,16738)),new T.ptr(new $Int64(0,32189),new $Int64(0,21473)),new T.ptr(new $Int64(0,32191),new $Int64(0,24754)),new T.ptr(new $Int64(0,32203),new $Int64(0,3553)),new T.ptr(new $Int64(0,32213),new $Int64(0,31774)),new T.ptr(new $Int64(0,32233),new $Int64(0,25316)),new T.ptr(new $Int64(0,32237),new $Int64(0,22980)),new T.ptr(new $Int64(0,32251),new $Int64(0,27136)),new T.ptr(new $Int64(0,32257),new $Int64(0,17414)),new T.ptr(new $Int64(0,32261),new $Int64(0,20277)),new T.ptr(new $Int64(0,32297),new $Int64(0,260)),new T.ptr(new $Int64(0,32299),new $Int64(0,20452)),new T.ptr(new $Int64(0,32303),new $Int64(0,27837)),new T.ptr(new $Int64(0,32309),new $Int64(0,24813)),new T.ptr(new $Int64(0,32321),new $Int64(0,26498)),new T.ptr(new $Int64(0,32323),new $Int64(0,15869)),new T.ptr(new $Int64(0,32327),new $Int64(0,10425)),new T.ptr(new $Int64(0,32341),new $Int64(0,18658)),new T.ptr(new $Int64(0,32353),new $Int64(0,26897)),new T.ptr(new $Int64(0,32359),new $Int64(0,8319)),new T.ptr(new $Int64(0,32363),new $Int64(0,18238)),new T.ptr(new $Int64(0,32369),new $Int64(0,3048)),new T.ptr(new $Int64(0,32371),new $Int64(0,27431)),new T.ptr(new $Int64(0,32377),new $Int64(0,21910)),new T.ptr(new $Int64(0,32381),new $Int64(0,29313)),new T.ptr(new $Int64(0,32401),new $Int64(0,25312)),new T.ptr(new $Int64(0,32411),new $Int64(0,20946)),new T.ptr(new $Int64(0,32413),new $Int64(0,20066)),new T.ptr(new $Int64(0,32423),new $Int64(0,2449)),new T.ptr(new $Int64(0,32429),new $Int64(0,22605)),new T.ptr(new $Int64(0,32441),new $Int64(0,7054)),new T.ptr(new $Int64(0,32443),new $Int64(0,16803)),new T.ptr(new $Int64(0,32467),new $Int64(0,30412)),new T.ptr(new $Int64(0,32479),new $Int64(0,5527)),new T.ptr(new $Int64(0,32491),new $Int64(0,30811)),new T.ptr(new $Int64(0,32497),new $Int64(0,23095)),new T.ptr(new $Int64(0,32503),new $Int64(0,26007)),new T.ptr(new $Int64(0,32507),new $Int64(0,29984)),new T.ptr(new $Int64(0,32531),new $Int64(0,452)),new T.ptr(new $Int64(0,32533),new $Int64(0,1355)),new T.ptr(new $Int64(0,32537),new $Int64(0,15214)),new T.ptr(new $Int64(0,32561),new $Int64(0,119)),new T.ptr(new $Int64(0,32563),new $Int64(0,14035)),new T.ptr(new $Int64(0,32569),new $Int64(0,27903)),new T.ptr(new $Int64(0,32573),new $Int64(0,15566)),new T.ptr(new $Int64(0,32579),new $Int64(0,11896)),new T.ptr(new $Int64(0,32587),new $Int64(0,26097)),new T.ptr(new $Int64(0,32603),new $Int64(0,31206)),new T.ptr(new $Int64(0,32609),new $Int64(0,27112)),new T.ptr(new $Int64(0,32611),new $Int64(0,1930)),new T.ptr(new $Int64(0,32621),new $Int64(0,13953)),new T.ptr(new $Int64(0,32633),new $Int64(0,1495)),new T.ptr(new $Int64(0,32647),new $Int64(0,2679)),new T.ptr(new $Int64(0,32653),new $Int64(0,8406)),new T.ptr(new $Int64(0,32687),new $Int64(0,31995)),new T.ptr(new $Int64(0,32693),new $Int64(0,20849)),new T.ptr(new $Int64(0,32707),new $Int64(0,4432)),new T.ptr(new $Int64(0,32713),new $Int64(0,5758)),new T.ptr(new $Int64(0,32717),new $Int64(0,4496)),new T.ptr(new $Int64(0,32719),new $Int64(0,23578)),new T.ptr(new $Int64(0,32749),new $Int64(0,7037)),new T.ptr(new $Int64(0,32771),new $Int64(0,4875)),new T.ptr(new $Int64(0,32779),new $Int64(0,20232)),new T.ptr(new $Int64(0,32783),new $Int64(0,10107)),new T.ptr(new $Int64(0,32789),new $Int64(0,13979)),new T.ptr(new $Int64(0,32797),new $Int64(0,19098)),new T.ptr(new $Int64(0,32801),new $Int64(0,6182)),new T.ptr(new $Int64(0,32803),new $Int64(0,22331)),new T.ptr(new $Int64(0,32831),new $Int64(0,18118)),new T.ptr(new $Int64(0,32833),new $Int64(0,18604)),new T.ptr(new $Int64(0,32839),new $Int64(0,30685)),new T.ptr(new $Int64(0,32843),new $Int64(0,7878)),new T.ptr(new $Int64(0,32869),new $Int64(0,7621)),new T.ptr(new $Int64(0,32887),new $Int64(0,13442)),new T.ptr(new $Int64(0,32909),new $Int64(0,13011)),new T.ptr(new $Int64(0,32911),new $Int64(0,2556)),new T.ptr(new $Int64(0,32917),new $Int64(0,31335)),new T.ptr(new $Int64(0,32933),new $Int64(0,3565)),new T.ptr(new $Int64(0,32939),new $Int64(0,14989)),new T.ptr(new $Int64(0,32941),new $Int64(0,2945)),new T.ptr(new $Int64(0,32957),new $Int64(0,12760)),new T.ptr(new $Int64(0,32969),new $Int64(0,5937)),new T.ptr(new $Int64(0,32971),new $Int64(0,17004)),new T.ptr(new $Int64(0,32983),new $Int64(0,14562)),new T.ptr(new $Int64(0,32987),new $Int64(0,16619)),new T.ptr(new $Int64(0,32993),new $Int64(0,24188)),new T.ptr(new $Int64(0,32999),new $Int64(0,26472)),new T.ptr(new $Int64(0,33013),new $Int64(0,14567)),new T.ptr(new $Int64(0,33023),new $Int64(0,3550)),new T.ptr(new $Int64(0,33029),new $Int64(0,16721)),new T.ptr(new $Int64(0,33037),new $Int64(0,4749)),new T.ptr(new $Int64(0,33049),new $Int64(0,29899)),new T.ptr(new $Int64(0,33053),new $Int64(0,20121)),new T.ptr(new $Int64(0,33071),new $Int64(0,24825)),new T.ptr(new $Int64(0,33073),new $Int64(0,10480)),new T.ptr(new $Int64(0,33083),new $Int64(0,20131)),new T.ptr(new $Int64(0,33091),new $Int64(0,4008)),new T.ptr(new $Int64(0,33107),new $Int64(0,27660)),new T.ptr(new $Int64(0,33113),new $Int64(0,30495)),new T.ptr(new $Int64(0,33119),new $Int64(0,25311)),new T.ptr(new $Int64(0,33149),new $Int64(0,23140)),new T.ptr(new $Int64(0,33151),new $Int64(0,11947)),new T.ptr(new $Int64(0,33161),new $Int64(0,6548)),new T.ptr(new $Int64(0,33179),new $Int64(0,8005)),new T.ptr(new $Int64(0,33181),new $Int64(0,8469)),new T.ptr(new $Int64(0,33191),new $Int64(0,8303)),new T.ptr(new $Int64(0,33199),new $Int64(0,33144)),new T.ptr(new $Int64(0,33203),new $Int64(0,18247)),new T.ptr(new $Int64(0,33211),new $Int64(0,19782)),new T.ptr(new $Int64(0,33223),new $Int64(0,26915)),new T.ptr(new $Int64(0,33247),new $Int64(0,8906)),new T.ptr(new $Int64(0,33287),new $Int64(0,1091)),new T.ptr(new $Int64(0,33289),new $Int64(0,12025)),new T.ptr(new $Int64(0,33301),new $Int64(0,28427)),new T.ptr(new $Int64(0,33311),new $Int64(0,19714)),new T.ptr(new $Int64(0,33317),new $Int64(0,14497)),new T.ptr(new $Int64(0,33329),new $Int64(0,4670)),new T.ptr(new $Int64(0,33331),new $Int64(0,5036)),new T.ptr(new $Int64(0,33343),new $Int64(0,2896)),new T.ptr(new $Int64(0,33347),new $Int64(0,30992)),new T.ptr(new $Int64(0,33349),new $Int64(0,17094)),new T.ptr(new $Int64(0,33353),new $Int64(0,29150)),new T.ptr(new $Int64(0,33359),new $Int64(0,17163)),new T.ptr(new $Int64(0,33377),new $Int64(0,24943)),new T.ptr(new $Int64(0,33391),new $Int64(0,26911)),new T.ptr(new $Int64(0,33403),new $Int64(0,11594)),new T.ptr(new $Int64(0,33409),new $Int64(0,20212)),new T.ptr(new $Int64(0,33413),new $Int64(0,26482)),new T.ptr(new $Int64(0,33427),new $Int64(0,6433)),new T.ptr(new $Int64(0,33457),new $Int64(0,27387)),new T.ptr(new $Int64(0,33461),new $Int64(0,24140)),new T.ptr(new $Int64(0,33469),new $Int64(0,6523)),new T.ptr(new $Int64(0,33479),new $Int64(0,28429)),new T.ptr(new $Int64(0,33487),new $Int64(0,9539)),new T.ptr(new $Int64(0,33493),new $Int64(0,19162)),new T.ptr(new $Int64(0,33503),new $Int64(0,20738)),new T.ptr(new $Int64(0,33521),new $Int64(0,10872)),new T.ptr(new $Int64(0,33529),new $Int64(0,6116)),new T.ptr(new $Int64(0,33533),new $Int64(0,280)),new T.ptr(new $Int64(0,33547),new $Int64(0,22375)),new T.ptr(new $Int64(0,33563),new $Int64(0,8386)),new T.ptr(new $Int64(0,33569),new $Int64(0,31532)),new T.ptr(new $Int64(0,33577),new $Int64(0,11485)),new T.ptr(new $Int64(0,33581),new $Int64(0,10036)),new T.ptr(new $Int64(0,33587),new $Int64(0,16116)),new T.ptr(new $Int64(0,33589),new $Int64(0,22955)),new T.ptr(new $Int64(0,33599),new $Int64(0,23966)),new T.ptr(new $Int64(0,33601),new $Int64(0,31251)),new T.ptr(new $Int64(0,33613),new $Int64(0,2676)),new T.ptr(new $Int64(0,33617),new $Int64(0,16525)),new T.ptr(new $Int64(0,33619),new $Int64(0,17224)),new T.ptr(new $Int64(0,33623),new $Int64(0,17890)),new T.ptr(new $Int64(0,33629),new $Int64(0,23979)),new T.ptr(new $Int64(0,33637),new $Int64(0,32054)),new T.ptr(new $Int64(0,33641),new $Int64(0,31277)),new T.ptr(new $Int64(0,33647),new $Int64(0,1607)),new T.ptr(new $Int64(0,33679),new $Int64(0,26053)),new T.ptr(new $Int64(0,33703),new $Int64(0,16395)),new T.ptr(new $Int64(0,33713),new $Int64(0,7371)),new T.ptr(new $Int64(0,33721),new $Int64(0,28196)),new T.ptr(new $Int64(0,33739),new $Int64(0,11050)),new T.ptr(new $Int64(0,33749),new $Int64(0,9803)),new T.ptr(new $Int64(0,33751),new $Int64(0,22447)),new T.ptr(new $Int64(0,33757),new $Int64(0,29774)),new T.ptr(new $Int64(0,33767),new $Int64(0,567)),new T.ptr(new $Int64(0,33769),new $Int64(0,21678)),new T.ptr(new $Int64(0,33773),new $Int64(0,10505)),new T.ptr(new $Int64(0,33791),new $Int64(0,15002)),new T.ptr(new $Int64(0,33797),new $Int64(0,7413)),new T.ptr(new $Int64(0,33809),new $Int64(0,3724)),new T.ptr(new $Int64(0,33811),new $Int64(0,30205)),new T.ptr(new $Int64(0,33827),new $Int64(0,31945)),new T.ptr(new $Int64(0,33829),new $Int64(0,31703)),new T.ptr(new $Int64(0,33851),new $Int64(0,12002)),new T.ptr(new $Int64(0,33857),new $Int64(0,14343)),new T.ptr(new $Int64(0,33863),new $Int64(0,31820)),new T.ptr(new $Int64(0,33871),new $Int64(0,2123)),new T.ptr(new $Int64(0,33889),new $Int64(0,12648)),new T.ptr(new $Int64(0,33893),new $Int64(0,14707)),new T.ptr(new $Int64(0,33911),new $Int64(0,12650)),new T.ptr(new $Int64(0,33923),new $Int64(0,33215)),new T.ptr(new $Int64(0,33931),new $Int64(0,22143)),new T.ptr(new $Int64(0,33937),new $Int64(0,30899)),new T.ptr(new $Int64(0,33941),new $Int64(0,7804)),new T.ptr(new $Int64(0,33961),new $Int64(0,29177)),new T.ptr(new $Int64(0,33967),new $Int64(0,921)),new T.ptr(new $Int64(0,33997),new $Int64(0,5804)),new T.ptr(new $Int64(0,34019),new $Int64(0,21054)),new T.ptr(new $Int64(0,34031),new $Int64(0,21364)),new T.ptr(new $Int64(0,34033),new $Int64(0,17584)),new T.ptr(new $Int64(0,34039),new $Int64(0,23033)),new T.ptr(new $Int64(0,34057),new $Int64(0,11377)),new T.ptr(new $Int64(0,34061),new $Int64(0,5824)),new T.ptr(new $Int64(0,34123),new $Int64(0,16480)),new T.ptr(new $Int64(0,34127),new $Int64(0,13767)),new T.ptr(new $Int64(0,34129),new $Int64(0,22591)),new T.ptr(new $Int64(0,34141),new $Int64(0,2643)),new T.ptr(new $Int64(0,34147),new $Int64(0,4286)),new T.ptr(new $Int64(0,34157),new $Int64(0,8891)),new T.ptr(new $Int64(0,34159),new $Int64(0,9396)),new T.ptr(new $Int64(0,34171),new $Int64(0,4685)),new T.ptr(new $Int64(0,34183),new $Int64(0,3208)),new T.ptr(new $Int64(0,34211),new $Int64(0,7174)),new T.ptr(new $Int64(0,34213),new $Int64(0,5253)),new T.ptr(new $Int64(0,34217),new $Int64(0,9539)),new T.ptr(new $Int64(0,34231),new $Int64(0,6044)),new T.ptr(new $Int64(0,34253),new $Int64(0,21399)),new T.ptr(new $Int64(0,34259),new $Int64(0,11072)),new T.ptr(new $Int64(0,34261),new $Int64(0,3816)),new T.ptr(new $Int64(0,34267),new $Int64(0,32235)),new T.ptr(new $Int64(0,34273),new $Int64(0,7813)),new T.ptr(new $Int64(0,34283),new $Int64(0,26341)),new T.ptr(new $Int64(0,34297),new $Int64(0,17042)),new T.ptr(new $Int64(0,34301),new $Int64(0,21148)),new T.ptr(new $Int64(0,34303),new $Int64(0,13260)),new T.ptr(new $Int64(0,34313),new $Int64(0,21008)),new T.ptr(new $Int64(0,34319),new $Int64(0,4903)),new T.ptr(new $Int64(0,34327),new $Int64(0,28022)),new T.ptr(new $Int64(0,34337),new $Int64(0,6348)),new T.ptr(new $Int64(0,34351),new $Int64(0,31185)),new T.ptr(new $Int64(0,34361),new $Int64(0,8261)),new T.ptr(new $Int64(0,34367),new $Int64(0,21623)),new T.ptr(new $Int64(0,34369),new $Int64(0,501)),new T.ptr(new $Int64(0,34381),new $Int64(0,18358)),new T.ptr(new $Int64(0,34403),new $Int64(0,19422)),new T.ptr(new $Int64(0,34421),new $Int64(0,20156)),new T.ptr(new $Int64(0,34429),new $Int64(0,12454)),new T.ptr(new $Int64(0,34439),new $Int64(0,24806)),new T.ptr(new $Int64(0,34457),new $Int64(0,16456)),new T.ptr(new $Int64(0,34469),new $Int64(0,24819)),new T.ptr(new $Int64(0,34471),new $Int64(0,29090)),new T.ptr(new $Int64(0,34483),new $Int64(0,20581)),new T.ptr(new $Int64(0,34487),new $Int64(0,11535)),new T.ptr(new $Int64(0,34499),new $Int64(0,17043)),new T.ptr(new $Int64(0,34501),new $Int64(0,20559)),new T.ptr(new $Int64(0,34511),new $Int64(0,6737)),new T.ptr(new $Int64(0,34513),new $Int64(0,5799)),new T.ptr(new $Int64(0,34519),new $Int64(0,15116)),new T.ptr(new $Int64(0,34537),new $Int64(0,13642)),new T.ptr(new $Int64(0,34543),new $Int64(0,26466)),new T.ptr(new $Int64(0,34549),new $Int64(0,21057)),new T.ptr(new $Int64(0,34583),new $Int64(0,8209)),new T.ptr(new $Int64(0,34589),new $Int64(0,20206)),new T.ptr(new $Int64(0,34591),new $Int64(0,1477)),new T.ptr(new $Int64(0,34603),new $Int64(0,19581)),new T.ptr(new $Int64(0,34607),new $Int64(0,31558)),new T.ptr(new $Int64(0,34613),new $Int64(0,29162)),new T.ptr(new $Int64(0,34631),new $Int64(0,22398)),new T.ptr(new $Int64(0,34649),new $Int64(0,29985)),new T.ptr(new $Int64(0,34651),new $Int64(0,5997)),new T.ptr(new $Int64(0,34667),new $Int64(0,30314)),new T.ptr(new $Int64(0,34673),new $Int64(0,18873)),new T.ptr(new $Int64(0,34679),new $Int64(0,34610)),new T.ptr(new $Int64(0,34687),new $Int64(0,9465)),new T.ptr(new $Int64(0,34693),new $Int64(0,12397)),new T.ptr(new $Int64(0,34703),new $Int64(0,32852)),new T.ptr(new $Int64(0,34721),new $Int64(0,24442)),new T.ptr(new $Int64(0,34729),new $Int64(0,6890)),new T.ptr(new $Int64(0,34739),new $Int64(0,10186)),new T.ptr(new $Int64(0,34747),new $Int64(0,34561)),new T.ptr(new $Int64(0,34757),new $Int64(0,1443)),new T.ptr(new $Int64(0,34759),new $Int64(0,34250)),new T.ptr(new $Int64(0,34763),new $Int64(0,30391)),new T.ptr(new $Int64(0,34781),new $Int64(0,20888)),new T.ptr(new $Int64(0,34807),new $Int64(0,10680)),new T.ptr(new $Int64(0,34819),new $Int64(0,14743)),new T.ptr(new $Int64(0,34841),new $Int64(0,31975)),new T.ptr(new $Int64(0,34843),new $Int64(0,22223)),new T.ptr(new $Int64(0,34847),new $Int64(0,15624)),new T.ptr(new $Int64(0,34849),new $Int64(0,4442)),new T.ptr(new $Int64(0,34871),new $Int64(0,7504)),new T.ptr(new $Int64(0,34877),new $Int64(0,13364)),new T.ptr(new $Int64(0,34883),new $Int64(0,24049)),new T.ptr(new $Int64(0,34897),new $Int64(0,432)),new T.ptr(new $Int64(0,34913),new $Int64(0,30060)),new T.ptr(new $Int64(0,34919),new $Int64(0,25675)),new T.ptr(new $Int64(0,34939),new $Int64(0,19820)),new T.ptr(new $Int64(0,34949),new $Int64(0,23384)),new T.ptr(new $Int64(0,34961),new $Int64(0,27894)),new T.ptr(new $Int64(0,34963),new $Int64(0,29844)),new T.ptr(new $Int64(0,34981),new $Int64(0,28638)),new T.ptr(new $Int64(0,35023),new $Int64(0,2797)),new T.ptr(new $Int64(0,35027),new $Int64(0,12223)),new T.ptr(new $Int64(0,35051),new $Int64(0,31126)),new T.ptr(new $Int64(0,35053),new $Int64(0,13226)),new T.ptr(new $Int64(0,35059),new $Int64(0,9556)),new T.ptr(new $Int64(0,35069),new $Int64(0,22133)),new T.ptr(new $Int64(0,35081),new $Int64(0,4544)),new T.ptr(new $Int64(0,35083),new $Int64(0,34748)),new T.ptr(new $Int64(0,35089),new $Int64(0,20983)),new T.ptr(new $Int64(0,35099),new $Int64(0,8889)),new T.ptr(new $Int64(0,35107),new $Int64(0,19768)),new T.ptr(new $Int64(0,35111),new $Int64(0,8643)),new T.ptr(new $Int64(0,35117),new $Int64(0,33172)),new T.ptr(new $Int64(0,35129),new $Int64(0,34366)),new T.ptr(new $Int64(0,35141),new $Int64(0,18717)),new T.ptr(new $Int64(0,35149),new $Int64(0,26760)),new T.ptr(new $Int64(0,35153),new $Int64(0,5052)),new T.ptr(new $Int64(0,35159),new $Int64(0,1335)),new T.ptr(new $Int64(0,35171),new $Int64(0,13243)),new T.ptr(new $Int64(0,35201),new $Int64(0,34556)),new T.ptr(new $Int64(0,35221),new $Int64(0,10186)),new T.ptr(new $Int64(0,35227),new $Int64(0,27437)),new T.ptr(new $Int64(0,35251),new $Int64(0,35013)),new T.ptr(new $Int64(0,35257),new $Int64(0,27839)),new T.ptr(new $Int64(0,35267),new $Int64(0,15689)),new T.ptr(new $Int64(0,35279),new $Int64(0,247)),new T.ptr(new $Int64(0,35281),new $Int64(0,12089)),new T.ptr(new $Int64(0,35291),new $Int64(0,12160)),new T.ptr(new $Int64(0,35311),new $Int64(0,15230)),new T.ptr(new $Int64(0,35317),new $Int64(0,24270)),new T.ptr(new $Int64(0,35323),new $Int64(0,14907)),new T.ptr(new $Int64(0,35327),new $Int64(0,12063)),new T.ptr(new $Int64(0,35339),new $Int64(0,25366)),new T.ptr(new $Int64(0,35353),new $Int64(0,19043)),new T.ptr(new $Int64(0,35363),new $Int64(0,7246)),new T.ptr(new $Int64(0,35381),new $Int64(0,23157)),new T.ptr(new $Int64(0,35393),new $Int64(0,20856)),new T.ptr(new $Int64(0,35401),new $Int64(0,3607)),new T.ptr(new $Int64(0,35407),new $Int64(0,13234)),new T.ptr(new $Int64(0,35419),new $Int64(0,8628)),new T.ptr(new $Int64(0,35423),new $Int64(0,34666)),new T.ptr(new $Int64(0,35437),new $Int64(0,775)),new T.ptr(new $Int64(0,35447),new $Int64(0,7288)),new T.ptr(new $Int64(0,35449),new $Int64(0,21517)),new T.ptr(new $Int64(0,35461),new $Int64(0,6642)),new T.ptr(new $Int64(0,35491),new $Int64(0,5646)),new T.ptr(new $Int64(0,35507),new $Int64(0,22358)),new T.ptr(new $Int64(0,35509),new $Int64(0,21110)),new T.ptr(new $Int64(0,35521),new $Int64(0,28672)),new T.ptr(new $Int64(0,35527),new $Int64(0,23110)),new T.ptr(new $Int64(0,35531),new $Int64(0,5889)),new T.ptr(new $Int64(0,35533),new $Int64(0,770)),new T.ptr(new $Int64(0,35537),new $Int64(0,22013)),new T.ptr(new $Int64(0,35543),new $Int64(0,13763)),new T.ptr(new $Int64(0,35569),new $Int64(0,29194)),new T.ptr(new $Int64(0,35573),new $Int64(0,20660)),new T.ptr(new $Int64(0,35591),new $Int64(0,23730)),new T.ptr(new $Int64(0,35593),new $Int64(0,20239)),new T.ptr(new $Int64(0,35597),new $Int64(0,22388)),new T.ptr(new $Int64(0,35603),new $Int64(0,25399)),new T.ptr(new $Int64(0,35617),new $Int64(0,26700)),new T.ptr(new $Int64(0,35671),new $Int64(0,8864)),new T.ptr(new $Int64(0,35677),new $Int64(0,1600)),new T.ptr(new $Int64(0,35729),new $Int64(0,27850)),new T.ptr(new $Int64(0,35731),new $Int64(0,6291)),new T.ptr(new $Int64(0,35747),new $Int64(0,29080)),new T.ptr(new $Int64(0,35753),new $Int64(0,16032)),new T.ptr(new $Int64(0,35759),new $Int64(0,23792)),new T.ptr(new $Int64(0,35771),new $Int64(0,22367)),new T.ptr(new $Int64(0,35797),new $Int64(0,6755)),new T.ptr(new $Int64(0,35801),new $Int64(0,22806)),new T.ptr(new $Int64(0,35803),new $Int64(0,17041)),new T.ptr(new $Int64(0,35809),new $Int64(0,10932)),new T.ptr(new $Int64(0,35831),new $Int64(0,32982)),new T.ptr(new $Int64(0,35837),new $Int64(0,6321)),new T.ptr(new $Int64(0,35839),new $Int64(0,8605)),new T.ptr(new $Int64(0,35851),new $Int64(0,15445)),new T.ptr(new $Int64(0,35863),new $Int64(0,10137)),new T.ptr(new $Int64(0,35869),new $Int64(0,25409)),new T.ptr(new $Int64(0,35879),new $Int64(0,27492)),new T.ptr(new $Int64(0,35897),new $Int64(0,24818)),new T.ptr(new $Int64(0,35899),new $Int64(0,10036)),new T.ptr(new $Int64(0,35911),new $Int64(0,5085)),new T.ptr(new $Int64(0,35923),new $Int64(0,10459)),new T.ptr(new $Int64(0,35933),new $Int64(0,15664)),new T.ptr(new $Int64(0,35951),new $Int64(0,18906)),new T.ptr(new $Int64(0,35963),new $Int64(0,23105)),new T.ptr(new $Int64(0,35969),new $Int64(0,29151)),new T.ptr(new $Int64(0,35977),new $Int64(0,5549)),new T.ptr(new $Int64(0,35983),new $Int64(0,18942)),new T.ptr(new $Int64(0,35993),new $Int64(0,12472)),new T.ptr(new $Int64(0,35999),new $Int64(0,34345)),new T.ptr(new $Int64(0,36007),new $Int64(0,13782)),new T.ptr(new $Int64(0,36011),new $Int64(0,32698)),new T.ptr(new $Int64(0,36013),new $Int64(0,2975)),new T.ptr(new $Int64(0,36017),new $Int64(0,13459)),new T.ptr(new $Int64(0,36037),new $Int64(0,32433)),new T.ptr(new $Int64(0,36061),new $Int64(0,17742)),new T.ptr(new $Int64(0,36067),new $Int64(0,3374)),new T.ptr(new $Int64(0,36073),new $Int64(0,8872)),new T.ptr(new $Int64(0,36083),new $Int64(0,7754)),new T.ptr(new $Int64(0,36097),new $Int64(0,25978)),new T.ptr(new $Int64(0,36107),new $Int64(0,29445)),new T.ptr(new $Int64(0,36109),new $Int64(0,20132)),new T.ptr(new $Int64(0,36131),new $Int64(0,23314)),new T.ptr(new $Int64(0,36137),new $Int64(0,27872)),new T.ptr(new $Int64(0,36151),new $Int64(0,9525)),new T.ptr(new $Int64(0,36161),new $Int64(0,9344)),new T.ptr(new $Int64(0,36187),new $Int64(0,32089)),new T.ptr(new $Int64(0,36191),new $Int64(0,25287)),new T.ptr(new $Int64(0,36209),new $Int64(0,33216)),new T.ptr(new $Int64(0,36217),new $Int64(0,12786)),new T.ptr(new $Int64(0,36229),new $Int64(0,7640)),new T.ptr(new $Int64(0,36241),new $Int64(0,17378)),new T.ptr(new $Int64(0,36251),new $Int64(0,7638)),new T.ptr(new $Int64(0,36263),new $Int64(0,32445)),new T.ptr(new $Int64(0,36269),new $Int64(0,26260)),new T.ptr(new $Int64(0,36277),new $Int64(0,286)),new T.ptr(new $Int64(0,36293),new $Int64(0,14842)),new T.ptr(new $Int64(0,36299),new $Int64(0,10172)),new T.ptr(new $Int64(0,36307),new $Int64(0,8293)),new T.ptr(new $Int64(0,36313),new $Int64(0,19415)),new T.ptr(new $Int64(0,36319),new $Int64(0,27297)),new T.ptr(new $Int64(0,36341),new $Int64(0,8138)),new T.ptr(new $Int64(0,36343),new $Int64(0,15283)),new T.ptr(new $Int64(0,36353),new $Int64(0,25126)),new T.ptr(new $Int64(0,36373),new $Int64(0,31311)),new T.ptr(new $Int64(0,36383),new $Int64(0,11544)),new T.ptr(new $Int64(0,36389),new $Int64(0,26565)),new T.ptr(new $Int64(0,36433),new $Int64(0,16895)),new T.ptr(new $Int64(0,36451),new $Int64(0,32964)),new T.ptr(new $Int64(0,36457),new $Int64(0,12288)),new T.ptr(new $Int64(0,36467),new $Int64(0,8791)),new T.ptr(new $Int64(0,36469),new $Int64(0,17746)),new T.ptr(new $Int64(0,36473),new $Int64(0,22877)),new T.ptr(new $Int64(0,36479),new $Int64(0,23032)),new T.ptr(new $Int64(0,36493),new $Int64(0,2723)),new T.ptr(new $Int64(0,36497),new $Int64(0,13055)),new T.ptr(new $Int64(0,36523),new $Int64(0,27381)),new T.ptr(new $Int64(0,36527),new $Int64(0,3861)),new T.ptr(new $Int64(0,36529),new $Int64(0,29690)),new T.ptr(new $Int64(0,36541),new $Int64(0,8560)),new T.ptr(new $Int64(0,36551),new $Int64(0,21668)),new T.ptr(new $Int64(0,36559),new $Int64(0,30107)),new T.ptr(new $Int64(0,36563),new $Int64(0,22139)),new T.ptr(new $Int64(0,36571),new $Int64(0,3370)),new T.ptr(new $Int64(0,36583),new $Int64(0,4822)),new T.ptr(new $Int64(0,36587),new $Int64(0,14668)),new T.ptr(new $Int64(0,36599),new $Int64(0,32029)),new T.ptr(new $Int64(0,36607),new $Int64(0,11854)),new T.ptr(new $Int64(0,36629),new $Int64(0,1711)),new T.ptr(new $Int64(0,36637),new $Int64(0,15112)),new T.ptr(new $Int64(0,36643),new $Int64(0,8216)),new T.ptr(new $Int64(0,36653),new $Int64(0,35055)),new T.ptr(new $Int64(0,36671),new $Int64(0,10932)),new T.ptr(new $Int64(0,36677),new $Int64(0,30835)),new T.ptr(new $Int64(0,36683),new $Int64(0,16788)),new T.ptr(new $Int64(0,36691),new $Int64(0,27353)),new T.ptr(new $Int64(0,36697),new $Int64(0,161)),new T.ptr(new $Int64(0,36709),new $Int64(0,36529)),new T.ptr(new $Int64(0,36713),new $Int64(0,17196)),new T.ptr(new $Int64(0,36721),new $Int64(0,33199)),new T.ptr(new $Int64(0,36739),new $Int64(0,9757)),new T.ptr(new $Int64(0,36749),new $Int64(0,28590)),new T.ptr(new $Int64(0,36761),new $Int64(0,35610)),new T.ptr(new $Int64(0,36767),new $Int64(0,2711)),new T.ptr(new $Int64(0,36779),new $Int64(0,25775)),new T.ptr(new $Int64(0,36781),new $Int64(0,2039)),new T.ptr(new $Int64(0,36787),new $Int64(0,24830)),new T.ptr(new $Int64(0,36791),new $Int64(0,2110)),new T.ptr(new $Int64(0,36793),new $Int64(0,7101)),new T.ptr(new $Int64(0,36809),new $Int64(0,3319)),new T.ptr(new $Int64(0,36821),new $Int64(0,14977)),new T.ptr(new $Int64(0,36833),new $Int64(0,3748)),new T.ptr(new $Int64(0,36847),new $Int64(0,22349)),new T.ptr(new $Int64(0,36857),new $Int64(0,10680)),new T.ptr(new $Int64(0,36871),new $Int64(0,15424)),new T.ptr(new $Int64(0,36877),new $Int64(0,7143)),new T.ptr(new $Int64(0,36887),new $Int64(0,15470)),new T.ptr(new $Int64(0,36899),new $Int64(0,29361)),new T.ptr(new $Int64(0,36901),new $Int64(0,866)),new T.ptr(new $Int64(0,36913),new $Int64(0,5981)),new T.ptr(new $Int64(0,36919),new $Int64(0,2078)),new T.ptr(new $Int64(0,36923),new $Int64(0,16197)),new T.ptr(new $Int64(0,36929),new $Int64(0,15578)),new T.ptr(new $Int64(0,36931),new $Int64(0,32033)),new T.ptr(new $Int64(0,36943),new $Int64(0,8191)),new T.ptr(new $Int64(0,36947),new $Int64(0,16178)),new T.ptr(new $Int64(0,36973),new $Int64(0,35004)),new T.ptr(new $Int64(0,36979),new $Int64(0,10929)),new T.ptr(new $Int64(0,36997),new $Int64(0,3692)),new T.ptr(new $Int64(0,37003),new $Int64(0,21050)),new T.ptr(new $Int64(0,37013),new $Int64(0,34327)),new T.ptr(new $Int64(0,37019),new $Int64(0,30455)),new T.ptr(new $Int64(0,37021),new $Int64(0,18954)),new T.ptr(new $Int64(0,37039),new $Int64(0,6636)),new T.ptr(new $Int64(0,37049),new $Int64(0,4451)),new T.ptr(new $Int64(0,37057),new $Int64(0,36146)),new T.ptr(new $Int64(0,37061),new $Int64(0,9484)),new T.ptr(new $Int64(0,37087),new $Int64(0,36166)),new T.ptr(new $Int64(0,37097),new $Int64(0,25870)),new T.ptr(new $Int64(0,37117),new $Int64(0,10675)),new T.ptr(new $Int64(0,37123),new $Int64(0,19709)),new T.ptr(new $Int64(0,37139),new $Int64(0,798)),new T.ptr(new $Int64(0,37159),new $Int64(0,12597)),new T.ptr(new $Int64(0,37171),new $Int64(0,11112)),new T.ptr(new $Int64(0,37181),new $Int64(0,4426)),new T.ptr(new $Int64(0,37189),new $Int64(0,18988)),new T.ptr(new $Int64(0,37199),new $Int64(0,29321)),new T.ptr(new $Int64(0,37201),new $Int64(0,6875)),new T.ptr(new $Int64(0,37217),new $Int64(0,18369)),new T.ptr(new $Int64(0,37223),new $Int64(0,2700)),new T.ptr(new $Int64(0,37243),new $Int64(0,8797)),new T.ptr(new $Int64(0,37253),new $Int64(0,28930)),new T.ptr(new $Int64(0,37273),new $Int64(0,31099)),new T.ptr(new $Int64(0,37277),new $Int64(0,17449)),new T.ptr(new $Int64(0,37307),new $Int64(0,26473)),new T.ptr(new $Int64(0,37309),new $Int64(0,12154)),new T.ptr(new $Int64(0,37313),new $Int64(0,8009)),new T.ptr(new $Int64(0,37321),new $Int64(0,7531)),new T.ptr(new $Int64(0,37337),new $Int64(0,9439)),new T.ptr(new $Int64(0,37339),new $Int64(0,11110)),new T.ptr(new $Int64(0,37357),new $Int64(0,8990)),new T.ptr(new $Int64(0,37361),new $Int64(0,26711)),new T.ptr(new $Int64(0,37363),new $Int64(0,10505)),new T.ptr(new $Int64(0,37369),new $Int64(0,9467)),new T.ptr(new $Int64(0,37379),new $Int64(0,31498)),new T.ptr(new $Int64(0,37397),new $Int64(0,35251)),new T.ptr(new $Int64(0,37409),new $Int64(0,5877)),new T.ptr(new $Int64(0,37423),new $Int64(0,12522)),new T.ptr(new $Int64(0,37441),new $Int64(0,28202)),new T.ptr(new $Int64(0,37447),new $Int64(0,8198)),new T.ptr(new $Int64(0,37463),new $Int64(0,36363)),new T.ptr(new $Int64(0,37483),new $Int64(0,23083)),new T.ptr(new $Int64(0,37489),new $Int64(0,36088)),new T.ptr(new $Int64(0,37493),new $Int64(0,35334)),new T.ptr(new $Int64(0,37501),new $Int64(0,20998)),new T.ptr(new $Int64(0,37507),new $Int64(0,36969)),new T.ptr(new $Int64(0,37511),new $Int64(0,21675)),new T.ptr(new $Int64(0,37517),new $Int64(0,25507)),new T.ptr(new $Int64(0,37529),new $Int64(0,16281)),new T.ptr(new $Int64(0,37537),new $Int64(0,14077)),new T.ptr(new $Int64(0,37547),new $Int64(0,25443)),new T.ptr(new $Int64(0,37549),new $Int64(0,11632)),new T.ptr(new $Int64(0,37561),new $Int64(0,7692)),new T.ptr(new $Int64(0,37567),new $Int64(0,23161)),new T.ptr(new $Int64(0,37571),new $Int64(0,30211)),new T.ptr(new $Int64(0,37573),new $Int64(0,26526)),new T.ptr(new $Int64(0,37579),new $Int64(0,17601)),new T.ptr(new $Int64(0,37589),new $Int64(0,22672)),new T.ptr(new $Int64(0,37591),new $Int64(0,9266)),new T.ptr(new $Int64(0,37607),new $Int64(0,20393)),new T.ptr(new $Int64(0,37619),new $Int64(0,20050)),new T.ptr(new $Int64(0,37633),new $Int64(0,18053)),new T.ptr(new $Int64(0,37643),new $Int64(0,31555)),new T.ptr(new $Int64(0,37649),new $Int64(0,23404)),new T.ptr(new $Int64(0,37657),new $Int64(0,30035)),new T.ptr(new $Int64(0,37663),new $Int64(0,19563)),new T.ptr(new $Int64(0,37691),new $Int64(0,32642)),new T.ptr(new $Int64(0,37693),new $Int64(0,27891)),new T.ptr(new $Int64(0,37699),new $Int64(0,21461)),new T.ptr(new $Int64(0,37717),new $Int64(0,22076)),new T.ptr(new $Int64(0,37747),new $Int64(0,34943)),new T.ptr(new $Int64(0,37781),new $Int64(0,29257)),new T.ptr(new $Int64(0,37783),new $Int64(0,20267)),new T.ptr(new $Int64(0,37799),new $Int64(0,36742)),new T.ptr(new $Int64(0,37811),new $Int64(0,10913)),new T.ptr(new $Int64(0,37813),new $Int64(0,33155)),new T.ptr(new $Int64(0,37831),new $Int64(0,26899)),new T.ptr(new $Int64(0,37847),new $Int64(0,31450)),new T.ptr(new $Int64(0,37853),new $Int64(0,8106)),new T.ptr(new $Int64(0,37861),new $Int64(0,7205)),new T.ptr(new $Int64(0,37871),new $Int64(0,26196)),new T.ptr(new $Int64(0,37879),new $Int64(0,24534)),new T.ptr(new $Int64(0,37889),new $Int64(0,4022)),new T.ptr(new $Int64(0,37897),new $Int64(0,30340)),new T.ptr(new $Int64(0,37907),new $Int64(0,17280)),new T.ptr(new $Int64(0,37951),new $Int64(0,10113)),new T.ptr(new $Int64(0,37957),new $Int64(0,25250)),new T.ptr(new $Int64(0,37963),new $Int64(0,25199)),new T.ptr(new $Int64(0,37967),new $Int64(0,36746)),new T.ptr(new $Int64(0,37987),new $Int64(0,36038)),new T.ptr(new $Int64(0,37991),new $Int64(0,36792)),new T.ptr(new $Int64(0,37993),new $Int64(0,17125)),new T.ptr(new $Int64(0,37997),new $Int64(0,29857)),new T.ptr(new $Int64(0,38011),new $Int64(0,8705)),new T.ptr(new $Int64(0,38039),new $Int64(0,25993)),new T.ptr(new $Int64(0,38047),new $Int64(0,32199)),new T.ptr(new $Int64(0,38053),new $Int64(0,22113)),new T.ptr(new $Int64(0,38069),new $Int64(0,33382)),new T.ptr(new $Int64(0,38083),new $Int64(0,19648)),new T.ptr(new $Int64(0,38113),new $Int64(0,11544)),new T.ptr(new $Int64(0,38119),new $Int64(0,34362)),new T.ptr(new $Int64(0,38149),new $Int64(0,8426)),new T.ptr(new $Int64(0,38153),new $Int64(0,1786)),new T.ptr(new $Int64(0,38167),new $Int64(0,3437)),new T.ptr(new $Int64(0,38177),new $Int64(0,3511)),new T.ptr(new $Int64(0,38183),new $Int64(0,31569)),new T.ptr(new $Int64(0,38189),new $Int64(0,25590)),new T.ptr(new $Int64(0,38197),new $Int64(0,35102)),new T.ptr(new $Int64(0,38201),new $Int64(0,12886)),new T.ptr(new $Int64(0,38219),new $Int64(0,5212)),new T.ptr(new $Int64(0,38231),new $Int64(0,7425)),new T.ptr(new $Int64(0,38237),new $Int64(0,23208)),new T.ptr(new $Int64(0,38239),new $Int64(0,35769)),new T.ptr(new $Int64(0,38261),new $Int64(0,19385)),new T.ptr(new $Int64(0,38273),new $Int64(0,20909)),new T.ptr(new $Int64(0,38281),new $Int64(0,36598)),new T.ptr(new $Int64(0,38287),new $Int64(0,5169)),new T.ptr(new $Int64(0,38299),new $Int64(0,34046)),new T.ptr(new $Int64(0,38303),new $Int64(0,21375)),new T.ptr(new $Int64(0,38317),new $Int64(0,37509)),new T.ptr(new $Int64(0,38321),new $Int64(0,28163)),new T.ptr(new $Int64(0,38327),new $Int64(0,37171)),new T.ptr(new $Int64(0,38329),new $Int64(0,24567)),new T.ptr(new $Int64(0,38333),new $Int64(0,33445)),new T.ptr(new $Int64(0,38351),new $Int64(0,21624)),new T.ptr(new $Int64(0,38371),new $Int64(0,15189)),new T.ptr(new $Int64(0,38377),new $Int64(0,38277)),new T.ptr(new $Int64(0,38393),new $Int64(0,16372)),new T.ptr(new $Int64(0,38431),new $Int64(0,18073)),new T.ptr(new $Int64(0,38447),new $Int64(0,14127)),new T.ptr(new $Int64(0,38449),new $Int64(0,25681)),new T.ptr(new $Int64(0,38453),new $Int64(0,26443)),new T.ptr(new $Int64(0,38459),new $Int64(0,4630)),new T.ptr(new $Int64(0,38461),new $Int64(0,9394)),new T.ptr(new $Int64(0,38501),new $Int64(0,23199)),new T.ptr(new $Int64(0,38543),new $Int64(0,678)),new T.ptr(new $Int64(0,38557),new $Int64(0,12861)),new T.ptr(new $Int64(0,38561),new $Int64(0,31113)),new T.ptr(new $Int64(0,38567),new $Int64(0,5926)),new T.ptr(new $Int64(0,38569),new $Int64(0,22409)),new T.ptr(new $Int64(0,38593),new $Int64(0,13540)),new T.ptr(new $Int64(0,38603),new $Int64(0,197)),new T.ptr(new $Int64(0,38609),new $Int64(0,4137)),new T.ptr(new $Int64(0,38611),new $Int64(0,26200)),new T.ptr(new $Int64(0,38629),new $Int64(0,13433)),new T.ptr(new $Int64(0,38639),new $Int64(0,7566)),new T.ptr(new $Int64(0,38651),new $Int64(0,7912)),new T.ptr(new $Int64(0,38653),new $Int64(0,24431)),new T.ptr(new $Int64(0,38669),new $Int64(0,32981)),new T.ptr(new $Int64(0,38671),new $Int64(0,24792)),new T.ptr(new $Int64(0,38677),new $Int64(0,35234)),new T.ptr(new $Int64(0,38693),new $Int64(0,20462)),new T.ptr(new $Int64(0,38699),new $Int64(0,30484)),new T.ptr(new $Int64(0,38707),new $Int64(0,12128)),new T.ptr(new $Int64(0,38711),new $Int64(0,37876)),new T.ptr(new $Int64(0,38713),new $Int64(0,26538)),new T.ptr(new $Int64(0,38723),new $Int64(0,26619)),new T.ptr(new $Int64(0,38729),new $Int64(0,4382)),new T.ptr(new $Int64(0,38737),new $Int64(0,10425)),new T.ptr(new $Int64(0,38747),new $Int64(0,17121)),new T.ptr(new $Int64(0,38749),new $Int64(0,12236)),new T.ptr(new $Int64(0,38767),new $Int64(0,9339)),new T.ptr(new $Int64(0,38783),new $Int64(0,32530)),new T.ptr(new $Int64(0,38791),new $Int64(0,21730)),new T.ptr(new $Int64(0,38803),new $Int64(0,5134)),new T.ptr(new $Int64(0,38821),new $Int64(0,11072)),new T.ptr(new $Int64(0,38833),new $Int64(0,28366)),new T.ptr(new $Int64(0,38839),new $Int64(0,27833)),new T.ptr(new $Int64(0,38851),new $Int64(0,8354)),new T.ptr(new $Int64(0,38861),new $Int64(0,31258)),new T.ptr(new $Int64(0,38867),new $Int64(0,36161)),new T.ptr(new $Int64(0,38873),new $Int64(0,7839)),new T.ptr(new $Int64(0,38891),new $Int64(0,5630)),new T.ptr(new $Int64(0,38903),new $Int64(0,31387)),new T.ptr(new $Int64(0,38917),new $Int64(0,8860)),new T.ptr(new $Int64(0,38921),new $Int64(0,1542)),new T.ptr(new $Int64(0,38923),new $Int64(0,19537)),new T.ptr(new $Int64(0,38933),new $Int64(0,25334)),new T.ptr(new $Int64(0,38953),new $Int64(0,16974)),new T.ptr(new $Int64(0,38959),new $Int64(0,10872)),new T.ptr(new $Int64(0,38971),new $Int64(0,24887)),new T.ptr(new $Int64(0,38977),new $Int64(0,25948)),new T.ptr(new $Int64(0,38993),new $Int64(0,2098)),new T.ptr(new $Int64(0,39019),new $Int64(0,23070)),new T.ptr(new $Int64(0,39023),new $Int64(0,11524)),new T.ptr(new $Int64(0,39041),new $Int64(0,6344)),new T.ptr(new $Int64(0,39043),new $Int64(0,27086)),new T.ptr(new $Int64(0,39047),new $Int64(0,16961)),new T.ptr(new $Int64(0,39079),new $Int64(0,18245)),new T.ptr(new $Int64(0,39089),new $Int64(0,29649)),new T.ptr(new $Int64(0,39097),new $Int64(0,10600)),new T.ptr(new $Int64(0,39103),new $Int64(0,779)),new T.ptr(new $Int64(0,39107),new $Int64(0,35642)),new T.ptr(new $Int64(0,39113),new $Int64(0,15077)),new T.ptr(new $Int64(0,39119),new $Int64(0,2775)),new T.ptr(new $Int64(0,39133),new $Int64(0,29152)),new T.ptr(new $Int64(0,39139),new $Int64(0,3591)),new T.ptr(new $Int64(0,39157),new $Int64(0,19985)),new T.ptr(new $Int64(0,39161),new $Int64(0,12623)),new T.ptr(new $Int64(0,39163),new $Int64(0,31512)),new T.ptr(new $Int64(0,39181),new $Int64(0,9609)),new T.ptr(new $Int64(0,39191),new $Int64(0,19357)),new T.ptr(new $Int64(0,39199),new $Int64(0,14620)),new T.ptr(new $Int64(0,39209),new $Int64(0,27429)),new T.ptr(new $Int64(0,39217),new $Int64(0,29242)),new T.ptr(new $Int64(0,39227),new $Int64(0,13140)),new T.ptr(new $Int64(0,39229),new $Int64(0,37665)),new T.ptr(new $Int64(0,39233),new $Int64(0,10420)),new T.ptr(new $Int64(0,39239),new $Int64(0,24853)),new T.ptr(new $Int64(0,39241),new $Int64(0,33282)),new T.ptr(new $Int64(0,39251),new $Int64(0,29915)),new T.ptr(new $Int64(0,39293),new $Int64(0,22899)),new T.ptr(new $Int64(0,39301),new $Int64(0,9874)),new T.ptr(new $Int64(0,39313),new $Int64(0,18584)),new T.ptr(new $Int64(0,39317),new $Int64(0,29166)),new T.ptr(new $Int64(0,39323),new $Int64(0,38738)),new T.ptr(new $Int64(0,39341),new $Int64(0,11050)),new T.ptr(new $Int64(0,39343),new $Int64(0,19060)),new T.ptr(new $Int64(0,39359),new $Int64(0,944)),new T.ptr(new $Int64(0,39367),new $Int64(0,22501)),new T.ptr(new $Int64(0,39371),new $Int64(0,9318)),new T.ptr(new $Int64(0,39373),new $Int64(0,15092)),new T.ptr(new $Int64(0,39383),new $Int64(0,11709)),new T.ptr(new $Int64(0,39397),new $Int64(0,37661)),new T.ptr(new $Int64(0,39409),new $Int64(0,19590)),new T.ptr(new $Int64(0,39419),new $Int64(0,37155)),new T.ptr(new $Int64(0,39439),new $Int64(0,6081)),new T.ptr(new $Int64(0,39443),new $Int64(0,21164)),new T.ptr(new $Int64(0,39451),new $Int64(0,38357)),new T.ptr(new $Int64(0,39461),new $Int64(0,13449)),new T.ptr(new $Int64(0,39499),new $Int64(0,28523)),new T.ptr(new $Int64(0,39503),new $Int64(0,13560)),new T.ptr(new $Int64(0,39509),new $Int64(0,30382)),new T.ptr(new $Int64(0,39511),new $Int64(0,15660)),new T.ptr(new $Int64(0,39521),new $Int64(0,8554)),new T.ptr(new $Int64(0,39541),new $Int64(0,15267)),new T.ptr(new $Int64(0,39551),new $Int64(0,11593)),new T.ptr(new $Int64(0,39563),new $Int64(0,39093)),new T.ptr(new $Int64(0,39569),new $Int64(0,15822)),new T.ptr(new $Int64(0,39581),new $Int64(0,17879)),new T.ptr(new $Int64(0,39607),new $Int64(0,3171)),new T.ptr(new $Int64(0,39619),new $Int64(0,9097)),new T.ptr(new $Int64(0,39623),new $Int64(0,1647)),new T.ptr(new $Int64(0,39631),new $Int64(0,7235)),new T.ptr(new $Int64(0,39659),new $Int64(0,23039)),new T.ptr(new $Int64(0,39667),new $Int64(0,17937)),new T.ptr(new $Int64(0,39671),new $Int64(0,24548)),new T.ptr(new $Int64(0,39679),new $Int64(0,33707)),new T.ptr(new $Int64(0,39703),new $Int64(0,4202)),new T.ptr(new $Int64(0,39709),new $Int64(0,25273)),new T.ptr(new $Int64(0,39719),new $Int64(0,14642)),new T.ptr(new $Int64(0,39727),new $Int64(0,39177)),new T.ptr(new $Int64(0,39733),new $Int64(0,21700)),new T.ptr(new $Int64(0,39749),new $Int64(0,28184)),new T.ptr(new $Int64(0,39761),new $Int64(0,22707)),new T.ptr(new $Int64(0,39769),new $Int64(0,13452)),new T.ptr(new $Int64(0,39779),new $Int64(0,18340)),new T.ptr(new $Int64(0,39791),new $Int64(0,16513)),new T.ptr(new $Int64(0,39799),new $Int64(0,22239)),new T.ptr(new $Int64(0,39821),new $Int64(0,22244)),new T.ptr(new $Int64(0,39827),new $Int64(0,23248)),new T.ptr(new $Int64(0,39829),new $Int64(0,2391)),new T.ptr(new $Int64(0,39839),new $Int64(0,16517)),new T.ptr(new $Int64(0,39841),new $Int64(0,37572)),new T.ptr(new $Int64(0,39847),new $Int64(0,14177)),new T.ptr(new $Int64(0,39857),new $Int64(0,20110)),new T.ptr(new $Int64(0,39863),new $Int64(0,38812)),new T.ptr(new $Int64(0,39869),new $Int64(0,3575)),new T.ptr(new $Int64(0,39877),new $Int64(0,8481)),new T.ptr(new $Int64(0,39883),new $Int64(0,21254)),new T.ptr(new $Int64(0,39887),new $Int64(0,869)),new T.ptr(new $Int64(0,39901),new $Int64(0,18276)),new T.ptr(new $Int64(0,39929),new $Int64(0,5156)),new T.ptr(new $Int64(0,39937),new $Int64(0,32053)),new T.ptr(new $Int64(0,39953),new $Int64(0,1990)),new T.ptr(new $Int64(0,39971),new $Int64(0,5986)),new T.ptr(new $Int64(0,39979),new $Int64(0,33862)),new T.ptr(new $Int64(0,39983),new $Int64(0,37411)),new T.ptr(new $Int64(0,39989),new $Int64(0,29273)),new T.ptr(new $Int64(0,40009),new $Int64(0,18929)),new T.ptr(new $Int64(0,40013),new $Int64(0,494)),new T.ptr(new $Int64(0,40031),new $Int64(0,28170)),new T.ptr(new $Int64(0,40037),new $Int64(0,31140)),new T.ptr(new $Int64(0,40039),new $Int64(0,26693)),new T.ptr(new $Int64(0,40063),new $Int64(0,35418)),new T.ptr(new $Int64(0,40087),new $Int64(0,23313)),new T.ptr(new $Int64(0,40093),new $Int64(0,17651)),new T.ptr(new $Int64(0,40099),new $Int64(0,16538)),new T.ptr(new $Int64(0,40111),new $Int64(0,23351)),new T.ptr(new $Int64(0,40123),new $Int64(0,3545)),new T.ptr(new $Int64(0,40127),new $Int64(0,11377)),new T.ptr(new $Int64(0,40129),new $Int64(0,25400)),new T.ptr(new $Int64(0,40151),new $Int64(0,8199)),new T.ptr(new $Int64(0,40153),new $Int64(0,27124)),new T.ptr(new $Int64(0,40163),new $Int64(0,32544)),new T.ptr(new $Int64(0,40169),new $Int64(0,35083)),new T.ptr(new $Int64(0,40177),new $Int64(0,11535)),new T.ptr(new $Int64(0,40189),new $Int64(0,9800)),new T.ptr(new $Int64(0,40193),new $Int64(0,12522)),new T.ptr(new $Int64(0,40213),new $Int64(0,27506)),new T.ptr(new $Int64(0,40231),new $Int64(0,28927)),new T.ptr(new $Int64(0,40237),new $Int64(0,13140)),new T.ptr(new $Int64(0,40241),new $Int64(0,36971)),new T.ptr(new $Int64(0,40253),new $Int64(0,30174)),new T.ptr(new $Int64(0,40277),new $Int64(0,22716)),new T.ptr(new $Int64(0,40283),new $Int64(0,29784)),new T.ptr(new $Int64(0,40289),new $Int64(0,36999)),new T.ptr(new $Int64(0,40343),new $Int64(0,29647)),new T.ptr(new $Int64(0,40351),new $Int64(0,24176)),new T.ptr(new $Int64(0,40357),new $Int64(0,2334)),new T.ptr(new $Int64(0,40361),new $Int64(0,38936)),new T.ptr(new $Int64(0,40387),new $Int64(0,27623)),new T.ptr(new $Int64(0,40423),new $Int64(0,36342)),new T.ptr(new $Int64(0,40427),new $Int64(0,29737)),new T.ptr(new $Int64(0,40429),new $Int64(0,29447)),new T.ptr(new $Int64(0,40433),new $Int64(0,10254)),new T.ptr(new $Int64(0,40459),new $Int64(0,33056)),new T.ptr(new $Int64(0,40471),new $Int64(0,313)),new T.ptr(new $Int64(0,40483),new $Int64(0,16114)),new T.ptr(new $Int64(0,40487),new $Int64(0,12288)),new T.ptr(new $Int64(0,40493),new $Int64(0,35815)),new T.ptr(new $Int64(0,40499),new $Int64(0,35705)),new T.ptr(new $Int64(0,40507),new $Int64(0,30214)),new T.ptr(new $Int64(0,40519),new $Int64(0,12886)),new T.ptr(new $Int64(0,40529),new $Int64(0,1630)),new T.ptr(new $Int64(0,40531),new $Int64(0,35358)),new T.ptr(new $Int64(0,40543),new $Int64(0,38313)),new T.ptr(new $Int64(0,40559),new $Int64(0,4741)),new T.ptr(new $Int64(0,40577),new $Int64(0,40174)),new T.ptr(new $Int64(0,40583),new $Int64(0,15147)),new T.ptr(new $Int64(0,40591),new $Int64(0,6802)),new T.ptr(new $Int64(0,40597),new $Int64(0,7823)),new T.ptr(new $Int64(0,40609),new $Int64(0,29071)),new T.ptr(new $Int64(0,40627),new $Int64(0,38989)),new T.ptr(new $Int64(0,40637),new $Int64(0,32378)),new T.ptr(new $Int64(0,40639),new $Int64(0,22140)),new T.ptr(new $Int64(0,40693),new $Int64(0,33485)),new T.ptr(new $Int64(0,40697),new $Int64(0,1466)),new T.ptr(new $Int64(0,40699),new $Int64(0,20648)),new T.ptr(new $Int64(0,40709),new $Int64(0,3935)),new T.ptr(new $Int64(0,40739),new $Int64(0,2137)),new T.ptr(new $Int64(0,40751),new $Int64(0,12189)),new T.ptr(new $Int64(0,40759),new $Int64(0,35846)),new T.ptr(new $Int64(0,40763),new $Int64(0,24112)),new T.ptr(new $Int64(0,40771),new $Int64(0,34264)),new T.ptr(new $Int64(0,40787),new $Int64(0,30613)),new T.ptr(new $Int64(0,40801),new $Int64(0,3342)),new T.ptr(new $Int64(0,40813),new $Int64(0,34970)),new T.ptr(new $Int64(0,40819),new $Int64(0,31719)),new T.ptr(new $Int64(0,40823),new $Int64(0,2798)),new T.ptr(new $Int64(0,40829),new $Int64(0,23321)),new T.ptr(new $Int64(0,40841),new $Int64(0,28587)),new T.ptr(new $Int64(0,40847),new $Int64(0,2767)),new T.ptr(new $Int64(0,40849),new $Int64(0,32181)),new T.ptr(new $Int64(0,40853),new $Int64(0,40786)),new T.ptr(new $Int64(0,40867),new $Int64(0,9702)),new T.ptr(new $Int64(0,40879),new $Int64(0,22965)),new T.ptr(new $Int64(0,40883),new $Int64(0,38151)),new T.ptr(new $Int64(0,40897),new $Int64(0,17625)),new T.ptr(new $Int64(0,40903),new $Int64(0,23003)),new T.ptr(new $Int64(0,40927),new $Int64(0,32960)),new T.ptr(new $Int64(0,40933),new $Int64(0,7716)),new T.ptr(new $Int64(0,40939),new $Int64(0,13449)),new T.ptr(new $Int64(0,40949),new $Int64(0,931)),new T.ptr(new $Int64(0,40961),new $Int64(0,10748)),new T.ptr(new $Int64(0,40973),new $Int64(0,17288)),new T.ptr(new $Int64(0,40993),new $Int64(0,40018)),new T.ptr(new $Int64(0,41011),new $Int64(0,12178)),new T.ptr(new $Int64(0,41017),new $Int64(0,12063)),new T.ptr(new $Int64(0,41023),new $Int64(0,24177)),new T.ptr(new $Int64(0,41039),new $Int64(0,7011)),new T.ptr(new $Int64(0,41047),new $Int64(0,35517)),new T.ptr(new $Int64(0,41051),new $Int64(0,3113)),new T.ptr(new $Int64(0,41057),new $Int64(0,1561)),new T.ptr(new $Int64(0,41077),new $Int64(0,2786)),new T.ptr(new $Int64(0,41081),new $Int64(0,18495)),new T.ptr(new $Int64(0,41113),new $Int64(0,4649)),new T.ptr(new $Int64(0,41117),new $Int64(0,16289)),new T.ptr(new $Int64(0,41131),new $Int64(0,4612)),new T.ptr(new $Int64(0,41141),new $Int64(0,3089)),new T.ptr(new $Int64(0,41143),new $Int64(0,32427)),new T.ptr(new $Int64(0,41149),new $Int64(0,38193)),new T.ptr(new $Int64(0,41161),new $Int64(0,33389)),new T.ptr(new $Int64(0,41177),new $Int64(0,21681)),new T.ptr(new $Int64(0,41179),new $Int64(0,22825)),new T.ptr(new $Int64(0,41183),new $Int64(0,1177)),new T.ptr(new $Int64(0,41189),new $Int64(0,7767)),new T.ptr(new $Int64(0,41201),new $Int64(0,14680)),new T.ptr(new $Int64(0,41203),new $Int64(0,22863)),new T.ptr(new $Int64(0,41213),new $Int64(0,16607)),new T.ptr(new $Int64(0,41221),new $Int64(0,10727)),new T.ptr(new $Int64(0,41227),new $Int64(0,18107)),new T.ptr(new $Int64(0,41231),new $Int64(0,38900)),new T.ptr(new $Int64(0,41233),new $Int64(0,13560)),new T.ptr(new $Int64(0,41243),new $Int64(0,26044)),new T.ptr(new $Int64(0,41257),new $Int64(0,5910)),new T.ptr(new $Int64(0,41263),new $Int64(0,14013)),new T.ptr(new $Int64(0,41269),new $Int64(0,10723)),new T.ptr(new $Int64(0,41281),new $Int64(0,9691)),new T.ptr(new $Int64(0,41299),new $Int64(0,26811)),new T.ptr(new $Int64(0,41333),new $Int64(0,36847)),new T.ptr(new $Int64(0,41341),new $Int64(0,805)),new T.ptr(new $Int64(0,41351),new $Int64(0,9105)),new T.ptr(new $Int64(0,41357),new $Int64(0,26713)),new T.ptr(new $Int64(0,41381),new $Int64(0,22578)),new T.ptr(new $Int64(0,41387),new $Int64(0,33296)),new T.ptr(new $Int64(0,41389),new $Int64(0,12160)),new T.ptr(new $Int64(0,41399),new $Int64(0,30605)),new T.ptr(new $Int64(0,41411),new $Int64(0,19895)),new T.ptr(new $Int64(0,41413),new $Int64(0,38256)),new T.ptr(new $Int64(0,41443),new $Int64(0,23700)),new T.ptr(new $Int64(0,41453),new $Int64(0,31322)),new T.ptr(new $Int64(0,41467),new $Int64(0,13987)),new T.ptr(new $Int64(0,41479),new $Int64(0,19697)),new T.ptr(new $Int64(0,41491),new $Int64(0,6186)),new T.ptr(new $Int64(0,41507),new $Int64(0,19004)),new T.ptr(new $Int64(0,41513),new $Int64(0,7459)),new T.ptr(new $Int64(0,41519),new $Int64(0,21859)),new T.ptr(new $Int64(0,41521),new $Int64(0,18541)),new T.ptr(new $Int64(0,41539),new $Int64(0,7131)),new T.ptr(new $Int64(0,41543),new $Int64(0,7039)),new T.ptr(new $Int64(0,41549),new $Int64(0,22321)),new T.ptr(new $Int64(0,41579),new $Int64(0,30385)),new T.ptr(new $Int64(0,41593),new $Int64(0,15382)),new T.ptr(new $Int64(0,41597),new $Int64(0,33974)),new T.ptr(new $Int64(0,41603),new $Int64(0,7444)),new T.ptr(new $Int64(0,41609),new $Int64(0,35925)),new T.ptr(new $Int64(0,41611),new $Int64(0,12855)),new T.ptr(new $Int64(0,41617),new $Int64(0,8955)),new T.ptr(new $Int64(0,41621),new $Int64(0,8863)),new T.ptr(new $Int64(0,41627),new $Int64(0,26877)),new T.ptr(new $Int64(0,41641),new $Int64(0,3702)),new T.ptr(new $Int64(0,41647),new $Int64(0,8535)),new T.ptr(new $Int64(0,41651),new $Int64(0,4490)),new T.ptr(new $Int64(0,41659),new $Int64(0,9066)),new T.ptr(new $Int64(0,41669),new $Int64(0,9814)),new T.ptr(new $Int64(0,41681),new $Int64(0,34713)),new T.ptr(new $Int64(0,41687),new $Int64(0,37806)),new T.ptr(new $Int64(0,41719),new $Int64(0,19936)),new T.ptr(new $Int64(0,41729),new $Int64(0,32110)),new T.ptr(new $Int64(0,41737),new $Int64(0,13609)),new T.ptr(new $Int64(0,41759),new $Int64(0,24989)),new T.ptr(new $Int64(0,41761),new $Int64(0,7676)),new T.ptr(new $Int64(0,41771),new $Int64(0,13433)),new T.ptr(new $Int64(0,41777),new $Int64(0,32389)),new T.ptr(new $Int64(0,41801),new $Int64(0,22661)),new T.ptr(new $Int64(0,41809),new $Int64(0,26171)),new T.ptr(new $Int64(0,41813),new $Int64(0,23198)),new T.ptr(new $Int64(0,41843),new $Int64(0,30394)),new T.ptr(new $Int64(0,41849),new $Int64(0,5822)),new T.ptr(new $Int64(0,41851),new $Int64(0,25012)),new T.ptr(new $Int64(0,41863),new $Int64(0,34040)),new T.ptr(new $Int64(0,41879),new $Int64(0,41712)),new T.ptr(new $Int64(0,41887),new $Int64(0,35658)),new T.ptr(new $Int64(0,41893),new $Int64(0,36565)),new T.ptr(new $Int64(0,41897),new $Int64(0,21223)),new T.ptr(new $Int64(0,41903),new $Int64(0,10114)),new T.ptr(new $Int64(0,41911),new $Int64(0,9326)),new T.ptr(new $Int64(0,41927),new $Int64(0,12013)),new T.ptr(new $Int64(0,41941),new $Int64(0,32660)),new T.ptr(new $Int64(0,41947),new $Int64(0,37951)),new T.ptr(new $Int64(0,41953),new $Int64(0,20293)),new T.ptr(new $Int64(0,41957),new $Int64(0,28358)),new T.ptr(new $Int64(0,41959),new $Int64(0,1188)),new T.ptr(new $Int64(0,41969),new $Int64(0,33259)),new T.ptr(new $Int64(0,41981),new $Int64(0,34858)),new T.ptr(new $Int64(0,41983),new $Int64(0,29566)),new T.ptr(new $Int64(0,41999),new $Int64(0,20853)),new T.ptr(new $Int64(0,42013),new $Int64(0,39188)),new T.ptr(new $Int64(0,42017),new $Int64(0,2437)),new T.ptr(new $Int64(0,42019),new $Int64(0,9774)),new T.ptr(new $Int64(0,42023),new $Int64(0,38816)),new T.ptr(new $Int64(0,42043),new $Int64(0,18919)),new T.ptr(new $Int64(0,42061),new $Int64(0,7416)),new T.ptr(new $Int64(0,42071),new $Int64(0,7036)),new T.ptr(new $Int64(0,42073),new $Int64(0,27076)),new T.ptr(new $Int64(0,42083),new $Int64(0,23043)),new T.ptr(new $Int64(0,42089),new $Int64(0,15358)),new T.ptr(new $Int64(0,42101),new $Int64(0,16662)),new T.ptr(new $Int64(0,42131),new $Int64(0,25965)),new T.ptr(new $Int64(0,42139),new $Int64(0,27651)),new T.ptr(new $Int64(0,42157),new $Int64(0,17431)),new T.ptr(new $Int64(0,42169),new $Int64(0,1710)),new T.ptr(new $Int64(0,42179),new $Int64(0,2971)),new T.ptr(new $Int64(0,42181),new $Int64(0,36218)),new T.ptr(new $Int64(0,42187),new $Int64(0,8161)),new T.ptr(new $Int64(0,42193),new $Int64(0,18428)),new T.ptr(new $Int64(0,42197),new $Int64(0,35813)),new T.ptr(new $Int64(0,42209),new $Int64(0,27082)),new T.ptr(new $Int64(0,42221),new $Int64(0,12112)),new T.ptr(new $Int64(0,42223),new $Int64(0,38129)),new T.ptr(new $Int64(0,42227),new $Int64(0,5033)),new T.ptr(new $Int64(0,42239),new $Int64(0,4642)),new T.ptr(new $Int64(0,42257),new $Int64(0,15242)),new T.ptr(new $Int64(0,42281),new $Int64(0,15276)),new T.ptr(new $Int64(0,42283),new $Int64(0,23589)),new T.ptr(new $Int64(0,42293),new $Int64(0,6226)),new T.ptr(new $Int64(0,42299),new $Int64(0,23643)),new T.ptr(new $Int64(0,42307),new $Int64(0,39122)),new T.ptr(new $Int64(0,42323),new $Int64(0,38776)),new T.ptr(new $Int64(0,42331),new $Int64(0,31177)),new T.ptr(new $Int64(0,42337),new $Int64(0,10125)),new T.ptr(new $Int64(0,42349),new $Int64(0,24161)),new T.ptr(new $Int64(0,42359),new $Int64(0,35631)),new T.ptr(new $Int64(0,42373),new $Int64(0,20348)),new T.ptr(new $Int64(0,42379),new $Int64(0,459)),new T.ptr(new $Int64(0,42391),new $Int64(0,34842)),new T.ptr(new $Int64(0,42397),new $Int64(0,33625)),new T.ptr(new $Int64(0,42403),new $Int64(0,11329)),new T.ptr(new $Int64(0,42407),new $Int64(0,12786)),new T.ptr(new $Int64(0,42409),new $Int64(0,364)),new T.ptr(new $Int64(0,42433),new $Int64(0,42102)),new T.ptr(new $Int64(0,42437),new $Int64(0,21009)),new T.ptr(new $Int64(0,42443),new $Int64(0,471)),new T.ptr(new $Int64(0,42451),new $Int64(0,5693)),new T.ptr(new $Int64(0,42457),new $Int64(0,2307)),new T.ptr(new $Int64(0,42461),new $Int64(0,33984)),new T.ptr(new $Int64(0,42463),new $Int64(0,37667)),new T.ptr(new $Int64(0,42467),new $Int64(0,20589)),new T.ptr(new $Int64(0,42473),new $Int64(0,33599)),new T.ptr(new $Int64(0,42487),new $Int64(0,37527)),new T.ptr(new $Int64(0,42491),new $Int64(0,31026)),new T.ptr(new $Int64(0,42499),new $Int64(0,9546)),new T.ptr(new $Int64(0,42509),new $Int64(0,22497)),new T.ptr(new $Int64(0,42533),new $Int64(0,27889)),new T.ptr(new $Int64(0,42557),new $Int64(0,31612)),new T.ptr(new $Int64(0,42569),new $Int64(0,32161)),new T.ptr(new $Int64(0,42571),new $Int64(0,39179)),new T.ptr(new $Int64(0,42577),new $Int64(0,10310)),new T.ptr(new $Int64(0,42589),new $Int64(0,12002)),new T.ptr(new $Int64(0,42611),new $Int64(0,29794)),new T.ptr(new $Int64(0,42641),new $Int64(0,22520)),new T.ptr(new $Int64(0,42643),new $Int64(0,41043)),new T.ptr(new $Int64(0,42649),new $Int64(0,15960)),new T.ptr(new $Int64(0,42667),new $Int64(0,41032)),new T.ptr(new $Int64(0,42677),new $Int64(0,19124)),new T.ptr(new $Int64(0,42683),new $Int64(0,16677)),new T.ptr(new $Int64(0,42689),new $Int64(0,25940)),new T.ptr(new $Int64(0,42697),new $Int64(0,38235)),new T.ptr(new $Int64(0,42701),new $Int64(0,20952)),new T.ptr(new $Int64(0,42703),new $Int64(0,23674)),new T.ptr(new $Int64(0,42709),new $Int64(0,31321)),new T.ptr(new $Int64(0,42719),new $Int64(0,26417)),new T.ptr(new $Int64(0,42727),new $Int64(0,2311)),new T.ptr(new $Int64(0,42737),new $Int64(0,14177)),new T.ptr(new $Int64(0,42743),new $Int64(0,3442)),new T.ptr(new $Int64(0,42751),new $Int64(0,8915)),new T.ptr(new $Int64(0,42767),new $Int64(0,5076)),new T.ptr(new $Int64(0,42773),new $Int64(0,26679)),new T.ptr(new $Int64(0,42787),new $Int64(0,8790)),new T.ptr(new $Int64(0,42793),new $Int64(0,9627)),new T.ptr(new $Int64(0,42797),new $Int64(0,8874)),new T.ptr(new $Int64(0,42821),new $Int64(0,32561)),new T.ptr(new $Int64(0,42829),new $Int64(0,12797)),new T.ptr(new $Int64(0,42839),new $Int64(0,10785)),new T.ptr(new $Int64(0,42841),new $Int64(0,20072)),new T.ptr(new $Int64(0,42853),new $Int64(0,6708)),new T.ptr(new $Int64(0,42859),new $Int64(0,41739)),new T.ptr(new $Int64(0,42863),new $Int64(0,35995)),new T.ptr(new $Int64(0,42899),new $Int64(0,9193)),new T.ptr(new $Int64(0,42901),new $Int64(0,3064)),new T.ptr(new $Int64(0,42923),new $Int64(0,12397)),new T.ptr(new $Int64(0,42929),new $Int64(0,25271)),new T.ptr(new $Int64(0,42937),new $Int64(0,746)),new T.ptr(new $Int64(0,42943),new $Int64(0,1070)),new T.ptr(new $Int64(0,42953),new $Int64(0,42432)),new T.ptr(new $Int64(0,42961),new $Int64(0,26008)),new T.ptr(new $Int64(0,42967),new $Int64(0,13055)),new T.ptr(new $Int64(0,42979),new $Int64(0,4158)),new T.ptr(new $Int64(0,42989),new $Int64(0,32328)),new T.ptr(new $Int64(0,43003),new $Int64(0,27943)),new T.ptr(new $Int64(0,43013),new $Int64(0,3453)),new T.ptr(new $Int64(0,43019),new $Int64(0,3331)),new T.ptr(new $Int64(0,43037),new $Int64(0,35924)),new T.ptr(new $Int64(0,43049),new $Int64(0,27922)),new T.ptr(new $Int64(0,43051),new $Int64(0,8655)),new T.ptr(new $Int64(0,43063),new $Int64(0,22626)),new T.ptr(new $Int64(0,43067),new $Int64(0,17481)),new T.ptr(new $Int64(0,43093),new $Int64(0,22631)),new T.ptr(new $Int64(0,43103),new $Int64(0,10662)),new T.ptr(new $Int64(0,43117),new $Int64(0,32430)),new T.ptr(new $Int64(0,43133),new $Int64(0,38624)),new T.ptr(new $Int64(0,43151),new $Int64(0,39332)),new T.ptr(new $Int64(0,43159),new $Int64(0,26531)),new T.ptr(new $Int64(0,43177),new $Int64(0,19384)),new T.ptr(new $Int64(0,43189),new $Int64(0,6821)),new T.ptr(new $Int64(0,43201),new $Int64(0,7207)),new T.ptr(new $Int64(0,43207),new $Int64(0,14466)),new T.ptr(new $Int64(0,43223),new $Int64(0,1883)),new T.ptr(new $Int64(0,43237),new $Int64(0,27337)),new T.ptr(new $Int64(0,43261),new $Int64(0,1361)),new T.ptr(new $Int64(0,43271),new $Int64(0,10522)),new T.ptr(new $Int64(0,43283),new $Int64(0,783)),new T.ptr(new $Int64(0,43291),new $Int64(0,32749)),new T.ptr(new $Int64(0,43313),new $Int64(0,11244)),new T.ptr(new $Int64(0,43319),new $Int64(0,15796)),new T.ptr(new $Int64(0,43321),new $Int64(0,22028)),new T.ptr(new $Int64(0,43331),new $Int64(0,24064)),new T.ptr(new $Int64(0,43391),new $Int64(0,12025)),new T.ptr(new $Int64(0,43397),new $Int64(0,38002)),new T.ptr(new $Int64(0,43399),new $Int64(0,15276)),new T.ptr(new $Int64(0,43403),new $Int64(0,21381)),new T.ptr(new $Int64(0,43411),new $Int64(0,29327)),new T.ptr(new $Int64(0,43427),new $Int64(0,16369)),new T.ptr(new $Int64(0,43441),new $Int64(0,694)),new T.ptr(new $Int64(0,43451),new $Int64(0,12454)),new T.ptr(new $Int64(0,43457),new $Int64(0,32172)),new T.ptr(new $Int64(0,43481),new $Int64(0,19923)),new T.ptr(new $Int64(0,43487),new $Int64(0,22061)),new T.ptr(new $Int64(0,43499),new $Int64(0,4020)),new T.ptr(new $Int64(0,43517),new $Int64(0,31673)),new T.ptr(new $Int64(0,43541),new $Int64(0,6749)),new T.ptr(new $Int64(0,43543),new $Int64(0,40278)),new T.ptr(new $Int64(0,43573),new $Int64(0,7256)),new T.ptr(new $Int64(0,43577),new $Int64(0,41577)),new T.ptr(new $Int64(0,43579),new $Int64(0,37303)),new T.ptr(new $Int64(0,43591),new $Int64(0,9395)),new T.ptr(new $Int64(0,43597),new $Int64(0,17286)),new T.ptr(new $Int64(0,43607),new $Int64(0,30791)),new T.ptr(new $Int64(0,43609),new $Int64(0,27472)),new T.ptr(new $Int64(0,43613),new $Int64(0,4024)),new T.ptr(new $Int64(0,43627),new $Int64(0,17810)),new T.ptr(new $Int64(0,43633),new $Int64(0,19580)),new T.ptr(new $Int64(0,43649),new $Int64(0,43137)),new T.ptr(new $Int64(0,43651),new $Int64(0,36946)),new T.ptr(new $Int64(0,43661),new $Int64(0,8774)),new T.ptr(new $Int64(0,43669),new $Int64(0,29233)),new T.ptr(new $Int64(0,43691),new $Int64(0,26359)),new T.ptr(new $Int64(0,43711),new $Int64(0,40250)),new T.ptr(new $Int64(0,43717),new $Int64(0,13534)),new T.ptr(new $Int64(0,43721),new $Int64(0,20164)),new T.ptr(new $Int64(0,43753),new $Int64(0,20814)),new T.ptr(new $Int64(0,43759),new $Int64(0,9064)),new T.ptr(new $Int64(0,43777),new $Int64(0,40864)),new T.ptr(new $Int64(0,43781),new $Int64(0,2325)),new T.ptr(new $Int64(0,43783),new $Int64(0,9970)),new T.ptr(new $Int64(0,43787),new $Int64(0,40476)),new T.ptr(new $Int64(0,43789),new $Int64(0,30057)),new T.ptr(new $Int64(0,43793),new $Int64(0,32237)),new T.ptr(new $Int64(0,43801),new $Int64(0,15796)),new T.ptr(new $Int64(0,43853),new $Int64(0,16707)),new T.ptr(new $Int64(0,43867),new $Int64(0,14928)),new T.ptr(new $Int64(0,43889),new $Int64(0,27853)),new T.ptr(new $Int64(0,43891),new $Int64(0,34606)),new T.ptr(new $Int64(0,43913),new $Int64(0,257)),new T.ptr(new $Int64(0,43933),new $Int64(0,39355)),new T.ptr(new $Int64(0,43943),new $Int64(0,24698)),new T.ptr(new $Int64(0,43951),new $Int64(0,6443)),new T.ptr(new $Int64(0,43961),new $Int64(0,512)),new T.ptr(new $Int64(0,43963),new $Int64(0,9462)),new T.ptr(new $Int64(0,43969),new $Int64(0,35781)),new T.ptr(new $Int64(0,43973),new $Int64(0,22771)),new T.ptr(new $Int64(0,43987),new $Int64(0,13299)),new T.ptr(new $Int64(0,43991),new $Int64(0,29023)),new T.ptr(new $Int64(0,43997),new $Int64(0,5211)),new T.ptr(new $Int64(0,44017),new $Int64(0,16683)),new T.ptr(new $Int64(0,44021),new $Int64(0,9506)),new T.ptr(new $Int64(0,44027),new $Int64(0,24776)),new T.ptr(new $Int64(0,44029),new $Int64(0,23580)),new T.ptr(new $Int64(0,44041),new $Int64(0,23978)),new T.ptr(new $Int64(0,44053),new $Int64(0,17458)),new T.ptr(new $Int64(0,44059),new $Int64(0,32212)),new T.ptr(new $Int64(0,44071),new $Int64(0,3863)),new T.ptr(new $Int64(0,44087),new $Int64(0,43506)),new T.ptr(new $Int64(0,44089),new $Int64(0,29360)),new T.ptr(new $Int64(0,44101),new $Int64(0,7247)),new T.ptr(new $Int64(0,44111),new $Int64(0,23065)),new T.ptr(new $Int64(0,44119),new $Int64(0,19981)),new T.ptr(new $Int64(0,44123),new $Int64(0,20237)),new T.ptr(new $Int64(0,44129),new $Int64(0,35632)),new T.ptr(new $Int64(0,44131),new $Int64(0,2215)),new T.ptr(new $Int64(0,44159),new $Int64(0,8691)),new T.ptr(new $Int64(0,44171),new $Int64(0,1055)),new T.ptr(new $Int64(0,44179),new $Int64(0,28460)),new T.ptr(new $Int64(0,44189),new $Int64(0,43163)),new T.ptr(new $Int64(0,44201),new $Int64(0,25066)),new T.ptr(new $Int64(0,44203),new $Int64(0,20730)),new T.ptr(new $Int64(0,44207),new $Int64(0,21543)),new T.ptr(new $Int64(0,44221),new $Int64(0,5588)),new T.ptr(new $Int64(0,44249),new $Int64(0,18268)),new T.ptr(new $Int64(0,44257),new $Int64(0,5146)),new T.ptr(new $Int64(0,44263),new $Int64(0,23964)),new T.ptr(new $Int64(0,44267),new $Int64(0,29068)),new T.ptr(new $Int64(0,44269),new $Int64(0,10618)),new T.ptr(new $Int64(0,44273),new $Int64(0,14545)),new T.ptr(new $Int64(0,44279),new $Int64(0,30832)),new T.ptr(new $Int64(0,44281),new $Int64(0,14642)),new T.ptr(new $Int64(0,44293),new $Int64(0,30341)),new T.ptr(new $Int64(0,44351),new $Int64(0,24564)),new T.ptr(new $Int64(0,44357),new $Int64(0,31664)),new T.ptr(new $Int64(0,44371),new $Int64(0,6970)),new T.ptr(new $Int64(0,44381),new $Int64(0,44122)),new T.ptr(new $Int64(0,44383),new $Int64(0,24295)),new T.ptr(new $Int64(0,44389),new $Int64(0,16722)),new T.ptr(new $Int64(0,44417),new $Int64(0,11007)),new T.ptr(new $Int64(0,44449),new $Int64(0,28312)),new T.ptr(new $Int64(0,44453),new $Int64(0,40783)),new T.ptr(new $Int64(0,44483),new $Int64(0,31334)),new T.ptr(new $Int64(0,44491),new $Int64(0,3122)),new T.ptr(new $Int64(0,44497),new $Int64(0,11175)),new T.ptr(new $Int64(0,44501),new $Int64(0,9254)),new T.ptr(new $Int64(0,44507),new $Int64(0,33494)),new T.ptr(new $Int64(0,44519),new $Int64(0,27708)),new T.ptr(new $Int64(0,44531),new $Int64(0,39322)),new T.ptr(new $Int64(0,44533),new $Int64(0,35933)),new T.ptr(new $Int64(0,44537),new $Int64(0,42137)),new T.ptr(new $Int64(0,44543),new $Int64(0,31799)),new T.ptr(new $Int64(0,44549),new $Int64(0,7466)),new T.ptr(new $Int64(0,44563),new $Int64(0,39374)),new T.ptr(new $Int64(0,44579),new $Int64(0,1136)),new T.ptr(new $Int64(0,44587),new $Int64(0,32990)),new T.ptr(new $Int64(0,44617),new $Int64(0,36968)),new T.ptr(new $Int64(0,44621),new $Int64(0,32637)),new T.ptr(new $Int64(0,44623),new $Int64(0,33877)),new T.ptr(new $Int64(0,44633),new $Int64(0,5701)),new T.ptr(new $Int64(0,44641),new $Int64(0,25152)),new T.ptr(new $Int64(0,44647),new $Int64(0,20122)),new T.ptr(new $Int64(0,44651),new $Int64(0,15965)),new T.ptr(new $Int64(0,44657),new $Int64(0,15840)),new T.ptr(new $Int64(0,44683),new $Int64(0,20598)),new T.ptr(new $Int64(0,44687),new $Int64(0,33250)),new T.ptr(new $Int64(0,44699),new $Int64(0,30343)),new T.ptr(new $Int64(0,44701),new $Int64(0,35881)),new T.ptr(new $Int64(0,44711),new $Int64(0,32044)),new T.ptr(new $Int64(0,44729),new $Int64(0,37457)),new T.ptr(new $Int64(0,44741),new $Int64(0,27540)),new T.ptr(new $Int64(0,44753),new $Int64(0,44389)),new T.ptr(new $Int64(0,44771),new $Int64(0,28084)),new T.ptr(new $Int64(0,44773),new $Int64(0,35411)),new T.ptr(new $Int64(0,44777),new $Int64(0,31181)),new T.ptr(new $Int64(0,44789),new $Int64(0,44286)),new T.ptr(new $Int64(0,44797),new $Int64(0,31814)),new T.ptr(new $Int64(0,44809),new $Int64(0,12650)),new T.ptr(new $Int64(0,44819),new $Int64(0,19410)),new T.ptr(new $Int64(0,44839),new $Int64(0,39479)),new T.ptr(new $Int64(0,44843),new $Int64(0,11294)),new T.ptr(new $Int64(0,44851),new $Int64(0,37424)),new T.ptr(new $Int64(0,44867),new $Int64(0,42819)),new T.ptr(new $Int64(0,44879),new $Int64(0,15782)),new T.ptr(new $Int64(0,44887),new $Int64(0,13459)),new T.ptr(new $Int64(0,44893),new $Int64(0,27209)),new T.ptr(new $Int64(0,44909),new $Int64(0,42969)),new T.ptr(new $Int64(0,44917),new $Int64(0,15835)),new T.ptr(new $Int64(0,44927),new $Int64(0,8519)),new T.ptr(new $Int64(0,44939),new $Int64(0,35983)),new T.ptr(new $Int64(0,44953),new $Int64(0,35486)),new T.ptr(new $Int64(0,44959),new $Int64(0,26335)),new T.ptr(new $Int64(0,44963),new $Int64(0,17478)),new T.ptr(new $Int64(0,44971),new $Int64(0,32133)),new T.ptr(new $Int64(0,44983),new $Int64(0,9704)),new T.ptr(new $Int64(0,44987),new $Int64(0,19294)),new T.ptr(new $Int64(0,45007),new $Int64(0,35976)),new T.ptr(new $Int64(0,45013),new $Int64(0,24089)),new T.ptr(new $Int64(0,45053),new $Int64(0,44349)),new T.ptr(new $Int64(0,45061),new $Int64(0,36260)),new T.ptr(new $Int64(0,45077),new $Int64(0,32223)),new T.ptr(new $Int64(0,45083),new $Int64(0,20317)),new T.ptr(new $Int64(0,45119),new $Int64(0,24160)),new T.ptr(new $Int64(0,45121),new $Int64(0,7347)),new T.ptr(new $Int64(0,45127),new $Int64(0,38867)),new T.ptr(new $Int64(0,45131),new $Int64(0,29978)),new T.ptr(new $Int64(0,45137),new $Int64(0,20790)),new T.ptr(new $Int64(0,45139),new $Int64(0,40397)),new T.ptr(new $Int64(0,45161),new $Int64(0,27009)),new T.ptr(new $Int64(0,45179),new $Int64(0,10494)),new T.ptr(new $Int64(0,45181),new $Int64(0,13247)),new T.ptr(new $Int64(0,45191),new $Int64(0,6384)),new T.ptr(new $Int64(0,45197),new $Int64(0,29103)),new T.ptr(new $Int64(0,45233),new $Int64(0,40030)),new T.ptr(new $Int64(0,45247),new $Int64(0,45163)),new T.ptr(new $Int64(0,45259),new $Int64(0,43805)),new T.ptr(new $Int64(0,45263),new $Int64(0,36880)),new T.ptr(new $Int64(0,45281),new $Int64(0,43818)),new T.ptr(new $Int64(0,45289),new $Int64(0,41832)),new T.ptr(new $Int64(0,45293),new $Int64(0,24450)),new T.ptr(new $Int64(0,45307),new $Int64(0,18179)),new T.ptr(new $Int64(0,45317),new $Int64(0,20805)),new T.ptr(new $Int64(0,45319),new $Int64(0,28221)),new T.ptr(new $Int64(0,45329),new $Int64(0,6125)),new T.ptr(new $Int64(0,45337),new $Int64(0,11703)),new T.ptr(new $Int64(0,45341),new $Int64(0,1819)),new T.ptr(new $Int64(0,45343),new $Int64(0,38591)),new T.ptr(new $Int64(0,45361),new $Int64(0,18715)),new T.ptr(new $Int64(0,45377),new $Int64(0,17546)),new T.ptr(new $Int64(0,45389),new $Int64(0,20303)),new T.ptr(new $Int64(0,45403),new $Int64(0,22971)),new T.ptr(new $Int64(0,45413),new $Int64(0,20840)),new T.ptr(new $Int64(0,45427),new $Int64(0,43777)),new T.ptr(new $Int64(0,45433),new $Int64(0,40676)),new T.ptr(new $Int64(0,45439),new $Int64(0,40552)),new T.ptr(new $Int64(0,45481),new $Int64(0,4316)),new T.ptr(new $Int64(0,45491),new $Int64(0,34080)),new T.ptr(new $Int64(0,45497),new $Int64(0,4366)),new T.ptr(new $Int64(0,45503),new $Int64(0,23211)),new T.ptr(new $Int64(0,45523),new $Int64(0,13345)),new T.ptr(new $Int64(0,45533),new $Int64(0,1108)),new T.ptr(new $Int64(0,45541),new $Int64(0,3753)),new T.ptr(new $Int64(0,45553),new $Int64(0,13843)),new T.ptr(new $Int64(0,45557),new $Int64(0,20187)),new T.ptr(new $Int64(0,45569),new $Int64(0,6294)),new T.ptr(new $Int64(0,45587),new $Int64(0,27430)),new T.ptr(new $Int64(0,45589),new $Int64(0,1917)),new T.ptr(new $Int64(0,45599),new $Int64(0,8200)),new T.ptr(new $Int64(0,45613),new $Int64(0,28739)),new T.ptr(new $Int64(0,45631),new $Int64(0,18815)),new T.ptr(new $Int64(0,45641),new $Int64(0,27980)),new T.ptr(new $Int64(0,45659),new $Int64(0,34142)),new T.ptr(new $Int64(0,45667),new $Int64(0,41271)),new T.ptr(new $Int64(0,45673),new $Int64(0,100)),new T.ptr(new $Int64(0,45677),new $Int64(0,35116)),new T.ptr(new $Int64(0,45691),new $Int64(0,30776)),new T.ptr(new $Int64(0,45697),new $Int64(0,29463)),new T.ptr(new $Int64(0,45707),new $Int64(0,32114)),new T.ptr(new $Int64(0,45737),new $Int64(0,44506)),new T.ptr(new $Int64(0,45751),new $Int64(0,10409)),new T.ptr(new $Int64(0,45757),new $Int64(0,33410)),new T.ptr(new $Int64(0,45763),new $Int64(0,16707)),new T.ptr(new $Int64(0,45767),new $Int64(0,33002)),new T.ptr(new $Int64(0,45779),new $Int64(0,32814)),new T.ptr(new $Int64(0,45817),new $Int64(0,42219)),new T.ptr(new $Int64(0,45821),new $Int64(0,465)),new T.ptr(new $Int64(0,45823),new $Int64(0,27189)),new T.ptr(new $Int64(0,45827),new $Int64(0,32473)),new T.ptr(new $Int64(0,45833),new $Int64(0,6129)),new T.ptr(new $Int64(0,45841),new $Int64(0,38376)),new T.ptr(new $Int64(0,45853),new $Int64(0,41533)),new T.ptr(new $Int64(0,45863),new $Int64(0,2502)),new T.ptr(new $Int64(0,45869),new $Int64(0,5671)),new T.ptr(new $Int64(0,45887),new $Int64(0,35839)),new T.ptr(new $Int64(0,45893),new $Int64(0,26241)),new T.ptr(new $Int64(0,45943),new $Int64(0,16199)),new T.ptr(new $Int64(0,45949),new $Int64(0,28051)),new T.ptr(new $Int64(0,45953),new $Int64(0,42733)),new T.ptr(new $Int64(0,45959),new $Int64(0,9183)),new T.ptr(new $Int64(0,45971),new $Int64(0,36644)),new T.ptr(new $Int64(0,45979),new $Int64(0,33432)),new T.ptr(new $Int64(0,45989),new $Int64(0,3940)),new T.ptr(new $Int64(0,46021),new $Int64(0,37952)),new T.ptr(new $Int64(0,46027),new $Int64(0,13364)),new T.ptr(new $Int64(0,46049),new $Int64(0,32490)),new T.ptr(new $Int64(0,46051),new $Int64(0,26556)),new T.ptr(new $Int64(0,46061),new $Int64(0,32908)),new T.ptr(new $Int64(0,46073),new $Int64(0,40129)),new T.ptr(new $Int64(0,46091),new $Int64(0,29925)),new T.ptr(new $Int64(0,46093),new $Int64(0,6064)),new T.ptr(new $Int64(0,46099),new $Int64(0,27210)),new T.ptr(new $Int64(0,46103),new $Int64(0,43690)),new T.ptr(new $Int64(0,46133),new $Int64(0,38453)),new T.ptr(new $Int64(0,46141),new $Int64(0,25928)),new T.ptr(new $Int64(0,46147),new $Int64(0,31747)),new T.ptr(new $Int64(0,46153),new $Int64(0,35880)),new T.ptr(new $Int64(0,46171),new $Int64(0,8083)),new T.ptr(new $Int64(0,46181),new $Int64(0,28980)),new T.ptr(new $Int64(0,46183),new $Int64(0,38660)),new T.ptr(new $Int64(0,46187),new $Int64(0,41541)),new T.ptr(new $Int64(0,46199),new $Int64(0,21323)),new T.ptr(new $Int64(0,46219),new $Int64(0,38547)),new T.ptr(new $Int64(0,46229),new $Int64(0,45248)),new T.ptr(new $Int64(0,46237),new $Int64(0,40181)),new T.ptr(new $Int64(0,46261),new $Int64(0,5892)),new T.ptr(new $Int64(0,46271),new $Int64(0,10327)),new T.ptr(new $Int64(0,46273),new $Int64(0,37545)),new T.ptr(new $Int64(0,46279),new $Int64(0,29651)),new T.ptr(new $Int64(0,46301),new $Int64(0,26095)),new T.ptr(new $Int64(0,46307),new $Int64(0,1032)),new T.ptr(new $Int64(0,46309),new $Int64(0,9118)),new T.ptr(new $Int64(0,46327),new $Int64(0,13104)),new T.ptr(new $Int64(0,46337),new $Int64(0,35878)),new T.ptr(new $Int64(0,46349),new $Int64(0,41013)),new T.ptr(new $Int64(0,46351),new $Int64(0,6517)),new T.ptr(new $Int64(0,46381),new $Int64(0,42419)),new T.ptr(new $Int64(0,46399),new $Int64(0,30006)),new T.ptr(new $Int64(0,46411),new $Int64(0,3164)),new T.ptr(new $Int64(0,46439),new $Int64(0,18743)),new T.ptr(new $Int64(0,46441),new $Int64(0,12155)),new T.ptr(new $Int64(0,46447),new $Int64(0,17546)),new T.ptr(new $Int64(0,46451),new $Int64(0,28813)),new T.ptr(new $Int64(0,46457),new $Int64(0,37224)),new T.ptr(new $Int64(0,46471),new $Int64(0,11687)),new T.ptr(new $Int64(0,46477),new $Int64(0,7331)),new T.ptr(new $Int64(0,46489),new $Int64(0,25478)),new T.ptr(new $Int64(0,46499),new $Int64(0,1603)),new T.ptr(new $Int64(0,46507),new $Int64(0,12760)),new T.ptr(new $Int64(0,46511),new $Int64(0,18326)),new T.ptr(new $Int64(0,46523),new $Int64(0,41648)),new T.ptr(new $Int64(0,46549),new $Int64(0,4422)),new T.ptr(new $Int64(0,46559),new $Int64(0,419)),new T.ptr(new $Int64(0,46567),new $Int64(0,937)),new T.ptr(new $Int64(0,46573),new $Int64(0,24319)),new T.ptr(new $Int64(0,46589),new $Int64(0,24377)),new T.ptr(new $Int64(0,46591),new $Int64(0,7342)),new T.ptr(new $Int64(0,46601),new $Int64(0,22563)),new T.ptr(new $Int64(0,46619),new $Int64(0,28526)),new T.ptr(new $Int64(0,46633),new $Int64(0,23768)),new T.ptr(new $Int64(0,46639),new $Int64(0,44931)),new T.ptr(new $Int64(0,46643),new $Int64(0,16174)),new T.ptr(new $Int64(0,46649),new $Int64(0,10917)),new T.ptr(new $Int64(0,46663),new $Int64(0,40740)),new T.ptr(new $Int64(0,46679),new $Int64(0,26814)),new T.ptr(new $Int64(0,46681),new $Int64(0,10026)),new T.ptr(new $Int64(0,46687),new $Int64(0,35360)),new T.ptr(new $Int64(0,46691),new $Int64(0,41929)),new T.ptr(new $Int64(0,46703),new $Int64(0,27369)),new T.ptr(new $Int64(0,46723),new $Int64(0,17991)),new T.ptr(new $Int64(0,46727),new $Int64(0,21464)),new T.ptr(new $Int64(0,46747),new $Int64(0,20905)),new T.ptr(new $Int64(0,46751),new $Int64(0,9033)),new T.ptr(new $Int64(0,46757),new $Int64(0,20999)),new T.ptr(new $Int64(0,46769),new $Int64(0,34680)),new T.ptr(new $Int64(0,46771),new $Int64(0,41409)),new T.ptr(new $Int64(0,46807),new $Int64(0,10855)),new T.ptr(new $Int64(0,46811),new $Int64(0,12435)),new T.ptr(new $Int64(0,46817),new $Int64(0,45136)),new T.ptr(new $Int64(0,46819),new $Int64(0,320)),new T.ptr(new $Int64(0,46829),new $Int64(0,10234)),new T.ptr(new $Int64(0,46831),new $Int64(0,15146)),new T.ptr(new $Int64(0,46853),new $Int64(0,28943)),new T.ptr(new $Int64(0,46861),new $Int64(0,1287)),new T.ptr(new $Int64(0,46867),new $Int64(0,9675)),new T.ptr(new $Int64(0,46877),new $Int64(0,36741)),new T.ptr(new $Int64(0,46889),new $Int64(0,3900)),new T.ptr(new $Int64(0,46901),new $Int64(0,4318)),new T.ptr(new $Int64(0,46919),new $Int64(0,6375)),new T.ptr(new $Int64(0,46933),new $Int64(0,16677)),new T.ptr(new $Int64(0,46957),new $Int64(0,16648)),new T.ptr(new $Int64(0,46993),new $Int64(0,24374)),new T.ptr(new $Int64(0,46997),new $Int64(0,34065)),new T.ptr(new $Int64(0,47017),new $Int64(0,21014)),new T.ptr(new $Int64(0,47041),new $Int64(0,28290)),new T.ptr(new $Int64(0,47051),new $Int64(0,38915)),new T.ptr(new $Int64(0,47057),new $Int64(0,10627)),new T.ptr(new $Int64(0,47059),new $Int64(0,1732)),new T.ptr(new $Int64(0,47087),new $Int64(0,28262)),new T.ptr(new $Int64(0,47093),new $Int64(0,39065)),new T.ptr(new $Int64(0,47111),new $Int64(0,7220)),new T.ptr(new $Int64(0,47119),new $Int64(0,12396)),new T.ptr(new $Int64(0,47123),new $Int64(0,44586)),new T.ptr(new $Int64(0,47129),new $Int64(0,30380)),new T.ptr(new $Int64(0,47137),new $Int64(0,12356)),new T.ptr(new $Int64(0,47143),new $Int64(0,25900)),new T.ptr(new $Int64(0,47147),new $Int64(0,10612)),new T.ptr(new $Int64(0,47149),new $Int64(0,44233)),new T.ptr(new $Int64(0,47161),new $Int64(0,31189)),new T.ptr(new $Int64(0,47189),new $Int64(0,8427)),new T.ptr(new $Int64(0,47207),new $Int64(0,23901)),new T.ptr(new $Int64(0,47221),new $Int64(0,10826)),new T.ptr(new $Int64(0,47237),new $Int64(0,4415)),new T.ptr(new $Int64(0,47251),new $Int64(0,47168)),new T.ptr(new $Int64(0,47269),new $Int64(0,23143)),new T.ptr(new $Int64(0,47279),new $Int64(0,6849)),new T.ptr(new $Int64(0,47287),new $Int64(0,18194)),new T.ptr(new $Int64(0,47293),new $Int64(0,2017)),new T.ptr(new $Int64(0,47297),new $Int64(0,1184)),new T.ptr(new $Int64(0,47303),new $Int64(0,2108)),new T.ptr(new $Int64(0,47309),new $Int64(0,8732)),new T.ptr(new $Int64(0,47317),new $Int64(0,29633)),new T.ptr(new $Int64(0,47339),new $Int64(0,1963)),new T.ptr(new $Int64(0,47351),new $Int64(0,29253)),new T.ptr(new $Int64(0,47353),new $Int64(0,43483)),new T.ptr(new $Int64(0,47363),new $Int64(0,9279)),new T.ptr(new $Int64(0,47381),new $Int64(0,24479)),new T.ptr(new $Int64(0,47387),new $Int64(0,32963)),new T.ptr(new $Int64(0,47389),new $Int64(0,35984)),new T.ptr(new $Int64(0,47407),new $Int64(0,40736)),new T.ptr(new $Int64(0,47417),new $Int64(0,29893)),new T.ptr(new $Int64(0,47419),new $Int64(0,3498)),new T.ptr(new $Int64(0,47431),new $Int64(0,6811)),new T.ptr(new $Int64(0,47441),new $Int64(0,41548)),new T.ptr(new $Int64(0,47459),new $Int64(0,42979)),new T.ptr(new $Int64(0,47491),new $Int64(0,13011)),new T.ptr(new $Int64(0,47497),new $Int64(0,14206)),new T.ptr(new $Int64(0,47501),new $Int64(0,45990)),new T.ptr(new $Int64(0,47507),new $Int64(0,40640)),new T.ptr(new $Int64(0,47513),new $Int64(0,373)),new T.ptr(new $Int64(0,47521),new $Int64(0,23499)),new T.ptr(new $Int64(0,47527),new $Int64(0,28352)),new T.ptr(new $Int64(0,47533),new $Int64(0,24108)),new T.ptr(new $Int64(0,47543),new $Int64(0,41160)),new T.ptr(new $Int64(0,47563),new $Int64(0,32284)),new T.ptr(new $Int64(0,47569),new $Int64(0,45126)),new T.ptr(new $Int64(0,47581),new $Int64(0,34295)),new T.ptr(new $Int64(0,47591),new $Int64(0,1208)),new T.ptr(new $Int64(0,47599),new $Int64(0,24743)),new T.ptr(new $Int64(0,47609),new $Int64(0,15660)),new T.ptr(new $Int64(0,47623),new $Int64(0,36440)),new T.ptr(new $Int64(0,47629),new $Int64(0,21416)),new T.ptr(new $Int64(0,47639),new $Int64(0,5521)),new T.ptr(new $Int64(0,47653),new $Int64(0,35975)),new T.ptr(new $Int64(0,47657),new $Int64(0,12286)),new T.ptr(new $Int64(0,47659),new $Int64(0,25655)),new T.ptr(new $Int64(0,47681),new $Int64(0,11511)),new T.ptr(new $Int64(0,47699),new $Int64(0,20419)),new T.ptr(new $Int64(0,47701),new $Int64(0,37336)),new T.ptr(new $Int64(0,47711),new $Int64(0,11411)),new T.ptr(new $Int64(0,47713),new $Int64(0,4871)),new T.ptr(new $Int64(0,47717),new $Int64(0,36732)),new T.ptr(new $Int64(0,47737),new $Int64(0,41413)),new T.ptr(new $Int64(0,47741),new $Int64(0,32439)),new T.ptr(new $Int64(0,47743),new $Int64(0,41826)),new T.ptr(new $Int64(0,47777),new $Int64(0,22531)),new T.ptr(new $Int64(0,47779),new $Int64(0,34884)),new T.ptr(new $Int64(0,47791),new $Int64(0,33026)),new T.ptr(new $Int64(0,47797),new $Int64(0,4913)),new T.ptr(new $Int64(0,47807),new $Int64(0,33088)),new T.ptr(new $Int64(0,47809),new $Int64(0,42488)),new T.ptr(new $Int64(0,47819),new $Int64(0,33703)),new T.ptr(new $Int64(0,47837),new $Int64(0,9250)),new T.ptr(new $Int64(0,47843),new $Int64(0,29686)),new T.ptr(new $Int64(0,47857),new $Int64(0,35780)),new T.ptr(new $Int64(0,47869),new $Int64(0,46104)),new T.ptr(new $Int64(0,47881),new $Int64(0,29130)),new T.ptr(new $Int64(0,47903),new $Int64(0,2709)),new T.ptr(new $Int64(0,47911),new $Int64(0,8603)),new T.ptr(new $Int64(0,47917),new $Int64(0,17850)),new T.ptr(new $Int64(0,47933),new $Int64(0,40097)),new T.ptr(new $Int64(0,47939),new $Int64(0,4574)),new T.ptr(new $Int64(0,47947),new $Int64(0,44529)),new T.ptr(new $Int64(0,47951),new $Int64(0,28474)),new T.ptr(new $Int64(0,47963),new $Int64(0,10834)),new T.ptr(new $Int64(0,47969),new $Int64(0,27567)),new T.ptr(new $Int64(0,47977),new $Int64(0,42436)),new T.ptr(new $Int64(0,47981),new $Int64(0,34088)),new T.ptr(new $Int64(0,48017),new $Int64(0,29120)),new T.ptr(new $Int64(0,48023),new $Int64(0,29198)),new T.ptr(new $Int64(0,48029),new $Int64(0,3539)),new T.ptr(new $Int64(0,48049),new $Int64(0,28829)),new T.ptr(new $Int64(0,48073),new $Int64(0,9230)),new T.ptr(new $Int64(0,48079),new $Int64(0,38153)),new T.ptr(new $Int64(0,48091),new $Int64(0,36236)),new T.ptr(new $Int64(0,48109),new $Int64(0,20190)),new T.ptr(new $Int64(0,48119),new $Int64(0,24805)),new T.ptr(new $Int64(0,48121),new $Int64(0,22017)),new T.ptr(new $Int64(0,48131),new $Int64(0,10670)),new T.ptr(new $Int64(0,48157),new $Int64(0,14668)),new T.ptr(new $Int64(0,48163),new $Int64(0,46404)),new T.ptr(new $Int64(0,48179),new $Int64(0,1324)),new T.ptr(new $Int64(0,48187),new $Int64(0,416)),new T.ptr(new $Int64(0,48193),new $Int64(0,35829)),new T.ptr(new $Int64(0,48197),new $Int64(0,18179)),new T.ptr(new $Int64(0,48221),new $Int64(0,39413)),new T.ptr(new $Int64(0,48239),new $Int64(0,31469)),new T.ptr(new $Int64(0,48247),new $Int64(0,25263)),new T.ptr(new $Int64(0,48259),new $Int64(0,9972)),new T.ptr(new $Int64(0,48271),new $Int64(0,20434)),new T.ptr(new $Int64(0,48281),new $Int64(0,30129)),new T.ptr(new $Int64(0,48299),new $Int64(0,14355)),new T.ptr(new $Int64(0,48311),new $Int64(0,8707)),new T.ptr(new $Int64(0,48313),new $Int64(0,22935)),new T.ptr(new $Int64(0,48337),new $Int64(0,42851)),new T.ptr(new $Int64(0,48341),new $Int64(0,24154)),new T.ptr(new $Int64(0,48353),new $Int64(0,44675)),new T.ptr(new $Int64(0,48371),new $Int64(0,37349)),new T.ptr(new $Int64(0,48383),new $Int64(0,33767)),new T.ptr(new $Int64(0,48397),new $Int64(0,47038)),new T.ptr(new $Int64(0,48407),new $Int64(0,31714)),new T.ptr(new $Int64(0,48409),new $Int64(0,20195)),new T.ptr(new $Int64(0,48413),new $Int64(0,41224)),new T.ptr(new $Int64(0,48437),new $Int64(0,41738)),new T.ptr(new $Int64(0,48449),new $Int64(0,7805)),new T.ptr(new $Int64(0,48463),new $Int64(0,29288)),new T.ptr(new $Int64(0,48473),new $Int64(0,1688)),new T.ptr(new $Int64(0,48479),new $Int64(0,45622)),new T.ptr(new $Int64(0,48481),new $Int64(0,18743)),new T.ptr(new $Int64(0,48487),new $Int64(0,3446)),new T.ptr(new $Int64(0,48491),new $Int64(0,25767)),new T.ptr(new $Int64(0,48497),new $Int64(0,42686)),new T.ptr(new $Int64(0,48523),new $Int64(0,18878)),new T.ptr(new $Int64(0,48527),new $Int64(0,21903)),new T.ptr(new $Int64(0,48533),new $Int64(0,5884)),new T.ptr(new $Int64(0,48539),new $Int64(0,39108)),new T.ptr(new $Int64(0,48541),new $Int64(0,34599)),new T.ptr(new $Int64(0,48563),new $Int64(0,14220)),new T.ptr(new $Int64(0,48571),new $Int64(0,35142)),new T.ptr(new $Int64(0,48589),new $Int64(0,26459)),new T.ptr(new $Int64(0,48593),new $Int64(0,45722)),new T.ptr(new $Int64(0,48611),new $Int64(0,37680)),new T.ptr(new $Int64(0,48619),new $Int64(0,1158)),new T.ptr(new $Int64(0,48623),new $Int64(0,44378)),new T.ptr(new $Int64(0,48647),new $Int64(0,32989)),new T.ptr(new $Int64(0,48649),new $Int64(0,5472)),new T.ptr(new $Int64(0,48661),new $Int64(0,5906)),new T.ptr(new $Int64(0,48673),new $Int64(0,24905)),new T.ptr(new $Int64(0,48677),new $Int64(0,15880)),new T.ptr(new $Int64(0,48679),new $Int64(0,37462)),new T.ptr(new $Int64(0,48731),new $Int64(0,27355)),new T.ptr(new $Int64(0,48733),new $Int64(0,29439)),new T.ptr(new $Int64(0,48751),new $Int64(0,8072)),new T.ptr(new $Int64(0,48757),new $Int64(0,17481)),new T.ptr(new $Int64(0,48761),new $Int64(0,33059)),new T.ptr(new $Int64(0,48767),new $Int64(0,624)),new T.ptr(new $Int64(0,48779),new $Int64(0,37742)),new T.ptr(new $Int64(0,48781),new $Int64(0,22587)),new T.ptr(new $Int64(0,48787),new $Int64(0,10510)),new T.ptr(new $Int64(0,48799),new $Int64(0,18298)),new T.ptr(new $Int64(0,48809),new $Int64(0,744)),new T.ptr(new $Int64(0,48817),new $Int64(0,12455)),new T.ptr(new $Int64(0,48821),new $Int64(0,48341)),new T.ptr(new $Int64(0,48823),new $Int64(0,9752)),new T.ptr(new $Int64(0,48847),new $Int64(0,30213)),new T.ptr(new $Int64(0,48857),new $Int64(0,45004)),new T.ptr(new $Int64(0,48859),new $Int64(0,14977)),new T.ptr(new $Int64(0,48869),new $Int64(0,48369)),new T.ptr(new $Int64(0,48871),new $Int64(0,35237)),new T.ptr(new $Int64(0,48883),new $Int64(0,5784)),new T.ptr(new $Int64(0,48889),new $Int64(0,43692)),new T.ptr(new $Int64(0,48907),new $Int64(0,10829)),new T.ptr(new $Int64(0,48947),new $Int64(0,22606)),new T.ptr(new $Int64(0,48953),new $Int64(0,12268)),new T.ptr(new $Int64(0,48973),new $Int64(0,41815)),new T.ptr(new $Int64(0,48989),new $Int64(0,38504)),new T.ptr(new $Int64(0,48991),new $Int64(0,9580)),new T.ptr(new $Int64(0,49003),new $Int64(0,47556)),new T.ptr(new $Int64(0,49009),new $Int64(0,39197)),new T.ptr(new $Int64(0,49019),new $Int64(0,11288)),new T.ptr(new $Int64(0,49031),new $Int64(0,35434)),new T.ptr(new $Int64(0,49033),new $Int64(0,10394)),new T.ptr(new $Int64(0,49037),new $Int64(0,17810)),new T.ptr(new $Int64(0,49043),new $Int64(0,18868)),new T.ptr(new $Int64(0,49057),new $Int64(0,17221)),new T.ptr(new $Int64(0,49069),new $Int64(0,33142)),new T.ptr(new $Int64(0,49081),new $Int64(0,23633)),new T.ptr(new $Int64(0,49103),new $Int64(0,13814)),new T.ptr(new $Int64(0,49109),new $Int64(0,19514)),new T.ptr(new $Int64(0,49117),new $Int64(0,40672)),new T.ptr(new $Int64(0,49121),new $Int64(0,12104)),new T.ptr(new $Int64(0,49123),new $Int64(0,14842)),new T.ptr(new $Int64(0,49139),new $Int64(0,2234)),new T.ptr(new $Int64(0,49157),new $Int64(0,3023)),new T.ptr(new $Int64(0,49169),new $Int64(0,36607)),new T.ptr(new $Int64(0,49171),new $Int64(0,11752)),new T.ptr(new $Int64(0,49177),new $Int64(0,12989)),new T.ptr(new $Int64(0,49193),new $Int64(0,40291)),new T.ptr(new $Int64(0,49199),new $Int64(0,3146)),new T.ptr(new $Int64(0,49201),new $Int64(0,20201)),new T.ptr(new $Int64(0,49207),new $Int64(0,15590)),new T.ptr(new $Int64(0,49211),new $Int64(0,33868)),new T.ptr(new $Int64(0,49223),new $Int64(0,620)),new T.ptr(new $Int64(0,49253),new $Int64(0,38495)),new T.ptr(new $Int64(0,49261),new $Int64(0,33439)),new T.ptr(new $Int64(0,49277),new $Int64(0,19374)),new T.ptr(new $Int64(0,49279),new $Int64(0,21481)),new T.ptr(new $Int64(0,49297),new $Int64(0,44687)),new T.ptr(new $Int64(0,49307),new $Int64(0,38584)),new T.ptr(new $Int64(0,49331),new $Int64(0,18279)),new T.ptr(new $Int64(0,49333),new $Int64(0,44488)),new T.ptr(new $Int64(0,49339),new $Int64(0,46916)),new T.ptr(new $Int64(0,49363),new $Int64(0,19550)),new T.ptr(new $Int64(0,49367),new $Int64(0,40579)),new T.ptr(new $Int64(0,49369),new $Int64(0,46439)),new T.ptr(new $Int64(0,49391),new $Int64(0,36681)),new T.ptr(new $Int64(0,49393),new $Int64(0,10569)),new T.ptr(new $Int64(0,49409),new $Int64(0,31751)),new T.ptr(new $Int64(0,49411),new $Int64(0,27457)),new T.ptr(new $Int64(0,49417),new $Int64(0,40797)),new T.ptr(new $Int64(0,49429),new $Int64(0,42471)),new T.ptr(new $Int64(0,49433),new $Int64(0,45821)),new T.ptr(new $Int64(0,49451),new $Int64(0,34873)),new T.ptr(new $Int64(0,49459),new $Int64(0,45449)),new T.ptr(new $Int64(0,49463),new $Int64(0,14360)),new T.ptr(new $Int64(0,49477),new $Int64(0,38993)),new T.ptr(new $Int64(0,49481),new $Int64(0,26429)),new T.ptr(new $Int64(0,49499),new $Int64(0,4080)),new T.ptr(new $Int64(0,49523),new $Int64(0,13759)),new T.ptr(new $Int64(0,49529),new $Int64(0,18815)),new T.ptr(new $Int64(0,49531),new $Int64(0,6593)),new T.ptr(new $Int64(0,49537),new $Int64(0,19369)),new T.ptr(new $Int64(0,49547),new $Int64(0,15112)),new T.ptr(new $Int64(0,49549),new $Int64(0,3717)),new T.ptr(new $Int64(0,49559),new $Int64(0,18715)),new T.ptr(new $Int64(0,49597),new $Int64(0,18129)),new T.ptr(new $Int64(0,49603),new $Int64(0,46949)),new T.ptr(new $Int64(0,49613),new $Int64(0,12706)),new T.ptr(new $Int64(0,49627),new $Int64(0,11038)),new T.ptr(new $Int64(0,49633),new $Int64(0,47560)),new T.ptr(new $Int64(0,49639),new $Int64(0,29721)),new T.ptr(new $Int64(0,49663),new $Int64(0,25548)),new T.ptr(new $Int64(0,49667),new $Int64(0,17431)),new T.ptr(new $Int64(0,49669),new $Int64(0,24715)),new T.ptr(new $Int64(0,49681),new $Int64(0,26602)),new T.ptr(new $Int64(0,49697),new $Int64(0,37437)),new T.ptr(new $Int64(0,49711),new $Int64(0,23328)),new T.ptr(new $Int64(0,49727),new $Int64(0,30393)),new T.ptr(new $Int64(0,49739),new $Int64(0,32373)),new T.ptr(new $Int64(0,49741),new $Int64(0,36796)),new T.ptr(new $Int64(0,49747),new $Int64(0,25626)),new T.ptr(new $Int64(0,49757),new $Int64(0,43969)),new T.ptr(new $Int64(0,49783),new $Int64(0,24068)),new T.ptr(new $Int64(0,49787),new $Int64(0,10112)),new T.ptr(new $Int64(0,49789),new $Int64(0,18806)),new T.ptr(new $Int64(0,49801),new $Int64(0,16517)),new T.ptr(new $Int64(0,49807),new $Int64(0,25433)),new T.ptr(new $Int64(0,49811),new $Int64(0,43437)),new T.ptr(new $Int64(0,49823),new $Int64(0,49256)),new T.ptr(new $Int64(0,49831),new $Int64(0,23683)),new T.ptr(new $Int64(0,49843),new $Int64(0,20487)),new T.ptr(new $Int64(0,49853),new $Int64(0,46036)),new T.ptr(new $Int64(0,49871),new $Int64(0,47201)),new T.ptr(new $Int64(0,49877),new $Int64(0,28230)),new T.ptr(new $Int64(0,49891),new $Int64(0,27325)),new T.ptr(new $Int64(0,49919),new $Int64(0,7780)),new T.ptr(new $Int64(0,49921),new $Int64(0,18801)),new T.ptr(new $Int64(0,49927),new $Int64(0,21953)),new T.ptr(new $Int64(0,49937),new $Int64(0,28688)),new T.ptr(new $Int64(0,49939),new $Int64(0,2287)),new T.ptr(new $Int64(0,49943),new $Int64(0,1128)),new T.ptr(new $Int64(0,49957),new $Int64(0,14817)),new T.ptr(new $Int64(0,49991),new $Int64(0,41871)),new T.ptr(new $Int64(0,49993),new $Int64(0,42611)),new T.ptr(new $Int64(0,49999),new $Int64(0,32434)),new T.ptr(new $Int64(0,50021),new $Int64(0,3306)),new T.ptr(new $Int64(0,50023),new $Int64(0,46472)),new T.ptr(new $Int64(0,50033),new $Int64(0,5641)),new T.ptr(new $Int64(0,50047),new $Int64(0,34755)),new T.ptr(new $Int64(0,50051),new $Int64(0,29196)),new T.ptr(new $Int64(0,50053),new $Int64(0,23636)),new T.ptr(new $Int64(0,50069),new $Int64(0,5490)),new T.ptr(new $Int64(0,50077),new $Int64(0,11901)),new T.ptr(new $Int64(0,50087),new $Int64(0,26510)),new T.ptr(new $Int64(0,50093),new $Int64(0,26891)),new T.ptr(new $Int64(0,50101),new $Int64(0,25951)),new T.ptr(new $Int64(0,50111),new $Int64(0,20195)),new T.ptr(new $Int64(0,50119),new $Int64(0,5024)),new T.ptr(new $Int64(0,50123),new $Int64(0,12073)),new T.ptr(new $Int64(0,50129),new $Int64(0,30511)),new T.ptr(new $Int64(0,50131),new $Int64(0,40177)),new T.ptr(new $Int64(0,50147),new $Int64(0,39592)),new T.ptr(new $Int64(0,50153),new $Int64(0,22439)),new T.ptr(new $Int64(0,50159),new $Int64(0,4410)),new T.ptr(new $Int64(0,50177),new $Int64(0,8725)),new T.ptr(new $Int64(0,50207),new $Int64(0,36003)),new T.ptr(new $Int64(0,50221),new $Int64(0,8052)),new T.ptr(new $Int64(0,50227),new $Int64(0,13881)),new T.ptr(new $Int64(0,50231),new $Int64(0,1827)),new T.ptr(new $Int64(0,50261),new $Int64(0,9548)),new T.ptr(new $Int64(0,50263),new $Int64(0,33489)),new T.ptr(new $Int64(0,50273),new $Int64(0,10389)),new T.ptr(new $Int64(0,50287),new $Int64(0,24171)),new T.ptr(new $Int64(0,50291),new $Int64(0,34762)),new T.ptr(new $Int64(0,50311),new $Int64(0,39693)),new T.ptr(new $Int64(0,50321),new $Int64(0,45880)),new T.ptr(new $Int64(0,50329),new $Int64(0,34169)),new T.ptr(new $Int64(0,50333),new $Int64(0,21891)),new T.ptr(new $Int64(0,50341),new $Int64(0,27232)),new T.ptr(new $Int64(0,50359),new $Int64(0,21499)),new T.ptr(new $Int64(0,50363),new $Int64(0,13288)),new T.ptr(new $Int64(0,50377),new $Int64(0,15470)),new T.ptr(new $Int64(0,50383),new $Int64(0,4829)),new T.ptr(new $Int64(0,50387),new $Int64(0,7264)),new T.ptr(new $Int64(0,50411),new $Int64(0,20190)),new T.ptr(new $Int64(0,50417),new $Int64(0,7155)),new T.ptr(new $Int64(0,50423),new $Int64(0,40228)),new T.ptr(new $Int64(0,50441),new $Int64(0,6332)),new T.ptr(new $Int64(0,50459),new $Int64(0,3403)),new T.ptr(new $Int64(0,50461),new $Int64(0,28658)),new T.ptr(new $Int64(0,50497),new $Int64(0,11118)),new T.ptr(new $Int64(0,50503),new $Int64(0,40460)),new T.ptr(new $Int64(0,50513),new $Int64(0,15283)),new T.ptr(new $Int64(0,50527),new $Int64(0,13232)),new T.ptr(new $Int64(0,50539),new $Int64(0,48360)),new T.ptr(new $Int64(0,50543),new $Int64(0,25075)),new T.ptr(new $Int64(0,50549),new $Int64(0,43669)),new T.ptr(new $Int64(0,50551),new $Int64(0,4633)),new T.ptr(new $Int64(0,50581),new $Int64(0,24330)),new T.ptr(new $Int64(0,50587),new $Int64(0,45869)),new T.ptr(new $Int64(0,50591),new $Int64(0,26706)),new T.ptr(new $Int64(0,50593),new $Int64(0,14667)),new T.ptr(new $Int64(0,50599),new $Int64(0,15384)),new T.ptr(new $Int64(0,50627),new $Int64(0,44624)),new T.ptr(new $Int64(0,50647),new $Int64(0,36133)),new T.ptr(new $Int64(0,50651),new $Int64(0,4853)),new T.ptr(new $Int64(0,50671),new $Int64(0,15578)),new T.ptr(new $Int64(0,50683),new $Int64(0,17288)),new T.ptr(new $Int64(0,50707),new $Int64(0,48308)),new T.ptr(new $Int64(0,50723),new $Int64(0,34412)),new T.ptr(new $Int64(0,50741),new $Int64(0,667)),new T.ptr(new $Int64(0,50753),new $Int64(0,48160)),new T.ptr(new $Int64(0,50767),new $Int64(0,13447)),new T.ptr(new $Int64(0,50773),new $Int64(0,25802)),new T.ptr(new $Int64(0,50777),new $Int64(0,39468)),new T.ptr(new $Int64(0,50789),new $Int64(0,50726)),new T.ptr(new $Int64(0,50821),new $Int64(0,37138)),new T.ptr(new $Int64(0,50833),new $Int64(0,50081)),new T.ptr(new $Int64(0,50839),new $Int64(0,24802)),new T.ptr(new $Int64(0,50849),new $Int64(0,20434)),new T.ptr(new $Int64(0,50857),new $Int64(0,50064)),new T.ptr(new $Int64(0,50867),new $Int64(0,5453)),new T.ptr(new $Int64(0,50873),new $Int64(0,25658)),new T.ptr(new $Int64(0,50891),new $Int64(0,44633)),new T.ptr(new $Int64(0,50893),new $Int64(0,43251)),new T.ptr(new $Int64(0,50909),new $Int64(0,242)),new T.ptr(new $Int64(0,50923),new $Int64(0,45960)),new T.ptr(new $Int64(0,50929),new $Int64(0,47245)),new T.ptr(new $Int64(0,50951),new $Int64(0,8063)),new T.ptr(new $Int64(0,50957),new $Int64(0,25736)),new T.ptr(new $Int64(0,50969),new $Int64(0,27458)),new T.ptr(new $Int64(0,50971),new $Int64(0,9127)),new T.ptr(new $Int64(0,50989),new $Int64(0,18648)),new T.ptr(new $Int64(0,50993),new $Int64(0,49916)),new T.ptr(new $Int64(0,51001),new $Int64(0,25067)),new T.ptr(new $Int64(0,51031),new $Int64(0,25069)),new T.ptr(new $Int64(0,51043),new $Int64(0,41632)),new T.ptr(new $Int64(0,51047),new $Int64(0,28395)),new T.ptr(new $Int64(0,51059),new $Int64(0,6861)),new T.ptr(new $Int64(0,51061),new $Int64(0,50678)),new T.ptr(new $Int64(0,51071),new $Int64(0,33643)),new T.ptr(new $Int64(0,51109),new $Int64(0,49633)),new T.ptr(new $Int64(0,51131),new $Int64(0,49645)),new T.ptr(new $Int64(0,51133),new $Int64(0,21030)),new T.ptr(new $Int64(0,51137),new $Int64(0,41638)),new T.ptr(new $Int64(0,51151),new $Int64(0,50729)),new T.ptr(new $Int64(0,51157),new $Int64(0,30658)),new T.ptr(new $Int64(0,51169),new $Int64(0,10765)),new T.ptr(new $Int64(0,51193),new $Int64(0,48390)),new T.ptr(new $Int64(0,51197),new $Int64(0,14912)),new T.ptr(new $Int64(0,51199),new $Int64(0,5388)),new T.ptr(new $Int64(0,51203),new $Int64(0,9929)),new T.ptr(new $Int64(0,51217),new $Int64(0,2476)),new T.ptr(new $Int64(0,51229),new $Int64(0,22830)),new T.ptr(new $Int64(0,51239),new $Int64(0,1792)),new T.ptr(new $Int64(0,51241),new $Int64(0,44074)),new T.ptr(new $Int64(0,51257),new $Int64(0,26630)),new T.ptr(new $Int64(0,51263),new $Int64(0,23691)),new T.ptr(new $Int64(0,51283),new $Int64(0,46746)),new T.ptr(new $Int64(0,51287),new $Int64(0,6036)),new T.ptr(new $Int64(0,51307),new $Int64(0,21099)),new T.ptr(new $Int64(0,51329),new $Int64(0,22678)),new T.ptr(new $Int64(0,51341),new $Int64(0,47964)),new T.ptr(new $Int64(0,51343),new $Int64(0,41492)),new T.ptr(new $Int64(0,51347),new $Int64(0,9762)),new T.ptr(new $Int64(0,51349),new $Int64(0,56)),new T.ptr(new $Int64(0,51361),new $Int64(0,7029)),new T.ptr(new $Int64(0,51383),new $Int64(0,48129)),new T.ptr(new $Int64(0,51407),new $Int64(0,24949)),new T.ptr(new $Int64(0,51413),new $Int64(0,17430)),new T.ptr(new $Int64(0,51419),new $Int64(0,31309)),new T.ptr(new $Int64(0,51421),new $Int64(0,20419)),new T.ptr(new $Int64(0,51427),new $Int64(0,33684)),new T.ptr(new $Int64(0,51431),new $Int64(0,43334)),new T.ptr(new $Int64(0,51437),new $Int64(0,31785)),new T.ptr(new $Int64(0,51439),new $Int64(0,2330)),new T.ptr(new $Int64(0,51449),new $Int64(0,48841)),new T.ptr(new $Int64(0,51461),new $Int64(0,46431)),new T.ptr(new $Int64(0,51473),new $Int64(0,2101)),new T.ptr(new $Int64(0,51479),new $Int64(0,29417)),new T.ptr(new $Int64(0,51481),new $Int64(0,7354)),new T.ptr(new $Int64(0,51487),new $Int64(0,12609)),new T.ptr(new $Int64(0,51503),new $Int64(0,33269)),new T.ptr(new $Int64(0,51511),new $Int64(0,32046)),new T.ptr(new $Int64(0,51517),new $Int64(0,19294)),new T.ptr(new $Int64(0,51521),new $Int64(0,34467)),new T.ptr(new $Int64(0,51539),new $Int64(0,8985)),new T.ptr(new $Int64(0,51551),new $Int64(0,3008)),new T.ptr(new $Int64(0,51563),new $Int64(0,51208)),new T.ptr(new $Int64(0,51577),new $Int64(0,40107)),new T.ptr(new $Int64(0,51581),new $Int64(0,15467)),new T.ptr(new $Int64(0,51593),new $Int64(0,7827)),new T.ptr(new $Int64(0,51599),new $Int64(0,7681)),new T.ptr(new $Int64(0,51607),new $Int64(0,37849)),new T.ptr(new $Int64(0,51613),new $Int64(0,4934)),new T.ptr(new $Int64(0,51631),new $Int64(0,6692)),new T.ptr(new $Int64(0,51637),new $Int64(0,29037)),new T.ptr(new $Int64(0,51647),new $Int64(0,39409)),new T.ptr(new $Int64(0,51659),new $Int64(0,40280)),new T.ptr(new $Int64(0,51673),new $Int64(0,23446)),new T.ptr(new $Int64(0,51679),new $Int64(0,7865)),new T.ptr(new $Int64(0,51683),new $Int64(0,16476)),new T.ptr(new $Int64(0,51691),new $Int64(0,38742)),new T.ptr(new $Int64(0,51713),new $Int64(0,13063)),new T.ptr(new $Int64(0,51719),new $Int64(0,44176)),new T.ptr(new $Int64(0,51721),new $Int64(0,27746)),new T.ptr(new $Int64(0,51749),new $Int64(0,15445)),new T.ptr(new $Int64(0,51767),new $Int64(0,17625)),new T.ptr(new $Int64(0,51769),new $Int64(0,26665)),new T.ptr(new $Int64(0,51787),new $Int64(0,35834)),new T.ptr(new $Int64(0,51797),new $Int64(0,42460)),new T.ptr(new $Int64(0,51803),new $Int64(0,5957)),new T.ptr(new $Int64(0,51817),new $Int64(0,36463)),new T.ptr(new $Int64(0,51827),new $Int64(0,8300)),new T.ptr(new $Int64(0,51829),new $Int64(0,38527)),new T.ptr(new $Int64(0,51839),new $Int64(0,14708)),new T.ptr(new $Int64(0,51853),new $Int64(0,33344)),new T.ptr(new $Int64(0,51859),new $Int64(0,2893)),new T.ptr(new $Int64(0,51869),new $Int64(0,10610)),new T.ptr(new $Int64(0,51871),new $Int64(0,5894)),new T.ptr(new $Int64(0,51893),new $Int64(0,17178)),new T.ptr(new $Int64(0,51899),new $Int64(0,37460)),new T.ptr(new $Int64(0,51907),new $Int64(0,21968)),new T.ptr(new $Int64(0,51913),new $Int64(0,8204)),new T.ptr(new $Int64(0,51929),new $Int64(0,11582)),new T.ptr(new $Int64(0,51941),new $Int64(0,1513)),new T.ptr(new $Int64(0,51949),new $Int64(0,26109)),new T.ptr(new $Int64(0,51971),new $Int64(0,18115)),new T.ptr(new $Int64(0,51973),new $Int64(0,17741)),new T.ptr(new $Int64(0,51977),new $Int64(0,49228)),new T.ptr(new $Int64(0,51991),new $Int64(0,38837)),new T.ptr(new $Int64(0,52009),new $Int64(0,21489)),new T.ptr(new $Int64(0,52021),new $Int64(0,19410)),new T.ptr(new $Int64(0,52027),new $Int64(0,50709)),new T.ptr(new $Int64(0,52051),new $Int64(0,29496)),new T.ptr(new $Int64(0,52057),new $Int64(0,37828)),new T.ptr(new $Int64(0,52067),new $Int64(0,45009)),new T.ptr(new $Int64(0,52069),new $Int64(0,43595)),new T.ptr(new $Int64(0,52081),new $Int64(0,4370)),new T.ptr(new $Int64(0,52103),new $Int64(0,15699)),new T.ptr(new $Int64(0,52121),new $Int64(0,4356)),new T.ptr(new $Int64(0,52127),new $Int64(0,30558)),new T.ptr(new $Int64(0,52147),new $Int64(0,37125)),new T.ptr(new $Int64(0,52153),new $Int64(0,12410)),new T.ptr(new $Int64(0,52163),new $Int64(0,47166)),new T.ptr(new $Int64(0,52177),new $Int64(0,16961)),new T.ptr(new $Int64(0,52181),new $Int64(0,40356)),new T.ptr(new $Int64(0,52183),new $Int64(0,41441)),new T.ptr(new $Int64(0,52189),new $Int64(0,51516)),new T.ptr(new $Int64(0,52201),new $Int64(0,7509)),new T.ptr(new $Int64(0,52223),new $Int64(0,49281)),new T.ptr(new $Int64(0,52237),new $Int64(0,1873)),new T.ptr(new $Int64(0,52249),new $Int64(0,1388)),new T.ptr(new $Int64(0,52253),new $Int64(0,32331)),new T.ptr(new $Int64(0,52259),new $Int64(0,28166)),new T.ptr(new $Int64(0,52267),new $Int64(0,14497)),new T.ptr(new $Int64(0,52289),new $Int64(0,13804)),new T.ptr(new $Int64(0,52291),new $Int64(0,14535)),new T.ptr(new $Int64(0,52301),new $Int64(0,42800)),new T.ptr(new $Int64(0,52313),new $Int64(0,29938)),new T.ptr(new $Int64(0,52321),new $Int64(0,22841)),new T.ptr(new $Int64(0,52361),new $Int64(0,21481)),new T.ptr(new $Int64(0,52363),new $Int64(0,15664)),new T.ptr(new $Int64(0,52369),new $Int64(0,39687)),new T.ptr(new $Int64(0,52379),new $Int64(0,4736)),new T.ptr(new $Int64(0,52387),new $Int64(0,3383)),new T.ptr(new $Int64(0,52391),new $Int64(0,35664)),new T.ptr(new $Int64(0,52433),new $Int64(0,23721)),new T.ptr(new $Int64(0,52453),new $Int64(0,48664)),new T.ptr(new $Int64(0,52457),new $Int64(0,40407)),new T.ptr(new $Int64(0,52489),new $Int64(0,36422)),new T.ptr(new $Int64(0,52501),new $Int64(0,33960)),new T.ptr(new $Int64(0,52511),new $Int64(0,41044)),new T.ptr(new $Int64(0,52517),new $Int64(0,28570)),new T.ptr(new $Int64(0,52529),new $Int64(0,2375)),new T.ptr(new $Int64(0,52541),new $Int64(0,49400)),new T.ptr(new $Int64(0,52543),new $Int64(0,30074)),new T.ptr(new $Int64(0,52553),new $Int64(0,45983)),new T.ptr(new $Int64(0,52561),new $Int64(0,42899)),new T.ptr(new $Int64(0,52567),new $Int64(0,34667)),new T.ptr(new $Int64(0,52571),new $Int64(0,888)),new T.ptr(new $Int64(0,52579),new $Int64(0,35342)),new T.ptr(new $Int64(0,52583),new $Int64(0,13900)),new T.ptr(new $Int64(0,52609),new $Int64(0,46964)),new T.ptr(new $Int64(0,52627),new $Int64(0,14702)),new T.ptr(new $Int64(0,52631),new $Int64(0,46974)),new T.ptr(new $Int64(0,52639),new $Int64(0,34725)),new T.ptr(new $Int64(0,52667),new $Int64(0,48211)),new T.ptr(new $Int64(0,52673),new $Int64(0,4781)),new T.ptr(new $Int64(0,52691),new $Int64(0,31315)),new T.ptr(new $Int64(0,52697),new $Int64(0,2530)),new T.ptr(new $Int64(0,52709),new $Int64(0,38795)),new T.ptr(new $Int64(0,52711),new $Int64(0,21471)),new T.ptr(new $Int64(0,52721),new $Int64(0,52545)),new T.ptr(new $Int64(0,52727),new $Int64(0,51084)),new T.ptr(new $Int64(0,52733),new $Int64(0,493)),new T.ptr(new $Int64(0,52747),new $Int64(0,13102)),new T.ptr(new $Int64(0,52757),new $Int64(0,18107)),new T.ptr(new $Int64(0,52769),new $Int64(0,2544)),new T.ptr(new $Int64(0,52783),new $Int64(0,28524)),new T.ptr(new $Int64(0,52807),new $Int64(0,6549)),new T.ptr(new $Int64(0,52813),new $Int64(0,41295)),new T.ptr(new $Int64(0,52817),new $Int64(0,21953)),new T.ptr(new $Int64(0,52837),new $Int64(0,25014)),new T.ptr(new $Int64(0,52859),new $Int64(0,40582)),new T.ptr(new $Int64(0,52861),new $Int64(0,36358)),new T.ptr(new $Int64(0,52879),new $Int64(0,49569)),new T.ptr(new $Int64(0,52883),new $Int64(0,17651)),new T.ptr(new $Int64(0,52889),new $Int64(0,3448)),new T.ptr(new $Int64(0,52901),new $Int64(0,39116)),new T.ptr(new $Int64(0,52903),new $Int64(0,46875)),new T.ptr(new $Int64(0,52919),new $Int64(0,50329)),new T.ptr(new $Int64(0,52937),new $Int64(0,41570)),new T.ptr(new $Int64(0,52951),new $Int64(0,12100)),new T.ptr(new $Int64(0,52957),new $Int64(0,32689)),new T.ptr(new $Int64(0,52963),new $Int64(0,47907)),new T.ptr(new $Int64(0,52967),new $Int64(0,38088)),new T.ptr(new $Int64(0,52973),new $Int64(0,50981)),new T.ptr(new $Int64(0,52981),new $Int64(0,47873)),new T.ptr(new $Int64(0,52999),new $Int64(0,35439)),new T.ptr(new $Int64(0,53003),new $Int64(0,14567)),new T.ptr(new $Int64(0,53017),new $Int64(0,29098)),new T.ptr(new $Int64(0,53047),new $Int64(0,39859)),new T.ptr(new $Int64(0,53051),new $Int64(0,3758)),new T.ptr(new $Int64(0,53069),new $Int64(0,39166)),new T.ptr(new $Int64(0,53077),new $Int64(0,17121)),new T.ptr(new $Int64(0,53087),new $Int64(0,36159)),new T.ptr(new $Int64(0,53089),new $Int64(0,40763)),new T.ptr(new $Int64(0,53093),new $Int64(0,7975)),new T.ptr(new $Int64(0,53101),new $Int64(0,2148)),new T.ptr(new $Int64(0,53113),new $Int64(0,8712)),new T.ptr(new $Int64(0,53117),new $Int64(0,16108)),new T.ptr(new $Int64(0,53129),new $Int64(0,5109)),new T.ptr(new $Int64(0,53147),new $Int64(0,1503)),new T.ptr(new $Int64(0,53149),new $Int64(0,37172)),new T.ptr(new $Int64(0,53161),new $Int64(0,44026)),new T.ptr(new $Int64(0,53171),new $Int64(0,10300)),new T.ptr(new $Int64(0,53173),new $Int64(0,27181)),new T.ptr(new $Int64(0,53189),new $Int64(0,12049)),new T.ptr(new $Int64(0,53197),new $Int64(0,9879)),new T.ptr(new $Int64(0,53201),new $Int64(0,4712)),new T.ptr(new $Int64(0,53231),new $Int64(0,22835)),new T.ptr(new $Int64(0,53233),new $Int64(0,51116)),new T.ptr(new $Int64(0,53239),new $Int64(0,7411)),new T.ptr(new $Int64(0,53267),new $Int64(0,5391)),new T.ptr(new $Int64(0,53269),new $Int64(0,44919)),new T.ptr(new $Int64(0,53279),new $Int64(0,39973)),new T.ptr(new $Int64(0,53281),new $Int64(0,8516)),new T.ptr(new $Int64(0,53299),new $Int64(0,10268)),new T.ptr(new $Int64(0,53309),new $Int64(0,10372)),new T.ptr(new $Int64(0,53323),new $Int64(0,9399)),new T.ptr(new $Int64(0,53327),new $Int64(0,40318)),new T.ptr(new $Int64(0,53353),new $Int64(0,38386)),new T.ptr(new $Int64(0,53359),new $Int64(0,3643)),new T.ptr(new $Int64(0,53377),new $Int64(0,41720)),new T.ptr(new $Int64(0,53381),new $Int64(0,13607)),new T.ptr(new $Int64(0,53401),new $Int64(0,10349)),new T.ptr(new $Int64(0,53407),new $Int64(0,42317)),new T.ptr(new $Int64(0,53411),new $Int64(0,34144)),new T.ptr(new $Int64(0,53419),new $Int64(0,50849)),new T.ptr(new $Int64(0,53437),new $Int64(0,15689)),new T.ptr(new $Int64(0,53441),new $Int64(0,1530)),new T.ptr(new $Int64(0,53453),new $Int64(0,44768)),new T.ptr(new $Int64(0,53479),new $Int64(0,1995)),new T.ptr(new $Int64(0,53503),new $Int64(0,45429)),new T.ptr(new $Int64(0,53507),new $Int64(0,6324)),new T.ptr(new $Int64(0,53527),new $Int64(0,34498)),new T.ptr(new $Int64(0,53549),new $Int64(0,843)),new T.ptr(new $Int64(0,53551),new $Int64(0,3838)),new T.ptr(new $Int64(0,53569),new $Int64(0,44396)),new T.ptr(new $Int64(0,53591),new $Int64(0,33804)),new T.ptr(new $Int64(0,53593),new $Int64(0,47821)),new T.ptr(new $Int64(0,53597),new $Int64(0,9400)),new T.ptr(new $Int64(0,53609),new $Int64(0,27702)),new T.ptr(new $Int64(0,53611),new $Int64(0,33165)),new T.ptr(new $Int64(0,53617),new $Int64(0,33391)),new T.ptr(new $Int64(0,53623),new $Int64(0,479)),new T.ptr(new $Int64(0,53629),new $Int64(0,49080)),new T.ptr(new $Int64(0,53633),new $Int64(0,48964)),new T.ptr(new $Int64(0,53639),new $Int64(0,18541)),new T.ptr(new $Int64(0,53653),new $Int64(0,42327)),new T.ptr(new $Int64(0,53657),new $Int64(0,42189)),new T.ptr(new $Int64(0,53681),new $Int64(0,7275)),new T.ptr(new $Int64(0,53693),new $Int64(0,28609)),new T.ptr(new $Int64(0,53699),new $Int64(0,32590)),new T.ptr(new $Int64(0,53717),new $Int64(0,20905)),new T.ptr(new $Int64(0,53719),new $Int64(0,13542)),new T.ptr(new $Int64(0,53731),new $Int64(0,20303)),new T.ptr(new $Int64(0,53759),new $Int64(0,8647)),new T.ptr(new $Int64(0,53773),new $Int64(0,47525)),new T.ptr(new $Int64(0,53777),new $Int64(0,38469)),new T.ptr(new $Int64(0,53783),new $Int64(0,1161)),new T.ptr(new $Int64(0,53791),new $Int64(0,52165)),new T.ptr(new $Int64(0,53813),new $Int64(0,13029)),new T.ptr(new $Int64(0,53819),new $Int64(0,26211)),new T.ptr(new $Int64(0,53831),new $Int64(0,39118)),new T.ptr(new $Int64(0,53849),new $Int64(0,41490)),new T.ptr(new $Int64(0,53857),new $Int64(0,15624)),new T.ptr(new $Int64(0,53861),new $Int64(0,2107)),new T.ptr(new $Int64(0,53881),new $Int64(0,17924)),new T.ptr(new $Int64(0,53887),new $Int64(0,40867)),new T.ptr(new $Int64(0,53891),new $Int64(0,48287)),new T.ptr(new $Int64(0,53897),new $Int64(0,43993)),new T.ptr(new $Int64(0,53899),new $Int64(0,29714)),new T.ptr(new $Int64(0,53917),new $Int64(0,17769)),new T.ptr(new $Int64(0,53923),new $Int64(0,49745)),new T.ptr(new $Int64(0,53927),new $Int64(0,19384)),new T.ptr(new $Int64(0,53939),new $Int64(0,53212)),new T.ptr(new $Int64(0,53951),new $Int64(0,26216)),new T.ptr(new $Int64(0,53959),new $Int64(0,32631)),new T.ptr(new $Int64(0,53987),new $Int64(0,46453)),new T.ptr(new $Int64(0,53993),new $Int64(0,28634)),new T.ptr(new $Int64(0,54001),new $Int64(0,31127)),new T.ptr(new $Int64(0,54011),new $Int64(0,21416)),new T.ptr(new $Int64(0,54013),new $Int64(0,13635)),new T.ptr(new $Int64(0,54037),new $Int64(0,25906)),new T.ptr(new $Int64(0,54049),new $Int64(0,31889)),new T.ptr(new $Int64(0,54059),new $Int64(0,27570)),new T.ptr(new $Int64(0,54083),new $Int64(0,46903)),new T.ptr(new $Int64(0,54091),new $Int64(0,16008)),new T.ptr(new $Int64(0,54101),new $Int64(0,14331)),new T.ptr(new $Int64(0,54121),new $Int64(0,23789)),new T.ptr(new $Int64(0,54133),new $Int64(0,20317)),new T.ptr(new $Int64(0,54139),new $Int64(0,39203)),new T.ptr(new $Int64(0,54151),new $Int64(0,30118)),new T.ptr(new $Int64(0,54163),new $Int64(0,46287)),new T.ptr(new $Int64(0,54167),new $Int64(0,51938)),new T.ptr(new $Int64(0,54181),new $Int64(0,50960)),new T.ptr(new $Int64(0,54193),new $Int64(0,30274)),new T.ptr(new $Int64(0,54217),new $Int64(0,21903)),new T.ptr(new $Int64(0,54251),new $Int64(0,537)),new T.ptr(new $Int64(0,54269),new $Int64(0,3294)),new T.ptr(new $Int64(0,54277),new $Int64(0,31118)),new T.ptr(new $Int64(0,54287),new $Int64(0,42020)),new T.ptr(new $Int64(0,54293),new $Int64(0,3328)),new T.ptr(new $Int64(0,54311),new $Int64(0,24926)),new T.ptr(new $Int64(0,54319),new $Int64(0,33934)),new T.ptr(new $Int64(0,54323),new $Int64(0,11945)),new T.ptr(new $Int64(0,54331),new $Int64(0,31765)),new T.ptr(new $Int64(0,54347),new $Int64(0,35307)),new T.ptr(new $Int64(0,54361),new $Int64(0,25578)),new T.ptr(new $Int64(0,54367),new $Int64(0,34279)),new T.ptr(new $Int64(0,54371),new $Int64(0,40298)),new T.ptr(new $Int64(0,54377),new $Int64(0,50143)),new T.ptr(new $Int64(0,54401),new $Int64(0,19981)),new T.ptr(new $Int64(0,54403),new $Int64(0,28394)),new T.ptr(new $Int64(0,54409),new $Int64(0,26829)),new T.ptr(new $Int64(0,54413),new $Int64(0,11163)),new T.ptr(new $Int64(0,54419),new $Int64(0,82)),new T.ptr(new $Int64(0,54421),new $Int64(0,49446)),new T.ptr(new $Int64(0,54437),new $Int64(0,9928)),new T.ptr(new $Int64(0,54443),new $Int64(0,22414)),new T.ptr(new $Int64(0,54449),new $Int64(0,10621)),new T.ptr(new $Int64(0,54469),new $Int64(0,41088)),new T.ptr(new $Int64(0,54493),new $Int64(0,33844)),new T.ptr(new $Int64(0,54497),new $Int64(0,37133)),new T.ptr(new $Int64(0,54499),new $Int64(0,31787)),new T.ptr(new $Int64(0,54503),new $Int64(0,23446)),new T.ptr(new $Int64(0,54517),new $Int64(0,36484)),new T.ptr(new $Int64(0,54521),new $Int64(0,23402)),new T.ptr(new $Int64(0,54539),new $Int64(0,14793)),new T.ptr(new $Int64(0,54541),new $Int64(0,43616)),new T.ptr(new $Int64(0,54547),new $Int64(0,47062)),new T.ptr(new $Int64(0,54559),new $Int64(0,4597)),new T.ptr(new $Int64(0,54563),new $Int64(0,32711)),new T.ptr(new $Int64(0,54577),new $Int64(0,47674)),new T.ptr(new $Int64(0,54581),new $Int64(0,35778)),new T.ptr(new $Int64(0,54583),new $Int64(0,33859)),new T.ptr(new $Int64(0,54601),new $Int64(0,9927)),new T.ptr(new $Int64(0,54617),new $Int64(0,50528)),new T.ptr(new $Int64(0,54623),new $Int64(0,21806)),new T.ptr(new $Int64(0,54629),new $Int64(0,3425)),new T.ptr(new $Int64(0,54631),new $Int64(0,35406)),new T.ptr(new $Int64(0,54647),new $Int64(0,5285)),new T.ptr(new $Int64(0,54667),new $Int64(0,14835)),new T.ptr(new $Int64(0,54673),new $Int64(0,11098)),new T.ptr(new $Int64(0,54679),new $Int64(0,36180)),new T.ptr(new $Int64(0,54709),new $Int64(0,32579)),new T.ptr(new $Int64(0,54713),new $Int64(0,10432)),new T.ptr(new $Int64(0,54721),new $Int64(0,34658)),new T.ptr(new $Int64(0,54727),new $Int64(0,2468)),new T.ptr(new $Int64(0,54751),new $Int64(0,29139)),new T.ptr(new $Int64(0,54767),new $Int64(0,45346)),new T.ptr(new $Int64(0,54773),new $Int64(0,30826)),new T.ptr(new $Int64(0,54779),new $Int64(0,44847)),new T.ptr(new $Int64(0,54787),new $Int64(0,33586)),new T.ptr(new $Int64(0,54799),new $Int64(0,49617)),new T.ptr(new $Int64(0,54829),new $Int64(0,19176)),new T.ptr(new $Int64(0,54833),new $Int64(0,25245)),new T.ptr(new $Int64(0,54851),new $Int64(0,8324)),new T.ptr(new $Int64(0,54869),new $Int64(0,52718)),new T.ptr(new $Int64(0,54877),new $Int64(0,47799)),new T.ptr(new $Int64(0,54881),new $Int64(0,50531)),new T.ptr(new $Int64(0,54907),new $Int64(0,11609)),new T.ptr(new $Int64(0,54917),new $Int64(0,46444)),new T.ptr(new $Int64(0,54919),new $Int64(0,47970)),new T.ptr(new $Int64(0,54941),new $Int64(0,26848)),new T.ptr(new $Int64(0,54949),new $Int64(0,39419)),new T.ptr(new $Int64(0,54959),new $Int64(0,22017)),new T.ptr(new $Int64(0,54973),new $Int64(0,16788)),new T.ptr(new $Int64(0,54979),new $Int64(0,211)),new T.ptr(new $Int64(0,54983),new $Int64(0,37769)),new T.ptr(new $Int64(0,55001),new $Int64(0,35861)),new T.ptr(new $Int64(0,55009),new $Int64(0,6627)),new T.ptr(new $Int64(0,55021),new $Int64(0,34051)),new T.ptr(new $Int64(0,55049),new $Int64(0,29436)),new T.ptr(new $Int64(0,55051),new $Int64(0,17777)),new T.ptr(new $Int64(0,55057),new $Int64(0,12617)),new T.ptr(new $Int64(0,55061),new $Int64(0,30207)),new T.ptr(new $Int64(0,55073),new $Int64(0,11601)),new T.ptr(new $Int64(0,55079),new $Int64(0,5833)),new T.ptr(new $Int64(0,55103),new $Int64(0,45393)),new T.ptr(new $Int64(0,55109),new $Int64(0,23770)),new T.ptr(new $Int64(0,55117),new $Int64(0,52413)),new T.ptr(new $Int64(0,55127),new $Int64(0,21853)),new T.ptr(new $Int64(0,55147),new $Int64(0,20805)),new T.ptr(new $Int64(0,55163),new $Int64(0,33732)),new T.ptr(new $Int64(0,55171),new $Int64(0,28398)),new T.ptr(new $Int64(0,55201),new $Int64(0,3198)),new T.ptr(new $Int64(0,55207),new $Int64(0,30948)),new T.ptr(new $Int64(0,55213),new $Int64(0,47860)),new T.ptr(new $Int64(0,55217),new $Int64(0,46284)),new T.ptr(new $Int64(0,55219),new $Int64(0,1922)),new T.ptr(new $Int64(0,55229),new $Int64(0,8980)),new T.ptr(new $Int64(0,55243),new $Int64(0,44285)),new T.ptr(new $Int64(0,55249),new $Int64(0,18357)),new T.ptr(new $Int64(0,55259),new $Int64(0,51478)),new T.ptr(new $Int64(0,55291),new $Int64(0,48897)),new T.ptr(new $Int64(0,55313),new $Int64(0,18393)),new T.ptr(new $Int64(0,55331),new $Int64(0,14643)),new T.ptr(new $Int64(0,55333),new $Int64(0,11536)),new T.ptr(new $Int64(0,55337),new $Int64(0,28805)),new T.ptr(new $Int64(0,55339),new $Int64(0,2866)),new T.ptr(new $Int64(0,55343),new $Int64(0,14132)),new T.ptr(new $Int64(0,55351),new $Int64(0,52959)),new T.ptr(new $Int64(0,55373),new $Int64(0,20598)),new T.ptr(new $Int64(0,55381),new $Int64(0,18340)),new T.ptr(new $Int64(0,55399),new $Int64(0,20164)),new T.ptr(new $Int64(0,55411),new $Int64(0,13963)),new T.ptr(new $Int64(0,55439),new $Int64(0,4265)),new T.ptr(new $Int64(0,55441),new $Int64(0,21323)),new T.ptr(new $Int64(0,55457),new $Int64(0,47427)),new T.ptr(new $Int64(0,55469),new $Int64(0,24424)),new T.ptr(new $Int64(0,55487),new $Int64(0,37960)),new T.ptr(new $Int64(0,55501),new $Int64(0,36954)),new T.ptr(new $Int64(0,55511),new $Int64(0,55090)),new T.ptr(new $Int64(0,55529),new $Int64(0,23757)),new T.ptr(new $Int64(0,55541),new $Int64(0,35575)),new T.ptr(new $Int64(0,55547),new $Int64(0,26875)),new T.ptr(new $Int64(0,55579),new $Int64(0,3045)),new T.ptr(new $Int64(0,55589),new $Int64(0,36361)),new T.ptr(new $Int64(0,55603),new $Int64(0,50906)),new T.ptr(new $Int64(0,55609),new $Int64(0,5366)),new T.ptr(new $Int64(0,55619),new $Int64(0,22587)),new T.ptr(new $Int64(0,55621),new $Int64(0,29477)),new T.ptr(new $Int64(0,55631),new $Int64(0,49985)),new T.ptr(new $Int64(0,55633),new $Int64(0,42972)),new T.ptr(new $Int64(0,55639),new $Int64(0,6022)),new T.ptr(new $Int64(0,55661),new $Int64(0,49442)),new T.ptr(new $Int64(0,55663),new $Int64(0,30414)),new T.ptr(new $Int64(0,55667),new $Int64(0,37388)),new T.ptr(new $Int64(0,55673),new $Int64(0,50159)),new T.ptr(new $Int64(0,55681),new $Int64(0,31706)),new T.ptr(new $Int64(0,55691),new $Int64(0,4557)),new T.ptr(new $Int64(0,55697),new $Int64(0,48912)),new T.ptr(new $Int64(0,55711),new $Int64(0,44009)),new T.ptr(new $Int64(0,55717),new $Int64(0,34504)),new T.ptr(new $Int64(0,55721),new $Int64(0,13118)),new T.ptr(new $Int64(0,55733),new $Int64(0,8984)),new T.ptr(new $Int64(0,55763),new $Int64(0,24183)),new T.ptr(new $Int64(0,55787),new $Int64(0,48169)),new T.ptr(new $Int64(0,55793),new $Int64(0,42018)),new T.ptr(new $Int64(0,55799),new $Int64(0,34840)),new T.ptr(new $Int64(0,55807),new $Int64(0,26880)),new T.ptr(new $Int64(0,55813),new $Int64(0,3384)),new T.ptr(new $Int64(0,55817),new $Int64(0,1230)),new T.ptr(new $Int64(0,55819),new $Int64(0,46665)),new T.ptr(new $Int64(0,55823),new $Int64(0,17266)),new T.ptr(new $Int64(0,55829),new $Int64(0,7739)),new T.ptr(new $Int64(0,55837),new $Int64(0,34913)),new T.ptr(new $Int64(0,55843),new $Int64(0,2814)),new T.ptr(new $Int64(0,55849),new $Int64(0,31333)),new T.ptr(new $Int64(0,55871),new $Int64(0,14758)),new T.ptr(new $Int64(0,55889),new $Int64(0,30276)),new T.ptr(new $Int64(0,55897),new $Int64(0,38999)),new T.ptr(new $Int64(0,55901),new $Int64(0,29886)),new T.ptr(new $Int64(0,55903),new $Int64(0,27306)),new T.ptr(new $Int64(0,55921),new $Int64(0,29217)),new T.ptr(new $Int64(0,55927),new $Int64(0,29452)),new T.ptr(new $Int64(0,55931),new $Int64(0,54529)),new T.ptr(new $Int64(0,55933),new $Int64(0,55357)),new T.ptr(new $Int64(0,55949),new $Int64(0,9656)),new T.ptr(new $Int64(0,55967),new $Int64(0,42929)),new T.ptr(new $Int64(0,55987),new $Int64(0,12117)),new T.ptr(new $Int64(0,55997),new $Int64(0,55301)),new T.ptr(new $Int64(0,56003),new $Int64(0,20147)),new T.ptr(new $Int64(0,56009),new $Int64(0,45840)),new T.ptr(new $Int64(0,56039),new $Int64(0,14724)),new T.ptr(new $Int64(0,56041),new $Int64(0,24409)),new T.ptr(new $Int64(0,56053),new $Int64(0,13702)),new T.ptr(new $Int64(0,56081),new $Int64(0,18245)),new T.ptr(new $Int64(0,56087),new $Int64(0,51986)),new T.ptr(new $Int64(0,56093),new $Int64(0,4447)),new T.ptr(new $Int64(0,56099),new $Int64(0,38530)),new T.ptr(new $Int64(0,56101),new $Int64(0,31749)),new T.ptr(new $Int64(0,56113),new $Int64(0,48500)),new T.ptr(new $Int64(0,56123),new $Int64(0,12509)),new T.ptr(new $Int64(0,56131),new $Int64(0,19808)),new T.ptr(new $Int64(0,56149),new $Int64(0,1127)),new T.ptr(new $Int64(0,56167),new $Int64(0,15214)),new T.ptr(new $Int64(0,56171),new $Int64(0,5438)),new T.ptr(new $Int64(0,56179),new $Int64(0,49267)),new T.ptr(new $Int64(0,56197),new $Int64(0,45861)),new T.ptr(new $Int64(0,56207),new $Int64(0,40474)),new T.ptr(new $Int64(0,56209),new $Int64(0,21259)),new T.ptr(new $Int64(0,56237),new $Int64(0,10481)),new T.ptr(new $Int64(0,56239),new $Int64(0,50359)),new T.ptr(new $Int64(0,56249),new $Int64(0,2487)),new T.ptr(new $Int64(0,56263),new $Int64(0,17196)),new T.ptr(new $Int64(0,56267),new $Int64(0,19129)),new T.ptr(new $Int64(0,56269),new $Int64(0,45931)),new T.ptr(new $Int64(0,56299),new $Int64(0,45379)),new T.ptr(new $Int64(0,56311),new $Int64(0,27044)),new T.ptr(new $Int64(0,56333),new $Int64(0,20730)),new T.ptr(new $Int64(0,56359),new $Int64(0,45174)),new T.ptr(new $Int64(0,56369),new $Int64(0,23328)),new T.ptr(new $Int64(0,56377),new $Int64(0,1768)),new T.ptr(new $Int64(0,56383),new $Int64(0,48325)),new T.ptr(new $Int64(0,56393),new $Int64(0,39146)),new T.ptr(new $Int64(0,56401),new $Int64(0,15607)),new T.ptr(new $Int64(0,56417),new $Int64(0,31058)),new T.ptr(new $Int64(0,56431),new $Int64(0,28060)),new T.ptr(new $Int64(0,56437),new $Int64(0,46226)),new T.ptr(new $Int64(0,56443),new $Int64(0,11415)),new T.ptr(new $Int64(0,56453),new $Int64(0,16770)),new T.ptr(new $Int64(0,56467),new $Int64(0,40539)),new T.ptr(new $Int64(0,56473),new $Int64(0,42831)),new T.ptr(new $Int64(0,56477),new $Int64(0,9623)),new T.ptr(new $Int64(0,56479),new $Int64(0,5323)),new T.ptr(new $Int64(0,56489),new $Int64(0,18073)),new T.ptr(new $Int64(0,56501),new $Int64(0,32013)),new T.ptr(new $Int64(0,56503),new $Int64(0,43517)),new T.ptr(new $Int64(0,56509),new $Int64(0,53748)),new T.ptr(new $Int64(0,56519),new $Int64(0,25578)),new T.ptr(new $Int64(0,56527),new $Int64(0,8)),new T.ptr(new $Int64(0,56531),new $Int64(0,29531)),new T.ptr(new $Int64(0,56533),new $Int64(0,45898)),new T.ptr(new $Int64(0,56543),new $Int64(0,32966)),new T.ptr(new $Int64(0,56569),new $Int64(0,52364)),new T.ptr(new $Int64(0,56591),new $Int64(0,52374)),new T.ptr(new $Int64(0,56597),new $Int64(0,38366)),new T.ptr(new $Int64(0,56599),new $Int64(0,24898)),new T.ptr(new $Int64(0,56611),new $Int64(0,22692)),new T.ptr(new $Int64(0,56629),new $Int64(0,29932)),new T.ptr(new $Int64(0,56633),new $Int64(0,24433)),new T.ptr(new $Int64(0,56659),new $Int64(0,8538)),new T.ptr(new $Int64(0,56663),new $Int64(0,3261)),new T.ptr(new $Int64(0,56671),new $Int64(0,38653)),new T.ptr(new $Int64(0,56681),new $Int64(0,36560)),new T.ptr(new $Int64(0,56687),new $Int64(0,51183)),new T.ptr(new $Int64(0,56701),new $Int64(0,46193)),new T.ptr(new $Int64(0,56711),new $Int64(0,32826)),new T.ptr(new $Int64(0,56713),new $Int64(0,28509)),new T.ptr(new $Int64(0,56731),new $Int64(0,41726)),new T.ptr(new $Int64(0,56737),new $Int64(0,21334)),new T.ptr(new $Int64(0,56747),new $Int64(0,9258)),new T.ptr(new $Int64(0,56767),new $Int64(0,20764)),new T.ptr(new $Int64(0,56773),new $Int64(0,46263)),new T.ptr(new $Int64(0,56779),new $Int64(0,37371)),new T.ptr(new $Int64(0,56783),new $Int64(0,18584)),new T.ptr(new $Int64(0,56807),new $Int64(0,28875)),new T.ptr(new $Int64(0,56809),new $Int64(0,23302)),new T.ptr(new $Int64(0,56813),new $Int64(0,1496)),new T.ptr(new $Int64(0,56821),new $Int64(0,10359)),new T.ptr(new $Int64(0,56827),new $Int64(0,50051)),new T.ptr(new $Int64(0,56843),new $Int64(0,55827)),new T.ptr(new $Int64(0,56857),new $Int64(0,43588)),new T.ptr(new $Int64(0,56873),new $Int64(0,37377)),new T.ptr(new $Int64(0,56891),new $Int64(0,14317)),new T.ptr(new $Int64(0,56893),new $Int64(0,47327)),new T.ptr(new $Int64(0,56897),new $Int64(0,1538)),new T.ptr(new $Int64(0,56909),new $Int64(0,56611)),new T.ptr(new $Int64(0,56911),new $Int64(0,497)),new T.ptr(new $Int64(0,56921),new $Int64(0,48770)),new T.ptr(new $Int64(0,56923),new $Int64(0,40855)),new T.ptr(new $Int64(0,56929),new $Int64(0,2991)),new T.ptr(new $Int64(0,56941),new $Int64(0,31428)),new T.ptr(new $Int64(0,56951),new $Int64(0,39906)),new T.ptr(new $Int64(0,56957),new $Int64(0,17557)),new T.ptr(new $Int64(0,56963),new $Int64(0,3136)),new T.ptr(new $Int64(0,56983),new $Int64(0,23621)),new T.ptr(new $Int64(0,56989),new $Int64(0,27845)),new T.ptr(new $Int64(0,56993),new $Int64(0,44459)),new T.ptr(new $Int64(0,56999),new $Int64(0,7346)),new T.ptr(new $Int64(0,57037),new $Int64(0,36575)),new T.ptr(new $Int64(0,57041),new $Int64(0,19697)),new T.ptr(new $Int64(0,57047),new $Int64(0,17542)),new T.ptr(new $Int64(0,57059),new $Int64(0,713)),new T.ptr(new $Int64(0,57073),new $Int64(0,28804)),new T.ptr(new $Int64(0,57077),new $Int64(0,46161)),new T.ptr(new $Int64(0,57089),new $Int64(0,23683)),new T.ptr(new $Int64(0,57097),new $Int64(0,29512)),new T.ptr(new $Int64(0,57107),new $Int64(0,46171)),new T.ptr(new $Int64(0,57119),new $Int64(0,41941)),new T.ptr(new $Int64(0,57131),new $Int64(0,24879)),new T.ptr(new $Int64(0,57139),new $Int64(0,32071)),new T.ptr(new $Int64(0,57143),new $Int64(0,20814)),new T.ptr(new $Int64(0,57149),new $Int64(0,9178)),new T.ptr(new $Int64(0,57163),new $Int64(0,8534)),new T.ptr(new $Int64(0,57173),new $Int64(0,17041)),new T.ptr(new $Int64(0,57179),new $Int64(0,9854)),new T.ptr(new $Int64(0,57191),new $Int64(0,7565)),new T.ptr(new $Int64(0,57193),new $Int64(0,56804)),new T.ptr(new $Int64(0,57203),new $Int64(0,48123)),new T.ptr(new $Int64(0,57221),new $Int64(0,1038)),new T.ptr(new $Int64(0,57223),new $Int64(0,34239)),new T.ptr(new $Int64(0,57241),new $Int64(0,11036)),new T.ptr(new $Int64(0,57251),new $Int64(0,18068)),new T.ptr(new $Int64(0,57259),new $Int64(0,39975)),new T.ptr(new $Int64(0,57269),new $Int64(0,35057)),new T.ptr(new $Int64(0,57271),new $Int64(0,49704)),new T.ptr(new $Int64(0,57283),new $Int64(0,29611)),new T.ptr(new $Int64(0,57287),new $Int64(0,32610)),new T.ptr(new $Int64(0,57301),new $Int64(0,47197)),new T.ptr(new $Int64(0,57329),new $Int64(0,9121)),new T.ptr(new $Int64(0,57331),new $Int64(0,29968)),new T.ptr(new $Int64(0,57347),new $Int64(0,4830)),new T.ptr(new $Int64(0,57349),new $Int64(0,54948)),new T.ptr(new $Int64(0,57367),new $Int64(0,16456)),new T.ptr(new $Int64(0,57373),new $Int64(0,6459)),new T.ptr(new $Int64(0,57383),new $Int64(0,6570)),new T.ptr(new $Int64(0,57389),new $Int64(0,4974)),new T.ptr(new $Int64(0,57397),new $Int64(0,35143)),new T.ptr(new $Int64(0,57413),new $Int64(0,2028)),new T.ptr(new $Int64(0,57427),new $Int64(0,31418)),new T.ptr(new $Int64(0,57457),new $Int64(0,11732)),new T.ptr(new $Int64(0,57467),new $Int64(0,3003)),new T.ptr(new $Int64(0,57487),new $Int64(0,16835)),new T.ptr(new $Int64(0,57493),new $Int64(0,45701)),new T.ptr(new $Int64(0,57503),new $Int64(0,25828)),new T.ptr(new $Int64(0,57527),new $Int64(0,47114)),new T.ptr(new $Int64(0,57529),new $Int64(0,14172)),new T.ptr(new $Int64(0,57557),new $Int64(0,11992)),new T.ptr(new $Int64(0,57559),new $Int64(0,13590)),new T.ptr(new $Int64(0,57571),new $Int64(0,15370)),new T.ptr(new $Int64(0,57587),new $Int64(0,25906)),new T.ptr(new $Int64(0,57593),new $Int64(0,31061)),new T.ptr(new $Int64(0,57601),new $Int64(0,54263)),new T.ptr(new $Int64(0,57637),new $Int64(0,16116)),new T.ptr(new $Int64(0,57641),new $Int64(0,5278)),new T.ptr(new $Int64(0,57649),new $Int64(0,1877)),new T.ptr(new $Int64(0,57653),new $Int64(0,18048)),new T.ptr(new $Int64(0,57667),new $Int64(0,10061)),new T.ptr(new $Int64(0,57679),new $Int64(0,34823)),new T.ptr(new $Int64(0,57689),new $Int64(0,27044)),new T.ptr(new $Int64(0,57697),new $Int64(0,51898)),new T.ptr(new $Int64(0,57709),new $Int64(0,19895)),new T.ptr(new $Int64(0,57713),new $Int64(0,33086)),new T.ptr(new $Int64(0,57719),new $Int64(0,23238)),new T.ptr(new $Int64(0,57727),new $Int64(0,39627)),new T.ptr(new $Int64(0,57731),new $Int64(0,57322)),new T.ptr(new $Int64(0,57737),new $Int64(0,24171)),new T.ptr(new $Int64(0,57751),new $Int64(0,34428)),new T.ptr(new $Int64(0,57773),new $Int64(0,51445)),new T.ptr(new $Int64(0,57781),new $Int64(0,27851)),new T.ptr(new $Int64(0,57787),new $Int64(0,22436)),new T.ptr(new $Int64(0,57791),new $Int64(0,35645)),new T.ptr(new $Int64(0,57793),new $Int64(0,13983)),new T.ptr(new $Int64(0,57803),new $Int64(0,21372)),new T.ptr(new $Int64(0,57809),new $Int64(0,15319)),new T.ptr(new $Int64(0,57829),new $Int64(0,35939)),new T.ptr(new $Int64(0,57839),new $Int64(0,23633)),new T.ptr(new $Int64(0,57847),new $Int64(0,6365)),new T.ptr(new $Int64(0,57853),new $Int64(0,31076)),new T.ptr(new $Int64(0,57859),new $Int64(0,45885)),new T.ptr(new $Int64(0,57881),new $Int64(0,1368)),new T.ptr(new $Int64(0,57899),new $Int64(0,27851)),new T.ptr(new $Int64(0,57901),new $Int64(0,33751)),new T.ptr(new $Int64(0,57917),new $Int64(0,36715)),new T.ptr(new $Int64(0,57923),new $Int64(0,17713)),new T.ptr(new $Int64(0,57943),new $Int64(0,43642)),new T.ptr(new $Int64(0,57947),new $Int64(0,10380)),new T.ptr(new $Int64(0,57973),new $Int64(0,8264)),new T.ptr(new $Int64(0,57977),new $Int64(0,28905)),new T.ptr(new $Int64(0,57991),new $Int64(0,36367)),new T.ptr(new $Int64(0,58013),new $Int64(0,16480)),new T.ptr(new $Int64(0,58027),new $Int64(0,30355)),new T.ptr(new $Int64(0,58031),new $Int64(0,3618)),new T.ptr(new $Int64(0,58043),new $Int64(0,12705)),new T.ptr(new $Int64(0,58049),new $Int64(0,32142)),new T.ptr(new $Int64(0,58057),new $Int64(0,41608)),new T.ptr(new $Int64(0,58061),new $Int64(0,35159)),new T.ptr(new $Int64(0,58067),new $Int64(0,39464)),new T.ptr(new $Int64(0,58073),new $Int64(0,24068)),new T.ptr(new $Int64(0,58099),new $Int64(0,35686)),new T.ptr(new $Int64(0,58109),new $Int64(0,26225)),new T.ptr(new $Int64(0,58111),new $Int64(0,28489)),new T.ptr(new $Int64(0,58129),new $Int64(0,25121)),new T.ptr(new $Int64(0,58147),new $Int64(0,39712)),new T.ptr(new $Int64(0,58151),new $Int64(0,198)),new T.ptr(new $Int64(0,58153),new $Int64(0,15232)),new T.ptr(new $Int64(0,58169),new $Int64(0,3153)),new T.ptr(new $Int64(0,58171),new $Int64(0,42204)),new T.ptr(new $Int64(0,58189),new $Int64(0,54939)),new T.ptr(new $Int64(0,58193),new $Int64(0,19060)),new T.ptr(new $Int64(0,58199),new $Int64(0,34885)),new T.ptr(new $Int64(0,58207),new $Int64(0,17104)),new T.ptr(new $Int64(0,58211),new $Int64(0,21046)),new T.ptr(new $Int64(0,58217),new $Int64(0,43797)),new T.ptr(new $Int64(0,58229),new $Int64(0,5454)),new T.ptr(new $Int64(0,58231),new $Int64(0,42742)),new T.ptr(new $Int64(0,58237),new $Int64(0,20589)),new T.ptr(new $Int64(0,58243),new $Int64(0,34122)),new T.ptr(new $Int64(0,58271),new $Int64(0,46594)),new T.ptr(new $Int64(0,58309),new $Int64(0,12471)),new T.ptr(new $Int64(0,58313),new $Int64(0,15371)),new T.ptr(new $Int64(0,58321),new $Int64(0,5651)),new T.ptr(new $Int64(0,58337),new $Int64(0,47384)),new T.ptr(new $Int64(0,58363),new $Int64(0,49060)),new T.ptr(new $Int64(0,58367),new $Int64(0,32700)),new T.ptr(new $Int64(0,58369),new $Int64(0,26216)),new T.ptr(new $Int64(0,58379),new $Int64(0,47561)),new T.ptr(new $Int64(0,58391),new $Int64(0,13382)),new T.ptr(new $Int64(0,58393),new $Int64(0,35887)),new T.ptr(new $Int64(0,58403),new $Int64(0,3507)),new T.ptr(new $Int64(0,58411),new $Int64(0,31933)),new T.ptr(new $Int64(0,58417),new $Int64(0,33404)),new T.ptr(new $Int64(0,58427),new $Int64(0,44670)),new T.ptr(new $Int64(0,58439),new $Int64(0,35204)),new T.ptr(new $Int64(0,58441),new $Int64(0,55463)),new T.ptr(new $Int64(0,58451),new $Int64(0,17746)),new T.ptr(new $Int64(0,58453),new $Int64(0,56216)),new T.ptr(new $Int64(0,58477),new $Int64(0,50701)),new T.ptr(new $Int64(0,58481),new $Int64(0,4537)),new T.ptr(new $Int64(0,58511),new $Int64(0,54677)),new T.ptr(new $Int64(0,58537),new $Int64(0,21543)),new T.ptr(new $Int64(0,58543),new $Int64(0,2219)),new T.ptr(new $Int64(0,58549),new $Int64(0,42294)),new T.ptr(new $Int64(0,58567),new $Int64(0,56586)),new T.ptr(new $Int64(0,58573),new $Int64(0,12270)),new T.ptr(new $Int64(0,58579),new $Int64(0,42184)),new T.ptr(new $Int64(0,58601),new $Int64(0,24802)),new T.ptr(new $Int64(0,58603),new $Int64(0,50257)),new T.ptr(new $Int64(0,58613),new $Int64(0,10795)),new T.ptr(new $Int64(0,58631),new $Int64(0,30013)),new T.ptr(new $Int64(0,58657),new $Int64(0,34889)),new T.ptr(new $Int64(0,58661),new $Int64(0,7862)),new T.ptr(new $Int64(0,58679),new $Int64(0,14128)),new T.ptr(new $Int64(0,58687),new $Int64(0,14255)),new T.ptr(new $Int64(0,58693),new $Int64(0,53691)),new T.ptr(new $Int64(0,58699),new $Int64(0,26848)),new T.ptr(new $Int64(0,58711),new $Int64(0,51247)),new T.ptr(new $Int64(0,58727),new $Int64(0,8613)),new T.ptr(new $Int64(0,58733),new $Int64(0,30473)),new T.ptr(new $Int64(0,58741),new $Int64(0,28079)),new T.ptr(new $Int64(0,58757),new $Int64(0,6020)),new T.ptr(new $Int64(0,58763),new $Int64(0,52488)),new T.ptr(new $Int64(0,58771),new $Int64(0,34948)),new T.ptr(new $Int64(0,58787),new $Int64(0,4364)),new T.ptr(new $Int64(0,58789),new $Int64(0,40588)),new T.ptr(new $Int64(0,58831),new $Int64(0,53350)),new T.ptr(new $Int64(0,58889),new $Int64(0,28489)),new T.ptr(new $Int64(0,58897),new $Int64(0,36032)),new T.ptr(new $Int64(0,58901),new $Int64(0,57910)),new T.ptr(new $Int64(0,58907),new $Int64(0,52393)),new T.ptr(new $Int64(0,58909),new $Int64(0,2124)),new T.ptr(new $Int64(0,58913),new $Int64(0,46663)),new T.ptr(new $Int64(0,58921),new $Int64(0,36082)),new T.ptr(new $Int64(0,58937),new $Int64(0,3595)),new T.ptr(new $Int64(0,58943),new $Int64(0,19762)),new T.ptr(new $Int64(0,58963),new $Int64(0,9863)),new T.ptr(new $Int64(0,58967),new $Int64(0,4289)),new T.ptr(new $Int64(0,58979),new $Int64(0,6629)),new T.ptr(new $Int64(0,58991),new $Int64(0,27840)),new T.ptr(new $Int64(0,58997),new $Int64(0,29443)),new T.ptr(new $Int64(0,59009),new $Int64(0,25069)),new T.ptr(new $Int64(0,59011),new $Int64(0,1547)),new T.ptr(new $Int64(0,59021),new $Int64(0,28488)),new T.ptr(new $Int64(0,59023),new $Int64(0,5834)),new T.ptr(new $Int64(0,59029),new $Int64(0,8674)),new T.ptr(new $Int64(0,59051),new $Int64(0,56037)),new T.ptr(new $Int64(0,59053),new $Int64(0,17798)),new T.ptr(new $Int64(0,59063),new $Int64(0,31131)),new T.ptr(new $Int64(0,59069),new $Int64(0,54688)),new T.ptr(new $Int64(0,59077),new $Int64(0,34106)),new T.ptr(new $Int64(0,59083),new $Int64(0,51554)),new T.ptr(new $Int64(0,59093),new $Int64(0,13658)),new T.ptr(new $Int64(0,59107),new $Int64(0,11257)),new T.ptr(new $Int64(0,59113),new $Int64(0,11704)),new T.ptr(new $Int64(0,59119),new $Int64(0,18565)),new T.ptr(new $Int64(0,59123),new $Int64(0,50447)),new T.ptr(new $Int64(0,59141),new $Int64(0,32209)),new T.ptr(new $Int64(0,59149),new $Int64(0,56909)),new T.ptr(new $Int64(0,59159),new $Int64(0,54727)),new T.ptr(new $Int64(0,59167),new $Int64(0,57875)),new T.ptr(new $Int64(0,59183),new $Int64(0,37757)),new T.ptr(new $Int64(0,59197),new $Int64(0,35772)),new T.ptr(new $Int64(0,59207),new $Int64(0,14125)),new T.ptr(new $Int64(0,59209),new $Int64(0,58061)),new T.ptr(new $Int64(0,59219),new $Int64(0,12217)),new T.ptr(new $Int64(0,59221),new $Int64(0,35822)),new T.ptr(new $Int64(0,59233),new $Int64(0,55043)),new T.ptr(new $Int64(0,59239),new $Int64(0,6530)),new T.ptr(new $Int64(0,59243),new $Int64(0,57829)),new T.ptr(new $Int64(0,59263),new $Int64(0,41380)),new T.ptr(new $Int64(0,59273),new $Int64(0,38599)),new T.ptr(new $Int64(0,59281),new $Int64(0,23096)),new T.ptr(new $Int64(0,59333),new $Int64(0,18159)),new T.ptr(new $Int64(0,59341),new $Int64(0,17043)),new T.ptr(new $Int64(0,59351),new $Int64(0,55877)),new T.ptr(new $Int64(0,59357),new $Int64(0,7979)),new T.ptr(new $Int64(0,59359),new $Int64(0,51611)),new T.ptr(new $Int64(0,59369),new $Int64(0,4167)),new T.ptr(new $Int64(0,59377),new $Int64(0,43859)),new T.ptr(new $Int64(0,59387),new $Int64(0,24046)),new T.ptr(new $Int64(0,59393),new $Int64(0,12867)),new T.ptr(new $Int64(0,59399),new $Int64(0,23499)),new T.ptr(new $Int64(0,59407),new $Int64(0,20424)),new T.ptr(new $Int64(0,59417),new $Int64(0,46896)),new T.ptr(new $Int64(0,59419),new $Int64(0,33232)),new T.ptr(new $Int64(0,59441),new $Int64(0,38459)),new T.ptr(new $Int64(0,59443),new $Int64(0,50146)),new T.ptr(new $Int64(0,59447),new $Int64(0,10619)),new T.ptr(new $Int64(0,59453),new $Int64(0,34232)),new T.ptr(new $Int64(0,59467),new $Int64(0,21009)),new T.ptr(new $Int64(0,59471),new $Int64(0,47910)),new T.ptr(new $Int64(0,59473),new $Int64(0,12310)),new T.ptr(new $Int64(0,59497),new $Int64(0,31228)),new T.ptr(new $Int64(0,59509),new $Int64(0,59455)),new T.ptr(new $Int64(0,59513),new $Int64(0,39766)),new T.ptr(new $Int64(0,59539),new $Int64(0,17656)),new T.ptr(new $Int64(0,59557),new $Int64(0,13202)),new T.ptr(new $Int64(0,59561),new $Int64(0,13070)),new T.ptr(new $Int64(0,59567),new $Int64(0,34979)),new T.ptr(new $Int64(0,59581),new $Int64(0,50563)),new T.ptr(new $Int64(0,59611),new $Int64(0,25026)),new T.ptr(new $Int64(0,59617),new $Int64(0,45823)),new T.ptr(new $Int64(0,59621),new $Int64(0,13649)),new T.ptr(new $Int64(0,59627),new $Int64(0,54463)),new T.ptr(new $Int64(0,59629),new $Int64(0,9477)),new T.ptr(new $Int64(0,59651),new $Int64(0,948)),new T.ptr(new $Int64(0,59659),new $Int64(0,56014)),new T.ptr(new $Int64(0,59663),new $Int64(0,20063)),new T.ptr(new $Int64(0,59669),new $Int64(0,57151)),new T.ptr(new $Int64(0,59671),new $Int64(0,26154)),new T.ptr(new $Int64(0,59693),new $Int64(0,56196)),new T.ptr(new $Int64(0,59699),new $Int64(0,40764)),new T.ptr(new $Int64(0,59707),new $Int64(0,40002)),new T.ptr(new $Int64(0,59723),new $Int64(0,56090)),new T.ptr(new $Int64(0,59729),new $Int64(0,28060)),new T.ptr(new $Int64(0,59743),new $Int64(0,6502)),new T.ptr(new $Int64(0,59747),new $Int64(0,48962)),new T.ptr(new $Int64(0,59753),new $Int64(0,22675)),new T.ptr(new $Int64(0,59771),new $Int64(0,24715)),new T.ptr(new $Int64(0,59779),new $Int64(0,2021)),new T.ptr(new $Int64(0,59791),new $Int64(0,37675)),new T.ptr(new $Int64(0,59797),new $Int64(0,7162)),new T.ptr(new $Int64(0,59809),new $Int64(0,48014)),new T.ptr(new $Int64(0,59833),new $Int64(0,54166)),new T.ptr(new $Int64(0,59863),new $Int64(0,50291)),new T.ptr(new $Int64(0,59879),new $Int64(0,2812)),new T.ptr(new $Int64(0,59887),new $Int64(0,28905)),new T.ptr(new $Int64(0,59921),new $Int64(0,17459)),new T.ptr(new $Int64(0,59929),new $Int64(0,4346)),new T.ptr(new $Int64(0,59951),new $Int64(0,59676)),new T.ptr(new $Int64(0,59957),new $Int64(0,38128)),new T.ptr(new $Int64(0,59971),new $Int64(0,32007)),new T.ptr(new $Int64(0,59981),new $Int64(0,28472)),new T.ptr(new $Int64(0,59999),new $Int64(0,40819)),new T.ptr(new $Int64(0,60013),new $Int64(0,35114)),new T.ptr(new $Int64(0,60017),new $Int64(0,32800)),new T.ptr(new $Int64(0,60029),new $Int64(0,18396)),new T.ptr(new $Int64(0,60037),new $Int64(0,16967)),new T.ptr(new $Int64(0,60041),new $Int64(0,58461)),new T.ptr(new $Int64(0,60077),new $Int64(0,58310)),new T.ptr(new $Int64(0,60083),new $Int64(0,43103)),new T.ptr(new $Int64(0,60089),new $Int64(0,1036)),new T.ptr(new $Int64(0,60091),new $Int64(0,41676)),new T.ptr(new $Int64(0,60101),new $Int64(0,35914)),new T.ptr(new $Int64(0,60103),new $Int64(0,27256)),new T.ptr(new $Int64(0,60107),new $Int64(0,24938)),new T.ptr(new $Int64(0,60127),new $Int64(0,35448)),new T.ptr(new $Int64(0,60133),new $Int64(0,9473)),new T.ptr(new $Int64(0,60139),new $Int64(0,31592)),new T.ptr(new $Int64(0,60149),new $Int64(0,28047)),new T.ptr(new $Int64(0,60161),new $Int64(0,22337)),new T.ptr(new $Int64(0,60167),new $Int64(0,3655)),new T.ptr(new $Int64(0,60169),new $Int64(0,276)),new T.ptr(new $Int64(0,60209),new $Int64(0,4647)),new T.ptr(new $Int64(0,60217),new $Int64(0,38163)),new T.ptr(new $Int64(0,60223),new $Int64(0,57452)),new T.ptr(new $Int64(0,60251),new $Int64(0,33280)),new T.ptr(new $Int64(0,60257),new $Int64(0,9635)),new T.ptr(new $Int64(0,60259),new $Int64(0,13475)),new T.ptr(new $Int64(0,60271),new $Int64(0,6427)),new T.ptr(new $Int64(0,60289),new $Int64(0,23826)),new T.ptr(new $Int64(0,60293),new $Int64(0,19537)),new T.ptr(new $Int64(0,60317),new $Int64(0,36730)),new T.ptr(new $Int64(0,60331),new $Int64(0,49979)),new T.ptr(new $Int64(0,60337),new $Int64(0,44327)),new T.ptr(new $Int64(0,60343),new $Int64(0,21216)),new T.ptr(new $Int64(0,60353),new $Int64(0,12050)),new T.ptr(new $Int64(0,60373),new $Int64(0,10898)),new T.ptr(new $Int64(0,60383),new $Int64(0,28509)),new T.ptr(new $Int64(0,60397),new $Int64(0,3674)),new T.ptr(new $Int64(0,60413),new $Int64(0,19938)),new T.ptr(new $Int64(0,60427),new $Int64(0,3540)),new T.ptr(new $Int64(0,60443),new $Int64(0,44267)),new T.ptr(new $Int64(0,60449),new $Int64(0,33954)),new T.ptr(new $Int64(0,60457),new $Int64(0,40127)),new T.ptr(new $Int64(0,60493),new $Int64(0,5239)),new T.ptr(new $Int64(0,60497),new $Int64(0,50045)),new T.ptr(new $Int64(0,60509),new $Int64(0,35106)),new T.ptr(new $Int64(0,60521),new $Int64(0,57961)),new T.ptr(new $Int64(0,60527),new $Int64(0,35059)),new T.ptr(new $Int64(0,60539),new $Int64(0,9163)),new T.ptr(new $Int64(0,60589),new $Int64(0,46673)),new T.ptr(new $Int64(0,60601),new $Int64(0,26940)),new T.ptr(new $Int64(0,60607),new $Int64(0,20110)),new T.ptr(new $Int64(0,60611),new $Int64(0,55)),new T.ptr(new $Int64(0,60617),new $Int64(0,1578)),new T.ptr(new $Int64(0,60623),new $Int64(0,28804)),new T.ptr(new $Int64(0,60631),new $Int64(0,56012)),new T.ptr(new $Int64(0,60637),new $Int64(0,48394)),new T.ptr(new $Int64(0,60647),new $Int64(0,48094)),new T.ptr(new $Int64(0,60649),new $Int64(0,11790)),new T.ptr(new $Int64(0,60659),new $Int64(0,22937)),new T.ptr(new $Int64(0,60661),new $Int64(0,757)),new T.ptr(new $Int64(0,60679),new $Int64(0,21419)),new T.ptr(new $Int64(0,60689),new $Int64(0,1592)),new T.ptr(new $Int64(0,60703),new $Int64(0,12792)),new T.ptr(new $Int64(0,60719),new $Int64(0,20685)),new T.ptr(new $Int64(0,60727),new $Int64(0,47571)),new T.ptr(new $Int64(0,60733),new $Int64(0,36142)),new T.ptr(new $Int64(0,60737),new $Int64(0,40596)),new T.ptr(new $Int64(0,60757),new $Int64(0,41449)),new T.ptr(new $Int64(0,60761),new $Int64(0,7931)),new T.ptr(new $Int64(0,60763),new $Int64(0,52595)),new T.ptr(new $Int64(0,60773),new $Int64(0,22971)),new T.ptr(new $Int64(0,60779),new $Int64(0,43323)),new T.ptr(new $Int64(0,60793),new $Int64(0,9911)),new T.ptr(new $Int64(0,60811),new $Int64(0,16721)),new T.ptr(new $Int64(0,60821),new $Int64(0,55666)),new T.ptr(new $Int64(0,60859),new $Int64(0,19385)),new T.ptr(new $Int64(0,60869),new $Int64(0,37808)),new T.ptr(new $Int64(0,60887),new $Int64(0,4307)),new T.ptr(new $Int64(0,60889),new $Int64(0,33309)),new T.ptr(new $Int64(0,60899),new $Int64(0,24062)),new T.ptr(new $Int64(0,60901),new $Int64(0,48337)),new T.ptr(new $Int64(0,60913),new $Int64(0,46381)),new T.ptr(new $Int64(0,60917),new $Int64(0,16100)),new T.ptr(new $Int64(0,60919),new $Int64(0,56132)),new T.ptr(new $Int64(0,60923),new $Int64(0,24108)),new T.ptr(new $Int64(0,60937),new $Int64(0,22061)),new T.ptr(new $Int64(0,60943),new $Int64(0,39996)),new T.ptr(new $Int64(0,60953),new $Int64(0,1331)),new T.ptr(new $Int64(0,60961),new $Int64(0,4567)),new T.ptr(new $Int64(0,61001),new $Int64(0,41845)),new T.ptr(new $Int64(0,61007),new $Int64(0,48928)),new T.ptr(new $Int64(0,61027),new $Int64(0,46922)),new T.ptr(new $Int64(0,61031),new $Int64(0,7951)),new T.ptr(new $Int64(0,61043),new $Int64(0,25802)),new T.ptr(new $Int64(0,61051),new $Int64(0,4528)),new T.ptr(new $Int64(0,61057),new $Int64(0,28875)),new T.ptr(new $Int64(0,61091),new $Int64(0,52114)),new T.ptr(new $Int64(0,61099),new $Int64(0,31608)),new T.ptr(new $Int64(0,61121),new $Int64(0,18175)),new T.ptr(new $Int64(0,61129),new $Int64(0,32280)),new T.ptr(new $Int64(0,61141),new $Int64(0,54269)),new T.ptr(new $Int64(0,61151),new $Int64(0,57816)),new T.ptr(new $Int64(0,61153),new $Int64(0,56705)),new T.ptr(new $Int64(0,61169),new $Int64(0,46580)),new T.ptr(new $Int64(0,61211),new $Int64(0,59004)),new T.ptr(new $Int64(0,61223),new $Int64(0,23768)),new T.ptr(new $Int64(0,61231),new $Int64(0,31609)),new T.ptr(new $Int64(0,61253),new $Int64(0,9935)),new T.ptr(new $Int64(0,61261),new $Int64(0,27570)),new T.ptr(new $Int64(0,61283),new $Int64(0,10598)),new T.ptr(new $Int64(0,61291),new $Int64(0,20588)),new T.ptr(new $Int64(0,61297),new $Int64(0,2106)),new T.ptr(new $Int64(0,61331),new $Int64(0,18988)),new T.ptr(new $Int64(0,61333),new $Int64(0,56780)),new T.ptr(new $Int64(0,61339),new $Int64(0,21989)),new T.ptr(new $Int64(0,61343),new $Int64(0,4327)),new T.ptr(new $Int64(0,61357),new $Int64(0,6552)),new T.ptr(new $Int64(0,61363),new $Int64(0,55076)),new T.ptr(new $Int64(0,61379),new $Int64(0,32039)),new T.ptr(new $Int64(0,61381),new $Int64(0,51600)),new T.ptr(new $Int64(0,61403),new $Int64(0,27181)),new T.ptr(new $Int64(0,61409),new $Int64(0,7807)),new T.ptr(new $Int64(0,61417),new $Int64(0,24689)),new T.ptr(new $Int64(0,61441),new $Int64(0,46648)),new T.ptr(new $Int64(0,61463),new $Int64(0,24905)),new T.ptr(new $Int64(0,61469),new $Int64(0,8398)),new T.ptr(new $Int64(0,61471),new $Int64(0,50340)),new T.ptr(new $Int64(0,61483),new $Int64(0,58869)),new T.ptr(new $Int64(0,61487),new $Int64(0,10492)),new T.ptr(new $Int64(0,61493),new $Int64(0,14397)),new T.ptr(new $Int64(0,61507),new $Int64(0,50179)),new T.ptr(new $Int64(0,61511),new $Int64(0,60430)),new T.ptr(new $Int64(0,61519),new $Int64(0,35482)),new T.ptr(new $Int64(0,61543),new $Int64(0,51272)),new T.ptr(new $Int64(0,61547),new $Int64(0,48654)),new T.ptr(new $Int64(0,61553),new $Int64(0,2082)),new T.ptr(new $Int64(0,61559),new $Int64(0,308)),new T.ptr(new $Int64(0,61561),new $Int64(0,60023)),new T.ptr(new $Int64(0,61583),new $Int64(0,38919)),new T.ptr(new $Int64(0,61603),new $Int64(0,4212)),new T.ptr(new $Int64(0,61609),new $Int64(0,4037)),new T.ptr(new $Int64(0,61613),new $Int64(0,12517)),new T.ptr(new $Int64(0,61627),new $Int64(0,41904)),new T.ptr(new $Int64(0,61631),new $Int64(0,8768)),new T.ptr(new $Int64(0,61637),new $Int64(0,2990)),new T.ptr(new $Int64(0,61643),new $Int64(0,8197)),new T.ptr(new $Int64(0,61651),new $Int64(0,30748)),new T.ptr(new $Int64(0,61657),new $Int64(0,41909)),new T.ptr(new $Int64(0,61667),new $Int64(0,2360)),new T.ptr(new $Int64(0,61673),new $Int64(0,13669)),new T.ptr(new $Int64(0,61681),new $Int64(0,24524)),new T.ptr(new $Int64(0,61687),new $Int64(0,44379)),new T.ptr(new $Int64(0,61703),new $Int64(0,26420)),new T.ptr(new $Int64(0,61717),new $Int64(0,58011)),new T.ptr(new $Int64(0,61723),new $Int64(0,10448)),new T.ptr(new $Int64(0,61729),new $Int64(0,47582)),new T.ptr(new $Int64(0,61751),new $Int64(0,34016)),new T.ptr(new $Int64(0,61757),new $Int64(0,9844)),new T.ptr(new $Int64(0,61781),new $Int64(0,1059)),new T.ptr(new $Int64(0,61813),new $Int64(0,1957)),new T.ptr(new $Int64(0,61819),new $Int64(0,13021)),new T.ptr(new $Int64(0,61837),new $Int64(0,4750)),new T.ptr(new $Int64(0,61843),new $Int64(0,10839)),new T.ptr(new $Int64(0,61861),new $Int64(0,14306)),new T.ptr(new $Int64(0,61871),new $Int64(0,26665)),new T.ptr(new $Int64(0,61879),new $Int64(0,7501)),new T.ptr(new $Int64(0,61909),new $Int64(0,39526)),new T.ptr(new $Int64(0,61927),new $Int64(0,41644)),new T.ptr(new $Int64(0,61933),new $Int64(0,4745)),new T.ptr(new $Int64(0,61949),new $Int64(0,17004)),new T.ptr(new $Int64(0,61961),new $Int64(0,37923)),new T.ptr(new $Int64(0,61967),new $Int64(0,45736)),new T.ptr(new $Int64(0,61979),new $Int64(0,53404)),new T.ptr(new $Int64(0,61981),new $Int64(0,16439)),new T.ptr(new $Int64(0,61987),new $Int64(0,53543)),new T.ptr(new $Int64(0,61991),new $Int64(0,35201)),new T.ptr(new $Int64(0,62003),new $Int64(0,33331)),new T.ptr(new $Int64(0,62011),new $Int64(0,34025)),new T.ptr(new $Int64(0,62017),new $Int64(0,40357)),new T.ptr(new $Int64(0,62039),new $Int64(0,4091)),new T.ptr(new $Int64(0,62047),new $Int64(0,36332)),new T.ptr(new $Int64(0,62053),new $Int64(0,19880)),new T.ptr(new $Int64(0,62057),new $Int64(0,44888)),new T.ptr(new $Int64(0,62071),new $Int64(0,27702)),new T.ptr(new $Int64(0,62081),new $Int64(0,599)),new T.ptr(new $Int64(0,62099),new $Int64(0,14238)),new T.ptr(new $Int64(0,62119),new $Int64(0,890)),new T.ptr(new $Int64(0,62129),new $Int64(0,23167)),new T.ptr(new $Int64(0,62131),new $Int64(0,15)),new T.ptr(new $Int64(0,62137),new $Int64(0,31248)),new T.ptr(new $Int64(0,62141),new $Int64(0,31608)),new T.ptr(new $Int64(0,62143),new $Int64(0,31161)),new T.ptr(new $Int64(0,62171),new $Int64(0,61420)),new T.ptr(new $Int64(0,62189),new $Int64(0,54346)),new T.ptr(new $Int64(0,62191),new $Int64(0,42915)),new T.ptr(new $Int64(0,62201),new $Int64(0,43041)),new T.ptr(new $Int64(0,62207),new $Int64(0,1666)),new T.ptr(new $Int64(0,62213),new $Int64(0,16803)),new T.ptr(new $Int64(0,62219),new $Int64(0,25951)),new T.ptr(new $Int64(0,62233),new $Int64(0,53541)),new T.ptr(new $Int64(0,62273),new $Int64(0,55421)),new T.ptr(new $Int64(0,62297),new $Int64(0,46493)),new T.ptr(new $Int64(0,62299),new $Int64(0,11255)),new T.ptr(new $Int64(0,62303),new $Int64(0,24374)),new T.ptr(new $Int64(0,62311),new $Int64(0,45799)),new T.ptr(new $Int64(0,62323),new $Int64(0,30473)),new T.ptr(new $Int64(0,62327),new $Int64(0,47247)),new T.ptr(new $Int64(0,62347),new $Int64(0,6829)),new T.ptr(new $Int64(0,62351),new $Int64(0,35530)),new T.ptr(new $Int64(0,62383),new $Int64(0,36267)),new T.ptr(new $Int64(0,62401),new $Int64(0,37278)),new T.ptr(new $Int64(0,62417),new $Int64(0,39100)),new T.ptr(new $Int64(0,62423),new $Int64(0,6274)),new T.ptr(new $Int64(0,62459),new $Int64(0,27923)),new T.ptr(new $Int64(0,62467),new $Int64(0,42912)),new T.ptr(new $Int64(0,62473),new $Int64(0,16738)),new T.ptr(new $Int64(0,62477),new $Int64(0,55459)),new T.ptr(new $Int64(0,62483),new $Int64(0,45012)),new T.ptr(new $Int64(0,62497),new $Int64(0,42917)),new T.ptr(new $Int64(0,62501),new $Int64(0,47151)),new T.ptr(new $Int64(0,62507),new $Int64(0,44792)),new T.ptr(new $Int64(0,62533),new $Int64(0,34402)),new T.ptr(new $Int64(0,62539),new $Int64(0,60155)),new T.ptr(new $Int64(0,62549),new $Int64(0,45850)),new T.ptr(new $Int64(0,62563),new $Int64(0,49528)),new T.ptr(new $Int64(0,62581),new $Int64(0,58423)),new T.ptr(new $Int64(0,62591),new $Int64(0,47172)),new T.ptr(new $Int64(0,62597),new $Int64(0,4725)),new T.ptr(new $Int64(0,62603),new $Int64(0,14266)),new T.ptr(new $Int64(0,62617),new $Int64(0,34492)),new T.ptr(new $Int64(0,62627),new $Int64(0,12845)),new T.ptr(new $Int64(0,62633),new $Int64(0,44291)),new T.ptr(new $Int64(0,62639),new $Int64(0,36420)),new T.ptr(new $Int64(0,62653),new $Int64(0,59379)),new T.ptr(new $Int64(0,62659),new $Int64(0,25905)),new T.ptr(new $Int64(0,62683),new $Int64(0,466)),new T.ptr(new $Int64(0,62687),new $Int64(0,49837)),new T.ptr(new $Int64(0,62701),new $Int64(0,32039)),new T.ptr(new $Int64(0,62723),new $Int64(0,24319)),new T.ptr(new $Int64(0,62731),new $Int64(0,57294)),new T.ptr(new $Int64(0,62743),new $Int64(0,58101)),new T.ptr(new $Int64(0,62753),new $Int64(0,44752)),new T.ptr(new $Int64(0,62761),new $Int64(0,54547)),new T.ptr(new $Int64(0,62773),new $Int64(0,57486)),new T.ptr(new $Int64(0,62791),new $Int64(0,52801)),new T.ptr(new $Int64(0,62801),new $Int64(0,56443)),new T.ptr(new $Int64(0,62819),new $Int64(0,11077)),new T.ptr(new $Int64(0,62827),new $Int64(0,20878)),new T.ptr(new $Int64(0,62851),new $Int64(0,24377)),new T.ptr(new $Int64(0,62861),new $Int64(0,18975)),new T.ptr(new $Int64(0,62869),new $Int64(0,43028)),new T.ptr(new $Int64(0,62873),new $Int64(0,62236)),new T.ptr(new $Int64(0,62897),new $Int64(0,25263)),new T.ptr(new $Int64(0,62903),new $Int64(0,36297)),new T.ptr(new $Int64(0,62921),new $Int64(0,56928)),new T.ptr(new $Int64(0,62927),new $Int64(0,428)),new T.ptr(new $Int64(0,62929),new $Int64(0,54605)),new T.ptr(new $Int64(0,62939),new $Int64(0,9149)),new T.ptr(new $Int64(0,62969),new $Int64(0,12912)),new T.ptr(new $Int64(0,62971),new $Int64(0,52858)),new T.ptr(new $Int64(0,62981),new $Int64(0,27631)),new T.ptr(new $Int64(0,62983),new $Int64(0,55366)),new T.ptr(new $Int64(0,62987),new $Int64(0,8640)),new T.ptr(new $Int64(0,62989),new $Int64(0,35559)),new T.ptr(new $Int64(0,63029),new $Int64(0,34805)),new T.ptr(new $Int64(0,63031),new $Int64(0,36883)),new T.ptr(new $Int64(0,63059),new $Int64(0,16159)),new T.ptr(new $Int64(0,63067),new $Int64(0,56366)),new T.ptr(new $Int64(0,63073),new $Int64(0,43678)),new T.ptr(new $Int64(0,63079),new $Int64(0,41297)),new T.ptr(new $Int64(0,63097),new $Int64(0,37719)),new T.ptr(new $Int64(0,63103),new $Int64(0,4220)),new T.ptr(new $Int64(0,63113),new $Int64(0,22626)),new T.ptr(new $Int64(0,63127),new $Int64(0,13883)),new T.ptr(new $Int64(0,63131),new $Int64(0,32285)),new T.ptr(new $Int64(0,63149),new $Int64(0,32474)),new T.ptr(new $Int64(0,63179),new $Int64(0,28308)),new T.ptr(new $Int64(0,63197),new $Int64(0,17839)),new T.ptr(new $Int64(0,63199),new $Int64(0,9050)),new T.ptr(new $Int64(0,63211),new $Int64(0,331)),new T.ptr(new $Int64(0,63241),new $Int64(0,21859)),new T.ptr(new $Int64(0,63247),new $Int64(0,21681)),new T.ptr(new $Int64(0,63277),new $Int64(0,1131)),new T.ptr(new $Int64(0,63281),new $Int64(0,54725)),new T.ptr(new $Int64(0,63299),new $Int64(0,51759)),new T.ptr(new $Int64(0,63311),new $Int64(0,37342)),new T.ptr(new $Int64(0,63313),new $Int64(0,31131)),new T.ptr(new $Int64(0,63317),new $Int64(0,49563)),new T.ptr(new $Int64(0,63331),new $Int64(0,38229)),new T.ptr(new $Int64(0,63337),new $Int64(0,42608)),new T.ptr(new $Int64(0,63347),new $Int64(0,11727)),new T.ptr(new $Int64(0,63353),new $Int64(0,40180)),new T.ptr(new $Int64(0,63361),new $Int64(0,57094)),new T.ptr(new $Int64(0,63367),new $Int64(0,43372)),new T.ptr(new $Int64(0,63377),new $Int64(0,43057)),new T.ptr(new $Int64(0,63389),new $Int64(0,16766)),new T.ptr(new $Int64(0,63391),new $Int64(0,10876)),new T.ptr(new $Int64(0,63397),new $Int64(0,36980)),new T.ptr(new $Int64(0,63409),new $Int64(0,26706)),new T.ptr(new $Int64(0,63419),new $Int64(0,11753)),new T.ptr(new $Int64(0,63421),new $Int64(0,35258)),new T.ptr(new $Int64(0,63439),new $Int64(0,22520)),new T.ptr(new $Int64(0,63443),new $Int64(0,34422)),new T.ptr(new $Int64(0,63463),new $Int64(0,47863)),new T.ptr(new $Int64(0,63467),new $Int64(0,46748)),new T.ptr(new $Int64(0,63473),new $Int64(0,38227)),new T.ptr(new $Int64(0,63487),new $Int64(0,36097)),new T.ptr(new $Int64(0,63493),new $Int64(0,53515)),new T.ptr(new $Int64(0,63499),new $Int64(0,60000)),new T.ptr(new $Int64(0,63521),new $Int64(0,35578)),new T.ptr(new $Int64(0,63527),new $Int64(0,34512)),new T.ptr(new $Int64(0,63533),new $Int64(0,23443)),new T.ptr(new $Int64(0,63541),new $Int64(0,21804)),new T.ptr(new $Int64(0,63559),new $Int64(0,59263)),new T.ptr(new $Int64(0,63577),new $Int64(0,26510)),new T.ptr(new $Int64(0,63587),new $Int64(0,11962)),new T.ptr(new $Int64(0,63589),new $Int64(0,30371)),new T.ptr(new $Int64(0,63599),new $Int64(0,43840)),new T.ptr(new $Int64(0,63601),new $Int64(0,34818)),new T.ptr(new $Int64(0,63607),new $Int64(0,5855)),new T.ptr(new $Int64(0,63611),new $Int64(0,3108)),new T.ptr(new $Int64(0,63617),new $Int64(0,14621)),new T.ptr(new $Int64(0,63629),new $Int64(0,29479)),new T.ptr(new $Int64(0,63647),new $Int64(0,15375)),new T.ptr(new $Int64(0,63649),new $Int64(0,16697)),new T.ptr(new $Int64(0,63659),new $Int64(0,29477)),new T.ptr(new $Int64(0,63667),new $Int64(0,44754)),new T.ptr(new $Int64(0,63671),new $Int64(0,43279)),new T.ptr(new $Int64(0,63689),new $Int64(0,32020)),new T.ptr(new $Int64(0,63691),new $Int64(0,3324)),new T.ptr(new $Int64(0,63697),new $Int64(0,19624)),new T.ptr(new $Int64(0,63703),new $Int64(0,28634)),new T.ptr(new $Int64(0,63709),new $Int64(0,33356)),new T.ptr(new $Int64(0,63719),new $Int64(0,46087)),new T.ptr(new $Int64(0,63727),new $Int64(0,19490)),new T.ptr(new $Int64(0,63737),new $Int64(0,9109)),new T.ptr(new $Int64(0,63743),new $Int64(0,61744)),new T.ptr(new $Int64(0,63761),new $Int64(0,12654)),new T.ptr(new $Int64(0,63773),new $Int64(0,19709)),new T.ptr(new $Int64(0,63781),new $Int64(0,26474)),new T.ptr(new $Int64(0,63793),new $Int64(0,59854)),new T.ptr(new $Int64(0,63799),new $Int64(0,25006)),new T.ptr(new $Int64(0,63803),new $Int64(0,3895)),new T.ptr(new $Int64(0,63809),new $Int64(0,33164)),new T.ptr(new $Int64(0,63823),new $Int64(0,10134)),new T.ptr(new $Int64(0,63839),new $Int64(0,54911)),new T.ptr(new $Int64(0,63841),new $Int64(0,41072)),new T.ptr(new $Int64(0,63853),new $Int64(0,42145)),new T.ptr(new $Int64(0,63857),new $Int64(0,44340)),new T.ptr(new $Int64(0,63863),new $Int64(0,932)),new T.ptr(new $Int64(0,63901),new $Int64(0,51931)),new T.ptr(new $Int64(0,63907),new $Int64(0,46838)),new T.ptr(new $Int64(0,63913),new $Int64(0,17890)),new T.ptr(new $Int64(0,63929),new $Int64(0,29139)),new T.ptr(new $Int64(0,63949),new $Int64(0,57758)),new T.ptr(new $Int64(0,63977),new $Int64(0,15982)),new T.ptr(new $Int64(0,63997),new $Int64(0,49733)),new T.ptr(new $Int64(0,64007),new $Int64(0,8684)),new T.ptr(new $Int64(0,64013),new $Int64(0,21254)),new T.ptr(new $Int64(0,64019),new $Int64(0,27789)),new T.ptr(new $Int64(0,64033),new $Int64(0,4682)),new T.ptr(new $Int64(0,64037),new $Int64(0,13598)),new T.ptr(new $Int64(0,64063),new $Int64(0,17084)),new T.ptr(new $Int64(0,64067),new $Int64(0,48406)),new T.ptr(new $Int64(0,64081),new $Int64(0,47244)),new T.ptr(new $Int64(0,64091),new $Int64(0,59027)),new T.ptr(new $Int64(0,64109),new $Int64(0,32007)),new T.ptr(new $Int64(0,64123),new $Int64(0,797)),new T.ptr(new $Int64(0,64151),new $Int64(0,56679)),new T.ptr(new $Int64(0,64153),new $Int64(0,14945)),new T.ptr(new $Int64(0,64157),new $Int64(0,9842)),new T.ptr(new $Int64(0,64171),new $Int64(0,53096)),new T.ptr(new $Int64(0,64187),new $Int64(0,661)),new T.ptr(new $Int64(0,64189),new $Int64(0,1609)),new T.ptr(new $Int64(0,64217),new $Int64(0,32850)),new T.ptr(new $Int64(0,64223),new $Int64(0,19415)),new T.ptr(new $Int64(0,64231),new $Int64(0,29436)),new T.ptr(new $Int64(0,64237),new $Int64(0,56786)),new T.ptr(new $Int64(0,64271),new $Int64(0,28213)),new T.ptr(new $Int64(0,64279),new $Int64(0,62824)),new T.ptr(new $Int64(0,64283),new $Int64(0,24089)),new T.ptr(new $Int64(0,64301),new $Int64(0,10545)),new T.ptr(new $Int64(0,64303),new $Int64(0,62886)),new T.ptr(new $Int64(0,64319),new $Int64(0,26602)),new T.ptr(new $Int64(0,64327),new $Int64(0,15882)),new T.ptr(new $Int64(0,64333),new $Int64(0,8785)),new T.ptr(new $Int64(0,64373),new $Int64(0,7097)),new T.ptr(new $Int64(0,64381),new $Int64(0,42352)),new T.ptr(new $Int64(0,64399),new $Int64(0,49238)),new T.ptr(new $Int64(0,64403),new $Int64(0,24520)),new T.ptr(new $Int64(0,64433),new $Int64(0,20267)),new T.ptr(new $Int64(0,64439),new $Int64(0,27746)),new T.ptr(new $Int64(0,64451),new $Int64(0,21628)),new T.ptr(new $Int64(0,64453),new $Int64(0,21164)),new T.ptr(new $Int64(0,64483),new $Int64(0,26891)),new T.ptr(new $Int64(0,64489),new $Int64(0,6545)),new T.ptr(new $Int64(0,64499),new $Int64(0,30317)),new T.ptr(new $Int64(0,64513),new $Int64(0,22376)),new T.ptr(new $Int64(0,64553),new $Int64(0,41328)),new T.ptr(new $Int64(0,64567),new $Int64(0,9362)),new T.ptr(new $Int64(0,64577),new $Int64(0,3810)),new T.ptr(new $Int64(0,64579),new $Int64(0,23215)),new T.ptr(new $Int64(0,64591),new $Int64(0,36957)),new T.ptr(new $Int64(0,64601),new $Int64(0,38119)),new T.ptr(new $Int64(0,64609),new $Int64(0,490)),new T.ptr(new $Int64(0,64613),new $Int64(0,63797)),new T.ptr(new $Int64(0,64621),new $Int64(0,51225)),new T.ptr(new $Int64(0,64627),new $Int64(0,54403)),new T.ptr(new $Int64(0,64633),new $Int64(0,20416)),new T.ptr(new $Int64(0,64661),new $Int64(0,25655)),new T.ptr(new $Int64(0,64663),new $Int64(0,9363)),new T.ptr(new $Int64(0,64667),new $Int64(0,18367)),new T.ptr(new $Int64(0,64679),new $Int64(0,39803)),new T.ptr(new $Int64(0,64693),new $Int64(0,51295)),new T.ptr(new $Int64(0,64709),new $Int64(0,48403)),new T.ptr(new $Int64(0,64717),new $Int64(0,1480)),new T.ptr(new $Int64(0,64747),new $Int64(0,40662)),new T.ptr(new $Int64(0,64763),new $Int64(0,42255)),new T.ptr(new $Int64(0,64781),new $Int64(0,61426)),new T.ptr(new $Int64(0,64783),new $Int64(0,31061)),new T.ptr(new $Int64(0,64793),new $Int64(0,40446)),new T.ptr(new $Int64(0,64811),new $Int64(0,22720)),new T.ptr(new $Int64(0,64817),new $Int64(0,35229)),new T.ptr(new $Int64(0,64849),new $Int64(0,11246)),new T.ptr(new $Int64(0,64853),new $Int64(0,11102)),new T.ptr(new $Int64(0,64871),new $Int64(0,43317)),new T.ptr(new $Int64(0,64877),new $Int64(0,12869)),new T.ptr(new $Int64(0,64879),new $Int64(0,56929)),new T.ptr(new $Int64(0,64891),new $Int64(0,54340)),new T.ptr(new $Int64(0,64901),new $Int64(0,62642)),new T.ptr(new $Int64(0,64919),new $Int64(0,61158)),new T.ptr(new $Int64(0,64921),new $Int64(0,2010)),new T.ptr(new $Int64(0,64927),new $Int64(0,49499)),new T.ptr(new $Int64(0,64937),new $Int64(0,12070)),new T.ptr(new $Int64(0,64951),new $Int64(0,26327)),new T.ptr(new $Int64(0,64969),new $Int64(0,20613)),new T.ptr(new $Int64(0,64997),new $Int64(0,40424)),new T.ptr(new $Int64(0,65003),new $Int64(0,3189)),new T.ptr(new $Int64(0,65011),new $Int64(0,36970)),new T.ptr(new $Int64(0,65027),new $Int64(0,41141)),new T.ptr(new $Int64(0,65029),new $Int64(0,16182)),new T.ptr(new $Int64(0,65033),new $Int64(0,23964)),new T.ptr(new $Int64(0,65053),new $Int64(0,53985)),new T.ptr(new $Int64(0,65063),new $Int64(0,50153)),new T.ptr(new $Int64(0,65071),new $Int64(0,30276)),new T.ptr(new $Int64(0,65089),new $Int64(0,1469)),new T.ptr(new $Int64(0,65099),new $Int64(0,24811)),new T.ptr(new $Int64(0,65101),new $Int64(0,43476)),new T.ptr(new $Int64(0,65111),new $Int64(0,57267)),new T.ptr(new $Int64(0,65119),new $Int64(0,22661)),new T.ptr(new $Int64(0,65123),new $Int64(0,42620)),new T.ptr(new $Int64(0,65129),new $Int64(0,212)),new T.ptr(new $Int64(0,65141),new $Int64(0,64891)),new T.ptr(new $Int64(0,65147),new $Int64(0,45252)),new T.ptr(new $Int64(0,65167),new $Int64(0,64395)),new T.ptr(new $Int64(0,65171),new $Int64(0,18419)),new T.ptr(new $Int64(0,65173),new $Int64(0,34422)),new T.ptr(new $Int64(0,65179),new $Int64(0,33328)),new T.ptr(new $Int64(0,65183),new $Int64(0,58255)),new T.ptr(new $Int64(0,65203),new $Int64(0,10060)),new T.ptr(new $Int64(0,65213),new $Int64(0,51425)),new T.ptr(new $Int64(0,65239),new $Int64(0,5171)),new T.ptr(new $Int64(0,65257),new $Int64(0,34512)),new T.ptr(new $Int64(0,65267),new $Int64(0,54268)),new T.ptr(new $Int64(0,65269),new $Int64(0,55364)),new T.ptr(new $Int64(0,65287),new $Int64(0,35229)),new T.ptr(new $Int64(0,65293),new $Int64(0,56141)),new T.ptr(new $Int64(0,65309),new $Int64(0,49439)),new T.ptr(new $Int64(0,65323),new $Int64(0,16278)),new T.ptr(new $Int64(0,65327),new $Int64(0,15324)),new T.ptr(new $Int64(0,65353),new $Int64(0,11242)),new T.ptr(new $Int64(0,65357),new $Int64(0,5978)),new T.ptr(new $Int64(0,65371),new $Int64(0,63297)),new T.ptr(new $Int64(0,65381),new $Int64(0,16078)),new T.ptr(new $Int64(0,65393),new $Int64(0,62444)),new T.ptr(new $Int64(0,65407),new $Int64(0,52936)),new T.ptr(new $Int64(0,65413),new $Int64(0,58466)),new T.ptr(new $Int64(0,65419),new $Int64(0,32209)),new T.ptr(new $Int64(0,65423),new $Int64(0,22196)),new T.ptr(new $Int64(0,65437),new $Int64(0,8099)),new T.ptr(new $Int64(0,65447),new $Int64(0,52162)),new T.ptr(new $Int64(0,65449),new $Int64(0,65030)),new T.ptr(new $Int64(0,65479),new $Int64(0,23375)),new T.ptr(new $Int64(0,65497),new $Int64(0,39350)),new T.ptr(new $Int64(0,65519),new $Int64(0,53607)),new T.ptr(new $Int64(0,65521),new $Int64(0,59564))]);U=120120;Y=A.NewInt(new $Int64(0,1));}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["crypto/rand"]=(function(){var $pkg={},$init,A,B,C,D,F,N,P,K,E;A=$packages["errors"];B=$packages["github.com/gopherjs/gopherjs/js"];C=$packages["io"];D=$packages["math/big"];F=$pkg.rngReader=$newType(0,$kindStruct,"rand.rngReader",true,"crypto/rand",false,function(){this.$val=this;if(arguments.length===0){return;}});N=$sliceType($Uint8);P=$ptrType(F);E=function(){$pkg.Reader=new F.ptr();};F.ptr.prototype.Read=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c=$ifaceNil;d=this;e=a.$array;f=$parseInt(a.$offset)>>0;g=$global.crypto;if(g===undefined){g=$global.msCrypto;}if(!(g===undefined)){if(!(g.getRandomValues===undefined)){b=a.$length;if(b>65536){b=65536;}g.getRandomValues(e.subarray(f,f+b>>0));h=b;i=$ifaceNil;b=h;c=i;return[b,c];}}j=$global.require;if(!(j===undefined)){k=j($externalize("crypto",$String)).randomBytes;if(!(k===undefined)){e.set(k(a.$length),f);l=a.$length;m=$ifaceNil;b=l;c=m;return[b,c];}}n=0;o=A.New("crypto/rand not available in this environment");b=n;c=o;return[b,c];};F.prototype.Read=function(a){return this.$val.Read(a);};P.methods=[{prop:"Read",name:"Read",pkg:"",typ:$funcType([N],[$Int,$error],false)}];F.init("",[]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.Reader=$ifaceNil;K=new D.Int.ptr(false,D.nat.nil).SetUint64(new $Uint64(3793877372,820596253));E();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["context"]=(function(){var $pkg={},$init,A,B,C,D,E,H,AB,AC,AD,AJ,I,J,T,U;A=$packages["errors"];B=$packages["fmt"];C=$packages["reflect"];D=$packages["sync"];E=$packages["time"];H=$pkg.emptyCtx=$newType(4,$kindInt,"context.emptyCtx",true,"context",false,null);AB=$ptrType(H);AC=$structType("",[]);AD=$ptrType(E.Location);AJ=$chanType(AC,false,true);$ptrType(H).prototype.Deadline=function(){var b,c;b=new E.Time.ptr(new $Uint64(0,0),new $Int64(0,0),AD.nil);c=false;return[b,c];};$ptrType(H).prototype.Done=function(){return $chanNil;};$ptrType(H).prototype.Err=function(){return $ifaceNil;};$ptrType(H).prototype.Value=function(b){var b;return $ifaceNil;};$ptrType(H).prototype.String=function(){var b,c;b=this;c=b;if(c===(I)){return"context.Background";}else if(c===(J)){return"context.TODO";}return"unknown empty Context";};U=function(){$close(T);};AB.methods=[{prop:"Deadline",name:"Deadline",pkg:"",typ:$funcType([],[E.Time,$Bool],false)},{prop:"Done",name:"Done",pkg:"",typ:$funcType([],[AJ],false)},{prop:"Err",name:"Err",pkg:"",typ:$funcType([],[$error],false)},{prop:"Value",name:"Value",pkg:"",typ:$funcType([$emptyInterface],[$emptyInterface],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.Canceled=A.New("context canceled");I=$newDataPointer(0,AB);J=$newDataPointer(0,AB);T=new $Chan(AC,0);U();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["database/sql/driver"]=(function(){var $pkg={},$init,A,B,D,C,E,F,G,AN,AY,AW,a;A=$packages["context"];B=$packages["errors"];D=$packages["fmt"];C=$packages["reflect"];E=$packages["strconv"];F=$packages["time"];G=$pkg.Value=$newType(8,$kindInterface,"driver.Value",true,"database/sql/driver",true,null);AN=$pkg.Valuer=$newType(8,$kindInterface,"driver.Valuer",true,"database/sql/driver",true,null);AY=$ptrType(AN);G.init([]);AN.init([{prop:"Value",name:"Value",pkg:"",typ:$funcType([],[G,$error],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrSkip=B.New("driver: skip fast-path; continue as if unimplemented");$pkg.ErrBadConn=B.New("driver: bad connection");$pkg.ErrRemoveArgument=B.New("driver: remove argument from query");a=C.TypeOf((AY.nil)).Elem();$s=7;case 7:if($c){$c=false;a=a.$blk();}if(a&&a.$blk!==undefined){break s;}AW=a;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["github.com/segmentio/ksuid"]=(function(){var $pkg={},$init,B,C,D,E,A,F,G,H,K,I,J,S,AQ,BH,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,CA,L,T,U,V,W,X,Y,Z,a,b,c,d,e,M,N,O,P,R,AA,AB,AC,AE,AF,AH,AN,AO,AP,BI,BJ,BK,BM,BN;B=$packages["bytes"];C=$packages["crypto/rand"];D=$packages["database/sql/driver"];E=$packages["encoding/binary"];A=$packages["errors"];F=$packages["fmt"];G=$packages["io"];H=$packages["math"];K=$packages["math/rand"];I=$packages["sync"];J=$packages["time"];S=$pkg.KSUID=$newType(20,$kindArray,"ksuid.KSUID",true,"github.com/segmentio/ksuid",true,null);AQ=$pkg.randSourceReader=$newType(0,$kindStruct,"ksuid.randSourceReader",true,"github.com/segmentio/ksuid",false,function(source_){this.$val=this;if(arguments.length===0){this.source=$ifaceNil;return;}this.source=source_;});BH=$pkg.uint128=$newType(16,$kindArray,"ksuid.uint128",true,"github.com/segmentio/ksuid",false,null);BP=$arrayType($Uint8,20);BQ=$arrayType($Uint8,16);BR=$sliceType($emptyInterface);BS=$sliceType($Uint32);BT=$arrayType($Uint32,5);BU=$sliceType($Uint8);BV=$arrayType($Uint8,27);BW=$ptrType(S);BX=$arrayType($Uint8,8);BY=$arrayType($Uint64,2);CA=$ptrType(AQ);M=function(f){var f;if(f>=48&&f<=57){return f-48<<24>>>24;}else if(f>=65&&f<=90){return 10+((f-65<<24>>>24))<<24>>>24;}else{return 36+((f-97<<24>>>24))<<24>>>24;}};N=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;h=$toNativeArray($kindUint32,[(((((((((0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0])>>>0))<<24>>>0)|((((1>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+1])>>>0))<<16>>>0))>>>0)|((((2>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+2])>>>0))<<8>>>0))>>>0)|(((3>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+3])>>>0)))>>>0,(((((((((4>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+4])>>>0))<<24>>>0)|((((5>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+5])>>>0))<<16>>>0))>>>0)|((((6>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+6])>>>0))<<8>>>0))>>>0)|(((7>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+7])>>>0)))>>>0,(((((((((8>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+8])>>>0))<<24>>>0)|((((9>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+9])>>>0))<<16>>>0))>>>0)|((((10>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+10])>>>0))<<8>>>0))>>>0)|(((11>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+11])>>>0)))>>>0,(((((((((12>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+12])>>>0))<<24>>>0)|((((13>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+13])>>>0))<<16>>>0))>>>0)|((((14>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+14])>>>0))<<8>>>0))>>>0)|(((15>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+15])>>>0)))>>>0,(((((((((16>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+16])>>>0))<<24>>>0)|((((17>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+17])>>>0))<<16>>>0))>>>0)|((((18>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+18])>>>0))<<8>>>0))>>>0)|(((19>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+19])>>>0)))>>>0]);i=f.$length;j=new BS(h);k=BT.zero();while(true){if(!(!((j.$length===0)))){break;}l=$subslice(new BS(k),0,0);m=new $Uint64(0,0);n=j;o=0;while(true){if(!(o=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]);s=(q=(new $Uint64(0,p)),r=$mul64((m),new $Uint64(1,0)),new $Uint64(q.$high+r.$high,q.$low+r.$low));t=$div64(s,new $Uint64(0,62),false);m=$div64(s,new $Uint64(0,62),true);if(!((l.$length===0))||!((t.$high===0&&t.$low===0))){l=$append(l,((t.$low>>>0)));}o++;}i=i-(1)>>0;((i<0||i>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+i]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".charCodeAt($flatten64(m)));j=l;}$copyString($subslice(f,0,i),"000000000000000000000000000");};O=function(f,g){var f,g,h;f=R(f,27);h=f.$length;N($subslice(f,h,(h+27>>0)),g);return $subslice(f,0,(h+27>>0));};P=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y;$unused((26>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+26]));h=$toNativeArray($kindUint8,[M((0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0])),M((1>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+1])),M((2>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+2])),M((3>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+3])),M((4>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+4])),M((5>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+5])),M((6>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+6])),M((7>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+7])),M((8>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+8])),M((9>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+9])),M((10>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+10])),M((11>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+11])),M((12>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+12])),M((13>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+13])),M((14>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+14])),M((15>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+15])),M((16>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+16])),M((17>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+17])),M((18>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+18])),M((19>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+19])),M((20>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+20])),M((21>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+21])),M((22>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+22])),M((23>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+23])),M((24>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+24])),M((25>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+25])),M((26>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+26]))]);i=f.$length;j=new BU(h);k=BV.zero();while(true){if(!(j.$length>0)){break;}l=$subslice(new BU(k),0,0);m=new $Uint64(0,0);n=j;o=0;while(true){if(!(o=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]);s=(q=(new $Uint64(0,p)),r=$mul64((m),new $Uint64(0,62)),new $Uint64(q.$high+r.$high,q.$low+r.$low));t=$div64(s,new $Uint64(1,0),false);m=$div64(s,new $Uint64(1,0),true);if(!((l.$length===0))||!((t.$high===0&&t.$low===0))){l=$append(l,((t.$low<<24>>>24)));}o++;}if(i<4){return L;}(u=i-4>>0,((u<0||u>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+u]=(($shiftRightUint64(m,24).$low<<24>>>24))));(v=i-3>>0,((v<0||v>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+v]=(($shiftRightUint64(m,16).$low<<24>>>24))));(w=i-2>>0,((w<0||w>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+w]=(($shiftRightUint64(m,8).$low<<24>>>24))));(x=i-1>>0,((x<0||x>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+x]=((m.$low<<24>>>24))));i=i-(4)>>0;j=l;}y=BP.zero();$copySlice($subslice(f,0,i),new BU(y));return $ifaceNil;};R=function(f,g){var f,g,h,i,j,k;h=f.$capacity;i=f.$length;j=h-i>>0;if(j>0))>0;}k=$makeSlice(BU,i,h);$copySlice(k,f);f=k;}return f;};S.prototype.Append=function(f){var f,g;g=this.$val;return O(f,new BU(g));};$ptrType(S).prototype.Append=function(f){return new S(this.$get()).Append(f);};S.prototype.Time=function(){var f;f=this.$val;return AC(new S($clone(f,S)).Timestamp());};$ptrType(S).prototype.Time=function(){return new S(this.$get()).Time();};S.prototype.Timestamp=function(){var f;f=this.$val;return $clone(E.BigEndian,E.bigEndian).Uint32($subslice(new BU(f),0,4));};$ptrType(S).prototype.Timestamp=function(){return new S(this.$get()).Timestamp();};S.prototype.Payload=function(){var f;f=this.$val;return $subslice(new BU(f),4);};$ptrType(S).prototype.Payload=function(){return new S(this.$get()).Payload();};S.prototype.String=function(){var f;f=this.$val;return($bytesToString(new S($clone(f,S)).Append($makeSlice(BU,0,27))));};$ptrType(S).prototype.String=function(){return new S(this.$get()).String();};S.prototype.Bytes=function(){var f;f=this.$val;return new BU(f);};$ptrType(S).prototype.Bytes=function(){return new S(this.$get()).Bytes();};S.prototype.IsNil=function(){var f;f=this.$val;return $equal(f,$pkg.Nil,S);};$ptrType(S).prototype.IsNil=function(){return new S(this.$get()).IsNil();};S.prototype.Get=function(){var f;f=this.$val;return new S(f);};$ptrType(S).prototype.Get=function(){return new S(this.$get()).Get();};S.prototype.Set=function(f){var f,g;g=this.$val;return new BW(g).UnmarshalText((new BU($stringToBytes(f))));};$ptrType(S).prototype.Set=function(f){return(new S(this.$get())).Set(f);};S.prototype.MarshalText=function(){var f;f=this.$val;return[(new BU($stringToBytes(new S($clone(f,S)).String()))),$ifaceNil];};$ptrType(S).prototype.MarshalText=function(){return new S(this.$get()).MarshalText();};S.prototype.MarshalBinary=function(){var f;f=this.$val;return[new S($clone(f,S)).Bytes(),$ifaceNil];};$ptrType(S).prototype.MarshalBinary=function(){return new S(this.$get()).MarshalBinary();};S.prototype.UnmarshalText=function(f){var f,g,h,i,j;g=this.$val;h=AA(($bytesToString(f)));i=$clone(h[0],S);j=h[1];if(!($interfaceIsEqual(j,$ifaceNil))){return j;}S.copy(g,i);return $ifaceNil;};$ptrType(S).prototype.UnmarshalText=function(f){return(new S(this.$get())).UnmarshalText(f);};S.prototype.UnmarshalBinary=function(f){var f,g,h,i,j;g=this.$val;h=AH(f);i=$clone(h[0],S);j=h[1];if(!($interfaceIsEqual(j,$ifaceNil))){return j;}S.copy(g,i);return $ifaceNil;};$ptrType(S).prototype.UnmarshalBinary=function(f){return(new S(this.$get())).UnmarshalBinary(f);};S.prototype.Value=function(){var f;f=this.$val;if(new S($clone(f,S)).IsNil()){return[$ifaceNil,$ifaceNil];}return[new $String(new S($clone(f,S)).String()),$ifaceNil];};$ptrType(S).prototype.Value=function(){return new S(this.$get()).Value();};S.prototype.Scan=function(f){var f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this.$val;h=f;if(h===$ifaceNil){$s=1;continue;}if($assertType(h,BU,true)[1]){$s=2;continue;}if($assertType(h,$String,true)[1]){$s=3;continue;}$s=4;continue;case 1:i=h;$s=-1;return new BW(g).scan(BU.nil);case 2:j=h.$val;$s=-1;return new BW(g).scan(j);case 3:k=h.$val;$s=-1;return new BW(g).scan((new BU($stringToBytes(k))));case 4:l=h;m=F.Errorf("Scan: unable to scan type %T into KSUID",new BR([l]));$s=6;case 6:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}$s=-1;return m;case 5:$s=-1;return $ifaceNil;}return;}if($f===undefined){$f={$blk:S.prototype.Scan};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(S).prototype.Scan=function(f){return(new S(this.$get())).Scan(f);};S.prototype.scan=function(f){var f,g,h;g=this.$val;h=f.$length;if(h===(0)){S.copy(g,$pkg.Nil);return $ifaceNil;}else if(h===(20)){return new BW(g).UnmarshalBinary(f);}else if(h===(27)){return new BW(g).UnmarshalText(f);}else{return W;}};$ptrType(S).prototype.scan=function(f){return(new S(this.$get())).scan(f);};AA=function(f){var f,g,h,i;if(!((f.length===27))){return[$pkg.Nil,X];}g=BV.zero();h=BP.zero();$copyString(new BU(g),f);i=P(new BU(h),new BU(g));if(!($interfaceIsEqual(i,$ifaceNil))){return[$pkg.Nil,Y];}return AH(new BU(h));};$pkg.Parse=AA;AB=function(f){var f,g;return(((g=$clone(f,J.Time).Unix(),new $Int64(g.$high-0,g.$low-1400000000)).$low>>>0));};AC=function(f){var f,g;return J.Unix((g=(new $Int64(0,f)),new $Int64(g.$high+0,g.$low+1400000000)),new $Int64(0,0));};AE=function(){var f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=BP.zero();g=$ifaceNil;i=AF($clone(J.Now(),J.Time));$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}h=i;S.copy(f,h[0]);g=h[1];$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:AE};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewRandom=AE;AF=function(f){var f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=BP.zero();h=$ifaceNil;$r=U.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}j=G.ReadAtLeast(T,new BU(V),16);$s=2;case 2:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;h=i[1];$copySlice($subslice(new BU(g),4),new BU(V));$r=U.Unlock();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(!($interfaceIsEqual(h,$ifaceNil))){S.copy(g,$pkg.Nil);$s=-1;return[g,h];}k=AB($clone(f,J.Time));$clone(E.BigEndian,E.bigEndian).PutUint32($subslice(new BU(g),0,4),k);$s=-1;return[g,h];}return;}if($f===undefined){$f={$blk:AF};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewRandomWithTime=AF;AH=function(f){var f,g;g=BP.zero();if(!((f.$length===20))){return[$pkg.Nil,W];}$copySlice(new BU(g),f);return[g,$ifaceNil];};$pkg.FromBytes=AH;S.prototype.Next=function(){var f,g,h,i,j;f=this.$val;g=$clone(BJ(new $Uint64(0,0),new $Uint64(0,0)),BH);h=new S($clone(f,S)).Timestamp();i=$clone(BI($clone(f,S)),BH);j=$clone(BM($clone(i,BH),$clone(BJ(new $Uint64(0,0),new $Uint64(0,1)),BH)),BH);if($equal(j,g,BH)){h=h+(1)>>>0;}return new BH($clone(j,BH)).ksuid(h);};$ptrType(S).prototype.Next=function(){return new S(this.$get()).Next();};S.prototype.Prev=function(){var f,g,h,i,j;f=this.$val;g=$clone(BJ(new $Uint64(4294967295,4294967295),new $Uint64(4294967295,4294967295)),BH);h=new S($clone(f,S)).Timestamp();i=$clone(BI($clone(f,S)),BH);j=$clone(BN($clone(i,BH),$clone(BJ(new $Uint64(0,0),new $Uint64(0,1)),BH)),BH);if($equal(j,g,BH)){h=h-(1)>>>0;}return new BH($clone(j,BH)).ksuid(h);};$ptrType(S).prototype.Prev=function(){return new S(this.$get()).Prev();};AN=function(){var f,g,h,i,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=AO();$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}f=g;h=f[0];i=f[1];if(!($interfaceIsEqual(i,$ifaceNil))){$panic(i);}$s=-1;return h;}return;}if($f===undefined){$f={$blk:AN};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.$s=$s;$f.$r=$r;return $f;};AO=function(){var f,g,h,i,j,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=$ifaceNil;g=$ifaceNil;h=new $Int64(0,0);j=AP();$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;h=i[0];g=i[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[f,g];}f=new AQ.ptr($assertType(K.NewSource(h),K.Source64));$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:AO};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.$s=$s;$f.$r=$r;return $f;};AP=function(){var f,g,h,i,j,k,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=new $Int64(0,0);g=$ifaceNil;h=BX.zero();j=G.ReadFull(C.Reader,new BU(h));$s=1;case 1:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;g=i[1];if(!($interfaceIsEqual(g,$ifaceNil))){$s=-1;return[f,g];}f=((k=$clone(E.LittleEndian,E.littleEndian).Uint64(new BU(h)),new $Int64(k.$high,k.$low)));$s=-1;return[f,g];}return;}if($f===undefined){$f={$blk:AP};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.$s=$s;$f.$r=$r;return $f;};AQ.ptr.prototype.Read=function(f){var f,g,h,i,j,k,l,m,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;h=$f.h;i=$f.i;j=$f.j;k=$f.k;l=$f.l;m=$f.m;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:g=this;h=$subslice(f,0,8);i=g.source.Uint64();$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;$r=$clone(E.LittleEndian,E.littleEndian).PutUint64(h,j);$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}k=$subslice(f,8);l=g.source.Uint64();$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}m=l;$r=$clone(E.LittleEndian,E.littleEndian).PutUint64(k,m);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return[16,$ifaceNil];}return;}if($f===undefined){$f={$blk:AQ.ptr.prototype.Read};}$f.f=f;$f.g=g;$f.h=h;$f.i=i;$f.j=j;$f.k=k;$f.l=l;$f.m=m;$f.$s=$s;$f.$r=$r;return $f;};AQ.prototype.Read=function(f){return this.$val.Read(f);};BI=function(f){var f;return BK($subslice(new BU(f),4));};BJ=function(f,g){var f,g;return $toNativeArray($kindUint64,[g,f]);};BK=function(f){var aa,ab,ac,ad,ae,af,ag,ah,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;return $toNativeArray($kindUint64,[(g=(h=(i=(j=(k=(l=(m=$shiftLeft64((new $Uint64(0,(8>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+8]))),56),n=$shiftLeft64((new $Uint64(0,(9>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+9]))),48),new $Uint64(m.$high|n.$high,(m.$low|n.$low)>>>0)),o=$shiftLeft64((new $Uint64(0,(10>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+10]))),40),new $Uint64(l.$high|o.$high,(l.$low|o.$low)>>>0)),p=$shiftLeft64((new $Uint64(0,(11>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+11]))),32),new $Uint64(k.$high|p.$high,(k.$low|p.$low)>>>0)),q=$shiftLeft64((new $Uint64(0,(12>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+12]))),24),new $Uint64(j.$high|q.$high,(j.$low|q.$low)>>>0)),r=$shiftLeft64((new $Uint64(0,(13>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+13]))),16),new $Uint64(i.$high|r.$high,(i.$low|r.$low)>>>0)),s=$shiftLeft64((new $Uint64(0,(14>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+14]))),8),new $Uint64(h.$high|s.$high,(h.$low|s.$low)>>>0)),t=(new $Uint64(0,(15>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+15]))),new $Uint64(g.$high|t.$high,(g.$low|t.$low)>>>0)),(u=(v=(w=(x=(y=(z=(aa=$shiftLeft64((new $Uint64(0,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]))),56),ab=$shiftLeft64((new $Uint64(0,(1>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+1]))),48),new $Uint64(aa.$high|ab.$high,(aa.$low|ab.$low)>>>0)),ac=$shiftLeft64((new $Uint64(0,(2>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+2]))),40),new $Uint64(z.$high|ac.$high,(z.$low|ac.$low)>>>0)),ad=$shiftLeft64((new $Uint64(0,(3>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+3]))),32),new $Uint64(y.$high|ad.$high,(y.$low|ad.$low)>>>0)),ae=$shiftLeft64((new $Uint64(0,(4>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+4]))),24),new $Uint64(x.$high|ae.$high,(x.$low|ae.$low)>>>0)),af=$shiftLeft64((new $Uint64(0,(5>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+5]))),16),new $Uint64(w.$high|af.$high,(w.$low|af.$low)>>>0)),ag=$shiftLeft64((new $Uint64(0,(6>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+6]))),8),new $Uint64(v.$high|ag.$high,(v.$low|ag.$low)>>>0)),ah=(new $Uint64(0,(7>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+7]))),new $Uint64(u.$high|ah.$high,(u.$low|ah.$low)>>>0))]);};BH.prototype.ksuid=function(f){var f,g;g=this.$val;return $toNativeArray($kindUint8,[(((f>>>24>>>0)<<24>>>24)),(((f>>>16>>>0)<<24>>>24)),(((f>>>8>>>0)<<24>>>24)),((f<<24>>>24)),(($shiftRightUint64(g[1],56).$low<<24>>>24)),(($shiftRightUint64(g[1],48).$low<<24>>>24)),(($shiftRightUint64(g[1],40).$low<<24>>>24)),(($shiftRightUint64(g[1],32).$low<<24>>>24)),(($shiftRightUint64(g[1],24).$low<<24>>>24)),(($shiftRightUint64(g[1],16).$low<<24>>>24)),(($shiftRightUint64(g[1],8).$low<<24>>>24)),((g[1].$low<<24>>>24)),(($shiftRightUint64(g[0],56).$low<<24>>>24)),(($shiftRightUint64(g[0],48).$low<<24>>>24)),(($shiftRightUint64(g[0],40).$low<<24>>>24)),(($shiftRightUint64(g[0],32).$low<<24>>>24)),(($shiftRightUint64(g[0],24).$low<<24>>>24)),(($shiftRightUint64(g[0],16).$low<<24>>>24)),(($shiftRightUint64(g[0],8).$low<<24>>>24)),((g[0].$low<<24>>>24))]);};$ptrType(BH).prototype.ksuid=function(f){return new BH(this.$get()).ksuid(f);};BH.prototype.String=function(){var f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:f=this.$val;g=F.Sprintf("0x%016X%016X",new BR([f[0],f[1]]));$s=1;case 1:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}$s=-1;return g;}return;}if($f===undefined){$f={$blk:BH.prototype.String};}$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};$ptrType(BH).prototype.String=function(){return new BH(this.$get()).String();};BM=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r;h=BY.zero();i=f[0];j=g[0];k=new $Uint64(i.$high+j.$high,i.$low+j.$low);h[0]=k;o=$shiftRightUint64(((l=new $Uint64(i.$high&j.$high,(i.$low&j.$low)>>>0),m=(n=new $Uint64(i.$high|j.$high,(i.$low|j.$low)>>>0),new $Uint64(n.$high&~k.$high,(n.$low&~k.$low)>>>0)),new $Uint64(l.$high|m.$high,(l.$low|m.$low)>>>0))),63);h[1]=(p=(q=f[1],r=g[1],new $Uint64(q.$high+r.$high,q.$low+r.$low)),new $Uint64(p.$high+o.$high,p.$low+o.$low));return h;};BN=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r,s;h=BY.zero();i=f[0];j=g[0];k=new $Uint64(i.$high-j.$high,i.$low-j.$low);h[0]=k;p=$shiftRightUint64(((l=new $Uint64(j.$high&~i.$high,(j.$low&~i.$low)>>>0),m=(n=(o=new $Uint64(~i.$high,~i.$low>>>0),new $Uint64(j.$high|o.$high,(j.$low|o.$low)>>>0)),new $Uint64(n.$high&k.$high,(n.$low&k.$low)>>>0)),new $Uint64(l.$high|m.$high,(l.$low|m.$low)>>>0))),63);h[1]=(q=(r=f[1],s=g[1],new $Uint64(r.$high-s.$high,r.$low-s.$low)),new $Uint64(q.$high-p.$high,q.$low-p.$low));return h;};S.methods=[{prop:"Append",name:"Append",pkg:"",typ:$funcType([BU],[BU],false)},{prop:"Time",name:"Time",pkg:"",typ:$funcType([],[J.Time],false)},{prop:"Timestamp",name:"Timestamp",pkg:"",typ:$funcType([],[$Uint32],false)},{prop:"Payload",name:"Payload",pkg:"",typ:$funcType([],[BU],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[BU],false)},{prop:"IsNil",name:"IsNil",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Get",name:"Get",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"MarshalText",name:"MarshalText",pkg:"",typ:$funcType([],[BU,$error],false)},{prop:"MarshalBinary",name:"MarshalBinary",pkg:"",typ:$funcType([],[BU,$error],false)},{prop:"Value",name:"Value",pkg:"",typ:$funcType([],[D.Value,$error],false)},{prop:"Next",name:"Next",pkg:"",typ:$funcType([],[S],false)},{prop:"Prev",name:"Prev",pkg:"",typ:$funcType([],[S],false)}];BW.methods=[{prop:"Set",name:"Set",pkg:"",typ:$funcType([$String],[$error],false)},{prop:"UnmarshalText",name:"UnmarshalText",pkg:"",typ:$funcType([BU],[$error],false)},{prop:"UnmarshalBinary",name:"UnmarshalBinary",pkg:"",typ:$funcType([BU],[$error],false)},{prop:"Scan",name:"Scan",pkg:"",typ:$funcType([$emptyInterface],[$error],false)},{prop:"scan",name:"scan",pkg:"github.com/segmentio/ksuid",typ:$funcType([BU],[$error],false)}];CA.methods=[{prop:"Read",name:"Read",pkg:"",typ:$funcType([BU],[$Int,$error],false)}];BH.methods=[{prop:"ksuid",name:"ksuid",pkg:"github.com/segmentio/ksuid",typ:$funcType([$Uint32],[S],false)},{prop:"bytes",name:"bytes",pkg:"github.com/segmentio/ksuid",typ:$funcType([],[BQ],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];S.init($Uint8,20);AQ.init("github.com/segmentio/ksuid",[{prop:"source",name:"source",embedded:false,exported:false,typ:K.Source64,tag:""}]);BH.init($Uint64,2);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=F.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=H.$init();$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=K.$init();$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=I.$init();$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=J.$init();$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.Nil=BP.zero();L=A.New("the output buffer is too small to hold to decoded value");T=C.Reader;U=new I.Mutex.ptr(0,0);V=BQ.zero();a=F.Errorf("Valid KSUIDs are %v bytes",new BR([new $Int(20)]));$s=12;case 12:if($c){$c=false;a=a.$blk();}if(a&&a.$blk!==undefined){break s;}W=a;b=F.Errorf("Valid encoded KSUIDs are %v characters",new BR([new $Int(27)]));$s=13;case 13:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}X=b;c=F.Errorf("Valid encoded KSUIDs are bounded by %s and %s",new BR([new $String("000000000000000000000000000"),new $String("aWgEPTl1tmebfsQzFP4bxwgy80V")]));$s=14;case 14:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}Y=c;d=F.Errorf("Valid KSUID payloads are %v bytes",new BR([new $Int(16)]));$s=15;case 15:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}Z=d;e=AN();$s=16;case 16:if($c){$c=false;e=e.$blk();}if(e&&e.$blk!==undefined){break s;}$pkg.FastRander=e;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["github.com/bonedaddy/vcaptcha/ticket"]=(function(){var $pkg={},$init,A,B,C,D,E,F,L,M,N,O,G,I,J;A=$packages["crypto/sha256"];B=$packages["encoding/hex"];C=$packages["encoding/json"];D=$packages["github.com/bonedaddy/vcaptcha/vdf"];E=$packages["github.com/segmentio/ksuid"];F=$pkg.Ticket=$newType(0,$kindStruct,"ticket.Ticket",true,"github.com/bonedaddy/vcaptcha/ticket",true,function(Seed_,Difficulty_,Proof_){this.$val=this;if(arguments.length===0){this.Seed=L.zero();this.Difficulty=0;this.Proof=N.zero();return;}this.Seed=Seed_;this.Difficulty=Difficulty_;this.Proof=Proof_;});L=$arrayType($Uint8,32);M=$ptrType(F);N=$arrayType($Uint8,516);O=$sliceType($Uint8);G=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=I();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=$clone(b[0],L);e=b[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return[M.nil,e];}$s=-1;return[new F.ptr($clone(d,L),a,N.zero()),$ifaceNil];}return;}if($f===undefined){$f={$blk:G};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewTicket=G;F.ptr.prototype.Encode=function(){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;c=a.Marshal();$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return["",e];}$s=-1;return[B.EncodeToString(d),$ifaceNil];}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Encode};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Encode=function(){return this.$val.Encode();};F.ptr.prototype.Marshal=function(){var a,b,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=C.Marshal(a);$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}$s=-1;return b;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Marshal};}$f.a=a;$f.b=b;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Marshal=function(){return this.$val.Marshal();};F.ptr.prototype.Hash=function(){var a,b,c,d,e,f,g,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;f=$f.f;g=$f.g;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;c=C.Marshal(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];if(!($interfaceIsEqual(e,$ifaceNil))){$s=-1;return"";}f=A.Sum256(d);$s=2;case 2:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=$clone(f,L);$s=-1;return B.EncodeToString(new O(g));}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Hash};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.f=f;$f.g=g;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Hash=function(){return this.$val.Hash();};F.ptr.prototype.Verify=function(a){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=this;c=D.New(b.Difficulty,$clone(b.Seed,L));d=c.Verify($clone(a,N));$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}$s=-1;return d;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Verify};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Verify=function(a){return this.$val.Verify(a);};F.ptr.prototype.Solve=function(){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:a=this;b=D.New(a.Difficulty,$clone(a.Seed,L));$r=b.Execute();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}c=$recv(b.GetOutputChannel());$s=2;case 2:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}d=$clone(c[0],N);N.copy(a.Proof,d);$s=-1;return d;}return;}if($f===undefined){$f={$blk:F.ptr.prototype.Solve};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};F.prototype.Solve=function(){return this.$val.Solve();};I=function(){var a,b,c,d,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:b=E.NewRandom();$s=1;case 1:if($c){$c=false;b=b.$blk();}if(b&&b.$blk!==undefined){break s;}a=b;c=$clone(a[0],E.KSUID);d=a[1];if(!($interfaceIsEqual(d,$ifaceNil))){$s=-1;return[L.zero(),d];}$s=-1;return[J($clone(c,E.KSUID)),$ifaceNil];}return;}if($f===undefined){$f={$blk:I};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.$s=$s;$f.$r=$r;return $f;};$pkg.NewSeed=I;J=function(a){var a,b,c,d;b=L.zero();c=O.nil;c=$appendSlice(c,new E.KSUID($clone(a,E.KSUID)).Bytes());c=$appendSlice(c,$subslice(new E.KSUID($clone(a,E.KSUID)).Payload(),0,12));d=0;while(true){if(!(d=b.length)?($throwRuntimeError("index out of range"),undefined):b[d]=((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]));d=d+(1)>>0;}return b;};$pkg.IDToBytes32=J;M.methods=[{prop:"Encode",name:"Encode",pkg:"",typ:$funcType([],[$String,$error],false)},{prop:"Marshal",name:"Marshal",pkg:"",typ:$funcType([],[O,$error],false)},{prop:"Hash",name:"Hash",pkg:"",typ:$funcType([],[$String],false)},{prop:"Verify",name:"Verify",pkg:"",typ:$funcType([N],[$Bool],false)},{prop:"Solve",name:"Solve",pkg:"",typ:$funcType([],[N],false)}];F.init("",[{prop:"Seed",name:"Seed",embedded:false,exported:true,typ:L,tag:"json:\"seed\""},{prop:"Difficulty",name:"Difficulty",embedded:false,exported:true,typ:$Int,tag:"json:\"difficulty\""},{prop:"Proof",name:"Proof",embedded:false,exported:true,typ:N,tag:"json:\"proof\""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); +$packages["."]=(function(){var $pkg={},$init,B,C,A,F,G,H,D,E;B=$packages["github.com/bonedaddy/vcaptcha/ticket"];C=$packages["github.com/gopherjs/gopherjs/js"];A=$packages["os"];F=$ptrType(C.Object);G=$funcType([$Int],[F],false);H=$mapType($String,$emptyInterface);D=function(){$global.ticket=$externalize($makeMap($String.keyFor,[{k:"New",v:new G(E)}]),H);};E=function(a){var a,b,c,d,e,$s,$r;$s=0;var $f,$c=false;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;a=$f.a;b=$f.b;c=$f.c;d=$f.d;e=$f.e;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:c=B.NewTicket(a);$s=1;case 1:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];if(!($interfaceIsEqual(e,$ifaceNil))){A.Exit(1);}$s=-1;return C.MakeWrapper(d);}return;}if($f===undefined){$f={$blk:E};}$f.a=a;$f.b=b;$f.c=c;$f.d=d;$f.e=e;$f.$s=$s;$f.$r=$r;return $f;};$pkg.New=E;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if($pkg===$mainPkg){D();$mainFinished=true;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})(); $synthesizeMethods(); var $mainPkg = $packages["."]; $packages["runtime"].$init(); diff --git a/ticket/js/js.js.map b/ticket/js/js.js.map index 76dccea..04c6f21 100644 --- a/ticket/js/js.js.map +++ b/ticket/js/js.js.map @@ -1 +1 @@ -{"version":3,"file":"js.js","sources":["/github.com/gopherjs/gopherjs/js/js.go","/internal/bytealg/index_generic.go","/internal/bytealg/indexbyte_generic.go","runtime.go","/runtime/error.go","/errors/errors.go","atomic.go","pool.go","sync.go","/sync/mutex.go","/sync/pool.go","/sync/runtime.go","/sync/rwmutex.go","/io/io.go","/math/bits/bits.go","math.go","/math/abs.go","/math/dim.go","/math/floor.go","/math/frexp.go","/math/ldexp.go","/math/log10.go","/unicode/utf8/utf8.go","/strconv/atof.go","/strconv/atoi.go","/strconv/decimal.go","/strconv/extfloat.go","/strconv/ftoa.go","/strconv/itoa.go","/strconv/quote.go","/crypto/crypto.go","/crypto/sha256/sha256.go","/crypto/sha256/sha256block.go","unicode.go","/unicode/digit.go","/unicode/graphic.go","/unicode/letter.go","reflect.go","swapper.go","/reflect/type.go","/reflect/value.go","/sort/search.go","/sort/slice.go","/sort/sort.go","/sort/zfuncversion.go","/internal/fmtsort/sort.go","syscall.go","syscall_unix.go","/syscall/dirent.go","/syscall/exec_unix.go","/syscall/str.go","/syscall/syscall.go","/syscall/syscall_linux.go","/syscall/syscall_linux_amd64.go","/syscall/syscall_unix.go","/syscall/zsyscall_linux_amd64.go","/github.com/gopherjs/gopherjs/nosync/map.go","/github.com/gopherjs/gopherjs/nosync/mutex.go","/github.com/gopherjs/gopherjs/nosync/once.go","/github.com/gopherjs/gopherjs/nosync/pool.go","time.go","/time/format.go","/time/time.go","/time/zoneinfo.go","fd_poll.go","/internal/poll/fd.go","/internal/poll/fd_fsync_posix.go","/internal/poll/fd_mutex.go","/internal/poll/fd_posix.go","/internal/poll/fd_unix.go","/internal/poll/fd_writev_unix.go","/internal/poll/sock_cloexec.go","/internal/poll/sockopt.go","/internal/poll/sockopt_linux.go","/internal/poll/sockopt_unix.go","/internal/poll/sockoptip.go","/internal/poll/writev.go","/internal/testlog/log.go","os.go","/os/dir.go","/os/dir_unix.go","/os/error.go","/os/error_posix.go","/os/error_unix.go","/os/file.go","/os/file_posix.go","/os/file_unix.go","/os/path_unix.go","/os/proc.go","/os/rawconn.go","/os/stat.go","/os/stat_linux.go","/os/stat_unix.go","/os/types.go","/os/types_unix.go","/fmt/format.go","/fmt/print.go","/fmt/scan.go","strings.go","/strings/builder.go","/strings/reader.go","/strings/strings.go","/encoding/hex/hex.go","bytes.go","/bytes/buffer.go","/bytes/bytes.go","/bytes/reader.go","/encoding/binary/binary.go","/encoding/base64/base64.go","/encoding/json/decode.go","/encoding/json/encode.go","/encoding/json/fold.go","/encoding/json/indent.go","/encoding/json/scanner.go","/encoding/json/tags.go","/log/log.go","/math/rand/exp.go","/math/rand/normal.go","/math/rand/rand.go","/math/rand/rng.go","/math/big/accuracy_string.go","/math/big/arith.go","/math/big/decimal.go","/math/big/float.go","/math/big/floatconv.go","/math/big/floatmarsh.go","/math/big/ftoa.go","/math/big/int.go","/math/big/intconv.go","/math/big/intmarsh.go","/math/big/nat.go","/math/big/natconv.go","/math/big/prime.go","/math/big/rat.go","/math/big/ratconv.go","/math/big/ratmarsh.go","/math/big/roundingmode_string.go","/math/big/sqrt.go","/regexp/syntax/compile.go","/regexp/syntax/op_string.go","/regexp/syntax/parse.go","/regexp/syntax/prog.go","/regexp/syntax/regexp.go","/regexp/syntax/simplify.go","/regexp/backtrack.go","/regexp/exec.go","/regexp/onepass.go","/regexp/regexp.go","/github.com/bonedaddy/vcaptcha/vdf/classgroup.go","/github.com/bonedaddy/vcaptcha/vdf/discriminant.go","/github.com/bonedaddy/vcaptcha/vdf/division.go","/github.com/bonedaddy/vcaptcha/vdf/encode.go","/github.com/bonedaddy/vcaptcha/vdf/gcd.go","/github.com/bonedaddy/vcaptcha/vdf/prime.go","/github.com/bonedaddy/vcaptcha/vdf/proof_wesolowski.go","/github.com/bonedaddy/vcaptcha/vdf/vdf.go","rand.go","/context/context.go","/github.com/segmentio/ksuid/base62.go","/github.com/segmentio/ksuid/ksuid.go","/github.com/segmentio/ksuid/rand.go","/github.com/segmentio/ksuid/uint128.go","/github.com/bonedaddy/vcaptcha/ticket/ticket.go","main.go"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+B4C;A;;;;;AAGW;A;;;;;AAGhB;A;;;;;AAGN;A;;;;;AAGQ;A;;;;;AAGc;A;;;;;AAGY;A;;;;;AAGX;A;;;;;AAGH;A;;;;;AAGrB;A;;;;;AAGI;A;;;;;AAGN;A;;;;;AAGI;A;;;;;AAGE;A;;;;;AAGA;A;;;;;AAGQ;A;;;;;AAGP;A;;;;;AASnC;A;;;;;AAKA;A;;;;AAsBA;A;;;;AAkDA;AACA;A;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;ACzJA;A;;;;AAcA;A;;;;ACTI;;;A;AAEF;A;AAFsB;A;AAKxB;A;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;A;;;;;AAGA;A;;;;AAIA;AACA;AACA;AACA;AAEI;AACJ;AACA;A;;;AAIA;A;AAEC;A;AAEE;A;AAEF;A;AACS;A;AACT;A;A;AAID;A;;;;;;;;AAQA;A;A;;;;;;;;;A;AAIA;A;;;;;;;;;A;;;AA6BA;AACA;A;;;;A;;;AAiF6D;A;;;;;;A;;;;;A;;;AAEA;A;;;;AAG7D;A;;;;A;;;;AA6CA;A;;A;;;;;ACpMA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAEC;A;A;AAIE;A;AAEA;A;A;AAGF;A;AAED;A;;;;;A;;;;;AAUA;A;;;;;;;;;;;;A;A;A;A;;;;;;;;;;;;;;;;;;;ACpDA;A;;;;;AASA;A;;;;;;;;;;;;;;;;A;;;;A;;;;A;;;A;;;A;;;;A;;;;A;;;;;;;;;;;;;;;;;;;;;;;;A;AC8BC;AACA;A;AAED;A;;;;A;AAqBC;AACA;A;AAED;A;;;;AAoBA;AACA;AACA;A;;;;AA4BA;A;;;;AAYA;A;;;;AAYA;A;;;;AAQA;A;;;;;;A;;A;;;;;A;AAqBC;A;A;AAGA;A;AAED;A;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxKA;;A;AACC;;A;AACC;;A;AAED;A;AAED;AACA;AACA;A;;;;;;A;AAKC;A;AAED;A;;;;A;;;;ACHA;;A;AACC;A;AAEC;A;AAEA;A;AAED;;AACA;A;AAEC;A;A;A;A;;;;;;A;AAUF;A;AAEC;A;AAGD;AACA;AACA;A;AAEC;A;AAGD;A;A;;;;;A;;;AAQA;A;;AAMA;A;;;AAKA;A;;;;;A;A;ACHE;A;AAED;A;AAGG;AACJ;AACA;AACA;AACA;AACA;AAGC;;A;A;AAME;A;AAED;AACA;AACA;AACA;A;AAED;A;AAGC;A;A;AAGA;A;A;AAOA;A;A;A;AAMC;A;AAED;A;AAED;;A;A;AAEE;A;AAGD;A;AAEC;A;AAED;AACA;AACA;A;A;AAOE;A;AAED;A;AAOC;A;AAED;AACA;A;AAED;AACA;A;;AAEA;A;A;A;AAKD;A;A;;;;;;;;A;AAYA;AACA;A;AAID;A;AAEC;A;AAED;;A;AACC;AACA;A;AAQE;A;AAGD;AACA;;A;AACC;AACA;A;AAED;A;A;;AAOD;A;A;;;;;;ACcD;;;;;;AACC;AACI;;;AACH;AACA;AACA;;;;;AACC;A;;AAED;AANiC;A;AAQlC;AACA;A;;AAED;A;;AASA;A;;;AAIA;AACA;A;;;ACxMI;AACJ;A;;;;;;;;A;ACRC;AACA;A;AAED;;A;AAEC;A;A;AAGA;AACA;A;A;;;;;;;;A;AAUA;AACA;AACA;A;AAEE;AAAH;;A;A;AAEE;AACA;A;AAGD;;A;AAEC;A;A;A;AAID;A;A;;;;;;;;A;AASA;AACA;A;AAGD;AAEA;AAEA;;A;AACC;A;A;AAGA;AACA;AACA;A;A;;;;;;;;A;AAYA;AACA;AACA;A;AAID;A;AAEC;AACA;A;AAGG;;;AACH;AADuB;A;AAIxB;A;AAEC;A;A;;;;;;;AAOD;A;;;;;;AAK4B;A;;;;;;;;AACA;A;;;;;;;;;;;;;;;;;;;A;A;A;A;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;ACgJzB;;;AAAH;;A;A;;;;;A;A;;;;;A;;;;;;;;A;A;;;;;A;AAkBA;;AACK;AACJ;;;;AACA;A;A;AAGA;A;AAEA;A;AAED;A;;;;;;;;A;;;;;A;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;A;;;;;;;;;;ACzS+B;A;;;;AAYI;A;;;;A;AAwBlC;A;AAED;A;;;;A;AAoBC;A;AAGD;A;;;;A;AAMC;A;AAaD;A;;;;A;AAwLC;A;AAED;A;;;;;A;AAoBC;AACA;A;A;AAGA;AACA;A;A;;A;;;;;A;AAQA;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;A;;A;;;;;A;A;A;;;;;;;;;;;;;;;;ACzRD;A;;;;A;AAKC;A;AAED;A;;;;AAoBA;A;;;;AAYA;A;;;;;;A;;;;A;;;;A;AAcC;A;AAEA;A;A;;;;A;AAMA;A;A;AAGA;A;AAED;A;;;;;A;;A;;;;A;A;AAUE;A;AAED;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;AAYA;A;;;;AAIA;A;;;AAuBA;A;;;;A;AAKC;A;AAED;A;;;;AAQA;A;;;;AAgBA;A;;;;AAyBA;AACA;AACA;AACA;A;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;A;;;;ACjPA;A;;;;;;A;A;;;;;A;A;;;;;A;;;A;AC4BC;A;AAEA;A;A;AAGC;A;AAED;A;A;AAGA;A;AAED;A;;;ACqBA;AACA;A;AAGC;A;AAEC;A;A;AAQD;AACA;AACA;A;AAED;A;;;;;;A;A;;;;;A;A;;;;;A;AClEA;;;AACA;AACA;AACA;AACA;AACA;AACA;A;;;A;ACZC;A;AAEA;A;AAED;;;AACA;AACA;AACA;A;AAEC;A;A;A;AAIC;A;AAED;A;AAEG;A;AAEH;AACA;A;AAED;AACA;AACA;A;;;ACxBA;;;A;AAIC;A;AAED;A;;;;A;A;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;AC4HA;A;A;;;;;A;AAIA;AACA;A;AAKC;A;;;;;A;AAGD;AACA;A;A;;;;;A;AAIA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;AAKC;A;;;;;A;AAGD;AACA;A;A;;;;;A;AAIA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;A;;;;;A;AAOA;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;A;;;;;A;AAOA;A;AAEC;A;AAEG;A;;A;AAEF;A;AAFyB;A;A;AAM1B;A;AAED;;;A;A;;;;;A;A;;;;;A;;;;;;AAgBA;A;A;;;;;A;AAIA;AACA;A;A;;;;;A;AAOA;A;AAEC;A;AAEG;A;;A;AAEF;A;AAFyB;A;A;AAM1B;A;AAED;;;A;A;;;;;A;A;;;;;A;;;;A;AAYC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAOO;A;AAEN;AACA;A;AAEA;AACA;AACA;AACA;A;AAEA;AAGA;AACA;AACA;AACA;AACA;A;AAJA;AACA;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;AACA;AACA;A;A;;;;AAOD;AACI;AACA;;;AACH;AACA;A;AAGC;AACA;A;AAED;A;AAEC;AACA;A;AAED;A;AAEC;AACA;A;AAED;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;A;AAED;A;;;;;AAKA;AACI;;;AACH;A;AAGC;AAJkB;A;A;AAOnB;A;AAEC;AATkB;A;A;AAYnB;A;AAEC;AAdkB;A;A;AAiBnB;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;AA3BmB;A;A;;A;;;;AAmCS;A;;;;AAoC7B;AACI;;;AACH;A;AAEC;AACA;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAED;AACG;A;AACF;A;A;AAES;A;AACT;A;A;AAES;A;AACT;A;A;A;AAED;A;AAED;A;;;;A;AAQC;A;AAEA;A;AAED;A;;;;;;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;ACrfC;A;AAEG;;;AACH;A;AAEC;A;AAED;A;AAEC;A;A;AAGA;A;AAVuB;A;AAazB;A;;;;;A;AAKC;A;A;A;A;A;;;;;A;A;A;A;;;;;A;A;A;A;;;;;A;A;A;A;;;;;A;A;AAIA;A;AAkBD;A;;;;;AAIA;AACA;AACA;A;AAIC;A;A;AAIA;A;AAEA;AACA;A;AAID;AACA;AACA;;A;A;AAIG;A;AAED;AACA;AAPgB;A;A;AAWhB;A;AAEC;AAbe;A;A;A;AAiBf;AACA;A;AAEA;A;AApBe;A;A;AAwBjB;A;A;AAGA;A;A;AAGA;A;A;AASA;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAGA;A;AAED;AACA;;A;AAEE;A;AAF8C;A;AAKhD;A;A;AAIA;A;AAGD;AACA;A;;;;;;;;;AAQA;A;AAIC;A;A;AAIA;A;AAEA;AACA;A;AAID;AACA;AACA;AACA;AACA;AACA;;AACQ;A;A;A;AAGL;A;AAED;AACA;AAPgB;A;A;AAWhB;A;AAEC;AAbe;A;A;AAgBhB;A;AAEC;AACA;AACA;A;AAEA;A;AAtBe;A;A;AA0BjB;A;A;AAGA;A;A;AAGA;A;A;AASA;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAGA;A;AAED;AACA;;A;AAEE;A;AAF8C;A;AAKhD;A;A;AAIA;A;A;AAIA;A;AAED;AACA;A;;;;;;;AAQI;AACA;AAGJ;;A;AACC;AACA;AACA;A;AAMD;;A;AACC;A;AAED;;A;AAEC;AACA;AACA;A;AAID;AACA;;AACK;A;AAEH;A;AAEA;A;AAED;AACA;A;AAED;;AACK;A;AAEH;A;AAEA;A;AAED;AACA;A;AAID;A;AAMC;AACA;AACA;A;AAGD;;A;AACC;A;AAID;AACA;AAGA;;A;AACC;AACA;AACA;;A;AACC;A;A;A;AAMD;A;AAED;AAED;AAEC;AACA;AACA;AAED;AAEC;AACA;A;AAEC;A;A;;;;;A;;;;;;;A;AAsBA;A;AAED;A;AAEC;A;A;A;;;;;A;A;AAYC;AACA;A;A;AAIA;A;A;;;;;A;A;;;;;A;AAMF;A;;;;;A;AAOC;A;AAED;A;AAEC;A;A;A;;;;;A;A;AAWC;AACA;A;A;AAIA;A;A;;;;;A;A;;;;;A;AAMF;A;;;;;AAMG;;;A;A;;;;;A;A;AAMF;;;;;;A;A;AAIK;;;A;A;;;;;A;A;AAKJ;AACG;A;AACF;;;AACA;A;AAEC;A;A;;;;;A;A;A;AAMA;A;A;;;;;A;AAIJ;;;AACA;A;AAEC;A;A;;;;;A;;;;;AAME;;;A;A;;;;;A;A;AAMF;;;;;;A;A;AAIK;;;A;A;;;;;A;A;AAKJ;AACG;A;AACF;;;AACA;A;AAEC;A;A;;;;;A;A;A;AAMA;A;A;;;;;A;AAIJ;;;AACA;A;AAEC;A;A;;;;;A;;;A;AAwBA;;;AACA;A;AAED;A;;;;;;ACngBA;;A;;;;;AAIA;A;;;AAIA;A;;;AAIA;A;;;AAIA;A;;;A;AAeC;A;AAGD;A;A;A;A;AAUG;A;AAED;AACA;A;AAEA;AACA;A;AAEA;A;A;AAID;A;A;AAIA;A;AAEA;A;AAKG;A;A;AAGH;A;AAEA;A;AAEA;A;AAGD;AAEI;AACJ;;;;;AACK;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;A;AAKA;A;AAED;AAEA;A;AAGC;A;AAED;A;;AAGD;A;;;;;;A;A;;;;;A;AA+BA;AACA;A;AAEC;A;AAEA;AACA;A;AAIG;AACJ;;;A;AAEC;AACA;A;;;;;A;A;AAKA;A;AAGD;A;A;;;;;A;A;A;;;;;A;AAOA;A;AAEC;A;A;;;;;A;;;;;AC7KD;A;AAEC;A;A;AAGA;A;AAGD;AACA;A;AAGC;A;AAIA;AACA;AACA;AACA;AACA;AACA;A;AAIA;AACA;AACA;AACA;A;AAIA;AACA;A;AAED;A;;;;AAIA;;;;;AACC;A;;AAED;A;;;AAOA;;AACC;A;A;AAGA;A;A;;;;AAMG;AAGJ;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAID;AACI;A;;AACH;AACA;AAFgB;A;AAIjB;AACA;A;;;;AAUA;AACA;AAGI;AACJ;;A;A;AAIG;AACA;A;AAED;;AACC;AACA;A;AAED;A;AAED;AACA;AAdgB;A;AAgBjB;AAEI;AAGJ;;AACC;AACA;AACA;AACA;AACA;AACA;AANe;A;AAUhB;;AACC;AACA;A;AAEC;AACA;A;AAEA;A;AAED;A;AAGD;AACA;A;;;AAiGI;;;A;AAEF;A;A;AAGA;A;AALsB;A;AAQxB;A;;;AAKA;A;AAEC;A;AAGD;AACA;AAGI;AACA;A;;AACH;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAED;AAVgB;A;AAcjB;;AACC;AACA;AACA;A;AAEC;A;AAEA;A;AAED;A;AAGD;A;AAEC;A;AAED;AACA;A;;;;A;A;AASC;;AACC;AACA;A;AAED;A;AAEA;;AACC;AACA;A;AAED;A;A;;;;A;AAOA;A;A;A;AAKC;A;AAED;A;AAGD;A;;;;A;AASC;A;A;AAGA;A;AAEA;A;A;;;;;A;AAOA;A;AAED;AACA;A;;;;;A;AAMC;A;AAIG;;;AACH;A;AAEC;AACA;AACA;A;AALuB;A;AAWzB;AACA;AACA;A;;;;;A;AAOC;A;AAEG;AACJ;AACI;;;AACH;AADgC;A;AAGjC;;AACC;AADe;A;A;AAIf;A;AAED;A;;;;;;;ACzRA;AAEA;A;AAIC;AACA;AACA;A;AAID;A;AAGC;A;A;AAKA;AACA;A;A;AAMA;AACA;AACA;A;AAGA;A;AAGD;AACA;A;AAEC;A;AAED;A;;;;;;;AAQA;AACA;AACA;A;AAGC;AACA;A;;;;;A;AAGD;AAEA;A;AAEC;A;AAEA;A;AAED;A;;;;;A;AAQC;A;AAED;AACA;AACA;AACA;A;;;;;AAMA;;;;AACA;;;;AAGA;AACA;AAGA;AACA;AAEA;AAEA;AACA;A;;;;;;AAeA;A;AAGC;A;AAGD;AACA;AACA;AAGA;A;A;;A;AAIA;A;AAKC;AACA;A;AAEA;AACA;AACA;A;AAID;A;AAEC;A;AAED;AAGA;AACA;AAQA;AACI;A;AAGH;A;AAEA;A;AAGD;AACA;A;A;;A;A;;A;;;;;;;AA0BA;AACA;AAEA;;AACC;A;AAGC;A;AAEA;A;AAEA;A;A;AAKF;A;;;;;A;;;;;AAOA;;;AACA;AACA;AACA;A;;;;A;AAQC;AACA;AACA;AACA;A;A;AAGA;A;AAID;AACA;;AAEA;AACA;AACA;AACA;AAGA;AACA;AACA;AACI;;;;;;A;AAEF;AACA;A;AAED;AALmC;A;AAOpC;A;AAGC;AACA;AACA;A;AAEA;A;AAIG;AACJ;AACI;;;AACH;AACA;AACA;AACA;AACA;A;AAEG;;;AACH;AAD2B;A;AAG5B;AACA;AACA;AACA;A;A;AAIE;A;AAID;;AACC;AACA;A;AAGC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;AAkBD;A;AAEC;A;AAGG;;;A;AAEF;AACA;A;AAHyB;A;AAM3B;A;;;;A;AAaC;A;A;AAGA;A;A;AAGA;A;A;AAIA;AACA;;A;AAEE;A;AAEA;A;AAJY;A;A;AAQb;AACA;AACA;A;AAEA;A;AAED;A;AAED;A;;;;A;AASC;AACA;AACA;AACA;A;A;AAII;AACJ;AACI;;;AACH;AACA;AACA;AACA;AACA;A;AAED;AACI;;;AACH;AADmB;A;AAGpB;;;;AACA;;AACC;A;A;AAGA;A;AAED;AACA;A;AAED;A;AAGC;AACA;A;A;AAGA;AACA;A;AAGD;AAEA;AACA;AAIA;AACA;AACA;AAGA;AAEA;AAGI;AACA;;;;;;A;AAEF;AACA;A;AAED;AALmC;A;AAOhC;;;AACH;AACA;AACA;AACA;AAEG;A;AACF;AACA;AACA;AAGA;A;AAZ6B;A;AAe/B;AACA;AACA;AAII;AACJ;AACA;AACC;AACA;AACA;AACA;AACA;AACA;A;AAKC;A;A;A;;;;A;AAcD;A;AAED;;A;AACC;AACA;A;A;AAIA;A;A;AAIA;A;A;AAIA;AACA;A;AAED;A;;;AC1lBA;A;;;;AAMA;A;;;;AAII;AACA;A;A;AAGH;AACA;A;AAEA;AACA;A;AAEA;A;AAGD;AACA;AACA;A;A;AAKK;A;AAGH;A;AAEA;A;AAEA;A;AAED;A;AAIA;A;AAIA;A;AAED;A;AAIC;A;A;AAIA;A;AAGG;AACJ;AAEA;A;AAGC;AACA;;;AACI;AACJ;AACA;A;AAEC;A;A;A;AAKA;A;AAEA;A;AAEA;A;A;AAID;A;A;AAGC;A;A;AAGC;A;AAED;A;A;AAII;AACJ;AACA;AACA;A;A;A;AAID;A;AAED;A;;;AAKA;AACA;AACA;AACI;AACJ;A;AAEC;AACA;A;A;AAIC;A;AAEA;A;AAEA;A;A;A;A;AAMA;A;AAEA;A;A;AAGC;A;AAED;A;AAED;A;AAED;A;;;A;A;AAMC;A;AAEA;A;AAGA;A;AAEC;A;A;AAMA;A;AAED;A;A;AAGE;A;AAED;A;A;AAGA;A;AAED;A;AAID;A;;;A;AAQC;AACA;A;AAiBD;A;AAGC;A;AAMD;AACA;AACA;AAQI;AACA;A;AAEH;AACA;A;AAEA;AACA;A;AAED;AACA;AACA;AAKA;AAII;;;AACH;A;AAEC;A;AAED;AACA;A;AAEC;A;AAMD;AAIA;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AA/BoB;A;A;;;A;AA8CrB;A;AAID;A;AAEC;A;AAED;A;AAIC;AACA;AACA;A;AAEC;AACA;A;AAED;;AACC;AADgB;A;A;AAMlB;AACA;A;AAEC;A;A;AAGA;AACA;A;AAEA;A;AAED;A;AAKC;A;AAEA;A;AAEA;A;AAGD;A;;;A;AAOC;A;A;AAKA;AACA;AACA;;AACC;AADe;A;A;AAIhB;A;A;AAKA;AACI;;;AACH;AACG;A;AACF;A;AAED;AALqB;A;A;AASvB;A;;;A;AAOC;A;AAID;;AAGA;AAGA;A;AAEC;A;AAED;;AAEA;A;;;A;AAKC;A;AAED;A;;;A;AAKC;A;AAED;A;;;A;ACrbC;A;AAED;;AACA;A;;;;A;AAQC;A;AAED;;AACA;A;;;;AAKA;A;;;;A;AAOC;A;AAED;;AACA;A;;;;A;AAOC;A;AAED;;AACA;A;;;;A;AAMC;A;AAED;A;;;;;A;AA4BC;A;AAIG;AACJ;A;AAGC;A;A;A;AAYC;;AAIC;AACA;AACI;;;AACH;AACA;AACA;AACA;AACA;AALkB;A;AAUnB;AACA;AAEA;A;A;AAMF;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;AAEC;AACA;A;A;AAWD;AACA;AACA;AACA;;AACC;AACA;AACA;A;AAGD;AACA;A;AAGA;AACA;;AACC;AAIA;AACA;AACA;A;AAGD;AACA;A;A;AAKA;AACA;A;A;AAIA;AACA;A;AAED;AACA;A;;;AAIA;A;;;AC5LA;A;;;AAQA;AACI;;;AACH;AACA;A;AAEC;;;A;A;AAGA;AACA;AACA;AAT0B;;A;AAY3B;AAZ2B;;AAc5B;AACA;A;;;AAIA;A;AAEC;A;AAED;AACA;AACA;A;;;AAII;A;AAEH;AACA;AACA;A;A;A;AAIC;AACA;A;A;AAGD;AACA;AACA;A;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIC;AACA;AACA;A;AAEA;AAGA;AACI;;;AACH;AADoB;A;A;AADrB;AACI;;;AACH;AADoB;A;A;AAIrB;AACI;;;AACH;AADoB;A;A;A;AAKvB;A;;;AAQA;A;;;;AAMA;A;;;;AAOA;A;;;;AAMA;A;;;;AA0BA;A;;;;AAcA;A;;;;AAqBA;;AACC;;;AACA;A;A;AAGE;A;AAED;A;A;AAGA;A;A;AAGA;A;A;AAGF;A;;;;;;AAIA;A;A;;;;;A;A;;;;;A;A;;;;;A;AASA;A;;;;;;;A;AAoBC;AACA;A;AAEM;A;AAEN;AACA;A;AAEA;;;A;;;;;;;;;A;A;;;;;;;;;A;A;AAQA;AACA;A;AAED;AACA;AAEA;A;A;AAEC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEG;A;AAEH;AACA;A;AAEG;;;AACH;;;A;AAEC;AACA;A;AAED;AANkB;A;AAQnB;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;AACA;A;AAEA;A;AAEC;AACA;A;AAEG;;;AACH;A;AAEC;AACA;A;AAED;AANkB;A;AAQnB;A;AAEC;AACA;A;AAED;A;AAEA;A;A;AAGC;AACA;A;AAED;A;AAEA;AACA;A;A;AAED;AACA;A;;;;AASA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;A;AAIE;A;A;AAIA;AACI;;;A;AAEF;A;AAFsB;A;AAKxB;A;AAED;A;A;AAGA;A;A;AAGA;A;A;A;A;A;AAQE;A;A;AAGD;;;A;AAEC;A;A;A;AAKC;AACJ;AACA;;AACC;;;;;A;AAEC;A;AAED;A;AAEC;A;AAEA;AACA;A;A;AAIA;A;A;AAGF;A;;;;AAKA;A;;;AAMA;;;;AACA;;AACC;A;AAEC;A;AAEA;A;A;AAGF;A;;;AAMA;;;;AACA;;AACC;A;AAEC;A;AAEA;A;A;AAGF;A;;;A;A;AAiBE;A;A;AAIA;A;AAED;A;A;AAUA;;;;;;AACA;A;AAEC;A;AAED;AACA;A;AAGD;;;;;;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;A;AAmBC;A;AAED;AACA;AACA;A;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;A;ACjbC;A;AAED;A;;;;;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxFA;AACA;A;;;;AAgDA;A;AAEC;A;AAEA;A;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;;;A;AAKC;A;A;AAGA;A;AAED;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;;;AACA;AACA;;;AACA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAII;AACJ;AACA;A;;;AAII;AACJ;AACA;A;;;AAIA;AACA;AAEA;A;;;AAIA;AACA;AACA;A;;;;A;AAKC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAED;AACA;A;;;;AAQA;AACA;AACA;A;;;;AAKA;AACA;AACA;AACA;A;;;;;A;AAKC;A;AAED;A;;;;;AAGkC;A;;;;;;;;AAGlC;AACA;AACA;;A;AACC;AACA;AACA;;A;AACC;AACA;A;AAED;A;AAED;;A;AACC;AACA;AACA;A;A;AAGA;A;AAED;A;;;;;;;AAKA;AACA;;A;AAEC;A;AAED;A;;;;;;;AAIA;AAEI;AACJ;AACA;;A;AACC;;A;;AAEA;;A;AAID;AACA;AACA;;A;AAGC;A;AAGG;AAEJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEC;A;AAGD;A;;;;;;AAKI;AACJ;AACA;;AACA;;A;;;;;ACtMI;AACJ;;;;;;;;;;;;;;;;AACA;;AAGK;;;AACH;AACA;AAFmB;A;AAIhB;;;AACH;AACA;AACA;AACA;AACA;AALoB;A;AAQrB;;;;;;;;;;;;;;;;AAEI;;;AACH;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAZmB;A;AAepB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAGD;;;;;;;;;;;;;;;;A;;;;;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;;;;;A;ACpHA;AACA;AACA;;AACC;AACA;A;AAEC;A;A;;;;;A;A;;;;;A;A;AAOA;A;AAEA;A;A;A;;;;;A;;;A;ACdD;A;AAED;A;;;;A;ACwCC;A;AAED;A;;;;AAgBA;;;;;A;AAEE;A;A;;AAGF;A;;;;A;AAiBC;A;AAED;A;;;;A;ACAC;;;;;AACC;A;AAEC;A;A;AAGA;A;A;;AAGF;A;AAID;AACA;AACA;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAEA;A;A;AAGF;A;;;A;AAMC;;;;;AACC;A;AAEC;A;A;AAGA;A;A;;AAGF;A;AAID;AACA;AACA;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAEA;A;A;AAGF;A;;;AAKA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;;;;AAIA;AACG;A;AACF;A;AAED;A;AAEC;A;AAED;A;;;AAqEA;;AACA;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;A;AAsEC;A;A;AAIA;A;AAID;AACA;AACA;;AACC;A;AAEC;A;AAEA;A;A;A;AAID;A;AAME;A;AACF;A;AAED;A;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AChWA;;A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;A;;;;;AAIA;A;;;A;AAKC;AAKA;AACA;AAEA;A;AAEC;A;AAEC;A;AAEG;AACA;;;AACH;AACA;A;AAFmC;A;A;AAMnC;AANmC;A;AAWpC;AACI;;;AACH;AACA;A;AAFmC;A;A;AAMnC;AANmC;A;AAWpC;AAMA;AACA;A;A;A;AAKA;A;AAKA;A;AAEC;A;A;AAGA;A;AAED;A;AAKA;AACA;AACA;;;;;AACC;A;;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;AAEC;A;AAED;A;AAQA;AACA;AACA;;;;;AACC;AACA;A;;AAKD;A;AAMA;A;AAKA;A;AAIA;A;AAIA;AACA;AACA;;;;;AACC;AACA;A;AAEC;A;AAED;A;;AAMD;A;A;AAQF;A;;;AAIA;AACA;A;;;;AAaA;A;;;;;AAIA;A;;;;;AAMA;A;;;;;AAaA;A;;;;;AAIA;A;;;;;;A;;A;;;;;;A;;A;;;;;AAiBiC;A;;;;;AACA;A;;;;AAGjC;AACA;AAKA;A;;;;AAQA;A;;;;AAIA;AACA;AACA;A;;;;AAMA;A;;;;AAIA;AACA;AACA;A;;;AAII;AACJ;AACA;A;;;AAIA;A;;;AAIA;AACI;;;AACH;AACA;AAFgC;A;A;;;;AAOjC;;AACA;;;;;;;;;A;AACC;;A;AAED;;A;;;;;;AAIA;;;A;AACC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;AAGD;;;AAAgH;;;A;;;A;;;;;A;AAK/G;A;A;AAGA;A;AAED;A;;;;;A;AAKC;A;AAED;;A;;;;;;AAYA;;;;;;;A;AACC;A;AAGD;AACA;;;;;;AACC;A;;AAED;AACA;;;;;;AACC;A;;AAED;A;;;;;;AAaA;A;;;;AAIA;A;;;;;AA2CA;;A;;;;;A;A;AAMC;A;AAEA;A;AAEA;A;A;;;;AAKD;;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAoCA;A;;;AAiBA;A;AAEC;A;AAED;AACA;A;;;AAIA;;AACA;A;AAEC;A;AAED;A;;;;AAIA;;;AACA;AACA;AACA;;;A;AACC;AACA;AACA;A;AAED;AACA;AACA;AACA;A;;;;;AAIA;;AACA;A;;;;AAgBA;;AACC;A;AAEC;A;AAGD;A;A;;;;AAKD;A;;;;AAIA;AACI;A;AAEH;A;AAEA;A;AAEC;A;AAED;AACA;AAGA;A;AAED;;;;A;;;;;AAIA;AACI;A;AAEH;A;AAEA;A;AAEC;A;AAED;AACA;AACA;A;AAED;;;;A;;;;AAIA;AACA;AACA;A;;;AAIA;A;;;;AAII;AACJ;;A;AACC;;A;AAGG;AACG;;A;AACP;;;;;A;AACC;AACA;AACA;AACA;AACA;A;A;AAEA;;;;A;AACC;;;A;AACC;AACA;A;AAED;AACA;;;;;AACA;A;AAED;A;A;AAEA;AACA;A;A;AAEA;A;;AAEA;A;A;AAED;;;A;;;;;;;AA4CI;A;AAEH;A;AAEC;A;AAED;A;AAEC;A;AAED;AACA;A;AAEA;A;AAEC;A;AAED;A;AAEC;A;AAED;AACA;A;AAED;A;AAEC;A;AAED;AACA;A;;;;A;AAKC;A;A;AAGA;A;AAED;;A;AACC;;A;A;AAIA;A;AAED;A;;;;AAIA;A;;AAIA;A;;;;;;A;AAKC;A;AAGD;;AACA;A;AAEC;A;AAED;;AACC;A;AAED;;A;;;;;A;A;AAMC;A;AAEA;A;A;;;;;;A;AAMD;;;;A;AACC;A;AAEA;;A;AAEI;;;AACH;;;A;AACC;A;AAF4B;A;A;A;AAM/B;A;;;;;;;;;A;AAKC;A;;A;AAGD;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACC;A;;AAED;AACA;;;;;AACC;A;;AAED;;AACA;AACA;AACA;;AACC;AACA;A;AAED;AAEA;A;;A;;;;;;A;AAMC;A;A;AAGA;A;AAEC;A;A;AAEC;A;AAEA;A;A;AAGC;AACA;A;AAED;AACA;AACA;AACA;AACA;A;A;A;AAGF;A;AAED;A;;;;;;AAIA;;A;AACC;;A;AAID;;;;A;AAGC;AACA;AACA;A;A;AAIC;A;AAKD;;A;AAEC;A;AAEA;A;AAED;A;A;AAID;A;;;;;;;;AAOC;AACA;AACA;A;AAGA;;;AACA;A;AAEC;A;A;AAGD;AACA;AACA;A;A;AAIA;A;AAGD;AACA;A;A;AAGE;A;A;AAGA;A;A;AAGA;A;A;A;AAIA;A;A;AAGA;A;A;AAGA;A;A;AAGF;;;;;A;AAEE;A;A;;AAGE;;;AACA;;;;AAAH;;;A;AACC;;;A;AAFiB;A;AAKnB;;A;AAEC;AACA;;AACA;;AACI;;;AACH;AACG;AAAH;;;A;AACC;;;A;AAED;;AALkB;A;AAOnB;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAED;AAEA;AACA;;;;;;AACC;;;;;;;;;A;;AAED;;A;AAGA;;;A;AACC;A;AAEA;;A;AAEA;AACA;;;;;AACC;;A;;AAED;A;A;A;;;;;;;AAKD;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAOC;A;AAED;A;;;A;AAKC;A;AAED;A;;;;;AAIO;A;AACP;;;A;AACC;A;AAEC;A;AAED;AACA;;A;A;AAIC;A;AAED;AACA;AACA;AACA;AACA;A;AAGA;A;A;A;;;;;;;;;;;;A;AAMA;A;AAED;A;AAEC;A;AAGD;AACA;AACA;AAEA;A;A;AAGE;A;AAEA;A;A;AAIC;AAAH;;A;AACI;AAAH;;A;AACC;;AACC;;AACA;;A;AACC;AACA;AACuC;A;;AACC;A;A;AAGzC;;A;AACC;;A;A;A;A;AAMJ;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;;;;;AAIA;;AAEC;AACA;;AACC;A;AAED;A;AAEC;A;AAKD;AACA;;AACC;A;A;AAGA;A;AAED;AACA;AAGA;AACA;;A;AAEE;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;;AACA;A;A;AAGF;A;;;;;;;;;;;AAIO;A;AACP;;;;A;AACC;A;AAEC;A;AAED;AACA;AAEA;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;AAGA;A;AAEC;A;AAED;AACA;AACA;AAEA;AACA;AACA;;A;AACC;AACuC;A;;AACC;A;A;AAGzC;;A;AAGA;A;AAEC;A;AAED;AACA;AACA;A;AAGA;A;A;A;;;;;;;AAKD;A;;;;;AAIO;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;;AAKM;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;;AAKM;A;A;A;AAGL;A;AAED;A;A;AAGC;A;AAED;A;A;AAGC;A;AAED;A;AAEA;A;A;;;;;;AAKD;AACA;AACA;;AACA;;A;A;AAEC;;;;A;AACC;A;A;AAEA;;A;A;AAEA;A;;AAEA;A;A;AAED;A;AAED;A;;;;;;;;AAIA;AACA;AACA;;;A;AACC;A;AAED;AACA;;;;;A;AACC;AACA;AACA;AACA;AACA;A;AAED;A;;;;;;;AAIA;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;;;AAKC;AACA;AACA;AAEM;A;AACP;;;;A;A;AAEE;A;AAED;AACA;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;AAGA;A;AAEC;A;AAED;;A;AAGA;A;A;A;AAIA;A;AAGD;;A;;;;;;;AAKC;AACA;AACA;AAEM;A;A;A;AAGL;A;AAED;AACA;AACA;AACA;A;AAGA;AACA;AACA;A;AAGA;A;A;AAIA;A;AAGD;;A;;;;;;AAIA;AACA;AACA;A;;;;;;;AAMA;A;AAEC;A;AAED;;A;A;;;;;A;AAIA;AACA;A;;;;;A;;;;;AAKA;A;AAEC;A;AAED;;A;AAEC;A;AAED;A;;;;;;;;ACv4CA;;A;AAEC;A;AAGD;A;A;AAGC;;AAAwB;A;A;AAExB;;A;AAEE;A;A;A;AAIH;AACA;AACA;;A;AAEE;A;AAED;AACA;AACA;AACA;AACA;A;A;;;;;;ACwYD;A;;;;;AAIA;A;;;;;A;AAsKC;A;AAED;A;;;;;AAiKA;A;AAEC;A;AAED;A;;;;;AAGgC;A;;;;;A;AAI/B;A;AAED;A;AAEC;A;AAED;A;;;;;AAG6B;A;;;;;AAEK;A;;;;;AAEL;A;;;;;AAII;A;;;;;AAGjC;A;AAEC;A;AAED;A;;;;;A;AAKC;AACA;A;AAED;A;;;;;;;;A;AAuCC;A;;;;A;AAGD;A;A;;;;;A;AAKA;;;;;;AACC;;A;A;;;;;;A;A;;A;;;;;A;;;;;;A;AASA;A;AAED;A;AAEC;A;AAED;A;;;;;A;AASC;A;AAED;AACA;AACA;;A;AAEE;A;AAED;A;AAED;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAED;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;AAKC;A;AAED;AACA;A;;;;;A;A;AAwCC;A;AAEA;A;AAEA;A;AAED;A;;;;;;A;AAMC;A;AAED;AACA;AACA;A;AAEC;A;AAEC;A;A;AAGF;AACA;AACA;A;;;;;AAIyC;A;;;;;;;A;AAKxC;A;AAEG;AACJ;;;;;AACC;A;A;;;;;A;A;;AAKD;A;;;;;AAmCA;;AACA;A;;;;;;;AAaA;;AAEC;AACA;;AACC;A;AAED;A;AAEC;A;AAOD;AACA;;AACC;A;A;AAGA;A;AAED;AACA;AAGA;AACA;;A;AAEE;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;;;A;AAEC;A;A;;;;;A;A;A;;;;;A;;;;;;A;AAWF;A;AAED;AACA;AACA;AACA;A;AAEC;A;AAEE;A;AACF;A;AAED;AASA;AACA;A;;;;;;;AAQA;AACA;;;;;;AACC;;A;AACC;AACA;;;;;;;A;AACC;;A;AAED;A;AAED;;A;;AAED;A;;;;;;;;;AAoBA;AACA;AAQI;AAOJ;AAEA;;AACC;;;;AACA;AACA;AAMA;;;;;AACC;AACA;;A;AAIC;;A;AAED;AACA;;;;;AACC;AAEA;AACI;AACJ;;A;AAEC;AACA;;A;AACC;;A;A;AAKF;;;A;A;A;;;;;A;AAMC;AACA;AACA;AACA;AACA;AACA;;A;A;AAOA;;A;AAED;A;AAEC;AACA;;A;A;AAGA;A;AAED;A;AAEC;A;AAEG;AACJ;AACA;AACA;A;;A;;A;AAID;A;A;AAGF;A;;;;;;;;;;AAOA;A;AAEC;;;;;AACC;A;A;;;;;A;A;AAKC;A;A;;A;A;AAKF;A;A;;AAE8C;A;;;;;A;;;;;AAgB/C;A;;;;;;A;AAwDC;A;AAED;;;A;AACC;A;AAED;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;;;A;AAKC;A;AAED;AACA;;A;;;;;A;AAUC;A;AAED;A;AAEC;A;A;AAgBA;AACA;AACI;;;AACH;AACA;AACA;AACA;A;A;AAGE;A;AAEC;A;AAED;A;AAEC;A;A;AAb4B;A;A;A;AAmB3B;A;AACF;A;A;AApB6B;A;AAwBhC;A;AAGD;A;AAEC;A;AAED;AACA;AACI;;;AACH;AACA;AACA;AACA;A;A;AAGE;A;AAEC;A;AAED;A;AAEC;A;A;AAb2B;A;A;A;AAmB1B;A;AACF;A;A;AApB4B;A;AAwB/B;A;;;;A;AAWC;A;A;AAMA;A;AAID;;A;;;;;A;AAKC;A;AAGD;;;;;;;;A;AACC;A;AAGD;;;;;;A;;;;;A;AAKC;A;AAGD;A;AAEC;A;A;AAMA;A;A;AAKD;;;;;;;;A;AACC;;;;A;AAMA;;;;;A;AACC;A;AAID;;;;A;AAGA;AACA;A;AAEC;A;AAEG;;;AACH;;;A;AACC;A;AAFyB;A;AAKvB;;;AACH;;;A;AACC;A;AAF0B;A;AAK5B;A;AAGA;AACA;A;AAEC;A;AAID;A;AAGA;;;;;A;AAGA;;A;AAGA;AACA;A;AAEC;A;A;AAGA;A;AAED;;;;;AACC;AACA;A;AAEC;A;AAED;;;A;AACC;A;A;AAGA;A;A;AAGA;A;A;;AAGF;A;A;AAGD;A;;;;A;AA4yCC;A;AAED;A;;;AA6GA;A;;;;AC59FA;A;;;;;A;AAKC;A;AAED;A;;;;;A;AAOC;A;A;AAGA;A;AAED;A;;;;;A;AAiEC;A;AAED;A;;;;;A;AAyCC;A;A;;;;;A;AAQA;A;A;AAGA;A;A;;;;;A;AASA;A;A;AAIA;A;A;AAGA;A;A;;;;;A;AAWA;A;AAED;A;;;;;AAMA;AACA;A;;;;;;AAMA;AACA;;;A;AACC;A;AAGD;A;;;;;;;AAMA;AACA;;;A;AACC;A;AAGD;A;;;;;;AASA;A;;;;;AASA;A;;;;;;AAYA;AACA;AACA;;A;;;;;;;AAWA;AACA;AACA;;A;;;;;;AAubA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;;AA6EA;;A;AACC;;A;AAED;AACA;;;;;;AACC;;A;AACC;;;;;A;A;AAEE;A;AAED;;A;A;AAGF;;A;;AAED;A;;;;;;;AAOA;AACG;;;;AAAH;;A;AACC;;A;AAED;A;;;;;;;AAQG;;;;AAAH;;A;AACC;;A;AAED;A;;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAsDA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;A;AAMC;A;AAED;A;;;;;;;A;;;A;;;;;;AAwFA;A;;;;;AAMA;A;;;;;;AA8BA;AACA;AASA;;AAEI;A;AAEH;A;AAEA;A;AAED;A;AAEC;A;AAED;AACA;AACA;AACA;A;;;;;;;AAQA;AACA;AACA;AAEA;AAEA;AACA;A;AAEC;A;AAED;AACA;AACI;AACA;;;AACH;;A;AAKC;A;AAED;AACA;AATsB;A;AAWvB;A;;;;;;;A;AAaC;A;AAED;;;A;AACC;A;AAGD;AACA;AACA;;;;;;A;;;;;;;A;AAMC;A;AAED;;;A;AACC;A;AAGD;AACA;AACA;;;;;;A;;;;;;;AAOA;;A;AACC;A;;AAEA;;;A;AACC;A;AAED;A;AAED;;A;;;;;;AAoBA;AACA;A;;;;A;AASC;AACA;AACA;A;AAED;A;;;;A;AASC;A;A;AAGA;A;A;AAGA;A;AAED;AACA;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAED;A;;;;;;A;AAUC;A;A;AAGA;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;AAMA;AACA;AACA;A;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAMA;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;AAMA;A;A;AAGC;AACA;AACA;A;AAED;A;;;;;AAMA;A;A;AAGC;AACA;AACA;A;AAED;A;;;;;;;;AAsDA;AACA;A;;;;;A;;;;;;;;;AAOA;A;AAEC;A;AAED;AACA;AACI;A;AAEH;AACA;AACA;A;AAEA;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;AAOA;AACA;AACA;;A;;;;;;;;;AAMA;A;AAEC;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;A;;;A;;;;;;AA0BD;AACA;AACA;A;;;;;;AAiBA;AACA;AACA;;;A;AACC;A;AAED;A;;;;;;;AAMA;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;;AAWD;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;;AAWD;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAVA;A;A;;;;;;AA+CD;AACA;AACA;AACA;AACA;;AACI;A;AAEH;A;AAEA;A;A;AAGA;AACA;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;AAED;A;;;;;;;AAMA;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAZA;A;A;;;;;AAmBD;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;;AA4HO;A;A;AAEN;A;AAEA;A;AAID;;A;;;;;;;;;AASA;AACA;A;;;;;A;;;;;;;AASA;AACA;AACA;;A;;;;;;AAKA;A;AAEC;A;A;AAIA;A;AAKD;A;AAGC;A;AAEC;A;AAED;AACA;A;AAGD;A;AAEC;A;AAED;AACA;A;;;;;AAMA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;A;AASC;A;A;AAGA;A;AAED;A;;;;A;AA6ZC;A;AAED;AACA;AACA;AACA;A;;;;;;AAsDA;;A;AACC;;A;AAED;;;AACA;;A;AACC;;A;AAED;;A;;;;;;A;AAOA;;;;;;;A;A;A;AAGE;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;AAEA;A;AAEA;A;A;A;A;A;AAMA;A;A;A;AAID;;;;;A;A;;A;AAGE;A;AAEA;A;A;A;A;A;AAKF;;;;;A;A;;A;AAGE;A;AAEA;A;A;A;A;A;AAMH;;;A;AACC;A;AAID;;;;;;;;;A;AAGC;A;A;A;AAKC;A;AAED;A;AAGD;A;;;;;AAwBA;;AACA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAMA;;AACA;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAIA;;AACA;AACA;AACA;A;;;;;AAUA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAKA;;;;;;A;;;;;AAoBA;;;AACA;;AACA;;;A;AACC;A;;AAEA;A;AAED;;A;;;;;AAKA;;A;AACC;;AACA;AACA;A;AAED;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;ACz/EA;;;;AACA;;AACC;AAEA;;;A;AACC;A;;AAEA;A;A;AAIF;A;;;;;;;;AAWA;;AAAyC;A;;A;;;;;;;AAsBJ;;A;;;;;;ACxFrC;;AACA;;AACA;AACA;A;;;;;;;ACKI;;;AACC;;;;;;AACH;AADuC;A;AADlB;A;A;;;;;;AAUvB;AACA;AACC;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;;A;AACC;A;AAED;AACA;A;A;;;;;;AAKD;AACA;AACA;AAGI;;;AACH;AAD8B;A;AAK3B;;;AACH;AACA;AAFwB;A;A;;;;;;AAYzB;;;A;AACC;A;AAGD;;;A;AACC;AAEA;;;A;AACC;A;A;A;;;;;;AAOE;;;AACH;AADkB;A;A;;;;;;;;AAMnB;AACA;;A;AAEC;AACA;AACA;AACA;A;AAED;AASA;AACA;;;;AAEA;;;;;AAAoC;A;AAEpC;AACA;AACC;;;;;AAAqC;A;AAErC;;;;;AAAsC;A;A;AAGrC;A;AAGD;AACA;AACA;A;AAID;AACA;;A;AAEC;AACA;;;A;AACC;AACA;AACA;A;AAED;;;A;AACC;AACA;A;AAKD;;;A;AACC;AACA;AACA;A;AAGD;A;AAED;;A;AAKC;AACC;;;;;AAAuC;A;AAEvC;;;;;AAAoC;A;A;AAGnC;A;AAGD;AACA;AACA;A;A;AAIF;A;;;;;A;;;;;AAKA;;AACC;;A;AACC;AACA;A;AAED;AACA;;;;AAGA;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAGF;;A;AAGK;;;AACH;;;A;AACC;A;AAFqB;A;AAKvB;A;A;;;;;;AAQD;;AACA;A;;;;;;AAMI;AACA;;;AACH;AADkB;A;AAGnB;A;;;;AA2CuC;A;;;;;AACA;A;;;;;AACA;;;;A;;;;;;AAGb;A;;;;;;;AA+BN;A;;;;;;;AAkDpB;;;;A;;;;;;;AAIA;AACA;;;;AACA;;AACC;AACA;AACA;A;AAED;AAEA;;AACC;;;;AACA;;AACC;AACA;AACA;A;AAEE;AAAH;;A;AACC;A;AAED;A;A;;;;;;AA2BD;;A;AAIC;AACA;AACA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIE;;;AACH;AADoB;A;AAGrB;A;AAMD;;A;AAIC;AACA;AACA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIE;;;AACH;AADkB;A;AAGnB;A;AAGD;AACA;AACI;;;;A;AAEH;AACA;A;AAEA;AACA;A;AAED;AAEA;;AACC;AACA;;;A;AACC;A;;AAEA;A;A;AAIF;AACA;;A;AACC;A;AAED;;A;AACC;A;AAED;;A;AACC;A;A;;;;;;AASD;AACA;AAEA;;AACC;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAIF;A;;;;;;AC5eI;;;AACC;;;;;;AACH;AADuC;A;AADlB;A;A;;;;;;AASvB;AACA;AACC;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;;A;AACC;A;AAED;AACA;A;A;;;;;;AAMD;AACA;AACA;AACI;;;AACH;AAD8B;A;AAG3B;;;AACH;AACA;AAFwB;A;A;;;;;;AAQzB;;;A;AACC;A;AAED;;;A;AACC;AACA;;;A;AACC;A;A;A;;;;;;;;AAcF;AACA;;A;AACC;AACA;AACA;AACA;A;AAED;AACA;AACA;;;;AACA;;;;;AAAoC;A;AAEpC;AACA;AACC;;;;;AAAqC;A;AAErC;;;;;AAAsC;A;A;AAGrC;A;AAED;AACA;AACA;A;AAED;AACA;;A;AACC;AACA;;;A;AACC;AACA;AACA;A;AAED;;;A;AACC;AACA;A;AAED;;;A;AACC;AACA;AACA;A;AAED;A;AAED;;A;AACC;AACC;;;;;AAAuC;A;AAEvC;;;;;AAAoC;A;A;AAGnC;A;AAED;AACA;AACA;A;A;AAGF;A;;;;;A;;;;;AAMA;;AACC;;A;AACC;AACA;A;AAED;AACA;;;;AACA;;A;AACC;AACA;A;;AAEA;AACA;A;A;AAGF;;A;AACK;;;AACH;;;A;AACC;A;AAFqB;A;AAKvB;A;A;;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;ACpIwC;A;;;;;;AACA;;A;;;;;;AAEzC;;;;AACA;;;;A;;;;;AAuBA;;;A;AACC;A;AAED;AACA;AACA;AACI;;;;AACH;;AACA;;AAFwB;A;AAIzB;AAIA;AACA;A;;;;;;AAQA;;;;A;AAEC;A;A;AAGD;;;;;;;;;;;;A;AACC;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;A;AAEA;;;;AACG;A;AACF;A;AAED;A;AAEA;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGD;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGE;;;A;AACF;A;AAED;;;;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAGG;;;AACA;;;;;;A;AACF;A;AAF+B;A;AAKjC;A;AAEI;;;AACA;;;;;;A;AACF;A;AAF0B;A;AAK5B;A;AAEG;;;A;AACF;A;AAED;;;;;;;;;;A;AAEC;A;AAED;;;;;;A;AAGA;;A;A;A;;;;;A;A;AAYC;A;AAED;A;A;AAGA;A;AAED;A;;;A;AAOC;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;AAIA;A;;;;;;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxMA;A;AAEE;AACA;A;A;A;;A;AAOD;A;AAED;A;;;AAIA;A;AAEC;AACA;A;AAGD;AACA;AACC;A;AAEC;A;AAED;AACA;A;A;;;AASD;A;;;;AAKA;;;;;;A;AAEE;A;A;;AAGF;A;;;AClDA;A;AAEC;A;AAED;AACA;AACA;AACI;;;AACH;AACA;AAFiC;A;AAIlC;A;;;;AAwBA;AACC;A;A;A;AAKC;A;AAED;AACA;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIG;A;AACF;A;;;;;;;A;A;AAIA;AACA;AACA;AACA;A;;;;;;;A;A;AAIA;A;AAED;A;;;;;;;A;;;;;;;AAKG;A;AACF;A;;;;;;;A;A;AAIA;A;A;;;;;;;A;;;;AAiCD;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;AACA;A;;;;;;A;A;;;;;A;A;A;;;;;A;A;;;;;A;;;A;A;AC3GC;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAGA;A;A;;;A;A;AAOA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAGA;A;A;;;;;;AASD;AACA;AACA;;AACC;;;A;A;;;;;;;A;AAIA;AACA;AACA;;;A;AAEC;A;A;AAGA;A;AAGD;;;A;AAEC;A;AAED;AACA;;;;;;A;AAEE;AACA;A;A;;A;AAKD;A;AAED;AACA;AACA;A;A;;;;;;;A;;;;ACHyB;A;;;;;AAG1B;;;A;A;;A;A;AAKC;A;AAEA;A;AAED;;A;;A;;;;A;;;A;;;A;ACnGC;A;AAED;A;;;AAII;AACJ;AACA;;AACC;AACA;AACA;A;AAED;AACA;A;;;;;;A;;;;;A;;;;;ACuEA;A;;;;;A;ACoQC;A;AAED;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;A;AAKC;A;AAED;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;AAIA;AACA;A;AAEC;A;A;AAGA;A;AAED;AACI;;;AACH;AADkB;A;AAInB;A;AAEC;A;A;AAGA;AAEA;A;AAGD;;A;;;;;A;AAeC;A;AAED;AACA;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;;A;;;;;AAYA;AACA;AACA;AACA;AACA;;A;;;;A;A;AAMC;;;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAGA;;;AACA;A;AAOC;A;AAQD;AACA;;AACC;A;AAED;AACA;AACA;A;AAGA;;;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAGA;;;AACA;AACA;AACA;AACA;AACI;;;AACH;AAD6B;A;AAG9B;A;AAED;A;;;;;;AAII;AACA;AACJ;;;A;AAEC;A;AAED;;;A;AAEC;AACA;A;AAED;A;;;;;;;AAII;AACA;AACJ;;;A;AAEC;A;A;AAGA;A;AAED;;;A;AAEC;AACA;A;AAED;A;;;;;A;;;;A;;;;;;;;;AAiEI;AACA;AACJ;;;AACA;AACI;A;AAEH;AACA;A;AAEG;A;A;AAGE;AACJ;;;A;AAEC;A;A;AAIA;AACA;A;A;AAGF;AACA;A;AAED;AACA;AACG;;;A;AACF;A;AAED;AACA;A;AAGC;;;A;AAED;A;;;;;;;;;;AASI;AACA;AACJ;;A;AACK;AACJ;;;;;A;A;;;;;A;A;AAKG;AACJ;AACA;AACI;A;AAEH;AACA;A;AAEG;A;A;AAGE;AACJ;;;A;A;;;;;A;A;AAMC;AACA;A;A;AAGF;AACA;A;AAED;AACA;AACG;;;A;A;;;;;A;A;AAIF;A;A;;;;;A;;;;;;;A;;;;A;;;;AAmKD;A;;;AAIA;A;;;AAIA;;;A;AAEC;A;AAED;A;;;;A;;A;;;;;ACtuBA;A;;;;;AAIA;A;;;;;;;;;A;A;;;;;A;AClFA;;;;A;A;;;;;A;AAMI;AAOJ;AAGA;AACA;AACA;AACA;A;;;;;A;;;;;;;;A;A;;A;AAUA;AACA;AACA;AACA;A;A;;A;AAMG;;A;A;;A;AAGH;A;;A;;;;;;A;AAeC;A;AAEC;A;A;AAGF;A;;;;;AAIA;A;;;;;AAIA;A;;;;A;A;AAgBC;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAoBA;;;A;A;AAGE;A;A;AAGA;A;A;A;AAID;A;AAED;A;;;;;;A;AAKC;A;AAED;;;A;AAEC;A;A;AAGA;A;AAED;A;;;;;;AAuDI;AACJ;AACA;A;;;;;A;;;;;;;AAKI;AACA;AACD;;;A;AACF;A;A;AAGA;;;A;AAED;A;;;;;;AAIA;;;;;A;A;;A;A;;A;;;;;;A;;A;;;;;AAYI;A;;A;;;;;A;;A;;;;;A;;;;A;;;;;A;;;;A;;;;;A;;;;A;;;;;AC0BJ;;A;AAEC;A;AAED;A;;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;AA0DA;;A;AAEC;A;AAED;A;;;;;AAMA;;A;AAEC;A;AAED;A;;;;;;AAqBA;;;AACA;A;AAEC;A;AAED;A;;;;AA0BA;;A;AAEC;A;AAED;A;;;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAgQI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;AAsQI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;AAsCA;;A;AAEC;A;AAED;A;;;;AAoGA;;A;AAEC;A;AAED;A;;;;;AAMA;;;;A;AAEC;A;AAED;A;;;;;AAgBA;;A;AAEC;A;AAED;A;;;;;;AAyFI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;AAkGA;;A;AAEC;A;AAED;A;;;;;;AAyDA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;AA0BI;AACJ;;;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;AA2BA;;A;AAEC;A;AAED;A;;;;AAMA;;A;AAEC;A;AAED;A;;;;;AA+CI;A;AAEH;A;AAEA;A;AAED;;;;;AACA;A;AAEC;A;AAED;A;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;;;AACA;A;AAEC;A;AAED;A;;;;;AAMA;;;AACA;A;AAEC;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvnDA;;;A;;;;;A;;;;;A;AAOC;A;AAED;A;;;;;;;AAOG;;;A;A;;;;;A;A;AAIF;A;AAED;A;;;;;A;;;;;A;AAOC;A;AAED;A;;;;;;AAcA;;;;;;A;A;;A;;;AACC;;;A;AACC;A;A;;A;;;;;;;A;ACrDD;A;AAED;A;;;;;A;AAMC;A;AAED;A;;;;;AAgDA;A;AAEC;A;A;;;;;AAMD;A;;;;;A;AAMC;A;A;;;;;;;A;ACvDA;A;A;AAGA;A;AAED;AACA;AACC;AACA;A;AAED;A;;;;;;;;ACQA;;A;AACC;;A;AACC;;A;AAED;A;AAED;AACA;AACA;A;;;;;;A;AAMC;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/CI;A;;;AAcJ;AACA;AACA;AACA;A;AAEC;AACA;A;AAED;AACA;A;;AAIA;A;;;;;;AAIA;A;;;;;;;A;;;AA6CA;A;;;A;AC8CC;A;AAED;AACA;A;;;;;;AAMI;;;AACI;A;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;;;;;;;A;A;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;AA2GL;AACA;AACA;;AACC;A;A;AAIA;A;AAEC;A;AAED;A;;;;;;;A;A;A;AAvHyB;A;A;;;;;;;A;;;AAqLzB;;;AACH;AACA;A;AAGC;AACA;A;AAEC;A;A;AARsB;A;AAYzB;A;;;AAIA;;;;;;A;AAEE;A;A;;AAGF;A;;;AAOA;A;AAEC;AACA;A;AAIG;AACJ;AACA;;AACC;AACA;AACA;AACA;A;AAED;AACA;AAGI;;;AACH;AADiC;A;AAIlC;A;;;;;AAQA;A;AAEC;AACA;A;AAED;;;;AACA;A;A;;;;;A;A;AAKC;A;A;;;;;A;;;AAQD;AACI;AACA;;;AACH;AACA;AACA;A;A;AAIA;A;A;AAGA;;AACC;A;A;AAGA;A;A;AAGF;AACA;A;;;;;AAcA;;A;AAIC;AACA;A;AAEC;AACA;A;AAED;;;;AACA;;;;AACI;AACJ;AACA;AACA;A;AAEC;AACA;A;AAED;AACA;AACA;AACA;A;AAED;A;;;;;;;AAqBI;AACJ;A;AAEK;AACJ;A;AAEA;A;AAED;;AACA;A;;;;;;;AAOC;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AAGD;;AACC;;;;A;AAEC;A;A;AAGA;A;AAED;A;AAIC;;;;A;A;AAKA;;;;A;AAGD;A;A;AAEC;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEA;A;A;AAGC;A;AAED;A;AAEA;A;AAEA;A;AAGA;A;AAEC;A;AAED;A;AAGA;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;A;A;AAIA;A;AAEA;A;A;A;AAMA;AACA;A;AAED;AACA;A;AAEC;AACA;AACA;A;AAEA;A;AAED;A;AAEC;A;A;AAGA;A;A;A;AAMC;A;AAED;A;A;A;AAKA;AACA;A;AAID;A;AAEC;AACA;A;AAEA;A;AAED;AACA;A;AAEA;A;A;A;AAGF;A;;;;;AAeA;A;;;;A;AAMC;A;AAMD;A;;;;A;AAOC;A;AAED;AACA;A;;;A;AAQC;A;A;A;AAIC;A;AAED;A;AAED;A;;;AAIA;;AACC;A;AAED;A;;;AAMA;;A;A;AAGG;A;AAED;AACA;AACA;A;A;AAGA;A;AAED;AACA;A;AAED;A;;;;AA0CA;;A;;;;;;AAaA;;;;AACA;AACA;AACA;AAIC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAID;AACK;AACJ;;;;AACA;AACA;;;A;AAEC;A;A;A;AAIC;A;AAED;A;AAED;AACI;AACJ;A;A;A;AAGE;AACA;A;AAED;;;;AACA;;;A;AAEC;A;AAEA;A;A;A;AAIA;AACA;A;AAED;;;;AACA;;;A;AAEA;;;;AACA;A;AAEA;;;;AACA;A;AAEA;;;;A;AAEC;A;A;AAID;;;A;AAEA;;;A;A;AAGC;A;AAED;;;;A;AAGC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;A;A;AAGD;;;;A;AAEC;AACA;A;A;AAKA;;AACA;A;AAGC;A;AAGD;AACA;;AAA2C;A;AAE3C;;;;AACA;A;A;A;AAIA;AACA;A;AAED;;;;A;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAIA;AACA;A;AAED;;;;A;A;AAGC;A;AAEA;A;AAEA;A;A;A;AAIA;AACA;AACA;A;AAEG;;;;;;;;A;A;AAGF;AACA;A;A;AAGA;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;A;AAGC;AACA;A;AAED;;;;;;;;;;A;AAEG;;;;;;AACJ;;;A;AAEC;;;A;A;AAGA;;;A;AAED;A;A;A;AAIC;A;AAEA;A;A;A;AAKA;AACA;AACA;A;AAED;;;A;AAEC;AACA;A;AAED;;;;A;AAKA;A;AAEC;AACA;A;AAED;;;;AACA;A;A;AAKC;A;AAID;AACA;;AACC;A;AAED;;;;AACA;A;A;A;AAGA;A;A;AAGA;A;A;A;AAID;A;AAEA;A;A;AAKA;A;AAGD;;A;AACC;;A;AAGD;;A;AACC;;AACA;AAIA;;;;A;AAEC;AACA;A;AAID;AACA;A;AAGD;;A;AACC;;AAGA;;;;A;AAEC;AACA;AACA;A;A;AAKA;;AACA;A;AAED;AACA;A;AAID;;A;;;;;;A;A;;;;;A;A;A;;;;;A;A;AAuBC;A;;;;;A;A;AAKA;AACA;A;;;;;A;AAIG;AACA;;;A;AAEF;A;AAEE;A;AACF;A;AAL0B;A;A;A;A;;;;;A;A;A;;;;;A;A;A;A;;;;;A;A;A;;;;;A;A;;;;;A;;;AA8B5B;A;AAEC;A;AAGD;A;;;AAOA;A;AAEC;A;AAED;;;;A;AAIC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;;;A;AAKC;AACA;A;AAEE;;;A;AACF;A;A;AAGA;AACA;A;AAKD;AACI;;;AACH;AAD4B;A;AAG7B;A;;;;;;AAOA;AACA;;AACC;A;AAEC;A;A;A;;;;;;;A;AAMD;A;A;;;;;;;A;AATiB;A;A;;;;;;;A;;;;AC5hClB;A;;;;;A;AAMC;A;AAED;A;;;;;AAIgC;A;;;;;A;AAK/B;AACA;A;AAEC;AACA;A;AAID;A;AAID;A;;;;;A;AAMC;A;AAED;AACA;A;;;;;A;AAMC;AACA;A;A;;;;;A;AAkCA;A;AAED;AACA;AACA;A;;;;;A;AAMC;A;AAED;A;;;;;A;AAUC;A;AAED;A;;;;;A;AAuCC;A;AAED;AACA;AACA;A;;;;;A;AA6BC;A;AAED;AACA;AACA;A;;;;;AA2GA;A;;;;;;AAMA;AAEA;;A;AACC;;A;AAED;AACA;;A;AACC;;A;AACC;A;;AAEA;;;AACA;A;A;AAGF;A;;;;;;;;;;AAMA;AACA;;A;AACC;;A;AAGD;AACA;;A;AACC;;A;AACC;AACA;A;;AAEA;;;;A;AAED;A;;AAEA;A;AAED;AACA;A;;;;;;;;;;AAKA;;;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;AACA;A;;;;;;;AAKA;;;A;;;;;AAMA;AACA;A;;;;;;;AAQA;;;;;;AACA;;AAgBA;AAMA;A;AAEC;A;A;AAMA;AACA;A;AAKC;A;A;A;AAQE;A;AACF;AACA;A;A;AAIF;A;;;;;;;;;;A;;;;;;;A;;;;;;;;AAUA;AACA;AACA;AACA;AACA;AACA;A;;;;;AAKA;;A;;;;;;;AAKA;;A;;;;;;;AAKA;;A;;;;;;AAMA;A;;;;;;AAMA;;;AACA;A;;;;;;AAuCI;AACJ;AAEA;AACA;A;AAEC;A;A;AAMI;AACJ;AACA;AACA;A;AAGC;A;AAGA;AACA;A;AAGA;AAEA;AACA;A;AAGA;AACA;A;AAED;;;AACA;A;AAEA;AACA;AAEA;;;AAGA;AACA;A;AAIC;AACA;AACA;AACA;A;AAKC;AACA;AACA;A;A;A;A;AAMF;AACA;A;AAGD;A;;;;;;AASA;AACA;AACI;;;AACH;AACA;A;AAEC;AACA;A;AAED;AAPqB;A;A;AAUrB;AACA;A;A;;;;;A;;;AAQD;A;AAEC;AACA;A;AAEA;;AACC;AACA;AACA;A;A;AAGF;A;;;;AAIuC;A;;;;;AAavC;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAOC;A;AAED;A;;;;AAMA;A;;;;A;AAWC;A;AAED;A;AAEC;A;AAEC;A;AAEE;A;AACF;A;AAED;A;A;AAGA;A;AAEE;A;AACF;A;AAED;A;;;;;AAKA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;AAEC;A;AAGC;A;AAEA;A;A;AAGF;A;;;;;A;AASC;AACA;AACA;A;AAEC;A;A;AAGA;A;AAED;A;AAED;A;AAIC;A;AAEA;A;AAEA;A;A;;;;AAOG;A;AAGH;A;AAEA;A;AAED;A;;;;;;AAyBA;;;;;AACA;;;;;AACA;;A;;;;;;;;;;;A;;;;;;;;A;;;;;;;;;AAsBA;AAGA;AACA;AACA;AAMA;AACA;AACA;AACA;AAKA;AACA;AACA;AAMA;AACA;AACA;AACA;AAEA;AACA;A;AAGC;A;AAGD;A;A;AAME;A;AAGA;AACA;AACA;A;A;AAMF;AACA;AACI;A;AAEH;AACA;A;AAEA;A;AAGD;AACA;AACA;A;;;A;AAwBC;A;AAED;A;;;AAoBA;;;;AACA;AACA;A;AAEC;A;AAED;A;;;;AAIA;A;;;;AAKA;AACA;A;;;;;AAKA;AACA;A;;;;;A;AAUC;A;AAED;AACA;A;;;;;AAKA;A;AAEC;A;AAED;A;;;;;;;;AAMA;;;;AACA;A;;;;;;AAOA;A;;;;;AAUA;A;;;;;;AAOI;AAEJ;;A;AACC;A;;AAEA;;;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAGD;AACA;AACA;AAkBA;A;;;;;;;AAKA;A;AAEC;A;A;AAIA;A;A;AAIA;A;AAGD;AACA;AAGA;AACA;AAEA;AACA;AAEA;AACA;AACA;AAEA;;A;AACC;A;;AACS;;;A;AACT;A;AAEA;A;A;AAGD;A;;;;;;;AASA;;A;;;;;;;AAKA;;A;;;;;;;AAMG;;A;AAGF;A;AAGD;AACA;AACA;;AACA;AACA;A;;;;;;;A;AAQC;A;AAGG;AACJ;;;;AACA;A;;;;;;;AAMG;;A;AACF;A;AAGD;AACA;;A;;;;;;;AAOI;AACJ;;;;AACA;A;;;;;A;AAUC;AACA;AACA;A;AAEC;AACA;A;A;AAGF;A;;;;AAIA;A;;;;;A;AAQC;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;;;;;A;;;;A;AAuBA;A;AAID;AACA;;;AACA;AAGA;;;AACA;;;AACA;;;AACA;;;AAEA;AAKA;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AAGA;A;AAEC;A;AAID;AAGA;AACA;AAEA;AAMA;;;;;AACA;;A;AACQ;AACP;;;A;AACC;;;A;A;AAEA;;;A;A;AAED;A;AAGD;AACA;AACA;A;;;;;;AAWA;A;AAEC;A;AAED;;AACA;A;;;;;AAYA;A;AAEC;A;AAED;;A;AAEC;A;AAED;A;;;;;;AAOA;AACA;AACA;A;AAGC;AACA;AACA;A;AAEC;AACA;A;A;A;AAOD;AACA;A;AAIA;AACA;AACA;A;AAQA;AACA;AACA;AACA;AACA;AACA;;;;A;AAEC;A;AAED;;;;A;AAEC;A;AAKD;AACA;;AACC;A;AAED;AACA;AACC;A;AAGC;AACA;;;;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;AACA;A;AAED;A;A;AAUA;AACA;A;AAED;A;;;;;A;AC18CC;A;AAED;;A;AACC;A;AAED;A;;;;;;;AAMA;;A;;;;;AAMA;AAOA;AACA;A;;;;;;;;;;AAWA;;A;AAGC;AACA;AACA;AACA;AACA;A;AAGE;A;AACF;AACA;AACA;AACA;AACA;A;A;AAIA;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAED;A;AAKD;AACA;AACA;AACA;AACA;;AACC;AACA;A;AAEC;AACA;A;AAEA;A;A;AAGF;AACA;AACA;AACA;AAEA;A;;;;;;A;AAqBC;A;A;AAKI;;;A;AAEF;A;AAFyC;A;A;AAQ5C;;;;;A;AAEE;A;A;;AAKF;A;;;;;AAMA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;;AAOA;;AAQA;;;;;AACC;AACA;;A;AACC;;;;A;A;;;;;A;A;A;;AAQF;;;;;AACC;A;A;;;;;A;A;;AAOD;A;;;;;;;;;;;;;;;;;;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3OwC;A;;;;;A;;;;;AAIX;A;;;;;A;AAI5B;A;AAED;A;;;;;AAGoD;A;;;;;AAEC;A;;;;;A;AAIpD;A;AAED;A;;;;;AAGiD;A;;;;;AAEC;A;;;AAIhB;A;;;;AAES;A;;;;AAEI;A;;;;AAEC;A;;;;;AAUhD;;A;AACC;AACA;AACA;;A;A;A;;;;;;A;AASD;A;AAEC;A;AAGD;AACA;AACA;A;AAEC;A;A;A;;;;;A;ACnDA;A;AAED;A;;;;AAUyC;A;;;;;AACA;A;;;;;AACA;A;;;;AAIzC;;AACC;A;AAEC;AACA;A;AAED;AACA;A;A;;;;;AC3CE;A;AACF;A;AAED;AACA;A;;;;;AAIA;;;A;AAEC;A;AAED;A;;;;AC6BA;AACC;A;AAEC;A;AAED;A;AAEC;A;A;AAGA;A;A;A;;;;;;AAQF;AACC;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;;A;AAGC;;AACC;AACA;A;AAED;;AACC;AACA;A;AAED;A;A;A;;;;;;;AAQF;AACC;A;AAEC;A;AAED;A;AAEC;A;A;A;;;;;;AAQE;;;;;;AACA;A;AAEH;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;A;AAED;AACC;A;AAEC;A;AAEG;A;AAGH;A;AAEC;A;A;AAID;A;AAEC;A;A;AAGF;;A;A;AAEE;A;AAED;A;A;A;;;;;;;;AASE;;;;;;AACA;A;AAEH;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;A;AAED;AACC;A;AAEC;A;AAGD;A;AAEC;A;AAED;;A;AACC;;A;AACC;A;AAED;A;A;A;;;;;;;A;AAaD;A;AAED;A;;;;;;AAOA;;A;AACC;;A;AAED;A;;;;;;;AAMA;;;A;AACC;A;AAED;A;;;;;;;AAOA;;;A;AACC;;A;A;;;;;;;;AAOD;;;A;AACC;A;AAED;A;;;;;;;AAOA;;;A;AACC;;A;A;;;;;;;A;ACxOA;A;AAED;A;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;A;ACUC;A;A;AAGA;AACA;A;AAED;A;AAIC;A;AAED;A;;;;;;AAQA;AACA;;AACA;AACA;AACA;A;;;;;;;AAMA;;;A;AACC;A;AAQD;AAIA;;AAQA;;A;AACC;A;AAGD;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AAIA;AACA;A;;;;;;;AAYG;;A;AACF;A;AAED;A;AAOC;A;AAEE;A;AACF;A;A;AAGA;A;AAED;AACC;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAOD;A;A;AAGF;AACA;A;A;;;;;;;;AASE;A;AACF;A;A;AAGA;A;AAED;;;A;AAEC;A;AAED;;AACA;AACA;A;;;;;;;AAKG;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAIH;AACA;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;;;A;A;AAIK;A;AACF;A;A;A;AAIH;AACA;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAEG;AACJ;AACC;A;AAEC;A;AAED;;;A;AAEC;A;A;AAGA;A;A;AAGG;A;AACF;A;A;A;AAID;A;A;AAGA;A;A;A;;;;;;;;AAUC;A;AACF;A;AAED;AACI;AACJ;AACC;A;AAEC;A;AAED;;;A;AAEC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;A;;;;;;;;AAOC;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;A;AAEI;A;AACF;A;A;A;AAID;A;AAED;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;;A;AAEI;A;AACF;A;A;A;AAID;A;AAED;A;A;;;;;;;;AAME;;A;AACF;A;AAED;AAEG;A;AACF;A;AAED;AACC;;;;;;A;AAEC;A;A;A;A;AAKI;A;AACF;A;A;A;AAOF;A;AAED;A;A;;;;;;;;AAME;A;AACF;A;AAED;AACA;A;;;;;;;AAOG;A;AACF;A;AAED;AACA;AACC;;;A;AAEC;A;AAEI;A;AACF;A;A;A;AAKH;A;A;;;;;;;;AAME;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;A;AAUC;;;A;AAEC;A;A;A;AAOA;A;AAEA;A;A;AAGF;;A;;;;;;AAMA;AACA;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;;AAKG;A;AACF;A;AAED;AACA;;A;;;;;;AAOA;A;;;;;;AAKG;;A;AACF;A;AAED;AACA;A;;;;;;;AAMG;A;AACF;A;AAED;AACA;AACA;A;;;;;;;AAKG;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;A;AACC;A;AAEE;A;AACF;A;A;A;;;;;;;;AAOC;;A;AACF;A;AAED;AACG;A;AACF;A;AAED;AACC;;;A;AACC;A;AAEE;A;AACF;A;A;A;;;;;;AC3hBF;;;A;AAEC;A;AAED;A;;;;ACFA;;;;;A;A;AAOC;A;A;A;A;A;AAEA;A;AAYD;;;;;A;AAEC;A;A;AAGA;A;AAEE;AAAH;;A;AACC;;AACA;A;AAED;A;;;;;;ACpCG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;ACxBG;A;AACF;A;AAED;AACA;A;;;;;;;ACFG;A;AACF;A;AAED;AACA;A;;;;;;;ACJG;A;AACF;A;AAED;AACA;A;;;;;;;AAKG;A;AACF;A;AAED;AACA;A;;;;;;;;ACVG;;A;AACF;A;AAED;AACG;A;AACF;A;AAGG;A;AAEH;A;AAKD;AAEI;AACA;AACJ;;AACC;AACA;;;;;A;AAEE;;A;AAED;A;AAEC;AACA;A;AAED;A;AAEC;A;A;;A;AAID;A;AAED;AAEI;AACJ;;;A;AAEC;A;AAED;AACA;AACA;A;A;AAGK;A;AACF;A;A;AAGF;A;A;AAGA;AACA;A;A;AAGF;A;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;;;;;;;;;;;;;;A;;;;;A;;;;;A;A;;;;;;;;;;;;;AClCA;A;AAEC;A;AAED;A;;;;;AAmBG;AAAH;;A;AACC;A;A;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvDD;A;;;AAIG;A;AACF;AACA;AACI;;;AACH;AADgC;A;A;A;AAKjC;A;A;;A;;;;;A;ACAA;A;AAED;;A;;;;;;;;;A;A;;;;;A;A;;;;;A;;;;;;A;;;;;;;;A;ACMC;AAEA;A;AAED;AAEA;A;AAEC;AACA;A;AAGD;AACA;;AAEC;;A;AACC;AACI;AACJ;;;;AACA;A;A;;;;;A;A;AAKC;A;A;AAKE;;;;AACJ;;;;AACA;AACA;A;A;A;;;;;A;A;;;;;A;;;;;;;AC/BmC;;A;;;;;;;AAIpC;;;AACA;;;;A;;;;;;;AASuC;;A;;;;;;;AAIvC;;;AACA;;;;A;;;;;A;AAQC;A;AAED;A;;;;AAcA;A;;;;AAmBA;A;A;AAEC;A;A;AAEA;A;A;AAEA;A;AAED;A;;;ACzFG;;A;AACF;A;AAED;A;;;ACAA;AACA;A;;;;ACgC8B;A;;;;;;AAgD9B;;A;;;;;;;;;AAOG;A;A;;;;;A;AAGH;;;;A;;;;;A;;;;;;;;;AASG;A;A;;;;;A;A;A;;;;;A;AAQH;;AACC;;;;A;AAEC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;;;;AAOG;A;A;;;;;A;AAGH;;;;A;AAEC;A;A;AAGA;A;AAGD;A;AAGC;A;A;;;;;A;;;;;;;;;AAUE;A;A;;;;;A;A;A;;;;;A;AAQH;;AACC;;;;A;AAEC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;;;;AASG;A;A;;;;;A;AAGH;;;;A;AAEC;A;A;A;;;;;A;A;;;;;A;;;;;;;;;A;;;;;A;;;;;;A;AAkHA;A;A;AAGA;A;AAED;A;;;;;;AAkH2C;;A;;;;;;AAyB3C;A;;;;;AAQA;A;;;;;AAUA;A;;;;;AAMG;A;AACF;A;AAED;;A;;;;;;;;AC7bA;A;AAEC;A;A;AAGA;A;A;AAGA;A;AAGD;A;;;;;AAaG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAoCG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAOG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAOG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;;AAuBG;A;AACF;A;AAEE;;A;AACF;A;AAED;A;;;;;;AAKG;A;AACF;A;AAED;A;;;;;AAKG;A;AACF;A;AAED;A;;;;;AAKG;A;AACF;A;AAED;A;;;;;A;AAOC;A;AAED;A;;;;;;A;ACxIC;A;AAQD;;A;AACC;;A;AAGD;A;;;;;AASA;AACG;;;A;AACF;A;AAED;A;;;;AAiBA;A;AAEC;A;AAED;AAUA;A;AAMK;A;A;AAQH;A;AASG;A;AACF;A;A;AAQE;A;AACF;A;A;A;AAKA;A;A;AAUC;A;AACF;A;A;AAIF;AACA;A;;;A;AAQC;A;A;;;;;A;AAuDA;A;AAED;;A;;;;;;;A;AAKC;A;A;AAGA;A;AAEG;AACD;;A;A;AAED;A;AAED;A;AAID;AACA;A;;;;;;;;;AAMA;;;;AACA;A;;;;;A;;;;;;;;;AAQA;;;;AACA;A;;;;;A;;;;;;;;;AAOA;;;;AACA;A;;;;;A;;;;;;;;;AAOA;;;;AACA;A;;;;;A;;;;;;;;;AASA;;;;AACA;A;;;;;A;;;;;;;;;AA8EA;A;AAEC;A;AAED;;;;AACA;AACA;;;;;AACC;;;;A;AAIC;;A;A;A;;;;;A;AAKD;A;;A;AAKA;A;A;;;;;A;;;;;ACzXD;AAEA;;AACC;AAD8B;A;AAI3B;A;;A;AAEF;AACA;A;AAHe;A;AAOjB;A;;A;ACdC;A;AAED;A;;;A;AAyCC;A;AAED;A;;;;;;AC9CG;A;AACF;A;AAED;;AACA;AACA;A;;;;;;;AAIG;A;AACF;A;AAED;;AACA;AACA;A;;;;;;;AAIG;A;AACF;A;AAED;;AACA;AACA;A;;;;;AAIA;A;;;;ACzBA;AACA;A;;;;;ACTA;AACA;AACA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;;;AAKD;A;;;;;;A;AC5BC;A;AAEG;AACJ;;A;AAEC;A;AAED;AACA;A;;;;;AAgBI;AACJ;A;AAEC;A;AAED;AACA;A;;;;ACoBI;AACJ;AACA;;;;;;;A;AAEE;AACA;A;A;;A;AAID;AACA;A;AAGD;;;;;;;A;AAEE;A;AAEA;A;AAED;A;;AAED;A;;;;;AAMA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAGmC;A;;;;;AACA;A;;;;;ACrFM;A;;;;;AACA;A;;;;;AACA;A;;;;;AACA;A;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC4BzC;A;;;;;AAIA;AACA;A;;;;;A;AAMC;A;AAED;AACA;AACA;A;AAGC;AACA;A;AAGD;A;AAEC;A;AAGD;AACA;;;;;AACC;A;;AAED;A;;;;;A;AAMC;AACA;A;AAED;A;AAGC;AACA;A;AAGA;AACA;A;A;;;;;A;AAOA;AACA;A;AAED;A;AAGC;AACA;A;AAGA;AACA;A;A;;;;;A;AAOA;A;AAEA;A;A;;;;;AAMD;AAKA;A;AAEC;AAEA;A;AAEC;A;A;AAKF;A;AAIC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGD;;AACC;AACA;AACA;AACA;A;AAED;AACA;AACA;AAEA;;AACC;AACA;AACA;A;AAGD;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;A;;;;;AAKA;A;AAEC;A;AAGD;A;AAKC;A;AAGC;A;A;AAOF;A;AAEC;A;AAGC;AACA;AACA;AACA;AACA;A;A;AAGD;A;AAEC;A;A;AAOF;A;A;AAKC;;AACC;AACA;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;;AACC;AACA;AACA;A;A;AAGD;A;AAED;AACA;AACA;;AACC;AACA;A;A;A;A;A;AAQE;AACA;A;A;AAID;AACA;AACA;AACA;A;A;A;AAKD;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAKD;AACA;AACA;AACA;A;;;;;A;AAMC;AACA;;;;;;AACC;A;AAEC;A;A;;A;AAIH;A;;;;;A;AAMC;AACI;;;AACH;A;AAEC;A;AAED;A;AAEC;;A;AAED;A;A;AAGF;A;;;;;AAKA;AACA;A;;;;;AAKA;AACA;A;;;;;AAKA;A;AAGC;A;A;AAIA;A;AAGD;A;A;A;AAKG;A;AAGD;A;AAGA;A;A;A;AAIA;A;AAED;A;A;AAIA;A;AAGD;A;AAGC;A;AAEG;AACA;;;A;AAGF;A;AAGC;A;A;A;AAID;A;AAEA;A;AAGD;AAfuB;A;AAiBxB;A;AAGC;A;A;;;;;AAMD;A;;;;;AAKA;A;;;;;AAOA;A;AAEC;AACA;A;AAED;A;AAEC;A;AAEA;A;A;;;;;AAOD;A;AAEC;A;AAED;AACA;AACA;A;;;;;AAMA;A;AAEC;A;AAED;A;AAEC;A;AAEA;A;A;;;;;A;AASA;A;AAGD;A;AAEC;A;AAEA;A;A;AAKA;A;A;AAKA;AACA;A;AAGC;A;AAED;AACA;AACA;A;A;AAKA;A;A;AAGC;A;AAGC;A;A;AAME;AACJ;AAEA;AAEI;;;A;A;AAGF;A;AAEA;AACA;A;AAEA;A;AARwB;A;A;AAYzB;A;AAED;;AACC;AACA;A;AAED;A;A;A;AAOC;AACA;AACA;AACA;A;AAED;AACA;A;AAGD;A;;;;;ACneA;A;;;;AAIA;A;;;;AAIA;A;;;;A;AAKC;AACA;A;AAGD;AACA;AACA;;AACC;A;AAED;AACA;A;;;;AAgCA;;AACA;AACA;AACA;AACA;A;;;;;A;AAYC;A;AAGD;AACA;AACA;AACA;A;;;;;;;A;;;;;A;;;;;;;A;;;;;A;;;;;A;A;AAUC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;;;AAMA;A;;;;;A;;;;;;;AAOA;A;;;;;A;;;;;;;AASA;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAWA;;AACA;AACA;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;;;AASA;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAaA;;AACA;AACA;AACA;AACA;A;;;;;;AA4BA;;AACA;AACA;AACA;AACA;A;;;;;;AAOA;;AACA;;A;AACC;;A;AAED;A;;;;AAOA;A;;;;;;A;A;;;;;;;A;AAQI;;;A;A;;;;;;;A;AAIH;AACA;AALiE;A;AAOlE;A;;;;;A;AAKC;AACA;A;AAED;AACA;;AACA;A;;;;;;;;AAIA;AACA;AACA;AACA;AAEA;;;A;AACC;;AACA;AACA;A;A;AAEA;;AACA;AACA;A;;AAEA;A;A;AAED;AACA;A;;;;;;;;A;AAKA;;A;AACC;A;;AAEA;A;A;A;;;;;;;AAOD;AACA;AACA;AACA;A;;;;;;A;AAMA;;;;;;;;;;A;A;AAEE;A;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;AACC;A;;AAEA;A;A;A;AAGD;A;;AAEA;A;A;A;;;;;;;;A;AAQD;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;A;AAWD;;A;AACC;AACA;AACA;AAEA;AACA;AACA;AACA;A;;AAEA;A;A;A;;;;;;;;A;AAMD;;;;;;A;A;AAEE;A;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;A;AAMD;;;;;;A;A;AAEE;A;AAEC;AACA;A;AAED;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;A;AAEA;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;;A;A;A;;;;;;;;AAKG;A;AAEJ;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;;;;A;AACC;;A;AACC;AACA;;AACA;A;AAEC;A;AAEA;A;AAED;A;;A;AAGC;A;AAEA;A;A;A;A;AAIF;A;A;AAEA;A;;AAEA;A;A;A;;;;;;;;AAKE;AAAH;;A;AAII;;A;AACF;AACA;A;A;AAMA;A;AAGD;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;A;A;;;;;;;;;A;AAMA;A;AAGE;;;AAAH;;A;AACC;AACA;AACA;AACA;A;AAID;;A;AACI;;;AAAH;;A;AACC;AACA;AAEA;;AACA;A;A;;A;AAOD;;A;AAKC;;;;A;A;AAEC;AACA;AACA;;AACA;A;A;AAGA;AACA;AACA;;AACA;A;A;A;A;A;;A;;;;;;;AAQH;AACA;AAEA;;A;A;AAEC;;A;AACC;A;;AAEA;A;A;AAED;A;A;AAMD;;;A;AACC;;AACA;A;AAEA;;AACA;A;A;AAID;;;;;;;;;;;;;;;;;;;;;A;A;AAEC;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAEA;A;A;A;AAIA;;A;AACC;;AACA;;;A;AACC;A;A;AAGF;A;;A;AAGA;;;A;AAGC;;A;A;A;;;;;;;;AASF;;A;AACC;;AACA;;;A;AACC;A;A;AAGF;AACA;AAEO;A;AACP;;;;;;;;;;;;;;;;A;AACC;;A;AACC;A;;A;AAGA;;A;AACC;A;;AAEA;A;A;A;A;A;AAIF;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;A;AAEA;;A;AACC;;A;AAEC;AACA;A;AAED;A;;AAEA;A;AAED;;AACA;;;;;;A;A;AAGG;A;AAEA;A;A;AAGF;AACA;AACA;A;;A;AAGA;A;AAEA;A;A;A;AAGD;;A;AACC;;A;AAED;AACI;;;A;A;AAGD;A;AAEA;A;A;AAGF;;A;AACI;;A;AACF;AACA;A;A;AAGF;;AAd6B;A;AAgB9B;A;A;AAEA;;AACA;;A;AACC;;A;AACC;;AACA;A;;AAEA;A;A;;AAGD;A;A;A;A;AAID;;A;AAEC;AACA;;;;A;AACK;AACJ;;;A;AACC;;A;A;AAEA;;;A;;AAKA;AACA;;;;;AACC;;;A;;A;AAGF;;;;;AACA;A;A;A;AAGF;;A;AACC;;A;AAEC;AACA;A;AAED;AACI;;;A;AAEF;A;AAED;;AAJwB;A;AAMzB;A;;AAEA;AACI;;;A;AAEF;A;AAED;;AAJwB;A;AAMzB;A;A;A;AAKD;;A;AACQ;;A;AACP;;A;AACC;AACA;AACA;A;A;A;AAKF;A;A;AAAA;A;;AAEA;A;A;A;;;;;;;;;;AAMD;AACA;;A;AACC;;;AACA;;A;AAEQ;;A;A;AAEN;A;AAEC;AACA;A;A;AAGD;A;AAEC;AACA;A;A;A;A;AAMH;A;AAEC;AACA;A;A;AAGF;A;;;;;;;A;A;;;;;;;A;AAgBI;;;A;AAEF;;;;A;A;;;;;;;A;A;;;;;;;A;AAF2B;A;A;;;;;;;A;;;;;;;A;A;;;;;;;A;AAmB7B;AACA;;;;A;A;;;;;;;A;AAIA;A;;;;;;;A;;;;;AAKA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;;AAIA;AACA;AACA;AACA;AAEI;;;AACH;AACA;AACA;;AACC;A;A;AAGA;A;A;AAIA;A;AAID;AAGA;AAEA;;AACC;A;AAEA;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;AACA;A;A;AAEA;A;;AAIA;;A;A;AAGE;AACA;AAEA;AACA;A;AAED;AACA;AACA;AACA;A;AAGD;A;A;AAhCa;A;AAqCf;;;;AAGA;;A;AACC;AACA;;;;;A;AAGC;A;A;AAMA;AACA;AACA;A;AAED;A;;AAEA;;;;A;AAEC;A;A;AAKF;;A;AACC;A;AAEC;A;AAED;;;;AACA;;A;AACC;AACA;;;;;A;AAGC;AACA;A;A;AAGA;A;AAED;A;;AAEA;;;;A;AAEC;AACA;A;A;A;A;AAMF;;;;A;A;AAIA;AACA;A;AAGD;;;;A;AAEC;;;A;AAED;AAGA;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAGA;AACA;AAEA;AACA;AAGA;AACA;A;;AADA;AACA;A;A;A;AAOF;;A;AACC;AACA;AACA;;;;;;A;AAEE;A;AAED;;A;AACC;A;;AAEA;;AACA;AACA;A;A;;AAGF;A;A;;;;;;;;AAKD;AACA;;;;;;AACC;;;;A;AAGC;A;AAED;AACA;A;;A;;;;;;;;AAOD;;;;;;A;AAEE;A;AAED;A;;AAED;A;;;;;;;;;A;;;;;A;;;;;;;;;A;ACh9BC;AACA;A;AAGD;;;;;A;AAEC;A;AAEC;A;A;AAGD;A;AAED;A;;;;;;;;A;A;;;;;A;A;;;;;A;;;;;;;AAaA;;;;A;A;A;;A;AAKC;A;AAED;A;;;;;;;AAeA;;AACA;AACA;AACA;A;;;;;;AAIA;A;;;;;AAIA;A;;;;;;;;;AAIA;;AACI;A;AACC;;;A;AACF;A;AAEA;A;A;A;A;AAKF;A;AAED;AACA;;AACA;A;;;;;A;AAoBC;A;AAED;AACA;;;;;A;AAEE;A;A;AAGA;A;A;;AAGF;A;;;AAKA;A;;;;A;AA2GC;AACA;A;A;AAIA;A;AAED;AACA;AACA;A;;;;;;AAOA;AACC;;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;A;A;AAEE;A;AAED;AACA;A;AAED;;A;AACC;;AACA;A;A;A;;;;;;;;AASF;;A;AACC;A;AAGD;AACC;;A;AAEC;A;AAED;;;A;AACC;;AACA;A;AAED;A;AAED;A;;;;;AAOA;;;;;;;A;AAEE;A;A;;AAGF;A;;;;;AAwBA;;AACA;;A;AACC;;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;ADrX0B;A;A;A;AC0PA;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/W1B;A;;;;AAIA;A;;;;;AAwCA;A;;;;;A;AAOC;A;AAEA;A;A;;;;;ACd4B;A;;;;;AAKA;A;;;;;AAI7B;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;AAOA;A;AAEC;A;A;AAGA;A;A;;;;;AAOD;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;AAMA;A;AAEC;AACA;A;AAED;A;AAEC;A;AAED;AACA;AACA;A;;;;;AAMA;AACA;AACA;A;;;;;A;AChGC;A;AAED;A;;;;;AAO+B;A;;;;;;;A;A;;;;;A;AAM/B;AACA;AACA;AACA;A;;;;;;;A;A;;;;;A;A;A;;;;;A;AAWA;A;AAEC;A;AAED;A;;;;;AAIA;A;AAEC;A;AAED;AACA;AACA;A;;;;;A;AAKC;A;AAED;AACA;AACA;A;;;;;;;;A;AAKC;A;;;;;;;A;AAGD;AACG;A;AACF;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;A;AAKC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;;AAKA;AACI;A;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;;;;;;;AAKA;A;A;;;;;A;AAIA;AACA;;;;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;;AAIkC;A;;;;AAIA;A;;;;ACvDlC;A;;;;AAUA;A;;;;A;AAoDC;A;AAEA;;;;;;;A;AAEE;A;A;;AAGF;A;AAEA;A;AAEA;A;A;;;;AAqRD;A;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;AC9a4B;A;;;;AAO5B;;;;;;AACC;AACA;A;;AAGD;A;;;;AAkEA;AACA;AACA;A;;;;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7FA;;;;;;A;AAEE;A;A;;AAGF;A;;;;A;AAKC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;ACkCiC;A;;;;;A;AAShC;A;AAED;A;;;;;AAI+B;A;;;;;AAIH;A;;;;;AAIA;A;;;;;A;AAO3B;AACA;A;AAED;A;AAEC;A;AAED;A;;;;;AAOA;AACA;AACA;A;;;;;AAOG;A;AACF;AACA;A;AAED;A;;;;;AAOA;A;AAGC;A;AAGE;;;A;AACF;A;A;AAGA;AACA;A;AAED;A;AAMC;A;AAEA;A;AAGA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;A;AAUC;A;AAED;AACA;A;;;;;;;AAOA;AACA;;;A;AAEC;A;A;;;;;A;;;;;;;AASD;AACA;;;A;AAEC;A;A;;;;;A;;;;;;;;AAgBD;AACA;AACC;AACA;AACA;;;;A;AAEC;A;AAGD;AACA;A;A;;;;;A;A;A;;;;;A;A;A;;;;;;;AAcD;A;AAEE;A;A;AAGF;A;;;;;;;;AAQA;AACG;AAAH;;A;AACC;;;;A;AAEC;A;AAED;AACA;A;A;;;;;A;A;A;;;;;A;A;AAWD;A;;;;;A;;;;;;AASA;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;;;A;AASC;A;;;;;A;AAGD;AACA;;;A;AAEC;A;AAED;AACA;A;;;;;A;;;;;;;AASA;A;AAGC;A;A;;;;;A;A;;;;;A;AAMD;AACA;A;AAEC;A;A;;;;;A;;;;;AAUD;AACA;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;A;AAQC;AACA;A;AAED;AACA;AACA;AACA;A;;;;;;;;A;AAWC;A;;;;;;;A;AAGD;A;AAEC;AACA;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;;;A;;;;;A;AAWC;A;A;AAGA;A;AAED;AACA;A;;;;;A;AASC;A;AAED;A;AAEC;A;AAED;A;;;;;;;AAUA;;;AAGA;A;;;;;A;;;;;;;AAMA;AACA;A;AAEC;AACA;A;AAED;AACA;AACA;A;;;;;A;;;;;;;AAWA;;;A;;;;;A;;;;ACRA;A;;;;;AA2JA;;A;AAEC;;AACA;A;AAEA;A;AAED;A;;;;;;AAgEI;;;AACH;;;;A;AAEC;;;A;AAED;AACA;;;A;AACC;A;A;AAGF;A;;;;;;AAcI;;;AACH;A;A;;;;;A;A;AAIA;AAL2B;A;A;;;;;A;;;;AAY5B;A;;;;A;AAKC;;AACC;A;A;AAGC;;;A;AACF;;AACC;A;A;AAGF;;AACC;;;;;;A;AAEE;A;A;;AAGF;A;A;;;;AAmBD;;A;;;;;AA6EA;;AAEK;;;;A;AAEH;;;;A;AAEA;;;AACA;;;;A;A;AAGA;;;;A;AAEA;;;AACA;;;;A;A;AAOA;A;A;AAKA;;;;A;A;A;AAMC;A;AAED;A;AAKD;AACA;;AACC;A;A;AAGA;A;AAED;A;AAID;A;;;;AAKA;A;AAGC;A;AAEA;A;A;AAGC;A;AAED;A;AAEA;A;A;AAIC;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;AAIE;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAGC;A;AAEC;A;AAED;A;A;AAGF;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;AAEE;A;AAEC;A;AAED;A;A;AAGA;A;AAED;AACA;A;AAUC;A;AAEC;A;AAED;A;A;AAGF;A;;;;AAKA;;;AACA;AACI;AACA;;;AACH;AADkB;A;A;AAIlB;A;AAEG;;;AACH;AACA;AACA;AACA;A;AAEC;A;A;AAGF;A;;;AASA;AACI;;;AACH;AADyB;A;AAGtB;;;;AACA;;;A;AAEF;A;AAED;AAJyB;A;AAM1B;A;;;;A;ACh8BC;A;AAED;A;;;;;AAO+B;A;;;;;;;A;A;;;;;A;AAO/B;AACA;AACA;AACA;A;;;;;;;A;A;;;;;A;A;A;;;;;A;AAYA;A;AAEC;A;AAED;A;;;;;AAKA;A;AAEC;A;AAED;AACA;AACA;A;;;;;A;AAMC;A;AAED;AACA;AACA;A;;;;;;;;A;AAMC;A;;;;;;;A;AAGD;AACG;A;AACF;A;;;;;;;A;AAGD;;;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAED;AACA;AACA;A;;;;;AAKA;AACI;A;A;AAGH;A;AAEA;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;;;;;;;AAKA;A;A;;;;;A;AAIA;AACA;;;;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;;AAIkC;A;;;;AAGA;A;;;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5GlC;AACA;A;;;;AAIA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAGqC;A;;;AAEE;A;;;;AAKvC;AACA;A;;;;AAIA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;AACA;AACA;A;;;;AAIA;AACA;A;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;AAGkC;A;;;AAEE;A;;;;;;;;;A;A;A;A;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;AClGnC;A;AAEG;;;A;AAEF;A;AAF4B;A;AAM9B;AACA;AACA;AAEI;;;AACH;AADiC;A;AAG9B;;;AACH;AAD6B;A;AAG9B;A;;;;;A;AAUC;A;AAGG;;;A;AAEF;A;AAF+B;A;AAMjC;AACA;A;;;;;AAOA;AACA;A;;;;;A;AAiCC;A;AAGD;;;;AACA;AACA;;AAEC;AAEA;AACA;AACA;AACA;AAEA;AACA;A;AAGD;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;A;A;AAIC;A;AAEC;A;A;A;AAIA;AACA;A;A;A;;;;;AAOF;AACA;AACA;A;;;;;;;;A;A;;;;;A;AAkBA;;A;AACK;AACA;;;AACH;AACA;AAFoC;A;AAIrC;AACA;A;AAEC;A;AAED;AACG;;;A;A;;;;;A;AAGH;A;AAID;;AACC;A;AAEC;AACA;A;AAED;AACG;;;A;A;;;;;A;AAGH;AACA;A;AAIG;;;AACH;AADuB;A;AAGxB;AACA;AACA;A;;;;;;;AAOA;;A;AACC;AACA;;;AACA;A;AAED;A;;;;;AASA;A;;;;;A;AAOC;A;AAED;A;;;;;AAUA;A;;;;;;;;AAUI;AACJ;;;;AAEI;;;A;A;A;;;;;;;A;A;;;;;;;A;AAQF;;;;AACA;A;AAED;AACA;AAEA;A;AAEC;AAhByB;A;A;A;AAqBzB;AArByB;A;A;A;A;;;;;;;A;A;A;A;;;;;;;A;AAqCzB;;AACC;A;A;A;;;;;;;A;A;A;;;;;;;A;AAWD;A;AAID;;AACC;A;A;AAIA;A;AAED;;;;AACA;A;AAID;AACA;;;;;;A;A;AAGC;AACA;AAGA;A;A;;;;;;;A;AAIA;AAGA;A;A;;;;;;;A;A;AAPA;A;A;;;;;;;A;AAIA;AAGA;A;A;;;;;;;A;A;AAAA;A;A;;;;;;;A;A;AAKD;A;;;;;;;A;;;;;AAOA;AACA;;;AACA;A;;;;;;;A;A;;;;;A;AA0FA;AACA;;AACI;;;A;AACF;AACA;AACA;A;AAEI;AACJ;;;;AACA;A;A;;;;;A;A;A;AAOF;;AACI;;;A;AACF;AACA;AACA;A;AAEI;AACJ;;;;AACA;A;A;;;;;A;A;A;AAOF;;AACK;AACJ;;;;AACA;A;A;;;;;A;A;A;;;;;A;;;;;;;AAYG;AACJ;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;A;;;;;A;;;;;;;AAQI;AACJ;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;AACG;A;A;;;;;A;AAGH;A;;;;;A;;;;;A;AAuCC;A;AAGD;A;;;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvaiC;A;;;;;AAIjC;A;;;;;AAKA;A;;;;A;AAUC;A;A;AAKA;A;AAEC;A;A;A;AAUD;A;AAGA;AACA;;AACC;A;A;AARD;A;A;AAcA;AACA;;AACC;A;A;A;AAOD;A;AAEC;A;AAEC;A;A;AAGF;;AACC;A;A;AAKF;A;;;;ACrGA;;AAEA;;A;AAEC;A;AAED;AAEA;AACA;AAEA;A;;;;;AA4BA;AACA;;;;;;A;A;AAGG;A;AAED;AACA;AACA;AACA;A;A;A;AAKC;A;AAED;AACA;AACA;A;A;;A;AAID;A;A;;;;;;AAiBD;;A;;;;;;AASA;A;;;;;;AAwBA;;;A;;;;;;AAcG;;A;AACF;AACA;AACA;A;AAED;A;;;;;;;;AASA;;AACI;A;AACC;;;A;AACF;A;AAEA;A;A;A;AAIH;;A;;A;;;;;;AAMA;A;;;;A;A;AAMC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAIA;;A;;;;;;;A;AAgBC;A;AAED;;A;;;;;;;AAIG;;;A;AACF;A;AAQA;AACA;AAED;AACA;;;AACC;AACA;A;;;;;A;AAGA;A;AAID;;AACA;AACA;AACA;A;;;;;AAWA;;;A;AACC;A;AAED;;;A;AACC;;;A;AACC;;;;;A;A;AAIF;;;A;AACC;A;AAED;;;A;AACC;;;A;AACC;;;;;A;A;A;;AAKF;;;;;;;;;;;;;A;AACC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;;A;AAEA;A;A;A;;;;;AAKD;A;;;;A;AAKC;AACA;A;AAED;;;;A;AAEC;AACA;A;AAED;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;;AAKD;A;AAEC;AACA;A;AAED;;AACA;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;;A;AAMA;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;;;AAIA;A;AAEC;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;;A;AAKC;A;A;AAGA;A;AAEA;A;A;AAGA;A;A;;;AAKD;A;AAEC;A;AAED;A;AAEC;A;A;;;AAKD;A;AAEC;A;AAED;A;AAEC;A;A;;;;AAOD;A;AAEC;A;AAQD;AACA;AACA;A;A;AAIE;A;A;AAGF;A;AAGC;A;AAEC;AACA;A;A;A;AAKD;A;AAED;A;AAEC;A;A;;;;;AAUD;;A;AACC;;A;AAIC;A;AAED;;A;AACC;;A;AAED;AACA;A;AAED;;A;AACC;;;;;A;AAEC;A;AAED;A;;AAEA;;A;A;;;;;;A;AAMA;AACA;A;AAED;;A;;;;;AAIA;A;;;;;AAQA;AAEA;;;;;AACC;AAGA;AACA;;;;;AACC;;A;AACC;;A;AACC;;A;AAED;;A;AAED;;A;;AAGD;;A;AACC;;A;AAED;AACA;A;AAEC;A;AAEA;A;AAED;AACA;A;;A;AAGA;A;AAEA;A;A;;;;;;;AAKD;;AACA;A;;;;;;;A;AASC;AACA;A;AAED;AAGA;;AACA;AACA;;;;;;AACC;AACG;;A;AACF;A;A;;AAGF;;AAAqC;A;AAErC;;;;;;A;AAEE;A;AAED;AACA;AACA;;;;;A;;AAED;A;;;;;;;A;;;AAKA;;;;;A;A;A;AAKE;A;A;AAGF;;;AACA;A;;;;;A;AAKC;AACA;A;AAED;;AACA;AACA;AACA;;;A;AAGC;AACA;AACA;A;A;AAIA;AACA;AACA;A;;AAIA;AACA;;AACA;;A;AAED;A;;;;;;;A;AAUC;AACA;A;AAED;A;;;;;;;AAKA;;;;A;AACC;;;AACA;;;;;;A;AACC;A;A;AAGF;;AACA;A;;;;;;AAQA;AACA;AACI;;;A;AAEF;A;AAED;;;;;AAJkB;A;AAMnB;A;;;;;;;AAIA;;;AACA;A;;;;;;A;AASC;AACA;A;AAED;;;;;A;;;;;;;AAIA;;;AACA;A;;;;;;AAQA;;A;AACC;A;;AAEA;A;A;;;;;;AAOD;AACA;A;;;A;AAKC;A;AAED;;;;;;A;A;AAOE;A;A;;AAGF;A;;;;AAIA;;;;;AACC;;;A;AACC;;A;AAED;;A;;AAED;A;;;;;;AASA;;A;AACC;;AACA;A;AAEE;;;;AAAH;;A;AACC;;;;AACA;AACA;A;A;A;AAIA;AACA;A;AAEA;AACA;A;AAED;A;;;;;;;AAKA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;AAED;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAOA;AACA;AACA;A;AAED;AACA;AACA;A;AAED;;;A;A;AAGE;A;AAED;AACA;AACA;AACA;A;A;A;AAWC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;;AAKA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;AAED;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAOA;AACA;AACA;A;AAED;AACA;AACA;A;AAED;;;A;A;AAGE;A;AAED;AACA;AACA;AACA;A;A;A;AAWC;A;AAED;AACA;AACA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;;AAwB4B;A;;;;;AAEK;;;;A;;;;;AAGjC;;;;;;A;AAEE;A;A;AAGA;A;A;;AAGF;A;;;;;;;AAQA;AACA;AAGA;AACA;AAGA;AAGI;AAGA;AAEJ;;AACC;;;;AACA;;;;AAEA;;;;;AACC;;A;AACC;;A;AAED;AAGI;;;;AACH;;AACA;AACA;;;A;AACC;AACA;;;A;AACC;;A;AAED;;;;;A;AARgC;A;A;A;A;AAAA;A;A;AAkBjC;AACA;;A;AAnBiC;A;A;AAsBjC;;;A;AAEC;A;AAED;AACA;AACA;AAEA;AACA;;;;;;A;AAEC;;A;AAID;AACA;;A;A;;A;AAOE;A;A;A;AAKF;;;;;A;AACC;A;AAEC;A;AAED;AAQA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAMC;A;AAhF+B;A;A;AAsFjC;AACA;;A;AACC;;A;AAxFgC;A;A;;A;AA8FpC;;AACC;A;AAKC;A;A;AAGA;A;A;AAGA;A;AAED;A;AASD;AACI;;;;;;AAGH;AACA;AACI;;;AACH;A;AAEC;A;AAHwC;A;A;AAOzC;AAZuC;A;A;AAexC;;;A;AAEC;A;AAjBuC;A;AAqBzC;AACA;AAEA;;;;;AACC;AACA;;;A;;AAED;A;;;;A;AAcC;A;AAED;A;;;;AAOG;;;A;AACF;A;AAED;;;;;;AACA;A;;;;ACttCA;AACA;AACA;;;;;A;AAEE;A;AAED;A;AAEC;A;AAGA;A;A;;A;AAID;A;A;AAGA;A;AAED;A;;;AAQA;;;;;A;AAEE;A;AAED;A;A;AAGE;A;A;AAGE;A;A;AAGD;A;A;AAGF;AACA;;A;AAID;;;A;A;A;AAIE;A;A;A;AAIA;A;A;AAGD;A;AAED;A;;A;AAIA;A;AAED;A;;;A;AASC;A;AAED;;;;;;AACC;A;AAEC;;A;A;A;AAIC;A;A;AAGD;A;A;;AAGF;A;;;A;AASC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;AC9HA;AACI;AACJ;AACA;AACA;;;;;;A;A;AAGG;A;AAED;AACA;AACA;AACA;A;A;A;AAKC;A;AAED;AACA;AACA;A;AAED;;A;A;AAGE;A;A;AAGA;A;AAED;A;A;;AAGF;;;A;AACC;AACA;A;A;AAGA;A;AAED;A;;;;;ACZsC;A;;;;;AAwEtC;AACA;AACA;AACA;A;;;;;;A;AAOC;A;A;AAGA;A;AAED;;A;AAEC;A;A;AAGA;A;AAED;A;;;;;;AAKA;A;;;;;AAMA;AACA;A;AAEC;AACA;A;AAEA;A;A;;;;AAKD;A;;;A;AAMC;A;A;AAGA;A;AAED;A;;;A;AAMC;A;A;A;AAIA;AACA;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAMC;A;A;AAGA;AACA;AACA;A;AAED;A;;;A;AAMC;A;A;AAGA;AACA;A;AAED;A;;;AAMA;A;AAGC;AACA;AACA;A;A;AAGA;AACA;A;AAED;A;A;A;AAIE;AACA;AACA;A;AAED;A;A;AAGC;AACA;AACA;A;A;AAGA;AACA;A;AAED;A;A;AAGC;AACA;A;A;AAGA;AACA;A;AAED;A;AAED;A;;;A;AASC;A;AAED;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;A;AAGA;A;AAED;A;;;A;A;AAOC;AACA;A;AAEA;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;AAGD;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAMC;AACA;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAOC;A;A;AAGA;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAOC;AACA;A;AAED;A;;;A;AAQC;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;A;AAMC;AACA;A;AAED;A;;;AAMA;A;;;;AAKA;AACA;AACA;A;;;;A;AAOC;A;A;AAGA;A;AAID;AACA;A;;;AC1iBG;A;AACF;A;AAED;A;;;;A;AAQC;A;AAED;AACA;;AACK;AACJ;A;AAEC;;;;A;A;AAGA;A;AAED;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;A;;A;A;A;;A;;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACoBA;A;;;;;;AAKA;AACA;AACA;A;;;;;AAQI;AACJ;AACA;;AACC;AACA;AACA;AACA;AACA;A;AAGD;AACA;A;;;;;AAQA;AACA;;A;A;AAEE;A;AAED;;A;AACC;;;;;AACA;AACA;AACA;AACA;AACA;AACA;A;AAED;;A;AACC;;;;;AACA;AACA;AACA;AACA;AACA;A;AAEC;AACA;A;AAED;A;A;A;A;AAKA;AACI;;;A;AAEF;AACA;A;AAH6B;A;AAM/B;A;AAED;AACA;AACA;AACA;A;A;;;;;;;;AAWD;AACI;AACA;AACJ;AACA;A;AAGC;AACI;AACJ;;;;A;AAEC;AACA;A;AAED;A;AAED;AACA;AACA;A;AAEC;A;AAED;;;AACA;A;;;;;;;AAMA;;;;A;;;;;;;;AAK0C;;;;A;;;;;;;;AAIE;;;;A;;;;;;;;AAI5C;;;;AACA;A;;;;;;;;AAKA;;;;AACA;A;;;;;;;;AAKA;;;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;;AACA;;AACA;A;;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;;AAKA;AACA;AACA;A;;;;;;AAyCA;;;;A;;;;;;;AAMA;;;;A;;;;;;;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpRA;AACC;;AACA;AACA;A;AAEC;A;AAED;;A;AACC;;;A;AAED;;;A;AACC;A;A;A;;;;;;A;AClBD;A;AAED;A;;;;;AAYA;AACC;;AACA;AACA;A;AAGC;A;AAGD;;A;AAEC;AACC;;;AACA;;;A;AAEC;A;A;A;AAID;A;AAED;A;AAED;;;A;AACC;A;A;A;;;;;;AClBE;AACJ;AACA;A;;;;AAqBA;;AACA;A;;;;;;AAMG;;;AAAH;;A;AACC;AACA;A;AAGD;AACA;A;;;;;;;;AAI8B;;A;;;;;;;AAGE;;A;;;;;;;AAIhC;;A;AACC;;A;AAED;;;A;;;;;;;AAI8B;;A;;;;;;;AAI9B;;AACA;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;AACA;;AACA;;AACC;;A;AAED;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;AACA;;AACA;;AACC;;A;AAED;A;;;;;;;AAaA;;AACA;AACA;AACA;;A;AACC;AACA;;AACC;;AACA;AACA;A;A;AAGF;A;;;;;;;A;AAOC;A;AAED;;A;AACC;;A;AAED;;A;;;;;;;AAqBD;AACC;;AACA;;A;AACC;A;AAED;A;;;;;;;AAQD;AACC;;AACA;;A;AACC;A;AAED;A;;;;;;;AAKA;AAMI;;;AACH;;AACA;AACA;AAHkB;A;AAKnB;A;;;;;;;A;AAQC;A;AASD;AACA;;AACC;;AACA;AAFoB;A;AAIrB;;AACC;;AACA;AAFY;A;A;;;;;;;;;;AAUV;;;AAAH;;A;A;;;;;A;A;;;;;A;;;;;;;;AAOA;AACA;AACI;;;AACH;;A;AACC;;AACA;A;AAED;AACA;AACA;AAPsB;A;AASvB;AACA;AACA;A;;;;;;;AAmGA;AACA;;AACA;AACA;A;;;;;;;;AAIA;AACA;;AACA;AACA;A;;;;;;;AAIA;AACA;AACA;A;;;;;;;;AAKA;AACA;AACA;AACA;A;;;;;;;;;;AAKA;AACA;;;;AACA;AACA;A;;;;;AC1NA;AACA;AACA;A;AAEC;A;AAED;A;;;;AAKA;AACA;AAEA;A;AAEC;A;A;AAGA;A;AAGD;AACI;;;AACH;A;AAEK;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAVwB;A;A;;;;;AAiB1B;A;;;;;AAKA;A;AAEC;A;AAGD;A;AAEC;A;AAGD;AACA;AACA;A;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/OA;A;AAEC;A;AAED;A;;;;;;ACmBA;AACA;A;AAEC;A;AAED;A;;;;;AAKA;AACA;A;AAEC;A;AAED;A;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;;;AAKA;;;AACG;A;AACF;A;AAED;A;;;AAMA;A;;;;;A;A;;;;;A;AAUA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;AACC;AACA;A;AAEC;A;A;AAIF;AACA;AACA;AAEA;;AACC;AACA;A;AAEC;A;A;A;;;;;A;;;;A;AAcD;;;;;AACC;;;A;;AAED;A;AAGD;;;;;;AACC;AACA;AACA;AAEA;A;;AAED;A;;;;A;AAMC;;;;;AACC;;;A;;AAED;A;AAGD;;;;;;AACC;AACA;AACA;AAEA;A;;AAED;A;;;;A;AAMC;AACA;;;;;AACC;;;A;;AAED;A;AAGD;AACA;;;;;;AACC;AACA;AACA;A;;AAED;A;;;;A;AAKC;AACA;;;;;AACC;;;A;;AAED;A;AAGD;AACA;;;;;;AACC;AACA;AACA;A;;AAED;A;;;;AAIG;A;AACF;AACA;AACA;AACI;;;AACH;AACA;AACA;AAHsB;A;AAKvB;A;AAED;A;;;;AAIG;A;AACF;AACA;AACA;AACI;;;AACH;AACA;AACA;AAHoB;A;AAKrB;A;AAED;A;;;;AAIA;AACA;;;;;AACC;;;A;;AAED;A;;;;AAKA;;;;;AACC;;;AACA;;;AACA;A;;AAED;A;;;;AAIA;AACI;;;AACH;;;AAD4B;A;AAG7B;A;;;;;A;;;;A;;;;;A;;;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;;A;;;;A;AChOC;A;AAED;A;;;;;;A;AAqBC;AACA;AACA;A;A;AAOA;AACA;A;AAEC;A;AAED;AACA;A;A;AAKA;AACA;A;AAID;;AACA;AACA;AAGA;;AACC;A;AAED;A;AAIC;;AACC;AACA;A;AAED;A;A;;;;;;AASD;AACI;AACJ;;AACC;AACA;AACA;A;A;AAIA;AACA;A;AAED;;AACC;AACA;A;AAED;AAGA;AACA;AACA;;AACC;AACA;AACA;AACA;AACA;AACA;AACA;A;AAID;;AACC;AACA;AACA;AACA;AACA;A;AAED;AAGA;;AACC;AACA;AACA;AACA;A;AAGD;A;;;;A;AAKC;A;AAGG;A;AAIH;AACA;AACA;A;AAIA;AACA;AACA;A;AAIA;AACA;A;AAGD;A;;;;AAKA;;AACC;AADY;A;AAGb;A;;;A;AASC;A;AAGD;A;;;;A;AAQC;A;A;AAIA;A;AAEA;A;A;;;;;A;AAMA;A;AAKD;;AACC;A;A;AAKA;AACA;AACA;AACA;A;A;AAID;AACA;A;;;;;A;AAMC;A;AAED;AACA;A;;;;AAMA;AACA;;AACC;A;AAED;A;AAEC;A;A;;;;ACvLD;A;;;;;A;AAQC;A;AAED;;A;;;;;;;AAyEA;A;AAIC;A;AAGC;AACA;A;AAED;A;A;AAKA;A;AAED;AACA;AACA;;A;AACC;A;AAED;A;;;;;A;AAKC;A;AAED;A;;;;AAOA;AACA;AACA;A;;;;;AAMA;A;;;;;A;AAQC;A;AAED;A;;;;;AAKA;A;;;;;AAKA;A;;;;;;AAUA;;A;AACC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;;;;;AAmBA;;A;AACC;A;A;AAGA;A;AAED;;A;AACC;;A;AAEC;A;A;AAGF;A;;;;;;;A;AAMC;AACA;AACA;A;A;AAKA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;;;;AAmBA;;A;AACC;AACA;A;AAED;;A;AAEC;A;AAED;AACA;A;;;;;;AAKA;A;;;;;AAKA;A;;;;;;AAMA;;A;AACC;A;A;AAIA;A;A;AAIA;A;AAGD;A;;;;;;;A;AAOC;A;A;AAGA;A;AAED;A;AAEC;A;AAGD;;A;AACC;;;;;A;A;AAGA;A;A;;;;;;;;AAaD;;A;AACC;A;AAGD;A;AAGC;A;AAKD;AACA;A;AAGC;A;AAiBD;AACA;A;AAIC;A;AAED;AAGA;A;AAEC;AACA;A;AAID;AACA;A;AAOC;A;A;AAGC;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAMD;A;A;A;AAQG;AACA;A;AAED;AAEA;A;AAGA;A;A;A;AAMH;AAEA;;A;AACC;A;A;;;;;;;;A;AAMA;A;AAED;AACA;A;AAEC;AACA;A;AAGD;AACA;AACA;AACA;AACA;;A;AACC;A;AAED;A;;;;;;;AAOA;;A;;;;;;;AAOA;A;AAEC;A;AAID;;A;;;;;;;A;AAQC;A;A;AAGA;A;AAED;AACA;A;AAEC;AACA;A;A;AAGA;AACA;A;AAGD;AACA;;;AACA;AACA;AACA;;A;AACC;A;AAED;A;;;;;A;AAQC;A;AAED;A;AAEC;A;AAEC;A;A;AAGF;A;;;;;AAUA;A;AAEC;A;AAED;AACA;A;AAEC;AACA;A;AAGD;AACA;AACA;AACA;A;;;;;;;;;AAOA;;A;AACC;;A;AAEG;;;;AACJ;;AACA;;A;AAEC;A;AAED;;A;;;;;;AAQA;AACA;AACA;AACA;A;;;;;;AAUA;;A;AACC;A;AAED;AACA;;A;AACC;AACA;A;AAEC;AACA;A;AAED;;;A;AACC;A;A;AAEA;A;A;AAGF;A;;;;;;;AAOA;;A;AACC;A;A;AAGA;AACA;AACA;AACA;AACA;A;AAEC;AACA;A;A;AAGF;A;;;;;AAKA;A;AAEC;A;A;AAGA;A;A;A;AAIA;A;AAEA;A;AAED;A;;;AAKA;A;AAEC;A;A;AAGA;A;A;A;AAIA;A;AAEC;A;AAED;A;AAEA;A;AAED;A;;;;;AASA;;A;AACC;A;A;A;A;AAMC;A;A;AAKA;A;A;AAKA;A;AAEC;A;AAED;A;AAGD;A;AAGA;A;A;AAIC;A;AAED;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;A;AAMA;A;AAGC;A;A;AAOA;A;AAEC;A;A;AAGA;A;AAED;A;A;A;AAKC;A;AAED;A;AAGD;A;AAGA;A;A;AAIC;A;AAED;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAID;;;;A;AAcC;AAMA;A;AAGC;A;A;AAWM;AACJ;A;AAED;A;A;A;AAOC;A;AAED;A;A;AAME;AACJ;AACA;;AACA;A;A;AAQE;A;AAED;A;AAKG;;;;;;A;AAEH;A;A;AAUA;AACA;A;AAGA;AACA;A;AAGD;A;A;AAIK;AACJ;A;AAED;A;A;AAIC;A;AAED;A;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAID;;;;A;AAcC;AAMA;A;AAGC;A;A;AAWM;AACJ;A;AAED;A;A;A;AAOC;A;AAED;A;A;AAME;AACJ;AACA;;AACA;A;A;AAQE;A;AAED;A;AAKG;;;;;;A;AAEH;A;A;AAUA;AACA;A;AAGA;AACA;A;AAGD;A;A;AAIK;AACJ;A;AAED;A;A;AAIC;A;AAED;A;A;AAGD;A;;;;;;;;AAUA;;A;AACC;A;A;AAIA;A;A;A;AAMA;A;AAGC;A;AAMD;AACA;A;AAEC;A;A;AAIA;A;AAED;A;AAGC;A;AAIA;A;AAFA;A;AAID;A;AAGA;A;AAGA;A;AAGD;A;;;;;;;;AASA;;A;AACC;A;A;AAIA;A;A;AAID;;;;A;AAEC;AAEA;AAEA;;;A;AACC;AACA;A;A;AAOA;AACA;AACA;AACA;;A;;AAPA;AACA;A;A;AAQD;A;AAGA;A;AAGA;A;A;AAGD;A;;;;;;;;AAMA;;AACA;AACA;A;;;;;;;AAMA;;AACA;AACA;A;;;;;A;AAMC;A;A;AAGA;A;A;AAGA;A;A;;;;;A;AAmBA;A;AAKD;AACA;AAEA;A;A;AAOE;AACA;A;AAEA;AACA;A;A;A;AAOA;AACA;A;AAEA;AACA;A;AAED;A;AATA;A;AAaD;A;;;;;;;;A;AAaC;A;AAGD;AACA;AAEA;A;A;AAKE;AACA;A;AAEA;AACA;A;A;A;AAOA;AACA;A;AAEA;AACA;A;AAED;A;AATA;A;A;AAcA;AACA;AACA;AACA;A;AAID;A;;;;;;;;A;AAQC;A;AASD;A;AAEC;A;AAEA;A;AAED;A;;;;;;;;A;AAQC;A;AAMD;AAGA;AACG;A;AAEF;AACA;A;AAQD;AAGI;AACJ;;;;AACA;AAMI;A;AAEH;A;AAGD;A;;;;;;;A;AAQC;A;A;AAKA;A;AAEA;A;AAKD;AACA;AACA;;AACK;;;;A;AAEH;AACA;A;A;AAGA;AACA;A;A;AAIA;A;AAEA;A;A;AAIF;A;;;;;;AA6BA;;A;AACC;AACA;A;A;AAIA;A;AAGD;;A;AAQC;AAEA;AACA;;A;AAGC;A;;AAIA;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;A;AAED;A;A;AAOA;AACA;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAGD;;A;AAGC;;A;AAKD;;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;;A;AAEC;AACA;AACA;;A;AAGC;A;;AAIA;;A;AACC;A;;AAEA;AACA;A;A;A;AAID;A;AAED;A;A;AAOA;AACA;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAGD;;A;AAGC;;A;AAKD;;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;AAEA;;A;AAEC;AACA;A;AAGD;A;AAKC;AACA;AACA;A;A;AAMA;AACA;A;AAKD;AACA;A;;;;;;;AAQA;;A;AACC;AACA;A;A;AAIA;A;AAGD;AAEA;;A;AAEC;AACA;A;AAGD;A;AAKC;AACA;AACA;A;A;AAMA;AACA;A;AAKD;AACA;A;;;;;;;AAUA;;A;AACC;AACA;A;AAGD;AACA;A;AAGC;A;AAEA;A;A;A;AAOA;A;AAEA;A;AAGD;A;;;;;;AAYI;A;A;AAGH;A;AAEA;A;AAEA;A;A;AAGA;A;AAED;A;;;;A;AAKC;A;AAED;A;;;;;ACvqDG;;;;A;AACF;A;AAED;A;;;;;;;;;;AAQA;A;AAEC;A;AAID;AAGA;;;;A;AAEC;A;AAIG;AACJ;;;;;;A;AAEC;A;AAIG;AACA;AACJ;;;;;A;AAEC;A;A;AAKA;AACA;AACA;AACA;AACA;A;AAgBD;AACA;A;AAOC;A;A;AAGC;AAGA;A;AAAA;A;AAEA;A;AAEA;A;A;A;A;AAQD;AAGA;A;AAAA;A;AAEA;A;AAKD;;A;AACC;AACA;AACA;AACA;A;;AAEA;;AACA;A;AAGD;;A;AAEC;AACA;A;AAKD;;AACA;;A;AACC;;;;;A;;AAEA;;;;;A;AAGD;A;;;;;;;AA4CA;;A;AACC;;A;AAID;;AACA;AAIA;;;AAEA;;AACC;;A;AACC;;A;AAED;;AACA;A;AAGD;A;;;;;;;;;;A;AA2CC;AACA;A;A;AAGA;AACA;A;AAGD;AACG;;;;;A;AACF;A;AAIE;;;AAAH;;;A;AACC;;A;A;AAEA;A;AAGD;A;;;;;;;AAiBA;AACA;;;AACA;A;;;;;;A;AC9QC;A;AAID;AACA;A;AAGC;A;AAOC;A;AAGD;A;AAED;AAEA;AACA;A;AAEC;A;AAED;AACA;A;AAGC;AACA;A;AAGD;A;;;;;;A;AAUC;AACA;A;AAGD;;A;AACC;;A;AAGD;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;A;AAGC;AACA;A;AAGD;;A;AACC;AACA;;A;AAGD;A;;;;;;;;;A;A;;;;;A;AAUI;A;;;;;;A;;;;;;;AAUJ;;;AACA;;A;AACC;;A;AAED;A;;;;;;;AC3EA;A;AAEC;A;AAED;;A;;;;;;;AAMA;;A;;;;;;;;A;AAQC;A;A;A;AAMC;A;AAED;A;A;AAKD;;;A;AACC;;A;AAEA;;A;A;AASG;AACJ;;A;AAEC;A;AAID;AACA;;A;AACC;AACA;A;A;AAIC;A;AAEA;A;AAEA;A;A;;A;A;AAOA;A;AAGA;A;A;AAGC;A;AAED;A;A;A;A;AAOD;A;AAEA;A;AAGA;A;AAEC;A;A;AAOA;A;AAED;A;A;AAGE;A;AAED;A;A;AAGA;A;AAED;A;A;AAKA;A;AAED;A;;;;;;A;AAMC;A;AAcD;AACA;AACA;A;AAGC;A;AAEA;A;AAED;AAII;AACA;AACJ;AAGI;AACJ;AAKA;AAIA;;;;;;AACC;AACA;AAKA;AAIA;A;AAMC;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;;A;;;;;AAQF;A;AAEC;A;AAED;A;AAIC;AACA;AACA;A;AAEC;AACA;A;AAED;;AACC;AADgB;A;A;AAMlB;AACI;A;AAEH;A;A;AAGA;AACA;A;AAEA;A;AAED;A;AAIC;A;AAED;A;;;A;AAOC;AACA;AACA;;AACC;AADgB;A;A;AAIjB;A;A;AAKA;AACI;;;AACH;AADqB;A;A;AAKvB;A;;;;;A;AAWC;A;A;AAIA;A;AAKD;AACO;A;AAEN;A;AAEA;A;AAGD;;;;AACA;AACA;A;AAEC;A;AAED;A;;;;;;;A;AAUC;A;A;AAIA;A;AAMD;AACA;AACA;;AACC;A;AAED;AAEA;AACA;;;;;AACA;A;AAEC;A;AAED;A;;;;;A;AAKC;A;AAED;A;;;;;AAeA;;;;A;AAEC;A;A;AAID;;;;;A;A;A;AAIC;A;A;AAGA;A;AAIC;A;A;A;A;AAAA;A;A;;AAGD;;;;;;AACA;A;A;AAEG;AACJ;;A;AAEC;A;AAIG;AAEJ;;;;;;;A;AACC;AACA;A;A;AAGA;AACA;;;A;AACC;A;AAED;A;A;AAEA;A;A;AAEA;A;A;AAGG;AACD;;;;A;AACF;A;AAID;;;;;A;AAEC;AACA;AACA;;A;A;AAGA;AACA;;AACA;A;;AAGA;AACA;AACA;;A;A;A;;;;;;;A;ACnaA;A;A;AAGA;A;AAED;A;;;;;AAKA;A;AAEC;AACA;A;AAED;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;AAKA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AASA;A;;;;;AASA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;A;AAIC;A;A;AAKC;A;AAEA;AACA;A;A;AAGF;AACA;A;;;;;AAKA;A;AAIC;A;A;AAKC;A;AAEA;AACA;A;A;AAGF;AACA;A;;;;;A;AAUC;AACA;AACA;A;AAED;AACA;AACA;A;;;;;A;AASC;A;AAEA;A;AAID;A;AAEC;AACA;;;;A;AAGD;AACA;AACA;A;;;;;;;;A;AAOC;A;AAEG;;;;AACJ;AACA;AACA;;A;;;;;;;AAOA;;;AACA;AACA;A;;;;;;;AAOA;;;AACA;AACA;A;;;;;;;AAgBA;;;;AACA;;;;AACA;A;;;;;;;;AAOA;AACI;AACJ;;A;A;AAGE;A;AAEA;A;A;AAGF;A;;;;;;;AAOA;A;AAEC;A;AAEG;AACJ;;A;A;AAGE;A;AAEA;A;A;AAGF;A;;;;;;;AAmBA;A;AAEC;A;AAED;;A;A;AAGE;AACA;A;AAEA;AACA;A;A;AAGF;A;;;;;;;A;AAgBC;A;AAEC;A;A;AAGD;A;AAEA;A;AAED;A;;;;;AAUA;A;;;;A;AAMC;A;AAED;A;;;A;AAMC;A;AAED;A;AAEC;A;AAED;A;;;;AAMA;A;AAEC;A;AAED;A;;;;;AAMA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AAKA;A;;;;;;AAmBA;;A;;;;;;;AAMG;;;A;AACF;A;AAGE;;;A;AACF;A;AAED;A;;;;;;AAMA;AACA;AACA;A;;;;;AAKA;AACA;A;;;;;AAMA;A;;;;;;AAUA;AACA;;A;A;AAEE;A;AAGD;;A;AAED;AAEI;A;AAEH;A;AAGD;;AACA;A;AAGC;AACA;A;AAGD;A;;;;;;;A;AASC;A;AAEC;A;A;AAGA;A;AAED;A;AAGD;;A;;;;;;;;;;AAeI;;;;;;;;AAEJ;AACA;AAGA;AACA;A;AAIC;A;AAEA;A;AAEA;A;AAQD;AAEA;;;;;;AACA;;;;;;AAMA;;AACC;;;;AACA;;;;AACA;;;;;;AACA;;;;;;AACA;A;AAED;A;;;AAYA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;A;;;;AAMA;;;;AAEA;;;;;;A;AAIC;AACA;AACA;AACA;A;A;;;;;;;AAeG;;;;;;;;AAEJ;AACA;AAEA;A;AAIC;AACA;A;AAID;AACA;AACA;AACA;A;AAIC;;;;AACA;;;;A;AAID;;AAEC;;;;;;AAGA;;A;AAIC;A;AAKC;A;A;;AAMD;A;A;AAIF;;A;AAEC;;A;AAEC;A;A;AAIA;;;;A;AAEK;;;;;;;;AACJ;;;;AACA;;;;AACA;AACA;;AACC;;;;AACA;;;;AACA;;;;AACA;;;;AACA;A;AAGD;AACA;AACA;AACA;AAEA;AACA;AAEA;A;AAEA;;AACC;;;;A;A;AAGF;A;A;A;AAKD;A;AAGD;;A;AAEC;AACA;AACA;;A;AAGD;AAEA;A;;;;;;;AAQA;A;AAEC;AACA;A;AAED;;AACA;A;;;;;;;;A;AAUK;AACJ;A;AAED;;A;AACK;AACJ;;A;AAEG;;;;AACJ;;A;AAIC;A;A;AAMA;A;AAEA;A;AAED;A;;;;;;;;;AAMA;;A;AACC;;A;AAOG;;;;;;AACJ;AACA;AACA;A;A;AAIE;A;AAED;A;AAGD;A;AAEE;A;A;AAGA;A;AAED;;A;AAEC;A;AAKD;A;AAEC;A;AAEC;A;A;AAGF;A;AAIC;A;AAED;AACA;A;A;;;;;;;;AAWD;AACA;AACA;;AACA;A;;;;;;;AAYA;AACA;AACA;;AACA;AACA;;AACA;AACA;;AACA;AACA;AACA;;AACA;AACA;;AACA;A;;;;;;;;;;;;;AAOI;AACJ;AACA;AACA;AAGI;AACJ;AACA;;;AACC;A;AAOG;;;;;;;;AACJ;AACA;AACA;;AACA;;AACA;;AACA;AACA;AAEK;AACJ;AACA;;AACC;;AACA;A;A;AAIA;A;AAGD;;AAEA;;AACA;;AACA;;AACA;A;A;;;;;;;;A;;A;AAWA;A;AAEA;A;AAEA;A;A;AAED;;A;AACC;;A;AAID;;;A;AAEC;;A;AAGA;;A;AAGA;;A;A;A;;;;;;;AAMD;AACA;AACA;A;;;;;A;AAOC;AACA;AACA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;A;A;AASE;A;AAED;A;A;AAGA;A;A;AAGA;AACA;A;AAGD;A;;;;;A;AASC;A;A;AAGA;AACA;AACA;AACA;AACA;A;AAED;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;AACA;AACA;AACA;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;A;AAQE;AACA;AACA;AACA;AACA;A;AAID;AACA;AACA;A;A;AAKA;;;;A;AAID;AACA;AACA;AACA;A;;;;;A;AAOC;AACA;AACA;A;AAID;AACA;AACA;A;;;;;;A;AAOC;A;AAED;AACA;;AACA;A;;;;;;;A;ACpmCC;A;AAED;;A;;;;;;;A;AAOC;A;AAED;;;;A;;;;;;;AAIA;;A;;;;;;AAKA;;A;AACC;AACA;;AACC;;AADgB;A;A;A;;;;;;;AAqBd;A;AAEJ;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAGA;;;;;;AACA;A;A;AAGD;;A;AACC;;AACA;A;AAID;AAEA;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAID;AACA;;;A;A;A;AAGE;A;AAEA;A;AAEA;A;A;AAIF;;A;AAGC;;;;;;A;AAEE;A;A;;A;AAMC;AACA;AACA;AAGJ;;;;A;A;AAIE;A;AAEA;A;A;AAKF;AACG;;;;AAAH;;A;AACQ;AACP;;;;;A;AAEC;A;A;AAGA;A;;AAGA;A;A;A;AAKF;AACA;AACA;AACA;AACA;;AACA;A;;;;;;;;AAgBA;;;;A;AAEC;A;AAID;;;;;A;AAEC;A;AAED;AAEA;A;;;;;;;;AAII;AACD;;;;A;A;;;;;A;A;AAIH;;;A;AACC;A;A;A;;AAIA;;A;A;AAED;A;;;;;;AAUA;;;;;AACA;;A;AACC;;A;AAED;A;;;;;;;AAIA;;A;;;;;;;AASA;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;A;AAIA;A;AAED;;;AACA;A;;;;;;A;AClOC;A;AAED;AACA;AACA;A;AAEC;A;AAED;AACA;A;;;;;;A;AAOC;AACA;A;AAED;AACA;;A;AACC;;A;AAED;AACA;AACA;A;;;;;;;;;A;A;;;;;A;A;;;;;;A;;;;;;;AAaG;;;AAAH;;A;AACC;;A;AAED;A;;;;;;;AASA;;A;;;;;;;A;AAOC;A;AAED;;A;;;;;;ACnCA;;;;;AACC;A;;A;;;;;AAKD;AACA;;AACC;A;AAED;A;;;;;A;AAKC;A;A;AAIA;A;AAKD;A;;;;;A;AAKC;A;AAED;AACA;AACA;A;;;;;AAKG;A;AACF;A;AAGD;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;AAIA;AACA;A;AAIC;A;AAGA;A;AAGA;A;AAID;AACA;A;AAEC;A;AAED;AAEA;A;;;;;AAIA;AACA;A;AAIC;A;AAGA;A;AAGA;A;AAID;AACA;A;AAEC;A;A;AAGA;A;AAGD;A;;;;;;AAIA;AACA;A;A;AAIE;A;AAEA;A;AAED;A;AAGD;AACA;;AACC;A;A;AAKA;A;AAEA;A;AAED;A;;;;;AAIA;A;AAEC;A;AAID;AACA;AAEA;A;;;;AAMA;AACA;;;;;;A;AAEE;A;A;;A;;;;A;AAoBD;A;AAED;AACA;AACI;AACA;;;AACH;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEC;A;AAEA;A;AAXiB;A;A;AAelB;A;AAEA;A;AAED;A;;;;AAMG;A;AACF;A;A;;;AAME;A;AACF;A;A;;;AAcD;A;AAMC;AACA;A;AA4BD;AACA;;;;AACA;;;;AAYA;AACA;AAGA;AACA;A;AAEC;AACA;A;AAID;A;AAEC;AACA;A;AAKD;AACA;AAIA;AACA;AAUA;AACA;A;AAEC;A;AAEA;A;A;;;AAUD;A;;;AAOG;A;AACC;A;AACF;A;AAEC;A;A;A;A;;;A;AAQF;A;AAED;A;;;AAQA;AACA;;AACC;AACA;A;AAED;A;;;;AAIA;AACA;A;AAIC;A;AAEA;A;AAEA;A;A;AAMA;A;A;AAKA;AACA;AACA;A;AAUD;AAIA;AACA;AACA;AACA;AACA;AACA;A;AAgBK;AAGJ;AACA;AACA;AACA;AAGA;AACI;;;AACH;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;AATuB;A;A;AAazB;A;;;;AAQA;AACA;AACA;;;AACI;;;AACH;AAEA;;;AAEA;AALkB;A;AAOnB;AACA;A;;;AASA;A;AAGC;AACA;A;AAGD;AACA;;;;AAEA;AACA;AAGA;A;AAEC;A;AAGD;AACA;AAEA;AACA;AAEA;AACA;AACA;A;;;;AAWA;A;AAGC;A;AAEA;AACA;AACA;;;AACA;A;A;AAIA;A;A;AAIA;AACA;AACA;A;A;AAGA;AACA;AACA;A;AAQD;AAEA;AACA;AACA;AACA;AACA;A;AAGK;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGD;A;;;;;A;AASC;A;AAEA;A;AAEA;A;AAEA;A;AAED;AACA;A;;;;;;;AAKA;A;AAGC;A;AAEA;AACA;A;AAEA;AACA;A;AAGD;AACA;AACA;AACA;A;;;;;;;;A;AAKC;A;A;AAIA;AACA;AACA;A;A;AAII;AACJ;;;AACA;AACA;A;AAGD;;;;AACA;A;;;;;;AAMI;AACD;;A;AACF;A;A;AAGA;A;AAED;AACA;A;;;;AAIA;A;;;;;;;AAaA;AACA;AAGA;AAEA;;AACA;AACA;AAGA;AACA;A;AAIC;A;AAED;AAEA;;AACA;AAGA;AACI;;;AAEH;AACG;A;AACE;AACJ;;;AAGA;AACA;;;AAEA;AACA;;AACC;AACA;AACA;A;AAGC;A;AAED;;;A;A;AAKF;AAEA;A;AAEC;A;AACA;AACA;A;AAGD;AAlCmB;A;AAqCpB;AACA;AAEA;AACA;AACA;A;;;;;A;;;;;;AAOG;A;AACF;A;AAED;A;;;;;A;AAOC;A;AAEG;AACJ;;AACC;A;AAGD;A;;;;AAIA;A;;;;A;A;AAOE;A;A;AAGA;A;A;AAIF;A;AAEC;A;AAID;AACA;AACA;AACA;AAEA;A;;;;;A;A;AAOE;A;A;AAGA;A;A;AAIF;AACA;A;AAEC;A;AAID;AACA;AAEA;A;;;;;AAIA;AACA;AACA;A;A;AAGC;AACA;A;AAGC;A;AAED;AACA;A;A;AAGC;AACA;A;AAEA;A;AAED;AACA;AAEA;A;AAED;A;;;;;AAKA;A;AAEC;A;AAGD;A;;;;;AAMA;A;A;AAGE;A;AAED;A;AAGD;;;;;A;AAEE;A;A;;A;AAID;A;AAED;A;;;;;AAIA;AACA;A;AAEC;A;AAID;AACI;;;AACH;AADkB;A;AAInB;A;;;;;AAIA;AACA;A;AAEC;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;;AAIA;AACA;AACA;A;AAEC;;;;AACA;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;;AAIA;AACA;AACA;A;AAEC;;;;AACA;A;AAID;AACI;;;AACH;AADkB;A;AAGnB;AAEA;A;;;;AAKA;A;;;;;AAMI;AACJ;A;;A;;;;;;A;AAQC;A;AAED;AAEA;A;AAEC;A;AAED;AAEA;A;AAEC;;;A;AACC;;;;;AACC;;A;;A;A;AAGD;;;;;AACC;;A;;A;;AAGD;A;A;A;AAED;A;AAEC;A;A;AAIF;A;;;;;;;A;AAQC;A;A;AAKA;A;A;AAMA;A;AAKD;;A;AACC;;;AACA;A;A;AAMA;A;AAED;AAOA;;A;AACC;;A;AACC;;A;AAED;;A;AAGD;AACA;AACA;AACI;AAQJ;AAGI;;;;AACA;;;AACH;AACA;;;;A;AAGC;AACA;;;;A;AAGD;;A;AACC;;;;AACA;;;;;;;;A;AAGD;AAdkB;A;AAiBf;;;AACH;AAEI;;;AACH;AACA;;;;A;AAGC;AACA;;;;A;AAGD;;A;AACC;;;;AACA;;;;;;;;A;AAGD;AAdmB;A;AAHQ;A;AAqB7B;A;;;;;;;AAOI;;;;AAIA;AACJ;AACA;AACI;;;AACH;;;;;;AACA;AACA;;;;AACA;;;;AACA;AACA;;;;AACA;;;;AAPqB;A;AAUtB;AAEI;;;AACH;AACI;;;AACH;;A;AAIC;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;AAEA;AACA;;;;AACA;;;;AACA;;;;A;AAGD;AACA;;;;AACA;;;;AACA;;;;AAEA;AA/BmB;A;AAFQ;A;AAqC7B;A;;;;;;;AAMA;AAIA;;A;AACC;;;A;A;AAIA;AACA;AACA;A;AAMD;AACA;AACI;;;AACH;AACA;AAFmB;A;AAIpB;AAGA;AACA;AACA;;;A;AAEC;AACA;AACA;A;AAGD;AACA;AAII;AACJ;AACA;AACI;;;AACH;AADqB;A;AAKtB;AACA;AAEA;AAGI;;;AACH;AACI;;;A;AAEF;AACA;AACA;AACA;A;AAED;AACA;;;;AACA;AATmB;A;AAFQ;A;AAe7B;AAIA;;A;AAQC;AACA;;A;AACC;;;A;A;AAIF;A;;;;;;;AAQA;AACA;;;;;AACK;;;AACH;AACA;AACA;AAHmB;A;A;;AAOrB;;AACC;A;AAGD;A;;;;A;AAMC;A;AAED;A;;;;AAMA;AAEA;AACI;;;AACH;AACA;AAFoB;A;A;AAKhB;AACA;;;AACH;AACA;AAFwB;A;AAIzB;A;AAGD;A;;;;;;A;AAMC;A;A;AAGA;A;AAQG;;;;AACJ;AACA;AACA;AACI;;AACH;;;AACA;AACA;A;A;AAKE;A;AAED;A;AAED;;;;AAZa;A;A;;;;;;;;ACryCd;;;;AACI;;;AAEH;AACA;A;AAGD;A;;;;AAQA;AACA;;A;AAEE;A;AAED;AACA;A;AAED;A;;;;;;;;;AAyCA;AAGA;;A;AACC;;A;AAID;;;;A;AAEC;A;AAID;AACA;;A;AAEC;AACA;;A;AACC;AACO;;;;A;AACP;;;A;A;AAGE;A;A;A;AAIA;A;AAEA;A;A;AAGD;;;A;AACC;AACG;;;;A;AAEF;A;A;A;AAGD;A;A;A;A;AAID;AACA;AACA;A;AAGA;A;A;A;A;AASH;AACA;AACA;;;AACA;AACA;AACA;AACA;AACC;;A;AACC;AACA;AAEG;;;;A;A;AAED;AACA;A;AAED;A;A;AAKE;A;AAGH;A;AAEA;A;A;AAGC;A;AAEA;A;A;AAGD;A;AAED;;A;AACC;;AACA;A;AAED;AAGA;AACA;A;AAIC;AACA;AACA;A;AAIE;;;;A;A;AAED;AACA;A;AAED;A;A;A;A;AAUA;AACA;A;AAGA;A;AAED;A;A;AAMA;A;AAED;A;AAKC;A;AAGD;A;;;;;;;AAMA;;A;;;;;;;A;AAMC;A;A;AAKA;A;AAKD;A;AAEC;A;AAED;AAGG;AAAH;;A;AAEC;AACA;AACA;AACA;AAGI;;;AAEH;;AACC;AACA;AACA;AACA;A;A;AAMA;AACA;A;AAGA;AACA;AACA;AAGA;AACA;A;AAtBsB;A;AA2BxB;;AACC;AACA;AACA;A;A;;AAID;;;AAIA;;AAGA;AAGA;AAKA;AACA;;AACC;A;A;A;AAKD;AACA;A;AAGD;A;;;;;;;AAqBA;;A;AAEK;AACJ;AACA;;AAEC;AACA;AACA;;AACC;A;A;AAGA;A;AAEC;A;A;AAKF;;;;AAGA;AACA;AACA;A;A;AAKF;AACI;A;AAGH;;AAEC;;;AACI;;;AACH;AAIA;AACA;AACA;AAPiC;A;A;A;AAWnC;;AAEC;;;AACI;;;AACH;AACA;AACA;AAHiC;A;A;A;AASpC;;AACC;AACA;A;A;;;;;;;;AAuBD;;A;;;;;;A;AAOC;A;AAID;AACI;;;AACH;AADkE;A;AAK/D;A;AAEH;AACA;A;AAEA;A;AAID;;A;AAEK;AACA;;;AACH;;A;AACC;;A;AACC;;AACA;A;;AAEA;AACA;A;AAID;AACA;;AACC;AACA;A;AAGD;A;AAjBiB;A;A;A;AAuBnB;A;AAGD;A;;;;;;A;ACjdC;A;A;AAGA;A;AAQD;A;AAEC;A;A;AAIA;A;AAMG;;;;A;A;AAGH;AACA;A;AAEA;AACA;AACA;A;AAEA;A;A;AAKA;A;AAGD;;;;;A;;;;;;;AASA;AAEA;AACA;AAEA;AACA;AAEI;;;;;;AACJ;AAGI;;;AACH;;A;AACC;A;;AAEA;;AACA;A;AAED;;AACA;;A;AARqB;A;A;AAWjB;;;AACH;AACA;;;;A;AAboB;A;A;A;AAkBnB;A;AAPuB;A;AAUzB;A;AAGD;A;;;;;;;A;AA8BC;A;A;AAKA;A;AAUD;AACA;AACA;AACA;AACA;AACA;AACC;;A;AAGC;;A;AAED;AACA;;A;AAEC;A;A;AAQA;A;AAED;;A;AAIC;;AACA;A;AAEC;A;A;AA1BK;A;AA2CR;AACA;AACA;AACA;AA8BA;AACA;AACA;AACA;AACI;;;AACH;;A;AAGC;AACA;AACA;AACA;;;;AAEA;AACA;AACA;;;;A;;AAIA;AACA;AACA;AACA;;;;AAEA;AACA;AACA;;;;A;AAtBgC;A;AA2BlC;;A;AAQC;AACA;A;AAEC;;;;A;AAED;AACA;AACA;AACA;AACA;;;;A;AAEC;A;A;AAKE;;;A;AAEF;A;A;AAKA;A;AAID;AACA;AACA;;;;AAboB;A;AAerB;A;;;;;;;ACxRA;AACA;AACA;A;A;AAGC;A;AAEA;A;AAEA;AACA;A;AAGD;AAGA;;AACC;AACA;A;AAGD;AACA;AACA;A;AAEC;A;AAEA;A;AAED;;A;;;;;;;;AAyBA;A;A;;;;;A;AAIA;A;AAEC;A;AASD;AACI;;;;AACJ;AACA;AACG;A;AACF;A;AAEA;A;AAMG;AACJ;;;;AACA;AACA;A;A;AAME;A;AAED;AACA;A;AAED;;A;AACC;;A;A;AAMA;AACA;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAEI;A;AAEF;AACA;A;A;A;AAIH;AAEA;A;AAEC;A;AAED;A;;;;;;;AAyBA;A;A;;;;;A;AAIA;A;AAEC;A;AASD;AACI;;;;AACJ;AACA;AACG;A;AACF;A;AAEA;A;AAMG;AACJ;;;;AACA;AACA;A;A;AAME;A;AAED;AACA;A;AAED;;A;AACC;;A;A;AAMA;AACA;AACA;AACA;AACA;A;AAGD;A;AAEC;A;AAEI;A;AAEF;AACA;A;A;A;AAIH;AAEA;A;AAEC;A;AAED;A;;;;;;;;AAQA;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;;;AAQA;A;AAEC;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;;AAKA;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;;A;;;;;;;AAKA;A;AAEC;A;A;AAGA;AACA;A;AAED;AACA;;A;;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAMC;AACA;A;AAED;A;;;;;AAKA;AACA;AACA;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAMC;A;AAED;AACA;A;AAEC;A;AAED;A;AAEC;A;AAED;;;;AACA;A;;;;;AAUA;A;;;;;AAKA;A;;;;;AAQA;A;;;;;AAOA;A;AAEC;A;AAED;A;;;;;;AAKA;;;;A;AAEC;AACA;A;A;A;A;AAKA;A;;AAEA;AACA;AACA;AACG;;AAAH;;A;AACC;;;AACA;;;A;AAGC;A;A;AAGF;A;A;AAED;A;;;;;A;AASC;A;AAEA;A;AAED;A;;;AAMI;A;AAEH;A;AAED;AACA;AACA;A;;;;AAUA;A;;;;;;AAKA;AACA;AACA;AACA;AACA;;A;;;;;;;AAKA;AACA;AACA;AACA;AACA;;A;;;;;;;A;AAOC;AACA;AACA;AACA;A;AAED;AACA;AACA;;A;;;;;;;A;AAOC;A;AAED;AACA;AACA;AACA;AACA;AACA;;A;;;;;ACzfA;A;;;;;AASA;;;;A;AAEC;A;A;AAGA;A;AAEE;;;A;AACF;A;AAED;A;;;;;;;A;AAUC;A;AAKE;AAAH;;A;AACI;;;A;AACF;A;AAED;AACI;AACD;;;;A;AACF;A;AAGE;;A;AACF;A;A;AAGA;A;AAED;;A;AAID;AAGA;;;;A;AAEC;A;AAKG;AACJ;;;;;A;AAEC;A;AAIG;AACJ;;;;A;AAEC;A;AAIE;;A;AACF;A;A;AAKA;A;A;AAMA;A;AAID;A;AAEC;A;AAED;;AAGA;;A;AACC;AACA;;A;;AAEA;AACA;A;AAGD;AAEA;A;;;;;;;;;AAcA;AAEI;AACD;;;;A;A;AAED;A;AAED;A;A;AAID;;;A;A;A;A;AAIE;AACA;A;AAID;;AACA;A;AADA;;AACA;A;A;AAGG;AACD;;;;A;AACF;A;AAGG;A;AAEH;A;AAMG;;AACA;;;;A;A;AAED;A;AAED;AACA;A;AAED;;A;AACC;;A;AACC;;AACA;;AACA;A;AAED;A;AAED;AAhBa;A;AAoBd;;;AACA;A;;;;;;AAKA;;A;;;;;;;AAKI;AACJ;;AACA;AACA;;A;AACC;;A;;AAEA;A;AAED;A;;;;;;;AAMA;;A;AACC;;A;AAED;;A;;;;;;;AAOI;AAEJ;;A;AACC;;A;AAEC;AACI;;;AACH;AADqB;A;A;AAIvB;A;AAID;;;;AAEA;AACA;;A;AACC;;A;AAGD;AACA;;;;AAGA;A;AAEC;A;AAEC;AACA;A;A;A;AAKD;A;AAED;;;;AAEA;;A;AACC;AACA;;AACI;;;AACH;AAD+B;A;AAGhC;A;AAGD;A;;;;;;A;ACtQC;A;AAED;AACA;AACA;AACA;A;AAGC;A;AAED;AACA;AACA;A;AAEC;A;AAED;AACA;A;;;;;;A;AAOC;AACA;A;AAED;AACA;;A;AACC;;A;AAGD;AACA;AACA;AACA;AACA;A;;;;;;;;;AAKA;;A;A;;;;;A;A;;;;;;A;;;;;;;AASG;;;AAAH;;A;AACC;;A;AAED;A;;;;;;A;AC7DC;A;AAED;A;;;;;;ACOA;;A;AACC;A;A;AAIA;A;AAGD;;;A;AAEC;A;A;AAKA;AACA;AACA;AACA;A;AAMD;AACA;;AACA;A;A;A;AAUC;A;AAEA;A;AAWD;;A;AACC;A;;AAEA;A;AAID;;A;;;;;;;;;AAcA;AACA;;;AACC;AACA;;AACA;;AACA;AACA;;A;;AAGD;;;AACA;;AAGA;;;A;AACC;A;A;AAEA;AACA;;AAGA;AACA;;A;;AADA;AACA;;A;A;AAGD;;A;;;;;;;;;;;AAaA;AACA;AACA;;;AACC;AACA;AACA;;AACA;;AACA;;AACA;;AACA;AACA;;A;;AAID;;;AACA;AACA;;AACI;;;AACH;AACA;;A;AAKD;;A;;;;;;AAMA;AAEA;AACA;A;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5IA;A;AAEC;A;AAED;A;;;;;AAIA;;AACC;A;AAEC;AACA;A;AAEA;AACA;A;A;A;;;;;A;AAOD;A;A;AAGA;A;AAGD;AACA;AACC;A;AAEC;A;AAED;A;AAGD;A;AAEC;A;AAEA;A;AAED;A;;;;AAgBI;AACJ;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;A;A;AASC;A;AAEA;A;A;AAGC;A;AAEG;AACJ;;;;;AACC;A;AAEC;A;AAEA;A;A;;AAGF;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;AACA;AACA;AACA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEG;AACJ;;;;;;A;AAEE;A;AAEA;A;A;;AAGF;A;AAEI;AACJ;;;;;AACC;A;;AAED;A;AAED;A;;;;;AAKA;AACA;AACA;A;;;;;AAIA;AACA;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;A;AAGC;A;AAED;A;;;;;A;AAMC;A;AAKD;AACA;A;;;;;A;AAMC;A;A;AAGA;A;AAGD;AACA;AACA;AACA;AACA;AACA;A;;;;;AAIA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;;AAIA;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;AACA;A;;;;;AAIA;AACA;AACA;AACA;A;AAGC;A;AAED;AACA;A;AAKC;A;AAEA;A;AAEA;A;AAGD;A;;;;;A;AC7QC;AACA;A;AAEA;A;AAEA;A;A;;;;;ACFD;A;;;;;AA2BA;A;;;;;AAwCA;A;AAEC;AACA;A;AAEA;A;AAED;AACA;A;;;;;AAIA;AACA;A;;;;;A;A;AAUE;A;AAED;AACA;AACA;A;A;AAWC;A;AAID;AACA;AACA;A;AAGA;A;AAGD;AACA;A;;;;;AAaA;A;AAEC;A;AAGD;AACA;A;AAEC;A;AAID;A;AAIC;AACA;AACA;AACA;A;AAGD;AACA;AACA;A;;;;;AAKA;AACA;A;AAEC;A;AAED;AACA;AACA;A;;;;A;AAMC;A;AAED;AACA;AACI;;;A;AAEF;A;AAFsC;;AAKxC;A;;;;AAMA;A;;;;;AAMA;AACA;AACA;A;;;;;AAQA;A;A;AAGE;AACA;A;A;AAMA;A;A;AAGF;A;AAEC;A;AAED;A;AAEC;A;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGC;A;AAGD;A;;;;A;AAcC;A;AAEC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;AAGF;;;;;A;AAEE;A;A;;AAGF;A;;;;;AAKA;AAGA;AACA;;AACC;A;AAED;AACA;A;AAIC;A;AAGD;;;A;;;;;;;AAOA;AACA;;AACC;A;AAED;AACA;AAIA;;A;AACC;A;A;AAMA;A;AAGD;;;A;;;;;;A;AAMA;;A;AACC;;A;AAEC;AACA;AACA;A;A;AAGA;AACA;AACA;A;A;AAKA;A;A;A;A;;;;;;;A;AAWD;A;AAED;AACA;AACA;;;;;A;AAEE;AACA;A;AAEA;A;A;;AAGF;;A;AACC;;A;AAEC;AACA;AACA;A;A;AAGF;A;;;;;;;A;AAgBC;A;AAIG;AACA;AACJ;AACA;AACI;;;AAOC;AACA;AACJ;;A;AACC;;;A;AAEC;AACA;;AACC;A;A;AAKA;AAnBuB;A;A;A;A;AA8B1B;;;A;A;A;AAIC;A;;AAGA;AACA;AACA;AAEI;;;AACH;AADsB;A;AAGvB;;AAEA;AACA;AACA;A;AAID;AACA;AACA;AAtD0B;A;AAwD3B;AAUA;AACA;AACI;AACA;;;AAMC;AACJ;;A;AACC;A;AARyB;A;A;A;AAoB1B;;;A;A;A;AAIC;A;;AAGA;AACI;;;AACH;AACA;AAFsB;A;AAIvB;;AAEA;AACA;AACA;A;AAID;AACA;AAzC0B;A;AA2C3B;AAGA;AACA;AACI;;;AAOH;;A;AAP0B;A;A;AAa1B;;;A;A;A;AAGC;A;;AAIA;AACI;;;A;AAEF;A;AAFyB;A;AAK3B;;;;AAEI;;;AACH;AACA;AAF0B;A;AAI3B;AACA;A;A;AAKA;A;AAED;AAxC0B;A;AA0C3B;AAGA;AACA;AACA;;;;;A;AAEE;;A;AAED;A;;AAED;AAEA;A;;;;;;A;AAOC;A;A;AAGA;A;AAED;A;;;;;A;AASC;AACA;AACA;A;AAEC;A;A;AAIC;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;A;A;AAGF;A;A;AAIA;A;AAEC;A;A;AAGF;A;;;;;A;AAOC;A;A;AAGA;A;AAEC;A;AAED;A;AAED;A;;;;;A;A;AASE;A;AAED;A;A;AAGC;AACA;A;AAEA;AACA;AACA;A;AAED;A;A;AAGA;A;AAED;A;;;;AAIA;AACA;AACA;AACA;;;;;;A;AAGE;AACA;A;AAED;A;;AAED;A;;;;A;AAWI;A;AACF;A;AAED;A;AAKA;AACA;AACA;AACA;AACA;AAED;AACA;AACA;AACA;;AACC;A;AASA;;;;;;;;;;;A;A;AAGK;;;A;AACF;A;AAED;A;AAED;AACA;AACA;A;A;AAEG;;A;AACF;A;AAED;A;A;AAEG;;A;AACF;A;AAED;A;A;A;AAGC;A;AAEA;A;AAED;A;A;A;A;A;A;AAKC;A;AAED;A;A;A;AAGC;A;AAEA;A;AAED;A;A;AAEG;;;;A;AACF;A;A;A;AAGD;A;A;AAGC;A;AAEA;A;AAEA;A;AAED;AACG;;;A;AACF;A;AAED;AACA;A;A;AAEA;AACA;AACA;;;;;A;AAGC;AACA;AACA;A;A;AAIA;A;AAEE;;;A;AACF;A;AAED;AACA;A;A;A;A;A;AAKE;AACA;AACA;A;AAEA;AACA;AACA;A;AAEA;AACA;AACA;A;AAGA;A;AAGI;AACD;A;AACF;AACA;A;AAEA;AACA;A;AAED;;AACC;;;;A;AAEC;A;AAED;AACA;A;AAED;A;AAEA;AACA;AACA;A;A;AAIF;AACA;AAGA;;A;AACC;;;;;A;AAEC;A;A;AAGA;AACA;AACA;AACA;A;A;AAKC;;;;A;AACF;AACA;AACA;AACA;A;AAED;AAGG;;;;A;AACF;A;AAED;A;;AAhKG;;;;A;AACF;A;AAED;A;A;AA+JD;A;AAGD;;AACA;;;A;AAEC;A;AAED;;AAEA;A;AAEC;A;AAED;A;;;;;;;;;;A;AAQC;A;AAED;AACI;AACD;;;;A;AACF;A;A;AAGA;A;A;AAGA;A;AAEA;A;AAEC;A;A;AAGA;A;AACS;;;;A;AACT;A;AAGA;A;A;A;A;AAID;A;AAED;AACA;AACA;A;;;;;;;AAOA;A;AAmBC;A;AAEI;A;A;;;;;A;A;;;;;A;AAMJ;AACA;AACG;A;A;;;;;A;A;A;;;;;A;AAQH;AACA;AACA;AACA;A;;;;;A;AAKG;AACJ;AACA;AACA;AACA;AAEA;;;AACI;;;;A;A;;;;;A;A;A;AASF;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;AAKC;A;AAED;AAGA;AACA;A;A;A;AAME;A;AAED;A;A;AAIA;A;AAED;A;;;;;A;AAvCA;A;A;A;;;;;A;;;;A;AAsDD;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;A;AAMC;A;A;AAIA;A;AAED;AACA;;AACC;A;AAED;AACA;AAEA;AACI;;;A;AAGF;AACA;A;AAED;AANuB;A;AAQxB;A;;;;AAMA;A;;;A;A;AAUC;A;AAEI;;;A;AAEF;A;AAF4B;A;AAK9B;A;AAEA;A;AAEA;A;AAED;A;;;;;AAKA;;AAMA;;;A;AACC;A;AAGD;A;;;;;AAOA;A;A;A;A;AAME;A;A;A;AAKA;A;AAEA;A;A;A;AAKA;A;AAED;AACA;AACA;A;A;A;;;;;AAUD;A;AAEC;AACA;A;AAGC;;;;AACA;A;AAED;AACA;AACA;AACA;A;AAGD;;A;AACC;AACA;AACA;;A;AACC;;A;AAGC;A;AAED;AACA;AACA;A;A;AAGF;A;;;;;;;AAKA;;AACA;;;A;AAEC;A;AAED;;AAEA;A;AAEC;A;AAED;AACA;AACA;A;AAEC;A;AAGD;A;AAGC;A;AAEA;AACA;AACA;AACA;A;AAED;A;;;;;;;;;AAMA;A;A;;;;;;;A;AAIA;;;;A;A;;;;;;;A;AAMA;;A;A;A;AAcE;A;AAKD;AACI;;;A;AAEF;A;AAED;AACA;AALkB;A;A;;;;;;;A;AADnB;AACI;;;A;AAEF;A;AAED;AACA;AALkB;A;A;;;;;;;A;A;AAYlB;A;AAEE;;;;A;A;;;;;;;A;A;AAQF;AACA;AACA;A;AAEE;A;AAEE;;;;A;A;;;;;;;A;A;AAIF;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAED;A;A;AAGA;A;A;;;;;;;A;AAMF;AACG;;;;A;A;;;;;;;A;AAGH;A;AAEC;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;;;;;;;A;A;A;;;;;;;A;;;;;;;;A;A;;;;;;;A;A;A;;;;;A;A;;;;;A;;;;;;;;A;AAoDD;A;AAED;A;AAEC;A;A;;;;;;A;;;;;;;;;;A;AAUA;A;AAGD;A;AAEC;A;AAED;AACA;;;;AACA;A;A;;;;;;;A;A;;;;;;;;A;;;;;;;AAQA;;A;A;AAEE;A;AAEA;A;A;;AAGD;AACA;AACA;AACA;;A;AAEC;A;AAEA;A;A;AAGF;A;;;;;A;AAaC;A;AAEE;A;AACF;A;AAEE;A;AACF;A;AAED;A;;;;;;;;A;AAQC;A;AAID;A;AAEC;A;AAED;AACA;;;;A;AAEC;A;AAEG;;;;A;AAGH;AACA;A;AAGA;A;AAEI;A;AACF;A;A;;;;;;;A;AAIF;;;;AACA;AACG;A;AACF;A;A;A;AAMD;AACA;A;AAGD;;;A;A;;;;;;;A;AAKA;;A;A;AAEE;A;AAEA;A;A;;AAMD;AACA;AACA;AACA;AACA;;A;AAEC;A;AAEA;A;A;A;;;;;;;A;;;;;;;;;AASF;AACA;AACA;AACA;AAEA;A;AAEC;AACA;A;AAKC;A;A;AAIF;AACA;AACA;;A;AAIE;;A;;;;;A;AAGD;AAGA;;A;AACC;;;;;A;A;;;;;A;A;AAKC;;;;AACA;A;A;AAKF;;;;;A;A;;;;;A;AAIA;;A;AACC;;;;AACA;A;AAIE;;;;A;AACF;;;;AACA;A;AAID;AACI;;;;AACD;;;;A;A;;;;;A;AAGH;A;AAGC;AACG;;;;A;A;;;;;A;A;AAIF;A;;;;;A;A;A;AAKD;A;AAEA;A;A;AAGF;AAGA;AACA;;A;AAEC;A;AAED;AACA;A;;;;;A;;;;;;AASA;AAEA;A;AAEC;A;AAID;AACI;;;AACH;;;;A;A;AAIE;A;AALqB;A;A;AAUvB;AACA;AACA;AAZuB;A;AAexB;A;;;;A;AAMC;A;AAED;A;;;AASA;AACI;;;A;AAEF;;;;A;A;AAGE;A;A;AAGA;A;AAED;A;A;AAViB;A;AAepB;A;;;A;AAgBC;A;A;AAIA;A;A;AAIA;AACA;A;A;AAIA;AACA;A;AAIG;;;AACH;AACA;AACA;;AACC;AACA;A;AALoB;A;AAQtB;A;;;AAMI;;;AACH;AADuB;A;AAGxB;A;;;AAKI;;;AACH;AADuB;A;AAGxB;A;;;AAMA;AACI;;;AACH;;;;A;AAEC;A;AAED;AALuB;A;A;AAQvB;A;AAED;A;;;AAKA;;;;;AACC;;;;;;A;AAEC;AACA;;A;AAEG;;;AACH;AADqB;A;A;;AAIvB;;;;;AACC;;;;;;A;AAEC;AACA;;A;AAEG;;;AACH;AADqB;A;A;;AAIvB;A;;;AAKA;AACA;;;;;AACC;;;;;;A;A;AAGE;A;AAED;AACA;;A;AAEG;;;A;AAEF;A;AAED;AAJqB;A;A;;AAOvB;;;;;AACC;;;;;;A;A;AAGE;A;AAED;AACA;;A;AAEG;;;A;AAEF;A;AAED;AAJqB;A;A;;A;AAQtB;A;AAED;A;;;AAMA;AACA;AACI;;;AACH;;;;A;AAEC;AACA;AACA;A;AAED;AAPuB;A;AASxB;A;AAIC;A;AAED;A;;;;AAYA;AACA;AACA;AACA;A;;;;;AAIA;A;;;;;AAIA;AACA;AACA;AACA;;;;;;;;A;;;;AAIA;;AACC;;;A;AAEC;A;AAED;A;AAED;A;;;;;;AAIA;;;A;A;;;;;;;A;A;;;;;;;A;;;AAQA;A;;;A;AAKC;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;A;ACn0DC;A;AAED;A;;;;AAkDA;A;;;;;AAYI;AACJ;AACA;A;;;;;AAKA;AACA;;AACC;A;AAED;A;;;;;AAKA;A;A;AAGC;A;AAED;A;;;;;;;AAOA;A;A;;;;;A;AAQI;AACJ;;AACC;AACA;A;A;;;;;A;;;;;AAQG;AACJ;AACA;AAEA;;A;A;AAGE;A;AAEA;A;A;AAIA;A;AAED;AACA;A;AAED;A;;;;;AAQA;A;;;;;AASA;A;A;AAIC;A;AAIA;A;AAEC;A;A;AAGI;;;A;AAEF;A;AAF0C;;A;AAM7C;A;A;AAIC;A;AAED;A;AAKI;;;A;AAEF;A;A;AAGA;A;AALyB;A;AAQ3B;A;AAID;AACA;AACA;;AACC;AACG;A;A;AAED;A;AAED;A;AAEA;A;A;AAGF;A;;;;;A;A;AASC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;AAII;AACJ;AACA;A;;;;AAIA;;;;;AACC;A;;A;;;AAKD;;;;;AACC;AACA;A;AAEC;A;A;AAGA;A;AAED;AACA;AACA;A;;A;;;AAKD;A;;;A;A;AAMC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAIC;A;AAED;A;AAEC;A;AAED;A;AAEA;A;AAEA;A;AAEA;A;A;;;;A;ACvRA;A;A;AAGA;A;A;A;A;AAMC;A;A;A;AAKA;A;AAED;;;;;;A;AAEE;A;A;;A;A;AAMD;A;AAED;;;;;;A;AAEE;A;A;;A;A;AAMD;A;A;A;AAKA;A;A;A;AAKA;A;A;AAGF;A;;;;AAKA;A;A;AAIC;A;AAEA;A;A;AAGC;A;AAED;;;;;AACC;A;;A;AAGA;A;A;A;AAIA;AACA;A;AAED;A;AAEC;A;AAIA;AACI;;;AACH;;;;AACA;A;AAEC;AACA;A;AAL8B;A;A;AAS5B;;;AACH;;;;AACA;A;AAEC;AACA;A;AAL4B;A;A;AAS/B;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;A;AAEA;A;A;AAGD;A;AAEA;A;A;AAGC;AACA;AACA;A;AAEA;A;A;AAGA;A;AAED;A;AAEG;A;AACF;AACA;AACA;A;AAEA;A;A;A;AAIA;A;AAEA;A;AAEA;A;AAEA;AACA;A;AAEC;A;AAEC;A;A;AAGF;A;A;AAGA;A;A;AAGD;;;;;A;AAEE;AACA;AACA;A;AAEA;A;A;;A;AAIF;;;;;;A;AAEE;A;AAED;A;;A;AA1HD;A;A;A;;;;AAgIG;AACJ;AACA;A;;;;A;A;AAQE;A;AAED;AACA;A;AAGD;A;A;AAEC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGC;AACA;A;AAEC;A;AAED;AACA;A;AAED;AACA;AACA;A;A;A;;;;AAMD;A;AAEC;A;AAED;;;;;AACI;A;AACF;A;A;;AAGF;A;;;;;AAKA;AACA;AACA;A;;;;;A;AAKC;A;AAED;;;;;AACC;A;;A;;;;;A;AC9SA;A;A;A;AAKA;AACA;;;;;;AACC;A;AAGC;AACA;AACA;AACA;A;A;AAGA;A;A;;AAGF;A;AAGA;AACA;A;A;AAMC;A;AAID;A;A;AAME;A;A;AAKA;A;AAID;AACA;AACI;;;AACH;AADyB;A;AAG1B;AACA;A;A;AAOA;A;AAQG;A;AAEH;AACA;AACI;;;AACH;AADuB;A;A;A;AAOxB;AACI;;;AACH;AACA;AACA;AAHgC;A;A;AAMhC;A;AAED;A;A;AAGA;A;AAKD;A;AAGD;A;;;;A;AAsBC;A;A;AAIA;A;A;AAGA;A;AAGD;AACA;AACA;A;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpGA;;;;A;AAEC;A;AAED;A;;;;AAIA;AACA;A;;;A;AAOC;A;AAED;A;;;AAMA;A;;;;AAOA;A;AAGC;A;AAEA;A;AAGD;A;AAEC;A;AAEA;AACA;;;;;AACC;A;;A;A;AAKD;A;AAEA;A;AAED;;;;;AACC;A;;A;AAIA;A;AAEA;A;AAED;;;;;AACC;A;;A;;;;;AAOD;A;AAEC;A;A;AAED;AACA;A;;;;;A;AASC;A;A;;;;;;AAMD;AAEA;AACA;;AACC;AAEA;AACA;AACA;AACA;AASA;AACD;A;AAEE;A;AAEF;AAEC;A;AAKA;;;;;;;;;;;;A;AACC;A;A;AAUA;;A;AAEC;AACA;AACA;A;;AAEA;AACA;AACA;A;A;A;A;AAMD;;A;AAEC;AACA;AACA;AACA;A;A;AAGD;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;;;AACA;;A;AACC;A;AAED;AACA;AACA;A;A;AAGA;;A;AAEC;AACA;A;;A;AAIC;AACA;A;AAED;AACA;A;A;A;AAID;;AACA;;A;AACC;A;AAED;AACA;A;A;AAGA;AACA;A;A;A;AAMC;A;A;AAOA;A;AAEE;A;AACF;A;A;AAKA;A;A;AAKA;A;AAID;A;;AAjIA;A;A;A;AAqIF;A;;;;;;;AAKA;A;AAEC;A;A;AAIA;A;AAGD;;AACA;;;AACA;AAGA;;A;A;AAEE;A;AAED;;;A;AACC;AACA;A;A;;AAUD;AACA;;AACC;;A;AAEC;;A;AAEC;AACA;A;AAED;A;A;AAIA;A;AAED;;;A;AAEC;A;AAED;;;AAlB+B;A;AAoBhC;AACA;A;AAGF;AACC;AACA;AACA;A;;;;;;ACrTA;AACA;A;;;;;AAIA;AACA;A;;;;;AAIA;AACA;AACA;AACA;A;;;;;A;AAOC;A;AAEA;A;AAEA;A;A;;;;;A;AAMA;A;A;AAGA;A;AAED;A;;;;;AAIA;;;;;AACC;A;;AAED;A;;;;;AAMI;AACD;A;AACF;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;AAWA;A;;;;A;AAKC;A;AAED;A;A;AAGE;A;AAED;A;A;A;AAIC;A;AAED;A;A;AAGA;A;AAED;A;A;AAGE;A;AAED;A;A;A;AAIC;A;AAED;A;A;AAGA;A;A;AAGA;A;AAEA;A;AAED;A;;;;;;;AAOA;A;AAEC;A;AAED;AACA;;;;;AACC;A;;AAED;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;A;AACC;;;;A;AAEG;AACJ;;A;AACC;A;;AAEA;;A;AAED;AACC;;A;A;AAGE;A;A;AAIA;A;AAED;;;;;A;AAEC;;A;AAEC;A;AAED;AACA;;;;AACA;;;;A;A;A;A;AAKA;A;AAED;A;AAED;AACA;A;AAEC;A;A;AAKA;A;AAED;AACA;;;;AACA;;A;AACC;;;;A;AAED;;;;A;AAED;AACA;A;;;;;;AAKA;;;;;A;AAEE;A;A;;AAGF;A;;;;;AASA;AACI;;;AACH;AACA;A;AAFgC;A;A;A;AAO/B;AAP+B;A;A;AAUhC;AACA;A;A;A;AAOE;AACA;A;A;AAIA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;AAGA;A;AAEA;A;AAEA;A;AAEA;A;AAzBA;A;A;AA4BA;A;A;AAGA;A;AA7C+B;A;AAgDjC;A;;;;;;AAQD;A;AAEE;A;AAEE;A;AACF;A;AAGD;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAIA;;;;;;;A;A;A;AAGC;AACA;AACA;A;A;AAEA;;A;AACC;AACA;A;A;A;AAGD;AACA;A;A;AAEA;;A;AACC;AACA;AACA;AACA;A;;AAEA;AACA;A;A;A;A;AAIA;A;AAEA;A;A;AAGA;A;AAED;AACA;A;;AAnCA;A;A;AAqCD;A;;;;;;AAWA;;;;A;AAEC;A;AAED;A;;;;AAIA;AACA;A;;;;;;AAKA;A;AAEC;A;AAGD;;A;AAEC;A;AAEA;A;AAGD;AACA;;;;;AACC;A;;AAGD;;AAEA;;;;AACA;;;;AACA;;;;AACA;;A;AACC;;;;A;AAEG;AACJ;;A;AACC;A;;AAEA;;A;AAED;AACA;AAEA;;;;;A;AAGC;;;A;AACC;A;AAED;AACA;;;;AACA;;;;AACA;;AACA;A;AAED;AACC;AACA;A;AAIA;;;;;;;;;;;A;AACC;A;AAEC;AACA;A;AAED;A;A;AAEA;;A;AACC;A;A;A;AAGD;;A;AACC;A;A;A;A;A;AAKD;;A;AACC;A;A;A;AAID;AACA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;AACC;A;AAED;A;A;A;AAGC;A;AAED;A;;AAvCA;A;A;A;AA0CA;A;AAED;AACA;AACA;;;;AACA;;A;AACC;;;;A;A;AAIH;A;AAEE;AACA;A;AAGD;AACA;AACA;A;;;;;;;AAKA;;A;;;;;;;A;AAUC;A;AAGD;;A;AACC;;A;AAED;;A;AACC;;A;AAGD;;AACA;;AAEA;AACA;;;A;AACC;AACA;A;AAGD;AACA;AACA;A;;;;;;;;ACxfA;A;A;;;;;;;A;AAIA;AACA;AACA;;AACC;AACA;A;A;A;;;;;;;A;AAQG;AACJ;;AACC;AACA;;;;A;A;AAKA;A;A;;;;;;;A;;;AAUD;A;AAEC;A;A;AAGA;A;AAED;A;;;AAIA;A;A;AAGC;A;AAED;A;;;;AAWA;A;;;;;;AAIA;AACA;AACA;A;;;;;AAIA;AACA;A;;;;;A;AAKC;A;AAED;A;;;;;A;AAKC;A;A;;;;;A;AAMA;A;AAED;AACA;AACA;A;;;;;A;;A;;;;;;;;;;AAuBA;AACA;A;AAEC;A;AAGA;;;;AAED;AACA;AACA;AACA;A;AAEE;AACA;A;A;AAIF;AACA;;A;AAEE;A;AAED;A;AAEA;AACA;AACA;A;AAGD;;AAEC;;;;A;AACC;;A;A;AAEA;;A;A;AAEA;;A;;AAEA;;A;A;A;AAGA;A;A;AAGF;A;;;;AAKA;;;;;;A;A;A;AAIE;A;AAEA;AACA;A;A;;A;;;AAOF;AAKA;;;;;;AACC;A;;AAQD;;;;;A;A;AAME;AACA;AAEA;A;AAEC;;;;AACA;A;AAEC;;A;A;AAGF;A;AAIC;;A;AAID;AACA;AACA;A;AAEC;A;AAEA;AACA;;;;A;A;AAGA;A;A;AAMA;A;A;AAtCD;;A;A;;AA0CF;A;;;;AAMwC;A;;;;;AACA;A;;;;;AACA;;;;A;;;;;;;;;;A;AAavC;A;AAIA;AACA;AACA;AACA;AAKD;;;;AACC;AACA;A;AAEC;A;AAED;A;AAEA;;;;;;;;;A;AACC;;;;;AAEA;AACA;A;AAEC;AACA;A;A;AAIA;;;;AACA;;;;A;A;AAGA;AACA;A;AAID;;;;A;AAGC;AACA;A;A;A;AAGD;;AACA;AAEA;AACA;AACA;;;;;AACC;A;;A;A;AAGD;;AACA;AACA;AACA;AACA;;;;;AACC;A;;A;A;AAGD;A;A;AAEA;A;AAEC;A;AAED;A;AAEC;AACA;AACA;A;AAED;AACA;;A;AACC;AACA;AACI;;;AACH;AAD2C;;AAG5C;A;;AAEA;A;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;A;AAEA;A;AAEC;A;AAED;AACA;AAEA;;A;AACC;AACA;AACI;;;AACH;AAD2C;;AAG5C;A;;AAEA;A;AAED;AACA;AACA;;;;;AACC;A;;AAED;A;A;AAEA;A;AAEC;A;AAED;AACA;AACA;A;A;AAEA;A;AAEC;A;AAED;AACA;AACA;AACA;;;;;AACC;A;;A;A;AAGF;A;;AAGD;AACA;AACA;AACA;;AACC;AACA;AACA;;;A;AACC;AACA;A;A;A;AAID;;;;;AACC;A;;A;AAGF;A;;;;;;A;A;;A;A;A;;A;AAiBA;;;;;AACC;A;A;A;A;;A;A;A;A;AAaG;;A;A;;A;A;A;;A;A;;AAQJ;AAGA;;A;AAGC;A;A;;A;;;;;AC/YD;A;;;;;AAYA;AACA;A;;;;;AAcA;;A;;;;;;AAiCA;A;;;;;AAIA;;;;A;AAEC;A;AAED;AACA;AAEA;AACA;;;A;AAEC;A;AAED;A;AAEC;A;AAED;;A;AAWC;;;AACA;A;AAEA;;;;A;A;AAKA;AACA;;A;AAGD;AACA;AACA;;AACC;A;AAED;AAEA;A;;;;;;AAkBA;;;;A;AAEC;A;AAED;AACA;A;AAEC;AACA;;;;;AACC;A;;A;AAMF;A;AAEC;A;A;AAGA;AACA;A;AAED;A;;;;;;AAKA;AACA;AACA;AACA;A;;;;;AAOA;;;;AACA;;A;AACC;;A;AAED;A;;;;;A;AAgBC;A;AAED;A;;;;AAKA;A;;;;;AASA;A;;;;;A;AAsBC;A;AAEC;A;AAED;A;AAED;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;;A;AAGC;A;AAEC;;A;A;A;AAKD;A;AAEC;;A;A;AAGF;A;;;;;A;AAUC;A;AAEC;A;AAED;A;AAED;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;;A;AAGC;A;AAEC;;A;A;A;AAKD;A;AAEC;;A;A;AAGF;A;;;;;;A;AAYC;A;AAGD;;;;;A;AAEC;AACA;A;AAED;AACA;A;;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;;;A;;;;;A;;;;;;AAaA;;A;;;;;;;AAMA;;A;;;;;;;AAMA;;A;;;;;;;;;;AAwCA;A;AAEC;A;AAED;;AACC;A;;AAED;A;;;;;;;;AAOA;;AACC;A;;A;;;;;;;;;AASD;;;AACC;;;;A;;;AAED;A;;;;;;;AAIA;AACA;AACI;AACA;A;AAEH;A;AAEA;A;A;AAGA;A;AAGG;AACJ;;AACC;;A;AAEC;A;A;AAKA;A;AAEA;A;AAOD;;A;AACC;;A;AAED;AAGI;A;AAEH;;A;AAEA;;A;A;AAGA;A;AAIA;A;AAEA;A;A;A;AAMD;A;AAEA;A;AAGD;A;;;;;;;;;;;AAOA;A;AAEC;A;AAED;AACA;;A;AAEE;A;AAED;A;;AAED;A;;;;;;;;AAOA;;AACC;A;;A;;;;;;;;;AASD;;;AACC;;;;A;;;A;;;;;AAaD;;;;;A;AACC;A;;A;;;;A;AA0CA;A;AAED;AACA;;AACC;A;AAED;A;;;;;;AAOI;A;AAEH;A;AAEA;A;AAGG;;;;;;;;AACH;;A;AAEC;A;AAGD;A;A;AAME;A;AAEG;A;AAGH;;A;AAEA;;A;A;AAGA;A;AAEA;A;A;AAGD;A;AAED;AAEA;;A;AACC;AACA;A;A;A;;;;;;;;AAQE;AACJ;;A;AAEC;A;AAED;A;;;;;;;;AAQA;;A;A;;A;A;;A;;;;;;;AAaI;AACJ;;A;AAEC;A;AAED;A;;;;;;;;AAQA;;A;A;;A;A;;A;;;;;;;;AAaA;;A;A;;A;A;;A;;;;;;;AAaI;AACJ;;A;AAEC;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;AAqBA;A;;;;;AAOA;A;;;;;AAIA;;AACC;A;AAEC;A;AAED;AACA;A;AAGC;AACA;AACA;A;AAED;;;;;A;AAGC;AACA;AACA;A;AAED;A;A;A;AAIG;A;AAEA;A;A;A;AAIF;;;;;;A;A;AAGG;A;AAEA;A;AAED;A;A;;A;A;AAKJ;AACA;A;;;;;;;;A;AAOC;A;AAED;A;AAEC;AACA;A;AAEA;A;AAED;AACA;;AACC;;;A;AAEC;A;AAED;A;A;AAIA;A;AAED;A;A;AAIE;A;AAED;A;AAID;AACI;;;A;AAEF;AACA;A;AAED;AAL0B;A;A;AAS1B;A;AAGD;AACA;AACA;A;;;;;AASA;;;A;;;;;;;AASI;AACJ;;A;AAEC;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;AASA;;;A;;;;;;;AASA;;;A;;;;;;;;;A;AAWC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;;;A;AASC;A;AAEG;AACJ;;A;AAEE;A;AAED;AACA;;;;;A;AAEE;A;A;;AAGF;A;AAED;A;;;;;;;;A;AAUC;A;AAEG;AACJ;;A;AAEE;A;AAED;A;AAED;A;;;;;;;A;AAqBC;A;A;AAIA;A;AAGD;;AACA;AAEA;AACA;AACA;;;;;A;AAEE;A;AAGD;A;AAEC;A;AAED;A;;A;AAIA;A;AAGD;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;;;;;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnrCA;A;;;;AAIA;A;;;;;AAKA;AAGA;;AAEA;A;;;;;;AAIA;AAGA;A;AAIC;A;AAGD;AACA;AAEA;;A;;;;;;AAIA;;A;;;;;;;AAIA;AACA;AACA;A;AAIC;A;AAID;AACA;;AAGA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;A;;;;;;;AAIA;;AACA;AACA;AACA;AAGA;;AAEC;AACA;;AAGA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;A;AAGD;;A;;;;;;;AAIA;;A;;;;;;A;AAKC;AACA;AACA;AACA;AACA;AACA;AAEA;A;AAED;A;;;;;;AAKA;;AAGA;;AAGA;AACA;;AAGA;AACA;;AAGA;;AACA;;AAGA;AAEA;AAEA;;AAEA;;AAEA;;AAGA;AACA;AACA;AACA;;;;;A;AAEC;A;AAID;;;;A;AAEC;A;AAID;AAGA;;AAGA;AACA;AAEA;AAEA;AACA;AAEA;AACA;;AAGA;AACA;AAGA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAGA;AACA;AAEA;AACA;;A;;;;;;;AAIA;AACA;;AAEA;;AACC;;A;AACC;;A;AAEC;A;A;AAGF;;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIA;AACA;;AAEA;AACA;;AACC;;A;AACC;;A;AAEC;A;A;AAGF;;A;AAEC;A;AAED;A;AAED;A;;;;;;;AAIA;;;;A;AAEC;A;AAID;AAGA;AACA;AAGA;AACA;AACA;AACA;;AACA;AAEA;;A;;;;;;;AAKA;;AAGA;AAEA;AAGA;;AAGA;AAEA;AAEA;;AAEA;AAEA;;AAGA;AACA;AACA;AACA;;;;;A;AAEC;A;AAID;;;;A;AAEC;A;AAID;AAGA;;AAGA;AACA;AAEA;AAEA;AACA;AAEA;AACA;;AAGA;AACA;AAGA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAGA;AACA;AAEA;AAEA;;A;;;;;;;AAMA;;AACA;AACA;AAEA;AACA;AACA;AAEA;A;;;;;;;AAIA;;AACA;;AAEA;A;;;;;;AC1WA;AACA;AAEA;AACA;AACA;AACA;;AACC;AACA;;AACA;AACA;AACA;A;AAGD;A;;;;;;AAOA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;;;AACA;AAEA;AAGA;AACC;AAEA;;;;;AAIC;;;AAEA;;AACC;AACA;A;A;;AAIF;;;;;;AACC;AACA;;;;;A;AACC;A;A;;AAKF;AACA;A;A;;;;;;;;ACnEG;AACJ;;;A;AAGC;A;AAGD;A;;;;A;ACPC;A;AAED;AACA;;;;;AACC;A;;AAED;AACA;A;;;A;AAKC;A;AAEC;A;AAGD;AACA;AACA;A;A;AAOA;AACA;AACA;A;AAGC;A;AAED;;;;;AACC;A;;A;AAGA;A;AAGD;AACA;AACA;AACA;A;AAED;A;;;A;AAKC;A;AAED;AACA;A;AAEK;;;AACH;AADuB;A;A;AAIzB;AACA;A;;;;;;;AC5DA;AACA;AAGA;AACA;AACA;AACA;A;AAKC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAID;;AAEC;AACA;AACA;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;A;;;;;;;A;;;;;;A;A;;A;A;A;;A;A;;;A;;;;;;;;AAgCD;;;;AAGA;AACA;AACA;;;;A;A;;;;;;;A;AAWA;AACA;;AACA;;A;;;;;;;A;;;;;ACvFA;AAEI;;;A;AAEE;;;AACH;AADyB;A;A;AAF+B;A;AAQ3D;AACI;;;A;AAEF;A;AAFoB;A;AAMtB;A;;;A;AAMC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;A;;;;AAII;AACA;;;AACH;;;A;AACC;A;AAFmB;A;AAMjB;AACJ;AAEA;;A;AACC;A;;AAEA;A;A;;;;;;AAKD;A;;;;;AC3CA;AACA;AACA;A;AAGC;A;AAOD;AACA;AAGA;AAEA;A;;;;AAIA;AAEA;AACA;AACA;AACA;;;;;AAEK;;;AACH;;A;AAEC;A;AAH4C;A;AAO9C;AACA;AAEA;A;AAEC;A;A;A;;AAKF;A;;;;;AAIA;;A;;;;;;AAIA;AAEA;;AACA;;AAEA;;;;AAEA;;A;AACC;A;AAEA;;;A;A;;;;;;;AAKD;AAEA;AAEA;;AACA;;AACA;;;AACA;;;AAEA;;A;;;;;;AAKI;AAEJ;AACA;AACA;AACC;AACA;AACA;AACA;AAEA;;AACA;AAEA;;;A;AACC;A;AAED;A;A;;;;;;AASD;AACA;;AACA;;A;;;;;AAMI;AACJ;AAGA;AAEI;;;AAEH;AACA;;A;AAEC;A;AAID;AACI;;;AACH;AAD+B;A;AAK5B;;;AACH;;A;AADwD;A;A;AAMxD;;;AACA;;A;AAEC;A;AATuD;A;AAcrD;;;AACH;AAEI;;;AAEH;;A;AAEC;A;AAJ0D;A;AAS5D;;A;AAEC;A;AAED;;A;AAEC;A;AAlBwD;A;AAuBtD;;;AACH;AAEI;;;AAEH;;A;AAEC;A;AAJwD;A;AAQ1D;;A;AAEC;A;AAED;;A;AAEC;A;AAjBwD;A;AApDnC;A;AA0ExB;A;;;;;AAMA;;AAGA;;AAEA;;AAEA;;AAEA;A;;;;;;;AAIA;;;AAEA;AACA;AAEI;;;AACH;AAD4B;A;AAI7B;AAEA;;A;A;;;;;A;AAMA;AAEA;;AAEA;;A;;;;;A;;;;;AAOA;;AAGA;;AAEA;;AAEA;;AAEA;;A;AAEC;A;AAGD;;A;AAEC;A;AAGD;;AACA;;;;;A;AACC;A;AAEA;A;A;;;;;;AAKD;AAGA;;AAGA;AAGA;;AACA;;AAEA;;A;;;;;AC5RA;A;;;;;AAUA;A;;;;;;;AAMA;AAEA;;;;AAEA;AACA;AAEA;;;A;A;;;AAIA;A;;;;;;;;AAMA;;A;;;;;;AAKA;A;;;;;AAKA;A;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;AClDA;A;;;;;;AAMA;AACA;AAGA;A;AAEC;A;A;A;AAIC;A;AAKC;A;AAED;A;;;;;A;A;AAMC;A;AACC;A;AACF;A;;;;;A;A;A;;;;;A;;;;;;;A;A;A;A;;A;A;;;;;;;;;;;;;;;;;;;;;;ACiIF;A;;AAIA;A;;AAIA;A;;;AAIA;A;;;;A;A;AAMC;A;AAEA;A;AAED;A;;AAoHA;A;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;ACjSC;A;AAEA;A;AAEA;A;A;;;AAkBD;AAoBA;AACA;AACA;AAEA;;AACC;AACA;AAEA;;;;;AACC;AACA;AACA;A;AAGC;A;A;;AAMF;AACA;AACA;A;AAKD;A;;;AAQA;AACA;AACA;AACA;A;;;AAgBA;AAEA;AAgCA;AACA;AACA;AAEA;;AACC;AACA;AAEA;;;;;AACC;AACA;AACA;A;AAGC;A;A;;A;AAKD;A;AAGD;AACA;AACA;AACA;AACA;AACA;A;AAGG;AACJ;AACA;A;;;AAcA;AACA;AAEG;A;AACF;A;AAEC;A;AAED;AACA;AACA;A;AAGD;A;;;;AClJA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAKA;A;;;;;AAMA;A;;;;;AAMA;A;;;;;AAIA;A;;;;;AAIA;A;;;;;AAIA;;;A;AAEC;A;AAED;AACA;A;;;;;AAIA;;;A;AAEC;A;AAED;AACA;A;;;;;A;AAOC;A;AAED;A;;;;;;AAOA;;;;;A;A;AAEC;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;A;;;;;;;A;A;AAOA;AACA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;A;AAOA;A;AAGD;AACA;AAEA;AAEG;A;AACF;A;AAGD;A;;;;AAIA;A;;;AAIA;A;;;;;;A;;;;;A;;;;;;;;AAsBA;AAEA;;;AACA;AAEA;A;AAGC;AACA;A;AAGD;AACA;AACA;A;;;;;AAqBI;A;AAGH;A;AAGD;AACA;A;;;;;AA+DA;AAEA;AACA;AACA;A;AAGC;A;AAGD;A;;;;;AAKA;AAEA;AACA;AACA;A;AAGC;A;AAGD;A;;;;;AC9UA;;;;A;AAEC;A;AAED;A;;;;;;;AAII;AAED;;;;A;AACF;A;AAGD;AACA;A;;;;;;;AAII;AAED;;;A;AACF;A;AAGD;AACA;A;;;;;;AASA;;;;AACA;;;;AACA;A;;;;;AC7CA;A;;;AAIA;A;;;AAIA;A;;;;AAuBA;A;;;;;;AAsDA;;A;;;;;;AAsBA;AACA;AACA;AACA;AAEA;AAEA;AACA;A;;;;AAIA;AACA;AACA;AACA;AAEA;AAEA;AACA;A;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;;A;A;A;A;A;;A;;A;;A;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpHA;;;;A;AAEC;A;AAED;A;;;;;;;AAYA;;;;A;AAEC;A;AAED;A;;;;;;;AAIA;;A;;;;;;;AAIA;;;;A;AAEC;A;AAED;;AACA;A;;;;;;;AAIA;AACA;;A;;;;;;;AAIA;AACA;AACA;;AACA;AACA;A;;;;;;AAIA;;;;A;AAEC;A;AAED;A;;;;;AAMC;AACA;AAED;AACA;AACI;;;AACH;AAD8B;A;AAG/B;A;;;;;;;A;A;A;A;A;;;;;;;;;;;;;;AC/EA;A;;;;A;A;A;A;A;A"} +{"version":3,"file":"js.js","sources":["/github.com/gopherjs/gopherjs/js/js.go","/internal/bytealg/index_generic.go","/internal/bytealg/indexbyte_generic.go","runtime.go","/runtime/error.go","/errors/errors.go","atomic.go","pool.go","sync.go","/sync/mutex.go","/sync/pool.go","/sync/runtime.go","/sync/rwmutex.go","/io/io.go","/math/bits/bits.go","math.go","/math/abs.go","/math/dim.go","/math/floor.go","/math/frexp.go","/math/ldexp.go","/math/log10.go","/unicode/utf8/utf8.go","/strconv/atof.go","/strconv/atoi.go","/strconv/decimal.go","/strconv/extfloat.go","/strconv/ftoa.go","/strconv/itoa.go","/strconv/quote.go","/crypto/crypto.go","/crypto/sha256/sha256.go","/crypto/sha256/sha256block.go","unicode.go","/unicode/digit.go","/unicode/graphic.go","/unicode/letter.go","reflect.go","swapper.go","/reflect/type.go","/reflect/value.go","/sort/search.go","/sort/slice.go","/sort/sort.go","/sort/zfuncversion.go","/internal/fmtsort/sort.go","syscall.go","syscall_unix.go","/syscall/dirent.go","/syscall/exec_unix.go","/syscall/str.go","/syscall/syscall.go","/syscall/syscall_linux.go","/syscall/syscall_linux_amd64.go","/syscall/syscall_unix.go","/syscall/zsyscall_linux_amd64.go","/github.com/gopherjs/gopherjs/nosync/map.go","/github.com/gopherjs/gopherjs/nosync/mutex.go","/github.com/gopherjs/gopherjs/nosync/once.go","/github.com/gopherjs/gopherjs/nosync/pool.go","time.go","/time/format.go","/time/time.go","/time/zoneinfo.go","fd_poll.go","/internal/poll/fd.go","/internal/poll/fd_fsync_posix.go","/internal/poll/fd_mutex.go","/internal/poll/fd_posix.go","/internal/poll/fd_unix.go","/internal/poll/fd_writev_unix.go","/internal/poll/sock_cloexec.go","/internal/poll/sockopt.go","/internal/poll/sockopt_linux.go","/internal/poll/sockopt_unix.go","/internal/poll/sockoptip.go","/internal/poll/writev.go","/internal/testlog/log.go","os.go","/os/dir.go","/os/dir_unix.go","/os/error.go","/os/error_posix.go","/os/error_unix.go","/os/file.go","/os/file_posix.go","/os/file_unix.go","/os/path_unix.go","/os/proc.go","/os/rawconn.go","/os/stat.go","/os/stat_linux.go","/os/stat_unix.go","/os/types.go","/os/types_unix.go","/fmt/format.go","/fmt/print.go","/fmt/scan.go","strings.go","/strings/builder.go","/strings/reader.go","/strings/strings.go","/encoding/hex/hex.go","bytes.go","/bytes/buffer.go","/bytes/bytes.go","/bytes/reader.go","/encoding/binary/binary.go","/encoding/base64/base64.go","/encoding/json/decode.go","/encoding/json/encode.go","/encoding/json/fold.go","/encoding/json/indent.go","/encoding/json/scanner.go","/encoding/json/tags.go","/log/log.go","/math/rand/exp.go","/math/rand/normal.go","/math/rand/rand.go","/math/rand/rng.go","/math/big/accuracy_string.go","/math/big/arith.go","/math/big/decimal.go","/math/big/float.go","/math/big/floatconv.go","/math/big/floatmarsh.go","/math/big/ftoa.go","/math/big/int.go","/math/big/intconv.go","/math/big/intmarsh.go","/math/big/nat.go","/math/big/natconv.go","/math/big/prime.go","/math/big/rat.go","/math/big/ratconv.go","/math/big/ratmarsh.go","/math/big/roundingmode_string.go","/math/big/sqrt.go","/regexp/syntax/compile.go","/regexp/syntax/op_string.go","/regexp/syntax/parse.go","/regexp/syntax/prog.go","/regexp/syntax/regexp.go","/regexp/syntax/simplify.go","/regexp/backtrack.go","/regexp/exec.go","/regexp/onepass.go","/regexp/regexp.go","/github.com/bonedaddy/vcaptcha/vdf/classgroup.go","/github.com/bonedaddy/vcaptcha/vdf/discriminant.go","/github.com/bonedaddy/vcaptcha/vdf/division.go","/github.com/bonedaddy/vcaptcha/vdf/encode.go","/github.com/bonedaddy/vcaptcha/vdf/gcd.go","/github.com/bonedaddy/vcaptcha/vdf/prime.go","/github.com/bonedaddy/vcaptcha/vdf/proof_wesolowski.go","/github.com/bonedaddy/vcaptcha/vdf/vdf.go","rand.go","/context/context.go","/github.com/segmentio/ksuid/base62.go","/github.com/segmentio/ksuid/ksuid.go","/github.com/segmentio/ksuid/rand.go","/github.com/segmentio/ksuid/uint128.go","/github.com/bonedaddy/vcaptcha/ticket/ticket.go","main.go"],"names":[],"mappings":";;;;;8nBA+B4C,yC,2GAGW,kE,8GAGhB,yC,6GAGN,kC,6GAGQ,mB,oHAGc,4C,4HAGY,yE,gHAGX,mD,6GAGH,kG,qGAGrB,mB,uGAGI,sC,wGAGN,8B,oGAGI,qC,yGAGE,sC,0GAGA,6B,4GAGQ,8C,iHAGP,gB,0GASnC,kE,wGAKA,4C,8EAsBA,oB,gDAkBA,IACA,wBACA,wBACA,wBACI,0DACH,U,2CADiC,W,S,CAKjC,4GACC,mJ,WANgC,W,CASlC,S,wCAmBA,kBACA,W,2sD;;wHCzJA,qC,mCAcA,qC,2CCTI,yC,wBAEF,S,CAFsB,W,CAKxB,S,yM;;opCCAA,a,4GAGA,S,mFAIA,qEACA,0BACA,wBACA,sBAEI,YACJ,sCACA,W,yBAIA,kB,kBAEC,U,CAEE,wB,qBAEF,+B,MACS,e,qBACT,+B,C,CAID,sB,qFAQA,yE,kB,qD,CAIA,6J,6F,6BA6BA,4CACA,a,wC,uDAiF6D,S,sH,6B,kGAEA,S,4EAG7D,c,wC,yCA6CA,oB,2C,gICpMA,c,6BAEC,wB,CAED,sB,wBAEC,mD,CAED,sB,yBAEC,iD,U,mDAIE,yC,MAEA,uC,C,CAGF,S,CAED,kF,kH,6IAUA,4B,++C,4F,4F,4F;iQCpDA,oB,2DASA,W;2F,qC,qC,mC,8B,wC,2C;sV,mBC8BC,YACA,Y,CAED,a,kE,4DAqBC,YACA,Y,CAED,a,6DAoBA,mBACA,YACA,U,wCA4BA,iB,yCAYA,iB,gDAYA,Y,iDAQA,Y,sF,kB,+G,oCAqBC,kE,C,+EAGA,mF,CAED,Q,0f;8hGCxKA,qD,OACC,kE,OACC,oG,OAED,uB,OAED,sIACA,oDACA,e,+N,mCAKC,O,CAED,2B,4E,4QCHA,8F,OACC,qB,MAEC,2J,MAEA,4I,CAED,2FACA,oI,gDAEC,uB,C,O,yB,8Y,yBAUF,+C,kBAEC,a,CAGD,4FACA,iBACA,sF,kBAEC,uB,CAGD,oI,gG,gK,sBAQA,a,eAMA,wF,sBAKA,4C,0R,oJ,UCHE,e,CAED,a,CAGG,kBACJ,QACA,QACA,IACA,UACA,OAGC,mD,O,2LAME,O,CAED,KACA,WACA,UACA,c,OAED,I,cAGC,Q,C,mBAGA,W,C,sBAOA,Q,C,M,cAMC,oC,CAED,c,CAED,iL,O,cAEE,c,CAGD,+B,8BAEC,M,CAED,wMACA,sGACA,U,mB,oCAOE,oC,CAED,K,wBAOC,W,CAED,mIACA,c,CAED,OACA,I,qBAEA,U,O,qB,UAKD,e,C,4b,UAYA,iBACA,e,CAID,sI,uBAEC,oC,CAED,2C,OACC,IACA,O,oCAQE,a,CAGD,eACA,iL,OACC,4MACA,a,OAED,U,qB,qBAOD,2M,O,8NCcD,sJACC,2GACI,mDACH,gBACA,wCACA,2EACC,0I,KAED,kCANiC,W,CAQlC,UACA,c,KAED,c,gBASA,M,6BAIA,yCACA,yC,sBCxMI,wBACJ,M,6R,UCRC,mBACA,Y,CAED,8L,OAEC,gO,O,UAGA,WACA,kJ,C,oX,UAUA,mBACA,uJACA,Y,CAEE,8JAAH,qC,O,6CAEE,WACA,uC,CAGD,6L,OAEC,gO,O,O,UAID,W,C,8X,UASA,mBACA,Y,CAGD,6FAEA,qLAEA,6M,OACC,gO,O,UAGA,WACA,kJACA,kJ,C,gY,UAYA,mBACA,kJACA,Y,CAID,sK,kBAEC,WACA,sC,CAGG,4CACH,gOADuB,W,qBAIxB,+F,UAEC,W,C,2OAOD,yC,8PAK4B,6H,uWACA,+H,2kH,4F,4F,4F,sG,K,K,sB,K;05BCgJzB,sCAAH,mC,O,kI,O,sJ,ib,gB,oD,CAkBA,iEACK,IACJ,sHACA,W,qB,SAGA,Y,6CAEA,wB,CAED,kB,qY,kI,w/B,4F,4F,4F,wC,0C,sB,8C,wE,iC,iC;8qB;mGCzS+B,mB,0CAYI,mB,4C,SAwBlC,oB,CAED,6B,6C,UAoBC,U,CAGD,qJ,iD,8BAMC,U,CAaD,wR,8C,SAwLC,qB,CAED,8B,6C,aAoBC,8BACA,K,C,WAGA,6BACA,W,C,wG,2C,0CAQA,4BACA,K,C,8CAGA,4BACA,Y,C,4CAGA,2BACA,W,C,4I,gM,qH,qN;gmBCzRD,+B,0C,+CAKC,U,CAED,U,wCAoBA,8B,mCAYA,gC,wD,0C,sC,UAcC,S,MAEA,S,C,2C,WAMA,a,C,WAGA,a,CAED,a,mD,0B,6C,sB,WAUE,U,CAED,mC,CAED,iB,uC,iBAKC,S,CAED,8B,qCAYA,c,4CAIA,iB,4BAuBA,S,2C,gDAKC,S,CAED,iC,qCAQA,wB,yCAgBA,+B,oCAyBA,+BACA,4CACA,8CACA,8C,yBAIA,sBACA,yB,6CAIA,qBACA,0B,uDAIA,sBACA,oJ,6CAIA,kCACA,wDACA,0B,oDCjPA,0E,iE,mC,6D,C,qC,+B,uBC4BC,a,yBAEA,Y,8B,WAGC,U,CAED,U,C,UAGA,U,CAED,U,2CCqBA,UACA,oD,YAGC,uF,cAEC,uF,C,kBAQD,iBACA,mGACA,qH,CAED,c,kF,a,qC,2B,qC,CClEA,4BACA,UACA,iHACA,yFACA,uFACA,UACA,c,iD,aCZC,U,2BAEA,U,CAED,4BACA,cACA,UACA,iE,aAEC,e,C,Y,SAIC,c,CAED,a,CAEG,K,aAEH,cACA,0B,CAED,yFACA,4GACA,iB,kCCxBA,2B,aAIC,kB,CAED,sC,kL,4F,yI,e,I,M,O,M;yXC4HA,Y,Q,gC,CAIA,4FACA,iF,WAKC,2B,+I,CAGD,YACA,8G,e,gC,CAIA,4F,mB,gC,C,U,0E,CAOA,4F,iB,gC,C,U,yG,CAOA,6F,mB,oC,C,4I,iHAgBA,W,Q,gC,CAIA,kBACA,iF,WAKC,2B,qE,CAGD,YACA,8G,e,gC,CAIA,kB,mB,gC,C,U,0E,CAOA,kB,iB,gC,C,U,yG,CAOA,mB,mB,oC,C,4I,oFAgBA,Y,U,gC,CAIA,SACA,0G,U,4B,CAOA,S,QAEC,I,CAEG,W,+B,wGAEF,M,CAFyB,W,C,QAM1B,I,CAED,oC,sB,gC,C,4B,gFAgBA,W,U,gC,CAIA,SACA,yB,U,4B,CAOA,S,QAEC,I,CAEG,W,+B,uBAEF,M,CAFyB,W,C,QAM1B,I,CAED,qC,sB,gC,C,4B,oD,QAYC,S,iBAEA,S,kBAEA,S,6BAEA,S,mBAEA,S,qBAEA,S,CAED,S,2CAOO,Y,WAEN,yGACA,S,kBAEA,mGACA,6HACA,gIACA,S,4CAEA,QAGA,mGACA,8HACA,wIACA,gIACA,S,mBAJA,mGACA,8HACA,wIACA,gIACA,S,MAEA,mGACA,8HACA,yIACA,wIACA,gIACA,S,C,oEAOD,YACI,IACA,kCACH,WACA,mG,UAGC,WACA,S,CAED,iF,YAEC,WACA,S,CAED,qB,eAEC,WACA,S,CAED,8GACG,8G,mBACF,I,gB,MAES,8G,iBACT,I,gB,MAES,8G,iBACT,I,C,C,CAED,W,CAED,S,iEAKA,WACI,kCACH,kB,UAGC,WAJkB,W,S,CAOnB,iF,YAEC,WATkB,W,S,CAYnB,qB,eAEC,WAdkB,W,S,CAiBnB,8GACG,yB,mBACF,I,gB,MAES,yB,iBACT,I,gB,MAES,yB,iBACT,I,C,C,CAED,WA3BmB,W,C,a,+CAmCS,+B,2DAoC7B,WACI,kCACH,kB,UAEC,WACA,S,CAED,iF,YAEC,a,CAED,qB,eAEC,a,CAED,8GACG,yB,mBACF,a,gB,MAES,yB,iBACT,a,gB,MAES,yB,iBACT,a,C,C,CAED,W,CAED,Y,yC,kBAQC,Y,8BAEA,Y,CAED,a,wW,67B;82E,6BCrfC,a,CAEG,yCACH,kB,iBAEC,kB,CAED,kB,iBAEC,kB,C,eAGA,a,CAVuB,W,CAazB,Y,wD,iBAKC,Y,C,kB,a,kC,sC,C,mB,kC,uC,C,kC,e,qC,C,kC,gC,sC,C,MAIA,Y,CAkBD,Y,0EAIA,IACA,YACA,c,gBAIC,S,C,2BAIA,W,iCAEA,WACA,W,CAID,QACA,QACA,qC,2B,MAIG,S,CAED,OACA,UAPgB,W,S,mDAWhB,O,uCAEC,iBAbe,W,S,C,aAiBf,8GACA,iB,oCAEA,a,CApBe,W,S,CAwBjB,M,C,OAGA,S,C,OAGA,U,C,kEASA,W,gBAEC,S,CAED,I,yBAEC,W,+BAEA,WACA,K,C,wDAGA,S,CAED,IACA,+E,YAEE,kD,CAF8C,W,CAKhD,4B,C,sBAIA,S,CAGD,OACA,S,4JAQA,I,gBAIC,kB,C,2BAIA,W,iCAEA,OACA,W,CAID,QACA,QACA,IACA,IACA,IACA,qCACQ,kB,O,mB,MAGL,kB,CAED,OACA,IAPgB,W,S,6BAWhB,O,sBAEC,WAbe,W,S,CAgBhB,W,SAEC,gCACA,kFACA,W,oCAEA,O,CAtBe,W,S,CA0BjB,M,C,OAGA,kB,C,OAGA,I,C,kEASA,W,gBAEC,kB,CAED,I,yBAEC,W,+BAEA,WACA,K,C,wDAGA,kB,CAED,IACA,+E,YAEE,kD,CAF8C,W,CAKhD,sB,C,sBAIA,kB,C,iCAIA,S,CAED,OACA,kB,yKAQI,IACA,mBAGJ,0C,OACC,mBACA,SACA,c,OAMD,0C,OACC,c,OAED,2C,OAEC,mBACA,SACA,c,OAID,IACA,iCACK,I,oBAEH,K,MAEA,4G,CAED,YACA,W,CAED,wDACK,I,qBAEH,K,MAEA,6G,CAED,WACA,W,CAID,W,oBAMC,qBACA,YACA,W,CAGD,yF,OACC,c,QAID,mCACA,qBAGA,sH,QACC,2BACA,WACA,0F,QACC,c,Q,Q,iIAMD,S,CAED,cAED,OAEC,mBACA,oDACA,OAED,OAEC,qIACA,6J,UAEC,yH,C,kC,4I,sEAsBA,Y,CAED,kB,MAEC,K,C,Y,+B,qB,SAYC,mHACA,K,C,sBAIA,Y,C,gI,sB,uI,CAMF,Y,gE,sEAOC,Y,CAED,kB,MAEC,K,C,Y,+B,qB,SAWC,4HACA,K,C,sBAIA,Y,C,yI,sB,gJ,CAMF,Y,gHAMG,qB,M,+C,C,MAMF,0C,M,OAIK,yB,M,oC,C,CAKJ,uCACG,8B,MACF,gCACA,oC,MAEC,oB,C,4B,C,C,CAMA,yC,e,gD,CAIJ,sCACA,qC,OAEC,oB,C,gC,gHAME,qB,M,oC,C,MAMF,0C,M,OAIK,yB,M,oC,C,CAKJ,uCACG,8B,MACF,gCACA,uB,MAEC,oB,C,4B,C,C,CAMA,yC,e,gD,CAIJ,sCACA,wB,OAEC,oB,C,gC,gC,WAwBA,qBACA,c,CAED,Y,4NCngBA,0J,yLAIA,qC,0BAIA,oC,8BAIA,mD,8BAIA,uD,wD,iBAeC,0C,CAGD,I,gB,kB,0F,eAUG,0C,CAED,KACA,kB,iCAEA,IACA,kB,MAEA,K,C,MAID,4C,C,UAIA,K,oBAEA,4C,CAKG,mB,I,aAGH,oC,mBAEA,2B,MAEA,0G,CAGD,+EAEI,mBACJ,2KACK,I,iBAGH,gB,wBAEA,8B,uBAEA,8B,MAEA,0C,C,sBAIA,0C,C,2DAKA,2B,CAED,iCAEA,oE,iHAGC,2B,CAED,I,KAGD,oB,sH,iB,wD,CA+BA,IACA,Q,yBAEC,kB,+BAEA,OACA,kB,CAIG,mBACJ,yB,iGAEC,kCACA,wB,0C,C,UAKA,K,CAGD,oD,+D,yG,C,6D,sG,CAOA,+B,MAEC,+B,C,oC,yEC7KD,a,WAEC,c,C,WAGA,e,CAGD,mBACA,I,eAGC,U,kBAIA,oGACA,WACA,oGACA,WACA,yCACA,kE,oBAIA,kEACA,oGACA,WACA,qE,MAIA,kEACA,kD,CAED,yC,wFAIA,kDACC,oG,KAED,iB,2BAOA,4IACC,iB,C,aAGA,O,C,iEAMG,YAGJ,IACA,+DACC,oCACA,6EACA,kIACA,WACA,I,CAID,OACI,W,+BACH,6KACA,iBAFgB,W,CAIjB,UACA,M,0HAUA,IACA,IAGI,IACJ,yD,Y,UAIG,OACA,O,CAED,yDACC,WACA,W,CAED,M,CAED,iGACA,4BAdgB,W,CAgBjB,wBAEI,oCAGJ,iCACC,iGACA,2BACA,cACA,+GACA,WACA,4BANe,W,CAUhB,8BACC,2BACA,c,UAEC,+GACA,W,cAEA,a,CAED,W,CAGD,OACA,M,6BAiGI,yC,iBAEF,Y,C,4HAGA,uH,CALsB,W,CAQxB,a,uDAKA,4G,iJAEC,W,CAGD,OACA,YAGI,IACA,W,+BACH,4IACA,yFACA,mBACA,W,UAEC,+G,qBAEA,a,CAED,IAVgB,W,CAcjB,8BACC,yFACA,mBACA,W,UAEC,+G,qBAEA,a,CAED,I,CAGD,iB,cAEC,S,CAED,iBACA,M,oD,e,cASC,+BACC,SACA,Y,CAED,gB,cAEA,gCACC,SACA,Y,CAED,iB,C,gG,iBAOA,a,C,qH,YAKC,Y,CAED,gM,CAGD,iG,oD,iBASC,O,C,YAGA,a,MAEA,e,C,mH,iBAOA,O,CAED,OACA,M,mI,iBAMC,O,CAIG,wCACH,yF,SAEC,6LACA,YACA,O,CALuB,W,CAWzB,UACA,OACA,iB,qI,YAOC,0C,CAEG,IACJ,mBACI,6CACH,qMADgC,W,CAGjC,iCACC,gCADe,W,C,eAIf,kE,CAED,S,oMCzRA,cAEA,c,oBAIC,qBACA,6CACA,W,CAID,kD,wJAGC,kE,C,uFAKA,2BACA,W,C,2DAMA,mBACA,oDACA,O,uIAGA,S,CAGD,qIACA,6J,UAEC,mH,CAED,Y,mPAQA,SACA,6BACA,Q,0HAGC,kDACA,Q,oE,CAGD,cAEA,4G,mGAEC,4G,MAEA,4G,CAED,Y,4J,yCAQC,S,CAED,2BACA,wCACA,mBACA,gB,oKAMA,8EACA,8EAGA,cACA,cAGA,qKACA,wMAEA,2EAEA,yFACA,6B,4MAeA,I,MAGC,W,CAGD,SACA,QACA,QAGA,oG,kB,iB,CAIA,4E,iKAKC,yGACA,c,MAEA,cACA,wGACA,W,CAID,wG,QAEC,W,CAED,WAGA,gBACA,2BAQA,eACI,I,aAGH,uD,MAEA,oB,CAGD,6CACA,qI,uY,iB,C,gB,wKA0BA,mHACA,oGAEA,iBACC,wG,UAGC,W,gBAEA,W,MAEA,W,C,CAKF,wG,oD,sGAOA,4BACA,wGACA,wGACA,S,0J,yCAQC,OACA,OACA,YACA,Y,C,UAGA,yF,CAID,cACA,qBAEA,iBACA,2CACA,6FACA,mBAGA,IACA,IACA,mBACI,8D,iFAEF,IACA,M,CAED,gCALmC,W,CAOpC,I,QAGC,8FACA,uGACA,wC,MAEA,I,CAIG,YACJ,KACI,kCACH,gGACA,6BACA,WACA,uGACA,K,CAEG,qCACH,6MAD2B,a,CAG5B,WACA,QACA,YACA,Y,Q,6CAIE,yE,CAID,8BACC,gCACA,gC,oIAGC,a,CAED,0BACA,qKACA,uEACA,aACA,W,CAED,Q,CAkBD,0G,QAEC,a,CAGG,6C,8HAEF,aACA,M,CAHyB,a,CAM3B,Y,4I,gFAaC,yE,C,6GAGA,0D,C,wJAGA,Y,C,wJAIA,YACA,+B,kHAEE,iB,MAEA,M,CAJY,W,C,QAQb,qGACA,OACA,iB,MAEA,iO,CAED,Y,CAED,a,sM,yCASC,OACA,OACA,YACA,Y,C,gDAII,YACJ,KACI,wEACH,oCACA,6EACA,kIACA,WACA,I,CAED,iBACI,kCACH,0MADmB,W,CAGpB,sBACA,8JACC,iB,C,aAGA,O,CAED,YACA,Y,CAED,c,gBAGC,uDACA,Y,C,gBAGA,uDACA,Y,CAGD,YAEA,gFACA,gFAIA,iBACA,2CACA,iGAGA,wEAEA,wEAGI,KACA,qE,wFAEF,MACA,M,CAED,kCALmC,a,CAOhC,qCACH,4GACA,6GACA,yIACA,0CAEG,0F,gEACF,aACA,aACA,YAGA,0D,CAZ6B,a,CAe/B,QACA,eACA,YAII,KACJ,oBACA,YACC,kCACA,kCACA,uCACA,gJACA,iBACA,2F,mFAKC,yG,C,C,8J,yFAcD,a,CAED,mN,YACC,iOACA,mD,C,2OAIA,a,C,gKAIA,a,C,yHAIA,OACA,O,CAED,Y,mCC1lBA,mE,2DAMA,qB,uHAII,mBACA,S,I,aAGH,+CACA,K,mBAEA,mBACA,K,MAEA,wE,CAGD,qFACA,wFACA,qI,I,kDAKK,K,iCAGH,Q,YAEA,S,MAEA,S,CAED,yB,kBAIA,W,MAIA,iG,CAED,gB,WAIC,qB,C,OAIA,yB,CAGG,+BACJ,QAEA,M,MAGC,uCACA,qEACI,aACJ,eACA,2B,OAEC,yB,C,K,8BAKA,kB,qBAEA,qB,oCAEA,O,C,uBAID,K,K,8BAGC,a,oC,UAGC,I,CAED,K,C,WAII,aACJ,eACA,0CACA,wB,C,C,OAID,yB,CAED,kC,yDAKA,wCACA,YACA,gCACI,+BACJ,M,MAEC,YACA,mD,I,4BAIC,Y,oBAEA,qB,kCAEA,O,C,M,I,4BAMA,gB,oBAEA,mB,kC,UAGC,I,CAED,W,CAED,mD,CAED,kC,iD,I,4BAMC,gC,oBAEA,8B,kCAGA,I,uBAEC,O,C,MAMA,I,CAED,Y,e,WAGE,O,CAED,iE,C,WAGA,O,CAED,4C,CAID,uB,2E,8BAQC,OACA,O,CAiBD,c,gFAGC,O,CAMD,wCACA,yEACA,uCAQI,mBACA,I,iHAEH,kCACA,I,MAEA,iEACA,S,CAED,wCACA,yEACA,uCAKA,gEAII,qCACH,K,WAEC,yF,CAED,yFACA,K,WAEC,yF,CAMD,mCAIA,mD,SAMC,gBACA,O,YAEA,oBACA,O,YAEA,kBACA,O,CA/BoB,W,C,6D,MA8CrB,gB,CAID,K,kBAEC,oG,CAED,e,QAIC,gBACA,IACA,kB,QAEC,qCACA,I,CAED,+BACC,gBADgB,W,C,CAMlB,eACA,Y,aAEC,I,C,QAGA,KACA,K,MAEA,K,CAED,e,SAKC,2C,gBAEA,mN,MAEA,+X,CAGD,S,6C,MAOC,gB,C,WAKA,gBACA,qCACA,iCACC,gBADe,W,C,MAIhB,gB,C,QAKA,gBACI,kCACH,KACG,Y,iBACF,2G,CAED,eALqB,W,C,CASvB,S,2C,MAOC,gB,CAID,+BAGA,iBAGA,2B,SAEC,gB,CAED,8CAEA,S,2B,QAKC,S,CAED,S,2B,QAKC,S,CAED,S,+B,2DCrbC,yB,CAED,oCACA,S,kD,kGAQC,sD,CAED,+FACA,S,yCAKA,gC,8C,kGAOC,sE,CAED,yFACA,S,mD,2DAOC,yC,CAED,8BACA,S,0C,SAMC,qE,CAED,+P,8G,cA4BC,iE,CAIG,YACJ,K,MAGC,gC,C,W,SAYC,yEAIC,4CACA,kGACI,kCACH,uEACA,4FACA,WACA,2TACA,2TALkB,W,CAUnB,WACA,wTAEA,I,C,CAMF,iBACA,iCACC,uEACA,4FACA,WACA,2TACA,2T,CAID,UACA,WACA,gT,UAEC,WACA,wS,C,gBAWD,6CACA,sBACA,mBACA,oFACC,WACA,4JACA,2B,CAGD,WACA,iJ,MAGA,sBACA,oFACC,WAIA,sBACA,+MACA,K,CAGD,WACA,iJ,C,MAKA,WACA,kF,C,MAIA,yCACA,Y,CAED,2CACA,Y,uBAIA,yB,qCC5LA,4J,6CAQA,eACI,yCACH,yBACA,I,WAEC,wC,C,yBAGA,wBACA,2EACA,uEAT0B,2B,CAY3B,gBAZ2B,mBAc5B,eACA,S,uCAIA,e,oBAEC,Q,CAED,gBACA,eACA,S,iDAII,Y,6BAEH,gBACA,4BACA,S,C,M,iBAIC,4BACA,S,C,0BAGD,4BACA,2CACA,S,C,I,YAIA,wB,kBAEA,wB,mBAEA,wB,mBAEA,wB,mBAEA,wB,kBAEA,wB,mBAEA,wB,M,SAIC,wBACA,0EACA,sE,oBAEA,QAGA,wBACI,oCACH,8EADoB,W,C,kBADrB,wBACI,oCACH,8EADoB,W,C,MAIrB,wBACI,oCACH,8EADoB,W,C,C,CAKvB,S,uBAQA,4B,yCAMA,8B,2CAOA,2B,gDAMA,6B,sDA0BA,8B,mDAcA,6B,4DAqBA,qCACC,wCACA,kB,Q,cAGE,a,CAED,S,C,cAGA,a,C,4CAGA,a,C,CAGF,Y,0EAIA,W,iB,qC,wB,6C,uB,6C,CASA,Y,oH,iBAoBC,iBACA,gB,CAEM,kB,kCAEN,iBACA,gB,iBAEA,wC,yE,sB,+F,C,gBAQA,iBACA,gB,CAED,kBACA,kBAEA,kB,I,aAEC,I,mBAEA,I,oBAEA,K,oBAEA,K,oBAEA,K,oBAEA,I,oBAEA,K,+CAEA,I,I,cAGC,I,oBAEA,I,mBAEA,I,CAEG,I,eAEH,iBACA,gB,CAEG,kCACH,qC,QAEC,iBACA,gB,CAED,cANkB,W,CAQnB,kB,YAGC,IACA,M,C,cAGA,iBACA,gB,CAED,IACA,O,yGAEA,kB,eAEC,iBACA,gB,CAEG,oCACH,iC,eAEC,iBACA,gB,CAED,mBANkB,a,CAQnB,kB,WAEC,iBACA,gB,CAED,K,mBAEA,K,iC,eAGC,iBACA,gB,CAED,W,MAEA,iBACA,gB,C,CAED,IACA,gB,6EASA,W,QAEC,0B,CAED,kB,oCAEC,0B,CAED,2B,W,aAIE,0B,C,aAIA,mCACI,yC,8BAEF,6B,CAFsB,W,CAKxB,sC,CAED,oB,C,6BAGA,0B,C,aAGA,0B,C,wB,I,a,qBAQE,oB,C,mBAGD,wC,iDAEC,oB,C,C,CAKC,YACJ,0HACA,qCACC,sC,sCAEC,a,CAED,I,cAEC,4B,MAEA,4BACA,2C,C,gCAIA,0B,C,CAGF,sC,2CAKA,uC,uCAMA,wBACA,8BACC,qG,uGAEC,S,MAEA,I,C,CAGF,S,uCAMA,wBACA,8BACC,qG,uGAEC,S,MAEA,I,C,CAGF,S,+D,W,kBAiBE,Y,C,mBAIA,mB,CAED,a,C,kBAUA,uCACA,U,+OAEC,a,CAED,UACA,+H,CAGD,kCACA,U,+OAEC,a,C,cAGA,Y,CAED,eACA,uBACA,4I,2C,YAmBC,a,CAED,iBACA,WACA,+H,yqG,4F,4F,4F,4F,4F,O,mC,6I,qE,0C,uC,q1E,ia,+4J,wiB,yB,2B,s3E,ouB,0+E,me;oM,UCjbC,qE,CAED,mG,sM,4F,4F,4F;8rBCxFA,oBACA,oB,0DAgDA,sB,YAEC,4B,MAEA,4B,CAED,cACA,cACA,cACA,cACA,cACA,cACA,cACA,cACA,+CACA,+CACA,aACA,oB,uJ,6IAKC,6D,C,yBAGA,uD,CAED,iBACA,0BACA,0BACA,0BACA,0BACA,0BACA,0BACA,0BACA,0BACA,wCACA,yBACA,sDACA,iB,wGAIA,mGACA,oHACA,oHACA,mHACA,yG,0BAIA,mGACA,oIACA,oIACA,oIACA,oIACA,oIACA,oIACA,mIACA,8G,4BAII,WACJ,cACA,gC,4BAII,WACJ,cACA,gC,oDAIA,mGACA,i1CAEA,yB,wBAIA,mGACA,6bACA,yB,gD,aAKC,kBACA,kBACA,kBACA,kBACA,kBACA,kBACA,iBACA,kB,MAEA,kBACA,iBACA,iBACA,kBACA,kBACA,kBACA,kBACA,kB,CAED,OACA,uB,6EAQA,wDACA,UACA,S,gCAKA,wDACA,aACA,UACA,S,6D,aAKC,U,CAED,U,0GAGkC,U,iVAGlC,YACA,gFACA,wC,OACC,2CACA,iBACA,2C,OACC,kGACA,O,OAED,iB,OAED,+C,OACC,qBACA,wGACA,iB,O,gBAGA,8B,CAED,kB,+aAKA,cACA,wG,YAEC,sD,CAED,sC,qcAIA,QAEI,WACJ,SACA,4G,OACC,gM,qBAEA,iM,OAID,sBACA,cACA,gH,kBAGC,iC,CAGG,WAEJ,gCACA,gCACA,gCACA,iCACA,iCACA,iCACA,iC,aAEC,iC,CAGD,e,kaAKI,wDACJ,UACA,0FACA,yG,+RCtMI,YACJ,wGACA,wCAGK,mCACH,aACA,ykBAFmB,W,CAIhB,oCACH,6FACA,2GACA,kGACA,yGACA,oSALoB,W,CAQrB,wFAEI,qCACH,kYAEA,yMAEA,MACA,MACA,MACA,aACA,MACA,MACA,MACA,aAZmB,a,CAepB,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aAEA,kB,CAGD,wH,8nC,4F,4F,4F,2rB,I;qlE,c,oC,CCpHA,IACA,YACA,8BACC,qGACA,mG,mCAEC,+F,c,4F,C,oC,C,kBAOA,I,MAEA,S,C,C,gC,sB,WCdD,oB,CAED,uB,uC,mBCwCC,+H,CAED,6B,+CAgBA,iJ,WAEE,Y,C,KAGF,a,kC,mBAiBC,8H,CAED,wB,gE,0BCAC,kDACC,mG,WAEC,a,C,YAGA,kH,C,KAGF,a,CAID,IACA,YACA,8BACC,qGACA,mG,qBAEC,kH,C,WAGA,I,MAEA,S,C,CAGF,a,gD,kBAMC,kDACC,mG,WAEC,a,C,YAGA,6G,C,KAGF,a,CAID,IACA,YACA,8BACC,qGACA,6G,qBAEC,6G,C,WAGA,I,MAEA,S,C,CAGF,a,gCAKA,Q,kJAEC,2B,CAED,Q,wHAEC,sB,CAED,a,4CAIA,QACG,gB,kJACF,wC,CAED,Q,wHAEC,sB,CAED,a,6BAqEA,gCACA,S,kC,W,kBAOE,Y,CAED,S,CAED,e,uC,W,iBAOE,Y,CAED,S,CAED,e,iD,mBAsEC,S,C,iBAIA,8F,CAID,IACA,aACA,8BACC,qG,sHAEC,S,MAEA,I,C,C,wIAID,oH,CAME,Q,eACF,S,CAED,a,ywC,ojB,wE,2b,sH,0D,wka,6gH,2lC,q0U,mM,6uG,+jM,22G,yJ,83M,4uF,y0C,kT,y8C,ylH,4J,wT,ykB,6J,oL,4jH,upB,gmJ,yU,8mB,2sC,25H,gL,wD,wD,yJ,W,W,W,W,c,W,e,U,W,W,W,U,W,W,W,W,W,U,U,W,W,W,W,W,W,W,U,W,W,W,W,U,U,8D,W,W,W,W,W,ysB,sH,gH,8D,29C,6K,uF,+E,sF,uF,+E,mW,yI,wG,gH,0D,+E,wD,+E,8D,uF,uF,qI,wG,wiI,yG,yI,2L,+N,8D,+H,4K,8D,8D,6xB,+N,6N,8D,4Z,s1B,mW,iZ,yd,6X,wD,gH,4P,4I,uF,+qB,uF,uF,4G,8D,mW,8O,mF,6O,6H,uF,uF,+b,2uB,sG,oJ,gH,oN,0D,8D,uF,8D,yN,+E,uF,gH,oN,4G,2F,gH,8D,gH,uF,uM,gH,kK,0G,uF,6H,gH,wD,yF,wD,wD,gH,uF,8D,8D,uF,8D,8D,mW,uF,uF,kK,8D,8D,0D,uF,gH,mF,+E,+E,mF,uF,8D,uF,sH,iV,uF,gH,+E,0D,6H,+E,sG,+E,oJ,mF,uF,iZ,mH,4U,wD,+E,kM,4G,uF,uF,0D,uF,mF,8D,c,a,8B,e,iB,gB,iB,c,kB,c,gB,kB,iB,e,gB,iB,c,4B,e,2B,e,a,iB,e,e,kB,gB,iB,gB,mB,iB,6B,gB,iB,iB,mB,e,gB,c,iB,iB,Y,e,gB,e,e,iB,yB,kB,8B,+B,iB,e,gB,iB,iB,mB,c,e,kB,Y,c,e,c,iB,iB,a,e,e,iB,kB,gB,mB,gB,sB,qB,sB,yB,6B,a,a,kB,Y,gB,gB,kB,oB,a,Y,c,c,iB,sB,mB,0B,mB,oB,0B,mB,c,c,gB,qB,kB,oB,iB,mB,wB,e,c,kB,mB,gB,gB,gB,oB,gB,qB,gB,kB,qB,e,gB,iB,e,iB,iB,c,c,e,e,e,a,gB,iB,gB,iB,Y,oB,W,yB,64I,owkB,mB,25B,sb,uzD,sD,u6E,yO,w5E,8E,8E,+H,uD,wD,8E;+gTChWA,wB,GACA,mKACA,iJACA,2IACA,+LACA,wLACA,gMACA,wMACA,4MACA,sLACA,wLACA,0MACA,yIACA,gKAEA,OACA,qC,wOAIA,iB,0I,+BAKC,8JAKA,aACA,kBAEA,kB,gDAEC,4B,iBAEC,4B,CAEG,UACA,uDACH,UACA,kB,QAFmC,a,S,CAMnC,6EANmC,a,CAWpC,2BACI,uDACH,UACA,kB,OAFmC,a,S,CAMnC,6EANmC,a,CAWpC,2FAMA,2FACA,a,C,a,cAKA,+G,oBAKA,K,oBAEC,K,C,oBAGA,K,CAED,oF,oBAKA,aACA,uCACA,yDACC,iH,MAED,cACA,uCACA,yDACC,iH,MAED,qC,oBAEC,oB,CAED,0E,oBAQA,cACA,uCACA,yDACC,UACA,sL,MAKD,mE,oBAMA,kG,oBAKA,yE,oBAIA,yE,oBAIA,aACA,uCACA,yDACC,UACA,qB,oBAEC,gB,CAED,2L,MAMD,uE,C,CAQF,yB,8BAIA,eACA,Y,oDAaA,mB,wHAIA,oD,qIAMA,uD,+GAaA,c,oGAIA,e,iH,yE,kH,wE,wGAiBiC,S,sHACA,sE,4GAGjC,yBACA,4GAKA,qB,6DAQA,yH,4FAIA,aACA,gBACA,gB,6DAMA,yH,4FAIA,aACA,gBACA,gB,2BAII,kBACJ,UACA,c,wBAIA,wB,8CAIA,gBACI,uDACH,qCACA,0DAFgC,a,C,sTAOjC,oGACA,ia,OACC,iJ,OAED,8L,4ZAIA,6I,OACC,2D,O,SAGA,uD,C,SAGA,uD,C,UAGA,oD,CAGD,+OAAgH,8M,oM,8J,OAK/G,mD,C,oCAGA,iB,CAED,yB,uM,oCAKC,oC,CAED,kI,0dAYA,6W,OACC,+E,OAGD,6BACA,mKACC,6G,MAED,6BACA,mKACC,6G,MAED,0F,iSAaA,0B,kFAIA,4B,wMA2CA,wH,iI,a,cAMC,yB,oBAEA,qB,MAEA,oD,C,0PAKD,oGACA,U,a,aAGC,+B,mBAEA,+B,iCAEA,0B,mBAEA,0C,mBAEA,gC,mBAEA,gC,+CAEA,2B,oBAEA,gB,CAED,sE,0KAoCA,mB,qCAiBA,M,2BAEC,a,CAED,gDACA,c,8CAIA,sBACA,gC,mBAEC,S,CAED,+C,yTAIA,+BACA,aACA,aACA,qI,OACC,gBACA,aACA,M,OAED,yBACA,QACA,QACA,gC,0OAIA,sBACA,oC,kEAgBA,yDACC,iB,wEAEC,M,CAGD,iB,C,gHAKD,2C,oPAIA,uCACI,Q,sBAEH,W,MAEA,uB,qCAEC,e,CAED,iBACA,wDAGA,W,CAED,qT,yXAIA,uCACI,Q,sBAEH,W,MAEA,uB,qCAEC,e,CAED,iBACA,wDACA,W,CAED,sT,iKAIA,uCACA,aACA,iB,yBAIA,mC,2XAII,0BACJ,oD,OACC,2H,OAGG,QACG,kG,MACP,kN,OACC,yBACA,sBACA,sBACA,0BACA,iC,e,OAEA,uO,QACC,qK,QACC,MACA,c,QAED,gBACA,iNACA,c,QAED,+B,e,OAEA,oBACA,a,e,OAEA,U,uBAEA,yC,Q,OAED,iS,oUA4CI,M,uBAEH,qB,iCAEC,qE,CAED,0H,sDAEC,4D,CAED,uCACA,8C,MAEA,4B,mCAEC,qE,CAED,qH,oDAEC,4D,CAED,sCACA,wD,CAED,0B,cAEC,sB,CAED,kCACA,iB,uM,gBAKC,gD,C,oCAGA,6G,CAED,8D,OACC,sH,O,cAIA,uD,CAED,uC,sIAIA,Y,gBAIA,gB,uQ,4BAKC,+E,CAGD,0DACA,6B,cAEC,4B,CAED,gEACC,gE,aAED,+K,8L,a,iFAMC,Y,MAEA,a,C,0T,aAMD,iI,OACC,mB,OAEA,yH,OAEI,mDACH,yJ,OACC,mB,QAF4B,a,qB,O,OAM/B,kB,otB,mBAKC,iB,0C,CAGD,wB,yBAEC,0D,CAED,qHACA,iCACA,4BACA,MACA,uBACA,iBACA,4CACA,kBACA,mKACC,kB,MAED,qCACA,mKACC,kB,MAED,wHACA,WACA,2DACA,gEACC,gGACA,oG,UAED,+CAEA,Y,+B,6Z,+CAMC,c,C,iCAGA,iB,qDAEC,kB,iB,4BAEC,oC,mCAEA,qC,oB,4BAGC,iBACA,M,CAED,6BACA,sBACA,sBACA,0BACA,M,C,C,CAGF,U,CAED,c,4WAIA,8D,OACC,6G,OAID,qK,OAGC,kDACA,gCACA,sC,O,WAIC,U,CAKD,gH,uBAEC,c,MAEA,a,CAED,mC,O,OAID,qG,upCAOC,UACA,KACA,Q,iCAGA,gEACA,0B,cAEC,sB,C,MAGD,qBACA,4BACA,a,C,WAIA,gE,CAGD,oBACA,oB,O,2BAGE,mE,C,kBAGA,uE,C,kBAGA,wE,C,M,0BAIA,a,C,kBAGA,kE,C,0CAGA,mE,C,CAGF,6J,6BAEE,iE,C,MAGE,wCACA,2JAAH,2I,OACC,4P,OAFiB,a,qBAKnB,4D,OAEC,oBACA,oHACA,iHACI,0CACH,wHACG,wBAAH,+I,QACC,wQ,QAED,iOALkB,a,uBAOnB,MACA,4BACA,kCACA,0G,OAGD,c,+BAEC,gE,CAED,qBAEA,wCACA,wKACC,2e,4BAED,uK,MAGA,yE,QACC,oB,QAEA,sK,QAEA,qBACA,8DACC,iP,4BAED,gB,Q,Q,+uBAKD,0B,M,cAGC,oB,mCAEA,sD,CAED,2C,oF,6BAOC,sB,CAED,U,+B,6BAKC,iB,CAED,U,qSAIO,0B,MACP,wE,OACC,0B,mBAEC,oC,CAED,qBACA,sI,O,0BAIC,oC,CAED,0BACA,qBACA,4CACA,qCACA,qD,OAGA,4C,O,O,iqB,qCAMA,iE,CAED,qB,0CAEC,yD,CAGD,sDACA,yHACA,aAEA,kD,oC,kBAGE,iB,MAEA,iB,C,CAIC,8IAAH,yD,OACI,aAAH,+C,OACC,eACC,+GACA,6C,OACC,oCACA,6FACuC,iE,0EACC,6D,2B,OAGzC,sD,QACC,+G,Q,qB,O,OAMJ,aACA,2G,QACC,0FACuC,oD,oEACC,gD,wB,QAGzC,8J,+UAIA,qCAEC,KACA,iEACC,a,CAED,qB,YAEC,M,CAKD,KACA,8HACC,a,C,0FAGA,M,CAED,yBACA,4BAGA,KACA,oE,2BAEE,a,CAED,a,C,kBAGA,M,CAED,gCACA,4B,cAGC,0BACA,U,C,CAGF,S,ocAIO,0B,MACP,qG,OACC,qB,iCAEC,yD,CAED,cACA,+EAEA,aACA,yG,OACC,gGACuC,8B,gFACC,0B,8B,OAGzC,sI,OAGA,0B,+CAEC,yD,CAED,qBACA,cACA,+DAEA,4CACA,gBACA,2G,QACC,gGACuC,8B,gFACC,0B,8B,QAGzC,wI,OAGA,mB,8BAEC,0D,CAED,4CACA,2BACA,uI,OAGA,6C,O,O,wZAKD,4D,kIAIO,0B,M,6BAEN,8C,oBAEA,yC,oBAEA,sD,oBAEA,sC,oBAEA,0C,oBAEA,kC,MAEA,6C,C,gHAKM,0B,M,6BAEN,gD,oBAEA,oD,oBAEA,2D,oBAEA,uD,MAEA,2C,C,gHAKM,0B,M,uD,0BAGL,S,CAED,8B,oB,0BAGC,S,CAED,S,oB,0BAGC,S,CAED,qC,MAEA,+C,C,mTAKD,mCACA,iCACA,uIACA,8D,O,iBAEC,qG,OACC,8B,c,OAEA,4H,c,OAEA,yB,qBAEA,oC,O,OAED,a,OAED,c,8dAIA,mCACA,2BACA,oJ,OACC,gE,OAED,MACA,mN,OACC,6BACA,sBACA,sBACA,0BACA,M,OAED,gB,2SAIA,mCACA,2BACA,iB,mEAEC,sE,CAED,6BACA,sBACA,sBACA,gBACA,gB,8HAIA,mCACA,2BACA,iB,0CAEC,oE,CAED,6BACA,sBACA,cACA,0BACA,gB,8YAKC,KACA,aACA,QAEM,0B,MACP,qG,O,4BAEE,yE,CAED,qBACA,iBACA,eACA,sC,c,OAGA,UACA,0BACA,8B,c,OAGA,mB,8BAEC,6E,CAED,wI,OAGA,6C,O,O,uBAIA,sE,CAGD,kJ,glBAKC,KACA,aACA,QAEM,0B,M,c,4BAGL,yE,CAED,qBACA,iBACA,eACA,sC,oBAGA,UACA,0BACA,8B,MAGA,8C,C,8BAIA,uE,CAGD,qJ,4TAIA,2BACA,iCACA,+B,6YAMA,0B,OAEC,0B,CAED,yG,oC,kD,CAIA,SACA,e,qD,yaAKA,oC,OAEC,0B,CAED,yG,oCAEC,mB,CAED,kB,wYCv4CA,+F,mCAEC,mD,CAGD,kC,S,aAGC,iEAAwB,yD,e,mBAExB,iE,6BAEE,yD,C,e,CAIH,gBACA,+BACA,oE,yCAEE,yD,CAED,iBACA,iBACA,aACA,oBACA,a,e,yMCwYD,8B,iHAIA,wC,oH,yBAsKC,6G,CAED,+B,sIAiKA,uC,gCAEC,wB,CAED,U,6GAGgC,e,4G,gBAI/B,iD,CAED,a,gBAEC,yE,CAED,+B,0GAG6B,sB,iHAEK,2B,qHAEL,iC,2GAII,U,2HAGjC,iB,gBAEC,c,CAED,4B,uI,mBAKC,iBACA,sB,CAED,oC,6hB,mBAuCC,iB,sE,CAGD,iB,gB,0G,CAKA,mMACC,2E,O,kK,O,0B,0G,sY,2BASA,S,CAED,iB,gBAEC,S,CAED,+C,qH,2BASC,S,CAED,eACA,kBACA,gC,2BAEE,M,CAED,a,CAED,gC,+G,wBAKC,yD,CAED,iBACA,oB,wH,wBAKC,4D,CAED,iBACA,yC,uI,a,cAMC,iBACA,mB,oBAEA,iBACA,mB,oBAEA,iBACA,mB,oBAEA,iBACA,mB,oBAEA,iBACA,mB,CAED,qD,kH,wBAKC,yD,CAED,iBACA,oB,gT,wBAKC,gE,CAED,iBACA,sH,kc,wBAKC,+D,CAED,iBACA,qH,mc,wBAKC,mE,CAED,iBACA,yH,oR,wBAKC,oD,CAED,iBACA,gI,2G,wBAKC,oD,CAED,iBACA,kB,yG,wBAKC,sD,CAED,iBACA,oB,8G,wBAKC,4D,CAED,iBACA,yB,qH,wBAKC,uD,CAED,iBACA,wB,gH,wBAKC,wD,CAED,iBACA,wB,uH,wBAKC,qD,CAED,iBACA,gI,iH,M,aAwCC,e,mBAEA,e,mBAEA,a,CAED,kC,4M,iCAMC,U,CAED,0HACA,uCACA,4B,+BAEC,kC,oBAEC,uC,C,CAGF,qCACA,YACA,U,sHAIyC,0B,4N,gBAKxC,c,CAEG,UACJ,iEACC,0H,oD,uE,C,MAKD,c,wIAmCA,kCACA,U,0LAaA,qCAEC,KACA,iEACC,a,CAED,qB,YAEC,M,CAOD,KACA,qJACC,a,C,oGAGA,M,CAED,yBACA,4BAGA,KACA,oE,2BAEE,a,CAED,a,C,kBAGA,M,CAED,gCACA,4B,YAGC,mC,uCAEC,M,C,wC,C,C,yC,wM,gCAWF,0D,CAED,yHACA,mBACA,iCACA,2B,oCAEC,uC,CAEE,2B,eACF,Y,CAED,sBASA,sBACA,U,ydAQA,qBACA,sKACC,sC,OACC,WACA,qX,OACC,oG,OAED,W,OAED,qH,0BAED,gB,09BAoBA,cACA,mCAQI,SAOJ,0BAEA,0CACC,uCACA,MACA,SAMA,2KACC,UACA,kF,OAIC,mB,OAED,8FACA,mEACC,yHAEA,4BACI,UACJ,gD,OAEC,UACA,kD,QACC,6G,Q,QAKF,iI,Q,uD,mG,CAMC,yBACA,gBACA,yCACA,8BACA,QACA,mB,Q,yCAOA,mB,CAED,iB,mDAEC,2FACA,mB,C,eAGA,0B,CAED,2F,mDAEC,2F,CAEG,UACJ,6BACA,kBACA,iC,0B,0B,OAID,c,C,qBAGF,oB,q6BAOA,S,kBAEC,gEACC,yH,qC,4E,C,kBAKC,Q,C,M,C,QAKF,oB,C,+DAE8C,kB,8I,gUAgB/C,kC,mP,oCAwDC,mE,CAED,0I,OACC,6E,OAED,uC,ob,oCAKC,qE,CAED,sBACA,uH,oc,oCAKC,sE,CAED,sBACA,sI,uT,wBAUC,a,CAED,iB,2BAEC,Y,C,mBAgBA,iBACA,KACI,qDACH,0HACA,uCACA,0HACA,iC,6F,+BAGE,0B,YAEC,+B,CAED,0B,YAEC,+B,C,eAb4B,a,S,C,CAmB3B,a,2BACF,Y,C,CApB6B,a,CAwBhC,a,CAGD,iB,gBAEC,a,CAED,KACA,gBACI,mDACH,0HACA,uCACA,qHACA,iC,8F,+BAGE,0B,YAEC,+B,CAED,0B,YAEC,2C,C,eAb2B,a,S,C,CAmB1B,a,2BACF,Y,C,CApB4B,a,CAwB/B,a,uM,YAWC,kB,C,qEAMA,mB,CAID,iH,ma,OAKC,sC,CAGD,md,OACC,mB,OAGD,4T,6uB,YAKC,kB,CAGD,a,wBAEC,mB,C,wCAMA,kB,C,MAKD,wO,OACC,mM,OAMA,sN,QACC,kB,QAID,2M,OAGA,iBACA,iB,iEAEC,mB,CAEG,wDACH,kK,QACC,mB,QAFyB,a,uBAKvB,yDACH,oK,QACC,mB,QAF0B,a,uBAK5B,kB,OAGA,iBACA,iB,uDAEC,kB,CAID,mB,OAGA,+R,OAGA,+H,OAGA,iBACA,iB,+CAEC,mB,C,iEAGA,mB,CAED,qEACC,yHACA,yH,2DAEC,mB,CAED,gJ,QACC,mB,Q,6DAGA,mB,C,yCAGA,mB,C,4BAGF,kB,O,OAGD,mB,wY,gBA4yCC,iB,CAED,U,yBA6GA,6B,mDC59FA,4B,4H,2BAKC,U,CAED,S,4H,6CAOC,iE,C,iCAGA,sB,CAED,c,gH,gBAiEC,qD,CAED,6E,mH,gCAyCC,2C,C,gJ,WAQA,2B,C,2BAGA,qF,C,8J,WASA,2B,C,2BAIA,qF,C,uBAGA,mE,C,qJ,4BAWA,iE,CAED,uE,yGAMA,0BACA,sB,yQAMA,2BACA,oJ,OACC,6D,OAGD,4B,uXAMA,2BACA,oJ,OACC,6D,OAGD,4B,0NASA,mC,iHASA,gC,0RAYA,2BACA,iCACA,gI,mZAWA,2BACA,iCACA,qI,4PAubA,0B,M,cAGC,gE,oBAEA,sB,CAED,mE,oYA6EA,gD,OACC,oN,OAED,2BACA,sKACC,sC,OACC,4N,O,0BAEE,mF,CAED,+G,O,OAGF,kH,0BAED,gB,qiBAOA,2BACG,4IAAH,oC,OACC,uI,OAED,oC,kgBAQG,gJAAH,oC,OACC,uI,OAED,oC,6SAMA,0B,M,cAGC,wB,oBAEA,sB,CAED,iE,mHAsDA,0BACA,U,M,aAGC,kC,mBAEA,kC,mBAEA,kC,mBAEA,kC,mBAEA,kB,CAED,+D,+G,gBAMC,mD,CAED,6B,sT,+H,+OAwFA,uB,+GAMA,8B,sVA8BA,2BACA,qBASA,kJAEI,K,iCAEH,U,MAEA,qH,CAED,yC,WAEC,oC,CAED,WACA,0CACA,gCACA,0B,wiBAQA,2BACA,qBACA,UAEA,gDAEA,2BACA,K,cAEC,U,CAED,iBACA,qBACI,KACA,gDACH,+F,WAKC,c,CAED,oHACA,OATsB,a,qBAWvB,gC,giB,cAaC,sD,CAED,oI,OACC,gE,OAGD,uBACA,UACA,yQ,ogB,cAMC,wD,CAED,oI,OACC,kE,OAGD,uBACA,WACA,yQ,icAOA,2C,OACC,6C,qBAEA,oI,OACC,iE,OAED,U,OAED,kH,iOAoBA,2BACA,mC,uG,WASC,UACA,aACA,sC,CAED,qC,4D,oBASC,6C,C,yEAGA,0D,C,gDAGA,8D,CAED,qBACA,iBACA,+CACA,oC,sH,oBAMC,gD,C,iCAGA,S,CAED,0B,4U,oBAUC,mD,C,iCAGA,oC,CAED,6I,QAEC,oC,CAED,4C,2RAMA,2BACA,qBACA,yB,uIAMA,0B,M,cAGC,kC,oBAEA,a,CAED,2E,uJAMA,0B,M,cAGC,c,oBAEA,a,CAED,yE,sG,SAKC,O,CAED,8D,0EAMA,0B,M,+DAGC,4BACA,oEACA,kD,CAED,uE,oJAMA,0B,M,8EAGC,4BACA,qEACA,kD,CAED,wE,mWAsDA,2BACA,iC,wJ,mhBAOA,qB,0BAEC,0D,CAED,WACA,sCACI,K,WAEH,UACA,UACA,4B,MAEA,qH,CAED,4I,QAEC,0B,CAED,oB,6cAOA,2BACA,iCACA,6H,meAMA,qB,0BAEC,0D,CAED,iCACA,+IACI,K,iCAEH,U,MAEA,qH,C,0I,4RA0BD,mCACA,0BACA,kB,oSAiBA,mCACA,2BACA,oJ,OACC,gE,OAED,kB,2QAMA,mCACO,0B,M,cAIN,mD,oBAEA,kB,MAJA,sE,C,wIAWD,mCACO,0B,M,cAIN,6B,oBAEA,kB,MAJA,oE,C,kIAWD,mCACO,0B,M,aAIN,4D,mBAEA,iE,mBAEA,iE,mBAEA,4D,mBAEA,kB,MAVA,kE,C,oWA+CD,2BACA,iCACA,iCACA,qBACA,qJACI,K,iCAEH,U,MAEA,qH,C,oBAGA,sCACA,a,CAED,iCACA,sJACI,K,iCAEH,U,MAEA,qH,CAED,2H,oUAMA,mCACO,0B,M,aAIN,+B,mBAEA,oC,mBAEA,oC,oBAEA,+B,oBAEA,kB,oBAEA,+B,MAZA,mE,C,8HAmBD,mCACA,2BACA,kB,mIAMA,mCACA,2BACA,kB,gTA4HO,0B,M,aAEN,8B,oBAEA,4B,CAID,6I,qdASA,2BACA,iC,uJ,waASA,2BACA,iCACA,yI,+PAKA,W,WAEC,2C,C,uBAIA,c,CAKD,yB,uBAGC,qB,2CAEC,qE,CAED,0HACA,8B,CAGD,4B,mCAEC,qE,CAED,qHACA,+B,qHAMA,0BACA,U,M,aAGC,mC,mBAEA,mC,mBAEA,mC,oBAEA,mC,oBAEA,kB,oBAEA,qE,CAED,gE,+G,oBASC,iD,C,4BAGA,uE,CAED,e,qG,oCA6ZC,yC,CAED,sBACA,UACA,MACA,oC,0SAsDA,8D,OACC,oH,OAED,oMACA,4D,OACC,8M,OAED,uH,gpB,aAOA,2U,O,a,0IAGE,gB,mCAEA,gB,oBAEA,gB,C,c,O,a,0IAMA,gB,mCAEA,gB,oBAEA,gB,C,c,O,a,+DAMA,gB,oFAEA,gB,mCAEA,gB,C,c,O,a,6BAMA,gB,C,c,OAID,iN,O,2G,aAGE,gB,mBAEA,gB,C,Q,Q,c,OAKF,kN,Q,2G,aAGE,gB,mBAEA,gB,C,Q,Q,O,OAMH,0I,QACC,gB,QAID,ud,QAGC,gB,Q,c,mBAKC,gB,CAED,gB,CAGD,mC,sgBAwBA,oGACA,U,W,aAGC,yB,mBAEA,c,CAED,sE,+XAMA,oGACA,U,W,aAGC,+C,oBAEA,c,CAED,sE,uWAIA,iHACA,4BACA,sCACA,gB,qVAIA,iHACA,6GACA,sCACA,gB,qVAIA,iHACA,6GACA,sCACA,gB,sUAUA,uL,iTAKA,mJ,oTAKA,yM,iTAKA,qK,wSAKA,gK,wSAKA,iK,wSAKA,oJ,wSAKA,sJ,wSAKA,sK,wSAKA,uK,wVAKA,6Q,4XAKA,sR,4XAKA,6Q,4XAKA,sR,oZAoBA,6LACA,gHACA,yI,OACC,c,qBAEA,6B,OAED,uK,kYAKA,uD,OACC,+FACA,6CACA,gB,OAED,8N,++mB,4F,4F,4F,4F,4F,4F,4F,8G,Q,K,K,uD,yD,mB,6P,qC;oxBCz/EA,gBACA,iCACC,oCAEA,sH,OACC,S,qBAEA,I,O,qBAIF,e,kVAWA,yDAAyC,sH,qG,6TAsBJ,2J,kZCxFrC,8FACA,8FACA,0BACA,8G,iXCKI,0CACC,gLACH,mGADuC,W,qBADlB,W,qB,wXAUvB,IACA,OACC,oB,SAEC,c,CAED,mM,OACC,W,OAED,uI,OACC,a,OAED,0GACA,I,qB,oYAKD,IACA,IACA,SAGI,kIACH,6FAD8B,W,qBAK3B,2CACH,mGACA,6FAFwB,W,qB,oXAYzB,4H,OACC,8F,OAGD,4H,OACC,8FAEA,+H,OACC,gG,Q,O,oVAOE,qCACH,wGADkB,W,qB,ilBAMnB,oCACA,6C,OAEC,gGACA,kHACA,uGACA,qI,OAED,kGASA,IACA,0BAEA,yKAAoC,W,qBAEpC,IACA,QACC,8KAAqC,W,uBAErC,kLAAsC,W,uB,SAGrC,e,CAGD,qGACA,WACA,W,uBAID,aACA,8I,QAEC,IACA,sI,QACC,qGACA,WACA,W,QAED,sI,QACC,WACA,W,QAKD,iI,QACC,qGACA,WACA,W,QAGD,M,QAED,qC,QAKC,QACC,4LAAuC,W,uBAEvC,sLAAoC,W,uB,SAGnC,e,CAGD,qGACA,WACA,W,uB,QAIF,qG,2C,+iBAKA,yCACC,uC,OACC,2FACA,a,OAED,WACA,wGAGA,mD,OACC,+FACA,I,qBAEA,+FACA,I,O,qBAGF,8C,QAGK,4CACH,qI,QACC,qG,QAFqB,W,uBAKvB,6F,Q,iVAQD,yFACA,gG,6IAMI,IACA,kCACH,WADkB,uB,CAGnB,kB,0CA2CuC,iB,kHACA,wM,8HACA,4Y,oQAGb,uF,kVA+BN,gJ,0SAkDpB,uL,yXAIA,KACA,gBACA,kCACC,2FACA,IACA,W,qBAED,2FAEA,iCACC,yBACA,kCACC,mGACA,IACA,sB,qBAEE,SAAH,uC,QACC,gG,QAED,e,qB,shBA2BD,8C,OAIC,IACA,IACA,iCACC,oCACA,4H,OACC,S,qBAEA,I,O,qBAIE,6CACH,qGADoB,W,sBAGrB,a,OAMD,gD,QAIC,IACA,IACA,mCACC,oCACA,iI,QACC,S,uBAEA,I,Q,uBAIE,uCACH,qGADkB,W,uBAGnB,a,QAGD,oCACA,SACI,gB,QAEH,SACA,I,MAEA,IACA,I,CAED,SAEA,mCACC,oCACA,sI,QACC,S,uBAEA,I,Q,uBAIF,SACA,4C,QACC,gG,QAED,4C,QACC,gG,QAED,4C,QACC,gG,Q,sdASD,SACA,SAEA,wCACC,qC,OACC,kGACA,W,qBAEA,8GACA,W,O,qBAIF,kG,+VC5eI,0CACC,gLACH,mGADuC,W,qBADlB,W,qB,0XASvB,IACA,OACC,oB,SAEC,c,CAED,mM,OACC,W,OAED,uI,OACC,a,OAED,0GACA,I,qB,sYAMD,IACA,IACA,SACI,kIACH,wGAD8B,W,qBAG3B,2CACH,mGACA,wGAFwB,W,qB,sXAQzB,4H,OACC,8F,OAED,4H,OACC,8FACA,+H,OACC,gG,Q,O,imBAcF,oCACA,6C,OACC,gGACA,6HACA,kHACA,gJ,OAED,6GACA,IACA,0BACA,yKAAoC,W,qBAEpC,IACA,QACC,8KAAqC,W,uBAErC,kLAAsC,W,uB,SAGrC,e,CAED,qGACA,WACA,W,uBAED,aACA,8I,QACC,IACA,sI,QACC,qGACA,WACA,W,QAED,sI,QACC,WACA,W,QAED,iI,QACC,qGACA,WACA,W,QAED,M,QAED,qC,QACC,QACC,4LAAuC,W,uBAEvC,sLAAoC,W,uB,SAGnC,e,CAED,qGACA,WACA,W,uB,QAGF,qG,2C,ijBAMA,yCACC,uC,OACC,sGACA,a,OAED,WACA,mHACA,mD,OACC,0GACA,I,qBAEA,0GACA,I,O,qBAGF,8C,QACK,4CACH,qI,QACC,qG,QAFqB,W,uBAKvB,wG,Q,40B;6aCpIwC,qB,oSACA,uV,4QAEzC,obACA,4b,oTAuBA,0J,OACC,mB,OAED,wCACA,0BACA,+BACI,yHACH,wLACA,0LAFwB,W,qBAIzB,iBAIA,8FACA,e,imCAQA,8D,8BAEC,e,C,2BAGD,yc,OACC,4D,0DAGC,e,gEAEA,e,MAEA,e,C,e,OAGD,8D,0DAGC,e,gEAEA,e,MAEA,e,C,e,OAGD,oO,QAGC,e,cAEA,e,MAEA,e,C,e,OAGD,oE,OAEA,oEACG,qB,eACF,e,CAED,gC,OAEA,oE,YAGC,e,aAEA,e,MAEA,e,C,e,OAGD,0E,UAGC,e,gBAEA,e,MAEA,e,C,e,OAGE,4D,OACF,gB,CAED,0E,UAGC,e,gBAEA,e,MAEA,e,C,e,QAGG,oEACA,+W,gBACF,gB,CAF+B,a,uBAKjC,e,QAEI,+DACA,+W,gBACF,gB,CAF0B,a,uBAK5B,e,QAEG,4D,OACF,gB,CAED,ywB,gBAEC,gB,CAED,mX,QAGA,+I,Q,O,otB,8B,8BAYC,e,CAED,gB,C,8BAGA,e,CAED,gB,0B,SAOC,S,eAEA,S,cAEA,S,cAEA,S,CAED,S,sBAIA,iB,giB,4F;u4RCxMA,0B,uBAEE,+DACA,S,C,G,e,OAOD,yJ,CAED,O,0BAIA,2B,qBAEC,KACA,O,CAGD,oBACA,YACC,U,WAEC,M,CAED,8EACA,wB,C,sBASD,qB,8CAKA,qJ,UAEE,S,C,KAGF,S,+BClDA,kB,kBAEC,c,CAED,QACA,yBACA,qCACI,oDACH,6BACA,wJAFiC,W,CAIlC,S,0JAwBA,4BACC,W,Q,a,MAKC,Y,CAED,OACA,kB,kBAEC,wB,CAED,qC,CAED,kC,2JAIG,e,gBACF,a,uH,C,gCAIA,IACA,qCACA,WACA,K,kE,C,YAIA,W,CAED,I,qD,iGAKG,gB,gBACF,mB,uH,C,iBAIA,I,C,mD,gDAiCD,yCACA,+K,UAEE,0B,CAED,O,KAED,cACA,wB,kG,+B,+C,C,U,kD,C,kD,kF,I,YC3GC,iH,kBAEA,mGACA,mS,kBAEA,mGACA,yoB,kBAEA,mGACA,g3C,MAGA,8D,C,kF,I,YAOA,iH,kBAEA,mGACA,mS,kBAEA,mGACA,yoB,kBAEA,mGACA,g3C,MAGA,8D,C,iHASD,YACA,IACA,kDACC,sB,6F,sC,CAIA,+BACA,6BACA,uB,OAEC,M,C,gCAGA,S,CAGD,0B,0IAEC,M,CAED,kEACA,mK,WAEE,sBACA,M,C,M,4DAKD,S,CAED,WACA,WACA,kC,C,yD,2CCHyB,U,mEAG1B,0B,sC,a,C,MAKC,W,MAEA,iB,CAED,mB,a,+C,2B,uB,QCnGC,yB,CAED,qB,+BAII,YACJ,KACA,gCACC,mKACA,WACA,2F,CAED,uGACA,+C,4F,yC,2GCuEA,wG,2H,2BCoQC,uB,CAED,eACA,iIACA,4CACA,oCACI,kCACH,wLAD6B,W,CAG9B,8C,mI,2BAKC,uB,CAED,gBACA,iIACA,4CACA,oCACA,wBACI,mCACH,wLAD6B,W,CAG9B,8C,mIAIA,SACA,W,UAEC,uB,C,yCAGA,uB,CAED,eACI,kCACH,0HADkB,W,CAInB,I,QAEC,4B,C,uBAGA,gBAEA,Y,CAGD,8C,+H,sCAeC,uB,CAED,gBACA,0BACA,+BACA,sBACA,wBACA,oBACI,kCACH,wLAD6B,W,CAG9B,8C,yHAYA,gBACA,gBACA,gBACA,sBACA,8C,4O,gB,aAMC,6cACA,0CACA,kBACA,YACA,YACA,kBACA,oB,mBAGA,unBACA,qEACA,wBACA,6BACA,oBACA,sBACA,kBACI,oCACH,kMAD6B,a,CAG9B,qB,kBAGA,ofACA,0C,mBAOC,c,CAQD,KACA,4IACC,a,CAED,8DACA,6BACA,qB,kBAGA,0nBACA,+DACA,2HACA,yEACI,oCACH,kMAD6B,a,CAG9B,qB,mBAGA,2lBACA,2DACA,2HACA,yEACA,sBACI,qCACH,kMAD6B,a,CAG9B,qB,CAED,6B,mEAII,gDACA,MACJ,mF,sCAEC,c,CAED,sB,sCAEC,MACA,I,CAED,c,sFAII,gDACA,MACJ,qF,sCAEC,c,C,UAGA,gD,CAED,sB,sCAEC,MACA,I,CAED,c,uE,gT,wIAiEI,6FACA,gDACJ,kSACA,cACI,sC,gBAEH,0CACA,oB,CAEG,I,gB,kBAGE,KACJ,8B,sCAEC,kB,C,gBAIA,oEACA,Y,C,CAGF,6CACA,2B,CAED,QACA,0BACG,6B,sCACF,kB,CAED,2BACA,iB,2BAGC,yB,CAED,kB,ieASI,IACA,IACJ,mE,OACK,YACJ,mH,sC,oC,C,OAKG,gGACJ,cACA,uBACI,yC,gBAEH,6CACA,uB,CAEG,O,gB,kBAGE,KACJ,8B,sC,sC,C,gBAMC,6GACA,e,C,CAGF,gDACA,8B,CAED,cACA,6BACG,gC,sC,sC,C,iCAIF,I,C,8C,kV,oC,0CAmKD,gB,uBAIA,iB,6BAIA,sB,OAEC,+B,CAED,8C,yC,4B,mECtuBA,yB,yHAIA,gC,wpB,S,gD,CClFA,2H,sC,yC,CAMI,uBAOJ,QAGA,0DACA,iGACA,kDACA,kG,+C,24B,kD,4B,CAUA,sDACA,iGACA,kDACA,sD,2F,4B,CAMG,kI,sC,mB,CAGH,8B,2B,4Z,8BAeC,mF,cAEC,S,C,CAGF,4B,mIAIA,6C,yIAIA,oC,0G,I,YAgBC,iB,mBAEA,U,mBAEA,U,kBAEA,U,CAED,iB,iDAoBA,wB,U,QAGE,mC,C,mCAGA,4E,C,C,eAID,yB,CAED,Y,8D,UAKC,iF,CAED,wB,eAEC,kC,C,eAGA,yB,CAED,Y,6EAuDI,IACJ,IACA,oI,mC,iGAKI,gDACA,MACD,uF,sCACF,c,C,2BAGA,sB,CAED,c,mRAIA,mH,sC,mB,C,+B,uM,oF,4EAYI,W,oF,uE,kD,mF,mR,gF,yN,kF,gJ,kEC0BJ,4B,eAEC,Q,CAED,S,+DAMA,oCACA,W,eAEC,Q,CAED,Y,qDA0DA,6B,eAEC,Q,CAED,S,4DAMA,qC,eAEC,Q,CAED,S,wEAqBA,oDACA,W,eAEC,Q,CAED,Y,yCA0BA,6B,eAEC,Q,CAED,S,qEAMI,I,gBAEH,qB,MAEA,sB,CAED,uDACA,W,eAEC,Q,CAED,Y,wEAgQI,I,gBAEH,qB,MAEA,sB,CAED,qDACA,W,eAEC,Q,CAED,Y,uDAsQI,I,gBAEH,qB,MAEA,sB,CAED,qDACA,W,eAEC,Q,CAED,Y,6CAsCA,yB,eAEC,Q,CAED,S,iDAoGA,6C,eAEC,Q,CAED,S,kEAMA,6mC,eAEC,Q,CAED,S,2DAgBA,0C,eAEC,Q,CAED,S,6EAyFI,I,gBAEH,qB,MAEA,sB,CAED,yEACA,W,eAEC,Q,CAED,Y,yEAMI,I,gBAEH,qB,MAEA,sB,CAED,yEACA,W,eAEC,Q,CAED,Y,sFAMA,wDACA,6C,eAEC,Q,CAED,Y,0DAkGA,qC,eAEC,Q,CAED,S,gFAyDA,iUACA,W,eAEC,Q,CAED,Y,mEAMA,gVACA,W,eAEC,Q,CAED,Y,+DA0BI,SACJ,qB,sCAEC,S,CAED,ioC,eAEC,Q,CAED,S,yDA2BA,yD,eAEC,Q,CAED,S,yDAMA,uD,eAEC,Q,CAED,S,yEA+CI,I,gBAEH,qB,MAEA,sB,CAED,iWACA,W,eAEC,Q,CAED,Y,2DAMI,I,gBAEH,qB,MAEA,sB,CAED,uE,eAEC,Q,CAED,S,+DAMA,weACA,W,eAEC,Q,CAED,Y,+DAMA,weACA,W,eAEC,Q,CAED,Y,qEAMA,0EACA,M,eAEC,Q,CAED,Y,0/Q,4F,4F,4F,6L,Q,Q,K,O,a,c,c,c,c,a,ozG,6C;6gDCvnDA,8F,4B,iH,gBAOC,O,CAED,qG,qKAOG,8F,M,+B,C,gBAIF,O,CAED,qG,gC,8H,gBAOC,O,CAED,sC,sUAcA,uE,kB,kB,aACC,wH,OACC,c,O,yB,8Q,aCrDD,uD,CAED,c,uG,cAMC,wD,CAED,e,2GAgDA,2B,gBAEC,wD,C,qGAMD,U,qG,uBAMC,wD,C,ga,cCvDA,a,C,eAGA,kD,CAED,gBACA,+CACC,iBACA,e,aAED,sF,4fCQA,qD,OACC,kE,OACC,oG,OAED,uB,OAED,sIACA,oDACA,e,+N,mCAMC,O,CAED,2B;u/EC/CI,6C,2BAcJ,sBACA,0BACA,UACA,U,uBAEC,cACA,O,CAED,iCACA,6F,eAIA,wF,2EAIA,M,gK,0BA6CA,+D,wB,iBC8CC,a,CAED,kBACA,qB,sTAMI,yCACI,yB,I,a,yD,6D,6E,C,+B,6E,C,C,mB,uB,qC,4D,6E,C,+B,+E,C,C,qC,kF,C,C,mB,+E,yM,C,mB,sD,mF,C,mF,mB,0D,mF,C,mF,mB,sD,iE,0F,C,mF,C,mB,mF,mB,mF,mB,mF,mB,sD,mF,C,oB,uD,mF,C,mB,6D,kF,C,+D,kF,C,2D,kF,C,4D,kF,C,yD,kF,C,mB,6D,kF,C,+D,kF,C,2D,kF,C,4D,kF,C,yD,kF,C,mB,sFA2GL,0BACA,UACA,+DACC,a,C,cAIA,M,gCAEC,M,CAED,sC,4E,C,C,CAvHyB,W,C,6C,gCAqLzB,yCACH,kBACA,kB,eAGC,eACA,e,4BAEC,a,C,CARsB,W,CAYzB,Y,kCAIA,qJ,sDAEE,2C,C,KAGF,gB,0CAOA,Y,QAEC,gBACA,a,CAIG,YACJ,KACA,gCACC,WACA,yFACA,wHACA,I,CAED,WACA,uGAGI,wCACH,gBADiC,W,CAIlC,8C,2DAQA,Q,gEAEC,uBACA,kB,CAED,6BACA,6C,iD,6B,C,MAKC,K,C,oC,+CAQD,IACI,YACA,kCACH,WACA,mKACA,2F,C,QAIA,I,C,MAGA,gIACC,W,C,UAGA,S,C,CAGF,gBACA,gD,mVAcA,gJ,+FAIC,0CACA,K,mDAEC,KACA,gC,CAED,+FACA,+FACI,SACJ,wBACA,eACA,I,iCAEC,uBACA,I,CAED,uBACA,gBACA,uBACA,0B,CAED,e,8fAqBI,SACJ,iB,SAEK,YACJ,2B,MAEA,qB,CAED,gHACA,gC,myBAOC,4HAEA,KACA,IACA,IACA,KACA,IACA,IAGD,oCACC,4B,cAEC,oB,C,UAGA,M,CAED,I,0BAIC,sC,C,0BAKA,iC,CAGD,kB,W,eAEC,K,SAEC,O,CAED,6E,qBAEA,W,qBAEA,qD,qBAEA,sBACA,qB,qBAEA,kB,qBAEA,kB,qBAEA,yD,qBAEA,0BACA,qB,qBAEA,W,qB,SAGC,gB,CAED,W,qBAEA,W,qBAEA,W,qBAGA,qE,WAEC,M,CAED,Y,qBAGA,qE,WAEC,M,CAED,Y,qBAEA,W,qBAEA,W,qBAEA,W,qBAEA,W,qB,UAGC,uB,MAEA,uB,C,qB,UAIA,uB,MAEA,uB,C,2I,gEAMA,gBACA,M,CAED,+FACA,K,SAEC,gBACA,OACA,O,MAEA,gB,CAED,sG,2CAEC,gB,C,6BAGA,4E,C,2C,uBAMC,gB,CAED,4E,C,oB,cAKA,oBACA,M,CAID,+F,SAEC,gBACA,O,MAEA,gB,CAED,sGACA,4E,mCAEA,kE,C,C,CAGF,e,ggBAeA,kB,iD,mBAMC,gH,CAMD,4C,sF,gBAOC,a,CAED,kBACA,oB,2B,aAQC,e,C,a,MAIC,e,CAED,uE,CAED,2H,uBAIA,6DACC,kB,CAED,S,2BAMA,qC,yB,0CAGG,a,CAED,QACA,QACA,S,C,2DAGA,a,CAED,kBACA,kB,CAED,oB,4LA0CA,wH,wqDAaA,gBACA,KACA,QACA,QAIC,IACA,IACA,IACA,IACA,IACA,IACA,IACA,UACA,MACA,MAID,YACK,aACJ,mCACA,mDACA,6B,uCAEC,0F,C,W,sBAIC,0G,CAED,M,CAED,KACI,MACJ,kB,Y,e,eAGE,MACA,M,CAED,mDACA,2B,UAEC,c,MAEA,c,C,qB,yBAIA,MACA,M,CAED,mDACA,2B,qBAEA,mCACA,W,qBAEA,mCACA,W,qCAEA,2C,eAEC,U,C,qBAID,2B,qBAEA,2B,mD,mDAGC,kB,CAED,2C,QAGC,Q,C,qBAGD,wC,eAEC,S,C,qCAGD,2C,cAEC,S,C,qCAGD,2C,eAEC,W,C,qCAGD,2C,eAEC,WACA,M,C,iDAKA,iBACA,c,yBAGC,M,CAGD,KACA,gDAA2C,a,CAE3C,qCACA,mB,C,qB,eAIA,MACA,M,CAED,mD,M,gBAGC,O,sBAEA,O,MAEA,M,C,qB,eAIA,MACA,M,CAED,mD,M,gBAGC,O,sBAEA,O,MAEA,M,C,2I,2EAIA,kBACA,YACA,M,CAEG,gD,yB,eAGF,MACA,M,C,8BAGA,MACA,M,CAED,uH,+B,eAGC,MACA,M,CAED,0G,+B,eAGC,MACA,M,C,yDAGA,MACA,M,CAED,oI,+B,eAGC,MACA,M,CAED,oI,M,eAGC,MACA,M,CAED,uH,CAEG,iCACJ,4B,oCAEC,4B,C,oCAGA,4B,CAED,8C,oB,c,oBAIC,O,MAEA,M,C,oB,2CAKA,YACA,kBACA,M,CAED,2B,QAEC,MACA,M,CAED,qD,oBAKA,sB,gBAEC,MACA,M,CAED,qCACA,mB,oB,kFAKC,M,CAID,KACA,6GACC,a,CAED,0CACA,0B,C,C,cAGA,8G,C,uCAGA,0F,C,C,YAID,Y,sBAEA,I,C,0BAKA,4G,CAGD,gD,OACC,yI,OAGD,8C,OACC,qIACA,kEAIA,iI,kCAEC,aACA,2B,CAID,qBACA,2B,OAGD,4C,OACC,uIAGA,0I,OAEC,kEACA,aACA,2B,C,4CAKA,iCACA,oB,CAED,qBACA,2B,OAID,0I,wtC,e,gC,C,0E,+B,C,8BAuBC,Q,+B,C,mDAKA,QACA,M,4B,CAIG,IACA,kC,gBAEF,M,CAEE,kB,eACF,M,CAL0B,W,C,I,+C,gC,kB,yB,iC,C,kB,uD,mC,C,kB,mC,C,oC,uBA8B5B,kB,iBAEC,S,CAGD,kB,iCAOA,kB,6BAEC,S,CAED,2C,2DAIC,S,C,WAGA,+B,C,2FAGA,S,CAED,4B,4D,8BAKC,KACA,c,CAEE,sC,sCACF,c,C,uBAGA,sBACA,c,CAKD,UACI,kCACH,gBAD4B,W,CAG7B,c,4FAOA,IACA,qCACC,kB,eAEC,M,C,kE,sD,CAMD,mI,yC,sD,CATiB,W,C,4D,kDC5hClB,4E,8G,+FAMC,iI,CAED,a,0GAIgC,4D,wI,+FAK/B,gFACA,4C,0FAEC,0NACA,O,CAID,c,CAID,8D,kH,WAMC,S,CAED,cACA,Q,0H,+FAMC,cACA,+F,C,qI,6JAkCA,8E,CAED,UACA,UACA,qH,oI,6JAMC,8E,CAED,iK,iI,6JAUC,6D,CAED,wF,oH,gBAuCC,kG,CAED,oBACA,2BACA,sD,sI,eA6BC,uF,CAED,oBACA,2BACA,wD,mIA2GA,4D,8VAMA,QAEA,oD,OACC,yF,OAED,cACA,2C,OACC,wM,OACC,mF,qBAEA,oGACA,kE,O,OAGF,8F,4iBAMA,QACA,oD,OACC,yF,OAGD,cACA,2C,OACC,wM,OACC,mBACA,qB,qBAEA,6G,OAED,kE,qBAEA,Q,OAED,oFACA,oB,2eAKA,8HACA,oB,sZAKA,iHACA,e,yYAKA,gHACA,e,0YAKA,gHACA,e,+XAKA,kM,yMAMA,2EACA,kH,mVAQA,qIACA,iLAgBA,uGAMA,iF,eAEC,W,C,UAMA,WACA,K,8BAKC,W,C,C,yBAQE,gF,eACF,WACA,I,C,CAIF,kB,6gB,gO,iPAUA,kDACA,0FACA,yBACA,wFACA,uBACA,c,mNAKA,kP,0XAKA,+O,uXAKA,yJ,0NAMA,sB,kSAMA,iHACA,oB,iPAuCI,YACJ,KAEA,gCACA,uC,MAEC,gC,C,kDAMI,IACJ,WACA,mFACA,W,8BAGC,W,kDAGA,IACA,mF,qDAGA,IAEA,WACA,+C,MAGA,IACA,mF,CAED,iDACA,iC,MAEA,WACA,mFAEA,iDAGA,gEACA,sC,yCAIC,WACA,mFACA,gEACA,sC,yCAKC,WACA,mFACA,iC,C,C,C,MAMF,WACA,kF,CAGD,+C,6IASA,YACA,QACI,kCACH,mCACA,kC,MAEC,WACA,mI,CAED,sCAPqB,W,C,MAUrB,WACA,oG,C,4B,6BAQD,Y,8BAEC,WACA,oG,MAEA,+DACC,WACA,kKACA,sC,C,CAGF,S,mDAIuC,mC,oIAavC,uCACA,sCACA,4C,4HAKA,wCACA,uCACA,4C,0HAKA,wCACA,uCACA,8C,0H,0CAOC,S,CAED,iE,gHAMA,6M,0D,0CAWC,S,CAED,mB,yCAEC,2B,YAEC,6C,CAEE,kF,0DACF,S,CAED,6B,C,YAGA,6C,CAEE,kF,0DACF,S,CAED,qC,yJAKA,wEACA,+F,kBAEC,gEACA,oB,cAEA,gEACA,oB,CAED,6IACA,Y,+FAEC,qF,iNAGC,c,MAEA,Q,C,CAGF,S,qI,6JASC,QACA,QACA,yE,gGAEC,qC,C,gGAGA,6B,CAED,S,CAED,2M,uDAIC,S,4CAEA,6B,MAEA,qC,C,sFAOG,sD,+FAGH,4G,MAEA,gB,CAED,sC,qVAyBA,0HACA,2HACA,0K,siB,2O,8SAsBA,uCAGA,wCACA,+BACA,iFAMA,uCACA,wEACA,8EACA,gFAKA,sCACA,4EACA,+EAMA,qCACA,wEACA,mDACA,8EAEA,gIACA,gB,OAGC,gB,CAGD,I,U,SAME,W,mBAGA,IACA,KACA,gB,C,CAMF,qGACA,0GACI,K,UAEH,WACA,M,MAEA,2F,CAGD,WACA,iBACA,gB,6B,mBAwBC,U,CAED,+L,wCAoBA,2BACA,mDACA,yE,yFAEC,0F,CAED,4M,uCAIA,0F,+CAKA,aACA,S,sGAKA,qBACA,S,0G,eAUC,iE,CAED,YACA,S,2GAKA,Q,eAEC,W,CAED,S,6SAMA,yHACA,kB,mOAOA,mB,+GAUA,8H,0VAOI,IAEJ,oE,OACC,K,qBAEA,4G,2EAEC,oF,CAED,0F,gCAEC,yE,CAED,gB,OAGD,UACA,WACA,icAkBA,0B,mpBAKA,I,kBAEC,oD,C,uGAIA,gE,C,wBAIA,2D,CAGD,iBACA,k0CAGA,iBACA,qaAEA,iBACA,+OAEA,+DACA,2BACA,QAEA,0C,OACC,a,qBACS,gI,YACT,qB,MAEA,oB,C,OAGD,uB,6iBASA,yH,sYAKA,iH,kaAMG,qG,kBAGF,+E,CAGD,sBACA,gBACA,oJACA,gBACA,0B,ub,iCAQC,uB,CAGG,YACJ,gKACA,e,4bAMG,qG,kBACF,+E,CAGD,sBACA,0K,ubAOI,YACJ,4JACA,e,qP,yFAUC,2CACA,kDACA,mF,yCAEC,yEACA,gE,C,CAGF,wD,0CAIA,0N,uD,QAQC,sGACA,WACA,sB,C,SAGA,uFACA,WACA,sB,C,4B,+pB,eAuBA,8D,CAID,gBACA,2BACA,gBAGA,mCACA,2BACA,2BACA,2BAEA,qGAKA,qCACA,iFACA,mCAGA,qCACA,iFACA,sFAGA,mCACA,+EACA,qFAGA,IACA,oFAGA,wK,gBAEC,wE,CAID,iFAGA,mCACA,kHAEA,2FAMA,gIACA,6C,OACQ,yEACP,6K,OACC,4I,c,OAEA,8G,O,OAED,yE,OAGD,8BACA,aACA,gB,wgBAWA,c,0CAEC,S,CAED,4BACA,kD,yHAYA,c,0CAEC,S,CAED,4B,YAEC,kD,CAED,+D,uMAOA,QACA,WACA,U,yCAGC,OACA,+BACA,K,QAEC,oBACA,gE,C,C,2JAOD,yIACA,oH,4EAIA,wEACA,mEACA,uI,MAQA,iCACA,gEACA,4BACA,uBACA,wFACA,oE,gEAEC,wE,CAED,4F,gEAEC,wE,CAKD,iCACA,uFACC,wB,CAED,oBACA,YACC,I,wKAGC,IACA,oE,gEAEC,wE,CAED,0D,C,6GAGA,M,CAED,6BACA,wHACA,6B,CAED,6B,C,oCAUA,aACA,wC,CAED,Y,gM,eC18CC,gB,CAED,wC,OACC,2F,OAED,e,gWAMA,yG,mMAMA,iLAOA,iHACA,S,gfAWA,yF,uBAGC,QACA,IACA,4BACA,oCACA,sB,CAGE,c,iKACF,SACA,WACA,eACA,aACA,sB,C,0LAIA,oIACA,SACA,WACA,4B,mBAEC,0G,MAEA,oC,CAED,sB,CAKD,OACA,oCACA,IACA,aACA,sCACC,6GACA,4G,6DAEC,KACA,M,MAEA,K,C,CAGF,gOACA,UACA,YACA,wGAEA,sB,oa,uBAqBC,S,C,iPAKI,sJ,uHAEF,S,CAFyC,W,C,CAQ5C,uD,uHAEE,S,C,KAKF,S,4IAMA,+J,gBAEE,Y,C,KAGF,a,4gBAOA,yFAQA,0DACC,8GACA,4C,OACC,gL,e,qC,C,O,yBAQF,6DACC,sH,gB,iD,C,MAOD,kB,uhO,4F,4F,4F,4F,kM,gD,qD,mF,sD,oF,0H,iC,gC,6B,+I,wG,+E,0C,0E,Y,c,wC,4C,+H;qgEC3OwC,iB,wG,wGAIX,e,iH,cAI5B,Y,CAED,iB,2HAGoD,wB,gIAEC,wB,8H,cAIpD,Y,CAED,uB,kHAGiD,qB,uHAEC,qB,wGAIhB,Y,8GAES,iB,0HAEI,iB,mIAEC,iB,2RAUhD,8C,OACC,qBACA,4IACA,2F,O,yB,gU,yBASD,+C,kBAEC,a,CAGD,4FACA,iBACA,sF,kBAEC,uB,C,gG,2I,MCnDA,2B,CAED,0B,gDAUyC,oB,0GACA,Y,gHACA,Y,oGAIzC,6CACC,iI,0DAEC,uOACA,O,CAED,kDACA,gC,C,mWC3CE,a,sCACF,e,CAED,4CACA,8B,wUAIA,4D,eAEC,kC,CAED,2B,yDC6BA,YACC,qI,2EAEC,a,CAED,kC,8EAEC,+F,C,qJAGA,Y,C,C,8VAQF,OACC,qI,2EAEC,mB,CAGD,4E,8EAEC,+F,CAGD,4FACA,kL,OAGC,gHACC,wEACA,0M,qBAED,6GACC,qEACA,4M,qBAED,kB,O,qB,qUAQF,YACC,qI,8EAEC,iD,CAED,kC,qJAEC,gF,C,C,6YAQE,qEACA,S,MAEH,mBACA,yBACA,+BACA,uH,MAEA,mBACA,sBACA,4BACA,uH,CAED,OACC,qI,2EAEC,mB,CAEG,mB,mFAGH,uF,8EAEC,+F,C,MAID,6C,mFAEC,+F,C,CAGF,kL,O,mFAEE,kB,CAED,uF,O,qB,8nBASE,qEACA,S,MAEH,mBACA,yBACA,+BACA,uH,MAEA,mBACA,sBACA,4BACA,uH,CAED,OACC,qI,8JAEC,iD,CAGD,yF,sFAEC,mD,CAED,kL,OACC,mH,OACC,uF,OAED,sF,O,qB,8V,qBAaD,mB,CAED,iB,qQAOA,iD,OACC,wG,OAED,uB,+WAMA,qI,OACC,yB,OAED,uB,gYAOA,sI,OACC,2F,O,gZAOD,sI,OACC,yB,OAED,uB,oYAOA,uI,OACC,2F,O,+P,6DCxOA,a,CAED,S,kbAKG,a,sCACF,e,CAED,4CACA,iC,yqBAKG,a,sCACF,e,CAED,4CACA,mC,4qBAKG,a,sCACF,e,CAED,4CACA,oC,iX,eCUC,c,C,OAGA,eACA,iB,CAED,e,sCAIC,e,CAED,S,iRAQA,aACA,yGACA,WACA,0MACA,e,wYAMA,yI,OACC,yB,OAQD,aAIA,4FAQA,kD,OACC,0M,OAGD,e,6hBAKG,a,sCACF,e,CAED,4CACA,mC,+pBAKG,a,sCACF,e,CAED,4CAIA,0JACA,0C,+sBAYG,8F,sCACF,kB,CAED,gD,kBAOC,0B,CAEE,6B,sCACF,kB,C,qCAGA,4B,CAED,YACC,kC,sCAEC,I,0DAEI,0B,mCACF,S,C,C,+CAOD,S,C,CAGF,kBACA,kB,C,6mBASE,a,sCACF,kB,C,qCAGA,4B,CAED,qC,sCAEC,I,CAED,0FACA,kBACA,kB,qnBAKG,8F,sCACF,4B,CAED,gDACG,6B,sCACF,4B,CAED,YACC,+C,sCAEC,I,0DAEI,0B,mCACF,S,C,C,CAIH,kBACA,oB,C,m1BAME,8F,sCACF,gC,CAED,gDACG,6B,sCACF,gC,CAED,YACC,8D,sC,0DAIK,0B,mCACF,S,C,C,CAIH,kBACA,wB,C,21BAME,+F,sCACF,kB,CAED,iDACG,8B,sCACF,kB,CAEG,IACJ,YACC,Y,oCAEC,kB,CAED,kD,QAEC,W,C,kBAGA,kB,C,0DAGG,2B,mCACF,S,C,C,sCAID,kB,C,UAGA,mC,C,C,0yBAUC,a,sCACF,kB,CAED,4CACI,IACJ,YACC,Y,oCAEC,kB,CAED,mH,QAEC,W,C,kBAGA,kB,C,sCAGA,kB,C,UAGA,mC,C,C,gyBAOC,+F,sCACF,kB,CAED,iDACG,8B,sCACF,kB,CAED,OACC,yG,0DAEI,2B,mCACF,c,C,C,sCAID,kB,CAED,kC,qB,mzBAME,+F,sCACF,oB,CAED,iDACG,8B,sCACF,oB,CAED,OACC,2H,0DAEI,2B,mCACF,c,C,C,sCAID,oB,CAED,4B,qB,40BAME,8F,sCACF,gC,CAED,gDAEG,6B,sCACF,gC,CAED,OACC,wH,mCAEC,uB,C,I,2C,oBAKI,0B,mCACF,c,C,C,kDAOF,c,CAED,+B,qB,oxBAME,a,sCACF,gC,CAED,4CACA,iC,mtBAOG,a,sCACF,kB,CAED,4CACA,YACC,wC,sCAEC,I,0DAEI,0B,mCACF,S,C,C,CAKH,kB,C,ktBAME,a,sCACF,e,CAED,4CACA,+B,opBAKG,a,sCACF,e,CAED,4CACA,gC,igB,kFAUC,4B,mCAEC,6B,C,yB,2BAOA,6E,MAEA,2B,C,CAGF,iG,geAMA,qGACA,sDACA,yB,sCAEC,yB,CAED,iBACA,6B,slBAKG,a,sCACF,sB,CAED,4CACA,uG,+VAOA,gC,0bAKG,+F,sCACF,kB,CAED,iDACA,gC,qrBAMG,a,sCACF,e,CAED,4CACA,qGACA,uB,+sBAKG,8F,sCACF,e,CAED,gDACG,6B,sCACF,e,CAED,OACC,mI,OACC,uB,OAEE,0B,sCACF,e,C,qB,0vBAOC,+F,sCACF,e,CAED,iDACG,8B,sCACF,e,CAED,OACC,mI,OACC,uB,OAEE,2B,sCACF,e,C,qB,yYC3hBF,+E,eAEC,2B,CAED,oB,wPCFA,iI,I,mCAOC,+B,iD,iD,iD,iD,MAEA,+B,CAYD,yH,mCAEC,iB,C,sCAGA,sC,CAEE,wBAAH,mE,OACC,iGACA,2C,OAED,+B,shBCpCG,a,sCACF,e,CAED,4CACA,4C,4uBAKG,a,sCACF,e,CAED,4CACA,6D,2vBAKG,a,sCACF,e,CAED,4CACA,+C,mvBCxBG,a,sCACF,e,CAED,4CACA,gD,mvBCFG,a,sCACF,e,CAED,4CACA,6C,4uBCJG,a,sCACF,e,CAED,4CACA,+C,ovBAKG,a,sCACF,e,CAED,4CACA,iD,41BCVG,+F,sCACF,gC,CAED,iDACG,8B,sCACF,gC,CAGG,Y,yBAEH,qB,CAKD,OAEI,kBACA,YACJ,gDACC,yBACA,2J,kBAEE,kB,CAED,wF,qCAEC,mJACA,c,CAED,kJ,qBAEC,c,C,yB,qBAID,c,CAED,4GAEI,IACJ,gC,mBAEC,I,CAED,mHACA,2FACA,gD,sC,gCAGK,2B,mCACF,c,C,CAGF,c,C,8BAGA,qBACA,c,C,qBAGF,kB,iqO,4F,4F,4F,4F,4F,4F,K,6D,gD,gE,4B,0C,G,I,2B,uB;yK,wC,oM,4F;sOClCA,W,mCAEC,iB,CAED,+B,8LAmBG,MAAH,mE,OACC,4F,O,0jB;+gHCvDD,iB,yBAIG,kB,qBACF,SACA,oDACI,2DACH,2JADgC,W,C,C,0BAKjC,wB,C,e,uN,eCAA,qC,CAED,yG,8c,e,qD,C,mI,kR,kc,4BCMC,qCAEA,uC,CAED,iBAEA,I,SAEC,MACA,K,CAGD,qBACA,wCAEC,gD,OACC,SACI,YACJ,iIACA,e,sC,mD,C,cAKC,c,C,OAKE,gBACJ,yEACA,qBACA,W,qB,0B,sC,C,0C,igBC/BmC,+H,kZAIpC,2CACA,qJ,8YASuC,yH,kZAIvC,2CACA,qJ,8N,mCAQC,iB,CAED,uB,+CAcA,a,kDAmBA,I,8B,SAEC,a,oC,SAEA,a,oC,SAEA,a,CAED,S,+BCzFG,qC,MACF,U,CAED,S,uBCAA,QACA,kF,gDCgC8B,mB,kQAgD9B,wI,sdAOG,uB,sC,kC,CAGH,yG,oD,0jBASG,uB,sC,kC,C,yC,0F,CAQH,yCACC,4G,sCAEC,sBACA,c,CAED,WACA,iBACA,kE,qBAED,kB,2jBAOG,wB,sC,kC,CAGH,0G,QAEC,I,C,uBAGA,kB,CAGD,Q,sCAGC,uB,C,kC,8jBAUE,wB,sC,kC,C,yC,2F,CAQH,yCACC,6G,sCAEC,uBACA,c,CAED,WACA,iBACA,kE,qBAED,kB,inBASG,uB,sC,gD,CAGH,2G,6FAEC,kB,C,sC,kE,C,0C,4gB,sJ,2Q,+DAkHA,S,C,0CAGA,iB,CAED,mC,wRAkH2C,uG,oOAyB3C,uC,qIAQA,2C,8IAUA,4C,4IAMG,8B,sCACF,oB,CAED,0B,oLC7bA,qC,+BAEC,iB,C,+BAGA,iB,C,+BAGA,gB,CAGD,S,uOAaG,wB,sCACF,e,CAEE,0G,sCACF,kC,CAED,uB,0aAoCG,wB,sCACF,e,CAEE,wG,sCACF,kC,CAED,uB,6aAOG,2B,sCACF,e,CAEE,yG,sCACF,qC,CAED,uB,6ZAOG,uB,sCACF,e,CAEE,oG,sCACF,iC,CAED,uB,yYAuBG,wB,sCACF,e,CAEE,qG,sCACF,kC,CAED,uB,2OAKG,8B,sCACF,S,CAED,gD,uIAKG,kC,sCACF,S,CAED,oD,gJAKG,mC,sCACF,S,CAED,qD,0I,eAOC,uB,CAED,iB,6Q,eCxIC,wB,CAQD,iD,OACC,wG,OAGD,qC,2LASA,IACG,uC,sCACF,I,CAED,iB,iEAiBA,W,QAEC,c,CAED,uKAUA,4B,UAMK,sT,U,oBAQH,Q,6DASG,e,mEACF,Q,C,yBAQE,e,oGACF,Q,C,C,CAKA,4B,sC,YAUC,wB,mCACF,qB,C,CAIF,uDACA,S,2B,6DAQC,K,C,2M,eAuDA,6B,CAED,2G,8X,eAKC,6B,C,0BAGA,kB,CAEG,YACD,+F,sC,0CAED,iB,CAED,+B,CAID,4BACA,e,gcAMA,kHACA,e,kC,ueAQA,qHACA,e,kC,0eAOA,mHACA,e,kC,2eAOA,sHACA,e,kC,qgBASA,oHACA,e,kC,ilBA8EA,c,WAEC,M,CAED,iHACA,6BACA,oJACC,2G,UAIC,kB,C,sC,kC,CAKD,e,yB,yDAKA,Q,C,kC,yTCzXD,gBAEA,sDACC,oBAD8B,W,CAI3B,W,+B,yBAEF,yBACA,M,CAHe,W,CAOjB,S,gB,UCdC,O,CAED,c,uB,UAyCC,I,CAED,U,sPC9CG,2C,sCACF,e,CAED,+GACA,oBACA,e,oaAIG,wC,sCACF,e,CAED,4GACA,oBACA,e,4ZAIG,yC,sCACF,e,CAED,6GACA,oBACA,e,+MAIA,gC,wKCzBA,4FACA,mB,wHCTA,aACA,kBACA,yDACA,sC,yB,gBAGC,+B,qBAEA,+B,sBAEA,iC,qBAEA,+B,sBAEA,gC,sB,sBAIA,+B,C,qCAGA,8B,C,qCAGA,8B,C,oCAGA,8B,C,uBAKD,gC,kO,eC5BC,wC,CAEG,kZACJ,4G,sCAEC,yD,CAED,qBACA,6B,uMAgBI,+YACJ,mB,sCAEC,0C,CAED,QACA,oB,+ECoBI,YACJ,IACA,yF,mEAEE,8FACA,W,C,S,UAID,kFACA,W,CAGD,qF,kEAEE,8F,MAEA,kF,CAED,W,SAED,iD,iIAMA,oC,mIAMA,+B,sIAKA,kB,2HAGmC,c,wGACA,gC,yGCrFM,c,uGACA,c,0GACA,iB,4GACA,a,4tN,4F,4F,4F,4F,4F,4F,4F,4F,4F,8F,+G,0C,8C,2C,8C,4C,yC,4C,+C,+C,M,I;wkHC4BzC,oF,oHAIA,QACA,e,kI,SAMC,O,CAED,eACA,YACA,S,kBAGC,8CACA,2B,CAGD,K,oBAEC,K,CAGD,mBACA,kDACC,mG,KAED,6B,2H,wCAMC,eACA,O,CAED,0B,sBAGC,kBACA,e,MAGA,eACA,kB,C,+G,wCAOA,qBACA,O,CAED,kC,sBAGC,kBACA,qB,MAGA,qBACA,kB,C,0H,MAOA,oB,MAEA,qB,C,sIAMD,gCAKA,I,qCAEC,SAEA,8B,gBAEC,mB,C,CAKF,Y,4FAIC,WACA,oGACA,kCACA,2CACA,WACA,oGACA,WACA,oG,CAGD,iEACC,WACA,oLACA,WACA,2B,CAED,WACA,+IACA,WAEA,8BACC,WACA,oGACA,W,CAGD,WACA,oGACA,WACA,oGAEA,kBACA,sBACA,sBACA,kB,sKAKA,2E,MAEC,gC,CAGD,gC,kDAKC,yB,gBAGC,mB,C,CAOF,I,2BAEC,S,uCAGC,kBACA,sBACA,sBACA,kBACA,O,C,iDAGD,Q,yCAEC,W,C,CAOF,Y,I,aAKC,iEACC,WACA,oCACA,iOACA,I,C,mBAGD,iEACC,WACA,kKACA,2B,C,kBAGD,gEACC,WACA,8LACA,2B,C,kBAGD,gEACC,WACA,8LACA,2B,C,MAGD,uD,CAED,WACA,6HACA,kDACC,WACA,oG,C,qB,I,Y,+GAQE,WACA,oG,C,mBAID,WACA,kHACA,WACA,oG,C,C,MAKD,WACA,oG,0BAEA,WACA,oG,2BAEA,WACA,oG,CAKD,kBACA,sBACA,sBACA,kB,sJ,2BAMC,SACA,oEACC,W,QAEC,yB,C,S,CAIH,S,0I,2BAMC,SACI,0CACH,W,QAEC,wB,CAED,I,0GAEC,sC,CAED,W,C,CAGF,S,kHAKA,sBACA,e,2GAKA,gBACA,S,gIAKA,Y,eAGC,W,C,qCAIA,S,CAGD,a,Q,qB,qBAKG,e,CAGD,kB,2BAGA,W,C,M,0BAIA,sB,CAED,O,C,sDAIA,2B,CAGD,e,qBAGC,iC,CAEG,IACA,kC,0BAGF,gB,qBAGC,iC,C,C,kBAID,mG,MAEA,kB,CAGD,uEAfuB,W,CAiBxB,c,qDAGC,2B,C,2HAMD,qB,qHAKA,iB,kHAOA,sB,wCAEC,uBACA,O,CAED,kC,oBAEC,iC,MAEA,0B,C,gHAOD,gB,+CAEC,Q,CAED,kCACA,mCACA,wB,+GAMA,gB,+CAEC,Q,CAED,kC,oBAEC,qC,MAEA,8B,C,8I,2BASA,S,CAGD,sE,uMAEC,iB,MAEA,6F,C,yIAKA,6F,C,uMAKA,kBACA,sB,0IAGC,iB,CAED,SACA,kBACA,O,C,kCAKA,I,I,yCAGC,I,WAGC,I,C,CAME,YACJ,2BAEA,QAEI,0C,mG,aAGF,O,kCAEA,iCACA,mB,MAEA,W,CARwB,W,C,OAYzB,gB,CAED,8BACC,gBACA,W,CAED,oB,C,yH,4DAOC,2GACA,mCACA,4BACA,O,CAED,SACA,O,CAGD,sB,qICneA,iC,+DAIA,iC,6DAIA,4B,qE,UAKC,yCACA,O,CAGD,WACA,YACA,+CACC,e,CAED,wGACA,gC,+KAgCA,yGACA,kBACA,iBACA,yHACA,e,kI,0BAYC,O,CAGD,2BACA,gBACA,oCACA,S,0H,4D,gI,8D,oH,I,aAUC,4B,mBAEA,iD,mBAEA,mD,mBAEA,4B,mBAEA,2B,CAED,a,mIAMA,sH,4C,2IAOA,4H,2C,kVASA,qFACA,kGACA,4KACA,SACA,kB,uWAWA,qFACA,kGACA,0BACA,SACA,e,2TAMA,yL,gXASA,qFACA,+FACA,4KACA,SACA,kB,oVAaA,qFACA,+FACA,0BACA,SACA,e,kTA4BA,qFACA,iGACA,0BACA,SACA,e,iUAOA,4GACA,6F,OACC,0G,OAED,e,gIAOA,6B,iE,S,0C,CAQI,4E,U,0C,CAIH,wDACA,OALiE,W,CAOlE,c,0N,iCAKC,kIACA,a,CAED,2HACA,6TACA,2H,saAIA,gBACA,+HACA,0HACA,2HAEA,4H,OACC,oTACA,2HACA,wG,c,OAEA,qUACA,2HACA,gI,qBAEA,kI,O,OAED,2HACA,iB,ma,IAKA,0D,OACC,oB,qBAEA,+F,O,O,iQAOD,uBACA,uBACA,iDACA,uB,iT,IAMA,iR,O,8BAEE,kB,MAEA,6C,C,e,OAGD,6C,e,OAEA,4C,e,OAEA,4C,e,OAEA,6C,e,OAEA,6C,e,OAEA,c,e,OAEA,+E,QACC,e,uBAEA,iG,Q,e,QAGD,oB,uBAEA,iG,Q,O,uc,IAQD,sL,OACC,2B,c,OAEA,yB,c,OAEA,wB,c,OAEA,0B,qBAEA,+F,O,O,8d,IAWD,oI,OACC,sBACA,2HACA,6LAEA,yBACA,6LACA,+HACA,sB,qBAEA,+F,O,O,kd,IAMD,8J,O,0BAEE,c,MAEA,c,C,c,OAGD,c,c,OAEA,mC,c,OAEA,mC,c,OAEA,c,qBAEA,+F,O,O,0gB,IAMD,6K,O,0BAEE,4H,eAEC,kIACA,a,CAED,4HACA,qJ,QAEE,+H,CAED,mC,KAED,4H,MAEA,2HACA,qJ,QAEE,2H,CAED,kE,KAED,2H,C,c,OAGD,e,c,OAEA,mC,c,OAEA,mC,c,OAEA,gC,qBAEA,kN,O,O,khBAKG,I,2BAEJ,wG,OACC,8B,qBAEA,+FACA,a,O,O,IAID,0J,OACC,yD,QACC,2HACA,iUACA,+H,UAEC,gI,MAEA,4D,CAED,2H,uB,UAGC,yB,MAEA,6E,C,Q,e,OAIF,6E,e,OAEA,sJ,uBAEA,iG,Q,O,8eAKE,aAAH,mE,OAII,8F,+DACF,kIACA,a,C,gBAMA,U,CAGD,2BAEA,mBAEA,+HACA,0HACA,oIACA,4HACA,sIACA,iBACA,oGACA,kBACA,2HAEA,yB,O,iuB,eAMA,e,CAGE,0CAAH,mC,OACC,OACA,gEACA,gGACA,e,OAID,uD,OACI,0CAAH,mC,OACC,OACA,kEAEA,4LACA,e,O,qB,IAOD,kG,QAKC,sH,Q,IAEC,OACA,+DACA,8LACA,e,Q,IAGA,OACA,gEACA,+LACA,e,Q,Q,Q,O,uB,m6BAQH,QACA,oCAEA,gE,O,IAEC,yD,OACC,yB,qBAEA,+F,O,OAED,a,O,IAMD,yE,OACC,sMACA,a,QAEA,oNACA,a,Q,OAID,o9B,Q,SAEC,mG,e,Q,SAEA,yG,e,Q,SAEA,uG,e,Q,SAEA,0I,e,Q,SAEA,0G,e,Q,SAEA,4H,e,Q,SAEA,4H,e,Q,SAEA,4H,e,Q,SAEA,4H,e,Q,SAEA,uI,e,Q,SAEA,6H,e,Q,SAEA,6H,e,Q,SAEA,6H,e,Q,SAEA,6H,e,Q,SAEA,4G,e,Q,SAEA,sJ,e,Q,SAEA,qG,e,Q,SAEA,6G,e,Q,UAIA,mG,QACC,4HACA,6I,QACC,a,Q,QAGF,yH,uB,KAGA,8I,QAGC,2N,Q,Q,6nCASF,oG,OACC,mHACA,mI,OACC,a,O,OAGF,gBACA,UAEO,I,2BACP,8kB,OACC,yC,QACC,oJ,uB,IAGA,6C,QACC,kI,uBAEA,iG,Q,Q,Q,e,OAIF,0H,e,QAEA,mK,e,QAEA,mI,e,QAEA,+H,e,QAEA,+H,e,QAEA,mI,e,QAEA,oI,e,QAEA,+M,e,QAEA,yD,QACC,iU,8BAEC,kIACA,a,CAED,4H,uBAEA,iI,QAED,6GACA,8J,Q,0BAGG,+H,MAEA,2H,C,CAGF,6HACA,2HACA,wO,2B,0BAGA,4H,MAEA,2H,C,e,QAGD,yD,QACC,iU,QAED,4HACI,kE,Q,0BAGD,+H,MAEA,2H,C,CAGF,+E,QACI,0H,cACF,4HACA,2H,C,QAGF,oOAd6B,W,uBAgB9B,4H,e,QAEA,4GACA,gE,QACC,yD,QACC,uUACA,kI,uBAEA,kI,Q,uBAGD,6H,Q,e,Q,KAID,yF,QAEC,4BACA,sO,QACK,UACJ,iH,QACC,oH,e,QAEA,4P,uBAKA,0CACA,8DACC,0V,4B,QAGF,0NACA,a,Q,Q,QAGF,yD,QACC,uU,+DAEC,kIACA,a,CAED,4HACI,+D,SAEF,+H,CAED,kPAJwB,a,uBAMzB,4H,uBAEA,2HACI,iE,SAEF,2H,CAED,kPAJwB,a,yBAMzB,2H,Q,e,QAKD,mF,SACQ,qH,6BACP,wF,SACC,2HACA,gIACA,a,S,S,SAKF,wH,e,QAAA,wH,uBAEA,uH,Q,O,s4BAMD,IACA,6C,OACC,wIACA,oC,OAEQ,6L,2B,0DAEN,0B,wGAEC,6CACA,O,C,8EAGD,2B,oJAEC,gBACA,O,C,C,O,OAMH,S,UAEC,IACA,Q,C,OAGF,oB,uP,e,0C,CAgBI,yC,yBAEF,iC,mB,+C,C,mD,CAF2B,W,C,0C,mH,2C,0C,CAmB7B,iBACA,2C,iB,8C,CAIA,mB,2C,qIAKA,+HACA,0HACA,uI,0HAIA,+HACA,0HACA,sI,ghBAIA,WACA,IACA,QACA,kBAEI,qCACH,kBACA,IACA,yDACC,W,C,QAGA,4I,C,SAIA,c,CAID,WAGA,mBAEA,iCACC,kB,IAEA,4J,OACC,0B,e,OAEA,0C,e,OAEA,yB,e,OAEA,0BACA,0B,e,QAEA,0B,uBAIA,8D,Q,YAGE,2CACA,2BAEA,yCACA,0B,CAED,0MACA,WACA,WACA,gB,QAGD,gB,Q,OAhCa,W,qBAqCf,oDAGA,+D,QACC,WACA,gJ,+BAGC,yI,C,gBAMA,qBACA,0BACA,0B,CAED,Q,uBAEA,iE,iCAEC,mB,C,QAKF,sE,QACC,W,MAEC,mB,CAED,oDACA,+D,QACC,WACA,kJ,iBAGC,aACA,iC,C,gCAGA,wI,CAED,Q,uBAEA,mE,gCAEC,aACA,gC,C,Q,Q,OAMF,oD,C,SAIA,uIACA,c,CAGD,qC,WAEC,sD,CAED,WAGA,6I,QACC,2H,e,QAEA,e,e,QAEA,gB,e,QAGA,2CACA,2BAEA,yCACA,0BAGA,mMACA,W,uBADA,mMACA,W,Q,Q,qBAOF,6D,QACC,mBACA,sIACA,yK,SAEE,+H,CAED,mE,QACC,kI,uBAEA,2TACA,2HACA,uG,Q,2BAGF,2H,Q,mpBAKD,QACA,wJACC,sL,gBAGC,2H,CAED,oGACA,I,yB,+dAOD,wJ,QAEE,2H,CAED,oG,yBAED,2H,iS,uF,+T,uCCh9BC,QACA,oB,CAGD,sH,mCAEC,uB,8BAEC,a,C,qCAGD,a,CAED,oB,+Q,gC,gC,C,4C,qSAaA,4G,sC,+B,oB,CAKC,W,CAED,e,4YAeA,iGACA,cACA,uBACA,uB,sOAIA,oD,uHAIA,2D,gfAIA,2DACI,a,sCACC,kD,MACF,W,MAEA,U,C,C,a,8BAKF,K,CAED,2BACA,8FACA,qB,gY,aAoBC,a,CAED,iBACA,6J,WAEE,a,C,YAGA,Y,C,KAGF,a,uBAKA,a,mD,gBA2GC,mBACA,O,C,yBAIA,O,CAED,2BACA,eACA,U,4SAOA,OACC,6F,WAEC,a,CAED,+K,OACC,c,OAED,wC,O,sBAEE,c,CAED,oCACA,a,OAED,0C,QACC,gGACA,c,Q,qB,0dASF,mC,OACC,gG,OAGD,OACC,6F,WAEC,c,CAED,sH,OACC,gGACA,c,OAED,0H,qBAED,gF,sPAOA,2E,UAEE,S,C,SAGF,S,sOAwBA,6FACA,6C,OACC,8F,OAED,wB,62V,4F,4F,4F,4F,4F,4F,4F,4F,4F,wCDrX0B,uL,I,kZ,yCC0PA,+E,I,iD;izBC/W1B,+D,2CAIA,kC,8DAwCA,8B,8G,oBAOC,S,wBAEA,gF,C,8GCd4B,qB,kGAKA,uB,oGAI7B,cACA,a,4GAMA,iEACA,oBACA,Q,0GAOA,c,QAEC,4D,C,yCAGA,U,C,2GAOD,cACA,4BACA,4B,iHAMA,cACA,uBACA,iB,6HAMA,c,UAEC,oCACA,oB,CAED,gB,6BAEC,U,CAED,8CACA,kCACA,oB,2HAMA,cACA,4BACA,2B,8H,gGChGC,S,CAED,kI,mGAO+B,iC,wI,gG,gC,CAM/B,cACA,iDACA,0EACA,Y,8I,yC,0E,C,0F,gC,CAWA,+C,gBAEC,Q,CAED,Y,6HAIA,c,gGAEC,gB,CAED,kCACA,wEACA,oB,yH,kDAKC,kE,CAED,cACA,wEACA,iB,6K,gGAKC,c,0C,CAGD,4DACG,kC,UACF,wE,qD,CAGD,sEACA,0EACA,c,qH,kDAKC,kE,C,iBAGA,+E,CAED,+BACA,cACA,iB,gIAKA,cACI,kB,I,YAGH,I,kBAEA,oD,kBAEA,2E,MAEA,qE,C,yCAGA,wE,CAED,MACA,oB,mZAKA,c,gG,wD,CAIA,kCACA,kH,eAEC,yE,CAED,0EACA,oB,sDAEC,kB,CAED,kB,8SAIkC,0C,gFAIA,uC,4CCvDlC,iB,4CAUA,kB,0D,gBAoDC,2B,sBAEA,2E,cAEE,S,C,SAGF,S,0BAEA,S,MAEA,6B,C,6CAqRD,wD,8tE,4F,4F,4F,4F,4F,4F;mMC9a4B,kB,wDAO5B,qJACC,gKACA,mK,KAGD,0B,sCAkEA,6BACA,OACA,0B,wM,4F,4F,4F,4F;8/BC7FA,qJ,UAEE,S,C,KAGF,S,mD,+BAKC,a,CAED,qJ,8GAEE,a,C,KAGF,Y,6DCkCiC,8B,yG,eAShC,c,CAED,+C,0GAI+B,4B,sGAIH,8B,kGAIA,uB,0G,UAO3B,UACA,O,CAED,a,mBAEC,6D,CAED,sC,gHAOA,2BACA,QACA,a,wHAOG,gB,8BACF,kCACA,e,CAED,gB,gJAOA,U,4BAGC,U,CAGE,sC,MACF,S,C,0BAGA,0BACA,S,CAED,kB,mGAMC,yC,qCAEA,yB,MAGA,uBACA,qCACA,Q,CAGD,QACA,kCACA,S,4G,QAUC,yD,CAED,YACA,2B,yIAOA,aACA,8C,OAEC,oB,C,mE,iJASD,aACA,6C,OAEC,mB,C,oE,8ZAgBD,aACA,OACC,cACA,2BACA,0I,QAEC,U,CAGD,kCACA,kE,+B,0C,C,sC,kC,C,qB,waAcD,4B,+CAEE,yB,C,QAGF,wB,2aAQA,aACG,UAAH,qC,OACC,+H,QAEC,iE,CAED,mBACA,oB,sC,kC,C,e,gD,C,OAWD,U,0C,iUASA,aACA,sC,OAEC,Y,CAED,6GACA,iB,2J,UASC,4B,oC,CAGD,aACA,sC,OAEC,Y,CAED,8CACA,kC,oC,oJASA,a,cAGC,U,kB,oC,C,gC,CAMD,uCACA,mB,QAEC,c,C,oC,8GAUD,aACA,U,QAEC,I,CAED,sCACA,mB,QAEC,c,CAED,S,iH,cAQC,UACA,gB,CAED,qHACA,mBACA,cACA,oB,uK,cAWC,U,0C,CAGD,qH,UAEC,mBACA,a,qD,CAGD,qDACA,mBACA,yB,8C,mH,kBAWC,2F,C,6BAGA,mC,CAED,aACA,iB,uH,mBASC,uF,CAED,a,YAEC,mB,CAED,iB,0JAUA,+BAGA,oB,4B,0JAMA,8BACA,oB,QAEC,gBACA,Q,CAED,2BACA,QACA,c,4B,uJAWA,+B,8C,+FCRA,2D,yOA2JA,+F,gHAEC,sCACA,W,MAEA,W,CAED,8B,4YAgEI,6CACH,iI,WAEC,mD,CAED,WACA,yH,OACC,e,O,qBAGF,e,kNAcI,yCACH,kB,W,oD,C,iBAIA,qNAL2B,W,C,mD,4DAY5B,uL,mH,wCAKC,yBACC,kC,G,CAGC,iC,MACF,yBACC,iD,G,CAGF,iCACC,uE,UAEE,Y,C,SAGF,a,G,4LAmBD,wG,kLA6EA,iEAEK,gB,kGAEH,4H,MAEA,gCACA,6B,C,kGAGA,4H,MAEA,gCACA,6B,C,UAOA,S,C,QAKA,gB,C,U,0CAMC,S,CAED,a,CAKD,kBACA,0CACC,kB,C,UAGA,S,CAED,a,CAID,6B,+EAKA,Y,YAGC,S,kBAEA,sG,0B,WAGC,S,CAED,S,sBAEA,S,sB,iBAIC,oB,CAED,4FACA,4FACA,IACA,wBACA,IACA,8B,8GAIE,wB,QAEC,S,CAED,W,C,oJAGA,S,CAED,WACA,W,mBAGC,4B,SAEC,c,CAED,S,C,CAGF,S,CAED,4FACA,4FACA,IACA,IACA,wBACA,8B,8GAEE,wB,QAEC,M,CAED,W,C,oJAGA,S,CAED,WACA,W,6BAUC,uB,QAEC,S,CAED,c,C,CAGF,S,yDAKA,sBACA,YACI,IACA,kCACH,uIADkB,W,C,mCAIlB,S,CAEG,0CACH,0BACA,mHACA,6IACA,W,0CAEC,c,C,CAGF,S,qCASA,IACI,0CACH,uIADyB,W,CAGtB,uBACA,0C,mBAEF,mB,CAED,mBAJyB,uB,CAM1B,Y,yD,iGCh8BC,S,CAED,mI,qGAO+B,kC,0I,iG,gC,CAO/B,cACA,+CACA,0EACA,Y,gJ,yC,wE,C,2F,gC,CAYA,6C,gBAEC,Q,CAED,Y,mIAKA,c,iGAEC,gB,CAED,qJACA,wEACA,oB,2H,kDAMC,+D,CAED,cACA,wEACA,iB,mL,iGAMC,c,0C,CAGD,4DACG,qJ,UACF,wE,qD,CAGD,6DACA,0EACA,c,uH,kDAMC,+D,C,iBAGA,6E,CAED,+BACA,cACA,iB,kIAKA,cACI,kB,I,YAGH,I,kBAEA,oD,kBAEA,4E,MAEA,mE,C,yCAGA,sE,CAED,MACA,oB,qZAKA,c,iG,wD,CAIA,iCACA,0G,gBAEC,iE,CAED,0EACA,oB,uDAEC,kB,CAED,kB,iTAIkC,4C,kFAGA,wC,ugH,4F,4F,4F,4F,4F,kD;;8gBC5GlC,mGACA,wO,8GAIA,mGACA,yGACA,wH,iHAIA,mGACA,ic,8GAIA,mGACA,yGACA,mHACA,oHACA,oH,6IAIA,mGACA,q1C,8GAKA,mGACA,8GACA,mIACA,oIACA,oIACA,oIACA,oIACA,oIACA,oI,0GAGqC,qB,gGAEE,4B,yGAKvC,mGACA,wO,8GAIA,mGACA,wHACA,yG,iHAIA,mGACA,ic,8GAIA,mGACA,oHACA,oHACA,mHACA,yG,6IAIA,mGACA,q1C,8GAKA,mGACA,oIACA,oIACA,oIACA,oIACA,oIACA,oIACA,mIACA,8G,0GAGkC,kB,gGAEE,yB,k9C,4F,4F,4F,qJ;0pC,uBClGnC,8D,CAEG,yC,mDAEF,oE,CAF4B,W,CAM9B,uCACA,aACA,+BAEI,oCACH,mGADiC,W,CAG9B,yCACH,gIAD6B,W,CAG9B,S,gF,8BAUC,uC,CAGG,mC,2GAEF,qD,CAF+B,W,CAMjC,YACA,S,uHAOA,cACA,S,gN,kBAiCC,O,CAGD,gBACA,0GACA,8BAEC,+XAEA,gOACA,gOACA,+NACA,qNAEA,WACA,W,CAGD,iB,UAEC,O,CAGD,mI,UAEC,+I,CAGD,4OACA,4O,K,aAIC,2O,wBAEC,uI,C,mB,wBAIA,uIACA,uI,C,C,8HAOF,wCACA,cACA,0B,2d,0C,sC,CAkBA,0C,OACK,IACA,oDACH,mMACA,qBAFoC,W,CAIrC,WACA,iB,aAEC,kB,CAED,wCACG,mI,0C,sC,CAGH,S,OAID,0CACC,M,gBAEC,YACA,sE,CAED,4CACG,iO,0C,sC,CAGH,WACA,iB,qBAIG,0CACH,0LADuB,W,CAGxB,iBACA,mBACA,kB,ggBAOA,8E,OACC,4DACA,0JACA,S,OAED,mB,gMASA,oD,8E,mBAOC,+G,CAED,8G,gHAUA,wF,mTAUI,WACJ,gBAEI,kC,kB,Y,8C,2C,wD,CAQF,qBACA,M,CAED,mGACA,WAEA,iG,iBAEC,iFAhByB,W,S,C,uBAqBzB,WArByB,W,S,C,8B,0D,C,K,2B,8D,mBAqCzB,0PACC,W,C,kB,+D,C,6H,8D,CAWD,W,CAID,0PACC,W,C,gBAIA,e,CAED,oBACA,M,CAID,0GACA,gH,K,aAGC,+FACA,OAGA,+F,4B,8D,CAIA,OAGA,+F,6C,8D,C,mBAPA,+F,4B,8D,CAIA,OAGA,+F,6C,8D,C,mBAAA,+F,6C,8D,C,CAKD,iB,iD,oJAOA,uCACA,uDACA,2B,oM,kB,oC,CA0FA,IACA,0EACI,2C,MACF,4DACA,WACA,W,MAEI,IACJ,2DACA,W,sC,4B,C,C,CAOF,mEACI,2C,MACF,4DACA,WACA,W,MAEI,IACJ,2DACA,W,sC,4B,C,C,CAOF,sCACK,IACJ,2DACA,W,sC,4B,C,C,gC,4KAYG,IACJ,mGACG,qM,Y,gC,CAGH,wBACG,qM,Y,gC,CAGH,wBACG,qM,Y,gC,CAGH,wBACG,qM,Y,gC,CAGH,uB,+B,gQAQI,mBACJ,mGACG,8M,gC,+C,CAGH,0EACG,8M,gC,+C,CAGH,0EACG,8M,gC,+C,CAGH,0EACG,8M,gC,+C,CAGH,0EACG,kN,gC,mD,CAGH,6EACG,qN,gC,mD,CAGH,6EACG,qN,gC,mD,CAGH,6EACG,qN,gC,mD,CAGH,6E,mC,4H,mBAuCC,sG,CAGD,qG,krE,4F,4F,4F,uF,uF,+D;;ukMCvaiC,U,gIAIjC,4B,gIAKA,6B,iG,WAUC,a,C,yBAKA,kB,WAEC,a,C,C,2BAUD,kB,mDAGA,kBACA,+EACC,kB,C,MARD,a,C,kFAcA,kBACA,+EACC,kB,C,C,mEAOD,kB,mDAEC,kB,WAEC,a,C,CAGF,+EACC,kB,C,CAKF,c,qNCrGA,sFAEA,qH,sCAEC,uB,CAED,0CAEA,iBACA,UAEA,0B,2KA4BA,IACA,qJ,iC,QAGG,0B,CAED,uBACA,6CACA,yCACA,S,C,4R,QAKC,0B,CAED,wBACA,mJACA,S,C,K,gBAID,wB,C,8NAiBD,sI,kNASA,wC,6QAwBA,yP,iWAcG,0F,sCACF,oBACA,iBACA,e,CAED,gE,ofASA,2DACI,a,sCACC,kD,MACF,a,MAEA,U,C,C,aAIH,2N,iC,mZAMA,oD,wF,2B,mDAMC,mC,kBAEA,gC,gEAEA,4D,8EAEA,6D,iCAEA,qC,iCAEA,iC,CAED,a,uOAIA,yN,wY,iCAgBC,gB,CAED,yH,yVAIG,2B,MACF,+B,CAQA,4BACA,2BAED,YACA,6OACC,YACA,yH,mI,MAGA,+B,CAID,+FACA,YACA,yBACA,kB,4fAWA,iI,OACC,gB,OAED,sI,OACC,0I,OACC,0M,O,OAIF,qI,QACC,gB,QAED,0I,QACC,8I,QACC,0M,Q,Q,4FAKF,kd,QACC,gB,QAEA,gB,QAEA,gB,QAEA,gB,QAEA,gB,QAEA,gB,QAEA,gB,QAEA,oG,QAEA,oG,QAEA,oG,QAEA,oG,QAEA,oG,QAEA,gB,Q,Q,ySAKD,6B,+Q,+DAKC,6BACA,a,CAED,kJ,OAEC,6BACA,a,CAED,+GACA,gE,OAEC,6G,O,sCAGA,gD,C,6aAKD,2B,8BAEC,6BACA,a,CAED,+HACA,+GACA,gE,OAEC,qG,O,sCAGA,gD,C,oZ,+DAMA,6BACA,a,CAED,4IACA,+G,sCAEC,gD,CAED,8B,+YAIA,2B,8BAEC,6BACA,a,CAED,4IACA,+G,sCAEC,gD,CAED,8B,wL,aAKC,uB,C,6BAGA,6B,MAEA,8B,C,aAGA,uB,C,iCAKD,2E,aAEC,uB,CAED,kB,aAEC,uB,C,iCAKD,6E,aAEC,uB,CAED,kB,aAEC,uB,C,kFAOD,4B,6BAEC,wE,CAQD,mCACA,WACA,M,e,wHAIE,M,C,CAGF,mC,YAGC,Y,sWAEC,wNACA,0B,C,C,aAKD,uB,CAED,kB,aAEC,uB,C,wWAUD,gF,OACC,4G,WAIC,M,CAED,uC,OACC,+O,OAED,wBACA,a,OAED,0C,OACC,8N,sCAEC,W,CAED,2C,sBAEA,uN,Q,8W,8BAMA,6BACA,a,CAED,uO,8IAIA,8C,+UAQA,MAEA,4DACC,gHAGA,IACA,0JACC,+D,OACC,2D,OACC,oB,OAED,0G,OAED,8G,yBAGD,sE,QACC,kB,QAED,sBACA,K,iBAEC,oC,MAEA,mC,CAED,kBACA,gI,yB,YAGA,2B,MAEA,wB,C,udAKD,mGACA,+C,6d,8BASC,6BACA,a,CAED,wBAGA,6GACA,8BACA,wJACC,8GACG,qM,sCACF,gD,C,yBAGF,0DAAqC,8N,wFAErC,sK,QAEE,uB,CAED,2BACA,uBACA,uQ,yBAED,wB,gjB,+KAKA,iX,O,c,OAKE,gB,O,OAGF,2LACA,+C,2Y,8BAKC,6BACA,a,CAED,2GACA,uBACA,sCACA,kE,OAGC,mCACA,0BACA,kB,c,OAIA,mBACA,0BACA,kB,qBAIA,gCACA,0FACA,yF,OAED,uB,mY,8BAUC,6BACA,a,CAED,+H,2cAKA,mN,OACC,kLACA,kR,OACC,gB,O,OAGF,qGACA,+C,4aAQA,uBACA,0BACI,qC,QAEF,uB,CAED,kPAJkB,W,qBAMnB,uB,sbAIA,yLACA,+C,yW,8BASC,6BACA,a,CAED,gP,waAIA,yLACA,+C,qUAQA,6D,OACC,iI,qBAEA,8H,O,sOAOD,kBACA,yC,+B,WAKC,a,CAED,uE,oD,wCAOE,a,C,SAGF,Y,yOAIA,oJACC,8H,OACC,0F,OAED,iG,yBAED,e,4ZASA,iE,OACC,gHACA,uB,OAEE,iKAAH,mC,OACC,+GACA,wBACA,e,O,6B,0DAIA,8CACA,uB,8EAEA,gDACA,uB,CAED,+C,oUAKA,uBACA,IACI,yCACA,kB,U,6KAED,WACA,S,C,QAGA,wC,CAED,uB,I,2BAGC,sB,mBAEA,wB,mBAEA,wB,kBAEA,wB,MAOA,4BACA,oDACA,gD,CAED,WACA,IACA,S,CAED,sD,yB,QAGE,wC,CAED,gCACA,WACA,IACA,S,C,2B,QAWC,wC,CAED,+BACA,0CACA,WACA,IACA,S,CAED,W,C,eAGA,sC,CAED,uB,6IAKA,uBACA,IACI,0CACA,mG,U,6KAED,WACA,S,C,QAGA,iC,CAED,uB,I,2BAGC,sB,mBAEA,wB,mBAEA,wB,kBAEA,wB,MAOA,4BACA,oDACA,gD,CAED,WACA,IACA,S,CAED,6C,yB,QAGE,iC,CAED,gCACA,WACA,IACA,S,C,2B,QAWC,iC,CAED,+BACA,0CACA,WACA,IACA,S,CAED,W,C,gBAGA,+B,CAED,uB,sHAwB4B,iB,wHAEK,ob,wIAGjC,0P,sHAEE,a,C,yNAGA,qN,C,KAGF,oO,2+BAQA,aACA,+GAGA,6BACA,6BAGA,6BAGI,YAGA,kCAEJ,yCACC,+BACA,yCAEA,+JACC,qF,OACC,kB,OAED,iGAGI,mIACH,wHACA,oBACA,qE,QACC,SACA,wI,QACC,kG,QAED,+L,QARgC,W,c,Q,e,QAAA,W,c,QAkBjC,sCACA,4C,QAnBiC,W,c,QAsBjC,4B,YAEC,M,CAED,yCACA,uBACA,8HAEA,UACA,+R,QAEC,oG,QAID,SACA,iE,Q,oG,6LAOE,Q,C,Q,QAKF,mN,QACC,c,YAEC,U,CAED,wHAQA,+CACA,8BAGA,aACA,uBACA,sBACA,wBACA,6BACA,iCAEA,sB,yDAMC,uJ,CAhF+B,W,c,QAsFjC,mJACA,uF,QACC,2M,QAxFgC,W,qB,yB,qBA8FpC,mEACC,Q,iOAKC,8N,C,qPAGA,gP,C,+NAGA,iH,CAED,kF,4FASD,uBACI,qEAGH,2HACA,WACI,uDACH,yI,oBAEC,M,CAHwC,a,C,WAOzC,kBAZuC,c,e,CAexC,kE,OAEC,kB,CAjBuC,c,uBAqBzC,QACA,oKAEA,gEACC,gHACA,4M,4BAED,kB,4pB,oaAcC,yH,CAED,uG,yPAOG,2B,MACF,+B,CAED,uMACA,+B,+KCttCA,QACA,QACA,iJ,WAEE,mB,CAED,c,eAEC,O,6BAGA,O,C,K,MAID,U,C,MAGA,U,CAED,U,6CAQA,iJ,kBAEE,a,CAED,4F,U,eAGE,c,iB,2BAGE,a,C,MAGD,a,C,CAGF,iBACA,a,CAID,gC,I,4B,iBAIE,a,C,kC,kBAIA,a,C,MAGD,a,CAED,iB,K,gBAIA,a,CAED,Y,qC,+BASC,a,CAED,qJACC,mG,UAEC,a,C,oC,uCAIC,a,C,MAGD,a,C,KAGF,Y,mC,+BASC,a,CAED,qJ,sIAEE,a,C,KAGF,Y,yTC9HA,UACI,8EACJ,aACA,IACA,wJ,sC,QAGG,0B,CAED,uBACA,6CACA,yCACA,S,C,4R,QAKC,0B,CAED,wBACA,mJACA,S,CAED,mG,S,WAGE,c,C,QAGA,0B,CAED,S,C,yBAGF,gI,OACC,cACA,sB,O,gBAGA,wB,CAED,uB,uOCZsC,a,0GAwEtC,UACA,yCACA,gBACA,e,kQ,0CAOC,gB,C,aAGA,gB,CAED,4F,aAEC,gB,C,uCAGA,yD,CAED,gB,wNAKA,qC,wIAMA,4BACA,yC,UAEC,UACA,c,MAEA,U,C,gGAKD,4C,2B,iBAMC,S,C,WAGA,e,CAED,e,6B,iBAMC,S,C,I,cAIA,UACA,oBACA,S,mBAEA,UACA,oBACA,S,mBAEA,UACA,S,mBAEA,UACA,S,mBAEA,UACA,S,oBAEA,UACA,S,oBAEA,UACA,S,oBAEA,UACA,S,C,iBAGA,UACA,S,CAED,mD,iC,iBAMC,S,C,YAGA,uBACA,6HACA,e,CAED,e,2B,iBAMC,S,C,WAGA,UACA,S,CAED,+D,6CAMA,uB,UAGC,UACA,cACA,e,C,iBAGA,UACA,S,CAED,6H,I,Y,WAIE,6HACA,UACA,S,CAED,qC,kB,WAGC,6HACA,UACA,S,C,YAGA,kBACA,S,CAED,gD,kB,WAGC,UACA,S,C,WAGA,kBACA,S,CAED,wC,CAED,qB,2B,WASC,mC,CAED,U,2B,WAMC,UACA,S,C,WAGA,UACA,S,C,SAGA,sC,CAED,S,6B,I,uGAOC,UACA,S,oBAEA,UACA,S,CAED,0C,2B,8CAMC,UACA,S,CAGD,wD,2B,8CAMC,UACA,S,CAGD,wD,2B,8CAMC,UACA,S,CAGD,wD,2B,8CAMC,UACA,S,CAGD,wD,2B,WAMC,UACA,S,C,iBAGA,UACA,S,CAED,uC,2B,iBAOC,UACA,S,CAED,e,2B,WAMC,UACA,S,C,wBAGA,UACA,S,CAED,e,2B,iBAOC,UACA,S,CAED,2D,2B,iBAOC,S,C,wBAGA,UACA,S,CAED,e,2B,uBAOC,UACA,S,CAED,e,2B,iBAOC,UACA,S,CAED,mD,2B,iBAQC,S,CAED,e,2B,YAMC,UACA,S,CAED,oD,2B,YAMC,UACA,S,CAED,oD,2B,YAMC,UACA,S,CAED,oD,2B,WAMC,UACA,S,CAED,qD,2B,YAMC,UACA,S,CAED,qD,2B,YAMC,UACA,S,CAED,qD,2B,YAMC,UACA,S,CAED,qD,2B,YAMC,UACA,S,CAED,oD,2B,YAMC,UACA,S,CAED,oD,2B,YAMC,UACA,S,CAED,oD,2BAMA,U,wDAKA,UACA,2DACA,U,wF,WAOC,c,C,WAGA,a,CAID,4BACA,8C,yBC1iBG,iB,gBACF,mD,CAED,a,kE,iBAQC,a,CAED,MACA,oCACK,KACJ,iB,SAEC,qD,C,UAGA,Y,CAED,I,CAED,a,+lM,4F,4F,4F,4F,4F,4F,4F,4F,4F,8F,8F,8F,8F,8F,8L,8G,uB,sB,8G,8G,mC,mC,isB;orBCoBA,qD,oMAKA,YACA,+CACA,Q,qKAQI,YACJ,KACA,qCACC,WACA,wFACA,yHACA,WACA,I,CAGD,sGACA,qD,wWAQA,wCACA,qD,O,yBAEE,sC,CAED,qD,OACC,8HACA,SACA,6BACA,gBACA,6BACA,SACA,6B,OAED,qD,OACC,+HACA,SACA,6BACA,SACA,6BACA,S,wBAEC,6BACA,2H,CAED,6B,O,O,yB,yBAKA,IACI,8C,yBAEF,yBACA,M,CAH6B,W,CAM/B,I,CAED,iCACA,6BACA,UACA,oC,C,uvBAWD,yBACI,KACA,IACJ,YACA,+C,yBAGC,cACI,QACJ,mC,OAEC,QACA,I,CAED,Y,CAED,2BACA,oOACA,4B,4DAEC,wB,CAED,2GACA,e,8lBAMA,6L,ubAK0C,0L,2aAIE,4L,+aAI5C,0LACA,U,qbAKA,6LACA,U,ybAKA,4LACA,U,+aAKA,6FACA,6FACA,uB,qbAKA,gGACA,6FACA,uB,ybAKA,+FACA,6FACA,uB,2XAKA,YACA,+CACA,c,sTAKA,YACA,+CACA,S,gTAKA,YACA,+CACA,gB,yTAKA,YACA,+CACA,W,kTAKA,YACA,+CACA,a,qVAyCA,6L,qUAMA,4L,m4D,4F,4F,4F,4F,4F,4F;ykDCpRA,OACC,4FACA,cACA,uF,qFAEC,e,CAED,uC,OACC,+M,OAED,ob,OACC,e,O,qB,oQ,QClBD,iB,CAED,gB,0SAYA,OACC,mGACA,QACA,uF,wFAGC,e,CAGD,uC,OAEC,OACC,wMACA,wL,aAEC,c,C,qB,QAID,8B,CAED,8B,OAED,2b,QACC,e,Q,qB,8RClBE,4BACJ,UACA,S,2CAqBA,+BACA,wC,gPAMG,2CAAH,mC,OACC,4NACA,a,OAGD,gGACA,Y,0YAI8B,0G,0WAGE,uI,maAIhC,uE,OACC,2G,OAED,gW,+ZAI8B,uK,uXAI9B,wGACA,wC,+c,0CAOC,kD,CAED,kJ,OACC,0L,OAED,8JACA,2FACA,mFACC,2F,qBAED,8B,4f,SAOC,kD,CAED,oD,OACC,iH,OAED,wGACA,2FACA,iCACC,2F,qBAED,yE,geAaA,4FACA,gDACA,iBACA,6C,OACC,gFACA,iCACC,4FACA,gDACA,iB,qB,OAGF,gD,0b,SAOC,gD,CAED,+C,OACC,qH,OAED,oK,wYAqBD,OACC,+HACA,uC,OACC,c,OAED,e,iYAQD,OACC,wGACA,uC,OACC,c,OAED,e,0ZAKA,mBAMI,qCACH,gGACA,kMACA,mGAHkB,W,qBAKnB,e,wc,QAQC,mD,CASD,SACA,0CACC,iKACA,yFAFoB,W,qBAIrB,iCACC,kHACA,yFAFY,W,qB,ohBAUV,2CAAH,mC,O,qX,O,sY,keAOA,WACA,WACI,6CACH,uC,OACC,qFACA,I,OAED,qHACA,0BACA,gBAPsB,W,qBASvB,UACA,UACA,kB,0WAmGA,YACA,+FACA,cACA,e,gZAIA,YACA,gGACA,cACA,e,sXAIA,YACA,gGACA,c,sYAKA,YACA,gGACA,UACA,c,sdAKA,YACA,kIACA,cACA,kB,iPC1NA,2FACA,mEACA,sC,QAEC,oB,CAED,S,mEAKA,QACA,WAEA,0C,yCAEC,yE,C,8BAGA,yB,CAGD,6CACI,sCACH,Q,SAEK,kBACJ,qCACA,QACA,yFACA,QACA,wEACA,uIACA,2F,CAVwB,W,C,8GAiB1B,8G,6HAKA,mB,YAEC,qB,CAGD,qB,aAEC,uB,CAGD,qPACA,oGACA,oC,ulG,4F,4F,uxF,+lL,o8J,u5C,ozF,u9E,kioB;ilGC/OA,iB,cAEC,qE,CAED,mN,2HCmBA,UACA,U,aAEC,I,CAED,Y,4CAKA,UACA,U,aAEC,I,CAED,Y,sDAMA,gBACA,aACA,gBACA,aACA,iBACA,oCACA,gBACA,aACA,2BACA,4CACA,iBACA,Y,8CAKA,uBACG,U,QACF,Y,CAED,Y,sBAMA,wC,yF,S,8C,CAUA,OACA,4BAEA,aACA,gBACA,wEACA,0BACA,aACA,gBACA,wFACA,yBAEA,kFACC,YACA,Y,aAEC,M,C,CAIF,oDACA,wFACA,yBAEA,kFACC,YACA,Y,aAEC,M,C,C,uI,wD,UAcD,kDACC,sT,KAED,S,CAGD,4KACC,mGACA,kBACA,mGAEA,0D,KAED,S,wD,UAMC,kDACC,sT,KAED,S,CAGD,4KACC,mGACA,kBACA,mGAEA,iE,KAED,S,sD,UAMC,IACA,kDACC,uN,KAED,S,CAGD,IACA,4KACC,UACA,mGACA,wB,KAED,S,sD,UAKC,IACA,kDACC,uN,KAED,S,CAGD,IACA,4KACC,UACA,mGACA,0B,KAED,S,0DAIG,Y,QACF,WACA,8GACA,2BACI,uCACH,IACA,8GACA,8JAHsB,W,CAKvB,oH,CAED,S,0DAIG,Y,QACF,WACA,4FACA,0BACI,yCACH,IACA,8GACA,8JAHoB,W,CAKrB,uI,CAED,S,gDAIA,IACA,kDACC,uN,KAED,S,mDAKA,kDACC,uNACA,wHACA,Y,KAED,S,6CAIA,IACI,gDACH,uNAD4B,W,CAG7B,S,yC,mC,6C,qC,qC,oB,qC,oB,qC,oB,qC,oB,qC,oB,qC,oB,yC,sB,qC,qB,yC,uB,mD,2BChOC,kH,CAED,U,iU,kBAqBC,6BACA,QACA,a,C,QAOA,uBACA,a,SAEC,I,CAED,oBACA,kB,C,QAKA,4BACA,I,CAID,4FACA,YACA,QAGA,kJACC,W,CAED,4D,QAIC,gCACC,SACA,Y,CAED,iB,C,mSASD,IACI,IACJ,6EACC,sHACA,WACA,mC,C,UAIA,6BACA,O,CAED,yDACC,WACA,oB,CAED,0BAGA,IACA,kCACA,2CACC,sHACA,WACA,2BACA,cACA,oIACA,WACA,mC,CAID,gDACC,2BACA,cACA,oIACA,WACA,kB,CAED,6BAGA,8BACC,2BACA,cACA,+CACA,kB,CAGD,M,oD,uBAKC,U,CAGG,S,aAIH,uBACA,eACA,yB,+BAIA,4CACA,gBACA,0C,MAIA,yBACA,gC,CAGD,0B,sFAKA,8BACC,gBADY,W,CAGb,S,mC,oJASC,oK,CAGD,sH,oD,2BAQC,O,C,YAIA,a,MAEA,e,C,6H,2BAMA,O,CAKD,wJACC,W,C,UAKA,wGACA,6BACA,mBACA,O,C,SAID,uOACA,6B,uH,2BAMC,O,CAED,6BACA,M,gGAMA,iBACA,2JACC,W,CAED,6B,UAEC,Q,C,iDCvLD,a,mP,eAQC,kE,CAED,6I,mUAyEA,Q,UAIC,S,eAGC,gBACA,S,CAED,e,C,iBAKA,a,CAED,SACA,iBACA,0C,OACC,6F,OAED,e,uM,MAKC,S,CAED,S,sDAOA,SACA,QACA,S,+GAMA,qB,0G,oBAQC,S,CAED,oE,6GAKA,c,sGAKA,a,sPAUA,uC,OACC,+F,O,eAGA,e,C,UAGA,e,CAED,e,2XAmBA,uC,OACC,+F,O,eAGA,e,CAED,+C,OACC,yF,eAEC,Q,C,OAGF,e,uZ,oDAMC,gBACA,SACA,a,C,kDAKA,iBACA,SACA,a,CAGD,SACA,iDACA,6F,6cAmBA,uC,OACC,+FACA,+F,OAED,yF,oBAEC,e,CAED,8LACA,e,qQAKA,a,8GAKA,kB,2PAMA,uC,OACC,+F,O,oBAIA,wB,C,aAIA,mB,CAGD,+D,gb,SAOC,iE,C,oBAGA,a,CAED,iB,UAEC,iE,CAGD,6K,OACC,4Y,O,eAGA,oD,C,wnBAaD,uC,OACC,+F,OAGD,Q,oBAGC,a,CAKD,yBACA,kB,cAGC,a,CAiBD,iCACA,wB,qCAIC,mB,CAED,cAGA,yG,QAEC,+CACA,6B,CAID,+BACA,0B,yBAOC,Q,S,YAGC,Q,kB,kBAIA,oJ,kBAEA,a,kBAEA,O,kBAEA,S,MAEA,mC,CAMD,uB,M,6J,sBAQG,SACA,a,CAED,mBAEA,gJ,UAGA,6O,C,C,CAMH,+NAEA,uC,OACC,+F,O,uiB,eAMA,U,CAED,QACA,Q,8BAEC,SACA,e,CAGD,SACA,sBACA,mDACA,uBACA,2C,OACC,6F,OAED,e,0ZAOA,iH,uZAOA,I,yCAEC,+B,CAID,4K,wb,eAQC,U,C,eAGA,0E,CAED,QACA,mB,UAEC,SACA,e,C,iBAGA,SACA,e,CAGD,SACA,2BACA,8GACA,eACA,2C,OACC,6F,OAED,e,oP,wJAQC,4C,CAED,yH,QAEC,4H,sBAEC,8C,C,CAGF,wB,sNAUA,qB,eAEC,gB,CAED,QACA,Y,sBAEC,SACA,e,CAGD,yBACA,WACA,wHACA,e,8cAOA,2C,OACC,8G,OAEG,8GACJ,oGACA,sG,eAEC,+B,CAED,6G,mRAQA,QACA,SACA,QACA,S,uQAUA,uC,OACC,+F,OAED,QACA,0C,OACC,cACA,Y,eAEC,YACA,0B,CAED,6E,OACC,c,c,OAEA,6F,O,OAGF,e,wWAOA,uC,OACC,+F,O,aAGA,cACA,cACA,YACA,cACA,Y,eAEC,0BACA,Y,C,CAGF,e,2LAKA,iB,QAEC,S,C,qIAGA,wC,C,K,aAIA,+G,mBAEA,gB,CAED,mC,uCAKA,iB,QAEC,wB,C,qIAGA,wC,C,K,aAIA,oK,QAEC,mN,CAED,S,mBAEA,uJ,CAED,mC,qNASA,uC,OACC,+F,O,S,Y,UAMC,iC,C,aAKA,kC,C,cAKA,yD,oBAEC,kB,CAED,mB,CAGD,oD,kBAGA,iC,kB,UAIC,iC,CAED,oD,CAGD,mC,kbASA,uC,OACC,+F,O,S,YAMA,Y,aAGC,gC,C,cAOA,0F,UAEC,+B,C,+BAGA,kB,CAED,kB,C,U,oCAKC,I,CAED,0C,CAGD,mD,kBAGA,gC,kB,UAIC,0C,CAED,mD,CAGD,mC,whBASA,uC,OACC,+F,O,SAID,+F,OAcC,aAMA,K,WAGC,kB,6E,UAWM,IACJ,mB,CAED,mB,C,U,UAOC,wC,CAED,sC,C,CAME,qCACJ,iBACA,wFACA,a,wB,UAQE,sC,CAED,oC,CAKG,wB,UAEH,a,C,WAUA,kBACA,oD,MAGA,6BACA,qC,CAGD,2D,O,UAIK,IACJ,mB,CAED,kB,O,UAIC,qC,CAED,oC,O,OAGD,mC,+lBASA,uC,OACC,+F,O,SAID,+F,OAcC,aAMA,K,YAGC,mB,6E,UAWM,IACJ,mB,CAED,mB,C,U,UAOC,yB,CAED,uB,C,CAME,qCACJ,iBACA,wFACA,a,yB,UAQE,2B,CAED,yB,CAKG,qE,UAEH,4B,C,YAUA,mBACA,kD,MAGA,gDACA,4F,CAGD,6I,O,UAIK,IACJ,mB,CAED,kB,O,UAIC,0B,CAED,yB,O,OAGD,mC,ygBAUA,uC,OACC,+F,O,0BAIA,2B,C,S,YAMA,Y,aAGC,4C,CAMD,gCACA,gB,mBAEC,I,C,eAIA,2B,CAED,Y,QAGC,gC,cAIA,gC,MAFA,wB,CAID,kB,kBAGA,4C,kBAGA,+B,CAGD,mC,8bASA,uC,OACC,+F,O,0BAIA,gE,C,SAID,+F,OAEC,kCAEA,cAEA,uE,QACC,iDACA,+B,e,QAOA,4BACA,sCACA,sCACA,0F,uBAPA,4BACA,+B,Q,OAQD,kB,OAGA,4C,OAGA,+B,O,OAGD,mC,maAMA,wFACA,YACA,e,uXAMA,wFACA,aACA,e,+L,SAMC,+E,C,uBAGA,4C,C,uBAGA,4C,C,kU,UAmBA,Q,CAKD,gIACA,gIAEA,uC,0D,MAOE,8EACA,4B,MAEA,iFACA,iC,C,gE,MAOA,8EACA,4B,MAEA,iFACA,iC,CAED,I,MATA,iC,CAaD,uQ,8kB,UAaC,Q,CAGD,gIACA,gIAEA,uC,0D,MAKE,8EACA,uB,MAEA,iFACA,iC,C,gE,MAOA,8EACA,uB,MAEA,iFACA,iC,CAED,I,MATA,iC,C,uBAcA,QACA,SACA,YACA,a,CAID,uQ,sgB,UAQC,Q,CASD,8F,UAEC,0B,MAEA,iC,CAED,+J,ijB,UAQC,Q,CAMD,0GAGA,SACG,0C,QAEF,uCACA,kC,CAQD,8BAGI,SACJ,gIACA,6MAMI,I,gBAEH,I,CAGD,+J,oW,UAQC,Q,C,gBAKA,S,sBAEA,S,CAKD,iBACA,iBACA,mCACK,gB,QAEH,WACA,8G,C,QAGA,WACA,8G,C,QAIA,S,cAEA,S,C,CAIF,S,kTA6BA,uC,OACC,+FACA,+F,O,eAIA,yB,CAGD,4D,OAQC,QAEA,YACA,2C,OAGC,gG,qBAIA,+C,QACC,gG,uBAEA,aACA,gG,Q,O,4CAID,W,CAED,e,O,iDAOA,QACA,SACA,YACA,+F,C,+BAKA,QACA,SACA,mBACA,e,CAGD,8D,QAGC,uG,QAKD,uG,6bAQA,uC,OACC,+FACA,+F,O,eAIA,yB,CAGD,4D,OAEC,QACA,YACA,8C,OAGC,gG,qBAIA,+C,QACC,gG,uBAEA,aACA,gG,Q,O,4CAID,W,CAED,e,O,8CAOA,QACA,SACA,YACA,+F,C,+BAKA,QACA,SACA,oBACA,e,CAGD,8D,QAGC,uG,QAKD,uG,kaAQA,uC,OACC,+FACA,+F,O,eAIA,yB,CAGD,uBAEA,4D,OAEC,8FACA,e,OAGD,Q,2DAKC,SACA,YACA,yF,C,+BAMA,SACA,e,CAKD,SACA,e,6YAQA,uC,OACC,+FACA,+F,O,eAIA,yB,CAGD,uBAEA,4D,OAEC,8FACA,e,OAGD,Q,2DAKC,SACA,YACA,qG,C,+BAMA,SACA,e,CAKD,SACA,e,oZAUA,uC,OACC,+FACA,+F,OAGD,UACA,U,QAGC,e,cAEA,e,C,I,aAOA,uB,kBAEA,uB,CAGD,e,qOAYI,I,S,YAGH,I,kBAEA,S,kBAEA,I,C,UAGA,K,CAED,S,gF,QAKC,S,CAED,S,oPCvqDG,4G,mCACF,qB,CAED,2B,m0BAQA,S,UAEC,K,CAID,SAGA,yG,sCAEC,oB,CAIG,IACJ,wI,sCAEC,oB,CAIG,kBACA,IACJ,iH,sCAEC,oB,C,uBAKA,SACA,QACA,SACA,IACA,oB,CAgBD,qHACA,kB,QAOC,oB,I,aAGC,IAGA,kD,kBAAA,kD,mBAEA,6E,MAEA,gD,C,C,K,cAQD,qDAGA,qD,mBAAA,qD,MAEA,gD,CAKD,kI,OACC,SACA,SACA,iDACA,I,qBAEA,gIACA,oB,OAGD,2D,OAEC,+FACA,oB,OAKD,sJACA,wE,QACC,8Q,uBAEA,0O,QAGD,oB,mvBA4CA,wE,OACC,8N,OAID,mGACA,mEAIA,wPAEA,kEACC,yG,OACC,4F,QAED,4FACA,2B,qBAGD,e,yiB,2CA2CC,kBACA,oB,C,yHAGA,iCACA,oB,CAGD,iBACG,kH,sCACF,oB,CAIE,6BAAH,iH,OACC,sJ,c,OAEA,I,OAGD,oB,8eAiBA,gGACA,8IACA,e,sQ,eC9QC,yB,CAID,IACA,I,eAGC,gH,qBAOC,iB,CAGD,6B,CAED,mBAEA,4FACA,2J,UAEC,c,CAED,4FACA,iE,eAGC,wEACA,+D,CAGD,oB,8T,kBAUC,8CACA,uB,CAGD,oI,OACC,2Q,OAGD,SACA,SAEA,4FACA,iDACA,yDACA,iDACA,2BACA,8D,eAGC,oEACA,wC,CAGD,4C,OACC,SACA,oG,OAGD,uB,uf,e,0E,CAUI,S,0I,4dAUJ,uHACA,mE,OACC,gK,OAED,e,+bC3EA,K,QAEC,W,CAED,8I,qYAMA,2G,ue,UAQC,gB,C,e,WAMC,gB,CAED,mC,C,IAKD,uE,OACC,sG,OAEA,sG,O,OASG,0BACJ,4C,OAEC,oI,OAID,QACA,uC,QACC,OACA,+F,I,4BAIC,yB,oBAEA,sC,kCAEA,oB,C,uB,I,4BAOA,mB,oBAGA,0B,kC,UAGC,I,CAED,c,C,Q,I,4BAOD,uC,oBAEA,qC,kCAGA,I,qDAEC,oB,C,MAOA,I,CAED,gB,e,wBAGE,oB,CAED,wE,C,eAGA,oB,CAED,uD,C,UAKA,kC,CAED,6B,4jB,uBAMC,a,CAcD,uBACA,6BACA,sC,QAGC,sB,cAEA,qB,CAED,WAII,uBACA,SACJ,wGAGI,uBACJ,wGAKA,0GAIA,0JACC,UACA,UAKA,6CAIA,6D,SAMC,gBACA,a,YAEA,oBACA,a,YAEA,kBACA,a,C,K,yPAQF,K,qBAEC,uG,CAED,e,QAIC,gBACA,IACA,4B,QAEC,wCACA,I,CAED,+BACC,gBADgB,W,C,CAMlB,eACI,kB,qBAEH,2D,C,yCAGA,KACA,+B,MAEA,K,CAED,e,0CAIC,gB,CAED,2B,mC,YAOC,2BACA,wCACA,kCACC,gBADgB,W,C,MAIjB,gB,C,QAKA,gBACI,kCACH,8BADqB,W,C,CAKvB,S,mR,eAWC,2B,C,2BAIA,wC,CAKD,SACO,uC,aAEN,yC,mBAEA,yC,CAGD,oHACA,iBACA,+F,0CAEC,gB,CAED,iC,yd,eAUC,2B,C,2BAIA,wC,CAMD,SACA,IACA,8IACC,W,CAED,iBAEA,wBACA,oNACA,iB,aAEC,gB,CAED,qD,qO,QAKC,S,CAED,S,idAeA,6G,OAEC,I,C,IAID,mM,O,c,OAIC,M,c,OAGA,M,OAIC,K,C,c,O,OAAA,K,C,qBAGD,gQACA,a,O,OAEG,SACJ,gH,kBAEC,gC,CAIG,KAEJ,yd,QACC,MACA,iB,e,QAGA,MACA,+H,QACC,M,QAED,iB,e,QAEA,M,e,QAEA,M,Q,QAGG,IACD,2G,iCACF,+B,CAID,uQ,QAEC,8FACA,gGACA,kG,e,QAGA,8FACA,kGACA,gG,uBAGA,gGACA,8FACA,kG,Q,Q,8a,sBCnaA,S,C,UAGA,S,CAED,S,gHAKA,Q,yCAEC,OACA,+B,CAED,qDACA,QACA,S,yHAKA,yBACA,YACA,S,0FAKA,4C,iE,aAMC,uBACA,Y,CAED,S,yGASA,0E,6GASA,yEACA,YACA,S,iHAKA,SACA,YACA,S,yGAKA,SACA,8BACA,S,+GAKA,Q,kBAIC,6B,M,wBAKC,6B,MAEA,KACA,6B,C,CAGF,yBACA,S,mHAKA,Q,qBAIC,6B,M,wBAKC,6B,MAEA,KACA,6B,C,CAGF,yBACA,S,iH,UAUC,uBACA,YACA,S,CAED,6BACA,wCACA,S,gI,0DASC,mC,uFAEA,mC,CAID,Q,yCAEC,mHACA,sE,CAGD,kFACA,QACA,S,0W,sJAOC,4C,CAEG,0FACJ,8FACA,iCACA,6G,+cAOA,0HACA,wCACA,e,6ZAOA,4HACA,6BACA,e,6bAgBA,oIACA,6EACA,kB,8cAOA,QACI,8BACJ,kG,a,MAGE,Y,MAEA,Y,C,CAGF,e,6aAOA,I,2BAEC,kC,CAEG,2BACJ,+F,U,UAGE,W,MAEA,W,C,CAGF,e,kbAmBA,I,2BAEC,kC,CAED,+F,U,UAGE,YACA,W,MAEA,YACA,W,C,CAGF,kB,kQ,kBAgBC,mB,UAEC,K,C,gBAGD,K,MAEA,I,CAED,S,4GAUA,wB,oF,kBAMC,S,CAED,wG,+B,kBAMC,wB,CAED,4I,sBAEC,sN,CAED,S,qDAMA,6C,UAEC,+B,CAED,S,2GAMA,iB,oH,qBAMC,6CACA,0H,CAED,a,iHAKA,+B,mSAmBA,+H,udAMG,oG,sCACF,2B,CAGE,qG,kCACF,2B,CAED,qB,0SAMA,wBACA,YACA,S,oHAKA,0CACA,mC,2GAMA,sB,wUAUA,QACA,uC,O,oCAEE,yC,CAGD,8H,OAED,QAEI,S,kBAEH,Q,CAGD,wGACA,qJ,uBAGC,yBACA,Y,CAGD,e,0c,6BASC,4B,kBAEC,4B,C,kBAGA,4B,CAED,e,CAGD,iH,iYAeI,gCAEJ,gBACA,gBAGA,yHACA,oT,YAIC,kU,yBAEA,mK,MAEA,I,CAQD,QAEA,8BACA,8BAMA,qDACC,+KACA,qBACA,oDACA,oDACA,K,CAED,kB,+DAYA,uBACA,uBACA,SACA,QAEA,WACA,WAEA,uBACA,uBACA,QACA,SAEA,WACA,WAEA,WACA,W,6SAMA,+GAEA,oF,MAIC,SACA,WACA,WACA,S,C,ijCAeG,oDAEJ,kCACA,kCAEA,+B,MAIC,qDACA,2B,CAID,2BACA,2BACA,2BACA,2B,uBAIC,gBACA,gB,CAID,6CAEC,iDAGA,6C,OAIC,8B,MAKC,8B,C,qBAMD,wG,O,qBAIF,iD,OAEC,kD,OAEC,0G,Q,oBAIA,kO,MAEK,4CACJ,sBACA,sBACA,QACA,sCACC,mLACA,wBACA,+CACA,+CACA,O,CAGD,wBACA,wBACA,UACA,SAEA,WACA,WAEA,W,MAEA,sCACC,wF,C,CAGF,2G,C,O,kBAKD,a,CAGD,iD,QAEC,WACA,WACA,kG,QAGD,aAEA,e,45BAQA,Y,+BAEC,aACA,e,CAED,0HACA,e,4d,UAUK,2BACJ,W,CAED,uC,OACK,2BACJ,4F,OAEG,uFACJ,sG,uBAIC,oB,C,aAMA,c,MAEA,Y,CAED,e,ikBAMA,0K,OACC,kM,OAOG,uIACJ,YACA,YACA,I,a,aAIE,K,CAED,e,CAGD,O,qBAEE,e,C,yBAGA,e,CAED,mG,yBAEC,e,CAKD,8B,yBAEC,iH,qBAEC,K,C,CAGF,iB,mPAIC,K,CAED,eACA,e,qB,gdAWD,qCACA,WACA,4FACA,e,ohBAYA,oCACA,oCACA,qHACA,oCACA,0FACA,WACA,0FACA,YACA,WACA,0FACA,WACA,0FACA,e,ouBAOI,8BACJ,eACA,8BACA,iBAGI,8BACJ,+BACA,iIACC,kB,qBAOG,oLACJ,kBACA,iBACA,kGACA,kGACA,qGACA,IACA,OAEK,IACJ,eACA,oDACC,iHACA,Y,sB,UAIA,yB,CAGD,yKAEA,iHACA,iHACA,uHACA,I,qB,8rB,yF,aAWA,oB,kBAEA,yC,kBAEA,c,C,OAED,oD,OACC,mH,OAID,8X,OAEC,uH,OAGA,uH,OAGA,0H,Q,O,oUAMD,yBACA,YACA,S,mH,UAOC,sBACA,aACA,kBACA,WACA,S,CAGD,yBACA,YACA,S,iH,U,oBASE,4H,CAED,S,C,QAGA,0C,C,UAGA,yBACA,+B,CAGD,4B,sH,QASC,0C,C,UAGA,sBACA,kCACA,kBACA,sBACA,S,CAED,sCACA,YACA,S,qI,kB,UAQE,yBACA,yBACA,kCACA,WACA,S,CAID,6BACA,YACA,S,C,UAKA,gB,CAID,yBACA,4BACA,YACA,S,4H,kB,UAQE,yBACA,yBACA,wBACA,YACA,S,CAID,gCACA,YACA,S,C,UAKA,yBACA,sCACA,WACA,S,CAID,yBACA,yBACA,YACA,S,gI,kB,UAQE,yBACA,yBACA,mCACA,WACA,S,CAID,4BACA,YACA,S,C,UAKA,gB,CAID,yBACA,0CACA,WACA,S,yH,kB,UAQE,yBACA,yBACA,qBACA,YACA,S,CAID,6BACA,YACA,S,C,UAKA,gB,CAID,yBACA,uCACA,WACA,S,6G,UAOC,0BACA,YACA,S,CAID,0BACA,WACA,S,2Q,UAOC,sD,CAED,YACA,uGACA,e,2X,eCpmCC,oB,CAED,iI,0Z,eAOC,qC,CAED,wI,kZAIA,uG,oXAKA,4C,OACC,8BACA,iCACC,0FADgB,W,qB,O,+rBAqBd,I,IAEJ,2K,OACC,I,c,OAEA,I,c,OAEA,K,c,OAEA,K,qBAGA,2PACA,a,O,OAGD,8C,QACC,4HACA,a,QAID,KAEA,yQ,QACC,M,e,QAEA,M,e,QAEA,M,Q,QAID,KACA,+H,Q,I,cAGE,M,oBAEA,O,mBAEA,O,C,QAIF,iG,WAGC,qJ,kBAEE,iI,C,K,CAMC,IACA,KACA,KAGJ,0H,O,iBAIE,mB,sIAEA,a,C,CAKF,+CACG,sHAAH,6C,QACQ,YACP,gQ,QAEC,M,e,QAGA,M,uBAGA,K,Q,Q,QAKF,gGACA,8FACA,8FACA,iGACA,kGACA,iG,ouBAgBA,qG,sCAEC,yB,CAID,gI,sCAEC,yB,CAED,yBAEA,4B,keAII,IACD,4G,sC,sC,C,IAIH,sE,OACC,O,c,O,qBAIA,8F,O,OAED,kB,uYAUA,6HACA,4E,OACC,sI,OAED,+B,6ZAIA,qH,4bASA,gGACA,I,I,aAGC,I,oBAEA,I,oBAEA,K,kCAEA,K,mC,MAIA,6C,CAED,8IACA,e,gR,eClOC,yB,CAED,iDACA,sBACA,I,UAEC,c,CAED,mGACA,iC,mS,kBAOC,oCACA,uB,CAED,4FACA,2D,OACC,gM,OAED,2BACA,qCACA,uB,yd,e,0E,C,4I,qdAaG,2HAAH,oC,OACC,kK,OAED,uB,waASA,4G,gZ,iCAOC,uB,CAED,+G,qPCnCA,kDACC,mG,K,qHAKD,YACA,iJACC,W,CAED,wB,kH,mBAKC,wB,C,UAIA,wB,CAKD,iC,uH,UAKC,wB,CAED,YACA,4FACA,S,mIAKG,iB,yFACF,oB,CAGD,YACA,+HACA,yGACA,S,6HAIA,oBACA,gBACA,S,iIAIA,YACA,Y,QAIC,kB,kBAGA,wB,kBAGA,gB,CAID,iBACA,yM,QAEC,oK,CAED,mGAEA,gB,qIAIA,YACA,Y,QAIC,iC,kBAGA,wB,kBAGA,gB,CAID,YACA,yM,QAEC,kK,C,eAGA,iC,CAGD,gB,iIAIA,YACA,Y,wB,QAIE,K,cAEA,I,CAED,S,CAGD,SACA,qOACC,W,C,sMAKA,K,4MAEA,I,CAED,S,kIAIA,Y,qBAEC,oB,CAID,iBACA,kPAEA,gB,gIAMA,gDACA,qJ,eAEE,kR,C,K,+F,+DAoBD,sE,CAED,qBACA,UACI,IACA,kCACH,mGACA,wJACA,gHACA,wJACA,UACA,UACA,8G,aAEC,I,MAEA,I,CAXiB,W,C,eAelB,0N,MAEA,4C,CAED,wB,wIAMG,yM,eACF,iL,C,uCAME,yM,eACF,iL,C,6DAcD,Y,8BAMC,UACA,O,CA4BD,UACA,4CACA,4CAYA,UACA,uBAGA,IACA,gD,+LAEC,KACA,kL,CAID,gD,+LAEC,KACA,kL,CAKD,4BACA,UAIA,4BACA,0CAUA,uBACA,oC,QAEC,uB,MAEA,uB,C,+BAUD,6M,6CAOG,Y,QACC,mO,eACF,S,gBAEC,gK,C,C,C,2B,QAQF,S,CAED,S,+BAQA,IACA,8BACC,uBACA,Y,CAED,6B,wEAIA,YACA,Y,QAIC,kB,2BAEA,wB,kBAEA,iH,C,qBAMA,S,C,SAKA,iBACA,UACA,gB,CAUD,WAIA,mBACA,mBACA,gCACA,UACA,0BACA,kC,oBAgBK,SAGJ,WACA,iBACA,aACA,UAGA,WACI,0CACH,iB,gBAEC,mB,CAED,WACA,aACA,UACA,aACA,eATuB,W,C,CAazB,gB,8HAQA,YACA,8BACA,wXACI,kCACH,mGAEA,2PAEA,+RALkB,W,CAOnB,+TACA,kL,6CASA,Y,8BAGC,kCACA,O,CAGD,UACA,4CAEA,QACA,qBAGA,gD,+LAEC,kL,CAGD,4BACA,QAEA,4BACA,0CAEA,uBACA,oCACA,uB,8DAWA,Y,YAGC,wB,kBAEA,4FACA,YACA,wMACA,gB,C,YAIA,S,C,SAIA,qBACA,UACA,gB,C,SAGA,qBACA,QACA,gB,CAQD,WAEA,mBACA,oCACA,QACA,8BACA,kC,QAGK,SACJ,WACA,iBACA,aACA,UACA,UACA,WACA,mB,CAGD,gB,8H,8BASC,qC,gEAEA,qC,+CAEA,sB,mFAEA,0D,CAED,8EACA,0F,uJAKA,Y,YAGC,wC,kBAEA,WACA,Y,kBAEA,mBACA,Y,CAGD,YACA,8HACA,WACA,Y,6W,kBAKC,wC,C,eAIA,mBACA,WACA,kB,C,kBAII,IACJ,oHACA,eACA,kB,CAGD,iHACA,kB,waAMI,SACD,0F,sCACF,oB,C,eAGA,6B,CAED,kBACA,e,yHAIA,U,+qBAaA,YACA,iBAGA,iHAEA,uFACA,WACA,0HAGA,yBACA,sQ,YAIC,S,CAED,iBAEA,4FACA,WAGA,8GACI,mCAEH,aACG,8G,eACE,KACJ,mJAGA,mHACA,8BAEA,0HACA,0CACC,YACA,MACA,c,UAGC,M,CAED,8B,C,CAKF,uPAEA,sP,gBAEC,8O,UACA,mNACA,Y,CAGD,mGAlCmB,W,CAqCpB,MACA,MAEA,WACA,0HACA,W,sC,4kBAOG,iB,SACF,uI,CAED,S,iI,kBAOC,S,CAEG,IACJ,+HACC,Y,CAGD,uJ,sHAIA,oH,4D,U,YAOE,S,C,aAGA,gB,C,CAIF,Y,UAEC,wB,CAID,qGACA,iBACA,mTACA,gCAEA,gB,mI,U,YAOE,S,C,aAGA,gB,C,CAIF,YACA,qG,SAEC,wB,CAID,YACA,gNAEA,gB,8IAIA,gGACA,wFACA,Y,I,YAGC,YACA,gB,SAGC,S,CAED,+MACA,gB,kB,SAGC,iBACA,uB,MAEA,Y,CAED,gBACA,8MAEA,S,CAED,6C,uIAKA,yF,yBAEC,S,CAGD,gN,kIAMA,yF,yB,kBAGE,S,CAED,S,CAGD,gK,eAEE,S,C,K,6MAID,S,CAED,S,iIAIA,YACA,Y,QAEC,I,CAID,YACI,kCACH,2SADkB,W,CAInB,gB,kIAIA,YACA,Y,QAEC,I,CAID,YACI,kCACH,4SADkB,W,CAGnB,8CAEA,gB,0IAIA,YACA,YACA,I,QAEC,gBACA,I,CAID,YACI,kCACH,2SADkB,W,CAGnB,8CAEA,gB,mIAIA,YACA,YACA,I,QAEC,gBACA,I,CAID,YACI,kCACH,2SADkB,W,CAGnB,8CAEA,gB,0GAKA,yB,uDAMI,SACJ,oB,uI,ka,YAQC,S,CAED,oBAEA,wE,UAEC,K,CAED,wCAEA,O,KAEC,sE,OACC,qDACC,qM,yB,c,OAGD,uDACC,+M,2B,qBAGD,yC,O,O,iBAED,8M,eAEC,c,C,qBAIF,sB,45B,qBAQC,S,C,qHAKA,0B,C,kBAMA,0B,CAKD,sK,OACC,4GACA,e,O,uBAMA,oB,CAED,WAOA,uE,OACC,yI,OACC,qH,OAED,mH,OAGD,sHACA,aACA,4BACI,SAQJ,iBAGI,0BACA,uCACH,WACA,gB,kCAGC,aACA,gB,CAGD,sD,QACC,oHACA,wC,QAGD,+BAdkB,W,uBAiBf,uDACH,sGAEI,0CACH,WACA,oB,kCAGC,aACA,oB,CAGD,sD,QACC,uHACA,wC,QAGD,+BAdmB,a,uBAHQ,a,uBAqB7B,sB,k0CAOI,0BAIA,YACJ,QACA,OACI,sCACH,kKACA,wBACA,mHACA,6BACA,0BACA,mHACA,+BAPqB,W,qBAUtB,eAEI,qDACH,uGACI,wCACH,0E,OAIC,WACA,oBACA,uHACA,oBAEA,WACA,oBACA,uHACA,oBAEA,WACA,oBACA,uHACA,oBAEA,WACA,oBACA,uHACA,oB,QAGD,8GACA,oBACA,uHACA,oBAEA,iCA/BmB,a,qBAFQ,a,qBAqC7B,sB,ioCAMA,YAIA,6C,OACC,iH,O,gBAIA,mBACA,gBACA,I,CAMD,kGACA,kGACI,mCACH,mBACA,6BAFmB,2B,CAIpB,SAGA,sBACA,mDACA,4G,gBAEC,YACA,gBACA,I,CAGD,mBACA,4FAII,YACJ,gCACA,gCACI,mCACH,+QADqB,W,CAKtB,YACA,mBAEA,YAGI,gDACH,mGACI,mC,0CAEF,0BACA,0BACA,0BACA,0B,CAED,sHACA,oBACA,+BATmB,W,CAFQ,W,CAe7B,0BAIA,6C,OAQC,aACA,6C,OACC,yH,O,OAIF,sB,wdAQA,YACA,iJACK,kCACH,WACA,gHACA,6BAHmB,W,C,KAOrB,8IACC,W,CAGD,S,8F,UAMC,6D,CAED,wD,mEAMA,uHAEA,YACI,mCACH,6HACA,WAFoB,W,C,QAKhB,IACA,kCACH,wJACA,WAFwB,Y,CAIzB,sH,CAGD,gB,8W,iBAMC,sB,C,YAGA,S,CAQG,0BACJ,IACA,gCACA,wHACI,WACH,0GACA,aACA,a,gB,cAKE,e,CAED,sB,CAED,gBAZa,W,qB,6SCryCd,gBACI,gIAEH,mBACA,W,CAGD,Y,iCAQA,IACA,8B,mBAEE,mB,CAED,mBACA,uB,CAED,S,0hBAyCA,6DAGA,oC,OACC,8J,OAID,4G,sCAEC,sB,CAID,IACA,uC,OAEC,KACA,wC,OACC,IACO,8G,IACP,mH,Q,OAGE,I,C,I,4BAIA,K,iCAEA,I,C,IAGD,qF,QACC,IACG,8G,sCAEF,sB,C,e,QAGD,I,Q,Q,e,QAID,mBACA,YACA,sB,QAGA,sB,Q,O,O,OASH,mBACA,YACA,sBACA,KACA,KACA,MACA,QACC,+C,QACC,QACA,KAEG,uH,sC,+BAED,YACA,e,CAED,sB,C,QAKE,K,iBAGH,2B,wBAEA,yC,uB,UAGC,yC,MAEA,yC,C,MAGD,M,CAED,yC,QACC,sGACA,e,QAED,WAGA,4BACA,a,WAIC,qBACA,KACA,K,CAIE,uH,sC,+BAED,YACA,e,CAED,sB,C,uB,U,qBAUA,IACA,K,iCAGA,wC,CAED,sB,C,SAMA,4B,CAED,W,UAKC,U,CAGD,sB,2mBAMA,4G,4iB,cAMC,oC,C,kBAKA,0C,CAKD,uC,MAEC,W,CAED,mBAGG,YAAH,wD,OAEC,qCACA,sCACA,4FACA,KAGI,0CAEH,+BACC,WACA,0LACA,6BACA,Y,C,UAMA,mGACA,K,MAGA,qIACA,WACA,0LAGA,oIACA,qB,CAtBsB,W,CA2BxB,qCACC,WACA,0LACA,6B,C,qBAID,sBAIA,qGAGA,kBAGA,4GAKA,IACA,gIACC,W,C,O,MAKD,WACA,oG,CAGD,4B,qtBAqBA,+C,OAEK,SACJ,iBACA,0CAEC,aACA,UACA,mJACC,W,C,8NAGA,W,QAEC,8C,C,CAKF,+MAGA,wHACA,wIACA,mB,qB,OAKF,YACI,I,WAGH,sCAEC,4BACI,uCACH,WAIA,yFACA,sJACA,IAPiC,W,C,C,MAWnC,sCAEC,4BACI,uCACH,WACA,2OACA,0FAHiC,W,C,C,CASpC,8BACC,WACA,oG,C,mlBAuBD,oJ,ge,oBAOC,oB,CAID,IACI,iDACH,WADkE,2B,CAK/D,S,WAEH,gBACA,kC,MAEA,mB,CAID,yJ,OAEK,SACA,qCACH,8I,OACC,uC,OACC,4MACA,8G,qBAEA,mOACA,sO,OAID,qHACA,0JACC,iNACA,yN,CAGD,qN,OAjBiB,W,qB,O,WAuBnB,kB,CAGD,e,kqB,QCjdC,oD,C,+BAGA,mB,CAQD,sG,8BAEC,yI,C,oBAIA,mB,CAMG,gB,K,aAGH,iCACA,iC,mBAEA,wBACA,gFACA,gF,MAEA,mD,C,+hCAKA,mB,CAGD,4S,8yBASA,qBAEA,uBACA,oBAEA,qBACA,+JAEI,uCACJ,aAGI,qCACH,mD,OACC,Y,qBAEA,iGACA,c,OAED,gGACA,iE,OARqB,W,c,OAWjB,uCACH,WACA,8G,iBAboB,W,gB,C,kBAkBnB,mB,CAPuB,Y,uBAUzB,mB,qBAGD,kB,85B,qCA8BC,mB,C,4GAKA,2B,CAUD,IACA,cACA,WACA,sBACA,sBACA,OACC,yC,OAGC,uK,OAED,mHACA,yF,WAEC,c,C,UAQA,qI,CAED,wC,OAIC,2FACA,W,iBAEC,mB,C,OA1BK,Y,qBA2CR,qBACA,8BACA,qBACA,qBA8BA,sBACA,sBACA,sBACA,WACI,mDACH,6D,QAGC,aACA,aACA,aACA,8GAEA,WACA,aACA,8G,uBAIA,aACA,aACA,aACA,8GAEA,WACA,aACA,uH,QAtBgC,W,uBA2BlC,mE,QAQC,cACA,c,iBAEC,wB,CAED,iBACA,KACA,SACA,WACA,4H,mBAEC,kB,C,QAKE,gD,kBAEF,kB,C,qHAKA,mB,CAID,WACA,cACA,uHAboB,a,uBAerB,mB,wvBCxRA,mBACA,uDACA,mF,I,eAGC,oB,kBAEA,c,MAEA,8EACA,c,CAGD,UAGA,mGACC,2BACA,W,CAGD,iBACA,YACA,Y,QAEC,uB,MAEA,wB,CAED,qG,sqBAyBA,a,U,qC,CAIA,a,UAEC,wC,CASD,SACI,0BACJ,WACA,WACG,U,QACF,qB,cAEA,sB,CAMG,SACJ,4GACA,QACA,c,qB,oBAME,O,CAED,6BACA,W,CAED,uD,OACC,2K,O,qBAMA,+BACA,+CACA,iBACA,gCACA,O,CAGD,K,yBAEC,Q,4BAEI,Y,gBAEF,gCACA,W,C,C,CAIH,gCAEA,kC,mBAEC,Q,CAED,kB,2uBAyBA,a,U,qC,CAIA,a,UAEC,wC,CASD,SACI,0BACJ,WACA,WACG,U,QACF,qB,cAEA,sB,CAMG,SACJ,4GACA,QACA,c,0D,wEAME,O,CAED,2BACA,W,CAED,0F,OACC,2K,O,uBAMA,iCACA,oIACA,oCACA,4BACA,Q,CAGD,K,8EAEC,Q,iFAEI,qE,sDAEF,2BACA,W,C,C,CAIH,2BAEA,mC,iBAEC,Q,CAED,kB,0iBAQA,U,kBAEC,Y,CAED,6G,YAEC,K,CAED,kB,gcAQA,U,kBAEC,Y,CAED,6G,YAEC,K,CAED,kB,8aAKA,yBACA,Q,kBAEC,wC,C,2BAGA,kB,CAED,2BACA,uBACA,qG,saAKA,gB,8BAEC,wC,C,yCAGA,+BACA,iB,CAED,yDACA,qG,sPAKA,WACA,+BACA,S,oHAKA,gBACA,+BACA,S,mH,aAMC,aACA,a,CAED,S,yGAKA,SACA,cACA,S,yGAKA,SACA,oCACA,S,iH,wBAMC,wC,CAED,SACA,U,kBAEC,Y,CAED,U,kBAEC,mB,CAED,4BACA,S,uGAUA,kB,wGAKA,mD,wGAQA,W,sGAOA,c,wBAEC,wB,CAED,W,yTAKA,yI,OAEC,cACA,+B,c,O,c,OAKA,+B,qBAEA,UACA,cACA,cACG,sIAAH,oD,OACC,kIACA,kI,wBAGC,+B,C,OAGF,U,O,OAED,e,uO,oBASC,gB,0BAEA,gB,CAED,kB,6BAMI,2B,kBAEH,gB,CAED,yBACA,YACA,S,kDAUA,4C,uSAKA,kBACA,kBACA,aACA,oCACA,qG,6aAKA,kBACA,kBACA,aACA,oCACA,qG,2Z,UAOC,cACA,6BACA,6BACA,e,CAED,iBACA,oCACA,qG,+Z,wBAOC,wC,CAED,kBACA,kBACA,cACA,cACA,yBACA,qG,oNCzfA,4C,qRASA,gH,sCAEC,e,C,iCAGA,6C,CAEE,yH,OACF,+C,CAED,uB,8qB,iBAUC,2B,CAKE,iBAAH,sC,OACI,2H,OACF,2B,CAED,sCACI,YACD,6H,sCACF,2B,CAGE,sB,kCACF,2B,C,wBAGA,2B,CAED,2G,OAID,iBAGA,qG,sCAEC,2B,CAKG,IACJ,oI,sCAEC,2B,CAIG,kBACJ,2G,sCAEC,2B,CAIE,sB,kCACF,2B,C,wBAKA,qB,C,QAMA,qE,CAID,K,4CAEC,kC,CAED,oJAGA,wE,QACC,WACA,gG,uBAEA,gCACA,+B,QAGD,6BAEA,qB,svBAcA,KAEI,IACD,4G,sC,+BAED,Y,CAED,oB,C,IAID,sF,O,c,O,MAIE,IACA,c,CAID,8FACA,oB,OADA,8FACA,oB,O,OAGG,QACD,qG,sCACF,oB,CAGG,S,MAEH,gB,CAMG,YACA,8G,sC,2CAED,oB,CAED,YACA,e,CAED,8C,QACC,yC,QACC,gGACA,4IACA,oB,QAED,e,QAED,eAhBa,W,uBAoBd,sDACA,oB,qaAKA,yH,mYAKI,SACJ,kGACA,gBACA,0D,OACC,kG,qBAEA,gB,OAED,e,6YAMA,2C,OACC,yG,OAED,uG,wiBAOI,SAEJ,2C,OACC,kG,QAEC,gBACI,kCACH,gBADqB,W,C,CAIvB,gC,OAID,sIAEA,KACA,qC,OACC,kJ,OAGD,aACA,yHAGA,a,sBAEC,c,gBAEC,qBACA,oB,C,C,YAKD,gB,CAED,oHAEA,uC,QACC,gBACA,8FACI,+CACH,gBAD+B,W,CAGhC,oB,QAGD,gC,kX,eCtQC,yB,CAED,0EACA,mBACA,kCACA,S,8BAGC,2D,CAED,6EACA,WACA,I,YAEC,c,CAED,mGACA,iC,4S,kBAOC,yEACA,uB,CAED,4FACA,2D,OACC,gM,OAGD,iEACA,6BACA,2CACA,yCACA,uB,geAKA,2C,O,mI,O,mI,qdASG,yHAAH,oC,OACC,kK,OAED,uB,4Q,SC7DC,4D,CAED,+Q,2WCOA,uC,OACC,+F,O,eAIA,c,CAGD,8H,OAEC,oF,O,oBAKA,QACA,cACA,YACA,e,CAMD,SACA,8FACA,S,+D,Y,kBAUC,mB,mBAEA,mB,CAWD,6C,OACC,oG,sBAEA,qG,QAID,mM,+hBAcA,wCACA,yNACC,iBACA,6FACA,mGACA,yBACA,0G,4GAGD,uGACA,+FAGA,yE,OACC,0D,c,OAEA,6BACA,sFAGA,6BACA,sF,qBADA,6BACA,wF,O,OAGD,0F,mlBAaA,gBACA,gBACA,6OACC,iBACA,iBACA,6FACA,mGACA,iGACA,gGACA,yBACA,wG,4HAID,uGACA,aACA,yGACI,sDACH,6BACA,sF,qBAKD,6F,0SAMA,qCAEA,2HACA,S,2hiB,4F,4F,4F,4F,4F,4F,4F,4F,4F,8F,8L,yC,2uB,e,wB,e,gB,M,M,O,K,oD;+qHC5IA,0H,oBAEC,oB,CAED,oB,yIAIA,qCACC,0H,oBAEC,gBACA,Q,MAEA,gBACA,Q,C,C,oJ,UAOD,S,C,UAGA,S,CAGD,IACA,YACC,mB,UAEC,M,CAED,I,CAGD,0H,oBAEC,gB,MAEA,gB,CAED,S,6GAgBI,oBACJ,SACA,yBACA,oCACA,qBACA,sB,8DAIA,2BACA,aACA,U,uJ,O,YASC,gB,kBAEA,e,kB,uBAGC,e,CAEG,iBACJ,uDACC,yD,UAEC,Y,MAEA,yC,C,KAGF,S,kBAEA,8B,kBAEA,mB,kBAEA,mB,kBAEA,kB,kBAEA,kB,kBAEA,kB,mBAEA,kB,mBAEA,mB,mBAEA,mB,mBAEA,yCACA,2HACA,6CACA,mE,mBAEA,oK,mBAEA,oK,mBAEA,qK,mB,sBAGC,e,CAEG,iBACJ,yJ,UAEE,uB,MAEA,oD,C,KAGF,S,mBAEI,iBACJ,qJACC,oD,KAED,S,CAED,yD,kHAKA,wCACA,oDACA,S,wGAIA,sBACA,2BACA,S,mGAIA,sB,6GAIA,sBACA,2BACA,0H,+BAGC,yB,CAED,S,2G,yBAMC,sB,CAKD,4BACA,4B,uH,YAMC,S,C,YAGA,S,CAGD,sBACA,sHACA,UACA,UACA,qCACA,S,yHAIA,sBACA,sH,MAEC,UACA,2B,MAEA,UACA,qC,CAED,qCACA,S,4HAIA,sBACA,sH,MAEC,UACA,2B,MAEA,UACA,qC,CAED,4BACA,S,kHAIA,gD,qHAIA,sBACA,kIACA,2BACA,S,wHAIA,sBACA,sHACA,SACA,c,8NAGC,oB,CAED,gBACA,2B,mPAKC,O,kOAEA,O,qaAEA,Q,CAGD,S,iH,gBC7QC,iBACA,4V,oBAEA,iB,MAEA,kD,C,+HCFD,uE,0GA2BA,U,sIAwCA,S,kBAEC,iBACA,sE,MAEA,6D,CAED,OACA,S,qHAIA,iBACA,S,gJ,oP,8IAUE,c,CAED,OACA,6BACA,8B,qjD,wIAWC,c,CAID,OACA,6BACA,wB,MAGA,oB,CAGD,2BACA,S,qIAaA,kB,QAEC,a,CAGD,wHACA,wH,6EAEC,a,CAID,mC,SAIC,sCACA,uGACA,UACA,Y,CAGD,sCACA,WACA,a,wIAKA,iBACA,U,yBAEC,O,CAED,aACA,sCACA,S,kG,mBAMC,S,CAED,IACA,IACI,uD,QAEF,I,CAFsC,mBAKxC,S,qDAMA,gC,gHAMA,iBACA,gBACA,iB,8IAQA,U,gC,uCAGE,kBACA,oB,C,cAMA,kG,C,CAGF,kB,UAEC,uG,CAED,wH,cAEC,uG,CAGD,iBACA,QACA,QACA,UACA,oCACA,sGACA,wH,uCAGC,oF,CAGD,oB,oH,cAcC,Q,UAEC,Y,C,QAGA,Q,C,QAGA,a,C,QAGA,yF,C,CAGF,qJ,YAEE,a,C,KAGF,Y,wPAKA,oBAGA,kBACA,4JACC,W,CAED,uBACA,+B,kBAIC,oC,CAGD,oM,ycAOA,kBACA,4JACC,W,CAED,uBACA,+BAIA,6C,OACC,yM,O,kBAMA,oC,CAGD,oM,oc,OAMA,yC,OACC,2M,uPAEC,cACA,OACA,a,C,gdAGA,cACA,OACA,a,C,6CAKA,2D,C,O,O,ya,kBAWD,sG,CAED,iBACA,oCACA,iJ,aAEE,gCACA,W,MAEA,uB,C,KAGF,wC,OACC,qG,sBAEC,IACA,sGACA,W,C,OAGF,e,kwB,gBAgBC,e,CAIG,SACA,IACJ,IACA,mBACI,8CAOC,SACA,IACJ,6C,OACC,kI,UAEC,IACA,0PACC,W,C,QAKA,mBAnBuB,W,c,C,C,OA8B1B,uE,O,c,OAIC,8G,qBAGA,iBACA,UACA,6CAEI,kCACH,mOADsB,W,CAGvB,iHAEA,kBACA,wCACA,e,OAID,IACA,IACA,IAtD0B,W,qBAwD3B,IAUA,IACA,mBACI,SACA,gDAMC,SACJ,+C,QACC,oH,8KARyB,W,e,C,QAoB1B,0E,Q,e,QAIC,8G,uBAGA,IACI,kCACH,aACA,2NAFsB,W,CAIvB,mHAEA,kBACA,wCACA,e,QAID,IACA,IAzC0B,W,uBA2C3B,IAGA,IACA,mBACI,kDAOH,wJ,QAP0B,a,e,QAa1B,4E,Q,e,QAGC,8G,uBAIA,KACI,0C,woBAEF,M,CAFyB,a,CAK3B,sZAEI,0CACH,wMACA,6GAF0B,a,CAI3B,wLACA,8G,Q,iBAKA,iH,CAED,UAxC0B,a,uBA0C3B,IAGA,IACA,mBACA,wD,iQAEE,c,CAED,iH,MAED,IAEA,e,me,iCAOC,sG,C,kBAGA,iB,CAED,+B,2J,iCASC,sGACA,6BACA,sG,aAEC,W,gB,yBAIC,OACA,a,kBAEA,IACA,sGACA,W,MAEA,qCACA,8C,C,CAGF,S,C,aAIA,kE,uBAEC,O,C,CAGF,S,yJ,aAOC,c,C,iCAGA,sG,aAEC,c,CAED,S,CAED,S,uJ,iC,MASE,6G,CAED,8D,gB,YAGC,OACA,a,kBAEA,IACA,sGACA,W,CAED,S,C,MAGA,W,CAED,sB,8HAIA,6DACA,UACA,sCACA,uE,qCAGE,mCACA,M,CAED,yB,SAED,S,ksB,yBAWI,Q,sCACF,uB,CAED,+B,CAKA,yCACA,YACA,IACA,IACA,KAED,UACA,gBACA,IACA,uCACC,K,kBASA,uU,O,qEAGK,oC,sCACF,uB,CAED,c,CAED,yBACA,uBACA,kB,e,OAEG,wG,sCACF,uB,CAED,kB,e,OAEG,uG,sCACF,uB,CAED,kB,e,O,gCAGC,Q,MAEA,Q,CAED,kB,e,O,gC,W,4B,MAKC,Q,CAED,kB,e,O,+BAGC,Q,MAEA,Q,CAED,kB,e,QAEG,iH,sCACF,uB,C,e,QAGD,I,kB,aAGC,K,mBAEA,K,mBAEA,K,CAED,kBACG,sC,sCACF,uB,CAED,IACA,I,e,QAEA,KACA,IACA,gD,QAGC,eACA,kBACA,c,C,mCAIA,8F,CAEE,yC,sCACF,uB,CAED,IACA,I,e,Q,6C,mB,cAKE,QACA,kBACA,gB,oBAEA,SACA,kBACA,gB,oBAEA,SACA,kBACA,gB,oBAGA,4E,oBAGI,MACD,oB,SACF,mBACA,K,MAEA,sBACA,0B,CAED,qCACC,qC,uCAEC,wB,CAED,cACA,M,CAED,gB,qBAEA,SACA,kBACA,gB,C,CAIF,kBACA,iBAGA,kG,QACC,4K,uCAEC,wB,C,mBAGA,WACA,KACA,WACA,gB,C,QAKC,sK,mBACF,WACA,KACA,WACA,gB,CAED,YAGG,4C,sCACF,uB,CAED,a,uBAhKG,iC,sCACF,uB,CAED,a,Q,OA+JD,I,qBAGD,kGACA,8I,QAEC,oD,QAED,qGAEA,mB,gBAEC,sD,CAED,kI,8kB,uCAQC,gB,CAED,kBACI,QACD,qC,OACF,gB,C,WAGA,gB,C,8BAGA,I,MAEA,kB,WAEC,gB,C,0BAGA,K,MACS,qC,OACT,gB,cAGA,K,C,C,C,uCAID,gB,CAED,kBACA,OACA,gB,kNAOA,I,+DAmBC,oB,QAEI,Q,sC,6B,C,gE,CAMJ,2BACA,oBACG,Q,sC,6B,C,U,gE,CAQH,yBACA,YACA,eACA,S,yD,CAKG,IACJ,kBACA,UACA,IACA,QAEA,yCACI,6B,sC,6B,C,K,eASF,cACA,O,qBAEA,qBACA,O,qBAEA,cACA,O,oBAEA,eACA,O,oB,QAKC,W,CAED,KAGA,cACA,Q,mC,Q,OAME,W,CAED,c,C,WAIA,U,CAED,U,wC,MAvCA,W,C,C,sH,0G,WAsDD,a,CAED,uE,wBAEE,a,C,SAGF,Y,iF,mDAMC,c,C,kFAIA,c,CAED,IACA,8EACC,kB,CAED,IACA,OAEA,yCACI,yC,iBAGF,KACA,M,CAED,kDANuB,W,CAQxB,c,sFAMA,2E,sC,O,YAUC,uI,kBAEI,+C,4OAEF,Y,CAF4B,W,CAK9B,a,kBAEA,kB,kBAEA,Y,CAED,a,8NAKA,0FAMA,qI,OACC,U,OAGD,uB,6OAOA,kB,O,Y,kB,YAME,O,C,kB,aAKA,+H,MAEA,yB,C,kB,uOAKA,M,CAED,OACA,8IACA,+H,C,C,4dAUD,kB,+XAEC,wHACA,wH,cAGC,gBACA,wH,CAED,OACA,WACA,sCACA,kB,CAGD,sC,OACC,wHACA,wHACA,4C,OACC,sC,OAGC,2M,OAED,gIACA,gIACA,kB,O,OAGF,mB,urBAKA,0FACA,oI,OAEC,oD,OAED,6FAEA,kB,QAEC,qD,CAED,wHACA,wHACA,sC,oBAEC,qD,CAGD,gB,cAGC,U,MAEA,QACA,oCACA,sGACA,U,CAED,uB,+fAMA,kB,W,6F,CAIA,6B,sC,uC,CAMA,yB,I,uF,mDAcE,M,CAKD,UACI,kC,mDAEF,M,CAED,iDACA,kBALkB,W,C,8C,mBADnB,UACI,kC,mDAEF,M,CAED,iDACA,kBALkB,W,C,8C,oB,WAYlB,M,CAEE,6B,sC,uC,C,YAQF,KACA,IACA,Y,WAEE,a,CAEE,iC,sC,6C,C,YAIF,M,CAED,S,SAEC,a,CAED,sB,cAEC,a,CAED,a,C,WAGA,a,C,oD,CAMF,SACG,iC,sC,6C,CAGH,S,eAEC,M,C,uE,mB,4C,oB,6C,oB,6C,oB,6C,oB,4C,oB,6C,wB,oD,C,C,uH,2K,W,sE,C,yB,sD,C,2C,kY,oEAoDD,kB,CAED,4F,eAEC,kB,C,0J,opB,qEAUA,oB,CAGD,gC,QAEC,oB,CAED,WACA,4DACA,4E,e,6F,C,8J,wiBAQA,uD,O,aAEE,kB,MAEA,kB,C,qBAGD,4BACA,kBACA,aACA,sN,aAEC,U,MAEA,U,C,OAGF,e,+O,cAaC,c,CAEE,+D,kBACF,yE,CAEE,4D,kBACF,uE,CAED,sB,ugB,4HAQC,oB,CAID,I,yBAEC,K,CAED,kBACA,6B,sCAEC,oB,CAEG,kB,iBAGH,yCACA,kB,MAGA,qB,QAEI,Q,sCACF,oB,C,6F,CAIF,4DACA,oBACG,Q,sCACF,oB,C,C,sCAMD,KACA,kB,CAGD,sB,e,6F,CAKA,qE,O,QAEE,U,MAEA,U,C,qBAMD,6BACA,YACA,YACA,cACA,6N,QAEC,W,MAEA,W,C,O,0D,2pCASF,kBACA,iBACA,gBACA,sCAEA,I,sCAEC,KACA,kB,0BAKC,6B,C,CAIF,SACA,OACA,kE,iHAIE,+C,qG,CAGD,QAGA,4F,OACC,6H,sC,mC,C,kBAKC,gBACA,c,C,OAKF,gI,uC,wC,CAIA,+C,OACC,oBACA,c,OAIE,sI,mBACF,sBACA,c,CAID,KACI,sBACD,mD,uC,wC,CAGH,M,mEAGC,kBACG,mD,uC,wC,C,UAIF,4C,mF,C,C,0BAKD,c,MAEA,c,C,qBAGF,kBAGA,SACA,8M,QAEC,Q,CAED,SACA,U,8C,w2BASA,sIAEA,W,gBAEC,e,CAID,IACI,0CACH,yN,0H,kHAIE,8G,CALqB,W,S,CAUvB,mGACA,8GACA,WAZuB,W,CAexB,8B,uM,yBAMC,iB,CAED,iB,mDASA,YACI,mC,SAEF,2O,6B,QAGE,8G,C,QAGA,qH,CAED,S,C,CAViB,W,CAepB,sB,mC,qBAgBC,iB,C,mBAIA,iB,C,SAIA,aACA,K,C,aAIA,iBACA,S,CAIG,mCACH,YACA,kBACA,qCACC,YACA,kB,CALoB,W,CAQtB,S,+BAMI,0CACH,qNADuB,W,CAGxB,S,+BAKI,0CACH,qNADuB,W,CAGxB,S,yCAMA,IACI,0CACH,yN,gBAEC,iB,CAED,SALuB,W,C,eAQvB,kB,CAED,S,mEAKA,uKACC,0D,UAEC,YACA,a,CAEG,mCACH,YADqB,W,C,KAIvB,uKACC,0D,UAEC,YACA,a,CAEG,mCACH,YADqB,W,C,KAIvB,S,qEAKA,IACA,uKACC,0D,U,gBAGE,iB,CAED,SACA,a,CAEG,mC,gBAEF,iB,CAED,SAJqB,W,C,KAOvB,uKACC,0D,U,gBAGE,iB,CAED,SACA,a,CAEG,mC,gBAEF,iB,CAED,SAJqB,W,C,K,eAQtB,kB,CAED,S,yCAMA,IACA,IACI,0CACH,yN,gBAEC,mGACA,qHACA,W,CAED,SAPuB,W,CASxB,mB,eAIC,uB,CAED,S,6DAYA,aACA,eACA,eACA,wmB,8GAIA,4G,8HAIA,aACA,eACA,eACA,o0B,0FAIA,oCACC,wC,yBAEC,oC,CAED,kB,CAED,iB,kEAIA,wC,yB,kE,C,4D,uBAQA,iD,uB,iBAKC,e,C,kBAGA,sB,C,iBAGA,sB,CAED,S,mD,kCCn0DC,S,CAED,0G,sGAkDA,2D,uEAYI,mCACJ,QACA,kB,yHAKA,8GACA,iDACC,sH,CAED,S,iHAKA,O,I,qCAGC,I,CAED,S,oIAOA,6B,6C,oC,CAQI,mCACJ,iGACC,kHACA,mB,C,4C,4HAQG,IACJ,kBACA,8GAEA,iB,O,YAGE,+B,kBAEA,W,+B,MAIA,W,CAED,QACA,8G,CAED,S,yHAQA,kC,4JASA,S,Y,YAIC,S,kBAIA,4F,UAEC,S,C,0CAGI,uD,UAEF,S,CAF0C,mB,CAM7C,S,kB,+LAIC,S,CAED,S,0CAKI,0C,uGAEF,S,C,mHAGA,2F,CALyB,W,CAQ3B,S,CAID,IACA,+FACA,8BACC,qGACG,kH,S,8HAED,S,CAED,S,MAEA,I,C,CAGF,S,6I,qB,YASC,yB,kBAEA,yB,kBAEA,c,kBAEA,c,mBAEA,uB,mBAEA,qB,CAED,+C,uIAII,mCACJ,QACA,kB,4FAIA,iJACC,iB,K,uCAKD,uDACC,8GACA,Y,eAEC,0C,C,gBAGA,U,CAED,uBACA,QACA,qB,K,uBAKD,2C,6B,O,YAMC,mD,kBAEA,wD,kBAEA,kD,kBAEA,oD,kBAEA,wB,kBAEA,uB,kBAEA,oC,kB,oBAIC,6B,CAED,iE,0CAEC,qB,CAED,iC,kBAEA,mF,kBAEA,oC,mBAEA,yC,C,sF,2BCvRA,a,C,qBAGA,a,C,O,a,mDAMC,a,C,+B,yCAKA,a,CAED,0J,yHAEE,a,C,K,iC,uCAMD,a,CAED,yJ,yHAEE,a,C,K,6C,kQAMD,a,C,mB,0SAKA,a,C,mB,4PAKA,a,C,CAGF,Y,0KAKA,kB,O,YAIC,sC,kBAEA,sB,kB,+BAGC,sB,CAED,sJACC,c,K,+BAGA,mB,C,kB,uFAIA,sCACA,M,CAED,gB,uBAEC,oC,oQAIA,gBACI,sDACH,uPACA,e,eAEC,gBACA,e,CAL8B,W,C,MAS5B,+CACH,6OACA,e,eAEC,gBACA,e,CAL4B,W,C,CAS/B,gB,kBAEA,yB,kBAEA,wB,kBAEA,wB,kBAEA,wB,kBAEA,qB,mB,iCAGC,yB,MAEA,qB,C,mBAGD,qB,mBAEA,qB,mB,mBAGC,sBACA,sBACA,gB,MAEA,gB,C,wHAGA,8G,CAED,gB,yDAEG,2G,6CACF,qBACA,SACA,mB,MAEA,S,C,Q,cAIA,gB,oBAEA,gB,oBAEA,gB,oBAEA,iBACA,6B,uBAEC,gB,aAEC,6B,C,CAGF,iB,C,gCAGA,gB,C,mBAGD,gK,eAEE,qBACA,SACA,mB,MAEA,S,C,M,mBAIF,sK,SAEE,iB,CAED,S,M,MA1HD,qD,C,C,oDAgIG,mCACJ,QACA,kB,8F,iB,2CAQE,gB,CAED,eACA,O,CAGD,kB,I,YAEC,qB,mBAEA,qB,mBAEA,qB,mBAEA,qB,kBAEA,qB,mBAEA,qB,M,UAGC,qBACA,oC,iBAEC,gB,CAED,iBACA,M,CAED,sBACA,iDACA,mB,C,C,4DAMD,I,cAEC,Q,CAED,qJACI,a,QACF,I,C,KAGF,S,iHAKA,mCACA,cACA,S,8H,cAKC,kH,CAED,qJACC,c,K,yJ,eC9SA,c,C,O,uCAKA,IACA,yJACC,e,oBAGC,6DACA,aACA,cACA,uE,C,aAGA,uB,C,KAGF,S,6CAGA,iHACA,4B,mB,6BAMC,kE,CAID,iH,e,cAME,+B,C,cAKA,+B,CAID,8DACA,oCACI,6CACH,uBADyB,W,CAG1B,6CACA,S,C,6BAOA,S,CAQG,S,YAEH,8DACA,oCACI,sCACH,uBADuB,W,C,C,gBAOxB,0BACI,+CACH,8DACA,iDACA,0BAHgC,W,C,eAMhC,S,CAED,uB,C,kBAGA,S,CAKD,kE,CAGD,S,oG,aAsBC,S,C,oDAIA,S,C,4KAGA,S,CAGD,6DACA,+CACA,S,i0Q,4F,4F,4F,4F,4F,2B,sB,iG,+G,mB,8B,sC,yM,gC,0B,mB,uB,0B,mB,oB,oB,oB,uC,wB,mB,sC,gC,k/B;mlNCpGA,4H,OAEC,sH,CAED,e,uHAIA,iBACA,S,wB,UAOC,S,CAED,6G,sBAMA,2B,uFAOA,Q,yBAGC,4B,MAEA,6B,CAGD,0I,0BAEC,gC,MAEA,mCACA,0DACC,iH,K,C,sBAKD,uB,MAEA,2B,CAED,sDACC,8G,K,2BAIA,4B,MAEA,qC,CAED,2DACC,mH,K,mJAOD,kD,sQAEC,a,C,yFAED,+QACA,Y,0I,0JASC,wC,C,6vBAMD,YAEA,oBACA,8CACC,sBAEA,iHACA,kHACA,kHACA,6BASA,cACD,O,wBAEE,c,CAEF,OAEC,kI,OAKA,gU,OACC,2C,e,OAUA,qC,QAEC,QACA,QACA,c,uBAEA,mBACA,QACA,c,Q,e,O,8HAMD,+E,QAEC,wBACA,QACA,QACA,c,Q,QAGD,4BACA,QACA,c,e,OAGA,2GACA,mD,QACC,c,QAED,WACA,QACA,c,e,QAGA,4GACA,qJ,QACC,c,QAED,YACA,QACA,c,e,QAGA,sHACA,wD,QACC,c,QAED,YACA,QACA,c,e,QAGA,sHACA,2C,QACC,c,QAED,YACA,QACA,c,e,QAGA,qC,QAEC,6HACA,c,uB,0CAIC,4IACA,6H,CAED,QACA,c,Q,e,QAID,uGACA,iE,QACC,c,QAED,QACA,c,e,QAGA,QACA,c,e,Q,sBAMC,kB,C,oBAOA,0G,CAEE,gH,8BACF,6B,C,OAKA,kB,C,cAKA,kB,CAID,c,uBAjIA,gC,Q,O,qBAqIF,sJ,q7BAKA,S,YAEC,oB,C,qCAIA,oB,CAGD,qFACA,6CACA,oBAGA,sD,O,oBAEE,sG,CAED,4J,OACC,KACA,oB,O,qBAUD,KACA,8CACC,qD,QAEC,gG,QAEC,KACA,oB,CAED,W,Q,oBAIA,sG,CAED,+J,QAEC,e,QAED,oGAlB+B,W,qBAoBhC,KACA,oB,OAGF,QACC,6BACA,KACA,e,0XCrTA,cACA,e,uHAIA,eACA,gB,yHAIA,aACA,qBACA,eACA,gB,kH,4BAOC,mB,qDAEA,qB,MAEA,gB,C,kH,sCAMA,yB,C,kBAGA,gC,CAED,gC,wHAIA,sJACC,2B,KAED,qC,mHAMI,SACD,iB,QACF,uHACA,oC,MAEA,2BACA,6D,CAED,SACA,S,0FAWA,wJ,mD,UAKC,Y,CAED,sC,yB,sBAGE,a,CAED,oB,C,yB,SAIC,a,CAED,oB,C,UAGA,Y,CAED,gB,yB,sBAGE,a,CAED,oB,C,yB,SAIC,a,CAED,oB,C,UAGA,Y,C,yCAGA,qB,MAEA,qB,CAED,a,qqBAOA,Y,YAEC,mB,CAED,gBACA,2DACC,mH,KAED,sBACA,kBACA,gBACA,yGACA,6C,OACC,8G,OAEG,gBACJ,uC,OACC,a,qBAEA,iG,OAED,OACC,uD,Q,qCAGE,e,C,cAIA,e,CAED,4O,QAEC,0G,SAEC,e,CAED,YACA,oHACA,yH,Q,Q,e,yBAKA,+G,CAED,kJ,CAED,YACA,0H,UAEC,e,C,wCAKA,e,CAED,WACA,oBACA,+C,QACC,yH,QAED,oB,sBAED,WACA,uB,6gBAKA,iK,oBAEE,2B,C,KAGF,+B,gKASA,eACI,gDACH,+GACA,M,eAFgC,W,S,C,gPAO/B,yBAP+B,W,S,CAUhC,SACA,Q,O,Y,kJAOE,sGACA,6B,C,OAIA,qL,oBAEE,2B,C,KAGF,+B,CAED,e,kBAGA,iB,kBAEA,2G,kBAEA,O,mBAEA,c,MAzBA,gC,C,MA4BA,6B,C,kBAGA,yB,CA7C+B,W,CAgDjC,+B,uNAQD,O,UAEE,e,CAEE,gH,qJACF,e,CAGD,kBACA,sCACA,+GACA,WACA,OACA,wHAEA,gH,OAIA,4O,O,e,OAGC,yBACA,QACA,c,e,OAEA,+D,QACC,QACA,c,Q,e,OAGD,QACA,c,e,OAEA,0D,QACC,6GACA,6GACA,4BACA,6G,uBAEA,QACA,c,Q,e,O,eAIA,a,MAEA,S,C,sGAGA,oB,CAED,MACA,S,sBAnCA,iC,Q,OAqCD,e,oRAWA,4H,OAEC,+F,CAED,e,wHAIA,iBACA,S,4vBAKA,S,YAEC,oB,CAGD,qF,2BAEC,4B,MAEA,qC,CAGD,QACA,2DACC,mH,KAGD,8BAEA,kBACA,gBACA,kHACA,6C,OACC,uH,OAEG,cACJ,uC,OACC,W,qBAEA,qG,OAED,mBACA,2IAEA,8P,QAGC,0I,QACC,e,QAED,yBACA,oHACA,yHACA,uGACA,sB,QAED,QACC,yIACA,wB,gBAIA,gU,QACC,O,yBAEC,+GACA,+G,CAED,e,e,QAEA,2D,QACC,e,Q,e,QAGD,6J,QACC,e,Q,e,Q,e,QAKD,0C,QACC,e,Q,e,QAID,qBACA,e,e,QAEA,e,e,QAEA,e,e,QAEA,yE,QACC,e,QAED,e,e,Q,4CAGC,0I,CAED,e,uBAvCA,gC,Q,Q,UA0CA,e,CAED,UACA,WACA,oBACA,+C,QACC,yH,Q,uBAIH,Q,OAEE,MACA,oB,CAGD,6BACA,MACA,e,20BAKA,qI,4gB,eAUC,8B,CAGD,uD,OACC,qH,OAED,0G,OACC,mH,OAGD,yFACA,8BAEA,UACA,gI,OACC,SACA,oB,OAGD,6BACA,SACA,e,iXCxfA,wH,wD,4D,CAIA,QACA,8GACA,mCACC,QACA,8G,C,4C,4D,CAQG,mCACJ,gGACC,kHACA,sI,C,oLAKA,O,C,+C,+BAUD,yB,SAEC,kH,C,kBAGA,kB,CAED,S,2BAIA,O,I,qCAGC,I,CAED,S,iDAWA,2B,mHAIA,6HACA,gCACA,S,wGAIA,SACA,c,wH,gCAKC,a,CAED,+V,sH,mBAKC,e,C,2H,gCAMA,O,CAED,qHACA,wHACA,sB,qG,6D,+hBAuBA,mBACA,mB,mCAEC,uD,CAGA,sBAED,sBACA,sBACA,UACA,yD,UAEE,YACA,Y,C,uBAIF,QACA,sE,yPAEE,a,CAED,0Q,wBAEA,iBACA,qBACA,Y,kBAGD,4CAEC,qU,OACC,8L,c,OAEA,gM,c,OAEA,gM,qBAEA,gM,O,O,UAGA,oB,C,qBAGF,wB,8YAKA,yK,O,oC,gEAIE,wH,2CAEA,wHACA,yJ,C,K,gHAOF,6DAKA,yKACC,yJ,KAQD,uD,sH,yBAME,yOACA,yOAEA,oI,wCAEC,gBACA,kI,wCAEC,a,C,CAGF,yI,uCAIC,a,CAID,iQACA,iQACA,S,2BAEC,Q,iCAEA,QACA,wB,C,OAGA,kB,C,yBAMA,kB,C,MAtCD,a,C,KA0CF,S,2CAMwC,iB,oHACA,wM,gIACA,4Y,kX,4BAavC,oB,CAIA,2BACA,2BACA,2BACA,sCAKD,q2BACC,OACA,iH,qBAEC,e,CAED,e,YAEA,+Q,OACC,uPAEA,kHACA,kH,SAEC,QACA,c,C,MAIA,oDACA,gB,C,MAGA,sGACA,Y,CAID,4U,0IAGC,QACA,c,C,e,OAGD,sGACA,qNAEA,gQACA,wOACA,6DACC,8H,M,e,OAGD,4GACA,qNACA,gQACA,wOACA,6DACC,8H,M,e,OAGD,iH,e,OAEA,uG,qBAEC,c,CAED,wB,4BAEC,qHACA,4BACA,c,CAED,oBACA,yG,QACC,iHACA,qBACI,2DACH,qBAD2C,qBAG5C,4J,uBAEA,gC,QAED,6GACA,wOACA,6DACC,8H,MAED,Y,e,OAEA,uG,qBAEC,c,CAED,wBACA,cAEA,8E,QACC,iHACA,qBACI,2DACH,qBAD2C,qBAG5C,4J,uBAEA,2O,QAED,6GACA,wOACA,6DACC,8H,MAED,Y,e,OAEA,uG,qBAEC,c,CAED,wBACA,sIACA,4B,e,OAEA,uG,qBAEC,c,CAED,wBACA,sIACA,wOACA,6DACC,8H,M,Q,OAGF,e,ilBAGD,aACA,gCACA,mCACA,2CACC,aACA,cACA,2H,OACC,YACA,c,O,qB,qBAID,0DACC,mO,K,CAGF,kB,kd,gB,wB,C,iS,wB,CAiBA,wKACC,yH,O,yB,0I,wB,C,kB,U,qCAaG,kB,C,wB,C,gB,wB,C,yBAQJ,QAGA,uF,kBAGC,Q,C,mB,wOC/YD,c,6GAYA,eACA,S,wOAcA,4G,uJAiCA,e,2YAIA,4G,sCAEC,uB,CAED,aACA,eAEA,eACA,6B,sCAEC,uB,CAED,W,QAEC,I,CAED,qJ,uBAWC,iDACA,sB,MAEA,6D,C,qBAKA,iDACA,mD,CAGD,iBACA,IACA,wMACC,W,CAED,UAEA,0B,qeAkBA,uN,OAEC,4K,CAED,OACA,W,oCAEC,qCACA,sJACC,gC,K,CAMF,+F,UAEC,sB,C,0BAGA,4DACA,4D,CAED,e,8QAKA,YACA,WACA,iBACA,oG,4QAOA,qGACA,mE,OACC,6I,OAED,e,2J,sBAgBC,gB,CAED,kB,qDAKA,mB,wHASA,qB,0H,mBAsBC,sB,UAEC,mB,CAED,iD,CAED,a,mHAIA,Y,mIAIA,mC,2HAIA,6C,iIAIA,kB,0CAGC,oC,WAEC,yD,C,C,mCAKD,6B,WAEC,mD,C,CAGF,c,sH,oBAUC,6G,UAEC,mB,CAED,wC,CAED,a,mHAIA,Y,mIAIA,wC,2HAIA,iD,uIAIA,kB,2CAGC,6H,WAEC,gD,C,C,oCAKD,oH,WAEC,0C,C,CAGF,c,uT,6BAYC,mB,CAGD,qH,sCAEC,aACA,mB,CAED,mBACA,kB,6PAIA,a,mIAIA,a,2HAIA,S,qHAIA,kB,6I,kD,oSAaA,mH,uZAMA,0H,iZAMA,sH,4bAwCA,I,yBAEC,mC,CAED,8EACC,yC,4FAED,gC,4dAOA,oEACC,4B,oH,+eASD,+PACC,+T,mMAED,gC,8jBAIA,IACA,IACI,SACA,I,kBAEH,Y,MAEA,W,C,oBAGA,gB,CAGG,YACJ,kCACC,yI,kBAEC,c,C,kBAKA,2H,MAEA,4H,CAOD,8N,OACC,wF,OAED,4FAGI,I,kBAEH,sC,MAEA,+C,C,uGAGA,W,6GAIA,W,MAEA,4F,C,qB,kBAMD,iC,MAEA,kC,CAGD,e,2jBAOA,I,4BAEC,mC,CAED,QACA,4E,oCAEE,4B,CAED,qC,8FAED,e,2cAOA,gEACC,4B,mG,8cASD,2PACC,8T,8M,kPAaD,2L,gEACC,kS,K,oD,eA0CA,c,CAED,gCACA,sCACC,gB,CAED,S,8ZAOI,I,eAEH,W,MAEA,Y,CAGG,gEACH,mI,kBAEC,c,CAGD,O,kG,kGAME,Q,CAEG,I,eAGH,iD,MAEA,wC,C,QAGA,W,MAEA,S,C,MAGD,4F,CAED,4FAEA,mC,OACC,8FACA,W,O,qB,iiBAQE,YACJ,0I,eAEC,oB,CAED,8M,yaAQA,wH,e,wB,C,kC,gbAaI,YACJ,8I,eAEC,e,CAED,+M,icAQA,4H,e,wB,C,kC,gdAaA,qH,e,wB,C,kC,mgBAaI,YACJ,sJ,eAEC,oB,CAED,oCACA,kD,+IAEE,qV,C,KAGF,e,+TAqBA,8C,gJAOA,gC,kMAIA,qCACC,iB,QAEC,M,CAED,oCACA,kB,uCAGC,gBACA,kBACA,S,CAED,oC,OAGC,gBACA,kBACA,S,CAED,I,S,sJ,kBAIG,sQ,MAEA,uQ,C,C,MAIF,iK,6J,kBAGG,sQ,MAEA,uQ,CAED,M,C,K,C,CAKJ,oBACA,S,8I,0CAOC,gB,CAED,Q,0BAEC,OACA,kB,MAEA,kB,CAED,IACA,qCACC,sD,+CAEC,M,CAED,W,C,UAIA,gB,CAED,oB,M,4CAIE,gB,CAED,W,CAID,IACI,yC,yDAEF,KACA,M,CAED,kDAL0B,W,C,uCAS1B,K,CAGD,kBACA,OACA,gB,0OASA,qO,wgBASI,YACJ,0J,eAEC,oB,CAED,oCACA,kD,+IAEE,sV,C,KAGF,e,ggBASA,yO,udASA,kO,qd,QAWC,oB,CAEG,YACJ,kE,kBAEE,yB,CAED,uN,0FAED,kB,wa,QASC,iB,CAEG,YACJ,6D,kBAEE,yB,CAED,oC,wFAED,kB,8b,QASC,mB,CAEG,YACJ,sE,kBAEE,yB,CAED,wN,0FAED,kB,gc,QASC,gB,CAEG,YACJ,iE,kBAEE,yB,CAED,oC,wFAED,kB,kd,QASC,oB,CAEG,YACJ,kF,kBAEE,yB,CAED,8GACA,kD,uHAEE,wV,C,KAGF,qB,0FAED,kB,wc,QASC,iB,CAEG,YACJ,6D,kBAEE,yB,CAED,qB,wFAED,kB,8d,QASC,mB,CAEG,YACJ,sF,kBAEE,yB,CAED,8GACA,kD,uHAEE,yV,C,KAGF,qB,0FAED,kB,ge,QAUC,gB,CAEG,YACJ,iE,kBAEE,yB,CAED,qB,wFAED,kB,mhB,UAqBC,oB,C,oCAIA,0B,CAGD,2GACA,6BAEA,IACA,IACA,iJ,6BAEE,M,CAGD,4F,uGAEC,+B,CAED,4F,K,sBAIA,6B,CAGD,e,mjZ,4F,4F,4F,4F,4F,4F,4F,4F,iO,c,wB,4B,uB,mD;opDCnrCA,qC,qDAIA,+B,6OAKA,gFAGA,sJAEA,sB,qXAIA,aAGA,oB,kCAIC,2B,CAGD,sBACA,oBAEA,2G,gVAIA,qJ,yYAIA,0CACA,0CACA,0C,uEAIC,e,CAID,0CACA,sJAGA,kEACA,WACA,wCACA,WAEA,0CACA,WACA,0CACA,WACA,WAEA,sB,4gBAIA,gGACA,0CACA,0CACA,0CAGA,qFAEC,0CACA,8HAGA,wCACA,wCACA,wCAEA,SACA,kEACA,WACA,WAEA,WACA,WACA,WACA,WACA,W,qBAGD,kH,wbAIA,oK,mO,iBAKC,0CACA,WACA,0CACA,aACA,mCACA,WAEA,M,CAED,W,wxBAKA,6FAGA,6FAGA,8CACA,gHAGA,8CACA,gHAGA,2FACA,2FAGA,wCAEA,4BAEA,0FAEA,0FAEA,wFAGA,0CACA,4CACA,WACA,iM,QAEC,oB,CAID,0O,QAEC,oB,CAID,oFAGA,8KAGA,2CACA,cAEA,2CAEA,cACA,aAEA,2CACA,mGAGA,2CACA,iBAGA,2CACA,4CACA,iBAEA,4CACA,4CACA,iBAEA,iBAGA,6CACA,4CAEA,iBACA,0H,kzBAIA,OACA,8FAEA,kEACC,oG,OACC,+F,eAEC,oB,C,OAGF,4F,eAEC,oB,CAED,0B,qBAED,e,ucAIA,OACA,8FAEA,wCACA,wCACC,8C,OACC,+F,eAEC,oB,C,OAGF,4F,eAEC,oB,CAED,W,qBAED,e,mfAIA,+G,OAEC,oB,CAID,8CAGA,4CACA,0GAGA,0CACA,4CACA,4CACA,0FACA,0CAEA,+G,o2BAKA,6FAGA,MAEA,4BAGA,2FAGA,wCAEA,4BAEA,0FAEA,IAEA,wFAGA,0CACA,4CACA,WACA,4L,OAEC,oB,CAID,2N,OAEC,oB,CAID,gFAGA,qKAGA,2CACA,aAEA,2CAEA,cACA,aAEA,2CACA,iGAGA,2CACA,iBAGA,2CACA,4CACA,iBAEA,2CACA,4CACA,iBAEA,iBAGA,4CACA,4CAEA,iBAEA,wH,4vBAMA,6FACA,4BACA,oBAEA,8BACA,2CACA,yCAEA,e,sbAIA,6FACA,6FAEA,uE,qaC1WA,+BACA,IAEA,IACA,kCACA,gBACA,kCACC,oEACA,wGACA,mBACA,YACA,iB,qBAGD,sC,0lBAOA,yBACA,4BACA,wFAEA,iCACA,4CACA,6EACA,oDACA,gRACA,iUAEA,wCAGA,OACC,uBAEA,8JAIC,2PAEA,8GACC,0IACA,oD,C,yBAIF,2JACC,+FACA,kM,QACC,oD,Q,2BAKF,+BACA,iF,qB,kjBCnEG,oCACJ,wI,+EAGC,mC,CAGD,e,+I,8GCPC,kD,CAED,2BACA,kDACC,mN,KAED,6CACA,yB,uC,eAKC,Y,8GAEC,S,CAGD,kCACA,6BACA,S,C,eAOA,wCACA,WACA,Y,kBAGC,qB,CAED,kDACC,qN,K,mHAGA,S,CAGD,kCACA,8FACA,6BACA,S,CAED,kB,iC,iBAKC,S,CAED,mBACA,iB,mHAEK,kCACH,qGADuB,W,C,CAIzB,6BACA,S,oZC5DA,wCACA,wCAGA,4BACA,4BACA,4BACA,4B,iBAKC,wCACA,IACA,IACA,wCACA,IACA,wCACA,IACA,IACA,I,CAID,0CAEC,4BACA,wCACA,+GAGA,IACA,IACA,wCACA,IACA,gFACA,wCACA,IACA,gF,qB,4C,4b,iB,uD,C,iB,uD,C,8N,8eAgCD,uGAGA,4BACA,wCACA,+G,8C,0D,CAWA,WACA,4FACA,wF,+C,yRCvFA,0BAEI,6D,6GAEE,4CACH,sGADyB,W,C,CAF+B,W,CAQ3D,qBACI,mC,6GAEF,e,CAFoB,W,CAMtB,S,mC,+BAMC,a,CAED,qJ,8GAEE,a,C,KAGF,Y,4MAII,qBACA,qCACH,6J,OACC,e,OAFmB,W,qBAMjB,QACJ,8GAEA,yC,OACC,8G,qBAEA,iH,O,oRAKD,4F,sHC3CA,wBACA,sBACA,I,UAGC,+B,CAOD,8BACA,yDAGA,0DAEA,c,wRAIA,KAEA,IACA,OACA,4FACA,oJAEK,4CACH,wG,eAEC,mB,CAH4C,W,qBAO9C,IACA,wFAEA,oB,aAEC,mB,mB,C,yBAKF,e,wWAIA,+G,kjBAIA,8CAEA,wFACA,0IAEA,6GAEA,4D,OACC,4B,OAEA,wM,O,4zBAKD,8CAEA,oBAEA,wFACA,0IACA,2HACA,uHAEA,wG,okBAKI,mBAEJ,mBACA,iCACA,OACC,+CACA,oDACA,oBACA,oBAEA,wGACA,sCAEA,mI,OACC,e,OAED,kE,qB,6YASD,yCACA,wMACA,yI,+tBAMI,uFACJ,SAGA,OAEI,2CAEH,+BACA,0F,eAEC,oB,CAID,+BACI,kGACH,uIAD+B,gE,CAK5B,qEACH,kF,OADwD,W,c,OAMxD,oMACA,wa,kJAEC,oB,CATuD,W,qBAcrD,yDACH,IAEI,2DAEH,iX,eAEC,oB,CAJ0D,W,uBAS5D,wJ,gBAEC,oB,CAED,wG,eAEC,oB,CAlBwD,W,uBAuBtD,2DACH,KAEI,2DAEH,qX,gBAEC,oB,CAJwD,a,uBAQ1D,qH,gBAEC,oB,CAED,wG,eAEC,oB,CAjBwD,a,uBApDnC,W,qBA0ExB,e,usBAMA,+FAGA,+FAEA,yFAEA,mGAEA,e,gkBAIA,sBAEA,oCACA,0BAEI,yCACH,yHAD4B,W,CAI7B,8GAEA,2F,c,4C,CAMA,iDAEA,sFAEA,mG,kC,ukBAOA,+FAGA,+FAEA,yFAEA,6KAEA,6F,eAEC,mB,CAGD,6F,eAEC,mB,CAGD,+FACA,wL,OACC,kB,OAEA,mB,Q,8dAKD,4BAGA,qBAGA,iBAGA,8GACA,mHAEA,sP,oLC5RA,kE,wEAUA,oB,gUAMA,oBAEA,2IAEA,kCACA,iDAEA,oL,2I,+FAIA,mB,+ZAMA,4I,mOAKA,kB,wHAKA,gB,y1E,4F,4F,4F,4F,4F,4F,4F,4F,4F,8F,8F,4rkC,o7gU,S;wXClDA,wB,4FAMA,WACA,0BAGA,iB,kBAEC,mB,C,qB,qCAIC,Y,YAKC,Q,CAED,wC,oC,C,CAMC,kB,qBACC,gD,qBACF,sB,4C,C,C,iF,4U,4F,4F,4F,kH,8E;0dCiIF,Y,wCAIA,gB,uCAIA,iB,gDAIA,iB,yD,I,YAMC,2B,kBAEA,qB,CAED,8B,eAoHA,U,gjB,4F,4F,4F,4F,4F,wC,wB,wB,kB;irB,4F,4F,4F,4F,4F,4F,2E,gD,mE;6oC,iBCjSC,qB,uBAEA,qC,MAEA,qC,C,oDAkBD,2tEAoBA,YACA,YACA,YAEA,6CACC,2BACA,mBAEA,iJACC,mGACA,oCACA,mC,qDAGC,4B,C,KAMF,WACA,4LACA,I,CAKD,4D,4BAQA,UACA,YACA,8BACA,gC,8DAgBA,qGAEA,ghFAgCA,YACA,YACA,YAEA,sCACC,2BACA,mBAEA,iJACC,oGACA,mCACA,kC,qDAGC,iC,C,K,QAKD,S,CAGD,sJACA,sJACA,qJACA,gIACA,WACA,I,CAGG,YACJ,uCACA,iB,kCAcA,cACA,YAEG,S,QACF,e,iBAEC,S,CAED,qBACA,gBACA,I,CAGD,S,qDClJA,sB,+HAKA,0C,8HAMA,wE,sIAKA,8B,iIAKA,uE,8HAMA,iB,4HAKA,4B,0HAMA,gB,yHAMA,4D,iIAIA,wE,gJAIA,6C,6JAIA,kD,sCAEC,S,CAED,YACA,iB,kKAIA,gC,sCAEC,S,CAED,YACA,iB,mJ,+BAOC,4B,CAED,2D,4UAOA,kJ,O,IAEC,oC,O,SAEA,+B,O,SAEA,yD,O,IAEA,4J,O,oS,Y,YAOA,mBACA,iB,mBAEA,oC,mBAEA,kC,MAEA,S,C,yG,uBAOA,mB,CAGD,YACA,YAEA,yBAEG,yB,sCACF,mB,CAGD,qB,uCAIA,uF,yBAIA,6F,0N,oJ,iWAsBA,2FAEA,sHACA,6CAEA,6F,sCAGC,mBACA,kB,CAGD,uBACA,sEACA,kB,mKAqBI,Y,wBAGH,mB,CAGD,wBACA,oB,0EA+DA,mDAEA,iCACA,6BACA,+E,mBAGC,Y,CAGD,qC,iIAKA,uFAEA,iCACA,6BACA,+E,mBAGC,Y,CAGD,qC,2QC9UA,oG,sCAEC,U,CAED,e,qUAII,kBAED,oG,sCACF,kB,CAGD,qDACA,kB,2VAII,YAED,uH,sCACF,kB,CAGD,2FACA,kB,iXASA,6PACA,2PACA,2B,iOC7CA,kC,2BAIA,yC,uFAIA,uuF,qDAuBA,kyB,4RAsDA,0I,iPAsBA,OACA,OACA,6CACA,OAEA,0OAEA,+GACA,S,+DAIA,OACA,OACA,6CACA,OAEA,gRAEA,+GACA,S,8gE,4F,4F,4F,4F,4F,4F,4F,4F,4F,8F,iH,mE,W,uB,Y,gJ,6J,6O,wJ;22BCpHA,6G,sCAEC,sB,CAED,0D,+VAYA,2G,sCAEC,mB,CAED,4C,mYAIA,yG,2ZAIA,4G,sCAEC,e,CAED,uGACA,wC,6ZAIA,uCACA,kH,8YAIA,uCACA,8FACA,0HACA,kBACA,e,8WAIA,6H,sCAEC,yB,CAED,6C,4IAMC,WACA,QAED,yDACA,2EACI,0CACH,gLAD8B,W,CAG/B,S,y0B,4F,4F,4F,4F;sRC7EA,+E,2MAMA,8G,sCAEC,U,CAED,8B,qS,4F,4F,4F,oB,I,mB"} diff --git a/ticket/js/main.go b/ticket/js/main.go index 26df307..b2a6f92 100644 --- a/ticket/js/main.go +++ b/ticket/js/main.go @@ -1,12 +1,22 @@ package main import ( + "os" + "github.com/bonedaddy/vcaptcha/ticket" "github.com/gopherjs/gopherjs/js" ) func main() { js.Global.Set("ticket", map[string]interface{}{ - "New": ticket.NewTicket, + "New": New, }) } + +func New(diff int) *js.Object { + tick, err := ticket.NewTicket(diff) + if err != nil { + os.Exit(1) + } + return js.MakeWrapper(tick) +} From 758787d1447840aa8597c69eea909001ed8faaea Mon Sep 17 00:00:00 2001 From: postables Date: Wed, 2 Sep 2020 23:50:33 -0700 Subject: [PATCH 3/3] examples/wasm: add wip wasm example --- examples/wasm/index.html | 17 +++++++++++++++++ examples/wasm/main.go | 15 +++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 examples/wasm/index.html create mode 100644 examples/wasm/main.go diff --git a/examples/wasm/index.html b/examples/wasm/index.html new file mode 100644 index 0000000..e5c1c37 --- /dev/null +++ b/examples/wasm/index.html @@ -0,0 +1,17 @@ + + + + + + + + + + + + diff --git a/examples/wasm/main.go b/examples/wasm/main.go new file mode 100644 index 0000000..9ce4d33 --- /dev/null +++ b/examples/wasm/main.go @@ -0,0 +1,15 @@ +package main + +import ( + "log" + + "github.com/bonedaddy/vcaptcha/ticket" +) + +func main() { + tick, err := ticket.NewTicket(1) + if err != nil { + log.Fatal(err) + } + tick.Solve() +}